From 9fcbdfcbfd1a46157ca9bdfac8148ef98623e851 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 10:47:15 +0530 Subject: [PATCH 001/978] chore(ci): added debug statement to see why transpilation report generation doesn't work --- scripts/run_tests/run_tests.py | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index d9f2ab503e2a9..fb3d5738e9733 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -227,6 +227,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): __file__[: __file__.rfind(os.sep)], "report.json" ) report_content = {} + print(f"REPORT FILE FOUND : {os.path.exists(report_path)}") if os.path.exists(report_path): report_content = json.load(open(report_path)) From b1336aa21947957d4c939e132d0f3cdd20342aa0 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 11:07:38 +0530 Subject: [PATCH 002/978] debug(ci): added another debug comment to test transpilation for manual tests --- scripts/run_tests/run_tests.py | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index fb3d5738e9733..cfed22f774095 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -168,6 +168,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): ' "$(pwd)"/.hypothesis:/.hypothesis unifyai/ivy:latest python3' f" -m pytest --tb=short {test_path} --backend {backend}" ) + print(f"COMMAND : {command}") # run the test sys.stdout.flush() From fe27b5ce0325803c49f9b4fc21cd87b622e3bccb Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 11:39:27 +0530 Subject: [PATCH 003/978] debug(ci): updated the command to run the container in interactive mode to use the same container for the transpilation tests and for getting the report from the container --- scripts/run_tests/run_tests.py | 35 ++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index cfed22f774095..e1e86f3569f1d 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -140,11 +140,11 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): ) print("Backends:", backends) command = ( - f"docker run --rm --env REDIS_URL={redis_url} --env" - f' REDIS_PASSWD={redis_pass} -v "$(pwd)":/ivy/ivy' - ' unifyai/multiversion:latest /bin/bash -c "python' - f" multiversion_framework_directory.py {' '.join(backends)};cd" - f' ivy;pytest --tb=short {test_path} --backend={backend.strip()}"' + f"docker run --name test-container -d -i -t --env" + f' REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass}' + '-v "$(pwd)":/ivy/ivy unifyai/multiversion:latest /bin/bash -c' + f' "python multiversion_framework_directory.py {" ".join(backends)}' + f';cd ivy;pytest --tb=short {test_path} --backend={backend.strip()}"' ) backend = backend.split("/")[0] + "\n" backend_version = backend_version.strip() @@ -153,20 +153,21 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): # gpu tests elif device == "gpu": command = ( - f"docker run --rm --gpus all --env REDIS_URL={redis_url} --env" - f' REDIS_PASSWD={redis_pass} -v "$(pwd)":/ivy -v' - ' "$(pwd)"/.hypothesis:/.hypothesis' + f"docker run --name test-container -d -i -t --gpus all --env" + f' REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass}' + ' -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis' " unifyai/multicuda:base_and_requirements python3 -m pytest" - f" --tb=short {test_path} --device=gpu:0 -B={backend}" + f" --tb=short {test_path} --device=gpu:0 --backend={backend}" ) # cpu tests else: command = ( - f"docker run --rm --env REDIS_URL={redis_url} --env" - f' REDIS_PASSWD={redis_pass} -v "$(pwd)":/ivy -v' - ' "$(pwd)"/.hypothesis:/.hypothesis unifyai/ivy:latest python3' - f" -m pytest --tb=short {test_path} --backend {backend}" + f"docker run --name test-container -d -i -t --env" + f' REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass} -v' + ' "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis' + ' unifyai/ivy:latest python3 -m pytest --tb=short' + f" {test_path} --backend {backend}" ) print(f"COMMAND : {command}") @@ -221,7 +222,10 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"{line[:-1]} --> transpilation tests") print(f"{'*' * 100}\n") sys.stdout.flush() - os.system(f"{command} --num-examples 5 --with-transpile") + os.system(( + f"{command.replace('docker run', 'docker exec')}"" --num-examples 5 --with-transpile" + )) + os.system(f"docker cp test-container:/ivy/report.json .") # load data from report if generated report_path = os.path.join( @@ -282,6 +286,9 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print( collection.update_one({"_id": id}, {"$set": test_info}, upsert=True) ) + + # delete the container + os.system("docker rm -f test-container") # if any tests fail, the workflow fails if failed: From 598bf2e669e63dbb915e56618e0d255176214789 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 25 Oct 2023 06:11:44 +0000 Subject: [PATCH 004/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scripts/run_tests/run_tests.py | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index e1e86f3569f1d..40af1ba7f7f47 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -140,11 +140,12 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): ) print("Backends:", backends) command = ( - f"docker run --name test-container -d -i -t --env" - f' REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass}' - '-v "$(pwd)":/ivy/ivy unifyai/multiversion:latest /bin/bash -c' - f' "python multiversion_framework_directory.py {" ".join(backends)}' - f';cd ivy;pytest --tb=short {test_path} --backend={backend.strip()}"' + "docker run --name test-container -d -i -t --env" + f" REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass}-v" + ' "$(pwd)":/ivy/ivy unifyai/multiversion:latest /bin/bash -c' + ' "python multiversion_framework_directory.py' + f" {' '.join(backends)};cd ivy;pytest --tb=short" + f' {test_path} --backend={backend.strip()}"' ) backend = backend.split("/")[0] + "\n" backend_version = backend_version.strip() @@ -153,8 +154,8 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): # gpu tests elif device == "gpu": command = ( - f"docker run --name test-container -d -i -t --gpus all --env" - f' REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass}' + "docker run --name test-container -d -i -t --gpus all --env" + f" REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass}" ' -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis' " unifyai/multicuda:base_and_requirements python3 -m pytest" f" --tb=short {test_path} --device=gpu:0 --backend={backend}" @@ -163,10 +164,10 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): # cpu tests else: command = ( - f"docker run --name test-container -d -i -t --env" - f' REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass} -v' + "docker run --name test-container -d -i -t --env" + f" REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass} -v" ' "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis' - ' unifyai/ivy:latest python3 -m pytest --tb=short' + " unifyai/ivy:latest python3 -m pytest --tb=short" f" {test_path} --backend {backend}" ) print(f"COMMAND : {command}") @@ -222,9 +223,10 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"{line[:-1]} --> transpilation tests") print(f"{'*' * 100}\n") sys.stdout.flush() - os.system(( - f"{command.replace('docker run', 'docker exec')}"" --num-examples 5 --with-transpile" - )) + os.system( + f"{command.replace('docker run', 'docker exec')}" + " --num-examples 5 --with-transpile" + ) os.system(f"docker cp test-container:/ivy/report.json .") # load data from report if generated @@ -286,7 +288,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print( collection.update_one({"_id": id}, {"$set": test_info}, upsert=True) ) - + # delete the container os.system("docker rm -f test-container") From d094bbac03094b73fc8232733a3517134b8e1b0f Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 11:53:21 +0530 Subject: [PATCH 005/978] fix(ci): removed the --name flag when running docker exec for the transpilation tests --- scripts/run_tests/run_tests.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 40af1ba7f7f47..980874da20fcd 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -224,7 +224,9 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"{'*' * 100}\n") sys.stdout.flush() os.system( - f"{command.replace('docker run', 'docker exec')}" + f"{command.replace( + 'docker run --name test-container', 'docker exec' + )}" " --num-examples 5 --with-transpile" ) os.system(f"docker cp test-container:/ivy/report.json .") From cc0e7feadba408285a8448ca27abb190a9158efb Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 11:57:29 +0530 Subject: [PATCH 006/978] fix(ci): single line f-string in run_tests.py --- scripts/run_tests/run_tests.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 980874da20fcd..9bdc6839355bf 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -224,9 +224,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"{'*' * 100}\n") sys.stdout.flush() os.system( - f"{command.replace( - 'docker run --name test-container', 'docker exec' - )}" + f"{command.replace('docker run --name test-container', 'docker exec')}" # noqa " --num-examples 5 --with-transpile" ) os.system(f"docker cp test-container:/ivy/report.json .") From 5dd0457518f3f7e3c72fc3f41c0eb0b080c54668 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 25 Oct 2023 06:29:26 +0000 Subject: [PATCH 007/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scripts/run_tests/run_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 9bdc6839355bf..7e41041f93829 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -224,7 +224,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"{'*' * 100}\n") sys.stdout.flush() os.system( - f"{command.replace('docker run --name test-container', 'docker exec')}" # noqa + f"{command.replace('docker run --name test-container', 'docker exec')}" # noqa " --num-examples 5 --with-transpile" ) os.system(f"docker cp test-container:/ivy/report.json .") From 1c1a110e311b6d68ffefd09910ff4db50a16c189 Mon Sep 17 00:00:00 2001 From: Rohit Singh Date: Wed, 25 Oct 2023 12:08:05 +0530 Subject: [PATCH 008/978] feat(numpy): add signbit (#26845) --- ivy/functional/frontends/numpy/__init__.py | 2 + .../floating_point_routines.py | 20 ++++++++ .../test_floating_point_routines.py | 48 +++++++++++++++++++ 3 files changed, 70 insertions(+) diff --git a/ivy/functional/frontends/numpy/__init__.py b/ivy/functional/frontends/numpy/__init__.py index 6f17b4b6998b4..a5edf2ebfe971 100644 --- a/ivy/functional/frontends/numpy/__init__.py +++ b/ivy/functional/frontends/numpy/__init__.py @@ -638,6 +638,7 @@ def promote_types_of_numpy_inputs( from ivy.functional.frontends.numpy.mathematical_functions.floating_point_routines import ( # noqa _nextafter, + _signbit, _spacing, ) @@ -721,6 +722,7 @@ def promote_types_of_numpy_inputs( conj = ufunc("_conj") rint = ufunc("_rint") nextafter = ufunc("_nextafter") +signbit = ufunc("_signbit") conjugate = ufunc("_conj") lcm = ufunc("_lcm") gcd = ufunc("_gcd") diff --git a/ivy/functional/frontends/numpy/mathematical_functions/floating_point_routines.py b/ivy/functional/frontends/numpy/mathematical_functions/floating_point_routines.py index a05be440fb7fe..44411b84554ac 100644 --- a/ivy/functional/frontends/numpy/mathematical_functions/floating_point_routines.py +++ b/ivy/functional/frontends/numpy/mathematical_functions/floating_point_routines.py @@ -35,6 +35,26 @@ def _nextafter( return ivy.nextafter(x1, x2, out=out) +@handle_numpy_out +@handle_numpy_dtype +@to_ivy_arrays_and_back +@handle_numpy_casting +@from_zero_dim_arrays_to_scalar +def _signbit( + x, + /, + out=None, + *, + where=True, + casting="safe", + order="K", + dtype=None, + subok=True, +): + x = ivy.astype(x, ivy.float64) + return ivy.logical_or(ivy.less(x, 0), ivy.atan2(0.0, x) == ivy.pi, out=out) + + @handle_numpy_out @handle_numpy_dtype @to_ivy_arrays_and_back diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_floating_point_routines.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_floating_point_routines.py index 54924a62fb272..0e108cd4754df 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_floating_point_routines.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_floating_point_routines.py @@ -54,6 +54,54 @@ def test_numpy_nextafter( ) +# signbit +@handle_frontend_test( + fn_tree="numpy.signbit", + dtypes_values_casting=np_frontend_helpers.dtypes_values_casting_dtype( + arr_func=[ + lambda: helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + shared_dtype=True, + ) + ], + ), + where=np_frontend_helpers.where(), + number_positional_args=np_frontend_helpers.get_num_positional_args_ufunc( + fn_name="signbit" + ), +) +def test_numpy_signbit( + dtypes_values_casting, + where, + frontend, + test_flags, + backend_fw, + fn_tree, + on_device, +): + input_dtypes, xs, casting, dtype = dtypes_values_casting + where, input_dtypes, test_flags = np_frontend_helpers.handle_where_and_array_bools( + where=where, + input_dtype=input_dtypes, + test_flags=test_flags, + ) + np_frontend_helpers.test_frontend_function( + input_dtypes=input_dtypes, + frontend=frontend, + test_flags=test_flags, + backend_to_test=backend_fw, + fn_tree=fn_tree, + on_device=on_device, + x=xs[0], + out=None, + where=where, + casting="safe", + order="K", + dtype=dtype, + subok=True, + ) + + # spacing @handle_frontend_test( fn_tree="numpy.spacing", From 7acfcc2975714135226f1f0ad84a8322bdff17e2 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 14:50:46 +0530 Subject: [PATCH 009/978] chore: updated the path for docker cp in run_tests.py --- scripts/run_tests/run_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 7e41041f93829..0b693551d46fd 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -227,7 +227,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): f"{command.replace('docker run --name test-container', 'docker exec')}" # noqa " --num-examples 5 --with-transpile" ) - os.system(f"docker cp test-container:/ivy/report.json .") + os.system("docker cp test-container:/ivy/ivy/report.json .") # load data from report if generated report_path = os.path.join( From 1e7ee87fb4cae8d0f3f62f794b6e9740b1dff39f Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 15:03:15 +0530 Subject: [PATCH 010/978] chore(ci): updated the transpilation command to remove -v when using docker exec --- scripts/run_tests/run_tests.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 0b693551d46fd..a91b9372c30a6 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -223,10 +223,12 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"{line[:-1]} --> transpilation tests") print(f"{'*' * 100}\n") sys.stdout.flush() - os.system( - f"{command.replace('docker run --name test-container', 'docker exec')}" # noqa - " --num-examples 5 --with-transpile" + command = ( + "docker exec test-container python3 -m pytest --tb=short" + f" {test_path} --backend {backend} --num-examples 5" + " --with-transpile" ) + os.system(command) os.system("docker cp test-container:/ivy/ivy/report.json .") # load data from report if generated From 9e3159f95d78e21b80be8ccdb3db1cd1006ed710 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 25 Oct 2023 09:46:09 +0000 Subject: [PATCH 011/978] fix(ivy): Handles `device` in the jax backend of asarray, which fixes "TypeError: batched_device_put(): incompatible function arguments." --- ivy/functional/backends/jax/creation.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/jax/creation.py b/ivy/functional/backends/jax/creation.py index ee3804bab9759..2193134e18c23 100644 --- a/ivy/functional/backends/jax/creation.py +++ b/ivy/functional/backends/jax/creation.py @@ -73,6 +73,7 @@ def asarray( out: Optional[JaxArray] = None, ) -> JaxArray: ivy.utils.assertions._check_jax_x64_flag(dtype) + obj = jax.device_put(obj, device=device) if copy is True: return jnp.array(obj, dtype=dtype, copy=True) else: From 654abe61a9b086ff10bd642193ba16f461902794 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 25 Oct 2023 10:11:57 +0000 Subject: [PATCH 012/978] fix(ivy): Fixes "RuntimeError: The function 'native_batch_norm' is not differentiable with respect to argument 'running_mean'/'running_var' --- ivy/functional/backends/torch/experimental/norms.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/torch/experimental/norms.py b/ivy/functional/backends/torch/experimental/norms.py index 32c5a28dc2561..97ec9ae1d02ab 100644 --- a/ivy/functional/backends/torch/experimental/norms.py +++ b/ivy/functional/backends/torch/experimental/norms.py @@ -50,8 +50,8 @@ def batch_norm( xdims = x.ndim if data_format == "NSC": x = torch.permute(x, dims=(0, xdims - 1, *range(1, xdims - 1))) - runningmean = mean.clone() - runningvariance = variance.clone() + runningmean = mean.detach().clone() + runningvariance = variance.detach().clone() xnormalized = torch.nn.functional.batch_norm( x, runningmean, From f96270053bd408c64551c5d360d341cca27a5d3e Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 25 Oct 2023 10:14:08 +0000 Subject: [PATCH 013/978] fix(ivy): Adds a deepcopy method to ivy.Shape to avoid errors in the testing pipeline when we try to deepcopy a shape argument --- ivy/__init__.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ivy/__init__.py b/ivy/__init__.py index 2addeeaaa06dc..6be47bf340ff1 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -259,6 +259,11 @@ def __repr__(self): f"ivy.Shape({shape_repr})" if self._shape is not None else "ivy.Shape(None)" ) + def __deepcopy__(self, memo): + ret = self.__class__.__new__(self.__class__) + ret._shape = self.shape + return ret + def __iter__(self): return iter(self._shape) From 2e8a18103f4df030e6bb8c019206f5c6bc7bcf46 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 16:51:42 +0530 Subject: [PATCH 014/978] fix(ci): fixed some issues with run_tests.py to detach the container and exec for each test rather than spinning a new one each time --- scripts/run_tests/run_tests.py | 56 ++++++++++++++++------------------ 1 file changed, 26 insertions(+), 30 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index a91b9372c30a6..3b2b2b307b11b 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -139,38 +139,39 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): other_backend + "/" + get_latest_package_version(other_backend) ) print("Backends:", backends) - command = ( - "docker run --name test-container -d -i -t --env" - f" REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass}-v" - ' "$(pwd)":/ivy/ivy unifyai/multiversion:latest /bin/bash -c' - ' "python multiversion_framework_directory.py' - f" {' '.join(backends)};cd ivy;pytest --tb=short" - f' {test_path} --backend={backend.strip()}"' + os.system( + "docker run --name test-container -v \"$(pwd)\":/ivy/ivy " + f"-e REDIS_URL={redis_url} -e REDIS_PASSWD={redis_pass} " + f"-itd unifyai/multiversion:latest /bin/bash -c" + f"python multiversion_framework_directory.py {' '.join(backends)};" + ) + os.system( + "docker exec test-container cd ivy; python3 -m pytest --tb=short " + f"{test_path} --backend={backend.strip()}" ) backend = backend.split("/")[0] + "\n" backend_version = backend_version.strip() print("Running", command) - # gpu tests - elif device == "gpu": - command = ( - "docker run --name test-container -d -i -t --gpus all --env" - f" REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass}" - ' -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis' - " unifyai/multicuda:base_and_requirements python3 -m pytest" - f" --tb=short {test_path} --device=gpu:0 --backend={backend}" - ) - - # cpu tests else: + device = "" + image = "unifyai/ivy:latest" + + # gpu tests + if device == "gpu": + image = "unifyai/multicuda:base_and_requirements" + device = " --device=gpu:0" + + os.system( + "docker run --name test-container -v \"$(pwd)\":/ivy -v " + f"\"$(pwd)\"/.hypothesis:/.hypothesis -e REDIS_URL={redis_url} " + f"-e REDIS_PASSWD={redis_pass} -itd {image}" + ) command = ( - "docker run --name test-container -d -i -t --env" - f" REDIS_URL={redis_url} --env REDIS_PASSWD={redis_pass} -v" - ' "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis' - " unifyai/ivy:latest python3 -m pytest --tb=short" - f" {test_path} --backend {backend}" + f"docker exec test-container python3 -m pytest --tb=short {test_path} " + f"{device} --backend {backend}" ) - print(f"COMMAND : {command}") + os.system(command) # run the test sys.stdout.flush() @@ -223,12 +224,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"{line[:-1]} --> transpilation tests") print(f"{'*' * 100}\n") sys.stdout.flush() - command = ( - "docker exec test-container python3 -m pytest --tb=short" - f" {test_path} --backend {backend} --num-examples 5" - " --with-transpile" - ) - os.system(command) + command = f"{command} --num-examples 5 --with-transpile" os.system("docker cp test-container:/ivy/ivy/report.json .") # load data from report if generated From 5faf333c372c5ac2454faf76cb0dbabcceca744f Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 25 Oct 2023 11:24:03 +0000 Subject: [PATCH 015/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scripts/run_tests/run_tests.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 3b2b2b307b11b..49b3272981354 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -140,10 +140,10 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): ) print("Backends:", backends) os.system( - "docker run --name test-container -v \"$(pwd)\":/ivy/ivy " + 'docker run --name test-container -v "$(pwd)":/ivy/ivy ' f"-e REDIS_URL={redis_url} -e REDIS_PASSWD={redis_pass} " - f"-itd unifyai/multiversion:latest /bin/bash -c" - f"python multiversion_framework_directory.py {' '.join(backends)};" + "-itd unifyai/multiversion:latest /bin/bash -c" + f'python multiversion_framework_directory.py {" ".join(backends)};' ) os.system( "docker exec test-container cd ivy; python3 -m pytest --tb=short " @@ -163,13 +163,13 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): device = " --device=gpu:0" os.system( - "docker run --name test-container -v \"$(pwd)\":/ivy -v " - f"\"$(pwd)\"/.hypothesis:/.hypothesis -e REDIS_URL={redis_url} " + 'docker run --name test-container -v "$(pwd)":/ivy -v ' + f'"$(pwd)"/.hypothesis:/.hypothesis -e REDIS_URL={redis_url} ' f"-e REDIS_PASSWD={redis_pass} -itd {image}" ) command = ( - f"docker exec test-container python3 -m pytest --tb=short {test_path} " - f"{device} --backend {backend}" + "docker exec test-container python3 -m pytest --tb=short" + f" {test_path} {device} --backend {backend}" ) os.system(command) From 474ef7d5a988ffa8d48722a385a0f39d8f4aedec Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 25 Oct 2023 11:24:36 +0000 Subject: [PATCH 016/978] fix(torch-frontend): Catches overflow error --- .../test_frontends/test_torch/test_tensor.py | 38 +++++++++++-------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 46ef776296160..5df66a195de9a 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -721,22 +721,28 @@ def test_torch___gt__( backend_fw, ): input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) + try: + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "other": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + except RuntimeError as e: + if "overflow" in e: + assume(False) + else: + raise # __invert__ From 38ae58e32047adb5babb29157165c5f07c1b2f47 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 17:09:15 +0530 Subject: [PATCH 017/978] feat: added a devcontainer for the apple silicon dockerfile (#27119) --- .../build_apple_silicon/devcontainer.json | 61 +++++++++++++++++++ docker/DockerfileAppleSilicon | 6 -- 2 files changed, 61 insertions(+), 6 deletions(-) create mode 100644 .devcontainer/build_apple_silicon/devcontainer.json diff --git a/.devcontainer/build_apple_silicon/devcontainer.json b/.devcontainer/build_apple_silicon/devcontainer.json new file mode 100644 index 0000000000000..386e9b7d883e5 --- /dev/null +++ b/.devcontainer/build_apple_silicon/devcontainer.json @@ -0,0 +1,61 @@ +// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at: +// https://github.com/microsoft/vscode-dev-containers/tree/v0.236.0/containers/docker-existing-dockerfile +{ + "name": "Ivy Apple Silicon Development Environment (build)", + + "build": { + "dockerfile": "../../docker/DockerfileAppleSilicon", + "context": "../..", + "args": { + "pycon": ["3.10"] + } + }, + + "customizations": { + "vscode": { + "extensions": [ + "ms-python.python" + ], + "settings": { + "python.defaultInterpreterPath": "/opt/miniconda/envs/multienv/bin/python3" + } + } + }, + + "postCreateCommand": { + "post_create": "bash .devcontainer/post_create_commands.sh", + "bashrc": "echo \"alias python=python3\" >> ~/.bashrc" + }, + + // Use 'forwardPorts' to make a list of ports inside the container available locally. + // "forwardPorts": [], + + // Uncomment the next line to run commands after the container is created - for example installing curl. + + // Uncomment when using a ptrace-based debugger like C++, Go, and Rust + // "runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ], + + // Uncomment to use the Docker CLI from inside the container. See https://aka.ms/vscode-remote/samples/docker-from-docker. + // "mounts": [ "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind" ], + + // Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root. + // "remoteUser": "vscode", + "features": { + "ghcr.io/devcontainers/features/common-utils:2": { + "installZsh": true, + "configureZshAsDefaultShell": true, + "installOhMyZsh": true, + "upgradePackages": false + }, + "ghcr.io/devcontainers/features/docker-outside-of-docker:1": { + "moby": true, + "installDockerBuildx": true, + "version": "20.10", + "dockerDashComposeVersion": "v2" + }, + "ghcr.io/devcontainers/features/github-cli:1": { + "installDirectlyFromGitHubRelease": true, + "version": "latest" + } + } +} diff --git a/docker/DockerfileAppleSilicon b/docker/DockerfileAppleSilicon index 1c0f5926cf3c9..b0d258ad19646 100644 --- a/docker/DockerfileAppleSilicon +++ b/docker/DockerfileAppleSilicon @@ -234,9 +234,3 @@ RUN python3 test_dependencies.py -fp requirements.txt && \ rm -rf tmp.txt && \ rm -rf test_dependencies.py && \ rm -rf requirement_mappings_apple_silicon.json - -# Post installation steps -COPY .devcontainer/post_create_commands.sh . -RUN chmod +x post_create_commands.sh && \ - bash post_create_commands.sh && \ - rm -rf post_create_commands.sh From ef43bbce4ad38a0867b6bd12232cf89516d0fe99 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 25 Oct 2023 17:22:33 +0530 Subject: [PATCH 018/978] debug(ci): some more changes to the path of report.json in run_tests.py --- scripts/run_tests/run_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 49b3272981354..3bea91b986267 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -225,7 +225,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"{'*' * 100}\n") sys.stdout.flush() command = f"{command} --num-examples 5 --with-transpile" - os.system("docker cp test-container:/ivy/ivy/report.json .") + os.system("docker cp test-container:/ivy/report.json .") # load data from report if generated report_path = os.path.join( From 0ddf39bc0d9a7bc3eddf904594d52ce777a58925 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 25 Oct 2023 18:29:27 +0530 Subject: [PATCH 019/978] feat: Updated `black` formatter version. (#27114) --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 9dc902caeca49..c58337243a79e 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: - id: check-toml - id: end-of-file-fixer - repo: https://github.com/psf/black-pre-commit-mirror - rev: 23.10.0 + rev: 23.10.1 hooks: - id: black language_version: python3 From 9e5046a49fe0822198c734f528bb42a29684ce85 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 25 Oct 2023 20:05:47 +0530 Subject: [PATCH 020/978] added the threshold activation to ivy experimental api (#26489) Co-authored-by: ivy-branch --- .../array/experimental/activations.py | 39 +++++ .../container/experimental/activations.py | 135 ++++++++++++++++++ .../backends/jax/experimental/activations.py | 14 ++ .../numpy/experimental/activations.py | 18 +++ .../paddle/experimental/activations.py | 21 +++ .../tensorflow/experimental/activations.py | 15 ++ .../torch/experimental/activations.py | 15 ++ .../ivy/experimental/activations.py | 58 ++++++++ .../test_nn/test_activations.py | 32 +++++ 9 files changed, 347 insertions(+) diff --git a/ivy/data_classes/array/experimental/activations.py b/ivy/data_classes/array/experimental/activations.py index 881c0f4b537c4..24e38a9dc52ff 100644 --- a/ivy/data_classes/array/experimental/activations.py +++ b/ivy/data_classes/array/experimental/activations.py @@ -361,6 +361,45 @@ def tanhshrink(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Ar """ return ivy.tanhshrink(self._data, out=out) + def threshold( + self: ivy.Array, + /, + *, + threshold: Union[int, float], + value: Union[int, float], + out: Optional[ivy.Array] = None, + ) -> ivy.Array: + """ + ivy.Array instance method variant of ivy.threshold. This method simply wraps the + function, and so the docstring for ivy.threshold also applies to this method + with minimal changes. + + Parameters + ---------- + self + input array. + threshold + threshold value for thresholding operation. + value + value to replace with if thresholding condition is not met. + out + optional output array, for writing the result to. It must have a shape + that the inputs broadcast to. + + Returns + ------- + ret + an array with the thresholding function applied element-wise. + + Examples + -------- + >>> x = ivy.array([-1., 0., 1.]) + >>> y = x.hreshold(threshold=0.5, value=0.0) + >>> print(y) + ivy.array([0.5, 0.5 , 1. ]) + """ + return ivy.threshold(self._data, threshold=threshold, value=value, out=out) + def softshrink( self: ivy.Array, /, diff --git a/ivy/data_classes/container/experimental/activations.py b/ivy/data_classes/container/experimental/activations.py index c6a7cb689379e..1d1cb87018641 100644 --- a/ivy/data_classes/container/experimental/activations.py +++ b/ivy/data_classes/container/experimental/activations.py @@ -1188,6 +1188,138 @@ def tanhshrink( out=out, ) + @staticmethod + def _static_threshold( + x: Union[ivy.Array, ivy.NativeArray, ivy.Container], + /, + *, + threshold: ivy.Container, + value: ivy.Container, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + out: Optional[ivy.Container] = None, + ) -> ivy.Container: + """ + ivy.Container static method variant of ivy.threshold. This method simply wraps + the function, and so the docstring for ivy.threshold also applies to this method + with minimal changes. + + Parameters + ---------- + x + input container. + threshold + threshold value for thresholding operation. + value + value to replace with if thresholding condition is not met. + key_chains + The key-chains to apply or not apply the method to. + to_apply + If True, the method will be applied to key_chains, otherwise key_chains + will be skipped. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + map_sequences + Whether to also map method to sequences (lists, tuples). + out + optional output container, for writing the result to. It must have a shape + that the inputs broadcast to. + + Returns + ------- + ret + a container with the threshold activation unit function + applied element-wise. + + Examples + -------- + >>> x = ivy.Container(a=ivy.array([1.0, -1.2]), b=ivy.array([0.4, -0.2])) + >>> y = x._static_threshold(threshold=0.5, value=0.0) + >>> print(y) + { + a: ivy.array([1., 0.]), + b: ivy.array([0., 0.]) + } + """ + return ContainerBase.cont_multi_map_in_function( + "threshold", + x, + threshold=threshold, + value=value, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + out=out, + ) + + def threshold( + self: ivy.Container, + /, + *, + threshold: ivy.Container, + value: ivy.Container, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + out: Optional[ivy.Container] = None, + ) -> ivy.Container: + """ + ivy.Container instance method variant of ivy.threshold. This method simply wraps + the function, and so the docstring for ivy.threshold also applies to this method + with minimal changes. + + Parameters + ---------- + self + input container. + threshold + threshold value for thresholding operation. + value + value to replace with if thresholding condition is not met. + key_chains + The key-chains to apply or not apply the method to. + to_apply + If True, the method will be applied to key_chains, otherwise key_chains + will be skipped. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + map_sequences + Whether to also map method to sequences (lists, tuples). + out + optional output container, for writing the result to. It must have a shape + that the inputs broadcast to. + + Returns + ------- + ret + a container with the threshold activation unit function + applied element-wise. + + Examples + -------- + >>> x = ivy.Container(a=ivy.array([1.0, -1.2]), b=ivy.array([0.4, -0.2])) + >>> y = x.threshold(threshold=0.5, value=0.0) + >>> print(y) + { + a: ivy.array([1., 0.]), + b: ivy.array([0., 0.]) + } + """ + return self._static_threshold( + self, + threshold=threshold, + value=value, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + out=out, + ) + @staticmethod def _static_softshrink( x: Union[ivy.Array, ivy.NativeArray, ivy.Container], @@ -1220,6 +1352,9 @@ def _static_softshrink( Whether to prune key_chains for which the function was not applied. map_sequences Whether to also map method to sequences (lists, tuples). + out + optional output container, for writing the result to. It must have a shape + that the inputs broadcast to. Returns ------- diff --git a/ivy/functional/backends/jax/experimental/activations.py b/ivy/functional/backends/jax/experimental/activations.py index c21f9c034e369..d06d11a7ad8a7 100644 --- a/ivy/functional/backends/jax/experimental/activations.py +++ b/ivy/functional/backends/jax/experimental/activations.py @@ -115,6 +115,20 @@ def tanhshrink(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return ret +def threshold( + x: JaxArray, + /, + *, + threshold: Union[int, float], + value: Union[int, float], + out: Optional[JaxArray] = None, +) -> JaxArray: + ret = jnp.where(x > threshold, x, value).astype(x.dtype) + if ivy.exists(out): + return ivy.inplace_update(out, ret).astype(x.dtype) # type: ignore + return ret + + @with_unsupported_dtypes({"0.4.16 and below": ("float16", "bfloat16")}, backend_version) def softshrink( x: JaxArray, /, *, lambd: float = 0.5, out: Optional[JaxArray] = None diff --git a/ivy/functional/backends/numpy/experimental/activations.py b/ivy/functional/backends/numpy/experimental/activations.py index b84c15cb7a062..721365d16b7b5 100644 --- a/ivy/functional/backends/numpy/experimental/activations.py +++ b/ivy/functional/backends/numpy/experimental/activations.py @@ -148,6 +148,24 @@ def tanhshrink(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndar tanhshrink.support_native_out = True +@_scalar_output_to_0d_array +def threshold( + x: np.ndarray, + /, + *, + threshold: float, + value: float, + out: Optional[np.ndarray] = None, +) -> np.ndarray: + ret = np.where(x > threshold, x, value) + if ivy.exists(out): + return ivy.inplace_update(out, ret).astype(x.dtype) + return ivy.astype(ret, x.dtype) + + +threshold.support_native_out = True + + @_scalar_output_to_0d_array def softshrink( x: np.ndarray, /, *, lambd: float = 0.5, out: Optional[np.ndarray] = None diff --git a/ivy/functional/backends/paddle/experimental/activations.py b/ivy/functional/backends/paddle/experimental/activations.py index d414972706b16..7b146de17f430 100644 --- a/ivy/functional/backends/paddle/experimental/activations.py +++ b/ivy/functional/backends/paddle/experimental/activations.py @@ -166,6 +166,27 @@ def tanhshrink( return F.tanhshrink(x.cast("float32")).cast(x.dtype) +@with_unsupported_device_and_dtypes( + {"2.5.1 and below": {"cpu": ("bfloat16", "float16")}}, backend_version +) +def threshold( + x: paddle.Tensor, + /, + *, + threshold: float, + value: float, + out: Optional[paddle.Tensor] = None, +) -> paddle.Tensor: + if x.dtype in [paddle.float32, paddle.float64]: + return paddle_backend.where(paddle_backend.greater(x, threshold), x, value) + if paddle.is_complex(x): + return paddle_backend.where(paddle_backend.greater(x, threshold), x, value) + x = x.cast("float32") + return paddle_backend.where(paddle_backend.greater(x, threshold), x, value).cast( + x.dtype + ) + + @with_unsupported_device_and_dtypes( {"2.5.1 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) diff --git a/ivy/functional/backends/tensorflow/experimental/activations.py b/ivy/functional/backends/tensorflow/experimental/activations.py index 8427d803331f5..1da7e9e2e80a7 100644 --- a/ivy/functional/backends/tensorflow/experimental/activations.py +++ b/ivy/functional/backends/tensorflow/experimental/activations.py @@ -113,6 +113,21 @@ def tanhshrink( return ivy.astype(ret, x.dtype) +@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +def threshold( + x: Tensor, + /, + *, + threshold: Union[int, float], + value: Union[int, float], + out: Optional[Tensor] = None, +) -> Tensor: + ret = tf.where(x > threshold, x, value) + if ivy.exists(out): + return ivy.inplace_update(out, ret).astype(x.dtype) + return ivy.astype(ret, x.dtype) + + @with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) def softshrink( x: Tensor, diff --git a/ivy/functional/backends/torch/experimental/activations.py b/ivy/functional/backends/torch/experimental/activations.py index 34b51951f75c1..a883a4f1fbbb7 100644 --- a/ivy/functional/backends/torch/experimental/activations.py +++ b/ivy/functional/backends/torch/experimental/activations.py @@ -118,6 +118,21 @@ def tanhshrink( return ivy.astype(ret, x.dtype) +@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +def threshold( + x: torch.Tensor, + /, + *, + threshold: float, + value: float, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + ret = torch.nn.functional.threshold(threshold=threshold, value=value, input=x) + if ivy.exists(out): + return ivy.inplace_update(out, ret).astype(x.dtype) + return ivy.astype(ret, x.dtype) + + @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) def softshrink( x: torch.Tensor, /, *, lambd: float = 0.5, out: Optional[torch.Tensor] = None diff --git a/ivy/functional/ivy/experimental/activations.py b/ivy/functional/ivy/experimental/activations.py index c78f44198b9d6..fe15ccc31721f 100644 --- a/ivy/functional/ivy/experimental/activations.py +++ b/ivy/functional/ivy/experimental/activations.py @@ -723,6 +723,64 @@ def _celu_jax_like( return complex_max + alpha * ivy.expm1(complex_min / alpha) +@handle_exceptions +@handle_backend_invalid +@handle_nestable +@handle_array_like_without_promotion +@handle_out_argument +@to_native_arrays_and_back +@handle_device +def threshold( + x: Union[ivy.Array, ivy.NativeArray], + /, + *, + threshold: float, + value: float, + out: Optional[ivy.Array] = None, +) -> ivy.Array: + """ + Apply the threshold function element-wise. + + Parameters + ---------- + x + input array. + threshold + The value to threshold at. + value + The value to replace with. + out + optional output array, for writing the result to. It must have a shape that the + inputs broadcast to. + + Returns + ------- + ret + an array containing the threshold activation of each element in ``x``. + + Examples + -------- + With :class:`ivy.Array` input: + >>> x = ivy.array([-1.0, 1.0, 2.0]) + >>> y = ivy.threshold(x,value=0.0, threshold=1.5) + >>> print(y) + ivy.array([0., 0., 2.]) + + >>> x = ivy.array([-1.0, 1.0, 2.0]) + >>> x.threshold(value=0.0, threshold=1.5) + >>> print(y) + ivy.array([0., 0., 2.]) + + + >>> x = ivy.array([[-1.3, 3.8, 2.1], [1.7, 4.2, -6.6]]) + >>> y = ivy.threshold(x, value=0.0, threshold=1.5) + >>> print(y) + ivy.array([[0. , 3.79999995, 2.0999999 ], + [1.70000005, 4.19999981, 0. ]]) + """ + return current_backend(x).threshold(x, threshold=threshold, value=value, out=out) + + @handle_exceptions @handle_backend_invalid @handle_nestable diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py index ab60d709d92ed..5a79ef33ad3cf 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py @@ -366,6 +366,38 @@ def test_tanhshrink(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): ) +# threshold +@handle_test( + fn_tree="functional.ivy.experimental.threshold", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + large_abs_safety_factor=8, + small_abs_safety_factor=8, + safety_factor_scale="log", + ), + threshold=st.one_of( + st.floats(min_value=-1e30, max_value=1e30), + ), + value=st.one_of( + st.floats(min_value=-1e30, max_value=1e30), + ), +) +def test_threshold( + *, dtype_and_x, threshold, value, test_flags, backend_fw, fn_name, on_device +): + dtype, x = dtype_and_x + helpers.test_function( + input_dtypes=dtype, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_name=fn_name, + on_device=on_device, + x=x[0], + threshold=threshold, + value=value, + ) + + # thresholded_relu @handle_test( fn_tree="functional.ivy.experimental.thresholded_relu", From b5c930574814e97e48111d0d4d31cbfaab4758a4 Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Wed, 25 Oct 2023 15:05:08 +0000 Subject: [PATCH 021/978] feat: Add ifftn to Paddle Frontend (#23448) Co-authored-by: hmahmood24 --- ivy/functional/frontends/paddle/fft.py | 10 +++++++ .../test_frontends/test_paddle/test_fft.py | 29 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 9045ef19bb89c..11eb1849bdcb0 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -125,6 +125,16 @@ def ifft(x, n=None, axis=-1.0, norm="backward", name=None): return ivy.astype(ret, x.dtype) +@with_supported_dtypes( + {"2.5.1 and below": ("complex64", "complex128")}, + "paddle", +) +@to_ivy_arrays_and_back +def ifftn(x, s=None, axes=None, norm="backward", name=None): + ret = ivy.ifftn(ivy.astype(x, "complex128"), s=s, axes=axes, norm=norm) + return ivy.astype(ret, x.dtype) + + @with_supported_dtypes( { "2.5.1 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py index c49ea38dd9aae..fcff4153a6409 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py @@ -4,6 +4,9 @@ # local import ivy_tests.test_ivy.helpers as helpers from ivy_tests.test_ivy.helpers import handle_frontend_test +from ivy_tests.test_ivy.test_functional.test_experimental.test_nn.test_layers import ( + _x_and_ifftn, +) # Custom Hypothesis strategy for generating sequences of 2 integers @@ -225,6 +228,32 @@ def test_paddle_ifft( ) +# ifftn +@handle_frontend_test( + fn_tree="paddle.fft.ifftn", + dtype_and_x=_x_and_ifftn(), +) +def test_paddle_ifftn( + dtype_and_x, + frontend, + backend_fw, + test_flags, + fn_tree, +): + dtype, x, s, axes, norm = dtype_and_x + helpers.test_frontend_function( + input_dtypes=dtype, + frontend=frontend, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + x=x, + s=s, + axes=axes, + norm=norm, + ) + + @handle_frontend_test( fn_tree="paddle.fft.ifftshift", dtype_x_axis=helpers.dtype_values_axis( From cabf3dc060aa15a10640a07f5b85d8d184a580d5 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 25 Oct 2023 15:24:50 +0000 Subject: [PATCH 022/978] fix(torch-frontend): Fixes where --- .../indexing_slicing_joining_mutating_ops.py | 2 + ...t_indexing_slicing_joining_mutating_ops.py | 47 ++++++++++++++----- 2 files changed, 38 insertions(+), 11 deletions(-) diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py index f20d9263bfa91..99e62dc19e67a 100644 --- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py +++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py @@ -6,6 +6,7 @@ numpy_to_torch_style_args, to_ivy_shape, ) +import ivy.functional.frontends.torch as torch_frontend @to_ivy_arrays_and_back @@ -508,4 +509,5 @@ def vstack(tensors, *, out=None): def where(condition, input=None, other=None): if not ivy.exists(input) and not ivy.exists(other): return nonzero(condition, as_tuple=True) + input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.where(condition, input, other) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py index 4e784594b8b3b..79667f0ab42fb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py @@ -11,12 +11,12 @@ import ivy_tests.test_ivy.helpers.globals as test_globals from ivy_tests.test_ivy.helpers import handle_frontend_test from ivy_tests.test_ivy.test_functional.test_core.test_manipulation import _get_splits -from ivy_tests.test_ivy.test_functional.test_core.test_searching import ( - _broadcastable_trio, -) from ivy_tests.test_ivy.test_functional.test_core.test_manipulation import ( # noqa _get_splits, ) +from ivy_tests.array_api_testing.test_array_api.array_api_tests import ( + hypothesis_helpers as hh, +) # --- Helpers --- # @@ -338,6 +338,31 @@ def _dtypes_input_mask(draw): return _dtype, _x, _mask +@st.composite +def _where_helper(draw): + shape_1, shape_2 = draw(hh.two_broadcastable_shapes()) + dtype_x1, x1 = draw( + helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + shape=shape_1, + ) + ) + dtype_x2, x2 = draw( + helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + shape=shape_1, + shared_dtype=True, + ) + ) + _, cond = draw( + helpers.dtype_and_values( + available_dtypes=["bool"], + shape=shape_2, + ) + ) + return ["bool", *dtype_x1, *dtype_x2], [cond[0], x1[0], x2[0]] + + # reshape @st.composite def dtypes_x_reshape(draw): @@ -1791,7 +1816,7 @@ def test_torch_vstack( @handle_frontend_test( fn_tree="torch.where", - broadcastables=_broadcastable_trio(), + broadcastables=_where_helper(), only_cond=st.booleans(), ) def test_torch_where( @@ -1804,7 +1829,7 @@ def test_torch_where( backend_fw, on_device, ): - cond, xs, dtypes = broadcastables + dtypes, arrays = broadcastables if only_cond: helpers.test_frontend_function( @@ -1814,18 +1839,18 @@ def test_torch_where( test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, - condition=xs[0], + condition=arrays[0], ) else: helpers.test_frontend_function( - input_dtypes=["bool"] + dtypes, + input_dtypes=dtypes, + backend_to_test=backend_fw, frontend=frontend, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, - condition=cond, - input=xs[0], - other=xs[1], - backend_to_test=backend_fw, + condition=arrays[0], + input=arrays[1], + other=arrays[2], ) From 45d70f22ffec3a7762bef4c4716b44ce83275a6f Mon Sep 17 00:00:00 2001 From: m571adil <145253791+m571adil@users.noreply.github.com> Date: Wed, 25 Oct 2023 20:33:15 +0500 Subject: [PATCH 023/978] feat: Added expand function to Paddle frontend (#26205) Co-authored-by: hmahmood24 --- .../frontends/paddle/tensor/tensor.py | 6 ++ .../test_paddle/test_tensor/test_tensor.py | 64 +++++++++++++++++++ 2 files changed, 70 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index d573e50adafca..87013e718708c 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -927,6 +927,12 @@ def gather_(self, y, name=None): res = self.gather(self, y) return ivy.inplace_update(self, res) + @with_supported_dtypes( + {"2.5.1 and below": ("bool", "int32", "int64", "float32", "float64")}, "paddle" + ) + def expand(self, shape, name=None): + return paddle_frontend.expand(self._ivy_array, shape) + @with_supported_device_and_dtypes( { "2.5.1 and below": { diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index eb5db6b83a986..e230d9d928068 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -225,6 +225,35 @@ def _reshape_helper(draw): return dtypes, x, reshape_shape +# expand helper function +@st.composite +def dtypes_x_shape(draw): + dtypes, x = draw( + helpers.dtype_and_values( + min_dim_size=1, + min_num_dims=1, + available_dtypes=["float32"], + shape=st.shared( + helpers.get_shape( + min_num_dims=1, + max_num_dims=6, + ), + key="shape", + ), + ) + ) + shape = draw( + st.shared( + helpers.get_shape( + min_num_dims=1, + max_num_dims=6, + ), + key="shape", + ) + ) + return dtypes, x, shape + + # diagonal @st.composite def dims_and_offset(draw, shape): @@ -2151,6 +2180,41 @@ def test_paddle_exp_( ) +# expand +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="expand", + dtype_x_shape=dtypes_x_shape(), +) +def test_paddle_tensor_expand( + dtype_x_shape, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x, shape = dtype_x_shape + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "shape": shape, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # fill_ @handle_frontend_method( class_tree=CLASS_TREE, From 7e9e762797da5e411652a816bb350d51b669f2ec Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 25 Oct 2023 15:36:02 +0000 Subject: [PATCH 024/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../test_paddle/test_tensor/test_tensor.py | 94 +++++++++---------- 1 file changed, 47 insertions(+), 47 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index e230d9d928068..d8c2bdc7b6f05 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -225,6 +225,18 @@ def _reshape_helper(draw): return dtypes, x, reshape_shape +# diagonal +@st.composite +def dims_and_offset(draw, shape): + shape_actual = draw(shape) + dim1 = draw(helpers.get_axis(shape=shape, force_int=True)) + dim2 = draw(helpers.get_axis(shape=shape, force_int=True)) + offset = draw( + st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) + ) + return dim1, dim2, offset + + # expand helper function @st.composite def dtypes_x_shape(draw): @@ -254,18 +266,6 @@ def dtypes_x_shape(draw): return dtypes, x, shape -# diagonal -@st.composite -def dims_and_offset(draw, shape): - shape_actual = draw(shape) - dim1 = draw(helpers.get_axis(shape=shape, force_int=True)) - dim2 = draw(helpers.get_axis(shape=shape, force_int=True)) - offset = draw( - st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) - ) - return dim1, dim2, offset - - # --- Main --- # # ------------ # @@ -2180,41 +2180,6 @@ def test_paddle_exp_( ) -# expand -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="expand", - dtype_x_shape=dtypes_x_shape(), -) -def test_paddle_tensor_expand( - dtype_x_shape, - frontend_method_data, - init_flags, - method_flags, - frontend, - on_device, - backend_fw, -): - input_dtype, x, shape = dtype_x_shape - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "shape": shape, - }, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - - # fill_ @handle_frontend_method( class_tree=CLASS_TREE, @@ -4609,6 +4574,41 @@ def test_paddle_tanh_( ) +# expand +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="expand", + dtype_x_shape=dtypes_x_shape(), +) +def test_paddle_tensor_expand( + dtype_x_shape, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x, shape = dtype_x_shape + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "shape": shape, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # tile @handle_frontend_method( class_tree=CLASS_TREE, From 40b27d818ce6a677c0e6073b7e351ee130aed532 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Wed, 25 Oct 2023 22:25:07 +0300 Subject: [PATCH 025/978] fix: handle multiple GPUs in paddle backend `to_device` --- ivy/functional/backends/paddle/device.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/device.py b/ivy/functional/backends/paddle/device.py index 9360fa702f1cd..3d732ec9ee9af 100644 --- a/ivy/functional/backends/paddle/device.py +++ b/ivy/functional/backends/paddle/device.py @@ -34,7 +34,11 @@ def to_device( device = as_native_dev(device) if device.is_cpu_place() and not x.place.is_cpu_place(): return x.cpu() - elif device.is_gpu_place() and not x.place.is_gpu_place(): + elif (device.is_gpu_place() and not x.place.is_gpu_place()) or ( + x.place.is_gpu_place() + and device.is_gpu_place() + and x.gpu_device_id() != device.gpu_device_id() + ): return x.cuda(device.gpu_device_id()) else: return x From d038b486dac1b8ad04bfaff90f99a5cae31a6449 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Wed, 25 Oct 2023 23:21:39 +0300 Subject: [PATCH 026/978] fix: return `default_device` as native to be used directly in the backend --- ivy/functional/ivy/device.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index d887aad881d5e..1aa1c82e7dc5e 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -164,7 +164,7 @@ def _shift_native_arrays_on_default_device(*args, **kwargs): ), [args, kwargs], ) - return args, kwargs, default_device + return args, kwargs, ivy.as_native_dev(default_device) # Device Queries # From 85b428c0f6be816e8476614a49d04819e7b7d3f8 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Wed, 25 Oct 2023 22:51:35 +0000 Subject: [PATCH 027/978] fix: fix recursion in `test_torch_fold` --- .../test_nn/test_functional/test_convolution_functions.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py index d2e95a4269d04..d61a1440719e1 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py @@ -3,7 +3,6 @@ from hypothesis import strategies as st, assume # local -import ivy import ivy_tests.test_ivy.helpers as helpers from ivy_tests.test_ivy.helpers import handle_frontend_test from ivy_tests.test_ivy.test_functional.test_nn.test_layers import ( @@ -44,7 +43,7 @@ def _fold_helper(draw, dim=2): ) ) if vals.shape[0] == 1: # un-batched inputs are also supported - vals = draw(st.one_of(st.just(vals), st.just(ivy.squeeze(vals, axis=0)))) + vals = draw(st.sampled_from([vals, vals[0]])) return dtype, vals, kernel_size, output_shape, dilation, stride, padding From 3f23158456397b6aaf3d7c0608152ace6dd5e14a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 26 Oct 2023 08:44:09 +0530 Subject: [PATCH 028/978] fix: Added missing `comma`. (#27111) --- ivy/functional/backends/jax/experimental/layers.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 84224b0e59928..122598cd4cfb3 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -689,7 +689,8 @@ def interpolate( "area", "nearest_exact", "tf_area", - "bicubic_tensorflow" "bicubic", + "bicubic_tensorflow", + "bicubic", "mitchellcubic", "lanczos3", "lanczos5", From 2ee3244fdd960e7320aa356f7a621a7e7db0376a Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Thu, 26 Oct 2023 05:04:39 +0100 Subject: [PATCH 029/978] =?UTF-8?q?fix:=20bug=20where=20fn=5Funsupported?= =?UTF-8?q?=5Fdnd=20is=20a=20tuple=20on=20the=20latest=20paddle=20ver?= =?UTF-8?q?=E2=80=A6=20(#27125)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/ivy/general.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index c3c5b5ca7a996..2003e4094007e 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -4069,8 +4069,9 @@ def _get_devices_and_dtypes(fn, recurse=False, complement=True): list(fn_supported_dnd.values())[0], tuple ) - for device, dtypes in fn_supported_dnd.items(): - fn_supported_dnd[device] = tuple(_expand_typesets(dtypes)) + if isinstance(fn_supported_dnd, dict): + for device, dtypes in fn_supported_dnd.items(): + fn_supported_dnd[device] = tuple(_expand_typesets(dtypes)) # dict intersection supported = _dnd_dict_intersection(supported, fn_supported_dnd) @@ -4086,8 +4087,9 @@ def _get_devices_and_dtypes(fn, recurse=False, complement=True): list(fn_unsupported_dnd.values())[0], tuple ) - for device, dtypes in fn_unsupported_dnd.items(): - fn_unsupported_dnd[device] = tuple(_expand_typesets(dtypes)) + if isinstance(fn_unsupported_dnd, dict): + for device, dtypes in fn_unsupported_dnd.items(): + fn_unsupported_dnd[device] = tuple(_expand_typesets(dtypes)) # dict difference supported = _dnd_dict_difference(supported, fn_unsupported_dnd) From 4d01cde21d8ba7efe8d4cf4d3370e95ffcca4d9d Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 26 Oct 2023 09:55:32 +0530 Subject: [PATCH 030/978] chore(ci): some more debug code to run_tests --- scripts/run_tests/run_tests.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 3bea91b986267..dc4568df23a1a 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -283,6 +283,8 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): # populate the ci_dashboard db, skip instance methods if function_name: id = test_info.pop("_id") + print(f"ID : {id}") + print(f"TEST INFO : {test_info}") print( collection.update_one({"_id": id}, {"$set": test_info}, upsert=True) ) From e8c3a95289f2bb680d95dc3e2c74367ad9faf548 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 26 Oct 2023 10:03:36 +0530 Subject: [PATCH 031/978] fix(ci): fixed another issue with run_tests due to wrong naming --- scripts/run_tests/run_tests.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index dc4568df23a1a..6b7c0c1372bec 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -154,13 +154,13 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print("Running", command) else: - device = "" + device_str = "" image = "unifyai/ivy:latest" # gpu tests if device == "gpu": image = "unifyai/multicuda:base_and_requirements" - device = " --device=gpu:0" + device_str = " --device=gpu:0" os.system( 'docker run --name test-container -v "$(pwd)":/ivy -v ' @@ -169,7 +169,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): ) command = ( "docker exec test-container python3 -m pytest --tb=short" - f" {test_path} {device} --backend {backend}" + f" {test_path} {device_str} --backend {backend}" ) os.system(command) From ab3f891a97553b9e5cb3dcc27cbd7e28e5bd90c5 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 26 Oct 2023 10:57:48 +0530 Subject: [PATCH 032/978] refactor: gpu dockerfile (#27126) 1. Removed the multicuda-base dockerfile and renamed the multicuda dockerfile to gpu dockerfile. 2. Refactored the gpu docker image on docker hub to be unifyai/ivy:latest-gpu instead of unifyai/multicuda:base_and_requirements 3. Removed all other occurrences of multicuda to avoid confusion --- .devcontainer/build_gpu/devcontainer.json | 6 +-- .devcontainer/image_gpu/devcontainer.json | 2 +- .github/workflows/dockerfile-gpu-push.yml | 26 ++++++++++ .../workflows/dockerfile-multicuda-push.yml | 31 ------------ .../{DockerfileGPUMultiCuda => DockerfileGPU} | 50 ++++++++++++------- docker/DockerfileGPUMultiCuda-base | 20 -------- docker/build_DockerfileGPUMultiCuda.sh | 1 - docker/build_gpu_dockerfile.sh | 1 + ...irectory.py => gpu_framework_directory.py} | 0 docker/rebuild_all_dockerfiles.sh | 2 +- docs/overview/contributing/setting_up.rst | 2 +- scripts/run_tests/run_tests.py | 5 +- 12 files changed, 68 insertions(+), 78 deletions(-) create mode 100644 .github/workflows/dockerfile-gpu-push.yml delete mode 100644 .github/workflows/dockerfile-multicuda-push.yml rename docker/{DockerfileGPUMultiCuda => DockerfileGPU} (75%) delete mode 100644 docker/DockerfileGPUMultiCuda-base delete mode 100644 docker/build_DockerfileGPUMultiCuda.sh create mode 100644 docker/build_gpu_dockerfile.sh rename docker/{multicuda_framework_directory.py => gpu_framework_directory.py} (100%) diff --git a/.devcontainer/build_gpu/devcontainer.json b/.devcontainer/build_gpu/devcontainer.json index 399fc8cf8d1b5..b74cb231c4a78 100644 --- a/.devcontainer/build_gpu/devcontainer.json +++ b/.devcontainer/build_gpu/devcontainer.json @@ -2,11 +2,11 @@ "name": "Ivy GPU Development Environment (build)", "build": { - "dockerfile": "../../docker/DockerfileGPUMultiCuda", + "dockerfile": "../../docker/DockerfileGPU", "context": "../..", "args": { - "IMAGE_NAME": "unifyai/multicuda", - "IMAGE_TAG": "base_and_requirements" + "IMAGE_NAME": "unifyai/ivy", + "IMAGE_TAG": "latest-gpu" } }, diff --git a/.devcontainer/image_gpu/devcontainer.json b/.devcontainer/image_gpu/devcontainer.json index 6824d7ca80037..ca899e132de7b 100644 --- a/.devcontainer/image_gpu/devcontainer.json +++ b/.devcontainer/image_gpu/devcontainer.json @@ -1,7 +1,7 @@ { "name": "Ivy GPU Development Environment (image)", - "image": "unifyai/multicuda:base_and_requirements", + "image": "unifyai/ivy:latest-gpu", "customizations": { "vscode": { "extensions": [ diff --git a/.github/workflows/dockerfile-gpu-push.yml b/.github/workflows/dockerfile-gpu-push.yml new file mode 100644 index 0000000000000..df978d2ee95a9 --- /dev/null +++ b/.github/workflows/dockerfile-gpu-push.yml @@ -0,0 +1,26 @@ +name: GPU Dockerfile Push + +on: + schedule: + - cron: '0 0 * * *' + workflow_dispatch: + +jobs: + + build: + runs-on: ubuntu-latest-4-cores + + steps: + - name: Checkout 🛎 Ivy + uses: actions/checkout@v3 + + - name: Login to Docker Hub + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - name: Build and push GPU image + run: | + docker build --progress=plain --no-cache -t unifyai/ivy:latest-gpu -f docker/DockerfileGPU . + docker push unifyai/ivy:latest-gpu diff --git a/.github/workflows/dockerfile-multicuda-push.yml b/.github/workflows/dockerfile-multicuda-push.yml deleted file mode 100644 index 1ace6afdc4b36..0000000000000 --- a/.github/workflows/dockerfile-multicuda-push.yml +++ /dev/null @@ -1,31 +0,0 @@ -name: Dockerfile MultiCUDA Push - -on: - schedule: - - cron: '0 0 * * *' - workflow_dispatch: - -jobs: - - build: - runs-on: ubuntu-latest-4-cores - - steps: - - name: Checkout 🛎 Ivy - uses: actions/checkout@v3 - - - name: Login to Docker Hub - uses: docker/login-action@v2 - with: - username: ${{ secrets.DOCKERHUB_USERNAME }} - password: ${{ secrets.DOCKERHUB_TOKEN }} - - - name: Build and push base image - run: | - docker build --progress=plain --no-cache -t unifyai/multicuda:base -f docker/DockerfileGPUMultiCuda-base . - docker push unifyai/multicuda:base - - - name: Build and push base_and_requirements image - run: | - docker build --progress=plain --no-cache -t unifyai/multicuda:base_and_requirements -f docker/DockerfileGPUMultiCuda . - docker push unifyai/multicuda:base_and_requirements diff --git a/docker/DockerfileGPUMultiCuda b/docker/DockerfileGPU similarity index 75% rename from docker/DockerfileGPUMultiCuda rename to docker/DockerfileGPU index 46ea25929c4a5..5eca7bab1a6cc 100644 --- a/docker/DockerfileGPUMultiCuda +++ b/docker/DockerfileGPU @@ -1,16 +1,32 @@ -# uses the base image which has cuda and cudnn installed(multiple versions) and then installs the +# installs multiple versions of cuda and cudnn and then installs the # latest frameworks and the requirements -FROM unifyai/multicuda:base +FROM debian:buster WORKDIR /ivy -ARG fw +# arguments +ARG fw ARG pycon=3.10 +# environment variables ENV DEBIAN_FRONTEND=noninteractive - -# Install miniconda +ENV TZ=Europe/Moscow ENV CONDA_DIR /opt/miniconda/ + +# install base libraries +RUN grep security /etc/apt/sources.list | tee /etc/apt/security.sources.list && \ + apt-get update && \ + apt-get upgrade -o Dir::Etc::SourceList=/etc/apt/security.sources.list -y &&\ + apt-get -y update && \ + apt-get install -y gnupg \ + curl \ + wget \ + software-properties-common \ + gcc \ + nano + + +# install miniconda RUN apt clean && \ rm -rf /var/lib/apt/lists/* && \ apt-get update && \ @@ -21,10 +37,12 @@ RUN apt clean && \ /bin/bash ~/miniconda.sh -b -p /opt/miniconda +# create conda environment ENV PATH=$CONDA_DIR/bin:$PATH RUN conda create --name multienv python==$pycon -y -# to fix protobuf conflicts + +# fix protobuf conflicts ENV PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION python ENV PATH=/opt/miniconda/envs/multienv/bin:$PATH RUN apt-get update && \ @@ -38,44 +56,42 @@ RUN apt-get update && \ pip3 install setuptools==58.5.3 -# Install Ivy Upstream +# install Ivy Upstream RUN git clone --progress --recurse-submodules https://github.com/unifyai/ivy --depth 1 && \ cd ivy && \ cd ivy_tests/array_api_testing/test_array_api && \ pip3 install --no-cache-dir -r requirements.txt -# Install local optional -COPY /docker/multicuda_framework_directory.py . + +# copy library files to workdir +COPY docker/gpu_framework_directory.py . COPY requirements/optional_gpu.txt . COPY requirements/requirements.txt . -#setting torch path early on because torch-scatter needs it +# setting torch path early on because torch-scatter needs it ENV PYTHONPATH "/opt/fw/torch:/opt/miniconda/envs/multienv/bin" + # requirement mappings directs which dependency to be installed and where COPY /docker/requirement_mappings_gpu.json . SHELL ["/bin/bash", "-c"] - -RUN python3 multicuda_framework_directory.py $fw &&\ +# install all libraries based on the mappings +RUN python3 gpu_framework_directory.py $fw &&\ jq -r 'to_entries[] | select(.value != [""]) | .key as $dir | .value[] | @sh "/opt/fw/\($dir) \(.)"' requirement_mappings_gpu.json | xargs -I {} sh -c 'printf "Installing %s\n" $2 && pip install --ignore-installed --target $1 $2 --extra-index-url https://download.pytorch.org/whl/cu118' sh {} - - - RUN sed -i '/numpy/d' requirements.txt &&\ pip install -r requirements.txt &&\ cp ./optional_gpu.txt tmp.txt &&\ jq -r 'to_entries[] | [.key] + .value | select(length > 0 or (. == "")) | .[]' requirement_mappings_gpu.json | sort -u | xargs -I {} sed -i '/{}/d;/jaxlib/d' tmp.txt && pip install -r tmp.txt - - # add all the directories to environment path so that python knows where to find them ENV PYTHONPATH "/opt/fw/mxnet:/opt/fw/numpy:/opt/fw/tensorflow:/opt/fw/jax:/opt/fw/torch:/opt/fw/paddle:/opt/miniconda/envs/multienv/bin" +# test dependencies COPY scripts/test_dependencies.py . RUN python3 test_dependencies.py -fp requirements.txt,optional_gpu.txt && \ rm -rf requirements.txt && \ diff --git a/docker/DockerfileGPUMultiCuda-base b/docker/DockerfileGPUMultiCuda-base deleted file mode 100644 index fa8c4c9895f53..0000000000000 --- a/docker/DockerfileGPUMultiCuda-base +++ /dev/null @@ -1,20 +0,0 @@ -# is used to create a base image where we then manually install cuda and cudnn -FROM debian:buster -WORKDIR /ivy - - -COPY ../docker/multicuda_framework_directory.py . -COPY ../docker/multicuda_requirements.txt . - -ENV DEBIAN_FRONTEND=noninteractive -ENV TZ=Europe/Moscow -RUN grep security /etc/apt/sources.list | tee /etc/apt/security.sources.list && \ - apt-get update && \ - apt-get upgrade -o Dir::Etc::SourceList=/etc/apt/security.sources.list -y &&\ - apt-get -y update && \ - apt-get install -y gnupg \ - curl \ - wget \ - software-properties-common \ - gcc \ - nano diff --git a/docker/build_DockerfileGPUMultiCuda.sh b/docker/build_DockerfileGPUMultiCuda.sh deleted file mode 100644 index f9e0ff9da5d9f..0000000000000 --- a/docker/build_DockerfileGPUMultiCuda.sh +++ /dev/null @@ -1 +0,0 @@ -docker build --progress=plain --no-cache -t unifyai/multicuda:base_and_requirements -f DockerfileGPUMultiCuda .. diff --git a/docker/build_gpu_dockerfile.sh b/docker/build_gpu_dockerfile.sh new file mode 100644 index 0000000000000..ec946c8b97e89 --- /dev/null +++ b/docker/build_gpu_dockerfile.sh @@ -0,0 +1 @@ +docker build --progress=plain --no-cache -t unifyai/ivy:latest-gpu -f DockerfileGPU .. diff --git a/docker/multicuda_framework_directory.py b/docker/gpu_framework_directory.py similarity index 100% rename from docker/multicuda_framework_directory.py rename to docker/gpu_framework_directory.py diff --git a/docker/rebuild_all_dockerfiles.sh b/docker/rebuild_all_dockerfiles.sh index 7af9cb5c2170e..386faff74fae5 100755 --- a/docker/rebuild_all_dockerfiles.sh +++ b/docker/rebuild_all_dockerfiles.sh @@ -1,4 +1,4 @@ #!/bin/bash docker build -t unifyai/ivy:latest --no-cache -f Dockerfile .. -docker build -t unifyai/multicuda:base_and_requirements --no-cache -f DockerfileGPUMultiCuda .. +docker build -t unifyai/ivy:latest-gpu --no-cache -f DockerfileGPU .. diff --git a/docs/overview/contributing/setting_up.rst b/docs/overview/contributing/setting_up.rst index 0a541c646a24d..0b6c0535dbc93 100644 --- a/docs/overview/contributing/setting_up.rst +++ b/docs/overview/contributing/setting_up.rst @@ -715,7 +715,7 @@ Just follow the steps outlined below: - :code:`Default project configuration` - This is the default option, it will set up with the default codespaces environment. - :code:`Ivy Development Environment (build)` - This will set up the development environment of ivy for CPU and build image from :code:`ivy/docker/Dockerfile`. - - :code:`Ivy GPU Development Environment (build)` - This will set up the development environment of ivy for GPU and build image from :code:`ivy/docker/DockerfileGPUMultiCuda`. + - :code:`Ivy GPU Development Environment (build)` - This will set up the development environment of ivy for GPU and build image from :code:`ivy/docker/DockerfileGPU`. - :code:`Ivv Development Environment for Multiver...` - This will set up the development environment of multiversion support with ivy and build image from :code:`ivy/docker/DockerfileMultiversion`. - :code:`Ivy Development Environment (image)` - This will set up the development environment of ivy for CPU and build image from the latest image from dockerhub. - :code:`Ivy GPU Development Environment (image)` - This will set up the development environment of ivy for GPU and build image from the latest image from dockerhub. diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 6b7c0c1372bec..1748b2c3d9486 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -105,7 +105,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): # pull gpu image for gpu testing if device == "gpu": - os.system("docker pull unifyai/multicuda:base_and_requirements") + os.system("docker pull unifyai/ivy:latest-gpu") # read the tests to be run with open("tests_to_run", "r") as f: @@ -151,7 +151,6 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): ) backend = backend.split("/")[0] + "\n" backend_version = backend_version.strip() - print("Running", command) else: device_str = "" @@ -159,7 +158,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): # gpu tests if device == "gpu": - image = "unifyai/multicuda:base_and_requirements" + image = "unifyai/ivy:latest-gpu" device_str = " --device=gpu:0" os.system( From ef5c313cd6b53188a8a85656c7b0d442512a2170 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 26 Oct 2023 12:33:48 +0530 Subject: [PATCH 033/978] fix(ci): fixing the run_tests script (#27127) transpilation metrics seem to now be working, wrapped the write action to the old dashboard in a try except as it will be phased out soon anyway --- scripts/run_tests/run_tests.py | 67 ++++++++++++++++++---------------- 1 file changed, 36 insertions(+), 31 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 1748b2c3d9486..3d331333ce467 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -2,6 +2,7 @@ import os import sys from pymongo import MongoClient +from pymongo.errors import WriteError import requests import json import old_run_test_helpers as old_helpers @@ -189,32 +190,35 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): frontend_version = None if coll[0] in ["numpy", "jax", "tensorflow", "torch", "paddle"]: frontend_version = "latest-stable" - if priority_flag: - print("Updating Priority DB") - old_helpers.update_individual_test_results( - old_db_priority[coll[0]], - coll[1], - submod, - backend, - test_fn, - res, - "latest-stable", - frontend_version, - device, - ) - else: - print(backend_version) - old_helpers.update_individual_test_results( - old_db[coll[0]], - coll[1], - submod, - backend, - test_fn, - res, - backend_version, - frontend_version, - device, - ) + try: + if priority_flag: + print("Updating Priority DB") + old_helpers.update_individual_test_results( + old_db_priority[coll[0]], + coll[1], + submod, + backend, + test_fn, + res, + "latest-stable", + frontend_version, + device, + ) + else: + print(backend_version) + old_helpers.update_individual_test_results( + old_db[coll[0]], + coll[1], + submod, + backend, + test_fn, + res, + backend_version, + frontend_version, + device, + ) + except WriteError: + print("Old DB Write Error") # skip updating db for instance methods as of now # run transpilation tests if the test passed @@ -222,16 +226,19 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): print(f"\n{'*' * 100}") print(f"{line[:-1]} --> transpilation tests") print(f"{'*' * 100}\n") - sys.stdout.flush() command = f"{command} --num-examples 5 --with-transpile" - os.system("docker cp test-container:/ivy/report.json .") + sys.stdout.flush() + os.system(command) + os.system( + "docker cp test-container:/ivy/report.json" + f" {__file__[: __file__.rfind(os.sep)]}/report.json" + ) # load data from report if generated report_path = os.path.join( __file__[: __file__.rfind(os.sep)], "report.json" ) report_content = {} - print(f"REPORT FILE FOUND : {os.path.exists(report_path)}") if os.path.exists(report_path): report_content = json.load(open(report_path)) @@ -282,8 +289,6 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): # populate the ci_dashboard db, skip instance methods if function_name: id = test_info.pop("_id") - print(f"ID : {id}") - print(f"TEST INFO : {test_info}") print( collection.update_one({"_id": id}, {"$set": test_info}, upsert=True) ) From e3a40257bc6a1313839341a0d22afd407d70d574 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 26 Oct 2023 10:31:46 +0000 Subject: [PATCH 034/978] fix: Adds @with_unsupported_dtypes to torch's avg_pool2d and fixes a bug in the jax backend that was causing wrong dtype to be returned --- ivy/functional/backends/jax/experimental/layers.py | 2 +- .../frontends/torch/nn/functional/pooling_functions.py | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 122598cd4cfb3..9cf76fa39757d 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -149,7 +149,7 @@ def general_pool( # if dtype is not set here, jax casts it to float64 inputs = jnp.array(inputs, dtype=jnp.float32) if not ivy.is_array(init): - init = jnp.array(init, dtype=jnp.float32) + init = jnp.array(init, dtype=inputs.dtype) promoted_type = jnp.promote_types(inputs.dtype, init.dtype) inputs = inputs.astype(promoted_type) init = init.astype(promoted_type) diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 040b005b68131..75454ec07d2aa 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -114,6 +114,10 @@ def avg_pool1d( ) +@with_unsupported_dtypes( + {"2.1.0 and below": ("float16",)}, + "torch", +) @to_ivy_arrays_and_back def avg_pool2d( input, From fab2db2318465ccd4d5e54083118c824fca589f1 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 26 Oct 2023 16:07:32 +0530 Subject: [PATCH 035/978] fix: issue with intelligent tests on PRs (#27128) Tested out the intelligent tests pr on a sample branch which seems to capture the tests correctly --- .github/workflows/intelligent-tests-pr.yml | 24 +++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index 9f3137fd4463c..cdb53c7954bd7 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -66,7 +66,7 @@ jobs: edit-mode: replace run_tests: - runs-on: ubuntu-latest + runs-on: ubuntu-20.04 strategy: fail-fast: false matrix: @@ -93,20 +93,34 @@ jobs: submodules: "recursive" fetch-depth: 100 + - name: Install ivy and fetch binaries + run: | + cd ivy + pip3 install -e . + mkdir .ivy + touch .ivy/key.pem + echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem + cd .. + + - name: Get Job URL + uses: Tiryoh/gha-jobid-action@v0 + id: jobs + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + job_name: ${{ github.job }} + - name: Determine and Run Tests id: tests run: | - git clone -b master${{ matrix.branch }} https://github.com/unifyai/Mapping.git --depth 200 + git clone -b master${{ matrix.branch }} https://github.com/unifyai/Mapping.git --depth 1 pip install pydriller GitPython python ivy/scripts/setup_tests/clone-mapping.py cp Mapping/tests.pbz2 ivy/ cd ivy - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem python scripts/determine_tests/determine_tests.py ${{ matrix.branch }} pr set -o pipefail python scripts/run_tests/run_tests_pr.py new_failures_${{ matrix.branch }}.txt | tee test_results_${{ matrix.branch }}.txt + cd .. continue-on-error: true - name: Upload test results From 0df77fac02df2b8495baf8dca3c25c53ce830016 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 26 Oct 2023 10:52:58 +0000 Subject: [PATCH 036/978] fix: Adds @with_unsupported_dtypes to torch's min --- ivy/functional/frontends/torch/reduction_ops.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index ea414e1e233a0..6e9aca464b8ed 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -162,6 +162,10 @@ def median(input, dim=None, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back +@with_unsupported_dtypes( + {"2.1.0 and below": ("complex64", "complex128")}, + "torch", +) def min(*input, dim=None, keepdim=False, out=None): if len(input) == 1: input = input[0] From ab17a44af3aae587762798ea6d873625178be927 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 26 Oct 2023 16:28:07 +0530 Subject: [PATCH 037/978] chore(ci): reverted changes to intelligent-tests-pr.yml (#27130) until the issue with determining tests on PRs is fixed --- .github/workflows/intelligent-tests-pr.yml | 35 ++-------------------- 1 file changed, 2 insertions(+), 33 deletions(-) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index cdb53c7954bd7..54a72ca61d903 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -1,12 +1,10 @@ name: intelligent-tests-pr on: workflow_dispatch: - pull_request_target: - types: [labeled, opened, synchronize, reopened, review_requested] + pull_request: permissions: actions: read - pull-requests: write jobs: display_test_results: @@ -26,44 +24,15 @@ jobs: cat combined_test_results.txt - name: New Failures Introduced - id: ci_output run: | find . -name "new_failures_*.txt" -exec cat {} + > combined_failures.txt if [ -s combined_failures.txt ] then echo "This PR introduces the following new failing tests:" cat combined_failures.txt - { - echo 'MESSAGE<> "$GITHUB_OUTPUT" else - echo "MESSAGE=This pull request does not result in any additional test failures. Congratulations!" >> "$GITHUB_OUTPUT" + echo "This PR does not introduce any new test failures! Yippee!" fi - - name: Find Comment - uses: peter-evans/find-comment@v2 - id: fc - with: - issue-number: ${{ github.event.pull_request.number }} - comment-author: 'github-actions[bot]' - body-includes: - - - name: Create or update comment - uses: peter-evans/create-or-update-comment@v3 - with: - comment-id: ${{ steps.fc.outputs.comment-id }} - issue-number: ${{ github.event.pull_request.number }} - body: | - Thank you for this PR, here is the CI results: - - ------------- - ${{ steps.ci_output.outputs.MESSAGE}} - - - edit-mode: replace run_tests: runs-on: ubuntu-20.04 From 41052c0798427877d078294145015ce6710c569f Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 26 Oct 2023 11:42:32 +0000 Subject: [PATCH 038/978] fix: Remove new_kernel variable from the arrays_for_pooling strategy. new_kernel was used for calculating the max padding values leading to invalid padding errors in the torch ground truth --- .../test_ivy/helpers/hypothesis_helpers/array_helpers.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py index 0c639012590e8..51a5dbcf99f8a 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py @@ -1790,22 +1790,18 @@ def arrays_for_pooling( ) if array_dim == 3: kernel = draw(st.tuples(st.integers(1, in_shape[1]))) - new_kernel = kernel if return_dilation: - new_kernel = [] dilations = [] for i in range(len(kernel)): if kernel[i] > 1: max_dilation = (in_shape[i + 1] - kernel[i]) // (kernel[i] - 1) + 1 dilations.append(draw(st.integers(1, max_dilation))) - new_kernel.append(kernel[i] + (kernel[i] - 1) * (dilations[i] - 1)) else: dilations.append(1) - new_kernel.append(kernel[i]) if explicit_or_str_padding or only_explicit_padding: padding = [] for i in range(array_dim - 2): - max_pad = new_kernel[i] // 2 + max_pad = kernel[i] // 2 padding.append( draw( st.tuples( From 7ec30f10ac243bb0a08f7ca9293f76c46124b44a Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 26 Oct 2023 12:45:11 +0000 Subject: [PATCH 039/978] fix: Update the interpolate helper to include the full supported range of scale factors while avoiding "RuntimeError: Input and output sizes should be greater than 0" --- .../test_experimental/test_nn/test_layers.py | 28 +++++++------------ 1 file changed, 10 insertions(+), 18 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 81eec1e5f3bf0..6349d46273437 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -131,33 +131,25 @@ def _interp_args(draw, mode=None, mode_list=None): ) ) if draw(st.booleans()): - scale_factor = draw( - st.one_of( - helpers.lists( - x=helpers.floats( - min_value=1.0, max_value=2.0, mixed_fn_compos=mixed_fn_compos - ), - min_size=num_dims - 2, - max_size=num_dims - 2, - ), - helpers.floats( - min_value=1.0, max_value=2.0, mixed_fn_compos=mixed_fn_compos - ), + if draw(st.booleans()): + scale_factor = draw( + st.floats(min_value=max([1 / d for d in x[0].shape[2:]]), max_value=3) ) - ) + else: + scale_factor = [] + for s in x[0].shape[2:]: + scale_factor += [draw(st.floats(min_value=1 / s, max_value=3))] recompute_scale_factor = draw(st.booleans()) size = None else: size = draw( st.one_of( - helpers.lists( - x=helpers.ints( - min_value=1, max_value=3, mixed_fn_compos=mixed_fn_compos - ), + st.lists( + st.integers(min_value=1, max_value=3 * max(x[0].shape)), min_size=num_dims - 2, max_size=num_dims - 2, ), - st.integers(min_value=1, max_value=3), + st.integers(min_value=1, max_value=3 * max(x[0].shape)), ) ) recompute_scale_factor = False From 3792dd2abbd8ca477c7c160493768f05b67f03f3 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 26 Oct 2023 12:53:23 +0000 Subject: [PATCH 040/978] refactor: Shorten the code that converts scalar scale factor to list in ivy.interpolate --- .../backends/jax/experimental/layers.py | 2 +- .../tensorflow/experimental/layers.py | 2 +- ivy/functional/ivy/experimental/layers.py | 20 +++++-------------- 3 files changed, 7 insertions(+), 17 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 9cf76fa39757d..b21543463cf02 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -703,7 +703,7 @@ def interpolate( out: Optional[JaxArray] = None, ): dims = len(x.shape) - 2 - size = _get_size(scale_factor, size, dims, x.shape) + size, _ = _get_size(scale_factor, size, dims, x.shape) mode = ( "nearest" if mode == "nearest-exact" diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 00bd0e8fed60c..71afe3b9a3347 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -893,7 +893,7 @@ def interpolate( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ): dims = len(x.shape) - 2 - size = _get_size(scale_factor, size, dims, x.shape) + size, _ = _get_size(scale_factor, size, dims, x.shape) remove_dim = False if mode in ["linear", "tf_area", "lanczos3", "lanczos5", "nearest-exact"]: if dims == 1: diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 2b8a3e9102014..e8b801edd2b01 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1849,21 +1849,11 @@ def interpolate( """ input_shape = ivy.shape(x) dims = len(input_shape) - 2 - size = _get_size(scale_factor, size, dims, x.shape) + size, scale_factor = _get_size(scale_factor, size, dims, x.shape) if recompute_scale_factor: - scale_factor = None - elif scale_factor is not None: - scale_factor = ( - [scale_factor] * dims - if isinstance(scale_factor, (int, float)) - else scale_factor - ) - scale_factor = ( - [scale_factor[0]] * dims - if isinstance(scale_factor, (list, tuple)) and len(scale_factor) != dims - else scale_factor - ) - scale = [ivy.divide(size[i], input_shape[i + 2]) for i in range(dims)] + scale = [ivy.divide(size[i], input_shape[i + 2]) for i in range(dims)] + else: + scale = [1] * dims if mode in [ "linear", "bilinear", @@ -1996,7 +1986,7 @@ def _get_size(scale_factor, size, dims, x_shape): ) else: size = (size,) * dims if isinstance(size, int) else tuple(size) - return size + return size, scale_factor def _output_ceil_shape(w, f, p, s): From 70e0a0fcac7f04b6185feaeaf75885c0385b4d23 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 26 Oct 2023 15:08:31 +0000 Subject: [PATCH 041/978] refactor: Added missing modes to interpolate tests and docstrings and fixed the naming for consistency --- docs/overview/deep_dive/superset_behaviour.rst | 2 +- ivy/functional/backends/jax/experimental/layers.py | 4 ++-- ivy/functional/backends/mxnet/experimental/layers.py | 4 +++- .../backends/tensorflow/experimental/layers.py | 7 ++++--- ivy/functional/backends/torch/experimental/layers.py | 4 +++- ivy/functional/frontends/tensorflow/image/cropping.py | 2 +- ivy/functional/ivy/experimental/layers.py | 6 +++--- .../test_paddle/test_nn/test_functional/test_common.py | 8 ++++---- .../test_experimental/test_nn/test_layers.py | 9 +++++---- 9 files changed, 26 insertions(+), 20 deletions(-) diff --git a/docs/overview/deep_dive/superset_behaviour.rst b/docs/overview/deep_dive/superset_behaviour.rst index 8a68e61eed23d..6ccccad5696f6 100644 --- a/docs/overview/deep_dive/superset_behaviour.rst +++ b/docs/overview/deep_dive/superset_behaviour.rst @@ -241,7 +241,7 @@ Ivy allows this using the `partial_mixed_handler`_ attribute on the backend-spec interpolate.partial_mixed_handler = lambda *args, mode="linear", **kwargs: mode not in [ "tf_area", - "bicubic_tensorflow", + "tf_bicubic", "mitchellcubic", "lanczos3", "lanczos5", diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index b21543463cf02..27295c83de76a 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -689,7 +689,7 @@ def interpolate( "area", "nearest_exact", "tf_area", - "bicubic_tensorflow", + "tf_bicubic", "bicubic", "mitchellcubic", "lanczos3", @@ -707,7 +707,7 @@ def interpolate( mode = ( "nearest" if mode == "nearest-exact" - else "bicubic" if mode == "bicubic_tensorflow" else mode + else "bicubic" if mode == "tf_bicubic" else mode ) size = [x.shape[0], *size, x.shape[1]] diff --git a/ivy/functional/backends/mxnet/experimental/layers.py b/ivy/functional/backends/mxnet/experimental/layers.py index 40ca4c4cec935..1d5cf6924d89d 100644 --- a/ivy/functional/backends/mxnet/experimental/layers.py +++ b/ivy/functional/backends/mxnet/experimental/layers.py @@ -214,11 +214,13 @@ def interpolate( "linear", "bilinear", "trilinear", + "nd", "nearest", "area", "nearest_exact", "tf_area", - "bicubic_tensorflow" "bicubic", + "tf_bicubic", + "bicubic", "mitchellcubic", "lanczos3", "lanczos5", diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 71afe3b9a3347..2eee64ff456d0 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -875,12 +875,13 @@ def interpolate( "linear", "bilinear", "trilinear", + "nd", "nearest", "area", - "nearest-exact", + "nearest_exact", "tf_area", + "tf_bicubic", "bicubic", - "bicubic_tensorflow", "mitchellcubic", "lanczos3", "lanczos5", @@ -910,7 +911,7 @@ def interpolate( else "nearest" if mode == "nearest-exact" else mode ) ) - if mode == "bicubic_tensorflow": + if mode == "tf_bicubic": mode = "bicubic" x = tf.transpose(x, (0, *range(2, dims + 2), 1)) ret = tf.transpose( diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 19a2dfd3d8b61..78dc7f72461b1 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -893,10 +893,12 @@ def interpolate( "linear", "bilinear", "trilinear", + "nd", "nearest", "area", "nearest_exact", "tf_area", + "tf_bicubic", "bicubic", "mitchellcubic", "lanczos3", @@ -923,7 +925,7 @@ def interpolate( interpolate.partial_mixed_handler = lambda *args, mode="linear", **kwargs: mode not in [ "tf_area", "nd", - "bicubic_tensorflow", + "tf_bicubic", "mitchellcubic", "lanczos3", "lanczos5", diff --git a/ivy/functional/frontends/tensorflow/image/cropping.py b/ivy/functional/frontends/tensorflow/image/cropping.py index a74f637fb91ca..f7d71422bfc45 100644 --- a/ivy/functional/frontends/tensorflow/image/cropping.py +++ b/ivy/functional/frontends/tensorflow/image/cropping.py @@ -46,7 +46,7 @@ def resize( else: new_height, new_width = size if method == "bicubic": - method = "bicubic_tensorflow" + method = "tf_bicubic" elif method == "area": method = "tf_area" image = ivy.interpolate( diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index e8b801edd2b01..a84618301bf90 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1726,7 +1726,7 @@ def area_interpolate(x, dims, size, scale): def get_interpolate_kernel(mode): kernel_func = _triangle_kernel - if mode == "bicubic_tensorflow": + if mode == "tf_bicubic": kernel_func = lambda inputs: _cubic_kernel(inputs) elif mode == "lanczos3": kernel_func = lambda inputs: _lanczos_kernel(3, inputs) @@ -1788,7 +1788,7 @@ def interpolate( "area", "nearest_exact", "tf_area", - "bicubic_tensorflow", + "tf_bicubic", "bicubic", "mitchellcubic", "lanczos3", @@ -1859,7 +1859,7 @@ def interpolate( "bilinear", "trilinear", "nd", - "bicubic_tensorflow", + "tf_bicubic", "lanczos3", "lanczos5", ]: diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py index 72596838f7e33..f020caefc0d57 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py @@ -34,7 +34,7 @@ def _interp_args(draw, mode=None, mode_list=None): "trilinear", "nearest-exact", "tf_area", - "bicubic_tensorflow", + "tf_bicubic", "lanczos3", "lanczos5", "mitchellcubic", @@ -46,7 +46,7 @@ def _interp_args(draw, mode=None, mode_list=None): "bilinear", "trilinear", "nearest-exact", - "bicubic_tensorflow", + "tf_bicubic", "lanczos3", "lanczos5", ] @@ -69,7 +69,7 @@ def _interp_args(draw, mode=None, mode_list=None): "nearest-exact", "area", "tf_area", - "bicubic_tensorflow", + "tf_bicubic", "lanczos3", "lanczos5", "mitchellcubic", @@ -86,7 +86,7 @@ def _interp_args(draw, mode=None, mode_list=None): num_dims = 3 elif mode in [ "bilinear", - "bicubic_tensorflow", + "tf_bicubic", "bicubic", "mitchellcubic", "gaussian", diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 6349d46273437..088badfb1e0a4 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -31,6 +31,7 @@ def _interp_args(draw, mode=None, mode_list=None): "nearest", "nearest-exact", "area", + "bicubic", ] tf_modes = [ @@ -39,7 +40,7 @@ def _interp_args(draw, mode=None, mode_list=None): "trilinear", "nearest-exact", "tf_area", - "bicubic_tensorflow", + "tf_bicubic", "lanczos3", "lanczos5", "mitchellcubic", @@ -51,7 +52,7 @@ def _interp_args(draw, mode=None, mode_list=None): "bilinear", "trilinear", "nearest-exact", - "bicubic_tensorflow", + "tf_bicubic", "lanczos3", "lanczos5", ] @@ -74,7 +75,7 @@ def _interp_args(draw, mode=None, mode_list=None): "nearest-exact", "area", "tf_area", - "bicubic_tensorflow", + "tf_bicubic", "lanczos3", "lanczos5", "mitchellcubic", @@ -91,7 +92,7 @@ def _interp_args(draw, mode=None, mode_list=None): num_dims = 3 elif mode in [ "bilinear", - "bicubic_tensorflow", + "tf_bicubic", "bicubic", "mitchellcubic", "gaussian", From 4ab487821fa2722b443be69e43284faffe7b1dd8 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 26 Oct 2023 15:43:32 +0000 Subject: [PATCH 042/978] fix: Add extra condition to get_item.partial_mixed_handler of the tensorflow backend to filter out queries that contain arrays of different shapes --- ivy/functional/backends/tensorflow/general.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 3d017fc9b01b5..7f398216b74f0 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -66,6 +66,7 @@ def get_item( get_item.partial_mixed_handler = lambda x, query, **kwargs: ( all(_check_query(i) for i in query) + and len(set(i.shape for i in query if ivy.is_array(i))) == 1 if isinstance(query, tuple) else _check_query(query) ) From e5778ef373c7a2a674b41abdbae4b806993c9db9 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Thu, 26 Oct 2023 21:31:56 +0300 Subject: [PATCH 043/978] fix: ensure correct device placement in backend `asarray` implementations --- ivy/functional/backends/jax/creation.py | 12 +++++++----- ivy/functional/backends/paddle/creation.py | 19 ++++++++++++++----- .../backends/tensorflow/creation.py | 14 ++++++-------- 3 files changed, 27 insertions(+), 18 deletions(-) diff --git a/ivy/functional/backends/jax/creation.py b/ivy/functional/backends/jax/creation.py index 2193134e18c23..141ae904b2a1d 100644 --- a/ivy/functional/backends/jax/creation.py +++ b/ivy/functional/backends/jax/creation.py @@ -73,11 +73,13 @@ def asarray( out: Optional[JaxArray] = None, ) -> JaxArray: ivy.utils.assertions._check_jax_x64_flag(dtype) - obj = jax.device_put(obj, device=device) - if copy is True: - return jnp.array(obj, dtype=dtype, copy=True) - else: - return jnp.asarray(obj, dtype=dtype) + ret = jnp.asarray(obj, dtype=dtype) + # jnp.copy is used to ensure correct device placement + # it's slower than jax.device_put before JIT, but it's necessary to use since + # jax device objects aren't serializable and prevent saving transpiled graphs + # this workaround only works because we are inside jax.default_device context + # invoked in @handle_device decorator + return jnp.copy(ret) if (ret.device != device or copy) else ret def empty( diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index c6922d3690032..8df475aef6155 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -95,15 +95,24 @@ def asarray( ret = obj.clone().detach() ret.stop_gradient = obj.stop_gradient else: - ret = obj + ret = paddle.to_tensor( + obj.detach(), + dtype=dtype, + place=device, + stop_gradient=obj.stop_gradient, + ) else: ret = obj - return ret.astype(dtype) + ret = ret.astype(dtype) if ret.dtype != obj.dtype else ret + return paddle_backend.to_device(ret, device) elif isinstance(obj, (Number, bool, complex)): - return paddle_backend.squeeze( - paddle.to_tensor(obj, dtype=dtype, place=device), axis=0 - ) + ret = paddle.to_tensor(obj, dtype=dtype, place=device) + + if ret.ndim != 0: # for versions <2.5.0 + return ret.squeeze() + else: + return ret obj = ivy.nested_map(_remove_np_bfloat16, obj, shallow=False) return paddle.to_tensor(obj, dtype=dtype, place=device) diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py index 348389832befb..2928cbfc5671e 100644 --- a/ivy/functional/backends/tensorflow/creation.py +++ b/ivy/functional/backends/tensorflow/creation.py @@ -90,14 +90,12 @@ def asarray( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: # convert the input to a tensor using the appropriate function - try: - ret = tf.convert_to_tensor(obj, dtype) - except (TypeError, ValueError): - obj = ( - obj if isinstance(obj, tf.Tensor) else tf.convert_to_tensor(obj, tf.float64) - ) - ret = tf.cast(obj, dtype) - return tf.identity(ret) if copy else ret + with tf.device(device): + if tf.is_tensor(obj): + ret = tf.cast(obj, dtype) if obj.dtype != dtype else obj + else: + ret = tf.convert_to_tensor(obj, dtype) + return tf.identity(ret) if (copy or ret.device != device) else ret def empty( From 7b21d3eade94febcb5cc51f7639936f8bac9cb41 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Thu, 26 Oct 2023 21:38:25 +0300 Subject: [PATCH 044/978] fix: remove unnecessary numpy backend device placement calls --- ivy/functional/backends/numpy/creation.py | 34 ++++++-------- ivy/functional/backends/numpy/device.py | 45 +++++-------------- .../backends/numpy/experimental/creation.py | 5 +-- ivy/functional/backends/numpy/general.py | 9 ++-- 4 files changed, 31 insertions(+), 62 deletions(-) diff --git a/ivy/functional/backends/numpy/creation.py b/ivy/functional/backends/numpy/creation.py index 1e7ad6d3aaa0d..eb6533ac1d039 100644 --- a/ivy/functional/backends/numpy/creation.py +++ b/ivy/functional/backends/numpy/creation.py @@ -6,7 +6,6 @@ # local import ivy -from ivy.functional.backends.numpy.device import _to_device from ivy.functional.ivy.creation import ( _asarray_to_native_arrays_and_back, _asarray_infer_device, @@ -35,7 +34,7 @@ def arange( ) -> np.ndarray: if dtype: dtype = as_native_dtype(dtype) - res = _to_device(np.arange(start, stop, step, dtype=dtype), device=device) + res = np.arange(start, stop, step, dtype=dtype) if not dtype: if res.dtype == np.float64: return res.astype(np.float32) @@ -60,7 +59,7 @@ def asarray( device: str = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: - ret = _to_device(np.asarray(obj, dtype=dtype), device=device) + ret = np.asarray(obj, dtype=dtype) return np.copy(ret) if copy else ret @@ -71,7 +70,7 @@ def empty( device: str = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: - return _to_device(np.empty(shape, dtype), device=device) + return np.empty(shape, dtype) def empty_like( @@ -82,7 +81,7 @@ def empty_like( device: str = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: - return _to_device(np.empty_like(x, dtype=dtype), device=device) + return np.empty_like(x, dtype=dtype) def eye( @@ -100,12 +99,12 @@ def eye( n_cols = n_rows i = np.eye(n_rows, n_cols, k, dtype) if batch_shape is None: - return _to_device(i, device=device) + return i else: reshape_dims = [1] * len(batch_shape) + [n_rows, n_cols] tile_dims = list(batch_shape) + [1, 1] return_mat = np.tile(np.reshape(i, reshape_dims), tile_dims) - return _to_device(return_mat, device=device) + return return_mat def to_dlpack(x, /, *, out: Optional[np.ndarray] = None): @@ -125,10 +124,7 @@ def full( out: Optional[np.ndarray] = None, ) -> np.ndarray: dtype = ivy.default_dtype(dtype=dtype, item=fill_value, as_native=True) - return _to_device( - np.full(shape, fill_value, dtype), - device=device, - ) + return np.full(shape, fill_value, dtype) def full_like( @@ -140,7 +136,7 @@ def full_like( device: str = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: - return _to_device(np.full_like(x, fill_value, dtype=dtype), device=device) + return np.full_like(x, fill_value, dtype=dtype) def linspace( @@ -165,7 +161,7 @@ def linspace( and (not isinstance(stop, np.ndarray)) ): ans[0] = start - return _to_device(ans, device=device) + return ans def meshgrid( @@ -184,7 +180,7 @@ def ones( device: str = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: - return _to_device(np.ones(shape, dtype), device=device) + return np.ones(shape, dtype) def ones_like( @@ -195,7 +191,7 @@ def ones_like( device: str = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: - return _to_device(np.ones_like(x, dtype=dtype), device=device) + return np.ones_like(x, dtype=dtype) def tril( @@ -217,7 +213,7 @@ def zeros( device: str = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: - return _to_device(np.zeros(shape, dtype), device=device) + return np.zeros(shape, dtype) def zeros_like( @@ -228,7 +224,7 @@ def zeros_like( device: str = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: - return _to_device(np.zeros_like(x, dtype=dtype), device=device) + return np.zeros_like(x, dtype=dtype) # Extra # @@ -304,6 +300,4 @@ def triu_indices( *, device: str = None, ) -> Tuple[np.ndarray]: - return tuple( - _to_device(np.asarray(np.triu_indices(n=n_rows, k=k, m=n_cols)), device=device) - ) + return tuple(np.asarray(np.triu_indices(n=n_rows, k=k, m=n_cols))) diff --git a/ivy/functional/backends/numpy/device.py b/ivy/functional/backends/numpy/device.py index 54eb13e61dc46..995280edffbca 100644 --- a/ivy/functional/backends/numpy/device.py +++ b/ivy/functional/backends/numpy/device.py @@ -18,11 +18,21 @@ def dev(x: np.ndarray, /, *, as_native: bool = False) -> Union[ivy.Device, str]: def as_ivy_dev(device: str, /): - return ivy.Device("cpu") + if "gpu" in device: + raise ivy.utils.exceptions.IvyException( + "Native Numpy does not support GPU placement, consider using Jax instead" + ) + elif "cpu" in device: + return ivy.Device("cpu") def as_native_dev(device: str, /): - return "cpu" + if "gpu" in device: + raise ivy.utils.exceptions.IvyException( + "Native Numpy does not support GPU placement, consider using Jax instead" + ) + elif "cpu" in device: + return "cpu" def clear_cached_mem_on_dev(device: str, /): @@ -41,25 +51,6 @@ def gpu_is_available() -> bool: return False -# private version of to_device to be used in backend implementations -def _to_device(x: np.ndarray, device=None) -> np.ndarray: - """Private version of `to_device` to be used in backend implementations.""" - if device is not None: - if "gpu" in device: - raise ivy.utils.exceptions.IvyException( - "Native Numpy does not support GPU placement, " - "consider using Jax instead" - ) - elif "cpu" in device: - pass - else: - raise ivy.utils.exceptions.IvyException( - "Invalid device specified, must be in the form [ 'cpu:idx' | 'gpu:idx'" - f" ], but found {device}" - ) - return x - - def to_device( x: np.ndarray, device: str, @@ -70,18 +61,6 @@ def to_device( ) -> np.ndarray: if device is not None: device = as_native_dev(device) - if "gpu" in device: - raise ivy.utils.exceptions.IvyException( - "Native Numpy does not support GPU placement, " - "consider using Jax instead" - ) - elif "cpu" in device: - pass - else: - raise ivy.utils.exceptions.IvyException( - "Invalid device specified, must be in the form [ 'cpu:idx' | 'gpu:idx'" - f" ], but found {device}" - ) return x diff --git a/ivy/functional/backends/numpy/experimental/creation.py b/ivy/functional/backends/numpy/experimental/creation.py index 1a8d604ef6d94..6916cb31ef88f 100644 --- a/ivy/functional/backends/numpy/experimental/creation.py +++ b/ivy/functional/backends/numpy/experimental/creation.py @@ -4,7 +4,6 @@ import numpy as np # local -from ivy.functional.backends.numpy.device import _to_device import ivy # Array API Standard # @@ -35,9 +34,7 @@ def tril_indices( *, device: str = None, ) -> Tuple[np.ndarray, ...]: - return tuple( - _to_device(np.asarray(np.tril_indices(n=n_rows, k=k, m=n_cols)), device=device) - ) + return tuple(np.asarray(np.tril_indices(n=n_rows, k=k, m=n_cols))) def hann_window( diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index d0b0e8ce8b3cd..b984c8ab8dec8 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -10,7 +10,6 @@ # local import ivy -from ivy.functional.backends.numpy.device import _to_device from ivy.functional.backends.numpy.helpers import _scalar_output_to_0d_array from ivy.func_wrapper import with_unsupported_dtypes from . import backend_version @@ -101,7 +100,7 @@ def gather( result.append(r) result = np.array(result) result = result.reshape([*params.shape[0:batch_dims], *result.shape[1:]]) - return _to_device(result) + return result def gather_nd_helper(params, indices): @@ -162,7 +161,7 @@ def gather_nd( result.append(r) result = np.array(result) result = result.reshape([*params.shape[0:batch_dims], *result.shape[1:]]) - return _to_device(result) + return result def get_num_dims(x, /, *, as_array=False): @@ -330,8 +329,8 @@ def scatter_nd( ' "mul" or "replace"' ) if ivy.exists(out): - return ivy.inplace_update(out, _to_device(target)) - return _to_device(target) + return ivy.inplace_update(out, target) + return target scatter_nd.support_native_out = True From 2d33dbb03bf6f095beae44504b6998da3f65625e Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Thu, 26 Oct 2023 22:03:29 +0300 Subject: [PATCH 045/978] fix: fix typo in 40b27d8 --- ivy/functional/backends/paddle/device.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/device.py b/ivy/functional/backends/paddle/device.py index 3d732ec9ee9af..0270ccd9d1d5b 100644 --- a/ivy/functional/backends/paddle/device.py +++ b/ivy/functional/backends/paddle/device.py @@ -37,7 +37,7 @@ def to_device( elif (device.is_gpu_place() and not x.place.is_gpu_place()) or ( x.place.is_gpu_place() and device.is_gpu_place() - and x.gpu_device_id() != device.gpu_device_id() + and x.place.gpu_device_id() != device.gpu_device_id() ): return x.cuda(device.gpu_device_id()) else: From 992cd253b1a0e06cef2d83d705b477ff55651da9 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Thu, 26 Oct 2023 22:56:47 +0300 Subject: [PATCH 046/978] fix: fix paddle backend `einsum` for multiple dtype operands --- ivy/functional/backends/paddle/elementwise.py | 2 +- ivy/functional/backends/paddle/statistical.py | 14 +++++++++++--- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 208e28495572a..bb8eddb8be644 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -13,7 +13,7 @@ def _elementwise_helper(x1, x2): - if (not hasattr(x1, "dtype") or not hasattr(x2, "dtype")) or (x1.dtype == x2.dtype): + if (not hasattr(x1, "dtype") or not hasattr(x2, "dtype")) or (x1.dtype != x2.dtype): x1, x2 = ivy.promote_types_of_inputs(x1, x2) if x1.shape != x2.shape: x1, x2 = paddle_backend.broadcast_arrays(x1, x2) diff --git a/ivy/functional/backends/paddle/statistical.py b/ivy/functional/backends/paddle/statistical.py index 791eaefee92cc..84cd7c0c38776 100644 --- a/ivy/functional/backends/paddle/statistical.py +++ b/ivy/functional/backends/paddle/statistical.py @@ -13,7 +13,6 @@ ) import ivy.functional.backends.paddle as paddle_backend from ivy.utils.einsum_parser import legalise_einsum_expr -from ivy.functional.ivy.statistical import _get_promoted_type_of_operands # local from . import backend_version @@ -329,6 +328,15 @@ def einsum( *operands: paddle.Tensor, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: - dtype = _get_promoted_type_of_operands(operands) equation = legalise_einsum_expr(*[equation, *operands]) - return paddle.einsum(equation, *operands).astype(dtype) + + dtype_list = set(map(lambda x: x.dtype, operands)) + dtype = dtype_list.pop() + if len(dtype_list) > 0: + for d in dtype_list: + dtype = ivy.promote_types(dtype, d) + operands = list( + map(lambda x: x.cast(dtype) if x.dtype != dtype else x, operands) + ) + + return paddle.einsum(equation, *operands) From ba0a940864ebb37b90bc8ca2c61e4af389b4b908 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 27 Oct 2023 02:02:21 +0530 Subject: [PATCH 047/978] fix: Remove `re-imports` present in few files. (#26937) Co-authored-by: hmahmood24 --- ivy/engines/XLA/__init__.py | 1 - .../backends/paddle/experimental/__init__.py | 1 - ivy/functional/frontends/numpy/__init__.py | 2 -- ivy/functional/frontends/tensorflow/__init__.py | 2 +- .../test_jax/test_numpy/test_statistical.py | 13 ++++++------- .../test_indexing_slicing_joining_mutating_ops.py | 3 --- 6 files changed, 7 insertions(+), 15 deletions(-) diff --git a/ivy/engines/XLA/__init__.py b/ivy/engines/XLA/__init__.py index 45a9584091f50..f5b736bcb5bec 100644 --- a/ivy/engines/XLA/__init__.py +++ b/ivy/engines/XLA/__init__.py @@ -7,7 +7,6 @@ # from .rust_api.python_frontend.sequential_handler import * from .rust_api.python_frontend.general import * -from .rust_api.python_frontend.manipulation import * from .rust_api.python_frontend.creation import * from .rust_api.python_frontend.linear_algebra import * from .rust_api.python_frontend.elementwise import * diff --git a/ivy/functional/backends/paddle/experimental/__init__.py b/ivy/functional/backends/paddle/experimental/__init__.py index d50ca9bf1c253..b85b671859139 100644 --- a/ivy/functional/backends/paddle/experimental/__init__.py +++ b/ivy/functional/backends/paddle/experimental/__init__.py @@ -14,7 +14,6 @@ from .layers import * from .losses import * from .linear_algebra import * -from .losses import * from .manipulation import * from .norms import * from .random import * diff --git a/ivy/functional/frontends/numpy/__init__.py b/ivy/functional/frontends/numpy/__init__.py index a5edf2ebfe971..9ec0d91d489aa 100644 --- a/ivy/functional/frontends/numpy/__init__.py +++ b/ivy/functional/frontends/numpy/__init__.py @@ -495,7 +495,6 @@ def promote_types_of_numpy_inputs( from . import ma from . import fft -from . import random from .ufunc import ufunc from . import linalg @@ -551,7 +550,6 @@ def promote_types_of_numpy_inputs( _reciprocal, _subtract, _divmod, - _remainder, ) from ivy.functional.frontends.numpy.mathematical_functions.trigonometric_functions import ( # noqa diff --git a/ivy/functional/frontends/tensorflow/__init__.py b/ivy/functional/frontends/tensorflow/__init__.py index 80ca1cf42b93f..8f41d31818161 100644 --- a/ivy/functional/frontends/tensorflow/__init__.py +++ b/ivy/functional/frontends/tensorflow/__init__.py @@ -84,7 +84,7 @@ def check_tensorflow_casting(x1, x2): from . import dtypes -from .dtypes import DType, as_dtype, cast +from .dtypes import as_dtype, cast from . import ragged from .ragged import * from . import tensor diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py index f9d2b610355a5..28d6388d2af2c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py @@ -5,7 +5,6 @@ # local import ivy -import ivy_tests.test_ivy.test_frontends.test_numpy.helpers as np_frontend_helpers import ivy_tests.test_ivy.helpers as helpers import ivy_tests.test_ivy.test_frontends.test_numpy.helpers as np_helpers from ivy_tests.test_ivy.helpers import handle_frontend_test @@ -106,7 +105,7 @@ def _get_castable_dtypes_values(draw, *, allow_nan=False, use_where=False): helpers.get_castable_dtype(draw(available_dtypes), dtype[0], values[0]) ) if use_where: - where = draw(np_frontend_helpers.where(shape=shape)) + where = draw(np_helpers.where(shape=shape)) return [dtype1], [values], axis, dtype2, where return [dtype1], [values], axis, dtype2 @@ -811,7 +810,7 @@ def test_jax_nancumsum( input_dtypes, x, axis, dtype = dtype_and_x_axis_dtype if ivy.current_backend_str() == "torch": assume(not test_flags.as_variable[0]) - np_frontend_helpers.test_frontend_function( + np_helpers.test_frontend_function( input_dtypes=input_dtypes, backend_to_test=backend_fw, frontend=frontend, @@ -1014,7 +1013,7 @@ def test_jax_nanmin( fn_tree="jax.numpy.nanstd", dtype_and_a=_statistical_dtype_values(function="nanstd"), dtype=helpers.get_dtypes("float", full=False, none=True), - where=np_frontend_helpers.where(), + where=np_helpers.where(), keep_dims=st.booleans(), ) def test_jax_nanstd( @@ -1031,13 +1030,13 @@ def test_jax_nanstd( input_dtypes, a, axis, correction = dtype_and_a if isinstance(axis, tuple): axis = axis[0] - where, input_dtypes, test_flags = np_frontend_helpers.handle_where_and_array_bools( + where, input_dtypes, test_flags = np_helpers.handle_where_and_array_bools( where=where, input_dtype=input_dtypes, test_flags=test_flags, ) assume(np.dtype(dtype[0]) >= np.dtype(input_dtypes[0])) - np_frontend_helpers.test_frontend_function( + np_helpers.test_frontend_function( input_dtypes=input_dtypes, backend_to_test=backend_fw, frontend=frontend, @@ -1124,7 +1123,7 @@ def test_jax_ptp( keep_dims, ): input_dtypes, x, axis, dtype = dtype_and_x_axis_dtype - np_frontend_helpers.test_frontend_function( + np_helpers.test_frontend_function( input_dtypes=input_dtypes, backend_to_test=backend_fw, frontend=frontend, diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py index 79667f0ab42fb..f08400ec8e6c3 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py @@ -11,9 +11,6 @@ import ivy_tests.test_ivy.helpers.globals as test_globals from ivy_tests.test_ivy.helpers import handle_frontend_test from ivy_tests.test_ivy.test_functional.test_core.test_manipulation import _get_splits -from ivy_tests.test_ivy.test_functional.test_core.test_manipulation import ( # noqa - _get_splits, -) from ivy_tests.array_api_testing.test_array_api.array_api_tests import ( hypothesis_helpers as hh, ) From 4801d9d0362fe0e6ad4af793bbbd2baa9511f8a3 Mon Sep 17 00:00:00 2001 From: HPatto <139283897+HPatto@users.noreply.github.com> Date: Thu, 26 Oct 2023 20:46:50 +0000 Subject: [PATCH 048/978] feat: Implementation of inv function in Paddle frontend. (#26979) Co-authored-by: hmahmood24 --- ivy/functional/frontends/paddle/math.py | 6 +++ .../test_frontends/test_paddle/test_math.py | 41 +++++++++++++++++++ 2 files changed, 47 insertions(+) diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index 29aefc5ca5d8f..a519a4798a449 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -325,6 +325,12 @@ def inner(x, y, name=None): return result +@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@to_ivy_arrays_and_back +def inverse(x, name=None): + return ivy.inv(x) + + @with_supported_dtypes( {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py index cd7c7541fed6c..21ed49947fc08 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py @@ -1,6 +1,8 @@ # global from hypothesis import strategies as st import hypothesis.extra.numpy as nph +import numpy as np +import sys # local import ivy_tests.test_ivy.helpers as helpers @@ -1322,6 +1324,45 @@ def test_paddle_inner( ) +# inverse +@handle_frontend_test( + fn_tree="paddle.inverse", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + min_value=-100.0, + max_value=100.0, + shape=helpers.ints(min_value=2, max_value=10).map(lambda x: tuple([x, x])), + ).filter( + lambda x: "float16" not in x[0] + and "bfloat16" not in x[0] + and np.linalg.det(np.asarray(x[1][0])) != 0 + and np.linalg.cond(x[1][0]) < 1 / sys.float_info.epsilon + ), + test_with_out=st.just(False), +) +def test_paddle_inverse( + *, + dtype_and_x, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + dtype, x = dtype_and_x + helpers.test_frontend_function( + input_dtypes=dtype, + backend_to_test=backend_fw, + rtol=1e-01, + atol=1e-01, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x=x[0], + ) + + # isfinite @handle_frontend_test( fn_tree="paddle.isfinite", From 659b9ce3e6e4aabae85b82bb59c21c924ab8a967 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 27 Oct 2023 09:04:17 +0530 Subject: [PATCH 049/978] fix(ci): Added missing event types for pull_request in intelligent-tests-pr.yml --- .github/workflows/intelligent-tests-pr.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index 54a72ca61d903..6dacacca4f6f3 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -2,6 +2,7 @@ name: intelligent-tests-pr on: workflow_dispatch: pull_request: + types: [labeled, opened, synchronize, reopened, review_requested] permissions: actions: read From f57535e39c4eeb9336d3fe71903e7b598cb06899 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 27 Oct 2023 09:28:09 +0530 Subject: [PATCH 050/978] =?UTF-8?q?Revert=20"fix:=20Ivy=20doesn't=20suppor?= =?UTF-8?q?t=20complex32=20natively=20so=20we'=20to=20raise=20exception?= =?UTF-8?q?=E2=80=A6"=20(#27142)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/backends/torch/data_type.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index 29dba78a4ba20..901acc1e5b19d 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -15,16 +15,10 @@ torch.int32: "int32", torch.int64: "int64", torch.uint8: "uint8", - torch.qint8: "qint8", - torch.qint32: "qint32", - torch.quint8: "quint8", - torch.quint2x4: "quint2x4", - torch.quint4x2: "quint4x2", torch.bfloat16: "bfloat16", torch.float16: "float16", torch.float32: "float32", torch.float64: "float64", - torch.complex32: "complex32", torch.complex64: "complex64", torch.complex128: "complex128", torch.bool: "bool", From f3a044457586b63e0367afe02ca182f8d5c0278b Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 27 Oct 2023 09:46:35 +0530 Subject: [PATCH 051/978] fix: Fixed missing mandatory keyword argument `backend_to_test` in function calls (#27133) Co-authored-by: vedpatwardhan --- .../test_jax/test_lax/test_operators.py | 2 +- .../test_mindspore/test_numpy.py | 2 ++ .../test_function/test_mindspore_nn_func.py | 16 ++++++++++++++++ .../test_ops/test_mindspore_nn_func.py | 2 ++ .../test_onnx/test_elementwise.py | 10 ++++++++++ .../test_frontends/test_paddle/test_stat.py | 2 ++ .../test_pandas/test_dataframe.py | 4 ++++ .../test_frontends/test_pandas/test_series.py | 2 ++ .../test_functional/test_loss_functions.py | 2 ++ .../test_frontends/test_torch/test_tensor.py | 4 ++++ ivy_tests/test_ivy/test_misc/test_shape.py | 3 +++ .../test_ivy/test_stateful/test_activations.py | 18 ++++++++++++++++++ .../test_ivy/test_stateful/test_losses.py | 7 +++++++ 13 files changed, 73 insertions(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py index b04d2ec3604f1..a77cb042f578f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py @@ -1748,7 +1748,7 @@ def test_jax_expand_dims( helpers.test_frontend_function( input_dtypes=x_dtype, frontend=frontend, - bakcend_to_test=backend_fw, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_numpy.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_numpy.py index a68b14562c81a..1cad3008612ce 100644 --- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_numpy.py +++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_numpy.py @@ -26,6 +26,7 @@ def test_mindspore_array( dtype_and_a, frontend, + backend_fw, test_flags, fn_tree, on_device, @@ -36,6 +37,7 @@ def test_mindspore_array( helpers.test_frontend_function( input_dtypes=dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py index f0d1ebd6caf1f..bcde9284d6eae 100644 --- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py +++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py @@ -189,6 +189,7 @@ def test_mindspore_adaptive_avg_pool2d( output_size, test_flags, frontend, + backend_fw, on_device, fn_tree, ): @@ -196,6 +197,7 @@ def test_mindspore_adaptive_avg_pool2d( helpers.test_frontend_function( input_dtypes=input_dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, on_device=on_device, fn_tree=fn_tree, @@ -389,12 +391,14 @@ def test_mindspore_dropout2d( on_device, fn_tree, frontend, + backend_fw, test_flags, ): dtype, x = d_type_and_x helpers.test_frontend_function( input_dtypes=dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, @@ -433,12 +437,14 @@ def test_mindspore_dropout3d( on_device, fn_tree, frontend, + backend_fw, test_flags, ): dtype, x = d_type_and_x helpers.test_frontend_function( input_dtypes=dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, @@ -461,6 +467,7 @@ def test_mindspore_fast_gelu( *, test_flags, frontend, + backend_fw, on_device, fn_tree, ): @@ -469,6 +476,7 @@ def test_mindspore_fast_gelu( helpers.test_frontend_function( input_dtypes=input_dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, @@ -551,6 +559,7 @@ def test_mindspore_interpolate( align_corners, recompute_scale_factor, on_device, + backend_fw, fn_tree, frontend, test_flags, @@ -562,6 +571,7 @@ def test_mindspore_interpolate( helpers.test_frontend_function( input_dtypes=dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, @@ -604,11 +614,13 @@ def test_mindspore_kl_div( on_device, fn_tree, frontend, + backend_fw, test_flags, ): helpers.test_frontend_function( input_dtypes=p[0], frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, @@ -740,11 +752,13 @@ def test_mindspore_pad( on_device, fn_tree, frontend, + backend_fw, test_flags, ): helpers.test_frontend_function( input_dtypes=input[0], frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, @@ -771,12 +785,14 @@ def test_mindspore_selu( on_device, fn_tree, frontend, + backend_fw, test_flags, ): input_dtype, x = dtype_and_x helpers.test_frontend_function( input_dtypes=input_dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_mindspore_nn_func.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_mindspore_nn_func.py index 555b62c8665b6..e0fc11644ad71 100644 --- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_mindspore_nn_func.py +++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_mindspore_nn_func.py @@ -22,12 +22,14 @@ def test_mindspore_softsign( on_device, fn_tree, frontend, + backend_fw, test_flags, ): input_dtype, x = dtype_and_x helpers.test_frontend_function( input_dtypes=input_dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, diff --git a/ivy_tests/test_ivy/test_frontends/test_onnx/test_elementwise.py b/ivy_tests/test_ivy/test_frontends/test_onnx/test_elementwise.py index 50cf23e71c94d..0f997b69770f1 100644 --- a/ivy_tests/test_ivy/test_frontends/test_onnx/test_elementwise.py +++ b/ivy_tests/test_ivy/test_frontends/test_onnx/test_elementwise.py @@ -28,12 +28,14 @@ def test_onnx_abs( on_device, fn_tree, frontend, + backend_fw, test_flags, ): input_dtype, x = dtype_and_x helpers.test_frontend_function( input_dtypes=input_dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, @@ -81,10 +83,12 @@ def test_onnx_acos( on_device, fn_tree, frontend, + backend_fw, test_flags, ): input_dtype, x = dtype_and_x helpers.test_frontend_function( + backend_to_test=backend_fw, input_dtypes=input_dtype, frontend=frontend, test_flags=test_flags, @@ -131,10 +135,12 @@ def test_onnx_acosh( on_device, fn_tree, frontend, + backend_fw, test_flags, ): input_dtype, x = dtype_and_x helpers.test_frontend_function( + backend_to_test=backend_fw, input_dtypes=input_dtype, frontend=frontend, test_flags=test_flags, @@ -187,12 +193,14 @@ def test_onnx_add( on_device, fn_tree, frontend, + backend_fw, test_flags, ): input_dtype, x = dtype_and_x helpers.test_frontend_function( input_dtypes=input_dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, @@ -246,12 +254,14 @@ def test_onnx_asin( on_device, fn_tree, frontend, + backend_fw, test_flags, ): input_dtype, x = dtype_and_x helpers.test_frontend_function( input_dtypes=input_dtype, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py index a7b41e0baf820..f8ccfc5b7ac2c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py @@ -86,6 +86,7 @@ def test_paddle_nanmedian( dtype_x_and_axis, keepdim, frontend, + backend_fw, test_flags, fn_tree, ): @@ -93,6 +94,7 @@ def test_paddle_nanmedian( helpers.test_frontend_function( input_dtypes=input_dtypes, frontend=frontend, + backend_to_test=backend_fw, test_flags=test_flags, fn_tree=fn_tree, x=x[0], diff --git a/ivy_tests/test_ivy/test_frontends/test_pandas/test_dataframe.py b/ivy_tests/test_ivy/test_frontends/test_pandas/test_dataframe.py index 074137130b30e..cd079b2375f49 100644 --- a/ivy_tests/test_ivy/test_frontends/test_pandas/test_dataframe.py +++ b/ivy_tests/test_ivy/test_frontends/test_pandas/test_dataframe.py @@ -24,6 +24,7 @@ def test_pandas_series_abs( frontend_method_data, init_flags, method_flags, + backend_fw, on_device, ): # todo add castable dtypes for output @@ -39,6 +40,7 @@ def test_pandas_series_abs( init_flags=init_flags, method_flags=method_flags, frontend=frontend, + backend_to_test=backend_fw, on_device=on_device, ) @@ -138,6 +140,7 @@ def test_pandas_series_to_numpy( na_values, copy, frontend_method_data, + backend_fw, init_flags, method_flags, on_device, @@ -157,5 +160,6 @@ def test_pandas_series_to_numpy( init_flags=init_flags, method_flags=method_flags, frontend=frontend, + backend_to_test=backend_fw, on_device=on_device, ) diff --git a/ivy_tests/test_ivy/test_frontends/test_pandas/test_series.py b/ivy_tests/test_ivy/test_frontends/test_pandas/test_series.py index 796045cb93a76..bbb520bb280b3 100644 --- a/ivy_tests/test_ivy/test_frontends/test_pandas/test_series.py +++ b/ivy_tests/test_ivy/test_frontends/test_pandas/test_series.py @@ -21,6 +21,7 @@ def test_pandas_series_abs( dtype_x, frontend, + backend_fw, frontend_method_data, init_flags, method_flags, @@ -38,6 +39,7 @@ def test_pandas_series_abs( init_flags=init_flags, method_flags=method_flags, frontend=frontend, + backend_to_test=backend_fw, on_device=on_device, ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_loss_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_loss_functions.py index 7ced14b897bc6..13abfcfcee803 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_loss_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_loss_functions.py @@ -685,11 +685,13 @@ def test_torch_multilabel_margin_loss( reduce, test_flags, fn_tree, + backend_fw, frontend, on_device, ): input_dtype, x = dtype_and_inputs helpers.test_frontend_function( + backend_to_test=backend_fw, input_dtypes=input_dtype, frontend=frontend, test_flags=test_flags, diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 5df66a195de9a..f004102fc0a14 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -2618,11 +2618,13 @@ def test_torch_angle( init_flags, method_flags, on_device, + backend_fw, ): input_dtype, values = dtype_and_values helpers.test_frontend_method( init_input_dtypes=input_dtype, + backend_to_test=backend_fw, init_all_as_kwargs_np={ "data": values[0], }, @@ -3983,10 +3985,12 @@ def test_torch_baddbmm_( init_flags, method_flags, on_device, + backend_fw, ): input_dtype, x, batch1, batch2 = dtype_and_matrices helpers.test_frontend_method( init_input_dtypes=input_dtype, + backend_to_test=backend_fw, init_all_as_kwargs_np={"data": x[0]}, method_input_dtypes=input_dtype, method_all_as_kwargs_np={ diff --git a/ivy_tests/test_ivy/test_misc/test_shape.py b/ivy_tests/test_ivy/test_misc/test_shape.py index 8c6a2b730339f..f20c34bb3a386 100644 --- a/ivy_tests/test_ivy/test_misc/test_shape.py +++ b/ivy_tests/test_ivy/test_misc/test_shape.py @@ -448,6 +448,7 @@ def test_shape__mul__( helpers.test_method( on_device=on_device, ground_truth_backend=ground_truth_backend, + backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, init_all_as_kwargs_np={"data": x[0]}, @@ -588,6 +589,7 @@ def test_shape__rmul__( method_name, class_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, @@ -596,6 +598,7 @@ def test_shape__rmul__( helpers.test_method( on_device=on_device, ground_truth_backend=ground_truth_backend, + backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, init_all_as_kwargs_np={"data": x[0]}, diff --git a/ivy_tests/test_ivy/test_stateful/test_activations.py b/ivy_tests/test_ivy/test_stateful/test_activations.py index 638aaee6fbe80..6a1892b165c6f 100644 --- a/ivy_tests/test_ivy/test_stateful/test_activations.py +++ b/ivy_tests/test_ivy/test_stateful/test_activations.py @@ -32,12 +32,14 @@ def test_elu( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -167,12 +169,14 @@ def test_hardswish( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -307,12 +311,14 @@ def test_logit( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -351,12 +357,14 @@ def test_logsigmoid( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -437,12 +445,14 @@ def test_prelu( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -521,12 +531,14 @@ def test_relu6( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -563,12 +575,14 @@ def test_selu( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -605,12 +619,14 @@ def test_sigmoid( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -781,12 +797,14 @@ def test_tanh( class_name, method_name, ground_truth_backend, + backend_fw, init_flags, method_flags, on_device, ): input_dtype, x = dtype_and_x helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, diff --git a/ivy_tests/test_ivy/test_stateful/test_losses.py b/ivy_tests/test_ivy/test_stateful/test_losses.py index c8efbe04c1295..2849ab86f7989 100644 --- a/ivy_tests/test_ivy/test_stateful/test_losses.py +++ b/ivy_tests/test_ivy/test_stateful/test_losses.py @@ -58,6 +58,7 @@ def test_binary_cross_entropy_loss( dtype_and_true, dtype_and_pred, dtype_and_pos, + backend_fw, from_logits, reduction, axis, @@ -75,6 +76,7 @@ def test_binary_cross_entropy_loss( if from_logits: helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -98,6 +100,7 @@ def test_binary_cross_entropy_loss( ) else: helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -158,6 +161,7 @@ def test_cross_entropy_loss( axis, reduction, class_name, + backend_fw, method_name, ground_truth_backend, init_flags, @@ -167,6 +171,7 @@ def test_cross_entropy_loss( targets_dtype, targets = dtype_and_targets log_input_dtype, log_input = dtype_and_log_input helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, @@ -224,6 +229,7 @@ def test_log_poisson_loss( axis, reduction, class_name, + backend_fw, method_name, ground_truth_backend, init_flags, @@ -233,6 +239,7 @@ def test_log_poisson_loss( targets_dtype, targets = dtype_and_targets log_input_dtype, log_input = dtype_and_log_input helpers.test_method( + backend_to_test=backend_fw, ground_truth_backend=ground_truth_backend, init_flags=init_flags, method_flags=method_flags, From 86c3a75dc9cbacd912cff4dbbc278361c72d5aec Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 27 Oct 2023 09:48:02 +0530 Subject: [PATCH 052/978] fix: Fixed few missing mandatory `key-word arguments` (#27139) Co-authored-by: vedpatwardhan --- ivy/functional/backends/paddle/creation.py | 5 ++++- ivy/functional/backends/torch/creation.py | 2 +- .../test_frontends/test_numpy/test_ndarray/test_ndarray.py | 1 + ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py | 2 ++ 4 files changed, 8 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index 8df475aef6155..b2270f6b1d63e 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -272,7 +272,10 @@ def _linspace_helper(start, stop, num, axis=None, *, dtype=None): sos_shape = stop_shape if num == 1: return ( - paddle_backend.ones(stop_shape[:axis] + [1] + stop_shape[axis:]) * start + paddle_backend.ones( + stop_shape[:axis] + [1] + stop_shape[axis:], dtype=dtype + ) + * start ) stop = stop.reshape((-1,)) linspace_method = ( diff --git a/ivy/functional/backends/torch/creation.py b/ivy/functional/backends/torch/creation.py index 14b059758a1c8..ea34478abeaa8 100644 --- a/ivy/functional/backends/torch/creation.py +++ b/ivy/functional/backends/torch/creation.py @@ -477,7 +477,7 @@ def ones_like_v_0p1p12_to_0p2p0( x[i] = 1 return x for i in range(x.shape[0]): - x[i, :] = ones_like_v_0p1p12_to_0p2p0(x[i, :]) + x[i, :] = ones_like_v_0p1p12_to_0p2p0(x[i, :], dtype=dtype) return x diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py index 303078151fede..f19d5968df2aa 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py @@ -2703,6 +2703,7 @@ def test_numpy_instance_ilshift__( init_all_as_kwargs_np={ "object": x[0], }, + method_input_dtypes=input_dtypes, backend_to_test=backend_fw, method_all_as_kwargs_np={ "value": x[1], diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index f004102fc0a14..3bde53fc3167c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -4023,6 +4023,7 @@ def test_torch_bernoulli( frontend_method_data, init_flags, method_flags, + on_device, backend_fw, ): input_dtype, x = dtype_and_x @@ -4038,6 +4039,7 @@ def test_torch_bernoulli( init_flags=init_flags, method_flags=method_flags, frontend=frontend, + on_device=on_device, ) From 298bfcd1e6979b196780535d1f0232d7745db21c Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 27 Oct 2023 10:02:02 +0530 Subject: [PATCH 053/978] fix(ci): set the max examples for the array api det coverage to 5 (#27143) As the determine coverage workflow times out after 6 hours and the default max examples is 100 --- scripts/determine_tests/array_api_det_coverage.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/scripts/determine_tests/array_api_det_coverage.py b/scripts/determine_tests/array_api_det_coverage.py index e68ec5d3aa582..53288a3e4586f 100644 --- a/scripts/determine_tests/array_api_det_coverage.py +++ b/scripts/determine_tests/array_api_det_coverage.py @@ -79,7 +79,14 @@ def main(): directories = set(directories_filtered) for test_backend in tqdm(test_names): test_name, backend = test_backend.split(",") - command = f'docker run --rm --env IVY_BACKEND={backend} --env ARRAY_API_TESTS_MODULE="ivy" -v "$(pwd)":/ivy unifyai/ivy:latest timeout 30m /bin/bash -c "coverage run --source=ivy,ivy_tests -m pytest {test_name} -k \\"{k_flag[backend]}\\" --disable-warnings --tb=short -vv > coverage_output;coverage annotate > coverage_output" ' # noqa + command = ( + f"docker run --rm --env IVY_BACKEND={backend} --env " + 'ARRAY_API_TESTS_MODULE="ivy" -v "$(pwd)":/ivy unifyai/ivy:latest ' + 'timeout 30m /bin/bash -c "coverage run --source=ivy,ivy_tests -m pytest ' + f'{test_name} -k \\"{k_flag[backend]}\\" --disable-warnings --tb=short ' + "--max-examples 5 -vv > coverage_output;coverage annotate > " + 'coverage_output"' + ) os.system(command) for directory in directories: for file_name in os.listdir(directory): From b12958dd31686261e2d778a51470322a128f3634 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 27 Oct 2023 11:35:08 +0530 Subject: [PATCH 054/978] fix: updated ubuntu version in some workflows from ubuntu 20 to ubuntu latest (#27145) --- .github/workflows/dockerfile-image.yml | 2 +- .github/workflows/dockerfile-push.yml | 2 +- .github/workflows/intelligent-tests-pr.yml | 2 +- .github/workflows/intelligent-tests.yml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/dockerfile-image.yml b/.github/workflows/dockerfile-image.yml index 9c5be23f40475..3f82ea05ea63c 100644 --- a/.github/workflows/dockerfile-image.yml +++ b/.github/workflows/dockerfile-image.yml @@ -11,7 +11,7 @@ jobs: build: if: ${{(github.event_name == 'push') || contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') || contains(github.event.pull_request.labels.*.name, 'Build Docker Files')}} - runs-on: ubuntu-20.04 + runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 diff --git a/.github/workflows/dockerfile-push.yml b/.github/workflows/dockerfile-push.yml index 06be15ea1e427..3a4e9959b6847 100644 --- a/.github/workflows/dockerfile-push.yml +++ b/.github/workflows/dockerfile-push.yml @@ -10,7 +10,7 @@ jobs: build: - runs-on: ubuntu-20.04 + runs-on: ubuntu-latest steps: - diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index 6dacacca4f6f3..fa294f12f12fc 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -36,7 +36,7 @@ jobs: fi run_tests: - runs-on: ubuntu-20.04 + runs-on: ubuntu-latest strategy: fail-fast: false matrix: diff --git a/.github/workflows/intelligent-tests.yml b/.github/workflows/intelligent-tests.yml index a9215fbbacf9b..261cd5fd1014f 100644 --- a/.github/workflows/intelligent-tests.yml +++ b/.github/workflows/intelligent-tests.yml @@ -24,7 +24,7 @@ jobs: cat combined_test_results.txt run_tests: - runs-on: ubuntu-20.04 + runs-on: ubuntu-latest strategy: fail-fast: false matrix: From cf06f23901fb572d7ccf8867b32df901eeadc4c7 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 27 Oct 2023 14:50:53 +0530 Subject: [PATCH 055/978] fix: replaced max-examples by hypothesis-max-examples as max-examples wasn't having any effect on the timeout --- scripts/determine_tests/array_api_det_coverage.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/determine_tests/array_api_det_coverage.py b/scripts/determine_tests/array_api_det_coverage.py index 53288a3e4586f..b17b4775fd7cf 100644 --- a/scripts/determine_tests/array_api_det_coverage.py +++ b/scripts/determine_tests/array_api_det_coverage.py @@ -84,7 +84,7 @@ def main(): 'ARRAY_API_TESTS_MODULE="ivy" -v "$(pwd)":/ivy unifyai/ivy:latest ' 'timeout 30m /bin/bash -c "coverage run --source=ivy,ivy_tests -m pytest ' f'{test_name} -k \\"{k_flag[backend]}\\" --disable-warnings --tb=short ' - "--max-examples 5 -vv > coverage_output;coverage annotate > " + "--hypothesis-max-examples 5 -vv > coverage_output;coverage annotate > " 'coverage_output"' ) os.system(command) From 9a45fda0ceced55603607fb44d759743a9548b4e Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Fri, 27 Oct 2023 11:53:35 +0100 Subject: [PATCH 056/978] fix: bug causing jax to make array copies on every asarray call (#27148) --- ivy/functional/backends/jax/creation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/creation.py b/ivy/functional/backends/jax/creation.py index 141ae904b2a1d..ee7cba4e854e0 100644 --- a/ivy/functional/backends/jax/creation.py +++ b/ivy/functional/backends/jax/creation.py @@ -79,7 +79,7 @@ def asarray( # jax device objects aren't serializable and prevent saving transpiled graphs # this workaround only works because we are inside jax.default_device context # invoked in @handle_device decorator - return jnp.copy(ret) if (ret.device != device or copy) else ret + return jnp.copy(ret) if (ret.device() != device or copy) else ret def empty( From d1a65e43d0e4f3f0d7b2ef9665164e3aa5e951fd Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 27 Oct 2023 12:27:20 +0000 Subject: [PATCH 057/978] fix(torch-frontend): Add missing @with_unsupported_dtypes --- ivy/functional/frontends/torch/comparison_ops.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index e4bb1e4b2382c..f1f6a9a815c11 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -98,12 +98,14 @@ def fmin(input, other, *, out=None): ) +@with_unsupported_dtypes({"2.1.0 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def greater(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.greater(input, other, out=out) +@with_unsupported_dtypes({"2.1.0 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def greater_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -239,12 +241,14 @@ def kthvalue(input, k, dim=-1, keepdim=False, *, out=None): return ret +@with_unsupported_dtypes({"2.1.0 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def less(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.less(input, other, out=out) +@with_unsupported_dtypes({"2.1.0 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def less_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -292,7 +296,7 @@ def topk(input, k, dim=None, largest=True, sorted=True, *, out=None): gt = greater +ne = not_equal ge = greater_equal le = less_equal lt = less -ne = not_equal From e5619552a160946aa15085bd67f5916512c1065b Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 27 Oct 2023 12:30:12 +0000 Subject: [PATCH 058/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/frontends/torch/comparison_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index f1f6a9a815c11..1f9241ab37948 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -296,7 +296,7 @@ def topk(input, k, dim=None, largest=True, sorted=True, *, out=None): gt = greater -ne = not_equal ge = greater_equal le = less_equal lt = less +ne = not_equal From 456f3b29cbb4fdf77ac270766f1b0021c78f64f7 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 27 Oct 2023 12:30:17 +0000 Subject: [PATCH 059/978] fix(torch-frontend): Limit the asarray and astype calls --- ivy/functional/frontends/torch/__init__.py | 25 +++++++++++----------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index f2a0bb1260a2f..0052993309e65 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -231,17 +231,14 @@ def promote_types_of_torch_inputs( used as inputs only for those functions that expect an array-like or tensor-like objects, otherwise it might give unexpected results. """ - # Ignore type of 0-dim arrays to mimic torch - x1_copy = x1 - x2_copy = x2 - x1 = ivy.asarray(x1) - x2 = ivy.asarray(x2) - if x1.shape == () and ivy.isscalar(x1_copy): - if ivy.is_int_dtype(x1): - x1 = ivy.astype(x1, "int64") - if x2.shape == () and ivy.isscalar(x2_copy): - if ivy.is_int_dtype(x2): - x2 = ivy.astype(x2, "int64") + if ivy.isscalar(x1) and ivy.is_int_dtype(x1): + x1 = ivy.asarray(x1, dtype="int64") + elif ivy.isscalar(x1): + x1 = ivy.asarray(x1) + if ivy.isscalar(x2) and ivy.is_int_dtype(x2): + x2 = ivy.asarray(x2, dtype="int64") + elif ivy.isscalar(x2): + x2 = ivy.asarray(x2) type1 = ivy.default_dtype(item=x1).strip("u123456789") type2 = ivy.default_dtype(item=x2).strip("u123456789") if not x1.shape == () and x2.shape == () and type1 == type2: @@ -254,8 +251,10 @@ def promote_types_of_torch_inputs( ) elif x1.dtype != x2.dtype: promoted = promote_types_torch(x1.dtype, x2.dtype) - x1 = ivy.asarray(x1, dtype=promoted) - x2 = ivy.asarray(x2, dtype=promoted) + if x1.dtype != promoted: + x1 = x1.astype(promoted) + if x2.dtype != promoted: + x2 = x2.astype(promoted) return x1, x2 From 3720e202feda86e3763d4f614c88ddafc4e114ea Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 27 Oct 2023 18:53:37 +0530 Subject: [PATCH 060/978] fix(ivy): updated the jax cuda version to be 11.8 and fixed an issue with dynamic backend setting (#27149) As jax and torch can't be used together with cuda 12.1, and fixed an issue with dynamic backend setting to retain the initial backend device in the target backend --- docker/gpu_framework_directory.py | 2 +- ivy/utils/backend/handler.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docker/gpu_framework_directory.py b/docker/gpu_framework_directory.py index 9ff00d59353b2..e4e185475ea85 100644 --- a/docker/gpu_framework_directory.py +++ b/docker/gpu_framework_directory.py @@ -45,7 +45,7 @@ def install_pkg(path, pkg, base="fw/"): ) elif pkg.split("==")[0] if "==" in pkg else pkg == "jax": subprocess.run( - f"yes |pip install --upgrade --target {path} 'jax[cuda12_pip]' -f" + f"yes |pip install --upgrade --target {path} 'jax[cuda11_pip]' -f" " https://storage.googleapis.com/jax-releases/jax_cuda_releases.html " " --no-cache-dir", shell=True, diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 72bbf8a79013e..d45679a793fe7 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -327,7 +327,7 @@ def convert_from_numpy_to_target_backend(variable_ids, numpy_objs, devices): # check if object was originally a variable if id(obj) in variable_ids: native_arr = ivy.nested_map( - lambda x: current_backend().asarray(x, device=device), + lambda x: ivy.asarray(x, device=device), np_arr, include_derived=True, shallow=False, @@ -336,7 +336,7 @@ def convert_from_numpy_to_target_backend(variable_ids, numpy_objs, devices): else: new_data = ivy.nested_map( - lambda x: current_backend().asarray(x, device=device), + lambda x: ivy.asarray(x, device=device), np_arr, include_derived=True, shallow=False, From 3d2bc7a8b92ab4d5c7ede4a72fd816bfb8397683 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 27 Oct 2023 15:25:25 +0000 Subject: [PATCH 061/978] fix(ivy): Shorten simple interpolate case. Should return the input array directly if the new size is same as the original --- ivy/functional/backends/jax/experimental/layers.py | 2 ++ ivy/functional/backends/tensorflow/experimental/layers.py | 2 ++ ivy/functional/ivy/experimental/layers.py | 2 ++ 3 files changed, 6 insertions(+) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 27295c83de76a..6ae66a0167f29 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -704,6 +704,8 @@ def interpolate( ): dims = len(x.shape) - 2 size, _ = _get_size(scale_factor, size, dims, x.shape) + if all(a == b for a, b in zip(size, x.shape[2:])): + return x mode = ( "nearest" if mode == "nearest-exact" diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 2eee64ff456d0..ec62cd40e9a79 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -895,6 +895,8 @@ def interpolate( ): dims = len(x.shape) - 2 size, _ = _get_size(scale_factor, size, dims, x.shape) + if all(a == b for a, b in zip(size, x.shape[2:])): + return x remove_dim = False if mode in ["linear", "tf_area", "lanczos3", "lanczos5", "nearest-exact"]: if dims == 1: diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index a84618301bf90..77f16a6a953bb 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1850,6 +1850,8 @@ def interpolate( input_shape = ivy.shape(x) dims = len(input_shape) - 2 size, scale_factor = _get_size(scale_factor, size, dims, x.shape) + if all(a == b for a, b in zip(size, input_shape[2:])): + return x if recompute_scale_factor: scale = [ivy.divide(size[i], input_shape[i + 2]) for i in range(dims)] else: From 431d3b102d0cd9062ab3c7f79dd31835c7b03bdc Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 27 Oct 2023 15:35:30 +0000 Subject: [PATCH 062/978] fix(ivy): Update interpolate to always support `out` --- .../backends/jax/experimental/layers.py | 28 ++- .../tensorflow/experimental/layers.py | 55 +++-- ivy/functional/ivy/experimental/layers.py | 232 +++++++++--------- 3 files changed, 166 insertions(+), 149 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 6ae66a0167f29..1d3debab8559e 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -705,19 +705,23 @@ def interpolate( dims = len(x.shape) - 2 size, _ = _get_size(scale_factor, size, dims, x.shape) if all(a == b for a, b in zip(size, x.shape[2:])): - return x - mode = ( - "nearest" - if mode == "nearest-exact" - else "bicubic" if mode == "tf_bicubic" else mode - ) + ret = x + else: + mode = ( + "nearest" + if mode == "nearest-exact" + else "bicubic" if mode == "tf_bicubic" else mode + ) - size = [x.shape[0], *size, x.shape[1]] - x = jnp.transpose(x, (0, *range(2, dims + 2), 1)) - return jnp.transpose( - jax.image.resize(x, shape=size, method=mode, antialias=antialias), - (0, dims + 1, *range(1, dims + 1)), - ) + size = [x.shape[0], *size, x.shape[1]] + x = jnp.transpose(x, (0, *range(2, dims + 2), 1)) + ret = jnp.transpose( + jax.image.resize(x, shape=size, method=mode, antialias=antialias), + (0, dims + 1, *range(1, dims + 1)), + ) + if ivy.exists(out): + return ivy.inplace_update(out, ret) + return ret interpolate.partial_mixed_handler = lambda *args, mode="linear", scale_factor=None, recompute_scale_factor=None, align_corners=None, **kwargs: ( # noqa: E501 diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index ec62cd40e9a79..cc69a5aa1e2ba 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -896,34 +896,37 @@ def interpolate( dims = len(x.shape) - 2 size, _ = _get_size(scale_factor, size, dims, x.shape) if all(a == b for a, b in zip(size, x.shape[2:])): - return x - remove_dim = False - if mode in ["linear", "tf_area", "lanczos3", "lanczos5", "nearest-exact"]: - if dims == 1: - size = (1,) + tuple(size) - x = tf.expand_dims(x, axis=-2) - dims = 2 - remove_dim = True - mode = ( - "bilinear" - if mode == "linear" - else ( - "area" - if mode == "tf_area" - else "nearest" if mode == "nearest-exact" else mode + ret = x + else: + remove_dim = False + if mode in ["linear", "tf_area", "lanczos3", "lanczos5", "nearest-exact"]: + if dims == 1: + size = (1,) + tuple(size) + x = tf.expand_dims(x, axis=-2) + dims = 2 + remove_dim = True + mode = ( + "bilinear" + if mode == "linear" + else ( + "area" + if mode == "tf_area" + else "nearest" if mode == "nearest-exact" else mode + ) ) + if mode == "tf_bicubic": + mode = "bicubic" + x = tf.transpose(x, (0, *range(2, dims + 2), 1)) + ret = tf.transpose( + tf.cast( + tf.image.resize(x, size=size, method=mode, antialias=antialias), x.dtype + ), + (0, dims + 1, *range(1, dims + 1)), ) - if mode == "tf_bicubic": - mode = "bicubic" - x = tf.transpose(x, (0, *range(2, dims + 2), 1)) - ret = tf.transpose( - tf.cast( - tf.image.resize(x, size=size, method=mode, antialias=antialias), x.dtype - ), - (0, dims + 1, *range(1, dims + 1)), - ) - if remove_dim: - ret = tf.squeeze(ret, axis=-2) + if remove_dim: + ret = tf.squeeze(ret, axis=-2) + if ivy.exists(out): + return ivy.inplace_update(out, ret) return ret diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 77f16a6a953bb..0c7c71e3dbe6e 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1851,120 +1851,130 @@ def interpolate( dims = len(input_shape) - 2 size, scale_factor = _get_size(scale_factor, size, dims, x.shape) if all(a == b for a, b in zip(size, input_shape[2:])): - return x - if recompute_scale_factor: - scale = [ivy.divide(size[i], input_shape[i + 2]) for i in range(dims)] + ret = x else: - scale = [1] * dims - if mode in [ - "linear", - "bilinear", - "trilinear", - "nd", - "tf_bicubic", - "lanczos3", - "lanczos5", - ]: - ret = _interpolate_with_kernel( - x, - dims, - size, - scale, - input_shape, - align_corners, - antialias, - scale_factor, - mode, - ) - elif mode == "bicubic": - return _upsample_bicubic2d_default(x, size, align_corners) - elif mode in ["nearest-exact", "nearest"]: - ret = nearest_interpolate(x, dims, size, input_shape, mode == "nearest-exact") - elif mode == "area": - ret = area_interpolate(x, dims, size, scale) - elif mode == "mitchellcubic": - batch, channels, in_height, in_width = x.shape - out_height, out_width = size - scale_factor_h = out_height / in_height - scale_factor_w = out_width / in_width - ret = ivy.zeros((batch, channels, out_height, out_width)) - for i in range(out_height): - for j in range(out_width): - p_i = i / scale_factor_h - p_j = j / scale_factor_w - left = int(math.floor(p_j - 2)) - right = int(math.ceil(p_j + 2)) - top = int(math.floor(p_i - 2)) - bottom = int(math.ceil(p_i + 2)) - kernel_w = ivy.array( - [ - _mitchellcubic_kernel((p_j - j) / scale_factor_w) - for i in range(left, right) - ] - ) - kernel_h = ivy.array( - [ - _mitchellcubic_kernel((p_i - i) / scale_factor_h) - for j in range(top, bottom) - ] - ) - left_pad = max(0, -left) - right_pad = max(0, right - in_width) - top_pad = max(0, -top) - bottom_pad = max(0, bottom - in_height) - pad_width = [(0, 0), (0, 0)] * (len(x.shape) - 3) + [ - (top_pad, bottom_pad), - (left_pad, right_pad), - ] - padded_x = ivy.pad(x, pad_width, mode="edge") - for b in range(batch): - for c in range(channels): - patch = padded_x[ - b, - c, - top + top_pad : bottom + top_pad, - left + left_pad : right + left_pad, + if recompute_scale_factor: + scale = [ivy.divide(size[i], input_shape[i + 2]) for i in range(dims)] + else: + scale = [1] * dims + if mode in [ + "linear", + "bilinear", + "trilinear", + "nd", + "tf_bicubic", + "lanczos3", + "lanczos5", + ]: + ret = _interpolate_with_kernel( + x, + dims, + size, + scale, + input_shape, + align_corners, + antialias, + scale_factor, + mode, + ) + elif mode == "bicubic": + return _upsample_bicubic2d_default(x, size, align_corners) + elif mode in ["nearest-exact", "nearest"]: + ret = nearest_interpolate( + x, dims, size, input_shape, mode == "nearest-exact" + ) + elif mode == "area": + ret = area_interpolate(x, dims, size, scale) + elif mode == "mitchellcubic": + batch, channels, in_height, in_width = x.shape + out_height, out_width = size + scale_factor_h = out_height / in_height + scale_factor_w = out_width / in_width + ret = ivy.zeros((batch, channels, out_height, out_width)) + for i in range(out_height): + for j in range(out_width): + p_i = i / scale_factor_h + p_j = j / scale_factor_w + left = int(math.floor(p_j - 2)) + right = int(math.ceil(p_j + 2)) + top = int(math.floor(p_i - 2)) + bottom = int(math.ceil(p_i + 2)) + kernel_w = ivy.array( + [ + _mitchellcubic_kernel((p_j - j) / scale_factor_w) + for i in range(left, right) ] - ret[b, c, i, j] = ivy.sum( - kernel_h[:, ivy.newaxis] * patch * kernel_w[ivy.newaxis, :] - ) - elif mode == "gaussian": - ratio_h = size[0] / x.shape[-2] - ratio_w = size[1] / x.shape[-1] - sigma = max(1 / ratio_h, 1 / ratio_w) * 0.5 - kernel_size = 2 * int(math.ceil(3 * sigma)) + 1 - kernel_h = ivy.zeros((kernel_size,), dtype=x.dtype) - kernel_w = ivy.zeros((kernel_size,), dtype=x.dtype) - for i in range(kernel_h.size): - kernel_h[i] = ivy.exp(-0.5 * ((i - kernel_h.size // 2) / sigma) ** 2) - kernel_w[i] = ivy.exp(-0.5 * ((i - kernel_w.size // 2) / sigma) ** 2) - kernel_h /= ivy.sum(kernel_h) - kernel_w /= ivy.sum(kernel_w) - pad_width = [(0, 0), (0, 0)] * (len(x.shape) - 3) + [ - (int(math.ceil(3 * sigma)), int(math.ceil(3 * sigma))), - (int(math.ceil(3 * sigma)), int(math.ceil(3 * sigma))), - ] - padded_x = ivy.pad(x, pad_width, mode="constant") - output_shape = x.shape[:2] + size - ret = ivy.zeros(output_shape, dtype=x.dtype) - for i in range(size[0]): - for j in range(size[1]): - p_i = int(math.floor(i / ratio_h + int(math.ceil(3 * sigma)))) - p_j = int(math.floor(j / ratio_w + int(math.ceil(3 * sigma)))) - for b in range(x.shape[0]): - for c in range(x.shape[1]): - patch = padded_x[ - b, - c, - p_i - kernel_size // 2 : p_i + kernel_size // 2 + 1, - p_j - kernel_size // 2 : p_j + kernel_size // 2 + 1, + ) + kernel_h = ivy.array( + [ + _mitchellcubic_kernel((p_i - i) / scale_factor_h) + for j in range(top, bottom) ] - ret[b, c, i, j] = ivy.sum( - kernel_h[ivy.newaxis, :] * patch * kernel_w[:, ivy.newaxis] - ) - elif mode == "tf_area": - ret = _tf_area_interpolate(x, size, dims) - return ivy.astype(ret, ivy.dtype(x), out=out) + ) + left_pad = max(0, -left) + right_pad = max(0, right - in_width) + top_pad = max(0, -top) + bottom_pad = max(0, bottom - in_height) + pad_width = [(0, 0), (0, 0)] * (len(x.shape) - 3) + [ + (top_pad, bottom_pad), + (left_pad, right_pad), + ] + padded_x = ivy.pad(x, pad_width, mode="edge") + for b in range(batch): + for c in range(channels): + patch = padded_x[ + b, + c, + top + top_pad : bottom + top_pad, + left + left_pad : right + left_pad, + ] + ret[b, c, i, j] = ivy.sum( + kernel_h[:, ivy.newaxis] + * patch + * kernel_w[ivy.newaxis, :] + ) + elif mode == "gaussian": + ratio_h = size[0] / x.shape[-2] + ratio_w = size[1] / x.shape[-1] + sigma = max(1 / ratio_h, 1 / ratio_w) * 0.5 + kernel_size = 2 * int(math.ceil(3 * sigma)) + 1 + kernel_h = ivy.zeros((kernel_size,), dtype=x.dtype) + kernel_w = ivy.zeros((kernel_size,), dtype=x.dtype) + for i in range(kernel_h.size): + kernel_h[i] = ivy.exp(-0.5 * ((i - kernel_h.size // 2) / sigma) ** 2) + kernel_w[i] = ivy.exp(-0.5 * ((i - kernel_w.size // 2) / sigma) ** 2) + kernel_h /= ivy.sum(kernel_h) + kernel_w /= ivy.sum(kernel_w) + pad_width = [(0, 0), (0, 0)] * (len(x.shape) - 3) + [ + (int(math.ceil(3 * sigma)), int(math.ceil(3 * sigma))), + (int(math.ceil(3 * sigma)), int(math.ceil(3 * sigma))), + ] + padded_x = ivy.pad(x, pad_width, mode="constant") + output_shape = x.shape[:2] + size + ret = ivy.zeros(output_shape, dtype=x.dtype) + for i in range(size[0]): + for j in range(size[1]): + p_i = int(math.floor(i / ratio_h + int(math.ceil(3 * sigma)))) + p_j = int(math.floor(j / ratio_w + int(math.ceil(3 * sigma)))) + for b in range(x.shape[0]): + for c in range(x.shape[1]): + patch = padded_x[ + b, + c, + p_i - kernel_size // 2 : p_i + kernel_size // 2 + 1, + p_j - kernel_size // 2 : p_j + kernel_size // 2 + 1, + ] + ret[b, c, i, j] = ivy.sum( + kernel_h[ivy.newaxis, :] + * patch + * kernel_w[:, ivy.newaxis] + ) + elif mode == "tf_area": + ret = _tf_area_interpolate(x, size, dims) + ret = ivy.astype(ret, ivy.dtype(x)) + if ivy.exists(out): + return ivy.inplace_update(out, ret) + return ret interpolate.mixed_backend_wrappers = { From a3e41080c14e153f4062cc7b4932c54eaa020325 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 27 Oct 2023 15:50:22 +0000 Subject: [PATCH 063/978] refactor(ivy): Remove current implementation of `alias` in ivy.interpolate. It had not been tested previously and its results were not correct. --- ivy/functional/ivy/experimental/layers.py | 20 +++++-------------- .../test_experimental/test_nn/test_layers.py | 6 +----- 2 files changed, 6 insertions(+), 20 deletions(-) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 0c7c71e3dbe6e..e1d7fd48e1f60 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1545,20 +1545,14 @@ def _compute_weight_mat( scale, align_corners, kernel_fn, - antialias: bool, dim_scale_factor, ): - inv_scale = 1.0 / scale - kernel_scale = ivy.maximum(inv_scale, 1.0) if antialias else 1.0 if not align_corners: sample_f = (ivy.arange(output_size) + 0.5) * dim_scale_factor - 0.5 else: sample_f = ivy.arange(output_size) * dim_scale_factor - x = ( - ivy.abs( - ivy.expand_dims(sample_f) - ivy.expand_dims(ivy.arange(input_size), axis=-1) - ) - / kernel_scale + x = ivy.abs( + ivy.expand_dims(sample_f) - ivy.expand_dims(ivy.arange(input_size), axis=-1) ) weights = kernel_fn(x) total_weight_sum = ivy.sum(weights, axis=0, keepdims=True) @@ -1746,7 +1740,7 @@ def generate_einsum_equation(dim): def _interpolate_with_kernel( - x, dims, size, scale, input_shape, align_corners, antialias, scale_factor, mode + x, dims, size, scale, input_shape, align_corners, scale_factor, mode ): spatial_dims = [2 + i for i in range(dims)] equation = generate_einsum_equation(dims) @@ -1763,7 +1757,7 @@ def _interpolate_with_kernel( scale_factor[i] if scale_factor is not None else None, ) w = _compute_weight_mat( - m, n, scale[i], align_corners, kernel_func, antialias, dim_scale_factor + m, n, scale[i], align_corners, kernel_func, dim_scale_factor ).astype(x.dtype) operands.append(w) return ivy.einsum(equation, x, *operands) @@ -1798,7 +1792,7 @@ def interpolate( scale_factor: Optional[Union[Sequence[int], int]] = None, recompute_scale_factor: Optional[bool] = None, align_corners: Optional[bool] = None, - antialias: bool = False, + antialias: bool = False, # ToDo: add support for antialias out: Optional[ivy.Array] = None, ) -> ivy.Array: """ @@ -1836,9 +1830,6 @@ def interpolate( out-of-boundary values. only has an effect when mode is 'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: False - antialias - If True, antialiasing is applied when downsampling an image. - Supported modes: 'bilinear', 'bicubic'. out Optional output array, for writing the result to. It must have a shape that the inputs broadcast to. @@ -1873,7 +1864,6 @@ def interpolate( scale, input_shape, align_corners, - antialias, scale_factor, mode, ) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 088badfb1e0a4..b7b270875323c 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -1067,13 +1067,10 @@ def test_ifftn( @handle_test( fn_tree="functional.ivy.experimental.interpolate", dtype_x_mode=_interp_args(), - antialias=st.just(False), test_gradients=st.just(False), number_positional_args=st.just(2), ) -def test_interpolate( - dtype_x_mode, antialias, test_flags, backend_fw, fn_name, on_device -): +def test_interpolate(dtype_x_mode, test_flags, backend_fw, fn_name, on_device): ( input_dtype, x, @@ -1095,7 +1092,6 @@ def test_interpolate( size=size, mode=mode, align_corners=align_corners, - antialias=antialias, scale_factor=scale_factor, recompute_scale_factor=recompute_scale_factor, ) From d5f8484c33eb3ce7eb890e2d828ec78dd9f8e2d5 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 27 Oct 2023 17:31:29 +0000 Subject: [PATCH 064/978] refactor: Add argument checks to ivy.interpolate and update docstring --- .../torch/nn/functional/vision_functions.py | 97 ------------------- ivy/functional/ivy/experimental/layers.py | 77 +++++++++++++++ .../test_experimental/test_nn/test_layers.py | 18 +++- 3 files changed, 91 insertions(+), 101 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index c6cf9d4541cf7..c12079f5a9dd3 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -4,7 +4,6 @@ import ivy from ivy import with_unsupported_dtypes, with_supported_dtypes from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back -from ivy.utils.exceptions import IvyNotImplementedException # --- Helpers --- # @@ -367,101 +366,6 @@ def interpolate( recompute_scale_factor=None, antialias=False, ): - if mode in ["nearest", "area", "nearest-exact"]: - ivy.utils.assertions.check_exists( - align_corners, - inverse=True, - message=( - "align_corners option can only be set with the interpolating modes:" - " linear | bilinear | bicubic | trilinear" - ), - ) - - dim = ivy.get_num_dims(input) - 2 # Number of spatial dimensions. - - if ivy.exists(size) and ivy.exists(scale_factor): - raise ivy.utils.exceptions.IvyException( - "only one of size or scale_factor should be defined" - ) - - elif ivy.exists(size) and not ivy.exists(scale_factor): - if isinstance(size, (list, tuple)): - ivy.utils.assertions.check_equal( - len(size), - dim, - inverse=False, - message=( - "Input and output must have the " - "same number of spatial dimensions," - f" but got input with spatial dimensions of {list(input.shape[2:])}" - f" and output size of {size}. " - "Please provide input tensor in (N, C, d1, d2, ...,dK) format" - " and output size in (o1, o2, ...,oK) format." - ), - as_array=False, - ) - elif ivy.exists(scale_factor) and not ivy.exists(size): - if isinstance(scale_factor, (list, tuple)): - ivy.utils.assertions.check_equal( - len(scale_factor), - dim, - inverse=False, - message=( - "Input and scale_factor must have the " - "same number of spatial dimensions," - f" but got input with spatial dimensions of {list(input.shape[2:])}" - f" and scale_factor of shape {scale_factor}. " - "Please provide input tensor in (N, C, d1, d2, ...,dK) format" - " and scale_factor in (s1, s2, ...,sK) format." - ), - as_array=False, - ) - else: - ivy.utils.assertions.check_any( - [ivy.exists(size), ivy.exists(scale_factor)], - message="either size or scale_factor should be defined", - as_array=False, - ) - - if ( - ivy.exists(size) - and ivy.exists(recompute_scale_factor) - and bool(recompute_scale_factor) - ): - raise ivy.utils.exceptions.IvyException( - "recompute_scale_factor is not meaningful with an explicit size." - ) - - if ( - bool(antialias) - and (mode not in ["bilinear", "bicubic"]) - and ivy.get_num_dims(input) == 4 - ): - raise ivy.utils.exceptions.IvyException( - "recompute_scale_factor is not meaningful with an explicit size." - ) - - if ivy.get_num_dims(input) == 3 and mode == "bilinear": - raise IvyNotImplementedException( - "Got 3D input, but bilinear mode needs 4D input" - ) - if ivy.get_num_dims(input) == 3 and mode == "trilinear": - raise IvyNotImplementedException( - "Got 3D input, but trilinear mode needs 5D input" - ) - if ivy.get_num_dims(input) == 4 and mode == "linear": - raise IvyNotImplementedException("Got 4D input, but linear mode needs 3D input") - if ivy.get_num_dims(input) == 4 and mode == "trilinear": - raise IvyNotImplementedException( - "Got 4D input, but trilinear mode needs 5D input" - ) - if ivy.get_num_dims(input) == 5 and mode == "linear": - raise IvyNotImplementedException("Got 5D input, but linear mode needs 3D input") - if ivy.get_num_dims(input) == 5 and mode == "bilinear": - raise IvyNotImplementedException( - "Got 5D input, but bilinear mode needs 4D input" - ) - ivy.utils.assertions.check_elem_in_list( ivy.get_num_dims(input), range(3, 6), @@ -471,7 +375,6 @@ def interpolate( f" bicubic | trilinear | area | nearest-exact (got {mode})" ), ) - return ivy.interpolate( input, size, diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index e1d7fd48e1f60..e87f42a4b3a09 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1817,12 +1817,18 @@ def interpolate( - area - tf_area - bicubic + - tf_bicubic - mitchellcubic - lanczos3 - lanczos5 - gaussian scale_factor Multiplier for spatial size that defines the output size (overwriting `size`). + recompute_scale_factor + If True, then scale_factor must be provided and scale_factor is used to + compute the output size. The computed output size will be used to infer new + scales for the interpolation. If recompute_scale_factor is False, then size + or scale_factor will be used directly for interpolation. align_corners If True, the corner pixels of the input and output tensors are aligned, and thus preserving the values at the corner pixels. If False, the corner @@ -1840,7 +1846,78 @@ def interpolate( """ input_shape = ivy.shape(x) dims = len(input_shape) - 2 + if ( + mode + not in [ + "linear", + "bilinear", + "trilinear", + "nd", + "tf_bicubic", + "lanczos3", + "lanczos5", + "bicubic", + ] + and align_corners is not None + ): + raise ivy.utils.exceptions.IvyException( + f"align_corners option cannot be set with interpolating mode {mode}" + ) + if ivy.exists(size) and ivy.exists(scale_factor): + raise ivy.utils.exceptions.IvyException( + "only one of size or scale_factor should be defined" + ) + elif ivy.exists(size) and not ivy.exists(scale_factor): + if isinstance(size, (list, tuple)): + ivy.utils.assertions.check_equal( + len(size), + dims, + inverse=False, + message=( + "Input and output must have the same number of spatial dimensions," + f" but got input with {list(x.shape[2:])} spatial dimensions and" + f" output size {size}." + ), + as_array=False, + ) + elif ivy.exists(scale_factor) and not ivy.exists(size): + if isinstance(scale_factor, (list, tuple)): + ivy.utils.assertions.check_equal( + len(scale_factor), + dims, + inverse=False, + message=( + "Input and scale_factor must have the same number of spatial" + f" dimensions, but got input with {list(x.shape[2:])} spatial" + f" dimensions and scale_factor {scale_factor}." + ), + as_array=False, + ) + else: + raise ivy.utils.exceptions.IvyException( + "either size or scale_factor should be defined" + ) + if ivy.exists(size) and recompute_scale_factor is not None: + raise ivy.utils.exceptions.IvyException( + "recompute_scale_factor is not meaningful with an explicit size." + ) + if ivy.get_num_dims(x) != 4 and mode == "bilinear": + raise ivy.utils.exceptions.IvyException( + f"Got {x.ndim}D input, but bilinear mode needs 4D input" + ) + if ivy.get_num_dims(x) != 5 and mode == "trilinear": + raise ivy.utils.exceptions.IvyException( + f"Got {x.ndim}D input, but trilinear mode needs 5D input" + ) + if ivy.get_num_dims(x) != 3 and mode == "linear": + raise ivy.utils.exceptions.IvyException( + f"Got {x.ndim}D input, but trilinear mode needs 3D input" + ) size, scale_factor = _get_size(scale_factor, size, dims, x.shape) + ivy.utils.assertions.check_true( + all(s > 0 for s in size), + message=f"output sizes should be greater than 0, but got {size}", + ) if all(a == b for a, b in zip(size, input_shape[2:])): ret = x else: diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index b7b270875323c..8dbbba87e723e 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -85,9 +85,18 @@ def _interp_args(draw, mode=None, mode_list=None): ) elif mode_list: mode = draw(st.sampled_from(mode_list)) - align_corners = draw(st.one_of(st.booleans(), st.none())) - if curr_backend in ["tensorflow", "jax"] and not mixed_fn_compos: - align_corners = False + align_corners = None + if mode in [ + "linear", + "bilinear", + "trilinear", + "nd", + "tf_bicubic", + "lanczos3", + "lanczos5", + "bicubic", + ]: + align_corners = draw(st.booleans()) if mode == "linear": num_dims = 3 elif mode in [ @@ -114,7 +123,6 @@ def _interp_args(draw, mode=None, mode_list=None): ) + 2 ) - align_corners = None if curr_backend == "tensorflow" and not mixed_fn_compos: num_dims = 3 dtype, x = draw( @@ -126,6 +134,8 @@ def _interp_args(draw, mode=None, mode_list=None): max_num_dims=num_dims, min_dim_size=2, max_dim_size=5, + max_value=10000, + min_value=-10000, large_abs_safety_factor=50, small_abs_safety_factor=50, safety_factor_scale="log", From d53ceeb9fd6ee0fe68cde0e209f5823c9ef237d4 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 27 Oct 2023 18:44:30 +0000 Subject: [PATCH 065/978] fix(ivy): Fixed interpolate to get its test passing. All cases now work except align_corners True. --- .../backends/jax/experimental/layers.py | 19 ++++++++++--- .../tensorflow/experimental/layers.py | 20 +++++++++++-- ivy/functional/ivy/experimental/layers.py | 28 ++++++++----------- .../test_experimental/test_nn/test_layers.py | 6 +--- 4 files changed, 44 insertions(+), 29 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 1d3debab8559e..d884808610dd6 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -724,9 +724,8 @@ def interpolate( return ret -interpolate.partial_mixed_handler = lambda *args, mode="linear", scale_factor=None, recompute_scale_factor=None, align_corners=None, **kwargs: ( # noqa: E501 - (align_corners is None or not align_corners) - and mode +interpolate.partial_mixed_handler = ( + lambda *args, mode="linear", recompute_scale_factor=None, align_corners=None, **kwargs: mode # noqa: E501 not in [ "area", "nearest", @@ -736,7 +735,19 @@ def interpolate( "gaussian", "bicubic", ] - and (scale_factor is None or ivy.all(ivy.array(scale_factor) > 1)) + and not align_corners + and ( + recompute_scale_factor + or mode + not in [ + "linear", + "bilinear", + "trilinear", + "tf_bicubic", + "lanczos3", + "lanczos5", + ] + ) ) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index cc69a5aa1e2ba..c78bb8c20b841 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -931,10 +931,24 @@ def interpolate( interpolate.partial_mixed_handler = ( - lambda x, *args, mode="linear", scale_factor=None, recompute_scale_factor=None, align_corners=None, **kwargs: not align_corners # noqa: E501 - and len(x.shape) < 4 + lambda x, *args, mode="linear", recompute_scale_factor=None, align_corners=None, **kwargs: len( # noqa: E501 + x.shape + ) + < 4 and mode not in ["nearest", "area", "bicubic", "nd"] - and (scale_factor is None or ivy.all(ivy.array(scale_factor) > 1)) + and not align_corners + and ( + recompute_scale_factor + or mode + not in [ + "linear", + "bilinear", + "trilinear", + "tf_bicubic", + "lanczos3", + "lanczos5", + ] + ) ) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index e87f42a4b3a09..9cd94a2f802d3 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1516,15 +1516,10 @@ def _lanczos_kernel(radius, x): def _dim_scale_factor(input_size, output_size, align_corners, scales): if align_corners: - if output_size > 1: - dim_scale_factor = (input_size - 1) / (output_size - 1) - else: - dim_scale_factor = 0.0 + dim_scale_factor = (input_size - 1) / (output_size - 1) else: dim_scale_factor = ( - input_size / (input_size * scales) - if scales is not None - else input_size / output_size + 1 / scales if scales is not None else input_size / output_size ) return dim_scale_factor @@ -1542,7 +1537,6 @@ def _mitchellcubic_kernel(x): def _compute_weight_mat( input_size, output_size, - scale, align_corners, kernel_fn, dim_scale_factor, @@ -1623,8 +1617,8 @@ def compute_source_index(scale, dst_index, align_corners): height_scale = compute_scale(iH, oH, align_corners, scale_h) width_scale = compute_scale(iW, oW, align_corners, scale_w) - N_idx = ivy.reshape(ivy.arange(N), (N, 1, 1, 1)) - C_idx = ivy.reshape(ivy.arange(C), (1, C, 1, 1)) + N_idx = ivy.reshape(ivy.arange(N), (N, 1, 1, 1)).astype(ivy.int64) + C_idx = ivy.reshape(ivy.arange(C), (1, C, 1, 1)).astype(ivy.int64) out_y = ivy.reshape(ivy.arange(oH), ((1, 1, oH, 1))) out_x = ivy.reshape(ivy.arange(oW), ((1, 1, 1, oW))) @@ -1740,7 +1734,7 @@ def generate_einsum_equation(dim): def _interpolate_with_kernel( - x, dims, size, scale, input_shape, align_corners, scale_factor, mode + x, dims, size, input_shape, align_corners, scale_factor, mode ): spatial_dims = [2 + i for i in range(dims)] equation = generate_einsum_equation(dims) @@ -1757,7 +1751,7 @@ def _interpolate_with_kernel( scale_factor[i] if scale_factor is not None else None, ) w = _compute_weight_mat( - m, n, scale[i], align_corners, kernel_func, dim_scale_factor + m, n, align_corners, kernel_func, dim_scale_factor ).astype(x.dtype) operands.append(w) return ivy.einsum(equation, x, *operands) @@ -1922,9 +1916,9 @@ def interpolate( ret = x else: if recompute_scale_factor: - scale = [ivy.divide(size[i], input_shape[i + 2]) for i in range(dims)] - else: - scale = [1] * dims + scale_factor = [ + ivy.divide(size[i], input_shape[i + 2]) for i in range(dims) + ] if mode in [ "linear", "bilinear", @@ -1938,7 +1932,6 @@ def interpolate( x, dims, size, - scale, input_shape, align_corners, scale_factor, @@ -1951,7 +1944,7 @@ def interpolate( x, dims, size, input_shape, mode == "nearest-exact" ) elif mode == "area": - ret = area_interpolate(x, dims, size, scale) + ret = area_interpolate(x, dims, size, scale_factor) elif mode == "mitchellcubic": batch, channels, in_height, in_width = x.shape out_height, out_width = size @@ -2065,6 +2058,7 @@ def _get_size(scale_factor, size, dims, x_shape): ) else: size = (size,) * dims if isinstance(size, int) else tuple(size) + scale_factor = [ivy.divide(size[i], x_shape[i + 2]) for i in range(dims)] return size, scale_factor diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 8dbbba87e723e..0293d62e76e4b 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -163,12 +163,8 @@ def _interp_args(draw, mode=None, mode_list=None): st.integers(min_value=1, max_value=3 * max(x[0].shape)), ) ) - recompute_scale_factor = False + recompute_scale_factor = None scale_factor = None - if curr_backend in ["tensorflow", "jax"] and not mixed_fn_compos: - if not recompute_scale_factor: - recompute_scale_factor = True - return (dtype, x, mode, size, align_corners, scale_factor, recompute_scale_factor) From c3a78b55dd0a9c94548886fce029616855d224c4 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 27 Oct 2023 19:48:48 +0000 Subject: [PATCH 066/978] fix: Fix to test torch interpolate for all supported cases + a leftover change to get `out` working for bicubic mode --- ivy/functional/ivy/experimental/layers.py | 2 +- .../test_functional/test_vision_functions.py | 2 +- .../test_experimental/test_nn/test_layers.py | 13 +++++-------- 3 files changed, 7 insertions(+), 10 deletions(-) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 9cd94a2f802d3..bfb3daa1595aa 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1938,7 +1938,7 @@ def interpolate( mode, ) elif mode == "bicubic": - return _upsample_bicubic2d_default(x, size, align_corners) + ret = _upsample_bicubic2d_default(x, size, align_corners) elif mode in ["nearest-exact", "nearest"]: ret = nearest_interpolate( x, dims, size, input_shape, mode == "nearest-exact" diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py index 9c34752b567e5..c799de3b914d0 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py @@ -238,7 +238,7 @@ def test_torch_grid_sample( @handle_frontend_test( fn_tree="torch.nn.functional.interpolate", dtype_and_input_and_other=_interp_args( - mode_list=["linear", "bilinear", "trilinear", "nearest", "area"], + mode_list="torch", ), number_positional_args=st.just(2), ) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 0293d62e76e4b..08d1ee0bf72cd 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -33,7 +33,6 @@ def _interp_args(draw, mode=None, mode_list=None): "area", "bicubic", ] - tf_modes = [ "linear", "bilinear", @@ -46,7 +45,6 @@ def _interp_args(draw, mode=None, mode_list=None): "mitchellcubic", "gaussian", ] - jax_modes = [ "linear", "bilinear", @@ -56,7 +54,8 @@ def _interp_args(draw, mode=None, mode_list=None): "lanczos3", "lanczos5", ] - + if mode_list == "torch": + mode_list = torch_modes if not mode and not mode_list: if curr_backend == "torch" and not mixed_fn_compos: mode = draw(st.sampled_from(torch_modes)) @@ -134,11 +133,9 @@ def _interp_args(draw, mode=None, mode_list=None): max_num_dims=num_dims, min_dim_size=2, max_dim_size=5, - max_value=10000, - min_value=-10000, - large_abs_safety_factor=50, - small_abs_safety_factor=50, - safety_factor_scale="log", + max_value=1e04, + min_value=-1e04, + abs_smallest_val=1e-04, ) ) if draw(st.booleans()): From e14854cc76f59eed06d5da6053376f0fcee46703 Mon Sep 17 00:00:00 2001 From: muhammadhammad-tech <75118771+muhammadhammad-tech@users.noreply.github.com> Date: Sat, 28 Oct 2023 08:35:30 +0500 Subject: [PATCH 067/978] feat: add heaviside method to paddle frontend (#26740) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 6 +++ .../test_paddle/test_tensor/test_tensor.py | 42 +++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 87013e718708c..6f53fd7300263 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -927,6 +927,12 @@ def gather_(self, y, name=None): res = self.gather(self, y) return ivy.inplace_update(self, res) + @with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + ) + def heaviside(self, y, name=None): + return paddle_frontend.heaviside(self, y) + @with_supported_dtypes( {"2.5.1 and below": ("bool", "int32", "int64", "float32", "float64")}, "paddle" ) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index d8c2bdc7b6f05..ff869ce9ca229 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -4609,6 +4609,48 @@ def test_paddle_tensor_expand( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="heaviside", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + num_arrays=2, + allow_inf=False, + large_abs_safety_factor=2, + small_abs_safety_factor=2, + safety_factor_scale="log", + shared_dtype=True, + ), +) +def test_paddle_tensor_heaviside( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "x": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + init_flags=init_flags, + method_flags=method_flags, + frontend_method_data=frontend_method_data, + frontend=frontend, + on_device=on_device, + ) + + # tile @handle_frontend_method( class_tree=CLASS_TREE, From 62101f423d2e8845d86f019e29b52a01c0c5bee1 Mon Sep 17 00:00:00 2001 From: Sultangazy Yergaliyev Date: Sat, 28 Oct 2023 09:46:00 +0600 Subject: [PATCH 068/978] feat: added swapaxes instance method and test function for it (#26513) Co-authored-by: NripeshN --- ivy/functional/frontends/jax/array.py | 3 + .../test_frontends/test_jax/test_array.py | 60 +++++++++++++++++++ 2 files changed, 63 insertions(+) diff --git a/ivy/functional/frontends/jax/array.py b/ivy/functional/frontends/jax/array.py index 2de2e3252c0f5..7d22cdd83974d 100644 --- a/ivy/functional/frontends/jax/array.py +++ b/ivy/functional/frontends/jax/array.py @@ -410,6 +410,9 @@ def var( where=where, ) + def swapaxes(self, axis1, axis2): + return jax_frontend.numpy.swapaxes(self, axis1=axis1, axis2=axis2) + # Jax supports DeviceArray from 0.4.13 and below # Hence aliasing it here diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py index bbf108fd4eec1..8fa019823c2c0 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py @@ -177,6 +177,30 @@ def _transpose_helper(draw): return x, xT +# swapaxes +@st.composite +def dtype_x_axis(draw): + dtype, x, x_shape = draw( + helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + min_num_dims=1, + max_num_dims=5, + ret_shape=True, + ) + ) + axis1, axis2 = draw( + helpers.get_axis( + shape=x_shape, + sort_values=False, + unique=True, + min_size=2, + max_size=2, + force_tuple=True, + ) + ) + return dtype, x, axis1, axis2 + + # --- Main --- # # ------------ # @@ -2766,3 +2790,39 @@ def test_jax_sum( on_device=on_device, atol_=1e-04, ) + + +# swapaxes +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="jax.numpy.array", + method_name="swapaxes", + dtype_x_axis=dtype_x_axis(), +) +def test_jax_swapaxes( + dtype_x_axis, + frontend, + frontend_method_data, + backend_fw, + init_flags, + method_flags, + on_device, +): + input_dtypes, x, axis1, axis2 = dtype_x_axis + helpers.test_frontend_method( + init_input_dtypes=input_dtypes, + backend_to_test=backend_fw, + method_input_dtypes=input_dtypes, + init_all_as_kwargs_np={ + "object": x[0], + }, + method_all_as_kwargs_np={ + "axis1": axis1, + "axis2": axis2, + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) From af8935b74f77ce79c9d6d5106f35af3a1c08db71 Mon Sep 17 00:00:00 2001 From: Sharjeel Nawaz <75641214+sharjeelnawaz8182@users.noreply.github.com> Date: Sat, 28 Oct 2023 12:13:04 +0500 Subject: [PATCH 069/978] feat: add pytorch frontend instance based corrcoef and tests --- ivy/functional/frontends/torch/tensor.py | 7 ++++ .../test_frontends/test_torch/test_tensor.py | 35 +++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index e80786ca4e0e3..c48e8af04489b 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2163,6 +2163,13 @@ def minimum(self, other, *, out=None): def rad2deg(self, *, out=None): return torch_frontend.rad2deg(self, out=out) + @with_supported_dtypes( + {"2.1.0 and below": "valid"}, + "torch", + ) + def corrcoef(self): + return torch_frontend.corrcoef(self) + # Method aliases absolute, absolute_ = abs, abs_ clip, clip_ = clamp, clamp_ diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 3bde53fc3167c..1a824bf209d64 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -12718,6 +12718,41 @@ def test_torch_tanh_( ) +# corrcoef +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="corrcoef", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + ), +) +def test_torch_tensor_corrcoef( + dtype_and_x, + frontend, + backend_fw, + frontend_method_data, + init_flags, + method_flags, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + backend_to_test=backend_fw, + on_device=on_device, + ) + + # positive @handle_frontend_method( class_tree=CLASS_TREE, From 99b0dfa60ae5582bdc320ac5eb3a018536a4bd16 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Sat, 28 Oct 2023 16:34:20 +0300 Subject: [PATCH 070/978] fix: improve `from_dlpack` to accept both `array` and `dltensor` inputs --- ivy/functional/backends/numpy/creation.py | 14 +++++++++++++- ivy/functional/backends/paddle/creation.py | 6 +++++- ivy/functional/backends/tensorflow/creation.py | 6 +++++- ivy/functional/ivy/creation.py | 4 ++-- 4 files changed, 25 insertions(+), 5 deletions(-) diff --git a/ivy/functional/backends/numpy/creation.py b/ivy/functional/backends/numpy/creation.py index eb6533ac1d039..4ce48b5332d57 100644 --- a/ivy/functional/backends/numpy/creation.py +++ b/ivy/functional/backends/numpy/creation.py @@ -111,8 +111,20 @@ def to_dlpack(x, /, *, out: Optional[np.ndarray] = None): return x.__dlpack__() +class _dlpack_wrapper: + def __init__(self, capsule) -> None: + self.capsule = capsule + + def dlpack(self): + return self.capsule + + def from_dlpack(x, /, *, out: Optional[np.ndarray] = None): - return np.from_dlpack(x) + if not hasattr(x, "__dlpack__"): + capsule = _dlpack_wrapper(x) + else: + capsule = x + return np.from_dlpack(capsule) def full( diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index b2270f6b1d63e..d3c160b8894ff 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -207,7 +207,11 @@ def to_dlpack(x, /, *, out: Optional[paddle.Tensor] = None): def from_dlpack(x, /, *, out: Optional[paddle.Tensor] = None): - return paddle.utils.dlpack.from_dlpack(x) + if hasattr(x, "__dlpack__"): + capsule = x.__dlpack__() + else: + capsule = x + return paddle.utils.dlpack.from_dlpack(capsule) def full( diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py index 2928cbfc5671e..7bd7f0b2d6b14 100644 --- a/ivy/functional/backends/tensorflow/creation.py +++ b/ivy/functional/backends/tensorflow/creation.py @@ -190,7 +190,11 @@ def from_dlpack( ) -> Union[tf.Tensor, tf.Variable]: if isinstance(x, tf.Variable): x = x.read_value() - return tf.experimental.dlpack.from_dlpack(x) + if hasattr(x, "__dlpack__"): + capsule = x.__dlpack__() + else: + capsule = x + return tf.experimental.dlpack.from_dlpack(capsule) def full( diff --git a/ivy/functional/ivy/creation.py b/ivy/functional/ivy/creation.py index 0c94beafdbced..44c9f370b04ed 100644 --- a/ivy/functional/ivy/creation.py +++ b/ivy/functional/ivy/creation.py @@ -1738,12 +1738,12 @@ def from_dlpack( ) -> ivy.Array: """ Return a new array containing the data from another (array) object with a - ``__dlpack__`` method. + ``__dlpack__`` method or PyCapsule Object. Parameters ---------- x object - input (array) object. + input (array) object with a ``__dlpack__`` method or PyCapsule Object. out optional output array, for writing the result to. It must have a shape that the inputs broadcast to. From d919d799b54d3eab4530444dade1cea93b2e28dd Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Sat, 28 Oct 2023 17:35:06 +0000 Subject: [PATCH 071/978] fix: better handling for different operand dtypes in tf `einsum` --- ivy/functional/backends/tensorflow/statistical.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/tensorflow/statistical.py b/ivy/functional/backends/tensorflow/statistical.py index 4d997c9f85ce3..938f21c1834be 100644 --- a/ivy/functional/backends/tensorflow/statistical.py +++ b/ivy/functional/backends/tensorflow/statistical.py @@ -4,7 +4,6 @@ # local import ivy -from ivy.functional.ivy.statistical import _get_promoted_type_of_operands from ivy.func_wrapper import with_unsupported_dtypes from . import backend_version from ivy.utils.einsum_parser import legalise_einsum_expr @@ -217,6 +216,15 @@ def einsum( *operands: Union[tf.Tensor, tf.Variable], out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - dtype = _get_promoted_type_of_operands(operands) equation = legalise_einsum_expr(*[equation, *operands]) - return tf.cast(tf.einsum(equation, *operands), dtype) + dtype_list = set(map(lambda x: x.dtype, operands)) + dtype = dtype_list.pop() + if len(dtype_list) > 0: + for d in dtype_list: + dtype = ivy.promote_types(dtype, d) + dtype = ivy.as_native_dtype(dtype) + operands = list( + map(lambda x: tf.cast(x, dtype) if x.dtype != dtype else x, operands) + ) + + return tf.einsum(equation, *operands) From ea0eaad440ff7f953c2fb4c621eccfe4a6fb2ecd Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Sat, 28 Oct 2023 17:37:57 +0000 Subject: [PATCH 072/978] feat: simplify paddle `_elementwise_helper` by removing broadcasting --- ivy/functional/backends/paddle/elementwise.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index bb8eddb8be644..68ea20c637437 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -15,8 +15,10 @@ def _elementwise_helper(x1, x2): if (not hasattr(x1, "dtype") or not hasattr(x2, "dtype")) or (x1.dtype != x2.dtype): x1, x2 = ivy.promote_types_of_inputs(x1, x2) - if x1.shape != x2.shape: - x1, x2 = paddle_backend.broadcast_arrays(x1, x2) + # the following was needed in versions <=2.4.2 because most functions didn't + # accept 0D inputs along other inputs + # if x1.shape != x2.shape: + # x1, x2 = paddle_backend.broadcast_arrays(x1, x2) return x1, x2, x1.dtype From a84b6b6632dfa9a336882b6aff6c2320555e9383 Mon Sep 17 00:00:00 2001 From: Kamlish <125588073+kamlishgoswami@users.noreply.github.com> Date: Sun, 29 Oct 2023 16:51:35 +0500 Subject: [PATCH 073/978] feat: Added unsorted_segment_mean function (#24984) Co-authored-by: ivy-branch Co-authored-by: Rishab Mallick --- .../array/experimental/creation.py | 44 +++++++ .../container/experimental/creation.py | 107 ++++++++++++++++++ .../backends/jax/experimental/creation.py | 21 +++- .../backends/numpy/experimental/creation.py | 32 +++++- .../backends/paddle/experimental/creation.py | 34 +++++- .../tensorflow/experimental/creation.py | 8 ++ .../backends/torch/experimental/creation.py | 29 ++++- ivy/functional/ivy/experimental/creation.py | 36 ++++++ ivy/utils/assertions.py | 2 +- .../test_core/test_creation.py | 27 +++++ .../test_ivy/test_misc/test_assertions.py | 6 +- 11 files changed, 334 insertions(+), 12 deletions(-) diff --git a/ivy/data_classes/array/experimental/creation.py b/ivy/data_classes/array/experimental/creation.py index 8fc3459e5cd2b..fdca1bcffabf3 100644 --- a/ivy/data_classes/array/experimental/creation.py +++ b/ivy/data_classes/array/experimental/creation.py @@ -265,6 +265,50 @@ def mel_weight_matrix( upper_edge_hertz, ) + def unsorted_segment_mean( + self: ivy.Array, + segment_ids: ivy.Array, + num_segments: Union[int, ivy.Array], + ) -> ivy.Array: + """ + Compute the mean of values in the array 'self' based on segment identifiers. + + Parameters + ---------- + self : ivy.Array + The array from which to gather values. + segment_ids : ivy.Array + Must be in the same size with the first dimension of `self`. Has to be + of integer data type. The index-th element of `segment_ids` array is + the segment identifier for the index-th element of `self`. + num_segments : Union[int, ivy.Array] + An integer or array representing the total number of distinct segment IDs. + + Returns + ------- + ret : ivy.Array + The output array, representing the result of a segmented mean operation. + For each segment, it computes the mean of values in `self` where + `segment_ids` equals to segment ID. + + Examples + -------- + >>> data = ivy.array([1.0, 2.0, 3.0, 4.0]) + >>> segment_ids = ivy.array([0, 0, 0, 0]) + >>> num_segments = 1 + >>> result = ivy.unsorted_segment_mean(data, segment_ids, num_segments) + >>> result + ivy.array([2.5]) + + >>> data = ivy.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]) + >>> segment_ids = ivy.array([0, 0, 1, 1, 2, 2]) + >>> num_segments = 3 + >>> result = ivy.unsorted_segment_mean(data, segment_ids, num_segments) + >>> result + ivy.array([[1.5, 3.5, 5.5],[1.5, 3.5, 5.5],[1.5, 3.5, 5.5]]) + """ + return ivy.unsorted_segment_mean(self._data, segment_ids, num_segments) + def polyval( coeffs=ivy.Array, diff --git a/ivy/data_classes/container/experimental/creation.py b/ivy/data_classes/container/experimental/creation.py index b708253e7adfb..b760f16ddde3f 100644 --- a/ivy/data_classes/container/experimental/creation.py +++ b/ivy/data_classes/container/experimental/creation.py @@ -1202,6 +1202,57 @@ def mel_weight_matrix( ) @staticmethod + def static_unsorted_segment_mean( + data: ivy.Container, + segment_ids: Union[ivy.Array, ivy.Container], + num_segments: Union[int, ivy.Container], + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + """ + Compute the mean of values in the input data based on segment identifiers. + + Parameters + ---------- + data : ivy.Container + Input array or container from which to gather the input. + segment_ids : ivy.Container + An array of integers indicating the segment identifier for each element in + 'data'. + num_segments : Union[int, ivy.Container] + An integer or array representing the total number of distinct segment IDs. + key_chains : Optional[Union[List[str], Dict[str, str], ivy.Container]], optional + The key-chains to apply or not apply the method to. Default is None. + to_apply : Union[bool, ivy.Container], optional + If True, the method will be applied to key-chains, otherwise key-chains will + be skipped. Default is True. + prune_unapplied : Union[bool, ivy.Container], optional + Whether to prune key-chains for which the function was not applied. + Default is False. + map_sequences : Union[bool, ivy.Container], optional + Whether to also map method to sequences (lists, tuples). Default is False. + + Returns + ------- + ivy.Container + A container representing the result of a segmented mean operation. + For each segment, it computes the mean of values in 'data' where + 'segment_ids' equals the segment ID. + """ + return ContainerBase.cont_multi_map_in_function( + "unsorted_segment_mean", + data, + segment_ids, + num_segments, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + def static_polyval( coeffs: ivy.Container, x: Union[ivy.Container, int, float], @@ -1253,6 +1304,62 @@ def static_polyval( map_sequences=map_sequences, ) + def unsorted_segment_mean( + self: ivy.Container, + segment_ids: Union[ivy.Array, ivy.Container], + num_segments: Union[int, ivy.Container], + ) -> ivy.Container: + """ + Compute the mean of values in the input array or container based on segment + identifiers. + + Parameters + ---------- + self : ivy.Container + Input array or container from which to gather the input. + segment_ids : ivy.Container + An array of integers indicating the segment identifier for each element + in 'self'. + num_segments : Union[int, ivy.Container] + An integer or array representing the total number of distinct segment IDs. + + Returns + ------- + ivy.Container + A container representing the result of a segmented mean operation. + For each segment, it computes the mean of values in 'self' where + 'segment_ids' equals the segment ID. + + Example + -------- + >>> data = ivy.Container(a=ivy.array([0., 1., 2., 4.]), + ... b=ivy.array([3., 4., 5., 6.])) + >>> segment_ids = ivy.array([0, 0, 1, 1]) + >>> num_segments = 2 + >>> result = ivy.unsorted_segment_mean(data, segment_ids, num_segments) + >>> print(result) + { + a: ivy.array([0.5, 3.0]), + b: ivy.array([3.5, 5.5]) + } + + >>> data = ivy.Container(a=ivy.array([0., 1., 2., 4., 5., 6.]), + ... b=ivy.array([3., 4., 5., 6., 7., 8.])) + >>> segment_ids = ivy.array([0, 0, 1, 1, 2, 2]) + >>> num_segments = 3 + >>> result = ivy.unsorted_segment_mean(data, segment_ids, num_segments) + >>> print(result) + { + a: ivy.array([0.5, 3.0, 5.5]), + b: ivy.array([3.5, 5.5, 7.5]) + } + """ + return self.static_unsorted_segment_mean( + self, + segment_ids, + num_segments, + ) + def polyval( self: ivy.Container, coeffs: ivy.Container, diff --git a/ivy/functional/backends/jax/experimental/creation.py b/ivy/functional/backends/jax/experimental/creation.py index 85c018578c38d..19e1833db5e4f 100644 --- a/ivy/functional/backends/jax/experimental/creation.py +++ b/ivy/functional/backends/jax/experimental/creation.py @@ -83,7 +83,7 @@ def unsorted_segment_min( num_segments: int, ) -> JaxArray: # added this check to keep the same behaviour as tensorflow - ivy.utils.assertions.check_unsorted_segment_min_valid_params( + ivy.utils.assertions.check_unsorted_segment_valid_params( data, segment_ids, num_segments ) return jax.ops.segment_min(data, segment_ids, num_segments) @@ -98,7 +98,7 @@ def unsorted_segment_sum( # the check should be same # Might require to change the assertion function name to # check_unsorted_segment_valid_params - ivy.utils.assertions.check_unsorted_segment_min_valid_params( + ivy.utils.assertions.check_unsorted_segment_valid_params( data, segment_ids, num_segments ) return jax.ops.segment_sum(data, segment_ids, num_segments) @@ -165,6 +165,23 @@ def hz_to_mel(f): return jnp.pad(mel_weights, [[1, 0], [0, 0]]) +def unsorted_segment_mean( + data: JaxArray, + segment_ids: JaxArray, + num_segments: int, +) -> JaxArray: + ivy.utils.assertions.check_unsorted_segment_valid_params( + data, segment_ids, num_segments + ) + segment_sum = jax.ops.segment_sum(data, segment_ids, num_segments) + + segment_count = jax.ops.segment_sum(jnp.ones_like(data), segment_ids, num_segments) + + segment_mean = segment_sum / segment_count + + return segment_mean + + def polyval( coeffs: JaxArray, x: JaxArray, diff --git a/ivy/functional/backends/numpy/experimental/creation.py b/ivy/functional/backends/numpy/experimental/creation.py index 6916cb31ef88f..e6c4b5a064779 100644 --- a/ivy/functional/backends/numpy/experimental/creation.py +++ b/ivy/functional/backends/numpy/experimental/creation.py @@ -89,7 +89,7 @@ def unsorted_segment_min( segment_ids: np.ndarray, num_segments: int, ) -> np.ndarray: - ivy.utils.assertions.check_unsorted_segment_min_valid_params( + ivy.utils.assertions.check_unsorted_segment_valid_params( data, segment_ids, num_segments ) @@ -143,7 +143,7 @@ def unsorted_segment_sum( # check should be same # Might require to change the assertion function name to # check_unsorted_segment_valid_params - ivy.utils.assertions.check_unsorted_segment_min_valid_params( + ivy.utils.assertions.check_unsorted_segment_valid_params( data, segment_ids, num_segments ) @@ -203,6 +203,34 @@ def hz_to_mel(f): return np.pad(mel_weights, [[1, 0], [0, 0]]) +def unsorted_segment_mean( + data: np.ndarray, + segment_ids: np.ndarray, + num_segments: int, +) -> np.ndarray: + ivy.utils.assertions.check_unsorted_segment_valid_params( + data, segment_ids, num_segments + ) + + if len(segment_ids) == 0: + # If segment_ids is empty, return an empty array of the correct shape + return np.zeros((num_segments,) + data.shape[1:], dtype=data.dtype) + + # Initialize an array to store the sum of elements for each segment + res = np.zeros((num_segments,) + data.shape[1:], dtype=data.dtype) + + # Initialize an array to keep track of the number of elements in each segment + counts = np.zeros(num_segments, dtype=np.int64) + + for i in range(len(segment_ids)): + seg_id = segment_ids[i] + if seg_id < num_segments: + res[seg_id] += data[i] + counts[seg_id] += 1 + + return res / counts[:, np.newaxis] + + def polyval(coeffs: np.ndarray, x: np.ndarray) -> np.ndarray: with ivy.PreciseMode(True): promoted_type = ivy.promote_types(ivy.dtype(coeffs[0]), ivy.dtype(x[0])) diff --git a/ivy/functional/backends/paddle/experimental/creation.py b/ivy/functional/backends/paddle/experimental/creation.py index 6f7d33f083002..bfbecb80e654c 100644 --- a/ivy/functional/backends/paddle/experimental/creation.py +++ b/ivy/functional/backends/paddle/experimental/creation.py @@ -103,7 +103,7 @@ def unsorted_segment_min( segment_ids: paddle.Tensor, num_segments: Union[int, paddle.Tensor], ) -> paddle.Tensor: - ivy.utils.assertions.check_unsorted_segment_min_valid_params( + ivy.utils.assertions.check_unsorted_segment_valid_params( data, segment_ids, num_segments ) if data.dtype == paddle.float32: @@ -156,7 +156,7 @@ def unsorted_segment_sum( # check should be same # Might require to change the assertion function name to # check_unsorted_segment_valid_params - ivy.utils.assertions.check_unsorted_segment_min_valid_params( + ivy.utils.assertions.check_unsorted_segment_valid_params( data, segment_ids, num_segments ) @@ -225,6 +225,36 @@ def mel_weight_matrix( return paddle.transpose(mel_mat, (1, 0)) +def unsorted_segment_mean( + data: paddle.Tensor, + segment_ids: paddle.Tensor, + num_segments: Union[int, paddle.Tensor], +) -> paddle.Tensor: + ivy.utils.assertions.check_unsorted_segment_valid_params( + data, segment_ids, num_segments + ) + + # Sum computation in paddle does not support int32, so needs to + # be converted to float32 + needs_conv = False + if data.dtype == paddle.int32: + data = paddle.cast(data, "float32") + needs_conv = True + + res = paddle.zeros((num_segments,) + tuple(data.shape[1:]), dtype=data.dtype) + + count = paddle.bincount(segment_ids) + count = paddle.where(count > 0, count, paddle.to_tensor([1], dtype="int32")) + res = unsorted_segment_sum(data, segment_ids, num_segments) + res = res / paddle.reshape(count, (-1, 1)) + + # condition for converting float32 back to int32 + if needs_conv is True: + res = paddle.cast(res, "int32") + + return res + + @with_unsupported_device_and_dtypes( { "2.5.1 and below": { diff --git a/ivy/functional/backends/tensorflow/experimental/creation.py b/ivy/functional/backends/tensorflow/experimental/creation.py index e86263c7d3f76..86af4561091c2 100644 --- a/ivy/functional/backends/tensorflow/experimental/creation.py +++ b/ivy/functional/backends/tensorflow/experimental/creation.py @@ -160,6 +160,14 @@ def mel_weight_matrix( ) +def unsorted_segment_mean( + data: tf.Tensor, + segment_ids: tf.Tensor, + num_segments: Union[int, tf.Tensor], +) -> tf.Tensor: + return tf.math.unsorted_segment_mean(data, segment_ids, num_segments) + + @with_unsupported_dtypes( {"2.13.0 and below": ("bool", "bfloat16", "float16", "complex")}, backend_version ) diff --git a/ivy/functional/backends/torch/experimental/creation.py b/ivy/functional/backends/torch/experimental/creation.py index 770e94654a1f4..953970525fd66 100644 --- a/ivy/functional/backends/torch/experimental/creation.py +++ b/ivy/functional/backends/torch/experimental/creation.py @@ -131,7 +131,7 @@ def unsorted_segment_min( segment_ids: torch.Tensor, num_segments: Union[int, torch.Tensor], ) -> torch.Tensor: - ivy.utils.assertions.check_unsorted_segment_min_valid_params( + ivy.utils.assertions.check_unsorted_segment_valid_params( data, segment_ids, num_segments ) if data.dtype in [torch.float32, torch.float64, torch.float16, torch.bfloat16]: @@ -180,7 +180,7 @@ def unsorted_segment_sum( # check should be same # Might require to change the assertion function name to # check_unsorted_segment_valid_params - ivy.utils.assertions.check_unsorted_segment_min_valid_params( + ivy.utils.assertions.check_unsorted_segment_valid_params( data, segment_ids, num_segments ) @@ -247,6 +247,31 @@ def hz_to_mel(f): return torch.nn.functional.pad(mel_weights, (0, 0, 1, 0)) +def unsorted_segment_mean( + data: torch.Tensor, + segment_ids: torch.Tensor, + num_segments: Union[int, torch.Tensor], +) -> torch.Tensor: + ivy.utils.assertions.check_unsorted_segment_valid_params( + data, segment_ids, num_segments + ) + + # Initialize an array to store the sum of elements for each segment + segment_sum = torch.zeros( + (num_segments,) + data.shape[1:], dtype=data.dtype, device=data.device + ) + + # Initialize an array to keep track of the number of elements in each segment + counts = torch.zeros(num_segments, dtype=torch.int64, device=data.device) + + for i in range(len(segment_ids)): + seg_id = segment_ids[i] + segment_sum[seg_id] += data[i] + counts[seg_id] += 1 + + return segment_sum / counts[:, None] + + @with_unsupported_dtypes({"2.0.1 and below": "float16"}, backend_version) def polyval( coeffs: torch.Tensor, diff --git a/ivy/functional/ivy/experimental/creation.py b/ivy/functional/ivy/experimental/creation.py index 710a5b4b5e74d..db01811743ebb 100644 --- a/ivy/functional/ivy/experimental/creation.py +++ b/ivy/functional/ivy/experimental/creation.py @@ -1139,6 +1139,42 @@ def mel_weight_matrix( ) +# unsorted_segment_mean +@handle_exceptions +@handle_nestable +@to_native_arrays_and_back +def unsorted_segment_mean( + data: Union[ivy.Array, ivy.NativeArray], + segment_ids: Union[ivy.Array, ivy.NativeArray], + num_segments: Union[int, ivy.Array, ivy.NativeArray], +) -> ivy.Array: + """ + Compute the mean of elements along segments of an array. Segments are defined by an + integer array of segment IDs. + + Parameters + ---------- + data : Union[ivy.Array, ivy.NativeArray] + The array from which to gather values. + + segment_ids : Union[ivy.Array, ivy.NativeArray] + Must be in the same size with the first dimension of `data`. Has to be + of integer data type. The index-th element of `segment_ids` array is + the segment identifier for the index-th element of `data`. + + num_segments : Union[int, ivy.Array, ivy.NativeArray] + An integer or array representing the total number of distinct segment IDs. + + Returns + ------- + ivy.Array + The output array, representing the result of a segmented mean operation. + For each segment, it computes the mean value in `data` where `segment_ids` + equals to segment ID. + """ + return ivy.current_backend().unsorted_segment_mean(data, segment_ids, num_segments) + + @handle_exceptions @handle_nestable @handle_array_function diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index 0a5f653f7fd8f..3ce9cb927f8be 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -182,7 +182,7 @@ def check_same_dtype(x1, x2, message=""): # -------- # -def check_unsorted_segment_min_valid_params(data, segment_ids, num_segments): +def check_unsorted_segment_valid_params(data, segment_ids, num_segments): if not isinstance(num_segments, int): raise ValueError("num_segments must be of integer type") diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_creation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_creation.py index 51b14a8d29b15..151cc3fcb344d 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_creation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_creation.py @@ -799,6 +799,33 @@ def test_trilu(*, dtype_and_x, k, upper, test_flags, backend_fw, fn_name, on_dev ) +@handle_test( + fn_tree="functional.ivy.experimental.unsorted_segment_mean", + d_x_n_s=valid_unsorted_segment_min_inputs(), + test_with_out=st.just(False), + test_gradients=st.just(False), +) +def test_unsorted_segment_mean( + *, + d_x_n_s, + test_flags, + backend_fw, + fn_name, + on_device, +): + dtypes, data, num_segments, segment_ids = d_x_n_s + helpers.test_function( + input_dtypes=dtypes, + test_flags=test_flags, + on_device=on_device, + backend_to_test=backend_fw, + fn_name=fn_name, + data=data, + segment_ids=segment_ids, + num_segments=num_segments, + ) + + # unsorted_segment_min @handle_test( fn_tree="functional.ivy.experimental.unsorted_segment_min", diff --git a/ivy_tests/test_ivy/test_misc/test_assertions.py b/ivy_tests/test_ivy/test_misc/test_assertions.py index b6e4c948c1dea..8d6484d4bacb4 100644 --- a/ivy_tests/test_ivy/test_misc/test_assertions.py +++ b/ivy_tests/test_ivy/test_misc/test_assertions.py @@ -23,7 +23,7 @@ check_shape, check_shapes_broadcastable, check_true, - check_unsorted_segment_min_valid_params, + check_unsorted_segment_valid_params, ) from ivy.utils.assertions import _check_jax_x64_flag import ivy @@ -852,7 +852,7 @@ def test_check_true(expression): (ivy.array([1, 2, 3]), ivy.array([0, 1, 0], dtype=ivy.int32), ivy.array([2])), ], ) -def test_check_unsorted_segment_min_valid_params(data, segment_ids, num_segments): +def test_check_unsorted_segment_valid_params(data, segment_ids, num_segments): filename = "except_out.txt" orig_stdout = sys.stdout @@ -860,7 +860,7 @@ def test_check_unsorted_segment_min_valid_params(data, segment_ids, num_segments sys.stdout = f lines = "" try: - check_unsorted_segment_min_valid_params(data, segment_ids, num_segments) + check_unsorted_segment_valid_params(data, segment_ids, num_segments) local_vars = {**locals()} except Exception as e: local_vars = {**locals()} From 26082d1405a9c107b54c1975f6ccc80aa75145b9 Mon Sep 17 00:00:00 2001 From: yopknopixx <30761130+yopknopixx@users.noreply.github.com> Date: Sun, 29 Oct 2023 17:28:45 +0530 Subject: [PATCH 074/978] fix(torch-frontend): fix failing test for torch.nn.functional.alpha_dropout (#27099) --- .../frontends/torch/nn/functional/dropout_functions.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py index affef1205b2fe..a6cc79fb21d99 100644 --- a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py @@ -8,6 +8,7 @@ # ToDo: this function will be simplified once ivy.alpha_dropout is implemented @to_ivy_arrays_and_back @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") def alpha_dropout(input, p=0.5, training=False, inplace=False): if p == 0.0 or not training or input.shape == () or input.shape == (0,): return input From 98d08da9591dde862c6eeb40b3910c87d5330bba Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 29 Oct 2023 17:38:47 +0530 Subject: [PATCH 075/978] fix: Fixed a type annotation of `Tuple`. (#27165) --- ivy/functional/backends/paddle/experimental/statistical.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/experimental/statistical.py b/ivy/functional/backends/paddle/experimental/statistical.py index 6ecfaa16caf5d..84ed593da8fd9 100644 --- a/ivy/functional/backends/paddle/experimental/statistical.py +++ b/ivy/functional/backends/paddle/experimental/statistical.py @@ -419,7 +419,7 @@ def unravel_index( /, *, out: Optional[paddle.Tensor] = None, -) -> tuple[Any, ...]: +) -> Tuple[Any, ...]: if indices.ndim == 0: indices = indices.unsqueeze(0) coord = [] From ed64f98468b69fbcfe325c30707ff76e2c1520cc Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 29 Oct 2023 21:19:21 +0400 Subject: [PATCH 076/978] lint fake flix --- ivy/functional/ivy/linear_algebra.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index 7e580378e5df4..3cc142b54d645 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -2279,7 +2279,8 @@ def svdvals( input array having shape ``(..., M, N)`` and whose innermost two dimensions form ``MxN`` matrices. driver - optional output array,name of the cuSOLVER method to be used. This keyword argument only works on CUDA inputs. + optional output array,name of the cuSOLVER method to be used. This keyword + argument only works on CUDA inputs. Available options are: None, gesvd, gesvdj, and gesvda.Default: None. out optional output array, for writing the result to. It must have a shape that the From 860f25059dd7360e7726d32bdb88ba00a4336fbc Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 29 Oct 2023 17:21:18 +0000 Subject: [PATCH 077/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/ivy/linear_algebra.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index 3cc142b54d645..54f8f94378641 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -2279,7 +2279,7 @@ def svdvals( input array having shape ``(..., M, N)`` and whose innermost two dimensions form ``MxN`` matrices. driver - optional output array,name of the cuSOLVER method to be used. This keyword + optional output array,name of the cuSOLVER method to be used. This keyword argument only works on CUDA inputs. Available options are: None, gesvd, gesvdj, and gesvda.Default: None. out From 790bf4332e577d7aa8d9fe9d8540d9a6d1bf5ac7 Mon Sep 17 00:00:00 2001 From: danielmunioz <47380745+danielmunioz@users.noreply.github.com> Date: Mon, 30 Oct 2023 08:11:14 +0000 Subject: [PATCH 078/978] fix(paddle-backend): Adding missing '2.5.2 and above' option to valid integers --- ivy/functional/backends/paddle/__init__.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/__init__.py b/ivy/functional/backends/paddle/__init__.py index bd0f7259b687c..2e067a94f1f05 100644 --- a/ivy/functional/backends/paddle/__init__.py +++ b/ivy/functional/backends/paddle/__init__.py @@ -181,7 +181,14 @@ def rep_method(*args, **kwargs): ivy.int32, ivy.int64, ivy.uint8, - ) + ), + "2.5.1 and above": ( + ivy.int8, + ivy.int16, + ivy.int32, + ivy.int64, + ivy.uint8, + ), } valid_float_dtypes = { "2.4.0 and below": (ivy.float16, ivy.float32, ivy.float64), From 1f73385a3874f44874893a7387175db850d5bc6b Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Mon, 30 Oct 2023 09:07:38 +0000 Subject: [PATCH 079/978] fix: Update dtypes to latest paddle version --- docs/overview/deep_dive/data_types.rst | 2 +- ivy/functional/backends/paddle/__init__.py | 14 +- ivy/functional/backends/paddle/activations.py | 16 +- ivy/functional/backends/paddle/creation.py | 12 +- ivy/functional/backends/paddle/elementwise.py | 58 ++-- .../paddle/experimental/activations.py | 28 +- .../backends/paddle/experimental/creation.py | 4 +- .../paddle/experimental/elementwise.py | 29 +- .../backends/paddle/experimental/layers.py | 22 +- .../paddle/experimental/linear_algebra.py | 11 +- .../backends/paddle/experimental/losses.py | 12 +- .../paddle/experimental/manipulation.py | 29 +- .../backends/paddle/experimental/norms.py | 4 +- .../backends/paddle/experimental/random.py | 2 +- .../paddle/experimental/sparse_array.py | 2 +- .../paddle/experimental/statistical.py | 22 +- ivy/functional/backends/paddle/general.py | 2 +- ivy/functional/backends/paddle/gradients.py | 2 +- ivy/functional/backends/paddle/layers.py | 8 +- .../backends/paddle/linear_algebra.py | 36 +-- .../backends/paddle/manipulation.py | 20 +- ivy/functional/backends/paddle/random.py | 8 +- ivy/functional/backends/paddle/searching.py | 8 +- ivy/functional/backends/paddle/set.py | 8 +- ivy/functional/backends/paddle/sorting.py | 8 +- ivy/functional/backends/paddle/statistical.py | 16 +- ivy/functional/frontends/__init__.py | 2 +- ivy/functional/frontends/jax/array.py | 4 +- ivy/functional/frontends/jax/numpy/fft.py | 2 +- .../jax/numpy/mathematical_functions.py | 2 +- ivy/functional/frontends/paddle/creation.py | 34 +-- ivy/functional/frontends/paddle/fft.py | 26 +- ivy/functional/frontends/paddle/linalg.py | 30 +- ivy/functional/frontends/paddle/logic.py | 39 +-- .../frontends/paddle/manipulation.py | 32 +-- ivy/functional/frontends/paddle/math.py | 164 +++++------ .../paddle/nn/functional/activation.py | 44 +-- .../frontends/paddle/nn/functional/common.py | 16 +- .../frontends/paddle/nn/functional/conv.py | 12 +- .../frontends/paddle/nn/functional/loss.py | 32 +-- .../frontends/paddle/nn/functional/norm.py | 4 +- .../frontends/paddle/nn/functional/pooling.py | 12 +- .../frontends/paddle/nn/functional/vision.py | 4 +- ivy/functional/frontends/paddle/random.py | 14 +- ivy/functional/frontends/paddle/search.py | 18 +- ivy/functional/frontends/paddle/stat.py | 10 +- .../frontends/paddle/tensor/manipulation.py | 2 +- .../frontends/paddle/tensor/math.py | 22 +- .../frontends/paddle/tensor/random.py | 4 +- .../frontends/paddle/tensor/tensor.py | 258 +++++++++--------- .../frontends/paddle/vision/transforms.py | 14 +- ivy/functional/frontends/tensorflow/math.py | 2 +- .../torch/nn/functional/dropout_functions.py | 2 +- 53 files changed, 605 insertions(+), 583 deletions(-) diff --git a/docs/overview/deep_dive/data_types.rst b/docs/overview/deep_dive/data_types.rst index 8e2c7a596c635..247982a098d87 100644 --- a/docs/overview/deep_dive/data_types.rst +++ b/docs/overview/deep_dive/data_types.rst @@ -423,7 +423,7 @@ set of dtypes is not supported by a certain device. .. code-block:: python - @with_unsupported_device_and_dtypes({"2.5.1 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version) + @with_unsupported_device_and_dtypes({" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version) def gcd( x1: Union[paddle.Tensor, int, list, tuple], x2: Union[paddle.Tensor, float, list, tuple], diff --git a/ivy/functional/backends/paddle/__init__.py b/ivy/functional/backends/paddle/__init__.py index 2e067a94f1f05..7db9bb2b1dce8 100644 --- a/ivy/functional/backends/paddle/__init__.py +++ b/ivy/functional/backends/paddle/__init__.py @@ -175,14 +175,14 @@ def rep_method(*args, **kwargs): ), } valid_int_dtypes = { - "2.5.1 and below": ( + " 2.5.2 and below": ( ivy.int8, ivy.int16, ivy.int32, ivy.int64, ivy.uint8, ), - "2.5.1 and above": ( + " 2.5.2 and above": ( ivy.int8, ivy.int16, ivy.int32, @@ -194,8 +194,8 @@ def rep_method(*args, **kwargs): "2.4.0 and below": (ivy.float16, ivy.float32, ivy.float64), "2.4.1 and above": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64), } -valid_uint_dtypes = {"2.5.1 and below": (ivy.uint8,)} -valid_complex_dtypes = {"2.5.1 and below": (ivy.complex64, ivy.complex128)} +valid_uint_dtypes = {" 2.5.2 and below": (ivy.uint8,)} +valid_complex_dtypes = {" 2.5.2 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -235,10 +235,10 @@ def rep_method(*args, **kwargs): ), } -invalid_int_dtypes = {"2.5.1 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_int_dtypes = {" 2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} invalid_float_dtypes = {"2.4.0 and below": (ivy.bfloat16,), "2.4.1 and above": ()} -invalid_uint_dtypes = {"2.5.1 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_complex_dtypes = {"2.5.1 and below": ()} +invalid_uint_dtypes = {" 2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_complex_dtypes = {" 2.5.2 and below": ()} # leave these untouched invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index 14d6692f818bf..134bf6490a97b 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/ivy/functional/backends/paddle/activations.py @@ -42,7 +42,7 @@ def relu( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def leaky_relu( x: paddle.Tensor, @@ -63,7 +63,7 @@ def leaky_relu( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def gelu( x: paddle.Tensor, @@ -88,7 +88,7 @@ def gelu( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def sigmoid( x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None @@ -101,7 +101,7 @@ def sigmoid( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def softmax( x: paddle.Tensor, @@ -151,7 +151,7 @@ def softplus( # Softsign @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def softsign( x: paddle.Tensor, @@ -165,7 +165,7 @@ def softsign( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def log_softmax( x: paddle.Tensor, @@ -184,7 +184,7 @@ def log_softmax( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def mish( x: paddle.Tensor, @@ -201,7 +201,7 @@ def mish( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def hardswish( x: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index d3c160b8894ff..cd8a58f764fb1 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -142,7 +142,7 @@ def empty_like( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "uint8", "int8", @@ -356,7 +356,7 @@ def _slice_at_axis(sl, axis): @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("uint16", "bfloat16", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("uint16", "bfloat16", "float16")}}, backend_version ) def linspace( start: Union[paddle.Tensor, float], @@ -414,7 +414,7 @@ def linspace( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -484,7 +484,7 @@ def ones_like( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -503,7 +503,7 @@ def tril( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -616,7 +616,7 @@ def one_hot( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def frombuffer( diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 68ea20c637437..29bcd515a1f55 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -70,7 +70,7 @@ def bitwise_invert( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -198,7 +198,7 @@ def floor(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def asin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -219,7 +219,7 @@ def asin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def asinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -245,7 +245,7 @@ def asinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def sign( @@ -319,7 +319,7 @@ def sqrt(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def cosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -449,7 +449,7 @@ def multiply( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def cos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -501,7 +501,7 @@ def divide( @with_supported_dtypes( - {"2.5.1 and below": ("float64", "float32", "int64", "int64")}, + {" 2.5.2 and below": ("float64", "float32", "int64", "int64")}, backend_version, ) def fmin( @@ -553,7 +553,7 @@ def greater_equal( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def acos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -578,7 +578,7 @@ def acos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def logical_xor( @@ -599,7 +599,7 @@ def logical_xor( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def logical_and( @@ -633,7 +633,7 @@ def logical_or( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def acosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -658,7 +658,7 @@ def acosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def sin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -703,7 +703,7 @@ def not_equal( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def tanh( @@ -756,7 +756,7 @@ def bitwise_or( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def sinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -803,7 +803,7 @@ def square( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def pow( x1: paddle.Tensor, @@ -851,7 +851,7 @@ def _round_half_to_even(x): # This function aims to mimic the behavior of np.round similar to how tf.experimental.numpy.round does # noqa: E501 # Reference for tf.experimental.numpy.round:https://github.com/tensorflow/tensorflow/blob/v2.13.0/tensorflow/python/ops/numpy_ops/np_array_ops.py#L724 # noqa: E501 @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16", "float16", "complex")}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16", "float16", "complex")}}, backend_version ) def round( x: paddle.Tensor, /, *, decimals: int = 0, out: Optional[paddle.Tensor] = None @@ -893,7 +893,7 @@ def trunc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_supported_dtypes( - {"2.5.1 and below": ("float64", "float32")}, + {" 2.5.2 and below": ("float64", "float32")}, backend_version, ) def trapz( @@ -963,7 +963,7 @@ def abs( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def logaddexp( x1: paddle.Tensor, x2: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None @@ -976,7 +976,7 @@ def logaddexp( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def logaddexp2( x1: Union[paddle.Tensor, float, list, tuple], @@ -991,7 +991,7 @@ def logaddexp2( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -1012,7 +1012,7 @@ def real(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def tan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1033,7 +1033,7 @@ def tan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def atan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1054,7 +1054,7 @@ def atan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128", "bool")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, backend_version, ) def atan2( @@ -1123,7 +1123,7 @@ def subtract( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128", "bool")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, backend_version, ) def remainder( @@ -1151,7 +1151,7 @@ def remainder( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bool", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def atanh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1201,7 +1201,7 @@ def bitwise_left_shift( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128", "bool")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, backend_version, ) def erf(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1327,7 +1327,7 @@ def fmod( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8", "uint8")}}, + {" 2.5.2 and below": {"cpu": ("int8", "uint8")}}, backend_version, ) def lcm( @@ -1363,7 +1363,7 @@ def angle( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version + {" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version ) def gcd( x1: Union[paddle.Tensor, int, list, tuple], @@ -1378,7 +1378,7 @@ def gcd( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", diff --git a/ivy/functional/backends/paddle/experimental/activations.py b/ivy/functional/backends/paddle/experimental/activations.py index 7b146de17f430..7557f0ea27594 100644 --- a/ivy/functional/backends/paddle/experimental/activations.py +++ b/ivy/functional/backends/paddle/experimental/activations.py @@ -14,7 +14,7 @@ @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def logit( x: paddle.Tensor, @@ -44,7 +44,7 @@ def logit( ).cast(x.dtype) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, backend_version) def thresholded_relu( x: paddle.Tensor, /, @@ -56,7 +56,7 @@ def thresholded_relu( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64")}, backend_version + {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def relu6( x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None @@ -67,7 +67,7 @@ def relu6( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64")}, backend_version + {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def logsigmoid( input: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None @@ -82,7 +82,7 @@ def logsigmoid( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64")}, backend_version + {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def selu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -101,7 +101,7 @@ def selu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64")}, backend_version + {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def silu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -110,7 +110,7 @@ def silu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64")}, backend_version + {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def elu( x: paddle.Tensor, /, *, alpha: float = 1.0, out: Optional[paddle.Tensor] = None @@ -128,7 +128,7 @@ def elu( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def hardtanh( x: paddle.Tensor, @@ -154,7 +154,7 @@ def hardtanh( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def tanhshrink( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None @@ -167,7 +167,7 @@ def tanhshrink( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def threshold( x: paddle.Tensor, @@ -188,7 +188,7 @@ def threshold( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def softshrink( x: paddle.Tensor, /, *, lambd: float = 0.5, out: Optional[paddle.Tensor] = None @@ -204,7 +204,7 @@ def softshrink( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def celu( x: paddle.Tensor, @@ -219,7 +219,7 @@ def celu( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("uint16", "float16", "float32", "float64"), } @@ -238,7 +238,7 @@ def scaled_tanh( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version, ) def hardshrink( diff --git a/ivy/functional/backends/paddle/experimental/creation.py b/ivy/functional/backends/paddle/experimental/creation.py index bfbecb80e654c..4e48162ac7dd5 100644 --- a/ivy/functional/backends/paddle/experimental/creation.py +++ b/ivy/functional/backends/paddle/experimental/creation.py @@ -183,7 +183,7 @@ def unsorted_segment_sum( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -257,7 +257,7 @@ def unsorted_segment_mean( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("float16", "int8", "int16", "uint8", "complex", "bool") } }, diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 0f4e6610ac915..ac51c0b1041e9 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -20,7 +20,7 @@ @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "float32", "float64", "int32", @@ -42,7 +42,7 @@ def amax( @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "float32", "float64", "int32", @@ -63,7 +63,7 @@ def amin( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, backend_version, ) def lgamma( @@ -73,7 +73,7 @@ def lgamma( @with_supported_dtypes( - {"2.5.1 and below": ("float64", "float32", "int32", "int64")}, + {" 2.5.2 and below": ("float64", "float32", "int32", "int64")}, backend_version, ) def fmax( @@ -89,7 +89,7 @@ def fmax( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def sinc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: y = ivy.pi * paddle.where(x == 0, paddle.to_tensor(1.0e-20, dtype=x.dtype), x) @@ -153,7 +153,8 @@ def copysign( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("uint8", "int8", "int16", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("uint8", "int8", "int16", "float16")}}, + backend_version, ) def nansum( x: paddle.Tensor, @@ -171,7 +172,7 @@ def nansum( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def isclose( a: paddle.Tensor, @@ -187,7 +188,7 @@ def isclose( @with_unsupported_dtypes( - {"2.5.1 and below": ("float16", "int16", "int8", "uint8")}, backend_version + {" 2.5.2 and below": ("float16", "int16", "int8", "uint8")}, backend_version ) def diff( x: Union[paddle.Tensor, list, tuple], @@ -236,7 +237,7 @@ def hypot( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -276,7 +277,7 @@ def fix( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def nextafter( x1: paddle.Tensor, @@ -317,7 +318,7 @@ def nextafter( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -395,7 +396,7 @@ def _np_ndim(x): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, backend_version, ) def gradient( @@ -653,7 +654,7 @@ def count_nonzero( @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "complex64", "complex128", "float32", @@ -770,7 +771,7 @@ def _is_scalar(x): # TODO: Repalce once native function becomes available. # Compute an approximation of the error function complement (1 - erf(x)). @with_supported_dtypes( - {"2.5.1 and below": ("float64", "float32")}, + {" 2.5.2 and below": ("float64", "float32")}, backend_version, ) def erfc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index 2cfa153cac992..8e564bd523247 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -30,7 +30,7 @@ def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_ @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -97,7 +97,7 @@ def max_pool1d( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -168,7 +168,7 @@ def max_pool2d( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -300,7 +300,7 @@ def dct( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "bool", "float16")}, backend_version + {" 2.5.2 and below": ("bfloat16", "bool", "float16")}, backend_version ) def fft( x: paddle.Tensor, @@ -344,7 +344,7 @@ def fft( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -366,7 +366,7 @@ def dropout1d( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -388,7 +388,7 @@ def dropout2d( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -421,7 +421,7 @@ def ifft( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("int8", "float32", "float64"), "gpu": ("int8", "bfloat16", "float16", "float32", "float64"), }, @@ -513,7 +513,7 @@ def rfft( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "float16", "complex64", "complex128", "bool")}, + {" 2.5.2 and below": ("bfloat16", "float16", "complex64", "complex128", "bool")}, backend_version, ) def rfftn( @@ -530,7 +530,7 @@ def rfftn( @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "complex64", "complex128", ) @@ -552,7 +552,7 @@ def fft2( # stft @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "complex64", "complex128", ) diff --git a/ivy/functional/backends/paddle/experimental/linear_algebra.py b/ivy/functional/backends/paddle/experimental/linear_algebra.py index d402779d15f5f..75e538afed720 100644 --- a/ivy/functional/backends/paddle/experimental/linear_algebra.py +++ b/ivy/functional/backends/paddle/experimental/linear_algebra.py @@ -13,7 +13,7 @@ @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8", "int16", "uint8", "float16", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8", "float16", "bfloat16")}}, backend_version, ) def diagflat( @@ -47,7 +47,7 @@ def diagflat( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8", "uint8", "int16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("int8", "uint8", "int16")}}, backend_version ) def kron( a: paddle.Tensor, @@ -91,7 +91,8 @@ def adjoint( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8", "uint8", "int16", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("int8", "uint8", "int16", "float16")}}, + backend_version, ) def solve_triangular( x1: paddle.Tensor, @@ -132,7 +133,7 @@ def lu_factor( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "float32", "float64", @@ -167,7 +168,7 @@ def dot( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "float32", "float64", diff --git a/ivy/functional/backends/paddle/experimental/losses.py b/ivy/functional/backends/paddle/experimental/losses.py index d2ec322ea218e..0efcc0d6f0f66 100644 --- a/ivy/functional/backends/paddle/experimental/losses.py +++ b/ivy/functional/backends/paddle/experimental/losses.py @@ -14,7 +14,7 @@ @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "float16", "int8", @@ -42,7 +42,7 @@ def l1_loss( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -72,7 +72,7 @@ def smooth_l1_loss( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "float16", "int8", @@ -100,7 +100,7 @@ def huber_loss( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "float16", "int8", @@ -127,7 +127,7 @@ def soft_margin_loss( @with_supported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float32", "float64")}}, + {" 2.5.2 and below": {"cpu": ("float32", "float64")}}, backend_version, ) def kl_div( @@ -195,7 +195,7 @@ def _validate_poisson_nll_params( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } diff --git a/ivy/functional/backends/paddle/experimental/manipulation.py b/ivy/functional/backends/paddle/experimental/manipulation.py index 62b7486b0d215..e40ac7cc23bd0 100644 --- a/ivy/functional/backends/paddle/experimental/manipulation.py +++ b/ivy/functional/backends/paddle/experimental/manipulation.py @@ -94,7 +94,7 @@ @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int16", "int8", "uint8", @@ -120,7 +120,7 @@ def moveaxis( @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, backend_version, ) def pad( @@ -178,7 +178,7 @@ def pad( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -203,7 +203,7 @@ def heaviside( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def flipud( @@ -228,7 +228,7 @@ def vstack( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int16", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("int16", "bfloat16")}}, backend_version, ) def hstack( @@ -245,7 +245,7 @@ def hstack( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def rot90( @@ -261,7 +261,7 @@ def rot90( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def top_k( @@ -288,7 +288,7 @@ def top_k( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def fliplr( @@ -456,7 +456,7 @@ def atleast_2d( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version, ) def atleast_3d( @@ -481,7 +481,7 @@ def atleast_3d( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "bool", "float16", "int16", "int8", "uint8")}, + {" 2.5.2 and below": ("bfloat16", "bool", "float16", "int16", "int8", "uint8")}, backend_version, ) def take_along_axis( @@ -603,7 +603,7 @@ def concat_from_sequence( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version + {" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version ) def unique_consecutive( x: paddle.Tensor, @@ -666,7 +666,8 @@ def unique_consecutive( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8", "int16", "uint8", "float16")}}, backend_version + {" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8", "float16")}}, + backend_version, ) def fill_diagonal( a: paddle.Tensor, @@ -731,7 +732,7 @@ def _take_with_axis( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("int64", "float64", "int32", "uint8", "float32", "bool") } }, @@ -868,7 +869,7 @@ def trim_zeros(a: paddle.Tensor, /, *, trim: Optional[str] = "bf") -> paddle.Ten @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def put_along_axis( arr: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/experimental/norms.py b/ivy/functional/backends/paddle/experimental/norms.py index a3ddb0728c0e4..7f58ca15dfdfe 100644 --- a/ivy/functional/backends/paddle/experimental/norms.py +++ b/ivy/functional/backends/paddle/experimental/norms.py @@ -12,7 +12,7 @@ # use numpy implementation with ivy functions @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -105,7 +105,7 @@ def batch_norm( ) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, backend_version) def l1_normalize( x: paddle.Tensor, /, *, axis: int = None, out: paddle.Tensor = None ) -> paddle.Tensor: diff --git a/ivy/functional/backends/paddle/experimental/random.py b/ivy/functional/backends/paddle/experimental/random.py index 2f4fd90678077..99c8871e9c777 100644 --- a/ivy/functional/backends/paddle/experimental/random.py +++ b/ivy/functional/backends/paddle/experimental/random.py @@ -16,7 +16,7 @@ @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", diff --git a/ivy/functional/backends/paddle/experimental/sparse_array.py b/ivy/functional/backends/paddle/experimental/sparse_array.py index c79a7c97ffac3..ff86ae8e1a77a 100644 --- a/ivy/functional/backends/paddle/experimental/sparse_array.py +++ b/ivy/functional/backends/paddle/experimental/sparse_array.py @@ -19,7 +19,7 @@ def is_native_sparse_array(x: paddle.Tensor) -> bool: @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("int8",)}}, backend_version ) def native_sparse_array( data=None, diff --git a/ivy/functional/backends/paddle/experimental/statistical.py b/ivy/functional/backends/paddle/experimental/statistical.py index 84ed593da8fd9..dabe9ac525381 100644 --- a/ivy/functional/backends/paddle/experimental/statistical.py +++ b/ivy/functional/backends/paddle/experimental/statistical.py @@ -14,7 +14,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def median( @@ -32,7 +32,7 @@ def median( ) else: ret = paddle.median(input, axis=axis, keepdim=True) - # keepdims is set to True because in versions up to 2.5.1 + # keepdims is set to True because in versions up to 2.5.2 # there was a problem when the axis was defined, and it was the # only axis in the tensor, so it needs to be handled manually if not keepdims: @@ -48,7 +48,7 @@ def median( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64", "int64")}, backend_version + {" 2.5.2 and below": ("complex", "float32", "float64", "int64")}, backend_version ) def nanmean( a: paddle.Tensor, @@ -101,7 +101,7 @@ def _validate_quantile(q): @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -140,7 +140,7 @@ def nanmin( return result -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, backend_version) def nanprod( a: paddle.Tensor, /, @@ -308,7 +308,7 @@ def _compute_quantile_wrapper( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -382,7 +382,7 @@ def histogram( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def nanmedian( input: paddle.Tensor, @@ -401,7 +401,7 @@ def nanmedian( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -433,7 +433,7 @@ def unravel_index( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -556,7 +556,7 @@ def cov( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "bool", "float32", "float64")}, + {" 2.5.2 and below": ("complex", "bool", "float32", "float64")}, backend_version, ) def cummax( @@ -681,7 +681,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("uint8", "int8", "int16")}}, + {" 2.5.2 and below": {"cpu": ("uint8", "int8", "int16")}}, backend_version, ) def cummin( diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 46ba0a4a23d3c..08b1d141e4efb 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -86,7 +86,7 @@ def _squeeze_helper(query, x_ndim): @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("int8", "int16", "float16", "complex64", "complex128") } }, diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index 3d3cd8f84785c..c248417947d02 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -104,7 +104,7 @@ def grad_(x): @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, backend_version + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def execute_with_gradients( func, xs, /, *, retain_grads=False, xs_grad_idxs=((0,),), ret_grad_idxs=((0,),) diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index f70c374bc70de..cfce593aed238 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -157,7 +157,7 @@ def conv1d( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16", "bfloat16")}}, + {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version, ) def conv1d_transpose( @@ -216,7 +216,7 @@ def conv2d( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version, ) def conv2d_transpose( @@ -275,7 +275,7 @@ def depthwise_conv2d( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version, ) def conv3d( @@ -334,7 +334,7 @@ def conv3d_transpose( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("float16",)}}, + {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version, ) def conv_general_dilated( diff --git a/ivy/functional/backends/paddle/linear_algebra.py b/ivy/functional/backends/paddle/linear_algebra.py index 3e7d5285849f2..60405f08b3005 100644 --- a/ivy/functional/backends/paddle/linear_algebra.py +++ b/ivy/functional/backends/paddle/linear_algebra.py @@ -24,7 +24,7 @@ @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -91,7 +91,7 @@ def _cross(x1, x2, axisa, axisb, axisc, axis): @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def det(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -183,7 +183,7 @@ def inner( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def inv( @@ -252,7 +252,7 @@ def matmul( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_norm( @@ -334,7 +334,7 @@ def eig( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_power( @@ -344,7 +344,7 @@ def matrix_power( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_rank( @@ -441,7 +441,7 @@ def tensorsolve( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def qr( @@ -457,7 +457,7 @@ def qr( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def slogdet( @@ -476,7 +476,7 @@ def slogdet( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def solve( @@ -503,7 +503,7 @@ def solve( return ret -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, backend_version) def svd( x: paddle.Tensor, /, *, full_matrices: bool = True, compute_uv: bool = True ) -> Union[paddle.Tensor, Tuple[paddle.Tensor, ...]]: @@ -517,7 +517,7 @@ def svd( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("complex64", "complex128")}}, + {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def svdvals( @@ -532,7 +532,7 @@ def svdvals( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64")}, backend_version + {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def tensordot( x1: paddle.Tensor, @@ -548,7 +548,7 @@ def tensordot( @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "int8", "int16", @@ -624,7 +624,7 @@ def vector_norm( @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, backend_version, ) def diag( @@ -638,7 +638,11 @@ def diag( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("uint8", "int8", "int16", "complex64", "complex128")}}, + { + " 2.5.2 and below": { + "cpu": ("uint8", "int8", "int16", "complex64", "complex128") + } + }, backend_version, ) def vander( @@ -660,7 +664,7 @@ def vander( @with_unsupported_dtypes( - {"2.5.1 and below": ("unsigned", "int8", "int16", "float16")}, + {" 2.5.2 and below": ("unsigned", "int8", "int16", "float16")}, backend_version, ) def vector_to_skew_symmetric_matrix( diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index 58adc9bec6ada..17236d5a584a5 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -74,7 +74,7 @@ def expand_dims( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def flip( @@ -91,7 +91,7 @@ def flip( @with_unsupported_dtypes( - {"2.5.1 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version + {" 2.5.2 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version ) def permute_dims( x: paddle.Tensor, @@ -159,7 +159,7 @@ def reshape( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def roll( @@ -174,7 +174,7 @@ def roll( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "float16", "int16")}, backend_version + {" 2.5.2 and below": ("bfloat16", "float16", "int16")}, backend_version ) def squeeze( x: paddle.Tensor, @@ -201,7 +201,7 @@ def squeeze( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int16", "uint8", "int8", "float16")}}, + {" 2.5.2 and below": {"cpu": ("int16", "uint8", "int8", "float16")}}, backend_version, ) def stack( @@ -249,7 +249,7 @@ def stack( # ------# -@with_unsupported_dtypes({"2.5.1 and below": ("int16",)}, backend_version) +@with_unsupported_dtypes({" 2.5.2 and below": ("int16",)}, backend_version) def split( x: paddle.Tensor, /, @@ -299,7 +299,7 @@ def split( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def repeat( @@ -335,7 +335,7 @@ def repeat( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def tile( @@ -378,7 +378,7 @@ def tile( @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bfloat16", "float16", "int8", @@ -462,7 +462,7 @@ def clip( @with_unsupported_dtypes( - {"2.5.1 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version + {" 2.5.2 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version ) def unstack( x: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/random.py b/ivy/functional/backends/paddle/random.py index c2a846e3f4b5a..2410f9548f17e 100644 --- a/ivy/functional/backends/paddle/random.py +++ b/ivy/functional/backends/paddle/random.py @@ -25,7 +25,7 @@ @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8",)}}, + {" 2.5.2 and below": {"cpu": ("int8",)}}, backend_version, ) def random_uniform( @@ -56,7 +56,7 @@ def random_uniform( @with_unsupported_dtypes( - {"2.5.1 and below": ("float16", "int16", "int8")}, backend_version + {" 2.5.2 and below": ("float16", "int16", "int8")}, backend_version ) def random_normal( *, @@ -77,7 +77,7 @@ def random_normal( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "float32", "float64", @@ -108,7 +108,7 @@ def multinomial( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8",)}}, + {" 2.5.2 and below": {"cpu": ("int8",)}}, backend_version, ) def randint( diff --git a/ivy/functional/backends/paddle/searching.py b/ivy/functional/backends/paddle/searching.py index 64b68a8a63ba1..5e242deb21ad4 100644 --- a/ivy/functional/backends/paddle/searching.py +++ b/ivy/functional/backends/paddle/searching.py @@ -16,7 +16,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {" 2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, backend_version, ) def argmax( @@ -48,7 +48,7 @@ def argmax( @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "bool", "complex", "float16", "int8")}, + {" 2.5.2 and below": ("bfloat16", "bool", "complex", "float16", "int8")}, backend_version, ) def argmin( @@ -80,7 +80,7 @@ def argmin( @with_unsupported_dtypes( - {"2.5.1 and below": ("float16", "int8", "uint8")}, backend_version + {" 2.5.2 and below": ("float16", "int8", "uint8")}, backend_version ) def nonzero( x: paddle.Tensor, @@ -161,7 +161,7 @@ def where( @with_unsupported_dtypes( - {"2.5.1 and below": ("float16", "int8", "uint8")}, backend_version + {" 2.5.2 and below": ("float16", "int8", "uint8")}, backend_version ) def argwhere( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None diff --git a/ivy/functional/backends/paddle/set.py b/ivy/functional/backends/paddle/set.py index f59684732568b..b736113350159 100644 --- a/ivy/functional/backends/paddle/set.py +++ b/ivy/functional/backends/paddle/set.py @@ -10,7 +10,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_all( x: paddle.Tensor, @@ -88,7 +88,7 @@ def unique_all( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_counts(x: paddle.Tensor, /) -> Tuple[paddle.Tensor, paddle.Tensor]: unique, counts = paddle.unique(x, return_counts=True) @@ -111,7 +111,7 @@ def unique_counts(x: paddle.Tensor, /) -> Tuple[paddle.Tensor, paddle.Tensor]: @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_inverse( x: paddle.Tensor, @@ -146,7 +146,7 @@ def unique_inverse( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_values( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None diff --git a/ivy/functional/backends/paddle/sorting.py b/ivy/functional/backends/paddle/sorting.py index 5712826cda9c8..c8309843e48a2 100644 --- a/ivy/functional/backends/paddle/sorting.py +++ b/ivy/functional/backends/paddle/sorting.py @@ -9,7 +9,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def argsort( x: paddle.Tensor, @@ -24,7 +24,7 @@ def argsort( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def sort( x: paddle.Tensor, @@ -39,7 +39,7 @@ def sort( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def searchsorted( x: paddle.Tensor, @@ -76,7 +76,7 @@ def searchsorted( @with_unsupported_device_and_dtypes( - {"2.5.1 and below": {"cpu": ("int8", "uint8", "int16", "float16", "complex")}}, + {" 2.5.2 and below": {"cpu": ("int8", "uint8", "int16", "float16", "complex")}}, backend_version, ) def msort( diff --git a/ivy/functional/backends/paddle/statistical.py b/ivy/functional/backends/paddle/statistical.py index 84cd7c0c38776..a7d82a4cb5f25 100644 --- a/ivy/functional/backends/paddle/statistical.py +++ b/ivy/functional/backends/paddle/statistical.py @@ -22,7 +22,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def min( @@ -51,7 +51,7 @@ def min( @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def max( @@ -89,7 +89,7 @@ def max( @with_supported_dtypes( - {"2.5.1 and below": ("bool", "complex", "float32", "float64")}, backend_version + {" 2.5.2 and below": ("bool", "complex", "float32", "float64")}, backend_version ) def mean( x: paddle.Tensor, @@ -119,7 +119,7 @@ def mean( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def prod( x: paddle.Tensor, @@ -167,7 +167,7 @@ def std( return _std(x, axis, correction, keepdims).cast(x.dtype) -@with_unsupported_dtypes({"2.5.1 and below": ("int8", "uint8")}, backend_version) +@with_unsupported_dtypes({" 2.5.2 and below": ("int8", "uint8")}, backend_version) def sum( x: paddle.Tensor, /, @@ -206,7 +206,7 @@ def var( # Extra # # ----- # @with_supported_dtypes( - {"2.5.1 and below": ("complex", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def cumprod( @@ -256,7 +256,7 @@ def cumprod( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def cumsum( x: paddle.Tensor, @@ -305,7 +305,7 @@ def cumsum( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("float32", "float64", "complex64", "complex128"), "gpu": ( "bfloat16", diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index ce11fd0eadd96..1deb9f4fa5b7a 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -7,7 +7,7 @@ "numpy": "1.25.2", "jax": "0.4.14", "scipy": "1.10.1", - "paddle": "2.5.1", + "paddle": " 2.5.2", "sklearn": "1.3.0", "xgboost": "1.7.6", "torchvision": "0.15.2.", diff --git a/ivy/functional/frontends/jax/array.py b/ivy/functional/frontends/jax/array.py index 7d22cdd83974d..c6dd9eac7fcb3 100644 --- a/ivy/functional/frontends/jax/array.py +++ b/ivy/functional/frontends/jax/array.py @@ -74,7 +74,7 @@ def astype(self, dtype): f"Dtype {self.dtype} is not castable to {dtype}" ) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def argmax( self, /, @@ -90,7 +90,7 @@ def argmax( keepdims=keepdims, ) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def argmin( self, /, diff --git a/ivy/functional/frontends/jax/numpy/fft.py b/ivy/functional/frontends/jax/numpy/fft.py index 4291615222f8e..9e558898dadb8 100644 --- a/ivy/functional/frontends/jax/numpy/fft.py +++ b/ivy/functional/frontends/jax/numpy/fft.py @@ -19,7 +19,7 @@ def fft2(a, s=None, axes=(-2, -1), norm=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def fftfreq(n, d=1.0, *, dtype=None): if not isinstance( n, (int, type(ivy.int8), type(ivy.int16), type(ivy.int32), type(ivy.int64)) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 59aab1bf27a48..2a4ef435a94df 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -90,7 +90,7 @@ def ceil(x, /): return ivy.ceil(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def clip(a, a_min=None, a_max=None, out=None): return ivy.array(ivy.clip(a, a_min, a_max), dtype=a.dtype) diff --git a/ivy/functional/frontends/paddle/creation.py b/ivy/functional/frontends/paddle/creation.py index 5a110fb73d326..1ec66e3ca191b 100644 --- a/ivy/functional/frontends/paddle/creation.py +++ b/ivy/functional/frontends/paddle/creation.py @@ -7,14 +7,14 @@ ) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def arange(start, end=None, step=1, dtype=None, name=None): return ivy.arange(start, end, step=step, dtype=dtype) @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64", "bool")}, + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64", "bool")}, "paddle", ) @to_ivy_arrays_and_back @@ -30,7 +30,7 @@ def assign(x, output=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("bfloat16", "uint16", "uint32", "uint64")}, "paddle" + {" 2.5.2 and below": ("bfloat16", "uint16", "uint32", "uint64")}, "paddle" ) @to_ivy_arrays_and_back def clone(x): @@ -38,7 +38,7 @@ def clone(x): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -54,7 +54,7 @@ def complex(real, imag, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diag(x, offset=0, padding_value=0, name=None): @@ -69,7 +69,7 @@ def diag(x, offset=0, padding_value=0, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diagflat(x, offset=0, name=None): @@ -105,7 +105,7 @@ def full_like(x, fill_value, /, *, dtype=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def linspace(start, stop, num, dtype=None, name=None): @@ -113,7 +113,7 @@ def linspace(start, stop, num, dtype=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def logspace(start, stop, num, base=10.0, dtype=None, name=None): @@ -121,14 +121,14 @@ def logspace(start, stop, num, base=10.0, dtype=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def meshgrid(*args, **kwargs): return ivy.meshgrid(*args, indexing="ij") -@with_unsupported_dtypes({"2.5.1 and below": "int8"}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": "int8"}, "paddle") @to_ivy_arrays_and_back def ones(shape, /, *, dtype=None, name=None): dtype = "float32" if dtype is None else dtype @@ -136,7 +136,7 @@ def ones(shape, /, *, dtype=None, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" + {" 2.5.2 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" ) @to_ivy_arrays_and_back def ones_like(x, /, *, dtype=None, name=None): @@ -152,7 +152,7 @@ def to_tensor(data, /, *, dtype=None, place=None, stop_gradient=True): @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "uint8", "int8", "int16", @@ -169,7 +169,7 @@ def tril(x, diagonal=0, name=None): return ivy.tril(x, k=diagonal) -@with_supported_dtypes({"2.5.1 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def tril_indices(row, col, offset=0, dtype="int64"): arr = ivy.tril_indices(row, col, offset) @@ -179,7 +179,7 @@ def tril_indices(row, col, offset=0, dtype="int64"): @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "uint8", "int8", "int16", @@ -196,7 +196,7 @@ def triu(x, diagonal=0, name=None): return ivy.triu(x, k=diagonal) -@with_supported_dtypes({"2.5.1 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def triu_indices(row, col=None, offset=0, dtype="int64"): arr = ivy.triu_indices(row, col, offset) @@ -206,7 +206,7 @@ def triu_indices(row, col=None, offset=0, dtype="int64"): return arr -@with_unsupported_dtypes({"2.5.1 and below": "int8"}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": "int8"}, "paddle") @to_ivy_arrays_and_back def zeros(shape, /, *, dtype=None, name=None): dtype = "float32" if dtype is None else dtype @@ -214,7 +214,7 @@ def zeros(shape, /, *, dtype=None, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" + {" 2.5.2 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" ) @to_ivy_arrays_and_back def zeros_like(x, /, *, dtype=None, name=None): diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 11eb1849bdcb0..9762afa2123b9 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -7,7 +7,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128")}, + {" 2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -18,7 +18,7 @@ def fft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float32", @@ -44,7 +44,7 @@ def fftfreq(n, d=1.0, dtype=None, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float32", @@ -73,7 +73,7 @@ def fftshift(x, axes=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128")}, + {" 2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -95,7 +95,7 @@ def hfft(x, n=None, axes=-1, norm="backward", name=None): @with_supported_dtypes( - {"2.5.1 and below": "complex64"}, + {" 2.5.2 and below": "complex64"}, "paddle", ) @to_ivy_arrays_and_back @@ -116,7 +116,7 @@ def hfft2(x, s=None, axis=(-2, -1), norm="backward"): @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128")}, + {" 2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -126,7 +126,7 @@ def ifft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128")}, + {" 2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -137,7 +137,7 @@ def ifftn(x, s=None, axes=None, norm="backward", name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float32", @@ -165,7 +165,7 @@ def ifftshift(x, axes=None, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float32", @@ -199,7 +199,7 @@ def ihfft2(x, s=None, axes=(-2, -1), norm="backward", name=None): @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128")}, + {" 2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -218,7 +218,7 @@ def irfft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float16", @@ -254,7 +254,7 @@ def irfft2(x, s=None, axes=(-2, -1), norm="backward"): @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128")}, + {" 2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -305,7 +305,7 @@ def irfftn(x, s=None, axes=None, norm="backward", name=None): return result_t -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rfft(x, n=None, axis=-1, norm="backward", name=None): return ivy.dft(x, axis=axis, inverse=False, onesided=True, dft_length=n, norm=norm) diff --git a/ivy/functional/frontends/paddle/linalg.py b/ivy/functional/frontends/paddle/linalg.py index e730b7b326027..cc3330ce4fe75 100644 --- a/ivy/functional/frontends/paddle/linalg.py +++ b/ivy/functional/frontends/paddle/linalg.py @@ -14,7 +14,7 @@ def bincount(x, weights=None, minlength=0, name=None): # bmm -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def bmm(x, y, transpose_x=False, transpose_y=False, name=None): if len(ivy.shape(x)) != 3 or len(ivy.shape(y)) != 3: @@ -24,14 +24,14 @@ def bmm(x, y, transpose_x=False, transpose_y=False, name=None): # cholesky -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cholesky(x, /, *, upper=False, name=None): return ivy.cholesky(x, upper=upper) # cholesky_solve -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cholesky_solve(x, y, /, *, upper=False, name=None): if upper: @@ -41,7 +41,7 @@ def cholesky_solve(x, y, /, *, upper=False, name=None): # cond -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cond(x, p=None, name=None): ret = ivy.cond(x, p=p, out=name) @@ -51,7 +51,7 @@ def cond(x, p=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def cross(x, y, /, *, axis=9, name=None): @@ -62,7 +62,7 @@ def cross(x, y, /, *, axis=9, name=None): # diagonal @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float64", @@ -87,7 +87,7 @@ def dist(x, y, p=2): # dot -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def dot(x, y, name=None): x, y = promote_types_of_paddle_inputs(x, y) @@ -151,7 +151,7 @@ def lu_unpack(lu_data, lu_pivots, unpack_datas=True, unpack_pivots=True, *, out= # matmul -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def matmul(x, y, transpose_x=False, transpose_y=False, name=None): x, y = promote_types_of_paddle_inputs(x, y) @@ -159,21 +159,21 @@ def matmul(x, y, transpose_x=False, transpose_y=False, name=None): # matrix_power -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def matrix_power(x, n, name=None): return ivy.matrix_power(x, n) # mv -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def mv(x, vec, name=None): return ivy.dot(x, vec) # norm -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def norm(x, p="fro", axis=None, keepdim=False, name=None): if axis is None and p is not None: @@ -226,7 +226,7 @@ def norm(x, p="fro", axis=None, keepdim=False, name=None): # pinv -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def pinv(x, rcond=1e-15, hermitian=False, name=None): # TODO: Add hermitian functionality @@ -234,21 +234,21 @@ def pinv(x, rcond=1e-15, hermitian=False, name=None): # qr -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def qr(x, mode="reduced", name=None): return ivy.qr(x, mode=mode) # solve -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def solve(x, y, name=None): return ivy.solve(x, y) # transpose -@with_unsupported_dtypes({"2.5.1 and below": ("uint8", "int8", "int16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("uint8", "int8", "int16")}, "paddle") @to_ivy_arrays_and_back def transpose(x, perm, name=None): return ivy.permute_dims(x, axes=perm) diff --git a/ivy/functional/frontends/paddle/logic.py b/ivy/functional/frontends/paddle/logic.py index 8b691b4380d42..db997c4ca72fa 100644 --- a/ivy/functional/frontends/paddle/logic.py +++ b/ivy/functional/frontends/paddle/logic.py @@ -13,7 +13,7 @@ @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "float32", "float64", "bool", @@ -35,7 +35,7 @@ def allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "uint8", "int8", @@ -54,7 +54,7 @@ def bitwise_and(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "uint8", "int8", @@ -73,7 +73,7 @@ def bitwise_not(x, out=None, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "uint8", "int8", @@ -92,7 +92,7 @@ def bitwise_or(x, y, name=None, out=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "uint8", "int8", @@ -110,7 +110,8 @@ def bitwise_xor(x, y, /, *, name=None, out=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle" + {" 2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + "paddle", ) @to_ivy_arrays_and_back def equal(x, y, /, *, name=None): @@ -119,7 +120,7 @@ def equal(x, y, /, *, name=None): @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "uint8", "int8", "int16", @@ -136,7 +137,7 @@ def equal_all(x, y, /, *, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -145,7 +146,7 @@ def greater_equal(x, y, /, *, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -154,7 +155,8 @@ def greater_than(x, y, /, *, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle" + {" 2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + "paddle", ) @to_ivy_arrays_and_back def is_empty(x, name=None): @@ -168,7 +170,7 @@ def is_tensor(x): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "float32", "float64", ) @@ -181,7 +183,7 @@ def isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -190,7 +192,7 @@ def less_equal(x, y, /, *, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -200,7 +202,7 @@ def less_than(x, y, /, *, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -220,7 +222,7 @@ def logical_and(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -240,7 +242,7 @@ def logical_not(x, /, *, name=None, out=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -260,7 +262,7 @@ def logical_or(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -279,7 +281,8 @@ def logical_xor(x, y, /, *, name=None, out=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle" + {" 2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + "paddle", ) @to_ivy_arrays_and_back def not_equal(x, y, /, *, name=None): diff --git a/ivy/functional/frontends/paddle/manipulation.py b/ivy/functional/frontends/paddle/manipulation.py index 5c99d82d61ccf..6ed5071982517 100644 --- a/ivy/functional/frontends/paddle/manipulation.py +++ b/ivy/functional/frontends/paddle/manipulation.py @@ -10,14 +10,14 @@ ) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def abs(x, name=None): return ivy.abs(x) @with_supported_dtypes( - {"2.5.1 and below": ("bool", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -27,7 +27,7 @@ def broadcast_to(x, shape, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "float16", "float32", @@ -44,14 +44,14 @@ def cast(x, dtype): return ivy.astype(x, dtype) -@with_unsupported_dtypes({"2.5.1 and below": ("int8", "int16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("int8", "int16")}, "paddle") @to_ivy_arrays_and_back def concat(x, axis, name=None): return ivy.concat(x, axis=axis) @with_supported_dtypes( - {"2.5.1 and below": ("bool", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -60,7 +60,7 @@ def expand(x, shape, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("int8", "uint8", "int16", "float16")}, + {" 2.5.2 and below": ("int8", "uint8", "int16", "float16")}, "paddle", ) @to_ivy_arrays_and_back @@ -69,7 +69,7 @@ def flip(x, axis, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("bool", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -78,7 +78,7 @@ def gather(params, indices, axis=-1, batch_dims=0, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, + {" 2.5.2 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, "paddle", ) @to_ivy_arrays_and_back @@ -93,7 +93,7 @@ def put_along_axis(arr, indices, values, axis, reduce="assign"): @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float32", "float64")}, + {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -126,7 +126,7 @@ def roll(x, shifts, axis=None, name=None): @with_supported_device_and_dtypes( { - "2.5.1 and above": { + " 2.5.2 and above": { "cpu": ( "bool", "int32", @@ -145,7 +145,7 @@ def rot90(x, k=1, axes=(0, 1), name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("int16", "complex64", "complex128")}, + {" 2.5.2 and below": ("int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -154,7 +154,7 @@ def split(x, num_or_sections, axis=0, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("float16", "bfloat16", "int8", "int16")}, + {" 2.5.2 and below": ("float16", "bfloat16", "int8", "int16")}, "paddle", ) @to_ivy_arrays_and_back @@ -172,7 +172,7 @@ def take_along_axis(arr, indices, axis): @with_unsupported_dtypes( - {"2.5.1 and below": ("int8", "uint8", "int16", "float16")}, + {" 2.5.2 and below": ("int8", "uint8", "int16", "float16")}, "paddle", ) @to_ivy_arrays_and_back @@ -186,7 +186,7 @@ def tolist(x): @with_supported_dtypes( - {"2.5.1 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + {" 2.5.2 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -198,7 +198,7 @@ def unbind(input, axis=0): @with_supported_dtypes( - {"2.5.1 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + {" 2.5.2 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -208,7 +208,7 @@ def unique_consecutive(x, axis=0): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "float32", "float64", "int32", diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index a519a4798a449..dc53e7992d9df 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -8,26 +8,26 @@ from ivy.functional.frontends.paddle.func_wrapper import to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def abs(x, name=None): return ivy.abs(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def acos(x, name=None): return ivy.acos(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def acosh(x, name=None): return ivy.acosh(x) @with_unsupported_dtypes( - {"2.5.1 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" + {" 2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" ) @to_ivy_arrays_and_back def add(x, y, name=None): @@ -35,7 +35,7 @@ def add(x, y, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" + {" 2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" ) @to_ivy_arrays_and_back def add_(x, y, name=None): @@ -43,7 +43,7 @@ def add_(x, y, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def addmm(input, x, y, beta=1.0, alpha=1.0, name=None): @@ -58,7 +58,7 @@ def all(x, axis, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def amax(x, axis=None, keepdims=False): @@ -76,7 +76,7 @@ def amax(x, axis=None, keepdims=False): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def amin(x, axis=None, keepdim=False, name=None): @@ -84,7 +84,7 @@ def amin(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128", "float32", "float64")}, + {" 2.5.2 and below": ("complex64", "complex128", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -98,19 +98,19 @@ def any(x, axis=None, keepdim=False, name=None): return ivy.any(x, axis=axis, keepdims=keepdim) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def asin(x, name=None): return ivy.asin(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def asinh(x, name=None): return ivy.asinh(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def atan(x, name=None): return ivy.atan(x) @@ -122,19 +122,19 @@ def atan2(x, y, name=None): return ivy.atan2(x, y) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def atanh(x, name=None): return ivy.atanh(x) -@with_supported_dtypes({"2.5.1 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def broadcast_shape(x_shape, y_shape): return ivy.broadcast_shapes(x_shape, y_shape) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def ceil(x, name=None): return ivy.ceil(x) @@ -146,20 +146,20 @@ def conj(x, name=None): return ivy.conj(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def cos(x, name=None): return ivy.cos(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def cosh(x, name=None): return ivy.cosh(x) @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float16", "float32", "float64", "bool")}, + {" 2.5.2 and below": ("int32", "int64", "float16", "float32", "float64", "bool")}, "paddle", ) @to_ivy_arrays_and_back @@ -169,7 +169,7 @@ def count_nonzero(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float32", @@ -186,14 +186,14 @@ def cumprod(x, dim=None, dtype=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def cumsum(x, axis=None, dtype=None, name=None): return ivy.cumsum(x, axis=axis, dtype=dtype) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def deg2rad(x, name=None): return ivy.deg2rad(x) @@ -201,7 +201,7 @@ def deg2rad(x, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float64", @@ -219,80 +219,82 @@ def diagonal(x, offset=0, axis1=0, axis2=1, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diff(x, n=1, axis=-1, prepend=None, append=None, name=None): return ivy.diff(x, n=n, axis=axis, prepend=prepend, append=append) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def digamma(x, name=None): digamma_fun = ivy.digamma return ivy.array(digamma_fun(x), dtype=x.dtype) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def divide(x, y, name=None): return ivy.divide(x, y) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def erf(x, name=None): return ivy.erf(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def exp(x, name=None): return ivy.exp(x) -@with_supported_dtypes({"2.5.1 and below": ("float16", "float32", "float64")}, "paddle") +@with_supported_dtypes( + {" 2.5.2 and below": ("float16", "float32", "float64")}, "paddle" +) @to_ivy_arrays_and_back def expm1(x, name=None): return ivy.expm1(x) @with_supported_dtypes( - {"2.5.1 and below": ("bfloat16", "float32", "float64")}, "paddle" + {" 2.5.2 and below": ("bfloat16", "float32", "float64")}, "paddle" ) @to_ivy_arrays_and_back def floor(x, name=None): return ivy.floor(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def floor_divide(x, y, name=None): return ivy.floor_divide(x, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def floor_mod(x, y, name=None): return ivy.remainder(x, y) -@with_unsupported_dtypes({"2.5.1 and below": "bfloat16"}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") @to_ivy_arrays_and_back def fmax(x, y, name=None): return ivy.fmax(x, y) -@with_unsupported_dtypes({"2.5.1 and below": "bfloat16"}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") @to_ivy_arrays_and_back def fmin(x, y, name=None): return ivy.fmin(x, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def frac(x, name=None): @@ -300,21 +302,21 @@ def frac(x, name=None): return ivy.subtract(x, y) -@with_supported_dtypes({"2.5.1 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def gcd(x, y, name=None): return ivy.gcd(x, y) @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def heaviside(x, y, name=None): return ivy.heaviside(x, y) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def inner(x, y, name=None): result = ivy.inner(x, y) @@ -325,14 +327,14 @@ def inner(x, y, name=None): return result -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def inverse(x, name=None): return ivy.inv(x) @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isfinite(x, name=None): @@ -340,7 +342,7 @@ def isfinite(x, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isinf(x, name=None): @@ -348,7 +350,7 @@ def isinf(x, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isnan(x, name=None): @@ -356,63 +358,63 @@ def isnan(x, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def kron(x, y, name=None): return ivy.kron(x, y) -@with_supported_dtypes({"2.5.1 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def lcm(x, y, name=None): return ivy.lcm(x, y) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lerp(x, y, weight, name=None): return ivy.lerp(x, y, weight) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lgamma(x, name=None): return ivy.lgamma(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def log(x, name=None): return ivy.log(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log10(x, name=None): return ivy.log10(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log1p(x, name=None): return ivy.log1p(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log2(x, name=None): return ivy.log2(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def logit(x, eps=None, name=None): return ivy.logit(x, eps=eps) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def max(x, axis=None, keepdim=False, name=None): @@ -420,14 +422,14 @@ def max(x, axis=None, keepdim=False, name=None): # maximum -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def maximum(x, y, name=None): return ivy.maximum(x, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def min(x, axis=None, keepdim=False, name=None): @@ -435,7 +437,7 @@ def min(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def minimum(x, y, name=None): @@ -443,27 +445,27 @@ def minimum(x, y, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def mm(input, mat2, name=None): return ivy.matmul(input, mat2) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def multiply(x, y, name=None): return ivy.multiply(x, y) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def nanmean(x, axis=None, keepdims=False): return ivy.nanmean(x, axis=axis, keepdims=keepdims) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def nansum(x, axis=None, dtype=None, name=None): @@ -471,7 +473,7 @@ def nansum(x, axis=None, dtype=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -479,39 +481,39 @@ def neg(x, name=None): return ivy.negative(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def outer(x, y, name=None): return ivy.outer(x, y) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def pow(x, y, name=None): return ivy.pow(x, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def prod(x, axis=None, keepdim=False, dtype=None, name=None): return ivy.prod(x, axis=axis, keepdims=keepdim, dtype=dtype) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def rad2deg(x, name=None): return ivy.rad2deg(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def reciprocal(x, name=None): return ivy.reciprocal(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def remainder(x, y, name=None): return ivy.remainder(x, y) @@ -519,7 +521,7 @@ def remainder(x, y, name=None): @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("float16", "float32", "float64"), } @@ -531,7 +533,7 @@ def remainder_(x, y, name=None): return ivy.inplace_update(x, remainder(x, y)) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def round(x, name=None): sign = ivy.sign(x) @@ -539,49 +541,49 @@ def round(x, name=None): return x -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rsqrt(x, name=None): return 1 / ivy.sqrt(x) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sgn(x, name=None): return ivy.sign(x, np_variant=True) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sign(x, name=None): return ivy.sign(x, np_variant=False) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sin(x, name=None): return ivy.sin(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sinh(x, name=None): return ivy.sinh(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sqrt(x, name=None): return ivy.sqrt(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def square(x, name=None): return ivy.square(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def stanh(x, scale_a=0.67, scale_b=1.7159, name=None): # TODO this function will be simplified as soon as the ivy.stanh(x,a,b) is added @@ -593,7 +595,7 @@ def stanh(x, scale_a=0.67, scale_b=1.7159, name=None): return ret -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def subtract(x, y, name=None): return ivy.subtract(x, y) @@ -601,7 +603,7 @@ def subtract(x, y, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "float64", "int64", ) @@ -619,7 +621,7 @@ def sum(x, axis=None, dtype=None, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int6")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int6")}, "paddle" ) @to_ivy_arrays_and_back def take( @@ -641,20 +643,20 @@ def take( return ivy.gather(x, index, axis=0) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def tan(x, name=None): return ivy.tan(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanh(x, name=None): return ivy.tanh(x) @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) @to_ivy_arrays_and_back def trace(x, offset=0, axis1=0, axis2=1, name=None): diff --git a/ivy/functional/frontends/paddle/nn/functional/activation.py b/ivy/functional/frontends/paddle/nn/functional/activation.py index 19abc10559ea9..15da49749b49d 100644 --- a/ivy/functional/frontends/paddle/nn/functional/activation.py +++ b/ivy/functional/frontends/paddle/nn/functional/activation.py @@ -8,7 +8,7 @@ tanh = paddle_tanh -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def celu( x, @@ -20,7 +20,7 @@ def celu( return ivy.celu(x, alpha=alpha) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def elu( x, @@ -32,13 +32,13 @@ def elu( return ivy.elu(x, alpha=alpha) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def gelu(x, approximate=False, name=None): return ivy.gelu(x, approximate=approximate) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def glu(x, axis=-1, name=None): size = x.shape[axis] @@ -63,21 +63,21 @@ def gumbel_softmax(x, temperature=1.0, hard=False, axis=-1, name=None): return y_soft -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardshrink(x, threshold=0.5, name=None): mask = ivy.logical_or(ivy.greater(x, threshold), ivy.less(x, -threshold)) return ivy.where(mask, x, 0.0) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardsigmoid(x, slope=0.1666667, offset=0.5, name=None): ret = ivy.minimum(ivy.maximum(ivy.add(ivy.multiply(x, slope), offset), 0), 1) return ret -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardswish(x, name=None): relu6_val = ivy.relu6(ivy.add(x, 3)) @@ -85,7 +85,7 @@ def hardswish(x, name=None): return ret -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardtanh( x, @@ -106,13 +106,13 @@ def leaky_relu(x, negative_slope=0.01, name=None): return ivy.leaky_relu(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log_sigmoid(x, name=None): return -ivy.softplus(-x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log_softmax(x, axis=-1, dtype=None, name=None): x = ivy.astype(x, dtype) if dtype else x @@ -121,31 +121,31 @@ def log_softmax(x, axis=-1, dtype=None, name=None): return ret -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def mish(x, name=None): return ivy.mish(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def prelu(x, weight, data_format="NCHW", name=None): return ivy.add(ivy.maximum(0, x), ivy.multiply(weight, ivy.minimum(0, x))) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu(x, name=None): return ivy.relu(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu6(x, name=None): return ivy.relu6(x) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu_(x, name=None): ret = ivy.relu(x) @@ -153,7 +153,7 @@ def relu_(x, name=None): return x -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rrelu( x, @@ -189,7 +189,7 @@ def rrelu( return out.astype(x.dtype) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def selu( x, @@ -222,13 +222,13 @@ def softmax_(x, axis=-1, dtype=None, name=None): return x -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softplus(x, beta=1, threshold=20, name=None): return ivy.softplus(x, beta=beta, threshold=threshold) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softshrink( x, @@ -243,7 +243,7 @@ def softshrink( return ivy.astype(add, x.dtype) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softsign( x, @@ -254,7 +254,7 @@ def softsign( return ivy.divide(x, ivy.add(1, ivy.abs(x))) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def swish(x, name=None): return ivy.multiply(x, ivy.sigmoid(x)) @@ -273,7 +273,7 @@ def tanh_(x, name=None): # return ret.astype(x.dtype) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanhshrink( x, diff --git a/ivy/functional/frontends/paddle/nn/functional/common.py b/ivy/functional/frontends/paddle/nn/functional/common.py index 58c54085ee571..414984d6f891f 100644 --- a/ivy/functional/frontends/paddle/nn/functional/common.py +++ b/ivy/functional/frontends/paddle/nn/functional/common.py @@ -5,7 +5,7 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def cosine_similarity(x1, x2, *, axis=1, eps=1e-08): if len(x1.shape) == len(x2.shape) and len(x2.shape) >= 2: numerator = ivy.sum(x1 * x2, axis=axis) @@ -26,7 +26,7 @@ def cosine_similarity(x1, x2, *, axis=1, eps=1e-08): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def dropout(x, p=0.5, axis=None, training=True, mode="upscale_in_train", name=None): if axis is not None and axis > 1: raise ValueError("Axis value can only be 0 or 1 or None.") @@ -53,13 +53,13 @@ def dropout(x, p=0.5, axis=None, training=True, mode="upscale_in_train", name=No @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def dropout2d(x, *, p=0.5, training=True, data_format="NCHW", name=None): return ivy.dropout2d(x, p=p, training=training, data_format=data_format) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def dropout3d(x, p=0.5, training=True, data_format="NCDHW", name=None): return ivy.dropout3d(x, p, training=training, data_format=data_format) @@ -74,7 +74,7 @@ def get_mask(shape, device, prob, seed=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def interpolate( x, size=None, @@ -91,14 +91,14 @@ def interpolate( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def linear(x, weight, bias=None, name=None): weight = ivy.swapaxes(weight, -1, -2) return ivy.linear(x, weight, bias=bias) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): # Input checking if isinstance(kernel_sizes, int): @@ -178,7 +178,7 @@ def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def zeropad2d(x, padding, data_format="NCHW", name=None): if ivy.is_array(padding): padding = padding.to_list() diff --git a/ivy/functional/frontends/paddle/nn/functional/conv.py b/ivy/functional/frontends/paddle/nn/functional/conv.py index b9a0f4a37335f..182c8652c5838 100644 --- a/ivy/functional/frontends/paddle/nn/functional/conv.py +++ b/ivy/functional/frontends/paddle/nn/functional/conv.py @@ -79,7 +79,7 @@ def _conv_transpose( # ------------ # -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv1d( x, @@ -95,7 +95,7 @@ def conv1d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv1d_transpose( x, @@ -115,7 +115,7 @@ def conv1d_transpose( ) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv2d( x, @@ -131,7 +131,7 @@ def conv2d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv2d_transpose( x, @@ -151,7 +151,7 @@ def conv2d_transpose( ) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv3d( x, @@ -167,7 +167,7 @@ def conv3d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv3d_transpose( x, diff --git a/ivy/functional/frontends/paddle/nn/functional/loss.py b/ivy/functional/frontends/paddle/nn/functional/loss.py index 84a80cb6cadc7..3aa8c6cfcc181 100644 --- a/ivy/functional/frontends/paddle/nn/functional/loss.py +++ b/ivy/functional/frontends/paddle/nn/functional/loss.py @@ -47,7 +47,7 @@ def _pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): # ------------ # -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def binary_cross_entropy(input, label, weight=None, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -59,7 +59,7 @@ def binary_cross_entropy(input, label, weight=None, reduction="mean", name=None) @with_supported_dtypes( - {"2.5.1 and below": ("float32",)}, + {" 2.5.2 and below": ("float32",)}, "paddle", ) @inputs_to_ivy_arrays @@ -83,7 +83,7 @@ def binary_cross_entropy_with_logits( @handle_exceptions @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def cosine_embedding_loss( input1, input2, label, margin=0.0, reduction="mean", name=None ): @@ -124,7 +124,7 @@ def cosine_embedding_loss( return out -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def dice_loss(input, label, epsilon=0.00001, name=None): ivy.assertions.check_true( @@ -164,7 +164,7 @@ def dice_loss(input, label, epsilon=0.00001, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32",)}, + {" 2.5.2 and below": ("float32",)}, "paddle", ) @to_ivy_arrays_and_back @@ -188,7 +188,7 @@ def hinge_embedding_loss(input, label, margin=1.0, reduction="mean"): return loss -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def kl_div( input, @@ -235,7 +235,7 @@ def l1_loss( @with_supported_dtypes( - {"2.5.1 and below": ("float32",)}, + {" 2.5.2 and below": ("float32",)}, "paddle", ) @to_ivy_arrays_and_back @@ -246,7 +246,7 @@ def log_loss(input, label, epsilon=0.0001, name=None): return out -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def margin_ranking_loss(input, other, label, margin=0.0, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -266,7 +266,7 @@ def margin_ranking_loss(input, other, label, margin=0.0, reduction="mean", name= return out -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @inputs_to_ivy_arrays def mse_loss(input, label, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -276,7 +276,7 @@ def mse_loss(input, label, reduction="mean", name=None): return paddle.to_tensor(ret) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def multi_label_soft_margin_loss( input, label, weight=None, reduction="mean", name=None @@ -294,7 +294,7 @@ def multi_label_soft_margin_loss( return ret -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def nll_loss( input, @@ -327,7 +327,7 @@ def nll_loss( return output -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sigmoid_focal_loss( logit, @@ -373,7 +373,7 @@ def sigmoid_focal_loss( return loss -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def smooth_l1_loss( input, @@ -400,7 +400,7 @@ def smooth_l1_loss( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @inputs_to_ivy_arrays @@ -460,13 +460,13 @@ def softmax_with_cross_entropy( return paddle.to_tensor(loss) -@with_supported_dtypes({"2.5.1 and below": ("float32",)}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32",)}, "paddle") @to_ivy_arrays_and_back def square_error_cost(input, label): return ivy.square(ivy.subtract(input, label)) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def triplet_margin_loss( input, diff --git a/ivy/functional/frontends/paddle/nn/functional/norm.py b/ivy/functional/frontends/paddle/nn/functional/norm.py index 76bc210cabbb6..b032a9d2e3aa2 100644 --- a/ivy/functional/frontends/paddle/nn/functional/norm.py +++ b/ivy/functional/frontends/paddle/nn/functional/norm.py @@ -5,13 +5,13 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def layer_norm(x, normalized_shape, weight=None, bias=None, epsilon=1e-05, name=None): return ivy.layer_norm(x, normalized_shape, weight, bias, epsilon) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def normalize(x, p=2, axis=1, epsilon=1e-12, name=None): if axis < 0: axis = ivy.get_num_dims(x) + axis diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index b40b468ed7441..0198b565c8090 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -9,13 +9,13 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def adaptive_avg_pool1d(x, output_size, name=None): return ivy.adaptive_avg_pool1d(x, output_size) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def adaptive_avg_pool2d(x, output_size, data_format="NCHW", name=None): return ivy.adaptive_avg_pool2d(x, output_size) @@ -27,13 +27,13 @@ def adaptive_avg_pool3d(x, output_size, data_format="NCHW", name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def adaptive_max_pool2d(x, output_size, return_mask=None, name=None): return ivy.adaptive_max_pool2d(x, output_size) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def avg_pool1d( x, kernel_size, stride=None, padding=0, exclusive=True, ceil_mode=False, name=None ): @@ -63,7 +63,7 @@ def avg_pool1d( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def avg_pool2d( x, kernel_size, @@ -101,7 +101,7 @@ def avg_pool2d( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def max_unpool1d( x, indices, diff --git a/ivy/functional/frontends/paddle/nn/functional/vision.py b/ivy/functional/frontends/paddle/nn/functional/vision.py index 07e08ad17ce54..02294f6e40080 100644 --- a/ivy/functional/frontends/paddle/nn/functional/vision.py +++ b/ivy/functional/frontends/paddle/nn/functional/vision.py @@ -9,7 +9,7 @@ @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def affine_grid(theta, out_shape, align_corners=True): if len(out_shape) == 4: N, C, H, W = out_shape @@ -75,7 +75,7 @@ def affine_grid(theta, out_shape, align_corners=True): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def channel_shuffle(x, groups, data_format="NCHW", name=None): if len(ivy.shape(x)) != 4: raise ValueError( diff --git a/ivy/functional/frontends/paddle/random.py b/ivy/functional/frontends/paddle/random.py index 9d45b9f23ea20..ab4cc1368d017 100644 --- a/ivy/functional/frontends/paddle/random.py +++ b/ivy/functional/frontends/paddle/random.py @@ -8,7 +8,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -18,7 +18,7 @@ def multinomial(x, num_samples=1, replacement=False, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -27,7 +27,7 @@ def normal(mean=0.0, std=1.0, shape=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -37,7 +37,7 @@ def poisson(x, name=None): @with_supported_device_and_dtypes( { - "2.5.1 and above": { + " 2.5.2 and above": { "cpu": ( "bfloat16", "float32", @@ -75,7 +75,7 @@ def randint(low=0, high=None, shape=[1], dtype=None, name=None): @with_unsupported_dtypes( - {"2.5.1 and below": ("int16", "float16", "bfloat16", "uint8")}, + {" 2.5.2 and below": ("int16", "float16", "bfloat16", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -99,7 +99,7 @@ def randn(shape, dtype=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -108,7 +108,7 @@ def standard_normal(shape, dtype=None, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/search.py b/ivy/functional/frontends/paddle/search.py index 884be2e77fc99..490fb5f4a46c0 100644 --- a/ivy/functional/frontends/paddle/search.py +++ b/ivy/functional/frontends/paddle/search.py @@ -7,7 +7,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {" 2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -16,7 +16,7 @@ def argmax(x, /, *, axis=None, keepdim=False, dtype="int64", name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {" 2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -34,7 +34,7 @@ def argsort(x, /, *, axis=-1, descending=False, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float32", "float64")}, + {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -44,7 +44,7 @@ def index_sample(x, index): # kthvalue @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def kthvalue(x, k, axis=None, keepdim=False, name=None): @@ -65,7 +65,7 @@ def kthvalue(x, k, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -86,7 +86,7 @@ def nonzero(input, /, *, as_tuple=False): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -102,7 +102,7 @@ def searchsorted(sorted_sequence, values, out_int32=False, right=False, name=Non @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -111,7 +111,7 @@ def sort(x, /, *, axis=-1, descending=False, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -121,7 +121,7 @@ def topk(x, k, axis=None, largest=True, sorted=True, name=None): # where @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/stat.py b/ivy/functional/frontends/paddle/stat.py index fc76cdad7b72c..345d5f4c1cbd9 100644 --- a/ivy/functional/frontends/paddle/stat.py +++ b/ivy/functional/frontends/paddle/stat.py @@ -6,7 +6,7 @@ ) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def mean(input, axis=None, keepdim=False, out=None): ret = ivy.mean(input, axis=axis, keepdims=keepdim, out=out) @@ -14,7 +14,7 @@ def mean(input, axis=None, keepdim=False, out=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -37,7 +37,7 @@ def nanmedian(x, axis=None, keepdim=True, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -51,7 +51,7 @@ def numel(x, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "uint16")}, + {" 2.5.2 and below": ("float32", "float64", "uint16")}, "paddle", ) @to_ivy_arrays_and_back @@ -64,7 +64,7 @@ def std(x, axis=None, unbiased=True, keepdim=False, name=None): return ivy.std(x, axis=axis, correction=int(unbiased), keepdims=keepdim) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def var(x, axis=None, unbiased=True, keepdim=False, name=None): if unbiased: diff --git a/ivy/functional/frontends/paddle/tensor/manipulation.py b/ivy/functional/frontends/paddle/tensor/manipulation.py index 35ce51915f140..4d21d3395a93a 100644 --- a/ivy/functional/frontends/paddle/tensor/manipulation.py +++ b/ivy/functional/frontends/paddle/tensor/manipulation.py @@ -12,7 +12,7 @@ @with_unsupported_dtypes( - {"2.5.1 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, + {" 2.5.2 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/tensor/math.py b/ivy/functional/frontends/paddle/tensor/math.py index 7f9d56ea6452a..01aeb9b37d8b1 100644 --- a/ivy/functional/frontends/paddle/tensor/math.py +++ b/ivy/functional/frontends/paddle/tensor/math.py @@ -9,14 +9,14 @@ # Please add non-inplace counterparts to `/frontends/paddle/math.py`. -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def ceil_(x, name=None): return ivy.ceil(x, out=x) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def clip_(x, min=None, max=None, name=None): @@ -38,54 +38,54 @@ def clip_(x, min=None, max=None, name=None): return res -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def exp_(x, name=None): return ivy.inplace_update(x, exp(x)) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def floor_(x, name=None): return ivy.inplace_update(x, floor(x)) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lerp_(x, y, weight, name=None): return ivy.inplace_update(x, lerp(x, y, weight)) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def reciprocal_(x, name=None): return ivy.inplace_update(x, reciprocal(x)) -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def round_(x, name=None): return ivy.inplace_update(x, round(x)) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def rsqrt_(x, name=None): return ivy.inplace_update(x, reciprocal(sqrt(x))) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sqrt_(x, name=None): return ivy.inplace_update(x, sqrt(x)) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def subtract_(x, y, name=None): return ivy.inplace_update(x, subtract(x, y)) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanh_(x, name=None): return ivy.inplace_update(x, tanh(x)) diff --git a/ivy/functional/frontends/paddle/tensor/random.py b/ivy/functional/frontends/paddle/tensor/random.py index ea6bd38157195..259d247f5c448 100644 --- a/ivy/functional/frontends/paddle/tensor/random.py +++ b/ivy/functional/frontends/paddle/tensor/random.py @@ -12,7 +12,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -21,7 +21,7 @@ def exponential_(x, lam=1.0, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64")}, + {" 2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 6f53fd7300263..29a490875436a 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -62,7 +62,7 @@ def ivy_array(self, array): # -------------------# @with_unsupported_dtypes( - {"2.5.1 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {" 2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __add__(self, y, /, name=None): @@ -103,47 +103,47 @@ def reshape(self, *args, shape=None): def dim(self): return self.ivy_array.ndim - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def abs(self): return paddle_frontend.abs(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def acosh(self, name=None): return paddle_frontend.acosh(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def add_n(self, inputs, name=None): inputs = ivy.array(inputs) return ivy.sum(inputs, dtype=inputs.dtype, axis=0) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def ceil(self): return paddle_frontend.ceil(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def ceil_(self): self.ivy_array = self.ceil().ivy_array return self - @with_unsupported_dtypes({"2.5.1 and below": ("complex", "int8")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("complex", "int8")}, "paddle") def numel(self): return paddle_frontend.numel(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16",)}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16",)}, "paddle") def asinh(self, name=None): return paddle_frontend.asinh(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def asin(self, name=None): return paddle_frontend.asin(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def cosh(self, name=None): return paddle_frontend.cosh(self) @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "int32", "int64", "float64", @@ -158,101 +158,101 @@ def cosh(self, name=None): def diagonal(self, offset, axis1=0, axis2=1, name=None): return paddle_frontend.diagonal(self, offset=offset, axis1=axis1, axis2=axis2) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def log(self, name=None): return paddle_frontend.log(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def sin(self, name=None): return paddle_frontend.sin(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def sinh(self, name=None): return paddle_frontend.sinh(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def lerp(self, y, weight, name=None): return paddle_frontend.lerp(self, y, weight) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def lerp_(self, y, weight, name=None): self.ivy_array = paddle_frontend.lerp(self, y, weight).ivy_array return self - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def argmax(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.argmax(self, axis=axis, keepdim=keepdim, dtype=dtype) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "uint16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "uint16")}, "paddle") def unsqueeze(self, axis=None, name=None): return paddle_frontend.Tensor(ivy.expand_dims(self._ivy_array, axis=axis)) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def sqrt(self, name=None): return paddle_frontend.sqrt(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def sqrt_(self, name=None): self.ivy_array = self.sqrt().ivy_array return self - @with_unsupported_dtypes({"2.5.1 and below": ("bfloat16", "uint16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("bfloat16", "uint16")}, "paddle") def zero_(self): self.ivy_array = paddle_frontend.zeros_like(self).ivy_array return self - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def cos(self, name=None): return paddle_frontend.cos(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def exp(self, name=None): return paddle_frontend.exp(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def exp_(self, name=None): self.ivy_array = self.exp().ivy_array return self - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def erf(self, name=None): return paddle_frontend.erf(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def subtract(self, y, name=None): return paddle_frontend.subtract(self, y) @with_unsupported_dtypes( - {"2.5.1 and below": ("float16", "uint8", "int8", "bool")}, "paddle" + {" 2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" ) def subtract_(self, y, name=None): self.ivy_array = self.subtract(y).ivy_array return self - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def log10(self, name=None): return paddle_frontend.Tensor(ivy.log10(self._ivy_array)) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def argsort(self, axis=-1, descending=False, name=None): return paddle_frontend.argsort(self, axis=axis, descending=descending) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def floor(self, name=None): return paddle_frontend.floor(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def floor_(self): self.ivy_array = self.floor().ivy_array return self - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def round_(self, name=None): self.ivy_array = paddle_frontend.round(self).ivy_array return self @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def clip(self, min=None, max=None, name=None): ivy.utils.assertions.check_all_or_any_fn( @@ -272,63 +272,63 @@ def clip(self, min=None, max=None, name=None): return paddle_frontend.Tensor(ret) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def clip_(self, min=None, max=None, name=None): self._ivy_array = self.clip(min, max).ivy_array return self - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def tanh(self, name=None): return paddle_frontend.tanh(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def add_(self, y, name=None): self.ivy_array = paddle_frontend.add(self, y).ivy_array return self - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def addmm(self, x, y, beta=1.0, alpha=1.0, name=None): return paddle_frontend.addmm(self, x, y, beta, alpha) @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isinf(self, name=None): return paddle_frontend.isinf(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "uint16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "uint16")}, "paddle") def unsqueeze_(self, axis=None, name=None): self.ivy_array = self.unsqueeze(axis=axis).ivy_array return self - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def square(self, name=None): return paddle_frontend.square(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def remainder_(self, y, name=None): self.ivy_array = paddle_frontend.remainder(self, y).ivy_array return self - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def cholesky(self, upper=False, name=None): return paddle_frontend.cholesky(self, upper=upper) @with_unsupported_dtypes( - {"2.5.1 and below": ("float16", "uint16", "int16")}, "paddle" + {" 2.5.2 and below": ("float16", "uint16", "int16")}, "paddle" ) def squeeze_(self, axis=None, name=None): self.ivy_array = paddle_frontend.squeeze(self, axis=axis).ivy_array return self - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def multiply(self, y, name=None): return paddle_frontend.multiply(self, y) @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isfinite(self, name=None): @@ -340,17 +340,17 @@ def all(self, axis=None, keepdim=False, dtype=None, name=None): ivy.all(self.ivy_array, axis=axis, keepdims=keepdim, dtype=dtype) ) - @with_supported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def allclose(self, other, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): return paddle_frontend.allclose( self, other, rtol=rtol, atol=atol, equal_nan=equal_nan ) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def sort(self, axis=-1, descending=False, name=None): return paddle_frontend.sort(self, axis=axis, descending=descending) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def log1p(self, name=None): return paddle_frontend.log1p(self) @@ -372,7 +372,7 @@ def bitwise_and(self, y, out=None, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -388,22 +388,22 @@ def logical_or(self, y, out=None, name=None): return paddle_frontend.logical_or(self, y, out=out) @with_supported_dtypes( - {"2.5.1 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, + {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, "paddle", ) def bitwise_xor(self, y, out=None, name=None): return paddle_frontend.bitwise_xor(self, y) - @with_supported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def any(self, axis=None, keepdim=False, name=None): return paddle_frontend.any(self, axis=axis, keepdim=keepdim) - @with_unsupported_dtypes({"2.5.1 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") def astype(self, dtype): return paddle_frontend.Tensor(ivy.astype(self._ivy_array, dtype)) @with_supported_dtypes( - {"2.5.1 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, + {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, "paddle", ) def bitwise_not(self, out=None, name=None): @@ -411,7 +411,7 @@ def bitwise_not(self, out=None, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -426,7 +426,7 @@ def bitwise_or(self, y, out=None, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -442,7 +442,7 @@ def logical_xor(self, y, out=None, name=None): return paddle_frontend.logical_xor(self, y, out=out) @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isnan(self, name=None): @@ -450,7 +450,7 @@ def isnan(self, name=None): @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "uint8", "int8", @@ -464,22 +464,22 @@ def isnan(self, name=None): def greater_than(self, y, name=None): return paddle_frontend.greater_than(self, y) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def rsqrt(self, name=None): return paddle_frontend.rsqrt(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def rsqrt_(self, name=None): self.ivy_array = self.rsqrt().ivy_array return self - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def reciprocal(self, name=None): return paddle_frontend.reciprocal(self) @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -494,19 +494,20 @@ def reciprocal(self, name=None): def logical_and(self, y, out=None, name=None): return paddle_frontend.logical_and(self, y, out=out) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def divide(self, y, name=None): return paddle_frontend.divide(self, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex64", "complex128")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "complex64", "complex128")}, + "paddle", ) def eigvals(self, name=None): return paddle_frontend.eigvals(self) @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "uint8", "int8", @@ -520,18 +521,18 @@ def eigvals(self, name=None): def less_than(self, y, name=None): return paddle_frontend.less_than(self, y) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def cumprod(self, dim=None, dtype=None, name=None): return paddle_frontend.cumprod(self, dim=dim, dtype=dtype) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def cumsum(self, axis=None, dtype=None, name=None): return paddle_frontend.Tensor( ivy.cumsum(self._ivy_array, axis=axis, dtype=dtype) ) @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128", "float32", "float64")}, + {" 2.5.2 and below": ("complex64", "complex128", "float32", "float64")}, "paddle", ) def angle(self, name=None): @@ -539,7 +540,7 @@ def angle(self, name=None): @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "uint8", "int8", "int16", @@ -552,13 +553,13 @@ def angle(self, name=None): def equal(self, y, name=None): return paddle_frontend.equal(self, y) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def rad2deg(self, name=None): return paddle_frontend.rad2deg(self) @with_unsupported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "uint8", "int8", "int16", @@ -572,46 +573,46 @@ def rad2deg(self, name=None): def equal_all(self, y, name=None): return paddle_frontend.equal_all(self, y) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def maximum(self, other, name=None): return paddle_frontend.maximum(self, other) - @with_unsupported_dtypes({"2.5.1 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") def fmax(self, y, name=None): return paddle_frontend.fmax(self, y) - @with_unsupported_dtypes({"2.5.1 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") def fmin(self, y, name=None): return paddle_frontend.fmin(self, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def minimum(self, y, name=None): return paddle_frontend.minimum(self, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def max(self, axis=None, keepdim=False, name=None): return paddle_frontend.max(self, axis=axis, keepdim=keepdim) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def deg2rad(self, name=None): return paddle_frontend.deg2rad(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def digamma(self, name=None): return paddle_frontend.digamma(self) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64", "bool")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64", "bool")}, "paddle" ) def rot90(self, k=1, axes=(0, 1), name=None): return paddle_frontend.rot90(self, k=k, axes=axes) @with_supported_dtypes( - {"2.5.1 and below": ("complex64", "complex128")}, + {" 2.5.2 and below": ("complex64", "complex128")}, "paddle", ) def imag(self, name=None): @@ -622,7 +623,7 @@ def is_tensor(self): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "float32", "float64", ) @@ -634,16 +635,16 @@ def isclose(self, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): self, y, rtol=rtol, atol=atol, equal_nan=equal_nan ) - @with_supported_dtypes({"2.5.1 and below": ("int32", "int64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") def floor_divide(self, y, name=None): return paddle_frontend.floor_divide(self, y) - @with_supported_dtypes({"2.5.1 and below": ("int32", "int64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") def mod(self, y, name=None): return paddle_frontend.Tensor(ivy.fmod(self._ivy_array, _to_ivy_array(y))) # cond - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def cond(self, p=None, name=None): return paddle_frontend.cond(self, p=p, name=name) @@ -651,7 +652,7 @@ def cond(self, p=None, name=None): def conj(self, name=None): return paddle_frontend.conj(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def log2(self, name=None): return paddle_frontend.log2(self) @@ -663,7 +664,7 @@ def neg(self, name=None): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int8", "int16", @@ -678,15 +679,15 @@ def neg(self, name=None): def logical_not(self, out=None, name=None): return paddle_frontend.logical_not(self) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def sign(self, name=None): return paddle_frontend.sign(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def var(self, axis=None, unbiased=True, keepdim=False, name=None): return paddle_frontend.var(self, axis=axis, unbiased=unbiased, keepdim=keepdim) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def sgn(self, name=None): return paddle_frontend.sgn(self) @@ -694,45 +695,45 @@ def tolist(self): return paddle_frontend.Tensor(ivy.to_list(self._ivy_array)) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) def min(self, axis=None, keepdim=False, name=None): return paddle_frontend.min(self, axis=axis, keepdim=keepdim) @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def pow(self, y, name=None): return paddle_frontend.pow(self, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def prod(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.Tensor( ivy.prod(self._ivy_array, axis=axis, keepdims=keepdim, dtype=dtype) ) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def atan(self, name=None): return paddle_frontend.atan(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def atanh(self, name=None): return paddle_frontend.atanh(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def std(self, axis=None, unbiased=True, keepdim=False, name=None): return paddle_frontend.std(self, axis=axis, unbiased=unbiased, keepdim=keepdim) @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def trunc(self, name=None): return paddle_frontend.trunc(self) - @with_supported_dtypes({"2.5.1 and below": ("complex64", "complex128")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("complex64", "complex128")}, "paddle") def as_real(self, name=None): if not ivy.is_complex_dtype(self._ivy_array): raise ivy.exceptions.IvyError( @@ -742,12 +743,12 @@ def as_real(self, name=None): im_part = ivy.imag(self._ivy_array) return paddle_frontend.Tensor(ivy.stack((re_part, im_part), axis=-1)) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def stanh(self, scale_a=0.67, scale_b=1.7159, name=None): return paddle_frontend.stanh(self, scale_a=scale_a, scale_b=scale_b) @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def trace(self, offset=0, axis1=0, axis2=1, name=None): return paddle_frontend.Tensor( @@ -755,55 +756,64 @@ def trace(self, offset=0, axis1=0, axis2=1, name=None): ) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + { + " 2.5.2 and below": ( + "float32", + "float64", + "int16", + "int32", + "int64", + "uint8", + ) + }, "paddle", ) def argmin(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.argmin(self, axis=axis, keepdim=keepdim, dtype=dtype) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) def topk(self, k, axis=None, largest=True, sorted=True, name=None): return paddle_frontend.topk(self, k, axis=axis, largest=largest, sorted=sorted) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def remainder(self, y, name=None): return paddle_frontend.remainder(self, y) def is_floating_point(self): return paddle_frontend.is_floating_point(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def tanh_(self, name=None): y = self.tanh(self) return ivy.inplace_update(self, y) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def reciprocal_(self, name=None): y = self.reciprocal(self) return ivy.inplace_update(self, y) @with_unsupported_dtypes( - {"2.5.1 and below": ("complex", "uint8", "uint16")}, "paddle" + {" 2.5.2 and below": ("complex", "uint8", "uint16")}, "paddle" ) def numpy(self): return self.ivy_array.to_numpy() - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def nonzero(self): return paddle_frontend.nonzero(self) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def inner(self, y, name=None): return paddle_frontend.inner(self, y, name) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def mean(self, axis=None, keepdim=False, name=None): return paddle_frontend.mean(self, axis=axis, keepdim=keepdim) - @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") def as_complex(self, name=None): if self.ivy_array.shape[-1] != 2: raise ivy.exceptions.IvyError( @@ -818,29 +828,29 @@ def as_complex(self, name=None): return value @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float32", "float64", "bool")}, "paddle" + {" 2.5.2 and below": ("int32", "int64", "float32", "float64", "bool")}, "paddle" ) def not_equal(self, y, name=None): return paddle_frontend.not_equal(self._ivy_array, y) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def less_equal(self, y, name=None): return paddle_frontend.less_equal(self._ivy_array, y) - @with_supported_dtypes({"2.5.1 and below": ("complex64", "complex128")}, "paddle") + @with_supported_dtypes({" 2.5.2 and below": ("complex64", "complex128")}, "paddle") def real(self, name=None): return paddle_frontend.real(self._ivy_array) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def t(self, name=None): axes = list(range(len(self.ivy_array.shape)))[::-1] return ivy.permute_dims(self.ivy_array, axes=axes) @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "float16", "float32", @@ -855,12 +865,12 @@ def t(self, name=None): def cast(self, dtype): return paddle_frontend.cast(self, dtype) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def bmm(self, y, transpose_x=False, transpose_y=False, name=None): return paddle_frontend.bmm(self, y, transpose_x, transpose_y) @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "int32", "int64")}, + {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def fill_(self, value): @@ -869,7 +879,7 @@ def fill_(self, value): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int32", "int64", @@ -885,7 +895,7 @@ def unbind(self, axis=0): @with_supported_dtypes( { - "2.5.1 and below": ( + " 2.5.2 and below": ( "bool", "int32", "int64", @@ -904,44 +914,44 @@ def cpu(self): return self @with_unsupported_dtypes( - {"2.5.1 and below": ("int16", "complex64", "complex128")}, + {" 2.5.2 and below": ("int16", "complex64", "complex128")}, "paddle", ) def split(self, num_or_sections, axis=0, name=None): return paddle_frontend.split(self._ivy_array, num_or_sections, axis, name) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def frac(self, name=None): return paddle_frontend.frac(self._ivy_array) - @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def gather(self, y, name=None): return paddle_frontend.gather(self, y) @with_unsupported_dtypes( - {"2.5.1 and below": ("float16", "uint8", "int8", "bool")}, "paddle" + {" 2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" ) def gather_(self, y, name=None): res = self.gather(self, y) return ivy.inplace_update(self, res) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def heaviside(self, y, name=None): return paddle_frontend.heaviside(self, y) @with_supported_dtypes( - {"2.5.1 and below": ("bool", "int32", "int64", "float32", "float64")}, "paddle" + {" 2.5.2 and below": ("bool", "int32", "int64", "float32", "float64")}, "paddle" ) def expand(self, shape, name=None): return paddle_frontend.expand(self._ivy_array, shape) @with_supported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ( "bool", "int32", diff --git a/ivy/functional/frontends/paddle/vision/transforms.py b/ivy/functional/frontends/paddle/vision/transforms.py index 43bd51fc3830a..1be9e31ccebac 100644 --- a/ivy/functional/frontends/paddle/vision/transforms.py +++ b/ivy/functional/frontends/paddle/vision/transforms.py @@ -104,7 +104,7 @@ def _rgb_to_hsv(img): # ------------ # -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def adjust_brightness(img, brightness_factor): assert brightness_factor >= 0, "brightness_factor should be non-negative." @@ -117,7 +117,7 @@ def adjust_brightness(img, brightness_factor): return _blend_images(img, extreme_target, brightness_factor) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64", "uint8")}, "paddle") +@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64", "uint8")}, "paddle") @to_ivy_arrays_and_back def adjust_hue(img, hue_factor): assert -0.5 <= hue_factor <= 0.5, "hue_factor should be in range [-0.5, 0.5]" @@ -145,7 +145,7 @@ def adjust_hue(img, hue_factor): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def hflip(img): @@ -154,7 +154,7 @@ def hflip(img): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def normalize(img, mean, std, data_format="CHW", to_rgb=False): if ivy.is_array(img): @@ -171,7 +171,7 @@ def normalize(img, mean, std, data_format="CHW", to_rgb=False): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def pad(img, padding, fill=0, padding_mode="constant"): @@ -201,7 +201,7 @@ def pad(img, padding, fill=0, padding_mode="constant"): @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def to_tensor(pic, data_format="CHW"): @@ -211,7 +211,7 @@ def to_tensor(pic, data_format="CHW"): @with_unsupported_device_and_dtypes( { - "2.5.1 and below": { + " 2.5.2 and below": { "cpu": ("int8", "uint8", "int16", "float16", "bfloat16", "bool") } }, diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index 5b7bc5d406626..bed1f35cd46bc 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -454,7 +454,7 @@ def minimum(x, y, name=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.1 and below": ("bfloat16",)}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("bfloat16",)}, "paddle") def mod(x, y, name=None): x, y = check_tensorflow_casting(x, y) return ivy.remainder(x, y) diff --git a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py index a6cc79fb21d99..c47ce815c1472 100644 --- a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py @@ -8,7 +8,7 @@ # ToDo: this function will be simplified once ivy.alpha_dropout is implemented @to_ivy_arrays_and_back @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") -@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") def alpha_dropout(input, p=0.5, training=False, inplace=False): if p == 0.0 or not training or input.shape == () or input.shape == (0,): return input From fe1e3c3f9b296fb3b8e66b7835f85362490072ef Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Mon, 30 Oct 2023 09:17:47 +0000 Subject: [PATCH 080/978] fix: Remove blank space from 1f73385 --- docs/overview/deep_dive/data_types.rst | 2 +- ivy/functional/backends/paddle/__init__.py | 14 +- ivy/functional/backends/paddle/activations.py | 16 +- ivy/functional/backends/paddle/creation.py | 12 +- ivy/functional/backends/paddle/elementwise.py | 58 ++-- .../paddle/experimental/activations.py | 28 +- .../backends/paddle/experimental/creation.py | 4 +- .../paddle/experimental/elementwise.py | 28 +- .../backends/paddle/experimental/layers.py | 22 +- .../paddle/experimental/linear_algebra.py | 10 +- .../backends/paddle/experimental/losses.py | 12 +- .../paddle/experimental/manipulation.py | 28 +- .../backends/paddle/experimental/norms.py | 4 +- .../backends/paddle/experimental/random.py | 2 +- .../paddle/experimental/sparse_array.py | 2 +- .../paddle/experimental/statistical.py | 22 +- ivy/functional/backends/paddle/general.py | 2 +- ivy/functional/backends/paddle/gradients.py | 2 +- ivy/functional/backends/paddle/layers.py | 8 +- .../backends/paddle/linear_algebra.py | 36 ++- .../backends/paddle/manipulation.py | 20 +- ivy/functional/backends/paddle/random.py | 8 +- ivy/functional/backends/paddle/searching.py | 8 +- ivy/functional/backends/paddle/set.py | 8 +- ivy/functional/backends/paddle/sorting.py | 8 +- ivy/functional/backends/paddle/statistical.py | 16 +- ivy/functional/frontends/__init__.py | 2 +- ivy/functional/frontends/jax/array.py | 4 +- ivy/functional/frontends/jax/numpy/fft.py | 2 +- .../jax/numpy/mathematical_functions.py | 2 +- ivy/functional/frontends/paddle/creation.py | 34 +-- ivy/functional/frontends/paddle/fft.py | 26 +- ivy/functional/frontends/paddle/linalg.py | 30 +-- ivy/functional/frontends/paddle/logic.py | 36 +-- .../frontends/paddle/manipulation.py | 32 +-- ivy/functional/frontends/paddle/math.py | 164 ++++++------ .../paddle/nn/functional/activation.py | 44 ++-- .../frontends/paddle/nn/functional/common.py | 16 +- .../frontends/paddle/nn/functional/conv.py | 12 +- .../frontends/paddle/nn/functional/loss.py | 32 +-- .../frontends/paddle/nn/functional/norm.py | 4 +- .../frontends/paddle/nn/functional/pooling.py | 12 +- .../frontends/paddle/nn/functional/vision.py | 4 +- ivy/functional/frontends/paddle/random.py | 14 +- ivy/functional/frontends/paddle/search.py | 18 +- ivy/functional/frontends/paddle/stat.py | 10 +- .../frontends/paddle/tensor/manipulation.py | 2 +- .../frontends/paddle/tensor/math.py | 22 +- .../frontends/paddle/tensor/random.py | 4 +- .../frontends/paddle/tensor/tensor.py | 248 +++++++++--------- .../frontends/paddle/vision/transforms.py | 14 +- ivy/functional/frontends/tensorflow/math.py | 2 +- .../torch/nn/functional/dropout_functions.py | 2 +- 53 files changed, 583 insertions(+), 589 deletions(-) diff --git a/docs/overview/deep_dive/data_types.rst b/docs/overview/deep_dive/data_types.rst index 247982a098d87..f3cb6defae24b 100644 --- a/docs/overview/deep_dive/data_types.rst +++ b/docs/overview/deep_dive/data_types.rst @@ -423,7 +423,7 @@ set of dtypes is not supported by a certain device. .. code-block:: python - @with_unsupported_device_and_dtypes({" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version) + @with_unsupported_device_and_dtypes({"2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version) def gcd( x1: Union[paddle.Tensor, int, list, tuple], x2: Union[paddle.Tensor, float, list, tuple], diff --git a/ivy/functional/backends/paddle/__init__.py b/ivy/functional/backends/paddle/__init__.py index 7db9bb2b1dce8..e63c5c3183202 100644 --- a/ivy/functional/backends/paddle/__init__.py +++ b/ivy/functional/backends/paddle/__init__.py @@ -175,14 +175,14 @@ def rep_method(*args, **kwargs): ), } valid_int_dtypes = { - " 2.5.2 and below": ( + "2.5.2 and below": ( ivy.int8, ivy.int16, ivy.int32, ivy.int64, ivy.uint8, ), - " 2.5.2 and above": ( + "2.5.2 and above": ( ivy.int8, ivy.int16, ivy.int32, @@ -194,8 +194,8 @@ def rep_method(*args, **kwargs): "2.4.0 and below": (ivy.float16, ivy.float32, ivy.float64), "2.4.1 and above": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64), } -valid_uint_dtypes = {" 2.5.2 and below": (ivy.uint8,)} -valid_complex_dtypes = {" 2.5.2 and below": (ivy.complex64, ivy.complex128)} +valid_uint_dtypes = {"2.5.2 and below": (ivy.uint8,)} +valid_complex_dtypes = {"2.5.2 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -235,10 +235,10 @@ def rep_method(*args, **kwargs): ), } -invalid_int_dtypes = {" 2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_int_dtypes = {"2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} invalid_float_dtypes = {"2.4.0 and below": (ivy.bfloat16,), "2.4.1 and above": ()} -invalid_uint_dtypes = {" 2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_complex_dtypes = {" 2.5.2 and below": ()} +invalid_uint_dtypes = {"2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_complex_dtypes = {"2.5.2 and below": ()} # leave these untouched invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index 134bf6490a97b..3ff01325f8c31 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/ivy/functional/backends/paddle/activations.py @@ -42,7 +42,7 @@ def relu( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def leaky_relu( x: paddle.Tensor, @@ -63,7 +63,7 @@ def leaky_relu( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def gelu( x: paddle.Tensor, @@ -88,7 +88,7 @@ def gelu( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def sigmoid( x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None @@ -101,7 +101,7 @@ def sigmoid( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def softmax( x: paddle.Tensor, @@ -151,7 +151,7 @@ def softplus( # Softsign @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def softsign( x: paddle.Tensor, @@ -165,7 +165,7 @@ def softsign( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def log_softmax( x: paddle.Tensor, @@ -184,7 +184,7 @@ def log_softmax( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def mish( x: paddle.Tensor, @@ -201,7 +201,7 @@ def mish( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def hardswish( x: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index cd8a58f764fb1..e91fcc479ba5d 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -142,7 +142,7 @@ def empty_like( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "uint8", "int8", @@ -356,7 +356,7 @@ def _slice_at_axis(sl, axis): @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("uint16", "bfloat16", "float16")}}, backend_version + {"2.5.2 and below": {"cpu": ("uint16", "bfloat16", "float16")}}, backend_version ) def linspace( start: Union[paddle.Tensor, float], @@ -414,7 +414,7 @@ def linspace( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -484,7 +484,7 @@ def ones_like( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -503,7 +503,7 @@ def tril( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -616,7 +616,7 @@ def one_hot( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def frombuffer( diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 29bcd515a1f55..b6244a0e1c254 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -70,7 +70,7 @@ def bitwise_invert( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -198,7 +198,7 @@ def floor(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def asin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -219,7 +219,7 @@ def asin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def asinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -245,7 +245,7 @@ def asinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def sign( @@ -319,7 +319,7 @@ def sqrt(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def cosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -449,7 +449,7 @@ def multiply( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def cos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -501,7 +501,7 @@ def divide( @with_supported_dtypes( - {" 2.5.2 and below": ("float64", "float32", "int64", "int64")}, + {"2.5.2 and below": ("float64", "float32", "int64", "int64")}, backend_version, ) def fmin( @@ -553,7 +553,7 @@ def greater_equal( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def acos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -578,7 +578,7 @@ def acos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def logical_xor( @@ -599,7 +599,7 @@ def logical_xor( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def logical_and( @@ -633,7 +633,7 @@ def logical_or( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def acosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -658,7 +658,7 @@ def acosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def sin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -703,7 +703,7 @@ def not_equal( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def tanh( @@ -756,7 +756,7 @@ def bitwise_or( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def sinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -803,7 +803,7 @@ def square( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version ) def pow( x1: paddle.Tensor, @@ -851,7 +851,7 @@ def _round_half_to_even(x): # This function aims to mimic the behavior of np.round similar to how tf.experimental.numpy.round does # noqa: E501 # Reference for tf.experimental.numpy.round:https://github.com/tensorflow/tensorflow/blob/v2.13.0/tensorflow/python/ops/numpy_ops/np_array_ops.py#L724 # noqa: E501 @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16", "float16", "complex")}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16", "float16", "complex")}}, backend_version ) def round( x: paddle.Tensor, /, *, decimals: int = 0, out: Optional[paddle.Tensor] = None @@ -893,7 +893,7 @@ def trunc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_supported_dtypes( - {" 2.5.2 and below": ("float64", "float32")}, + {"2.5.2 and below": ("float64", "float32")}, backend_version, ) def trapz( @@ -963,7 +963,7 @@ def abs( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def logaddexp( x1: paddle.Tensor, x2: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None @@ -976,7 +976,7 @@ def logaddexp( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def logaddexp2( x1: Union[paddle.Tensor, float, list, tuple], @@ -991,7 +991,7 @@ def logaddexp2( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -1012,7 +1012,7 @@ def real(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def tan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1033,7 +1033,7 @@ def tan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def atan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1054,7 +1054,7 @@ def atan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, backend_version, ) def atan2( @@ -1123,7 +1123,7 @@ def subtract( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, backend_version, ) def remainder( @@ -1151,7 +1151,7 @@ def remainder( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, backend_version, ) def atanh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1201,7 +1201,7 @@ def bitwise_left_shift( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, backend_version, ) def erf(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1327,7 +1327,7 @@ def fmod( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8", "uint8")}}, + {"2.5.2 and below": {"cpu": ("int8", "uint8")}}, backend_version, ) def lcm( @@ -1363,7 +1363,7 @@ def angle( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version + {"2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version ) def gcd( x1: Union[paddle.Tensor, int, list, tuple], @@ -1378,7 +1378,7 @@ def gcd( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", diff --git a/ivy/functional/backends/paddle/experimental/activations.py b/ivy/functional/backends/paddle/experimental/activations.py index 7557f0ea27594..8d13b487369da 100644 --- a/ivy/functional/backends/paddle/experimental/activations.py +++ b/ivy/functional/backends/paddle/experimental/activations.py @@ -14,7 +14,7 @@ @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def logit( x: paddle.Tensor, @@ -44,7 +44,7 @@ def logit( ).cast(x.dtype) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) def thresholded_relu( x: paddle.Tensor, /, @@ -56,7 +56,7 @@ def thresholded_relu( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def relu6( x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None @@ -67,7 +67,7 @@ def relu6( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def logsigmoid( input: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None @@ -82,7 +82,7 @@ def logsigmoid( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def selu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -101,7 +101,7 @@ def selu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def silu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -110,7 +110,7 @@ def silu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def elu( x: paddle.Tensor, /, *, alpha: float = 1.0, out: Optional[paddle.Tensor] = None @@ -128,7 +128,7 @@ def elu( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def hardtanh( x: paddle.Tensor, @@ -154,7 +154,7 @@ def hardtanh( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def tanhshrink( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None @@ -167,7 +167,7 @@ def tanhshrink( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def threshold( x: paddle.Tensor, @@ -188,7 +188,7 @@ def threshold( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def softshrink( x: paddle.Tensor, /, *, lambd: float = 0.5, out: Optional[paddle.Tensor] = None @@ -204,7 +204,7 @@ def softshrink( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def celu( x: paddle.Tensor, @@ -219,7 +219,7 @@ def celu( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("uint16", "float16", "float32", "float64"), } @@ -238,7 +238,7 @@ def scaled_tanh( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version, ) def hardshrink( diff --git a/ivy/functional/backends/paddle/experimental/creation.py b/ivy/functional/backends/paddle/experimental/creation.py index 4e48162ac7dd5..4a0da45868140 100644 --- a/ivy/functional/backends/paddle/experimental/creation.py +++ b/ivy/functional/backends/paddle/experimental/creation.py @@ -183,7 +183,7 @@ def unsorted_segment_sum( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -257,7 +257,7 @@ def unsorted_segment_mean( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("float16", "int8", "int16", "uint8", "complex", "bool") } }, diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index ac51c0b1041e9..bb7843015e089 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -20,7 +20,7 @@ @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "float32", "float64", "int32", @@ -42,7 +42,7 @@ def amax( @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "float32", "float64", "int32", @@ -63,7 +63,7 @@ def amin( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, backend_version, ) def lgamma( @@ -73,7 +73,7 @@ def lgamma( @with_supported_dtypes( - {" 2.5.2 and below": ("float64", "float32", "int32", "int64")}, + {"2.5.2 and below": ("float64", "float32", "int32", "int64")}, backend_version, ) def fmax( @@ -89,7 +89,7 @@ def fmax( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def sinc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: y = ivy.pi * paddle.where(x == 0, paddle.to_tensor(1.0e-20, dtype=x.dtype), x) @@ -153,7 +153,7 @@ def copysign( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("uint8", "int8", "int16", "float16")}}, + {"2.5.2 and below": {"cpu": ("uint8", "int8", "int16", "float16")}}, backend_version, ) def nansum( @@ -172,7 +172,7 @@ def nansum( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def isclose( a: paddle.Tensor, @@ -188,7 +188,7 @@ def isclose( @with_unsupported_dtypes( - {" 2.5.2 and below": ("float16", "int16", "int8", "uint8")}, backend_version + {"2.5.2 and below": ("float16", "int16", "int8", "uint8")}, backend_version ) def diff( x: Union[paddle.Tensor, list, tuple], @@ -237,7 +237,7 @@ def hypot( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -277,7 +277,7 @@ def fix( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def nextafter( x1: paddle.Tensor, @@ -318,7 +318,7 @@ def nextafter( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -396,7 +396,7 @@ def _np_ndim(x): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, backend_version, ) def gradient( @@ -654,7 +654,7 @@ def count_nonzero( @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "complex64", "complex128", "float32", @@ -771,7 +771,7 @@ def _is_scalar(x): # TODO: Repalce once native function becomes available. # Compute an approximation of the error function complement (1 - erf(x)). @with_supported_dtypes( - {" 2.5.2 and below": ("float64", "float32")}, + {"2.5.2 and below": ("float64", "float32")}, backend_version, ) def erfc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index 8e564bd523247..f685b3083303a 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -30,7 +30,7 @@ def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_ @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -97,7 +97,7 @@ def max_pool1d( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -168,7 +168,7 @@ def max_pool2d( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -300,7 +300,7 @@ def dct( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "bool", "float16")}, backend_version + {"2.5.2 and below": ("bfloat16", "bool", "float16")}, backend_version ) def fft( x: paddle.Tensor, @@ -344,7 +344,7 @@ def fft( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -366,7 +366,7 @@ def dropout1d( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -388,7 +388,7 @@ def dropout2d( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -421,7 +421,7 @@ def ifft( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("int8", "float32", "float64"), "gpu": ("int8", "bfloat16", "float16", "float32", "float64"), }, @@ -513,7 +513,7 @@ def rfft( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "float16", "complex64", "complex128", "bool")}, + {"2.5.2 and below": ("bfloat16", "float16", "complex64", "complex128", "bool")}, backend_version, ) def rfftn( @@ -530,7 +530,7 @@ def rfftn( @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "complex64", "complex128", ) @@ -552,7 +552,7 @@ def fft2( # stft @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "complex64", "complex128", ) diff --git a/ivy/functional/backends/paddle/experimental/linear_algebra.py b/ivy/functional/backends/paddle/experimental/linear_algebra.py index 75e538afed720..aa76b96d31996 100644 --- a/ivy/functional/backends/paddle/experimental/linear_algebra.py +++ b/ivy/functional/backends/paddle/experimental/linear_algebra.py @@ -13,7 +13,7 @@ @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8", "float16", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("int8", "int16", "uint8", "float16", "bfloat16")}}, backend_version, ) def diagflat( @@ -47,7 +47,7 @@ def diagflat( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8", "uint8", "int16")}}, backend_version + {"2.5.2 and below": {"cpu": ("int8", "uint8", "int16")}}, backend_version ) def kron( a: paddle.Tensor, @@ -91,7 +91,7 @@ def adjoint( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8", "uint8", "int16", "float16")}}, + {"2.5.2 and below": {"cpu": ("int8", "uint8", "int16", "float16")}}, backend_version, ) def solve_triangular( @@ -133,7 +133,7 @@ def lu_factor( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "float32", "float64", @@ -168,7 +168,7 @@ def dot( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "float32", "float64", diff --git a/ivy/functional/backends/paddle/experimental/losses.py b/ivy/functional/backends/paddle/experimental/losses.py index 0efcc0d6f0f66..a6a4b4973bf89 100644 --- a/ivy/functional/backends/paddle/experimental/losses.py +++ b/ivy/functional/backends/paddle/experimental/losses.py @@ -14,7 +14,7 @@ @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "float16", "int8", @@ -42,7 +42,7 @@ def l1_loss( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -72,7 +72,7 @@ def smooth_l1_loss( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "float16", "int8", @@ -100,7 +100,7 @@ def huber_loss( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "float16", "int8", @@ -127,7 +127,7 @@ def soft_margin_loss( @with_supported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float32", "float64")}}, + {"2.5.2 and below": {"cpu": ("float32", "float64")}}, backend_version, ) def kl_div( @@ -195,7 +195,7 @@ def _validate_poisson_nll_params( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } diff --git a/ivy/functional/backends/paddle/experimental/manipulation.py b/ivy/functional/backends/paddle/experimental/manipulation.py index e40ac7cc23bd0..9fa5e60405ac0 100644 --- a/ivy/functional/backends/paddle/experimental/manipulation.py +++ b/ivy/functional/backends/paddle/experimental/manipulation.py @@ -94,7 +94,7 @@ @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int16", "int8", "uint8", @@ -120,7 +120,7 @@ def moveaxis( @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, backend_version, ) def pad( @@ -178,7 +178,7 @@ def pad( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -203,7 +203,7 @@ def heaviside( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def flipud( @@ -228,7 +228,7 @@ def vstack( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int16", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("int16", "bfloat16")}}, backend_version, ) def hstack( @@ -245,7 +245,7 @@ def hstack( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def rot90( @@ -261,7 +261,7 @@ def rot90( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def top_k( @@ -288,7 +288,7 @@ def top_k( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def fliplr( @@ -456,7 +456,7 @@ def atleast_2d( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version, ) def atleast_3d( @@ -481,7 +481,7 @@ def atleast_3d( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "bool", "float16", "int16", "int8", "uint8")}, + {"2.5.2 and below": ("bfloat16", "bool", "float16", "int16", "int8", "uint8")}, backend_version, ) def take_along_axis( @@ -603,7 +603,7 @@ def concat_from_sequence( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version + {"2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version ) def unique_consecutive( x: paddle.Tensor, @@ -666,7 +666,7 @@ def unique_consecutive( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8", "int16", "uint8", "float16")}}, + {"2.5.2 and below": {"cpu": ("int8", "int16", "uint8", "float16")}}, backend_version, ) def fill_diagonal( @@ -732,7 +732,7 @@ def _take_with_axis( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("int64", "float64", "int32", "uint8", "float32", "bool") } }, @@ -869,7 +869,7 @@ def trim_zeros(a: paddle.Tensor, /, *, trim: Optional[str] = "bf") -> paddle.Ten @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def put_along_axis( arr: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/experimental/norms.py b/ivy/functional/backends/paddle/experimental/norms.py index 7f58ca15dfdfe..2ffebad9ed2eb 100644 --- a/ivy/functional/backends/paddle/experimental/norms.py +++ b/ivy/functional/backends/paddle/experimental/norms.py @@ -12,7 +12,7 @@ # use numpy implementation with ivy functions @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -105,7 +105,7 @@ def batch_norm( ) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) def l1_normalize( x: paddle.Tensor, /, *, axis: int = None, out: paddle.Tensor = None ) -> paddle.Tensor: diff --git a/ivy/functional/backends/paddle/experimental/random.py b/ivy/functional/backends/paddle/experimental/random.py index 99c8871e9c777..9e1d00a6d3262 100644 --- a/ivy/functional/backends/paddle/experimental/random.py +++ b/ivy/functional/backends/paddle/experimental/random.py @@ -16,7 +16,7 @@ @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", diff --git a/ivy/functional/backends/paddle/experimental/sparse_array.py b/ivy/functional/backends/paddle/experimental/sparse_array.py index ff86ae8e1a77a..9a1f7870a323d 100644 --- a/ivy/functional/backends/paddle/experimental/sparse_array.py +++ b/ivy/functional/backends/paddle/experimental/sparse_array.py @@ -19,7 +19,7 @@ def is_native_sparse_array(x: paddle.Tensor) -> bool: @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8",)}}, backend_version + {"2.5.2 and below": {"cpu": ("int8",)}}, backend_version ) def native_sparse_array( data=None, diff --git a/ivy/functional/backends/paddle/experimental/statistical.py b/ivy/functional/backends/paddle/experimental/statistical.py index dabe9ac525381..7cd409e19532d 100644 --- a/ivy/functional/backends/paddle/experimental/statistical.py +++ b/ivy/functional/backends/paddle/experimental/statistical.py @@ -14,7 +14,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def median( @@ -32,7 +32,7 @@ def median( ) else: ret = paddle.median(input, axis=axis, keepdim=True) - # keepdims is set to True because in versions up to 2.5.2 + # keepdims is set to True because in versions up to 2.5.2 # there was a problem when the axis was defined, and it was the # only axis in the tensor, so it needs to be handled manually if not keepdims: @@ -48,7 +48,7 @@ def median( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64", "int64")}, backend_version + {"2.5.2 and below": ("complex", "float32", "float64", "int64")}, backend_version ) def nanmean( a: paddle.Tensor, @@ -101,7 +101,7 @@ def _validate_quantile(q): @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -140,7 +140,7 @@ def nanmin( return result -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) def nanprod( a: paddle.Tensor, /, @@ -308,7 +308,7 @@ def _compute_quantile_wrapper( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -382,7 +382,7 @@ def histogram( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def nanmedian( input: paddle.Tensor, @@ -401,7 +401,7 @@ def nanmedian( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -433,7 +433,7 @@ def unravel_index( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -556,7 +556,7 @@ def cov( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "bool", "float32", "float64")}, + {"2.5.2 and below": ("complex", "bool", "float32", "float64")}, backend_version, ) def cummax( @@ -681,7 +681,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("uint8", "int8", "int16")}}, + {"2.5.2 and below": {"cpu": ("uint8", "int8", "int16")}}, backend_version, ) def cummin( diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 08b1d141e4efb..54150e1a75d9f 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -86,7 +86,7 @@ def _squeeze_helper(query, x_ndim): @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("int8", "int16", "float16", "complex64", "complex128") } }, diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index c248417947d02..5a428da2517dd 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -104,7 +104,7 @@ def grad_(x): @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version ) def execute_with_gradients( func, xs, /, *, retain_grads=False, xs_grad_idxs=((0,),), ret_grad_idxs=((0,),) diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index cfce593aed238..d970754ef63f1 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -157,7 +157,7 @@ def conv1d( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, + {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version, ) def conv1d_transpose( @@ -216,7 +216,7 @@ def conv2d( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version, ) def conv2d_transpose( @@ -275,7 +275,7 @@ def depthwise_conv2d( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version, ) def conv3d( @@ -334,7 +334,7 @@ def conv3d_transpose( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("float16",)}}, + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version, ) def conv_general_dilated( diff --git a/ivy/functional/backends/paddle/linear_algebra.py b/ivy/functional/backends/paddle/linear_algebra.py index 60405f08b3005..83b274820b503 100644 --- a/ivy/functional/backends/paddle/linear_algebra.py +++ b/ivy/functional/backends/paddle/linear_algebra.py @@ -24,7 +24,7 @@ @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -91,7 +91,7 @@ def _cross(x1, x2, axisa, axisb, axisc, axis): @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def det(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -183,7 +183,7 @@ def inner( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def inv( @@ -252,7 +252,7 @@ def matmul( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_norm( @@ -334,7 +334,7 @@ def eig( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_power( @@ -344,7 +344,7 @@ def matrix_power( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_rank( @@ -441,7 +441,7 @@ def tensorsolve( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def qr( @@ -457,7 +457,7 @@ def qr( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def slogdet( @@ -476,7 +476,7 @@ def slogdet( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def solve( @@ -503,7 +503,7 @@ def solve( return ret -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) def svd( x: paddle.Tensor, /, *, full_matrices: bool = True, compute_uv: bool = True ) -> Union[paddle.Tensor, Tuple[paddle.Tensor, ...]]: @@ -517,7 +517,7 @@ def svd( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def svdvals( @@ -532,7 +532,7 @@ def svdvals( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version ) def tensordot( x1: paddle.Tensor, @@ -548,7 +548,7 @@ def tensordot( @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "int8", "int16", @@ -624,7 +624,7 @@ def vector_norm( @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, backend_version, ) def diag( @@ -638,11 +638,7 @@ def diag( @with_unsupported_device_and_dtypes( - { - " 2.5.2 and below": { - "cpu": ("uint8", "int8", "int16", "complex64", "complex128") - } - }, + {"2.5.2 and below": {"cpu": ("uint8", "int8", "int16", "complex64", "complex128")}}, backend_version, ) def vander( @@ -664,7 +660,7 @@ def vander( @with_unsupported_dtypes( - {" 2.5.2 and below": ("unsigned", "int8", "int16", "float16")}, + {"2.5.2 and below": ("unsigned", "int8", "int16", "float16")}, backend_version, ) def vector_to_skew_symmetric_matrix( diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index 17236d5a584a5..f064728cc7dee 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -74,7 +74,7 @@ def expand_dims( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def flip( @@ -91,7 +91,7 @@ def flip( @with_unsupported_dtypes( - {" 2.5.2 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version + {"2.5.2 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version ) def permute_dims( x: paddle.Tensor, @@ -159,7 +159,7 @@ def reshape( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def roll( @@ -174,7 +174,7 @@ def roll( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "float16", "int16")}, backend_version + {"2.5.2 and below": ("bfloat16", "float16", "int16")}, backend_version ) def squeeze( x: paddle.Tensor, @@ -201,7 +201,7 @@ def squeeze( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int16", "uint8", "int8", "float16")}}, + {"2.5.2 and below": {"cpu": ("int16", "uint8", "int8", "float16")}}, backend_version, ) def stack( @@ -249,7 +249,7 @@ def stack( # ------# -@with_unsupported_dtypes({" 2.5.2 and below": ("int16",)}, backend_version) +@with_unsupported_dtypes({"2.5.2 and below": ("int16",)}, backend_version) def split( x: paddle.Tensor, /, @@ -299,7 +299,7 @@ def split( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def repeat( @@ -335,7 +335,7 @@ def repeat( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def tile( @@ -378,7 +378,7 @@ def tile( @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bfloat16", "float16", "int8", @@ -462,7 +462,7 @@ def clip( @with_unsupported_dtypes( - {" 2.5.2 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version + {"2.5.2 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version ) def unstack( x: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/random.py b/ivy/functional/backends/paddle/random.py index 2410f9548f17e..c60fd5e24efea 100644 --- a/ivy/functional/backends/paddle/random.py +++ b/ivy/functional/backends/paddle/random.py @@ -25,7 +25,7 @@ @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8",)}}, + {"2.5.2 and below": {"cpu": ("int8",)}}, backend_version, ) def random_uniform( @@ -56,7 +56,7 @@ def random_uniform( @with_unsupported_dtypes( - {" 2.5.2 and below": ("float16", "int16", "int8")}, backend_version + {"2.5.2 and below": ("float16", "int16", "int8")}, backend_version ) def random_normal( *, @@ -77,7 +77,7 @@ def random_normal( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "float32", "float64", @@ -108,7 +108,7 @@ def multinomial( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8",)}}, + {"2.5.2 and below": {"cpu": ("int8",)}}, backend_version, ) def randint( diff --git a/ivy/functional/backends/paddle/searching.py b/ivy/functional/backends/paddle/searching.py index 5e242deb21ad4..d5c6a6ffbb9da 100644 --- a/ivy/functional/backends/paddle/searching.py +++ b/ivy/functional/backends/paddle/searching.py @@ -16,7 +16,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {"2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, backend_version, ) def argmax( @@ -48,7 +48,7 @@ def argmax( @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "bool", "complex", "float16", "int8")}, + {"2.5.2 and below": ("bfloat16", "bool", "complex", "float16", "int8")}, backend_version, ) def argmin( @@ -80,7 +80,7 @@ def argmin( @with_unsupported_dtypes( - {" 2.5.2 and below": ("float16", "int8", "uint8")}, backend_version + {"2.5.2 and below": ("float16", "int8", "uint8")}, backend_version ) def nonzero( x: paddle.Tensor, @@ -161,7 +161,7 @@ def where( @with_unsupported_dtypes( - {" 2.5.2 and below": ("float16", "int8", "uint8")}, backend_version + {"2.5.2 and below": ("float16", "int8", "uint8")}, backend_version ) def argwhere( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None diff --git a/ivy/functional/backends/paddle/set.py b/ivy/functional/backends/paddle/set.py index b736113350159..3825cf5914731 100644 --- a/ivy/functional/backends/paddle/set.py +++ b/ivy/functional/backends/paddle/set.py @@ -10,7 +10,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_all( x: paddle.Tensor, @@ -88,7 +88,7 @@ def unique_all( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_counts(x: paddle.Tensor, /) -> Tuple[paddle.Tensor, paddle.Tensor]: unique, counts = paddle.unique(x, return_counts=True) @@ -111,7 +111,7 @@ def unique_counts(x: paddle.Tensor, /) -> Tuple[paddle.Tensor, paddle.Tensor]: @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_inverse( x: paddle.Tensor, @@ -146,7 +146,7 @@ def unique_inverse( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_values( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None diff --git a/ivy/functional/backends/paddle/sorting.py b/ivy/functional/backends/paddle/sorting.py index c8309843e48a2..0585c975204f9 100644 --- a/ivy/functional/backends/paddle/sorting.py +++ b/ivy/functional/backends/paddle/sorting.py @@ -9,7 +9,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def argsort( x: paddle.Tensor, @@ -24,7 +24,7 @@ def argsort( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def sort( x: paddle.Tensor, @@ -39,7 +39,7 @@ def sort( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def searchsorted( x: paddle.Tensor, @@ -76,7 +76,7 @@ def searchsorted( @with_unsupported_device_and_dtypes( - {" 2.5.2 and below": {"cpu": ("int8", "uint8", "int16", "float16", "complex")}}, + {"2.5.2 and below": {"cpu": ("int8", "uint8", "int16", "float16", "complex")}}, backend_version, ) def msort( diff --git a/ivy/functional/backends/paddle/statistical.py b/ivy/functional/backends/paddle/statistical.py index a7d82a4cb5f25..8869dcfe888e7 100644 --- a/ivy/functional/backends/paddle/statistical.py +++ b/ivy/functional/backends/paddle/statistical.py @@ -22,7 +22,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def min( @@ -51,7 +51,7 @@ def min( @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def max( @@ -89,7 +89,7 @@ def max( @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "complex", "float32", "float64")}, backend_version + {"2.5.2 and below": ("bool", "complex", "float32", "float64")}, backend_version ) def mean( x: paddle.Tensor, @@ -119,7 +119,7 @@ def mean( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def prod( x: paddle.Tensor, @@ -167,7 +167,7 @@ def std( return _std(x, axis, correction, keepdims).cast(x.dtype) -@with_unsupported_dtypes({" 2.5.2 and below": ("int8", "uint8")}, backend_version) +@with_unsupported_dtypes({"2.5.2 and below": ("int8", "uint8")}, backend_version) def sum( x: paddle.Tensor, /, @@ -206,7 +206,7 @@ def var( # Extra # # ----- # @with_supported_dtypes( - {" 2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def cumprod( @@ -256,7 +256,7 @@ def cumprod( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def cumsum( x: paddle.Tensor, @@ -305,7 +305,7 @@ def cumsum( @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("float32", "float64", "complex64", "complex128"), "gpu": ( "bfloat16", diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 1deb9f4fa5b7a..73478b8f9c43c 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -7,7 +7,7 @@ "numpy": "1.25.2", "jax": "0.4.14", "scipy": "1.10.1", - "paddle": " 2.5.2", + "paddle": "2.5.2", "sklearn": "1.3.0", "xgboost": "1.7.6", "torchvision": "0.15.2.", diff --git a/ivy/functional/frontends/jax/array.py b/ivy/functional/frontends/jax/array.py index c6dd9eac7fcb3..7e5aa872f4c04 100644 --- a/ivy/functional/frontends/jax/array.py +++ b/ivy/functional/frontends/jax/array.py @@ -74,7 +74,7 @@ def astype(self, dtype): f"Dtype {self.dtype} is not castable to {dtype}" ) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def argmax( self, /, @@ -90,7 +90,7 @@ def argmax( keepdims=keepdims, ) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def argmin( self, /, diff --git a/ivy/functional/frontends/jax/numpy/fft.py b/ivy/functional/frontends/jax/numpy/fft.py index 9e558898dadb8..69b9415b6176b 100644 --- a/ivy/functional/frontends/jax/numpy/fft.py +++ b/ivy/functional/frontends/jax/numpy/fft.py @@ -19,7 +19,7 @@ def fft2(a, s=None, axes=(-2, -1), norm=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def fftfreq(n, d=1.0, *, dtype=None): if not isinstance( n, (int, type(ivy.int8), type(ivy.int16), type(ivy.int32), type(ivy.int64)) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 2a4ef435a94df..c8a429121b7c7 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -90,7 +90,7 @@ def ceil(x, /): return ivy.ceil(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def clip(a, a_min=None, a_max=None, out=None): return ivy.array(ivy.clip(a, a_min, a_max), dtype=a.dtype) diff --git a/ivy/functional/frontends/paddle/creation.py b/ivy/functional/frontends/paddle/creation.py index 1ec66e3ca191b..24d90399e4f8a 100644 --- a/ivy/functional/frontends/paddle/creation.py +++ b/ivy/functional/frontends/paddle/creation.py @@ -7,14 +7,14 @@ ) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def arange(start, end=None, step=1, dtype=None, name=None): return ivy.arange(start, end, step=step, dtype=dtype) @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64", "bool")}, + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64", "bool")}, "paddle", ) @to_ivy_arrays_and_back @@ -30,7 +30,7 @@ def assign(x, output=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("bfloat16", "uint16", "uint32", "uint64")}, "paddle" + {"2.5.2 and below": ("bfloat16", "uint16", "uint32", "uint64")}, "paddle" ) @to_ivy_arrays_and_back def clone(x): @@ -38,7 +38,7 @@ def clone(x): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -54,7 +54,7 @@ def complex(real, imag, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diag(x, offset=0, padding_value=0, name=None): @@ -69,7 +69,7 @@ def diag(x, offset=0, padding_value=0, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diagflat(x, offset=0, name=None): @@ -105,7 +105,7 @@ def full_like(x, fill_value, /, *, dtype=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def linspace(start, stop, num, dtype=None, name=None): @@ -113,7 +113,7 @@ def linspace(start, stop, num, dtype=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def logspace(start, stop, num, base=10.0, dtype=None, name=None): @@ -121,14 +121,14 @@ def logspace(start, stop, num, base=10.0, dtype=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def meshgrid(*args, **kwargs): return ivy.meshgrid(*args, indexing="ij") -@with_unsupported_dtypes({" 2.5.2 and below": "int8"}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": "int8"}, "paddle") @to_ivy_arrays_and_back def ones(shape, /, *, dtype=None, name=None): dtype = "float32" if dtype is None else dtype @@ -136,7 +136,7 @@ def ones(shape, /, *, dtype=None, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" + {"2.5.2 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" ) @to_ivy_arrays_and_back def ones_like(x, /, *, dtype=None, name=None): @@ -152,7 +152,7 @@ def to_tensor(data, /, *, dtype=None, place=None, stop_gradient=True): @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "uint8", "int8", "int16", @@ -169,7 +169,7 @@ def tril(x, diagonal=0, name=None): return ivy.tril(x, k=diagonal) -@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def tril_indices(row, col, offset=0, dtype="int64"): arr = ivy.tril_indices(row, col, offset) @@ -179,7 +179,7 @@ def tril_indices(row, col, offset=0, dtype="int64"): @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "uint8", "int8", "int16", @@ -196,7 +196,7 @@ def triu(x, diagonal=0, name=None): return ivy.triu(x, k=diagonal) -@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def triu_indices(row, col=None, offset=0, dtype="int64"): arr = ivy.triu_indices(row, col, offset) @@ -206,7 +206,7 @@ def triu_indices(row, col=None, offset=0, dtype="int64"): return arr -@with_unsupported_dtypes({" 2.5.2 and below": "int8"}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": "int8"}, "paddle") @to_ivy_arrays_and_back def zeros(shape, /, *, dtype=None, name=None): dtype = "float32" if dtype is None else dtype @@ -214,7 +214,7 @@ def zeros(shape, /, *, dtype=None, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" + {"2.5.2 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" ) @to_ivy_arrays_and_back def zeros_like(x, /, *, dtype=None, name=None): diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 9762afa2123b9..361b616afe789 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -7,7 +7,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128")}, + {"2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -18,7 +18,7 @@ def fft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float32", @@ -44,7 +44,7 @@ def fftfreq(n, d=1.0, dtype=None, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float32", @@ -73,7 +73,7 @@ def fftshift(x, axes=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128")}, + {"2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -95,7 +95,7 @@ def hfft(x, n=None, axes=-1, norm="backward", name=None): @with_supported_dtypes( - {" 2.5.2 and below": "complex64"}, + {"2.5.2 and below": "complex64"}, "paddle", ) @to_ivy_arrays_and_back @@ -116,7 +116,7 @@ def hfft2(x, s=None, axis=(-2, -1), norm="backward"): @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128")}, + {"2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -126,7 +126,7 @@ def ifft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128")}, + {"2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -137,7 +137,7 @@ def ifftn(x, s=None, axes=None, norm="backward", name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float32", @@ -165,7 +165,7 @@ def ifftshift(x, axes=None, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float32", @@ -199,7 +199,7 @@ def ihfft2(x, s=None, axes=(-2, -1), norm="backward", name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128")}, + {"2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -218,7 +218,7 @@ def irfft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float16", @@ -254,7 +254,7 @@ def irfft2(x, s=None, axes=(-2, -1), norm="backward"): @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128")}, + {"2.5.2 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -305,7 +305,7 @@ def irfftn(x, s=None, axes=None, norm="backward", name=None): return result_t -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rfft(x, n=None, axis=-1, norm="backward", name=None): return ivy.dft(x, axis=axis, inverse=False, onesided=True, dft_length=n, norm=norm) diff --git a/ivy/functional/frontends/paddle/linalg.py b/ivy/functional/frontends/paddle/linalg.py index cc3330ce4fe75..acd78acb75823 100644 --- a/ivy/functional/frontends/paddle/linalg.py +++ b/ivy/functional/frontends/paddle/linalg.py @@ -14,7 +14,7 @@ def bincount(x, weights=None, minlength=0, name=None): # bmm -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def bmm(x, y, transpose_x=False, transpose_y=False, name=None): if len(ivy.shape(x)) != 3 or len(ivy.shape(y)) != 3: @@ -24,14 +24,14 @@ def bmm(x, y, transpose_x=False, transpose_y=False, name=None): # cholesky -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cholesky(x, /, *, upper=False, name=None): return ivy.cholesky(x, upper=upper) # cholesky_solve -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cholesky_solve(x, y, /, *, upper=False, name=None): if upper: @@ -41,7 +41,7 @@ def cholesky_solve(x, y, /, *, upper=False, name=None): # cond -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cond(x, p=None, name=None): ret = ivy.cond(x, p=p, out=name) @@ -51,7 +51,7 @@ def cond(x, p=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def cross(x, y, /, *, axis=9, name=None): @@ -62,7 +62,7 @@ def cross(x, y, /, *, axis=9, name=None): # diagonal @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float64", @@ -87,7 +87,7 @@ def dist(x, y, p=2): # dot -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def dot(x, y, name=None): x, y = promote_types_of_paddle_inputs(x, y) @@ -151,7 +151,7 @@ def lu_unpack(lu_data, lu_pivots, unpack_datas=True, unpack_pivots=True, *, out= # matmul -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def matmul(x, y, transpose_x=False, transpose_y=False, name=None): x, y = promote_types_of_paddle_inputs(x, y) @@ -159,21 +159,21 @@ def matmul(x, y, transpose_x=False, transpose_y=False, name=None): # matrix_power -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def matrix_power(x, n, name=None): return ivy.matrix_power(x, n) # mv -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def mv(x, vec, name=None): return ivy.dot(x, vec) # norm -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def norm(x, p="fro", axis=None, keepdim=False, name=None): if axis is None and p is not None: @@ -226,7 +226,7 @@ def norm(x, p="fro", axis=None, keepdim=False, name=None): # pinv -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def pinv(x, rcond=1e-15, hermitian=False, name=None): # TODO: Add hermitian functionality @@ -234,21 +234,21 @@ def pinv(x, rcond=1e-15, hermitian=False, name=None): # qr -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def qr(x, mode="reduced", name=None): return ivy.qr(x, mode=mode) # solve -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def solve(x, y, name=None): return ivy.solve(x, y) # transpose -@with_unsupported_dtypes({" 2.5.2 and below": ("uint8", "int8", "int16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("uint8", "int8", "int16")}, "paddle") @to_ivy_arrays_and_back def transpose(x, perm, name=None): return ivy.permute_dims(x, axes=perm) diff --git a/ivy/functional/frontends/paddle/logic.py b/ivy/functional/frontends/paddle/logic.py index db997c4ca72fa..220d26ded9aaf 100644 --- a/ivy/functional/frontends/paddle/logic.py +++ b/ivy/functional/frontends/paddle/logic.py @@ -13,7 +13,7 @@ @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "float32", "float64", "bool", @@ -35,7 +35,7 @@ def allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "uint8", "int8", @@ -54,7 +54,7 @@ def bitwise_and(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "uint8", "int8", @@ -73,7 +73,7 @@ def bitwise_not(x, out=None, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "uint8", "int8", @@ -92,7 +92,7 @@ def bitwise_or(x, y, name=None, out=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "uint8", "int8", @@ -110,7 +110,7 @@ def bitwise_xor(x, y, /, *, name=None, out=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + {"2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -120,7 +120,7 @@ def equal(x, y, /, *, name=None): @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "uint8", "int8", "int16", @@ -137,7 +137,7 @@ def equal_all(x, y, /, *, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -146,7 +146,7 @@ def greater_equal(x, y, /, *, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -155,7 +155,7 @@ def greater_than(x, y, /, *, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + {"2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -170,7 +170,7 @@ def is_tensor(x): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "float32", "float64", ) @@ -183,7 +183,7 @@ def isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -192,7 +192,7 @@ def less_equal(x, y, /, *, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -202,7 +202,7 @@ def less_than(x, y, /, *, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -222,7 +222,7 @@ def logical_and(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -242,7 +242,7 @@ def logical_not(x, /, *, name=None, out=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -262,7 +262,7 @@ def logical_or(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -281,7 +281,7 @@ def logical_xor(x, y, /, *, name=None, out=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + {"2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/manipulation.py b/ivy/functional/frontends/paddle/manipulation.py index 6ed5071982517..2e3e24fea4c90 100644 --- a/ivy/functional/frontends/paddle/manipulation.py +++ b/ivy/functional/frontends/paddle/manipulation.py @@ -10,14 +10,14 @@ ) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def abs(x, name=None): return ivy.abs(x) @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -27,7 +27,7 @@ def broadcast_to(x, shape, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "float16", "float32", @@ -44,14 +44,14 @@ def cast(x, dtype): return ivy.astype(x, dtype) -@with_unsupported_dtypes({" 2.5.2 and below": ("int8", "int16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("int8", "int16")}, "paddle") @to_ivy_arrays_and_back def concat(x, axis, name=None): return ivy.concat(x, axis=axis) @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -60,7 +60,7 @@ def expand(x, shape, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("int8", "uint8", "int16", "float16")}, + {"2.5.2 and below": ("int8", "uint8", "int16", "float16")}, "paddle", ) @to_ivy_arrays_and_back @@ -69,7 +69,7 @@ def flip(x, axis, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -78,7 +78,7 @@ def gather(params, indices, axis=-1, batch_dims=0, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, + {"2.5.2 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, "paddle", ) @to_ivy_arrays_and_back @@ -93,7 +93,7 @@ def put_along_axis(arr, indices, values, axis, reduce="assign"): @with_supported_dtypes( - {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, + {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -126,7 +126,7 @@ def roll(x, shifts, axis=None, name=None): @with_supported_device_and_dtypes( { - " 2.5.2 and above": { + "2.5.2 and above": { "cpu": ( "bool", "int32", @@ -145,7 +145,7 @@ def rot90(x, k=1, axes=(0, 1), name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("int16", "complex64", "complex128")}, + {"2.5.2 and below": ("int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -154,7 +154,7 @@ def split(x, num_or_sections, axis=0, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("float16", "bfloat16", "int8", "int16")}, + {"2.5.2 and below": ("float16", "bfloat16", "int8", "int16")}, "paddle", ) @to_ivy_arrays_and_back @@ -172,7 +172,7 @@ def take_along_axis(arr, indices, axis): @with_unsupported_dtypes( - {" 2.5.2 and below": ("int8", "uint8", "int16", "float16")}, + {"2.5.2 and below": ("int8", "uint8", "int16", "float16")}, "paddle", ) @to_ivy_arrays_and_back @@ -186,7 +186,7 @@ def tolist(x): @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + {"2.5.2 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -198,7 +198,7 @@ def unbind(input, axis=0): @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + {"2.5.2 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -208,7 +208,7 @@ def unique_consecutive(x, axis=0): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "float32", "float64", "int32", diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index dc53e7992d9df..9d21b5e4f9445 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -8,26 +8,26 @@ from ivy.functional.frontends.paddle.func_wrapper import to_ivy_arrays_and_back -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def abs(x, name=None): return ivy.abs(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def acos(x, name=None): return ivy.acos(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def acosh(x, name=None): return ivy.acosh(x) @with_unsupported_dtypes( - {" 2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" ) @to_ivy_arrays_and_back def add(x, y, name=None): @@ -35,7 +35,7 @@ def add(x, y, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" ) @to_ivy_arrays_and_back def add_(x, y, name=None): @@ -43,7 +43,7 @@ def add_(x, y, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def addmm(input, x, y, beta=1.0, alpha=1.0, name=None): @@ -58,7 +58,7 @@ def all(x, axis, keepdim=False, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def amax(x, axis=None, keepdims=False): @@ -76,7 +76,7 @@ def amax(x, axis=None, keepdims=False): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def amin(x, axis=None, keepdim=False, name=None): @@ -84,7 +84,7 @@ def amin(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128", "float32", "float64")}, + {"2.5.2 and below": ("complex64", "complex128", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -98,19 +98,19 @@ def any(x, axis=None, keepdim=False, name=None): return ivy.any(x, axis=axis, keepdims=keepdim) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def asin(x, name=None): return ivy.asin(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def asinh(x, name=None): return ivy.asinh(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def atan(x, name=None): return ivy.atan(x) @@ -122,19 +122,19 @@ def atan2(x, y, name=None): return ivy.atan2(x, y) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def atanh(x, name=None): return ivy.atanh(x) -@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def broadcast_shape(x_shape, y_shape): return ivy.broadcast_shapes(x_shape, y_shape) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def ceil(x, name=None): return ivy.ceil(x) @@ -146,20 +146,20 @@ def conj(x, name=None): return ivy.conj(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def cos(x, name=None): return ivy.cos(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def cosh(x, name=None): return ivy.cosh(x) @with_supported_dtypes( - {" 2.5.2 and below": ("int32", "int64", "float16", "float32", "float64", "bool")}, + {"2.5.2 and below": ("int32", "int64", "float16", "float32", "float64", "bool")}, "paddle", ) @to_ivy_arrays_and_back @@ -169,7 +169,7 @@ def count_nonzero(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float32", @@ -186,14 +186,14 @@ def cumprod(x, dim=None, dtype=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def cumsum(x, axis=None, dtype=None, name=None): return ivy.cumsum(x, axis=axis, dtype=dtype) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def deg2rad(x, name=None): return ivy.deg2rad(x) @@ -201,7 +201,7 @@ def deg2rad(x, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float64", @@ -219,82 +219,80 @@ def diagonal(x, offset=0, axis1=0, axis2=1, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diff(x, n=1, axis=-1, prepend=None, append=None, name=None): return ivy.diff(x, n=n, axis=axis, prepend=prepend, append=append) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def digamma(x, name=None): digamma_fun = ivy.digamma return ivy.array(digamma_fun(x), dtype=x.dtype) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def divide(x, y, name=None): return ivy.divide(x, y) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def erf(x, name=None): return ivy.erf(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def exp(x, name=None): return ivy.exp(x) -@with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64")}, "paddle" -) +@with_supported_dtypes({"2.5.2 and below": ("float16", "float32", "float64")}, "paddle") @to_ivy_arrays_and_back def expm1(x, name=None): return ivy.expm1(x) @with_supported_dtypes( - {" 2.5.2 and below": ("bfloat16", "float32", "float64")}, "paddle" + {"2.5.2 and below": ("bfloat16", "float32", "float64")}, "paddle" ) @to_ivy_arrays_and_back def floor(x, name=None): return ivy.floor(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def floor_divide(x, y, name=None): return ivy.floor_divide(x, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def floor_mod(x, y, name=None): return ivy.remainder(x, y) -@with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") @to_ivy_arrays_and_back def fmax(x, y, name=None): return ivy.fmax(x, y) -@with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") @to_ivy_arrays_and_back def fmin(x, y, name=None): return ivy.fmin(x, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def frac(x, name=None): @@ -302,21 +300,21 @@ def frac(x, name=None): return ivy.subtract(x, y) -@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def gcd(x, y, name=None): return ivy.gcd(x, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def heaviside(x, y, name=None): return ivy.heaviside(x, y) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def inner(x, y, name=None): result = ivy.inner(x, y) @@ -327,14 +325,14 @@ def inner(x, y, name=None): return result -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def inverse(x, name=None): return ivy.inv(x) @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isfinite(x, name=None): @@ -342,7 +340,7 @@ def isfinite(x, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isinf(x, name=None): @@ -350,7 +348,7 @@ def isinf(x, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isnan(x, name=None): @@ -358,63 +356,63 @@ def isnan(x, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def kron(x, y, name=None): return ivy.kron(x, y) -@with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def lcm(x, y, name=None): return ivy.lcm(x, y) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lerp(x, y, weight, name=None): return ivy.lerp(x, y, weight) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lgamma(x, name=None): return ivy.lgamma(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def log(x, name=None): return ivy.log(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log10(x, name=None): return ivy.log10(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log1p(x, name=None): return ivy.log1p(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log2(x, name=None): return ivy.log2(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def logit(x, eps=None, name=None): return ivy.logit(x, eps=eps) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def max(x, axis=None, keepdim=False, name=None): @@ -422,14 +420,14 @@ def max(x, axis=None, keepdim=False, name=None): # maximum -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def maximum(x, y, name=None): return ivy.maximum(x, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def min(x, axis=None, keepdim=False, name=None): @@ -437,7 +435,7 @@ def min(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def minimum(x, y, name=None): @@ -445,27 +443,27 @@ def minimum(x, y, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def mm(input, mat2, name=None): return ivy.matmul(input, mat2) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def multiply(x, y, name=None): return ivy.multiply(x, y) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def nanmean(x, axis=None, keepdims=False): return ivy.nanmean(x, axis=axis, keepdims=keepdims) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def nansum(x, axis=None, dtype=None, name=None): @@ -473,7 +471,7 @@ def nansum(x, axis=None, dtype=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -481,39 +479,39 @@ def neg(x, name=None): return ivy.negative(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def outer(x, y, name=None): return ivy.outer(x, y) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def pow(x, y, name=None): return ivy.pow(x, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def prod(x, axis=None, keepdim=False, dtype=None, name=None): return ivy.prod(x, axis=axis, keepdims=keepdim, dtype=dtype) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def rad2deg(x, name=None): return ivy.rad2deg(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def reciprocal(x, name=None): return ivy.reciprocal(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def remainder(x, y, name=None): return ivy.remainder(x, y) @@ -521,7 +519,7 @@ def remainder(x, y, name=None): @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("float32", "float64"), "gpu": ("float16", "float32", "float64"), } @@ -533,7 +531,7 @@ def remainder_(x, y, name=None): return ivy.inplace_update(x, remainder(x, y)) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def round(x, name=None): sign = ivy.sign(x) @@ -541,49 +539,49 @@ def round(x, name=None): return x -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rsqrt(x, name=None): return 1 / ivy.sqrt(x) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sgn(x, name=None): return ivy.sign(x, np_variant=True) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sign(x, name=None): return ivy.sign(x, np_variant=False) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sin(x, name=None): return ivy.sin(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sinh(x, name=None): return ivy.sinh(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sqrt(x, name=None): return ivy.sqrt(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def square(x, name=None): return ivy.square(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def stanh(x, scale_a=0.67, scale_b=1.7159, name=None): # TODO this function will be simplified as soon as the ivy.stanh(x,a,b) is added @@ -595,7 +593,7 @@ def stanh(x, scale_a=0.67, scale_b=1.7159, name=None): return ret -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def subtract(x, y, name=None): return ivy.subtract(x, y) @@ -603,7 +601,7 @@ def subtract(x, y, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "float64", "int64", ) @@ -621,7 +619,7 @@ def sum(x, axis=None, dtype=None, keepdim=False, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int6")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int6")}, "paddle" ) @to_ivy_arrays_and_back def take( @@ -643,20 +641,20 @@ def take( return ivy.gather(x, index, axis=0) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def tan(x, name=None): return ivy.tan(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanh(x, name=None): return ivy.tanh(x) @with_supported_dtypes( - {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) @to_ivy_arrays_and_back def trace(x, offset=0, axis1=0, axis2=1, name=None): diff --git a/ivy/functional/frontends/paddle/nn/functional/activation.py b/ivy/functional/frontends/paddle/nn/functional/activation.py index 15da49749b49d..f8621b7f3f998 100644 --- a/ivy/functional/frontends/paddle/nn/functional/activation.py +++ b/ivy/functional/frontends/paddle/nn/functional/activation.py @@ -8,7 +8,7 @@ tanh = paddle_tanh -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def celu( x, @@ -20,7 +20,7 @@ def celu( return ivy.celu(x, alpha=alpha) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def elu( x, @@ -32,13 +32,13 @@ def elu( return ivy.elu(x, alpha=alpha) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def gelu(x, approximate=False, name=None): return ivy.gelu(x, approximate=approximate) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def glu(x, axis=-1, name=None): size = x.shape[axis] @@ -63,21 +63,21 @@ def gumbel_softmax(x, temperature=1.0, hard=False, axis=-1, name=None): return y_soft -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardshrink(x, threshold=0.5, name=None): mask = ivy.logical_or(ivy.greater(x, threshold), ivy.less(x, -threshold)) return ivy.where(mask, x, 0.0) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardsigmoid(x, slope=0.1666667, offset=0.5, name=None): ret = ivy.minimum(ivy.maximum(ivy.add(ivy.multiply(x, slope), offset), 0), 1) return ret -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardswish(x, name=None): relu6_val = ivy.relu6(ivy.add(x, 3)) @@ -85,7 +85,7 @@ def hardswish(x, name=None): return ret -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardtanh( x, @@ -106,13 +106,13 @@ def leaky_relu(x, negative_slope=0.01, name=None): return ivy.leaky_relu(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log_sigmoid(x, name=None): return -ivy.softplus(-x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log_softmax(x, axis=-1, dtype=None, name=None): x = ivy.astype(x, dtype) if dtype else x @@ -121,31 +121,31 @@ def log_softmax(x, axis=-1, dtype=None, name=None): return ret -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def mish(x, name=None): return ivy.mish(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def prelu(x, weight, data_format="NCHW", name=None): return ivy.add(ivy.maximum(0, x), ivy.multiply(weight, ivy.minimum(0, x))) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu(x, name=None): return ivy.relu(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu6(x, name=None): return ivy.relu6(x) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu_(x, name=None): ret = ivy.relu(x) @@ -153,7 +153,7 @@ def relu_(x, name=None): return x -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rrelu( x, @@ -189,7 +189,7 @@ def rrelu( return out.astype(x.dtype) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def selu( x, @@ -222,13 +222,13 @@ def softmax_(x, axis=-1, dtype=None, name=None): return x -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softplus(x, beta=1, threshold=20, name=None): return ivy.softplus(x, beta=beta, threshold=threshold) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softshrink( x, @@ -243,7 +243,7 @@ def softshrink( return ivy.astype(add, x.dtype) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softsign( x, @@ -254,7 +254,7 @@ def softsign( return ivy.divide(x, ivy.add(1, ivy.abs(x))) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def swish(x, name=None): return ivy.multiply(x, ivy.sigmoid(x)) @@ -273,7 +273,7 @@ def tanh_(x, name=None): # return ret.astype(x.dtype) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanhshrink( x, diff --git a/ivy/functional/frontends/paddle/nn/functional/common.py b/ivy/functional/frontends/paddle/nn/functional/common.py index 414984d6f891f..d43f6a42a93bc 100644 --- a/ivy/functional/frontends/paddle/nn/functional/common.py +++ b/ivy/functional/frontends/paddle/nn/functional/common.py @@ -5,7 +5,7 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def cosine_similarity(x1, x2, *, axis=1, eps=1e-08): if len(x1.shape) == len(x2.shape) and len(x2.shape) >= 2: numerator = ivy.sum(x1 * x2, axis=axis) @@ -26,7 +26,7 @@ def cosine_similarity(x1, x2, *, axis=1, eps=1e-08): @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def dropout(x, p=0.5, axis=None, training=True, mode="upscale_in_train", name=None): if axis is not None and axis > 1: raise ValueError("Axis value can only be 0 or 1 or None.") @@ -53,13 +53,13 @@ def dropout(x, p=0.5, axis=None, training=True, mode="upscale_in_train", name=No @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def dropout2d(x, *, p=0.5, training=True, data_format="NCHW", name=None): return ivy.dropout2d(x, p=p, training=training, data_format=data_format) @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def dropout3d(x, p=0.5, training=True, data_format="NCDHW", name=None): return ivy.dropout3d(x, p, training=training, data_format=data_format) @@ -74,7 +74,7 @@ def get_mask(shape, device, prob, seed=None): @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def interpolate( x, size=None, @@ -91,14 +91,14 @@ def interpolate( @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def linear(x, weight, bias=None, name=None): weight = ivy.swapaxes(weight, -1, -2) return ivy.linear(x, weight, bias=bias) @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): # Input checking if isinstance(kernel_sizes, int): @@ -178,7 +178,7 @@ def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def zeropad2d(x, padding, data_format="NCHW", name=None): if ivy.is_array(padding): padding = padding.to_list() diff --git a/ivy/functional/frontends/paddle/nn/functional/conv.py b/ivy/functional/frontends/paddle/nn/functional/conv.py index 182c8652c5838..296ba22e4237c 100644 --- a/ivy/functional/frontends/paddle/nn/functional/conv.py +++ b/ivy/functional/frontends/paddle/nn/functional/conv.py @@ -79,7 +79,7 @@ def _conv_transpose( # ------------ # -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv1d( x, @@ -95,7 +95,7 @@ def conv1d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv1d_transpose( x, @@ -115,7 +115,7 @@ def conv1d_transpose( ) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv2d( x, @@ -131,7 +131,7 @@ def conv2d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv2d_transpose( x, @@ -151,7 +151,7 @@ def conv2d_transpose( ) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv3d( x, @@ -167,7 +167,7 @@ def conv3d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv3d_transpose( x, diff --git a/ivy/functional/frontends/paddle/nn/functional/loss.py b/ivy/functional/frontends/paddle/nn/functional/loss.py index 3aa8c6cfcc181..52d07db32110b 100644 --- a/ivy/functional/frontends/paddle/nn/functional/loss.py +++ b/ivy/functional/frontends/paddle/nn/functional/loss.py @@ -47,7 +47,7 @@ def _pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): # ------------ # -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def binary_cross_entropy(input, label, weight=None, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -59,7 +59,7 @@ def binary_cross_entropy(input, label, weight=None, reduction="mean", name=None) @with_supported_dtypes( - {" 2.5.2 and below": ("float32",)}, + {"2.5.2 and below": ("float32",)}, "paddle", ) @inputs_to_ivy_arrays @@ -83,7 +83,7 @@ def binary_cross_entropy_with_logits( @handle_exceptions @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def cosine_embedding_loss( input1, input2, label, margin=0.0, reduction="mean", name=None ): @@ -124,7 +124,7 @@ def cosine_embedding_loss( return out -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def dice_loss(input, label, epsilon=0.00001, name=None): ivy.assertions.check_true( @@ -164,7 +164,7 @@ def dice_loss(input, label, epsilon=0.00001, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32",)}, + {"2.5.2 and below": ("float32",)}, "paddle", ) @to_ivy_arrays_and_back @@ -188,7 +188,7 @@ def hinge_embedding_loss(input, label, margin=1.0, reduction="mean"): return loss -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def kl_div( input, @@ -235,7 +235,7 @@ def l1_loss( @with_supported_dtypes( - {" 2.5.2 and below": ("float32",)}, + {"2.5.2 and below": ("float32",)}, "paddle", ) @to_ivy_arrays_and_back @@ -246,7 +246,7 @@ def log_loss(input, label, epsilon=0.0001, name=None): return out -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def margin_ranking_loss(input, other, label, margin=0.0, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -266,7 +266,7 @@ def margin_ranking_loss(input, other, label, margin=0.0, reduction="mean", name= return out -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @inputs_to_ivy_arrays def mse_loss(input, label, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -276,7 +276,7 @@ def mse_loss(input, label, reduction="mean", name=None): return paddle.to_tensor(ret) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def multi_label_soft_margin_loss( input, label, weight=None, reduction="mean", name=None @@ -294,7 +294,7 @@ def multi_label_soft_margin_loss( return ret -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def nll_loss( input, @@ -327,7 +327,7 @@ def nll_loss( return output -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sigmoid_focal_loss( logit, @@ -373,7 +373,7 @@ def sigmoid_focal_loss( return loss -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def smooth_l1_loss( input, @@ -400,7 +400,7 @@ def smooth_l1_loss( @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @inputs_to_ivy_arrays @@ -460,13 +460,13 @@ def softmax_with_cross_entropy( return paddle.to_tensor(loss) -@with_supported_dtypes({" 2.5.2 and below": ("float32",)}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32",)}, "paddle") @to_ivy_arrays_and_back def square_error_cost(input, label): return ivy.square(ivy.subtract(input, label)) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def triplet_margin_loss( input, diff --git a/ivy/functional/frontends/paddle/nn/functional/norm.py b/ivy/functional/frontends/paddle/nn/functional/norm.py index b032a9d2e3aa2..17e2aca071c79 100644 --- a/ivy/functional/frontends/paddle/nn/functional/norm.py +++ b/ivy/functional/frontends/paddle/nn/functional/norm.py @@ -5,13 +5,13 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def layer_norm(x, normalized_shape, weight=None, bias=None, epsilon=1e-05, name=None): return ivy.layer_norm(x, normalized_shape, weight, bias, epsilon) @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def normalize(x, p=2, axis=1, epsilon=1e-12, name=None): if axis < 0: axis = ivy.get_num_dims(x) + axis diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index 0198b565c8090..de81646e8c4da 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -9,13 +9,13 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def adaptive_avg_pool1d(x, output_size, name=None): return ivy.adaptive_avg_pool1d(x, output_size) @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def adaptive_avg_pool2d(x, output_size, data_format="NCHW", name=None): return ivy.adaptive_avg_pool2d(x, output_size) @@ -27,13 +27,13 @@ def adaptive_avg_pool3d(x, output_size, data_format="NCHW", name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def adaptive_max_pool2d(x, output_size, return_mask=None, name=None): return ivy.adaptive_max_pool2d(x, output_size) @to_ivy_arrays_and_back -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def avg_pool1d( x, kernel_size, stride=None, padding=0, exclusive=True, ceil_mode=False, name=None ): @@ -63,7 +63,7 @@ def avg_pool1d( @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def avg_pool2d( x, kernel_size, @@ -101,7 +101,7 @@ def avg_pool2d( @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def max_unpool1d( x, indices, diff --git a/ivy/functional/frontends/paddle/nn/functional/vision.py b/ivy/functional/frontends/paddle/nn/functional/vision.py index 02294f6e40080..cf0ad4893580a 100644 --- a/ivy/functional/frontends/paddle/nn/functional/vision.py +++ b/ivy/functional/frontends/paddle/nn/functional/vision.py @@ -9,7 +9,7 @@ @to_ivy_arrays_and_back -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def affine_grid(theta, out_shape, align_corners=True): if len(out_shape) == 4: N, C, H, W = out_shape @@ -75,7 +75,7 @@ def affine_grid(theta, out_shape, align_corners=True): @to_ivy_arrays_and_back -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def channel_shuffle(x, groups, data_format="NCHW", name=None): if len(ivy.shape(x)) != 4: raise ValueError( diff --git a/ivy/functional/frontends/paddle/random.py b/ivy/functional/frontends/paddle/random.py index ab4cc1368d017..2a436935b9933 100644 --- a/ivy/functional/frontends/paddle/random.py +++ b/ivy/functional/frontends/paddle/random.py @@ -8,7 +8,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -18,7 +18,7 @@ def multinomial(x, num_samples=1, replacement=False, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -27,7 +27,7 @@ def normal(mean=0.0, std=1.0, shape=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -37,7 +37,7 @@ def poisson(x, name=None): @with_supported_device_and_dtypes( { - " 2.5.2 and above": { + "2.5.2 and above": { "cpu": ( "bfloat16", "float32", @@ -75,7 +75,7 @@ def randint(low=0, high=None, shape=[1], dtype=None, name=None): @with_unsupported_dtypes( - {" 2.5.2 and below": ("int16", "float16", "bfloat16", "uint8")}, + {"2.5.2 and below": ("int16", "float16", "bfloat16", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -99,7 +99,7 @@ def randn(shape, dtype=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -108,7 +108,7 @@ def standard_normal(shape, dtype=None, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/search.py b/ivy/functional/frontends/paddle/search.py index 490fb5f4a46c0..c26923d08ae2e 100644 --- a/ivy/functional/frontends/paddle/search.py +++ b/ivy/functional/frontends/paddle/search.py @@ -7,7 +7,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {"2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -16,7 +16,7 @@ def argmax(x, /, *, axis=None, keepdim=False, dtype="int64", name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {"2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -34,7 +34,7 @@ def argsort(x, /, *, axis=-1, descending=False, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, + {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -44,7 +44,7 @@ def index_sample(x, index): # kthvalue @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def kthvalue(x, k, axis=None, keepdim=False, name=None): @@ -65,7 +65,7 @@ def kthvalue(x, k, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -86,7 +86,7 @@ def nonzero(input, /, *, as_tuple=False): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -102,7 +102,7 @@ def searchsorted(sorted_sequence, values, out_int32=False, right=False, name=Non @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -111,7 +111,7 @@ def sort(x, /, *, axis=-1, descending=False, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -121,7 +121,7 @@ def topk(x, k, axis=None, largest=True, sorted=True, name=None): # where @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/stat.py b/ivy/functional/frontends/paddle/stat.py index 345d5f4c1cbd9..1ee6edd5ce54d 100644 --- a/ivy/functional/frontends/paddle/stat.py +++ b/ivy/functional/frontends/paddle/stat.py @@ -6,7 +6,7 @@ ) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def mean(input, axis=None, keepdim=False, out=None): ret = ivy.mean(input, axis=axis, keepdims=keepdim, out=out) @@ -14,7 +14,7 @@ def mean(input, axis=None, keepdim=False, out=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -37,7 +37,7 @@ def nanmedian(x, axis=None, keepdim=True, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -51,7 +51,7 @@ def numel(x, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "uint16")}, + {"2.5.2 and below": ("float32", "float64", "uint16")}, "paddle", ) @to_ivy_arrays_and_back @@ -64,7 +64,7 @@ def std(x, axis=None, unbiased=True, keepdim=False, name=None): return ivy.std(x, axis=axis, correction=int(unbiased), keepdims=keepdim) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def var(x, axis=None, unbiased=True, keepdim=False, name=None): if unbiased: diff --git a/ivy/functional/frontends/paddle/tensor/manipulation.py b/ivy/functional/frontends/paddle/tensor/manipulation.py index 4d21d3395a93a..5300c5ba213d9 100644 --- a/ivy/functional/frontends/paddle/tensor/manipulation.py +++ b/ivy/functional/frontends/paddle/tensor/manipulation.py @@ -12,7 +12,7 @@ @with_unsupported_dtypes( - {" 2.5.2 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, + {"2.5.2 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/tensor/math.py b/ivy/functional/frontends/paddle/tensor/math.py index 01aeb9b37d8b1..ceb36b11d7310 100644 --- a/ivy/functional/frontends/paddle/tensor/math.py +++ b/ivy/functional/frontends/paddle/tensor/math.py @@ -9,14 +9,14 @@ # Please add non-inplace counterparts to `/frontends/paddle/math.py`. -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def ceil_(x, name=None): return ivy.ceil(x, out=x) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def clip_(x, min=None, max=None, name=None): @@ -38,54 +38,54 @@ def clip_(x, min=None, max=None, name=None): return res -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def exp_(x, name=None): return ivy.inplace_update(x, exp(x)) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def floor_(x, name=None): return ivy.inplace_update(x, floor(x)) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lerp_(x, y, weight, name=None): return ivy.inplace_update(x, lerp(x, y, weight)) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def reciprocal_(x, name=None): return ivy.inplace_update(x, reciprocal(x)) -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def round_(x, name=None): return ivy.inplace_update(x, round(x)) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def rsqrt_(x, name=None): return ivy.inplace_update(x, reciprocal(sqrt(x))) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sqrt_(x, name=None): return ivy.inplace_update(x, sqrt(x)) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def subtract_(x, y, name=None): return ivy.inplace_update(x, subtract(x, y)) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanh_(x, name=None): return ivy.inplace_update(x, tanh(x)) diff --git a/ivy/functional/frontends/paddle/tensor/random.py b/ivy/functional/frontends/paddle/tensor/random.py index 259d247f5c448..dd6be26c2f4f2 100644 --- a/ivy/functional/frontends/paddle/tensor/random.py +++ b/ivy/functional/frontends/paddle/tensor/random.py @@ -12,7 +12,7 @@ @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -21,7 +21,7 @@ def exponential_(x, lam=1.0, name=None): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64")}, + {"2.5.2 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 29a490875436a..870269f06a9f3 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -62,7 +62,7 @@ def ivy_array(self, array): # -------------------# @with_unsupported_dtypes( - {" 2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __add__(self, y, /, name=None): @@ -103,47 +103,47 @@ def reshape(self, *args, shape=None): def dim(self): return self.ivy_array.ndim - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def abs(self): return paddle_frontend.abs(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def acosh(self, name=None): return paddle_frontend.acosh(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def add_n(self, inputs, name=None): inputs = ivy.array(inputs) return ivy.sum(inputs, dtype=inputs.dtype, axis=0) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def ceil(self): return paddle_frontend.ceil(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def ceil_(self): self.ivy_array = self.ceil().ivy_array return self - @with_unsupported_dtypes({" 2.5.2 and below": ("complex", "int8")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("complex", "int8")}, "paddle") def numel(self): return paddle_frontend.numel(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16",)}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16",)}, "paddle") def asinh(self, name=None): return paddle_frontend.asinh(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def asin(self, name=None): return paddle_frontend.asin(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def cosh(self, name=None): return paddle_frontend.cosh(self) @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "int32", "int64", "float64", @@ -158,101 +158,101 @@ def cosh(self, name=None): def diagonal(self, offset, axis1=0, axis2=1, name=None): return paddle_frontend.diagonal(self, offset=offset, axis1=axis1, axis2=axis2) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def log(self, name=None): return paddle_frontend.log(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def sin(self, name=None): return paddle_frontend.sin(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def sinh(self, name=None): return paddle_frontend.sinh(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def lerp(self, y, weight, name=None): return paddle_frontend.lerp(self, y, weight) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def lerp_(self, y, weight, name=None): self.ivy_array = paddle_frontend.lerp(self, y, weight).ivy_array return self - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def argmax(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.argmax(self, axis=axis, keepdim=keepdim, dtype=dtype) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "uint16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "uint16")}, "paddle") def unsqueeze(self, axis=None, name=None): return paddle_frontend.Tensor(ivy.expand_dims(self._ivy_array, axis=axis)) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def sqrt(self, name=None): return paddle_frontend.sqrt(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def sqrt_(self, name=None): self.ivy_array = self.sqrt().ivy_array return self - @with_unsupported_dtypes({" 2.5.2 and below": ("bfloat16", "uint16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("bfloat16", "uint16")}, "paddle") def zero_(self): self.ivy_array = paddle_frontend.zeros_like(self).ivy_array return self - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def cos(self, name=None): return paddle_frontend.cos(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def exp(self, name=None): return paddle_frontend.exp(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def exp_(self, name=None): self.ivy_array = self.exp().ivy_array return self - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def erf(self, name=None): return paddle_frontend.erf(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def subtract(self, y, name=None): return paddle_frontend.subtract(self, y) @with_unsupported_dtypes( - {" 2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" + {"2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" ) def subtract_(self, y, name=None): self.ivy_array = self.subtract(y).ivy_array return self - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def log10(self, name=None): return paddle_frontend.Tensor(ivy.log10(self._ivy_array)) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def argsort(self, axis=-1, descending=False, name=None): return paddle_frontend.argsort(self, axis=axis, descending=descending) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def floor(self, name=None): return paddle_frontend.floor(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def floor_(self): self.ivy_array = self.floor().ivy_array return self - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def round_(self, name=None): self.ivy_array = paddle_frontend.round(self).ivy_array return self @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def clip(self, min=None, max=None, name=None): ivy.utils.assertions.check_all_or_any_fn( @@ -272,63 +272,63 @@ def clip(self, min=None, max=None, name=None): return paddle_frontend.Tensor(ret) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def clip_(self, min=None, max=None, name=None): self._ivy_array = self.clip(min, max).ivy_array return self - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def tanh(self, name=None): return paddle_frontend.tanh(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def add_(self, y, name=None): self.ivy_array = paddle_frontend.add(self, y).ivy_array return self - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def addmm(self, x, y, beta=1.0, alpha=1.0, name=None): return paddle_frontend.addmm(self, x, y, beta, alpha) @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isinf(self, name=None): return paddle_frontend.isinf(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "uint16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "uint16")}, "paddle") def unsqueeze_(self, axis=None, name=None): self.ivy_array = self.unsqueeze(axis=axis).ivy_array return self - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def square(self, name=None): return paddle_frontend.square(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def remainder_(self, y, name=None): self.ivy_array = paddle_frontend.remainder(self, y).ivy_array return self - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def cholesky(self, upper=False, name=None): return paddle_frontend.cholesky(self, upper=upper) @with_unsupported_dtypes( - {" 2.5.2 and below": ("float16", "uint16", "int16")}, "paddle" + {"2.5.2 and below": ("float16", "uint16", "int16")}, "paddle" ) def squeeze_(self, axis=None, name=None): self.ivy_array = paddle_frontend.squeeze(self, axis=axis).ivy_array return self - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def multiply(self, y, name=None): return paddle_frontend.multiply(self, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isfinite(self, name=None): @@ -340,17 +340,17 @@ def all(self, axis=None, keepdim=False, dtype=None, name=None): ivy.all(self.ivy_array, axis=axis, keepdims=keepdim, dtype=dtype) ) - @with_supported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def allclose(self, other, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): return paddle_frontend.allclose( self, other, rtol=rtol, atol=atol, equal_nan=equal_nan ) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def sort(self, axis=-1, descending=False, name=None): return paddle_frontend.sort(self, axis=axis, descending=descending) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def log1p(self, name=None): return paddle_frontend.log1p(self) @@ -372,7 +372,7 @@ def bitwise_and(self, y, out=None, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -388,22 +388,22 @@ def logical_or(self, y, out=None, name=None): return paddle_frontend.logical_or(self, y, out=out) @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, + {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, "paddle", ) def bitwise_xor(self, y, out=None, name=None): return paddle_frontend.bitwise_xor(self, y) - @with_supported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def any(self, axis=None, keepdim=False, name=None): return paddle_frontend.any(self, axis=axis, keepdim=keepdim) - @with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") def astype(self, dtype): return paddle_frontend.Tensor(ivy.astype(self._ivy_array, dtype)) @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, + {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, "paddle", ) def bitwise_not(self, out=None, name=None): @@ -411,7 +411,7 @@ def bitwise_not(self, out=None, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -426,7 +426,7 @@ def bitwise_or(self, y, out=None, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -442,7 +442,7 @@ def logical_xor(self, y, out=None, name=None): return paddle_frontend.logical_xor(self, y, out=out) @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isnan(self, name=None): @@ -450,7 +450,7 @@ def isnan(self, name=None): @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "uint8", "int8", @@ -464,22 +464,22 @@ def isnan(self, name=None): def greater_than(self, y, name=None): return paddle_frontend.greater_than(self, y) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def rsqrt(self, name=None): return paddle_frontend.rsqrt(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def rsqrt_(self, name=None): self.ivy_array = self.rsqrt().ivy_array return self - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def reciprocal(self, name=None): return paddle_frontend.reciprocal(self) @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -494,12 +494,12 @@ def reciprocal(self, name=None): def logical_and(self, y, out=None, name=None): return paddle_frontend.logical_and(self, y, out=out) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def divide(self, y, name=None): return paddle_frontend.divide(self, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "complex64", "complex128")}, + {"2.5.2 and below": ("float32", "float64", "complex64", "complex128")}, "paddle", ) def eigvals(self, name=None): @@ -507,7 +507,7 @@ def eigvals(self, name=None): @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "uint8", "int8", @@ -521,18 +521,18 @@ def eigvals(self, name=None): def less_than(self, y, name=None): return paddle_frontend.less_than(self, y) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def cumprod(self, dim=None, dtype=None, name=None): return paddle_frontend.cumprod(self, dim=dim, dtype=dtype) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def cumsum(self, axis=None, dtype=None, name=None): return paddle_frontend.Tensor( ivy.cumsum(self._ivy_array, axis=axis, dtype=dtype) ) @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128", "float32", "float64")}, + {"2.5.2 and below": ("complex64", "complex128", "float32", "float64")}, "paddle", ) def angle(self, name=None): @@ -540,7 +540,7 @@ def angle(self, name=None): @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "uint8", "int8", "int16", @@ -553,13 +553,13 @@ def angle(self, name=None): def equal(self, y, name=None): return paddle_frontend.equal(self, y) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def rad2deg(self, name=None): return paddle_frontend.rad2deg(self) @with_unsupported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "uint8", "int8", "int16", @@ -573,46 +573,46 @@ def rad2deg(self, name=None): def equal_all(self, y, name=None): return paddle_frontend.equal_all(self, y) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def maximum(self, other, name=None): return paddle_frontend.maximum(self, other) - @with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") def fmax(self, y, name=None): return paddle_frontend.fmax(self, y) - @with_unsupported_dtypes({" 2.5.2 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") def fmin(self, y, name=None): return paddle_frontend.fmin(self, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def minimum(self, y, name=None): return paddle_frontend.minimum(self, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def max(self, axis=None, keepdim=False, name=None): return paddle_frontend.max(self, axis=axis, keepdim=keepdim) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def deg2rad(self, name=None): return paddle_frontend.deg2rad(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def digamma(self, name=None): return paddle_frontend.digamma(self) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64", "bool")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64", "bool")}, "paddle" ) def rot90(self, k=1, axes=(0, 1), name=None): return paddle_frontend.rot90(self, k=k, axes=axes) @with_supported_dtypes( - {" 2.5.2 and below": ("complex64", "complex128")}, + {"2.5.2 and below": ("complex64", "complex128")}, "paddle", ) def imag(self, name=None): @@ -623,7 +623,7 @@ def is_tensor(self): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "float32", "float64", ) @@ -635,16 +635,16 @@ def isclose(self, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): self, y, rtol=rtol, atol=atol, equal_nan=equal_nan ) - @with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") def floor_divide(self, y, name=None): return paddle_frontend.floor_divide(self, y) - @with_supported_dtypes({" 2.5.2 and below": ("int32", "int64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") def mod(self, y, name=None): return paddle_frontend.Tensor(ivy.fmod(self._ivy_array, _to_ivy_array(y))) # cond - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def cond(self, p=None, name=None): return paddle_frontend.cond(self, p=p, name=name) @@ -652,7 +652,7 @@ def cond(self, p=None, name=None): def conj(self, name=None): return paddle_frontend.conj(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def log2(self, name=None): return paddle_frontend.log2(self) @@ -664,7 +664,7 @@ def neg(self, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int8", "int16", @@ -679,15 +679,15 @@ def neg(self, name=None): def logical_not(self, out=None, name=None): return paddle_frontend.logical_not(self) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def sign(self, name=None): return paddle_frontend.sign(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def var(self, axis=None, unbiased=True, keepdim=False, name=None): return paddle_frontend.var(self, axis=axis, unbiased=unbiased, keepdim=keepdim) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def sgn(self, name=None): return paddle_frontend.sgn(self) @@ -695,45 +695,45 @@ def tolist(self): return paddle_frontend.Tensor(ivy.to_list(self._ivy_array)) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) def min(self, axis=None, keepdim=False, name=None): return paddle_frontend.min(self, axis=axis, keepdim=keepdim) @with_supported_dtypes( - {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def pow(self, y, name=None): return paddle_frontend.pow(self, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def prod(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.Tensor( ivy.prod(self._ivy_array, axis=axis, keepdims=keepdim, dtype=dtype) ) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def atan(self, name=None): return paddle_frontend.atan(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def atanh(self, name=None): return paddle_frontend.atanh(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def std(self, axis=None, unbiased=True, keepdim=False, name=None): return paddle_frontend.std(self, axis=axis, unbiased=unbiased, keepdim=keepdim) @with_supported_dtypes( - {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def trunc(self, name=None): return paddle_frontend.trunc(self) - @with_supported_dtypes({" 2.5.2 and below": ("complex64", "complex128")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("complex64", "complex128")}, "paddle") def as_real(self, name=None): if not ivy.is_complex_dtype(self._ivy_array): raise ivy.exceptions.IvyError( @@ -743,12 +743,12 @@ def as_real(self, name=None): im_part = ivy.imag(self._ivy_array) return paddle_frontend.Tensor(ivy.stack((re_part, im_part), axis=-1)) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def stanh(self, scale_a=0.67, scale_b=1.7159, name=None): return paddle_frontend.stanh(self, scale_a=scale_a, scale_b=scale_b) @with_supported_dtypes( - {" 2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def trace(self, offset=0, axis1=0, axis2=1, name=None): return paddle_frontend.Tensor( @@ -757,7 +757,7 @@ def trace(self, offset=0, axis1=0, axis2=1, name=None): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "float32", "float64", "int16", @@ -772,48 +772,48 @@ def argmin(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.argmin(self, axis=axis, keepdim=keepdim, dtype=dtype) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) def topk(self, k, axis=None, largest=True, sorted=True, name=None): return paddle_frontend.topk(self, k, axis=axis, largest=largest, sorted=sorted) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def remainder(self, y, name=None): return paddle_frontend.remainder(self, y) def is_floating_point(self): return paddle_frontend.is_floating_point(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def tanh_(self, name=None): y = self.tanh(self) return ivy.inplace_update(self, y) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def reciprocal_(self, name=None): y = self.reciprocal(self) return ivy.inplace_update(self, y) @with_unsupported_dtypes( - {" 2.5.2 and below": ("complex", "uint8", "uint16")}, "paddle" + {"2.5.2 and below": ("complex", "uint8", "uint16")}, "paddle" ) def numpy(self): return self.ivy_array.to_numpy() - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def nonzero(self): return paddle_frontend.nonzero(self) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def inner(self, y, name=None): return paddle_frontend.inner(self, y, name) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def mean(self, axis=None, keepdim=False, name=None): return paddle_frontend.mean(self, axis=axis, keepdim=keepdim) - @with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def as_complex(self, name=None): if self.ivy_array.shape[-1] != 2: raise ivy.exceptions.IvyError( @@ -828,29 +828,29 @@ def as_complex(self, name=None): return value @with_supported_dtypes( - {" 2.5.2 and below": ("int32", "int64", "float32", "float64", "bool")}, "paddle" + {"2.5.2 and below": ("int32", "int64", "float32", "float64", "bool")}, "paddle" ) def not_equal(self, y, name=None): return paddle_frontend.not_equal(self._ivy_array, y) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def less_equal(self, y, name=None): return paddle_frontend.less_equal(self._ivy_array, y) - @with_supported_dtypes({" 2.5.2 and below": ("complex64", "complex128")}, "paddle") + @with_supported_dtypes({"2.5.2 and below": ("complex64", "complex128")}, "paddle") def real(self, name=None): return paddle_frontend.real(self._ivy_array) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def t(self, name=None): axes = list(range(len(self.ivy_array.shape)))[::-1] return ivy.permute_dims(self.ivy_array, axes=axes) @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "float16", "float32", @@ -865,12 +865,12 @@ def t(self, name=None): def cast(self, dtype): return paddle_frontend.cast(self, dtype) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def bmm(self, y, transpose_x=False, transpose_y=False, name=None): return paddle_frontend.bmm(self, y, transpose_x, transpose_y) @with_supported_dtypes( - {" 2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def fill_(self, value): @@ -879,7 +879,7 @@ def fill_(self, value): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int32", "int64", @@ -895,7 +895,7 @@ def unbind(self, axis=0): @with_supported_dtypes( { - " 2.5.2 and below": ( + "2.5.2 and below": ( "bool", "int32", "int64", @@ -914,44 +914,44 @@ def cpu(self): return self @with_unsupported_dtypes( - {" 2.5.2 and below": ("int16", "complex64", "complex128")}, + {"2.5.2 and below": ("int16", "complex64", "complex128")}, "paddle", ) def split(self, num_or_sections, axis=0, name=None): return paddle_frontend.split(self._ivy_array, num_or_sections, axis, name) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def frac(self, name=None): return paddle_frontend.frac(self._ivy_array) - @with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def gather(self, y, name=None): return paddle_frontend.gather(self, y) @with_unsupported_dtypes( - {" 2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" + {"2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" ) def gather_(self, y, name=None): res = self.gather(self, y) return ivy.inplace_update(self, res) @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def heaviside(self, y, name=None): return paddle_frontend.heaviside(self, y) @with_supported_dtypes( - {" 2.5.2 and below": ("bool", "int32", "int64", "float32", "float64")}, "paddle" + {"2.5.2 and below": ("bool", "int32", "int64", "float32", "float64")}, "paddle" ) def expand(self, shape, name=None): return paddle_frontend.expand(self._ivy_array, shape) @with_supported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ( "bool", "int32", diff --git a/ivy/functional/frontends/paddle/vision/transforms.py b/ivy/functional/frontends/paddle/vision/transforms.py index 1be9e31ccebac..dac89b602ea19 100644 --- a/ivy/functional/frontends/paddle/vision/transforms.py +++ b/ivy/functional/frontends/paddle/vision/transforms.py @@ -104,7 +104,7 @@ def _rgb_to_hsv(img): # ------------ # -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def adjust_brightness(img, brightness_factor): assert brightness_factor >= 0, "brightness_factor should be non-negative." @@ -117,7 +117,7 @@ def adjust_brightness(img, brightness_factor): return _blend_images(img, extreme_target, brightness_factor) -@with_supported_dtypes({" 2.5.2 and below": ("float32", "float64", "uint8")}, "paddle") +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64", "uint8")}, "paddle") @to_ivy_arrays_and_back def adjust_hue(img, hue_factor): assert -0.5 <= hue_factor <= 0.5, "hue_factor should be in range [-0.5, 0.5]" @@ -145,7 +145,7 @@ def adjust_hue(img, hue_factor): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def hflip(img): @@ -154,7 +154,7 @@ def hflip(img): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def normalize(img, mean, std, data_format="CHW", to_rgb=False): if ivy.is_array(img): @@ -171,7 +171,7 @@ def normalize(img, mean, std, data_format="CHW", to_rgb=False): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def pad(img, padding, fill=0, padding_mode="constant"): @@ -201,7 +201,7 @@ def pad(img, padding, fill=0, padding_mode="constant"): @with_supported_dtypes( - {" 2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def to_tensor(pic, data_format="CHW"): @@ -211,7 +211,7 @@ def to_tensor(pic, data_format="CHW"): @with_unsupported_device_and_dtypes( { - " 2.5.2 and below": { + "2.5.2 and below": { "cpu": ("int8", "uint8", "int16", "float16", "bfloat16", "bool") } }, diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index bed1f35cd46bc..9dd3a44045d53 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -454,7 +454,7 @@ def minimum(x, y, name=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({" 2.5.2 and below": ("bfloat16",)}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("bfloat16",)}, "paddle") def mod(x, y, name=None): x, y = check_tensorflow_casting(x, y) return ivy.remainder(x, y) diff --git a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py index c47ce815c1472..5faa28c1e4a7c 100644 --- a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py @@ -8,7 +8,7 @@ # ToDo: this function will be simplified once ivy.alpha_dropout is implemented @to_ivy_arrays_and_back @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") -@with_unsupported_dtypes({" 2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def alpha_dropout(input, p=0.5, training=False, inplace=False): if p == 0.0 or not training or input.shape == () or input.shape == (0,): return input From 63a2fc6dcdb6897e0f79755537d699f71a677d87 Mon Sep 17 00:00:00 2001 From: yopknopixx <30761130+yopknopixx@users.noreply.github.com> Date: Mon, 30 Oct 2023 14:51:22 +0530 Subject: [PATCH 081/978] fix(torch-frontend): fix failing test for torch.Tensor.reshape_as with the paddle backend (#27116) --- ivy/functional/frontends/torch/tensor.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index c48e8af04489b..623e7b7269632 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -142,6 +142,7 @@ def reshape(self, *args, shape=None): return torch_frontend.reshape(self) @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.5.1 and below": ("float16",)}, "paddle") def reshape_as(self, other): return torch_frontend.reshape(self, other.shape) From 22aaf1d147d3c49f510f2afd3f5757fac1a7545b Mon Sep 17 00:00:00 2001 From: zerodoxxx <91450747+zerodoxxx@users.noreply.github.com> Date: Mon, 30 Oct 2023 15:28:33 +0530 Subject: [PATCH 082/978] feat: add bartlett manipulation to JAX frontend (#26874) --- .../frontends/jax/numpy/manipulations.py | 15 ++++++++++++ .../test_jax/test_numpy/test_manipulations.py | 24 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/ivy/functional/frontends/jax/numpy/manipulations.py b/ivy/functional/frontends/jax/numpy/manipulations.py index 374ceaa04ce82..f3f3c1721c546 100644 --- a/ivy/functional/frontends/jax/numpy/manipulations.py +++ b/ivy/functional/frontends/jax/numpy/manipulations.py @@ -37,6 +37,21 @@ def atleast_3d(*arys): return ivy.atleast_3d(*arys) +@to_ivy_arrays_and_back +def bartlett(M): + if M < 1: + return ivy.array([]) + if M == 1: + return ivy.ones(M, dtype=ivy.float64) + res = ivy.arange(0, M) + res = ivy.where( + ivy.less_equal(res, (M - 1) / 2.0), + 2.0 * res / (M - 1), + 2.0 - 2.0 * res / (M - 1), + ) + return res + + @to_ivy_arrays_and_back def blackman(M): if M < 1: diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py index 0595ae1968a5e..2d9d150748115 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py @@ -498,6 +498,30 @@ def test_jax_atleast_3d( ) +# bartlett +@handle_frontend_test( + fn_tree="jax.numpy.bartlett", + m=helpers.ints(min_value=0, max_value=20), +) +def test_jax_bartlett( + m, + frontend, + backend_fw, + test_flags, + fn_tree, + on_device, +): + helpers.test_frontend_function( + input_dtypes=["int64"], + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + M=m, + ) + + # blackman @handle_frontend_test( fn_tree="jax.numpy.blackman", From 3add98d4fad7cdfa89b9a0c003e60642fb1fe815 Mon Sep 17 00:00:00 2001 From: Shivam Singh <103785990+Shivam250702@users.noreply.github.com> Date: Mon, 30 Oct 2023 17:09:23 +0530 Subject: [PATCH 083/978] docs: fix typo in README.md (#27179) --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 9164b0f96d5f0..bad25c53f71eb 100644 --- a/README.md +++ b/README.md @@ -237,7 +237,7 @@ After installing Ivy, you can start using it straight away, for example: # Documentation -You can find Ivy's documentation in the [Docs page](https://unify.ai/docs/ivy/), which includes: +You can find Ivy's documentation on the [Docs page](https://unify.ai/docs/ivy/), which includes: - [Motivation](https://unify.ai/docs/ivy/overview/background.html): This contextualizes the problem Ivy is trying to solve by going over - The current [ML Explosion](https://unify.ai/docs/ivy/overview/background/ml_explosion.html#ml-explosion). - Explaining why it is important [to solve this problem](https://unify.ai/docs/ivy/overview/background/why_unify.html#why-unify). @@ -1337,7 +1337,7 @@ train(images, classes, num_epochs, model, device, num_classes = num_classes, bat # Diving deeper -Although the [Docs](https://unify.ai/docs/ivy/) are the best place to learn more, in the next section we will take a look at how Ivy works as both a transpiler and a framework in a bit more of detail to get an idea of why and where to use it. +Although the [Docs](https://unify.ai/docs/ivy/) are the best place to learn more, in the next section we will take a look at how Ivy works as both a transpiler and a framework in a bit more detail to get an idea of why and where to use it.
Ivy as a transpiler @@ -1591,7 +1591,7 @@ our journey to unify all ML frameworks! In order to achieve the ambitious goal of unifying AI we definitely need as many hands as possible on it! Whether you are a seasoned developer or -just starting out, you\'ll find a place here! Join the Ivy community in +just starting out, you\'ll find a place here! Join the Ivy community on our [Discord](https://discord.gg/sXyFF8tDtm) 👾 server, which is the perfect place to ask questions, share ideas, and get help from both fellow developers and the Ivy Team directly! From a8ba293f2c78b0a9cc2418812fdc0f2625026c74 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Mon, 30 Oct 2023 13:40:30 +0000 Subject: [PATCH 084/978] feat: Add TensorShape class to the TensorFlow frontend (#27113) --- ivy/functional/frontends/tensorflow/tensor.py | 110 +++++++++++++++++- .../test_tensorflow/test_tensorshape.py | 80 +++++++++++++ 2 files changed, 189 insertions(+), 1 deletion(-) create mode 100644 ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensorshape.py diff --git a/ivy/functional/frontends/tensorflow/tensor.py b/ivy/functional/frontends/tensorflow/tensor.py index a34096cbbd050..517d842fbe2f5 100644 --- a/ivy/functional/frontends/tensorflow/tensor.py +++ b/ivy/functional/frontends/tensorflow/tensor.py @@ -45,7 +45,7 @@ def dtype(self): @property def shape(self): - return tuple(self.ivy_array.shape.shape) + return TensorShape(self.ivy_array.shape.shape) # Instance Methods # # ---------------- # @@ -228,6 +228,114 @@ def __iter__(self): yield self[i] +class TensorShape: + # TODO: there are still some methods that may need implementing + + def __init__(self, dims): + self._dims = tuple(dims) + + def __repr__(self): + if self._dims is not None: + return f"TensorShape({list(self._dims)})" + else: + return "TensorShape(None)" + + def __str__(self): + if self.rank is None: + return "" + elif self.rank == 1: + return "(%s,)" % self._dims[0] + else: + return "(%s)" % ", ".join(str(d) for d in self._dims) + + # Properties # + # ---------- # + + @property + def dims(self): + return self._dims + + @property + def ivy_shape(self): + return ivy.Shape(self._dims) + + @property + def ndims(self): + return self.__len__() + + @property + def rank(self): + return self.__len__() + + # Instance Methods # + # ---------------- # + + def __add__(self, other): + return self.concatenate(other) + + def __bool__(self): + return self._dims is not None + + def __concat__(self, other): + return self.concatenate(other) + + def __eq__(self, other): + return self._dims == other.dims + + def __getitem__(self, key): + if isinstance(key, slice): + return TensorShape(self._dims[key]) + else: + return self._dims[key] + + def __iter__(self): + return iter(d for d in self._dims) + + def __len__(self): + return len(self._dims) + + def __nonzero__(self): + return self.__bool__() + + def __radd__(self, other): + return other.concatenate(self) + + def as_list(self): + return list(self._dims) + + def concatenate(self, other): + other = as_shape(other) + if self.dims is None or other.dims is None: + return unknown_shape() + else: + return TensorShape(self.dims + other.dims) + + def num_elements(self): + return ivy.to_scalar(ivy.prod(self._dims)) + + # Dummy Tensor class to help with compilation, don't add methods here class Tensor(EagerTensor): pass + + +# Helpers + + +def as_shape(shape): + """Converts the given object to a TensorShape.""" + if isinstance(shape, TensorShape): + return shape + else: + return TensorShape(shape) + + +def unknown_shape(rank=None, **kwargs): + if rank is None and "ndims" in kwargs: + rank = kwargs.pop("ndims") + if kwargs: + raise TypeError("Unknown argument: %s" % kwargs) + if rank is None: + return TensorShape(None) + else: + return TensorShape([None] * rank) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensorshape.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensorshape.py new file mode 100644 index 0000000000000..044f5601897e6 --- /dev/null +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensorshape.py @@ -0,0 +1,80 @@ +# global +from hypothesis import strategies as st + +# local +import ivy +import ivy_tests.test_ivy.helpers as helpers +from ivy_tests.test_ivy.helpers import handle_frontend_method +import pytest + +CLASS_TREE = "ivy.functional.frontends.tensorflow.tensor.TensorShape" + + +# __add__ +@pytest.mark.skip("TODO: test needs implementing correctly") +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="tensorflow.TensorShape", + method_name="__add__", + shape_list=helpers.list_of_size(x=st.sampled_from([0, 1, 2, 3, 4]), size=3), + other_list=helpers.list_of_size(x=st.sampled_from([0, 1, 2, 3, 4]), size=3), +) +def test_tensorflow__add__( + shape_list, + other_list, + frontend, + frontend_method_data, + init_flags, + method_flags, + on_device, + backend_fw, +): + helpers.test_frontend_method( + init_input_dtypes=[ivy.int64], + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "dims": shape_list, + }, + method_input_dtypes=[ivy.int64], + method_all_as_kwargs_np={ + "other": other_list, + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + +# __bool__ +@pytest.mark.skip("TODO: test needs implementing correctly") +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="tensorflow.TensorShape", + method_name="__bool__", + shape_list=helpers.list_of_size(x=st.sampled_from([0, 1, 2, 3, 4]), size=3), +) +def test_tensorflow__bool__( + shape_list, + frontend, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + on_device, +): + helpers.test_frontend_method( + init_input_dtypes=[ivy.int64], + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "dims": shape_list, + }, + method_input_dtypes=[ivy.int64], + method_all_as_kwargs_np={}, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) From a0384e51b9ebf40252fdae53711ccb3559937535 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 30 Oct 2023 20:43:34 +0530 Subject: [PATCH 085/978] fix: Fixed passing `positional` arguments in few functions (#27082) --- ivy/data_classes/array/experimental/manipulation.py | 2 +- ivy/functional/frontends/paddle/nn/functional/pooling.py | 9 ++++++++- .../frontends/sklearn/model_selection/_split.py | 4 ++-- ivy/functional/frontends/torch/tensor.py | 2 +- ivy/functional/frontends/xgboost/sklearn.py | 2 +- 5 files changed, 13 insertions(+), 6 deletions(-) diff --git a/ivy/data_classes/array/experimental/manipulation.py b/ivy/data_classes/array/experimental/manipulation.py index f63c94adc5c1c..017df89bd4b6b 100644 --- a/ivy/data_classes/array/experimental/manipulation.py +++ b/ivy/data_classes/array/experimental/manipulation.py @@ -1197,7 +1197,7 @@ def trim_zeros( >>> ivy.trim_zeros([0, 8, 3, 0, 0]) [8, 3] """ - return ivy.trim_zeros(self, trim) + return ivy.trim_zeros(self, trim=trim) def unfold( self: Union[ivy.Array, ivy.NativeArray], diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index de81646e8c4da..46af2f9787402 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -112,4 +112,11 @@ def max_unpool1d( output_size=None, name=None, ): - return ivy.max_unpool1d(x, indices, kernel_size, stride, padding, data_format) + return ivy.max_unpool1d( + x, + indices, + kernel_size, + strides=stride, + padding=padding, + data_format=data_format, + ) diff --git a/ivy/functional/frontends/sklearn/model_selection/_split.py b/ivy/functional/frontends/sklearn/model_selection/_split.py index 25b51c3451fe6..58f68bcc63bf6 100644 --- a/ivy/functional/frontends/sklearn/model_selection/_split.py +++ b/ivy/functional/frontends/sklearn/model_selection/_split.py @@ -74,7 +74,7 @@ def __init__( ) def _iter_test_indices(self, X=None, y=None, groups=None): - ivy.seed(self.random_state) + ivy.seed(seed_value=self.random_state) y = ivy.array(y) y = column_or_1d(y) _, y_idx, y_inv, _ = ivy.unique_all(y, return_index=True, return_inverse=True) @@ -139,7 +139,7 @@ def train_test_split( indices = ivy.arange(0, n_train + n_test) if shuffle: if random_state is not None: - ivy.seed(random_state) + ivy.seed(seed_value=random_state) indices = ivy.shuffle(indices) train_indices = indices[:n_train] test_indices = indices[n_train:] diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 623e7b7269632..fd4d15663ea81 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -888,7 +888,7 @@ def cumsum(self, dim, *, dtype=None): @numpy_to_torch_style_args @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") def cumsum_(self, dim, *, dtype=None): - self.ivy_array = self.cumsum(dim, dtype).ivy_array + self.ivy_array = self.cumsum(dim, dtype=dtype).ivy_array return self @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") diff --git a/ivy/functional/frontends/xgboost/sklearn.py b/ivy/functional/frontends/xgboost/sklearn.py index 5e9fc2f187e35..e2edeecb81802 100644 --- a/ivy/functional/frontends/xgboost/sklearn.py +++ b/ivy/functional/frontends/xgboost/sklearn.py @@ -119,7 +119,7 @@ def get_params(self, deep=True): # take random_state into account only if it's an integer if isinstance(params["random_state"], int): - ivy.seed(params["random_state"]) + ivy.seed(seed_value=params["random_state"]) return params From 4ae7574718f7e384ba0263831918089e0c540153 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Mon, 30 Oct 2023 17:57:50 +0000 Subject: [PATCH 086/978] =?UTF-8?q?fix:=20ensure=20jax=20device=20checking?= =?UTF-8?q?=20doesn't=20cause=20abstract=20tracer=20values=20=E2=80=A6=20(?= =?UTF-8?q?#27172)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Mahmoud Ashraf --- ivy/functional/backends/jax/creation.py | 3 ++- ivy/functional/backends/jax/device.py | 11 ++++------- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/ivy/functional/backends/jax/creation.py b/ivy/functional/backends/jax/creation.py index ee7cba4e854e0..17ade3b74b32e 100644 --- a/ivy/functional/backends/jax/creation.py +++ b/ivy/functional/backends/jax/creation.py @@ -12,6 +12,7 @@ import ivy from ivy import as_native_dtype from ivy.functional.backends.jax import JaxArray +from ivy.functional.backends.jax.device import dev from ivy.functional.ivy.creation import ( _asarray_to_native_arrays_and_back, _asarray_infer_device, @@ -79,7 +80,7 @@ def asarray( # jax device objects aren't serializable and prevent saving transpiled graphs # this workaround only works because we are inside jax.default_device context # invoked in @handle_device decorator - return jnp.copy(ret) if (ret.device() != device or copy) else ret + return jnp.copy(ret) if (dev(ret, as_native=True) != device or copy) else ret def empty( diff --git a/ivy/functional/backends/jax/device.py b/ivy/functional/backends/jax/device.py index 7cd30e045142e..e12164e617440 100644 --- a/ivy/functional/backends/jax/device.py +++ b/ivy/functional/backends/jax/device.py @@ -41,14 +41,11 @@ def dev( ) -> Union[ivy.Device, jaxlib.xla_extension.Device]: if isinstance(x, jax.interpreters.partial_eval.DynamicJaxprTracer): return "" - try: - dv = _to_array(x).device_buffer.device - dv = dv() - except Exception: + if hasattr(x, "device_buffer"): + dv = _to_array(x).device_buffer.device() + else: dv = jax.devices()[0] - if as_native: - return dv - return as_ivy_dev(dv) + return dv if as_native else as_ivy_dev(dv) def to_device( From 9d6dcbd0dabce5371f1973823c5291ab7002bbdb Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Mon, 30 Oct 2023 19:17:10 +0000 Subject: [PATCH 087/978] fix: Updates ivy.interpolate to support recompute_scale_factor and align_corners in all modes + fixes some scaling bugs --- .../backends/jax/experimental/layers.py | 22 +-- .../backends/mxnet/experimental/layers.py | 18 +- .../backends/paddle/experimental/layers.py | 2 +- .../tensorflow/experimental/layers.py | 22 +-- .../backends/torch/experimental/layers.py | 26 ++- .../torch/nn/functional/vision_functions.py | 10 +- ivy/functional/ivy/experimental/layers.py | 172 +++++++----------- .../test_functional/test_vision_functions.py | 2 + .../test_experimental/test_nn/test_layers.py | 13 +- 9 files changed, 107 insertions(+), 180 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index d884808610dd6..8ff17ef9cb5ee 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -698,13 +698,14 @@ def interpolate( ] = "linear", scale_factor: Optional[Union[Sequence[int], int]] = None, recompute_scale_factor: Optional[bool] = None, - align_corners: Optional[bool] = None, + align_corners: bool = False, antialias: bool = False, out: Optional[JaxArray] = None, ): - dims = len(x.shape) - 2 - size, _ = _get_size(scale_factor, size, dims, x.shape) - if all(a == b for a, b in zip(size, x.shape[2:])): + input_size = ivy.shape(x)[2:] + dims = len(input_size) + size, _ = _get_size(scale_factor, size, dims, input_size) + if all(a == b for a, b in zip(size, input_size)): ret = x else: mode = ( @@ -736,18 +737,7 @@ def interpolate( "bicubic", ] and not align_corners - and ( - recompute_scale_factor - or mode - not in [ - "linear", - "bilinear", - "trilinear", - "tf_bicubic", - "lanczos3", - "lanczos5", - ] - ) + and recompute_scale_factor ) diff --git a/ivy/functional/backends/mxnet/experimental/layers.py b/ivy/functional/backends/mxnet/experimental/layers.py index 1d5cf6924d89d..b77458ec487c1 100644 --- a/ivy/functional/backends/mxnet/experimental/layers.py +++ b/ivy/functional/backends/mxnet/experimental/layers.py @@ -3,7 +3,6 @@ import mxnet as mx # local -from ivy.func_wrapper import handle_partial_mixed_function from ivy.utils.exceptions import IvyNotImplementedException @@ -190,21 +189,6 @@ def ifft( raise IvyNotImplementedException() -@handle_partial_mixed_function( - lambda *args, mode="linear", scale_factor=None, recompute_scale_factor=None, align_corners=None, **kwargs: ( # noqa: E501 - not align_corners - and mode - not in [ - "area", - "nearest", - "tf_area", - "mitchellcubic", - "gaussian", - "bicubic", - ] - and recompute_scale_factor - ) -) def interpolate( x: mx.nd.NDArray, size: Union[Sequence[int], int], @@ -228,7 +212,7 @@ def interpolate( ] = "linear", scale_factor: Optional[Union[Sequence[int], int]] = None, recompute_scale_factor: Optional[bool] = None, - align_corners: Optional[bool] = None, + align_corners: bool = False, antialias: bool = False, out: Optional[mx.nd.NDArray] = None, ): diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index f685b3083303a..58911129ef59d 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -464,7 +464,7 @@ def interpolate( mode: Optional[Literal["linear", "bilinear", "trilinear"]] = "linear", scale_factor: Optional[Union[Sequence[int], int]] = None, recompute_scale_factor: Optional[bool] = None, - align_corners: Optional[bool] = None, + align_corners: bool = False, antialias: Optional[bool] = False, out: Optional[paddle.Tensor] = None, ): diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index c78bb8c20b841..8ffe1f9d56e98 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -889,13 +889,14 @@ def interpolate( ] = "linear", scale_factor: Optional[Union[Sequence[int], int]] = None, recompute_scale_factor: Optional[bool] = None, - align_corners: Optional[bool] = None, + align_corners: bool = False, antialias: bool = False, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ): - dims = len(x.shape) - 2 - size, _ = _get_size(scale_factor, size, dims, x.shape) - if all(a == b for a, b in zip(size, x.shape[2:])): + input_size = ivy.shape(x)[2:] + dims = len(input_size) + size, _ = _get_size(scale_factor, size, dims, input_size) + if all(a == b for a, b in zip(size, input_size)): ret = x else: remove_dim = False @@ -937,18 +938,7 @@ def interpolate( < 4 and mode not in ["nearest", "area", "bicubic", "nd"] and not align_corners - and ( - recompute_scale_factor - or mode - not in [ - "linear", - "bilinear", - "trilinear", - "tf_bicubic", - "lanczos3", - "lanczos5", - ] - ) + and recompute_scale_factor ) diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 78dc7f72461b1..3f277d825e1c7 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -907,10 +907,12 @@ def interpolate( ] = "linear", scale_factor: Optional[Union[Sequence[int], int]] = None, recompute_scale_factor: Optional[bool] = None, - align_corners: Optional[bool] = None, + align_corners: bool = False, antialias: bool = False, out: Optional[torch.Tensor] = None, ): + if mode not in ["linear", "bilinear", "bicubic", "trilinear"]: + align_corners = None return torch.nn.functional.interpolate( x, size=size, @@ -922,15 +924,19 @@ def interpolate( ) -interpolate.partial_mixed_handler = lambda *args, mode="linear", **kwargs: mode not in [ - "tf_area", - "nd", - "tf_bicubic", - "mitchellcubic", - "lanczos3", - "lanczos5", - "gaussian", -] +interpolate.partial_mixed_handler = ( + lambda *args, mode="linear", align_corners=False, **kwargs: mode + not in [ + "tf_area", + "nd", + "tf_bicubic", + "mitchellcubic", + "lanczos3", + "lanczos5", + "gaussian", + ] + and (mode in ["linear", "bilinear", "bicubic", "trilinear"] or not align_corners) +) @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index c12079f5a9dd3..0603d89982c0a 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -366,6 +366,14 @@ def interpolate( recompute_scale_factor=None, antialias=False, ): + if ( + mode not in ["linear", "bilinear", "bicubic", "trilinear"] + and align_corners is not None + ): + raise ivy.utils.exceptions.IvyException( + "align_corners option can only be set with the interpolating" + f"modes: linear | bilinear | bicubic | trilinear (got {mode})" + ) ivy.utils.assertions.check_elem_in_list( ivy.get_num_dims(input), range(3, 6), @@ -381,7 +389,7 @@ def interpolate( mode=mode, scale_factor=scale_factor, recompute_scale_factor=recompute_scale_factor, - align_corners=align_corners, + align_corners=True if align_corners else False, antialias=antialias, ) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index bfb3daa1595aa..19daa2b1affe3 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1409,9 +1409,8 @@ def _tf_area_indices(dim_index, scale): return starting_index, ending_index, rounded_indices -def _tf_area_interpolate(x, size, dims): +def _tf_area_interpolate(x, size, scale, dims): ret = ivy.zeros((x.shape[:2] + size)) - scale = ivy.divide(ivy.shape(x)[2:], size) area = 1.0 / ivy.prod(scale) for i, ba in enumerate(x): for j, ch in enumerate(ba): @@ -1487,12 +1486,11 @@ def _tf_area_interpolate(x, size, dims): return ret -def nearest_interpolate(x, dims, size, input_shape, exact): +def nearest_interpolate(x, dims, size, scale, exact): off = 0.5 if exact else 0 for d in range(dims): - m = input_shape[d + 2] n = size[d] - offsets = (ivy.arange(n, dtype="float32") + off) * m / n + offsets = (ivy.arange(n, dtype="float32") + off) * scale[d] offsets = ivy.astype(ivy.floor(ivy.astype(offsets, "float32")), "int32") x = ivy.gather(x, offsets, axis=d + 2) return x @@ -1514,14 +1512,17 @@ def _lanczos_kernel(radius, x): return ivy.where(ivy.bitwise_and(x >= radius, x < -radius), 0.0, out) -def _dim_scale_factor(input_size, output_size, align_corners, scales): - if align_corners: - dim_scale_factor = (input_size - 1) / (output_size - 1) - else: - dim_scale_factor = ( - 1 / scales if scales is not None else input_size / output_size - ) - return dim_scale_factor +def _get_final_scale(input_size, output_size, align_corners, scale_factor): + scale = [] + for i, (input, output) in enumerate(zip(input_size, output_size)): + if align_corners: + if output > 1: + scale.append((input - 1) / (output - 1)) + else: + scale.append(1) + else: + scale.append(1 / scale_factor[i]) + return scale def _mitchellcubic_kernel(x): @@ -1539,12 +1540,12 @@ def _compute_weight_mat( output_size, align_corners, kernel_fn, - dim_scale_factor, + dim_scale, ): if not align_corners: - sample_f = (ivy.arange(output_size) + 0.5) * dim_scale_factor - 0.5 + sample_f = (ivy.arange(output_size) + 0.5) * dim_scale - 0.5 else: - sample_f = ivy.arange(output_size) * dim_scale_factor + sample_f = ivy.arange(output_size) * dim_scale x = ivy.abs( ivy.expand_dims(sample_f) - ivy.expand_dims(ivy.arange(input_size), axis=-1) ) @@ -1595,39 +1596,31 @@ def _sum_tensors(ts): def _upsample_bicubic2d_default( a, output_size, + scale, align_corners, - scale_h=None, - scale_w=None, ): N, C, iH, iW = a.shape oH, oW = output_size - def compute_scale(in_size, out_size, align_corners, scale=None): - if align_corners: - return (in_size - 1) / (out_size - 1) if out_size > 1 else 0 - else: - return 1 / scale if scale is not None and scale > 0 else in_size / out_size - def compute_source_index(scale, dst_index, align_corners): if align_corners: return scale * dst_index else: return scale * (dst_index + 0.5) - 0.5 - height_scale = compute_scale(iH, oH, align_corners, scale_h) - width_scale = compute_scale(iW, oW, align_corners, scale_w) - N_idx = ivy.reshape(ivy.arange(N), (N, 1, 1, 1)).astype(ivy.int64) C_idx = ivy.reshape(ivy.arange(C), (1, C, 1, 1)).astype(ivy.int64) out_y = ivy.reshape(ivy.arange(oH), ((1, 1, oH, 1))) out_x = ivy.reshape(ivy.arange(oW), ((1, 1, 1, oW))) - real_x = compute_source_index(width_scale, out_x, align_corners) + scale_y, scale_x = scale + + real_x = compute_source_index(scale_x, out_x, align_corners) in_x = ivy.floor(real_x) t_x = real_x - in_x ix = ivy.astype(in_x, ivy.int64) - real_y = compute_source_index(height_scale, out_y, align_corners) + real_y = compute_source_index(scale_y, out_y, align_corners) in_y = ivy.floor(real_y) t_y = real_y - in_y iy = ivy.astype(in_y, ivy.int64) @@ -1652,7 +1645,6 @@ def get_x_interp(y): def area_interpolate(x, dims, size, scale): ret = ivy.zeros((x.shape[:2] + size)) - inv_scale = ivy.divide(1.0, scale) for i, ba in enumerate(x): for j, ch in enumerate(ba): if dims == 3: @@ -1660,16 +1652,16 @@ def area_interpolate(x, dims, size, scale): for h_dim in range(size[1]): for w_dim in range(size[2]): d_index = ( - int(d_dim * inv_scale[0]), - math.ceil((d_dim + 1) * inv_scale[0]), + int(d_dim * scale[0]), + math.ceil((d_dim + 1) * scale[0]), ) h_index = ( - int(h_dim * inv_scale[1]), - math.ceil((h_dim + 1) * inv_scale[1]), + int(h_dim * scale[1]), + math.ceil((h_dim + 1) * scale[1]), ) w_index = ( int(w_dim * scale[2]), - math.ceil((w_dim + 1) * inv_scale[2]), + math.ceil((w_dim + 1) * scale[2]), ) scale_z = d_index[1] - d_index[0] scale_y = h_index[1] - h_index[0] @@ -1686,12 +1678,12 @@ def area_interpolate(x, dims, size, scale): for h_dim in range(size[0]): for w_dim in range(size[1]): h_index = ( - int(h_dim * inv_scale[0]), - math.ceil((h_dim + 1) * inv_scale[0]), + int(h_dim * scale[0]), + math.ceil((h_dim + 1) * scale[0]), ) w_index = ( - int(w_dim * inv_scale[1]), - math.ceil((w_dim + 1) * inv_scale[1]), + int(w_dim * scale[1]), + math.ceil((w_dim + 1) * scale[1]), ) scale_y = h_index[1] - h_index[0] scale_x = w_index[1] - w_index[0] @@ -1702,8 +1694,8 @@ def area_interpolate(x, dims, size, scale): else: for w_dim in range(size[0]): w_index = ( - int(w_dim * inv_scale[0]), - math.ceil((w_dim + 1) * inv_scale[0]), + int(w_dim * scale[0]), + math.ceil((w_dim + 1) * scale[0]), ) scale_x = w_index[1] - w_index[0] ret[i, j, w_dim] = ivy.sum(ch[w_index[0] : w_index[1]]) * ( @@ -1733,26 +1725,12 @@ def generate_einsum_equation(dim): return einsum_string -def _interpolate_with_kernel( - x, dims, size, input_shape, align_corners, scale_factor, mode -): - spatial_dims = [2 + i for i in range(dims)] +def _interpolate_with_kernel(x, dims, size, input_size, align_corners, scale, mode): equation = generate_einsum_equation(dims) kernel_func = get_interpolate_kernel(mode) - output_shape = tuple(input_shape[:2]) + size operands = [] - for i, d in enumerate(spatial_dims): - m = input_shape[d] - n = output_shape[d] - dim_scale_factor = _dim_scale_factor( - m, - n, - align_corners, - scale_factor[i] if scale_factor is not None else None, - ) - w = _compute_weight_mat( - m, n, align_corners, kernel_func, dim_scale_factor - ).astype(x.dtype) + for m, n, s in zip(input_size, size, scale): + w = _compute_weight_mat(m, n, align_corners, kernel_func, s).astype(x.dtype) operands.append(w) return ivy.einsum(equation, x, *operands) @@ -1785,7 +1763,7 @@ def interpolate( ] = "linear", scale_factor: Optional[Union[Sequence[int], int]] = None, recompute_scale_factor: Optional[bool] = None, - align_corners: Optional[bool] = None, + align_corners: bool = False, antialias: bool = False, # ToDo: add support for antialias out: Optional[ivy.Array] = None, ) -> ivy.Array: @@ -1828,8 +1806,6 @@ def interpolate( and thus preserving the values at the corner pixels. If False, the corner pixels are not aligned, and the interpolation uses edge value padding for out-of-boundary values. - only has an effect when mode is 'linear', 'bilinear', - 'bicubic' or 'trilinear'. Default: False out Optional output array, for writing the result to. It must have a shape that the inputs broadcast to. @@ -1838,25 +1814,8 @@ def interpolate( ------- resized array """ - input_shape = ivy.shape(x) - dims = len(input_shape) - 2 - if ( - mode - not in [ - "linear", - "bilinear", - "trilinear", - "nd", - "tf_bicubic", - "lanczos3", - "lanczos5", - "bicubic", - ] - and align_corners is not None - ): - raise ivy.utils.exceptions.IvyException( - f"align_corners option cannot be set with interpolating mode {mode}" - ) + input_size = ivy.shape(x)[2:] + dims = len(input_size) if ivy.exists(size) and ivy.exists(scale_factor): raise ivy.utils.exceptions.IvyException( "only one of size or scale_factor should be defined" @@ -1869,7 +1828,7 @@ def interpolate( inverse=False, message=( "Input and output must have the same number of spatial dimensions," - f" but got input with {list(x.shape[2:])} spatial dimensions and" + f" but got input with {list(input_size)} spatial dimensions and" f" output size {size}." ), as_array=False, @@ -1882,7 +1841,7 @@ def interpolate( inverse=False, message=( "Input and scale_factor must have the same number of spatial" - f" dimensions, but got input with {list(x.shape[2:])} spatial" + f" dimensions, but got input with {list(input_size)} spatial" f" dimensions and scale_factor {scale_factor}." ), as_array=False, @@ -1907,18 +1866,21 @@ def interpolate( raise ivy.utils.exceptions.IvyException( f"Got {x.ndim}D input, but trilinear mode needs 3D input" ) - size, scale_factor = _get_size(scale_factor, size, dims, x.shape) + size, scale_factor = _get_size(scale_factor, size, dims, input_size) ivy.utils.assertions.check_true( all(s > 0 for s in size), message=f"output sizes should be greater than 0, but got {size}", ) - if all(a == b for a, b in zip(size, input_shape[2:])): + if all(a == b for a, b in zip(size, input_size)): ret = x else: if recompute_scale_factor: + scale_factor = [ivy.divide(size[i], input_size[i]) for i in range(dims)] + else: scale_factor = [ - ivy.divide(size[i], input_shape[i + 2]) for i in range(dims) + 1 if input_size[i] == size[i] else scale_factor[i] for i in range(dims) ] + scale = _get_final_scale(input_size, size, align_corners, scale_factor) if mode in [ "linear", "bilinear", @@ -1932,42 +1894,39 @@ def interpolate( x, dims, size, - input_shape, + input_size, align_corners, - scale_factor, + scale, mode, ) elif mode == "bicubic": - ret = _upsample_bicubic2d_default(x, size, align_corners) + ret = _upsample_bicubic2d_default(x, size, scale, align_corners) elif mode in ["nearest-exact", "nearest"]: - ret = nearest_interpolate( - x, dims, size, input_shape, mode == "nearest-exact" - ) + ret = nearest_interpolate(x, dims, size, scale, mode == "nearest-exact") elif mode == "area": - ret = area_interpolate(x, dims, size, scale_factor) + ret = area_interpolate(x, dims, size, scale) elif mode == "mitchellcubic": batch, channels, in_height, in_width = x.shape out_height, out_width = size - scale_factor_h = out_height / in_height - scale_factor_w = out_width / in_width + scale_h, scale_w = scale ret = ivy.zeros((batch, channels, out_height, out_width)) for i in range(out_height): for j in range(out_width): - p_i = i / scale_factor_h - p_j = j / scale_factor_w + p_i = i * scale_h + p_j = j * scale_w left = int(math.floor(p_j - 2)) right = int(math.ceil(p_j + 2)) top = int(math.floor(p_i - 2)) bottom = int(math.ceil(p_i + 2)) kernel_w = ivy.array( [ - _mitchellcubic_kernel((p_j - j) / scale_factor_w) + _mitchellcubic_kernel((p_j - j) * scale_w) for i in range(left, right) ] ) kernel_h = ivy.array( [ - _mitchellcubic_kernel((p_i - i) / scale_factor_h) + _mitchellcubic_kernel((p_i - i) * scale_h) for j in range(top, bottom) ] ) @@ -1994,9 +1953,8 @@ def interpolate( * kernel_w[ivy.newaxis, :] ) elif mode == "gaussian": - ratio_h = size[0] / x.shape[-2] - ratio_w = size[1] / x.shape[-1] - sigma = max(1 / ratio_h, 1 / ratio_w) * 0.5 + ratio_h, ratio_w = scale + sigma = max(ratio_h, ratio_w) * 0.5 kernel_size = 2 * int(math.ceil(3 * sigma)) + 1 kernel_h = ivy.zeros((kernel_size,), dtype=x.dtype) kernel_w = ivy.zeros((kernel_size,), dtype=x.dtype) @@ -2014,8 +1972,8 @@ def interpolate( ret = ivy.zeros(output_shape, dtype=x.dtype) for i in range(size[0]): for j in range(size[1]): - p_i = int(math.floor(i / ratio_h + int(math.ceil(3 * sigma)))) - p_j = int(math.floor(j / ratio_w + int(math.ceil(3 * sigma)))) + p_i = int(math.floor(i * ratio_h + int(math.ceil(3 * sigma)))) + p_j = int(math.floor(j * ratio_w + int(math.ceil(3 * sigma)))) for b in range(x.shape[0]): for c in range(x.shape[1]): patch = padded_x[ @@ -2030,7 +1988,7 @@ def interpolate( * kernel_w[:, ivy.newaxis] ) elif mode == "tf_area": - ret = _tf_area_interpolate(x, size, dims) + ret = _tf_area_interpolate(x, size, scale, dims) ret = ivy.astype(ret, ivy.dtype(x)) if ivy.exists(out): return ivy.inplace_update(out, ret) @@ -2046,7 +2004,7 @@ def interpolate( } -def _get_size(scale_factor, size, dims, x_shape): +def _get_size(scale_factor, size, dims, input_shape): if scale_factor is not None: if isinstance(scale_factor, (float, int)): scale_factor = [scale_factor] * dims @@ -2054,11 +2012,11 @@ def _get_size(scale_factor, size, dims, x_shape): scale_factor = [scale_factor[0]] * dims size = tuple( - int(math.floor(x_shape[2 + i] * scale_factor[i])) for i in range(dims) + int(math.floor(input_shape[i] * scale_factor[i])) for i in range(dims) ) else: size = (size,) * dims if isinstance(size, int) else tuple(size) - scale_factor = [ivy.divide(size[i], x_shape[i + 2]) for i in range(dims)] + scale_factor = [ivy.divide(size[i], input_shape[i]) for i in range(dims)] return size, scale_factor diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py index c799de3b914d0..97b4c2bbf574d 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py @@ -260,6 +260,8 @@ def test_torch_interpolate( scale_factor, recompute_scale_factor, ) = dtype_and_input_and_other + if mode not in ["linear", "bilinear", "bicubic", "trilinear"]: + align_corners = None helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 08d1ee0bf72cd..0d54103cda8a5 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -84,18 +84,6 @@ def _interp_args(draw, mode=None, mode_list=None): ) elif mode_list: mode = draw(st.sampled_from(mode_list)) - align_corners = None - if mode in [ - "linear", - "bilinear", - "trilinear", - "nd", - "tf_bicubic", - "lanczos3", - "lanczos5", - "bicubic", - ]: - align_corners = draw(st.booleans()) if mode == "linear": num_dims = 3 elif mode in [ @@ -138,6 +126,7 @@ def _interp_args(draw, mode=None, mode_list=None): abs_smallest_val=1e-04, ) ) + align_corners = draw(st.booleans()) if draw(st.booleans()): if draw(st.booleans()): scale_factor = draw( From 1b2637088efc97bba66c9a48c3111a8da12a73c2 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 31 Oct 2023 15:13:22 +0530 Subject: [PATCH 088/978] fix: updated set_backend and unset_backend to avoid changing values of the global modes for usage convenience of setting the mode once and using it across backends (#27188) --- ivy/utils/backend/handler.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index d45679a793fe7..f07d3f2b5225c 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -206,6 +206,8 @@ def _set_module_backend( ) backend_str = backend.current_backend_str() if backend_str is None else backend_str for k, v in original_dict.items(): + if k in ivy.GLOBAL_PROPS: + continue compositional = k not in backend.__dict__ if compositional: if k in invalid_dtypes and k in target.__dict__: @@ -535,6 +537,8 @@ def previous_backend(): # wrap backend functions if there still is a backend, and add functions # to ivy namespace for k, v in new_backend_dict.items(): + if k in ivy.GLOBAL_PROPS: + continue if backend_stack and k in ivy_original_dict: v = _wrap_function(k, v, ivy_original_dict[k]) if k in ivy_original_dict: From d7bc2149671f3210928e8a08a301e2614c876409 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 31 Oct 2023 10:57:01 +0000 Subject: [PATCH 089/978] fix: Update the tolerance values of test_interpolate and test_torch_interpolate. --- .../test_nn/test_functional/test_vision_functions.py | 3 +-- .../test_functional/test_experimental/test_nn/test_layers.py | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py index 97b4c2bbf574d..912c3e82599be 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py @@ -269,8 +269,7 @@ def test_torch_interpolate( test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, - rtol=1e-01, - atol=1e-01, + atol=1e-03, input=x[0], size=size, scale_factor=scale_factor, diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 0d54103cda8a5..1840881cf128c 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -1079,7 +1079,7 @@ def test_interpolate(dtype_x_mode, test_flags, backend_fw, fn_name, on_device): fn_name=fn_name, on_device=on_device, rtol_=1e-01, - atol_=1e-01, + atol_=1e-03, x=x[0], size=size, mode=mode, From 08c1ce01d5e6859a68f9c9ef3a6ae7df35316506 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 31 Oct 2023 12:28:28 +0000 Subject: [PATCH 090/978] fix: Remove redundant operations from torch avg_pool functions and correct the ivy typehints --- .../backends/jax/experimental/layers.py | 6 +- .../backends/mxnet/experimental/layers.py | 8 +-- .../backends/numpy/experimental/layers.py | 6 +- .../backends/paddle/experimental/layers.py | 6 +- .../tensorflow/experimental/layers.py | 6 +- .../backends/torch/experimental/layers.py | 6 +- .../torch/nn/functional/pooling_functions.py | 62 +++++-------------- ivy/functional/ivy/experimental/layers.py | 8 +-- .../test_functional/test_pooling_functions.py | 9 +-- 9 files changed, 40 insertions(+), 77 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 8ff17ef9cb5ee..735ccd390c3dd 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -291,7 +291,7 @@ def avg_pool1d( x: JaxArray, kernel: Union[int, Tuple[int]], strides: Union[int, Tuple[int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NWC", @@ -341,7 +341,7 @@ def avg_pool2d( x: JaxArray, kernel: Union[int, Tuple[int], Tuple[int, int]], strides: Union[int, Tuple[int], Tuple[int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NHWC", @@ -393,7 +393,7 @@ def avg_pool3d( x: JaxArray, kernel: Union[int, Tuple[int], Tuple[int, int, int]], strides: Union[int, Tuple[int], Tuple[int, int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NDHWC", diff --git a/ivy/functional/backends/mxnet/experimental/layers.py b/ivy/functional/backends/mxnet/experimental/layers.py index b77458ec487c1..618f365a0e65b 100644 --- a/ivy/functional/backends/mxnet/experimental/layers.py +++ b/ivy/functional/backends/mxnet/experimental/layers.py @@ -1,5 +1,5 @@ # global -from typing import Optional, Union, Tuple, Literal, Sequence +from typing import List, Optional, Union, Tuple, Literal, Sequence import mxnet as mx # local @@ -74,7 +74,7 @@ def avg_pool1d( x: mx.nd.NDArray, kernel: Union[int, Tuple[int]], strides: Union[int, Tuple[int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NWC", @@ -89,7 +89,7 @@ def avg_pool2d( x: mx.nd.NDArray, kernel: Union[int, Tuple[int], Tuple[int, int]], strides: Union[int, Tuple[int], Tuple[int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NHWC", @@ -105,7 +105,7 @@ def avg_pool3d( x: mx.nd.NDArray, kernel: Union[int, Tuple[int], Tuple[int, int, int]], strides: Union[int, Tuple[int], Tuple[int, int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NDHWC", diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index e549c93fc53a6..832a1c872eda7 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -386,7 +386,7 @@ def avg_pool1d( x: np.ndarray, kernel: Union[int, Tuple[int]], strides: Union[int, Tuple[int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NWC", @@ -470,7 +470,7 @@ def avg_pool2d( x: np.ndarray, kernel: Union[int, Tuple[int], Tuple[int, int]], strides: Union[int, Tuple[int], Tuple[int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NHWC", @@ -577,7 +577,7 @@ def avg_pool3d( x: np.ndarray, kernel: Union[int, Tuple[int], Tuple[int, int, int]], strides: Union[int, Tuple[int], Tuple[int, int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NDHWC", diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index 58911129ef59d..16a36c4979fa6 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -243,7 +243,7 @@ def avg_pool1d( x: paddle.Tensor, kernel: Union[int, Tuple[int]], strides: Union[int, Tuple[int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NWC", @@ -258,7 +258,7 @@ def avg_pool2d( x: paddle.Tensor, kernel: Union[int, Tuple[int], Tuple[int, int]], strides: Union[int, Tuple[int], Tuple[int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NHWC", @@ -274,7 +274,7 @@ def avg_pool3d( x: paddle.Tensor, kernel: Union[int, Tuple[int], Tuple[int, int, int]], strides: Union[int, Tuple[int], Tuple[int, int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NDHWC", diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 8ffe1f9d56e98..a75fd79321f50 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -282,7 +282,7 @@ def avg_pool1d( x: Union[tf.Tensor, tf.Variable], kernel: Union[int, Tuple[int]], strides: Union[int, Tuple[int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NWC", @@ -354,7 +354,7 @@ def avg_pool2d( x: Union[tf.Tensor, tf.Variable], kernel: Union[int, Tuple[int], Tuple[int, int]], strides: Union[int, Tuple[int], Tuple[int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NHWC", @@ -446,7 +446,7 @@ def avg_pool3d( x: Union[tf.Tensor, tf.Variable], kernel: Union[int, Tuple[int], Tuple[int, int, int]], strides: Union[int, Tuple[int], Tuple[int, int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NDHWC", diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 3f277d825e1c7..7f0924891cec0 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -316,7 +316,7 @@ def avg_pool1d( x: torch.Tensor, kernel: Union[int, Tuple[int]], strides: Union[int, Tuple[int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NWC", @@ -406,7 +406,7 @@ def avg_pool2d( x: torch.Tensor, kernel: Union[int, Tuple[int], Tuple[int, int]], strides: Union[int, Tuple[int], Tuple[int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NHWC", @@ -493,7 +493,7 @@ def avg_pool3d( x: torch.Tensor, kernel: Union[int, Tuple[int], Tuple[int, int, int]], strides: Union[int, Tuple[int], Tuple[int, int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NDHWC", diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 75454ec07d2aa..8f4825bd2b2f1 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -81,6 +81,10 @@ def adaptive_max_pool2d( return ivy.adaptive_max_pool2d(input, output_size) +@with_unsupported_dtypes( + {"2.1.0 and below": ("float16",)}, + "torch", +) @to_ivy_arrays_and_back def avg_pool1d( input, @@ -90,25 +94,12 @@ def avg_pool1d( ceil_mode=False, count_include_pad=True, ): - if stride is None: - stride = kernel_size - data_format = "NCW" - # TODO: remove the broadcasting and padding string specification when ivy.avg_pool - # support explicit padding - kernel_size = _broadcast_pooling_helper(kernel_size, "1d", name="kernel_size") - padding = _broadcast_pooling_helper(padding, "1d", name="padding") - if all( - [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] - ): - padding = "SAME" - else: - padding = "VALID" return ivy.avg_pool1d( input, kernel_size, - stride, - padding, - data_format=data_format, + stride if stride is not None else kernel_size, + [(pad, pad) for pad in padding], + data_format="NCW", count_include_pad=count_include_pad, ceil_mode=ceil_mode, ) @@ -128,31 +119,22 @@ def avg_pool2d( count_include_pad=True, divisor_override=None, ): - if stride is None: - stride = kernel_size - data_format = "NCHW" - # TODO: remove the broadcasting and padding string specification when ivy.avg_pool - # support explicit padding - kernel_size = _broadcast_pooling_helper(kernel_size, "2d", name="kernel_size") - padding = _broadcast_pooling_helper(padding, "2d", name="padding") - if all( - [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] - ): - padding = "SAME" - else: - padding = "VALID" return ivy.avg_pool2d( input, kernel_size, - stride, - padding, - data_format=data_format, + stride if stride is not None else kernel_size, + [(pad, pad) for pad in padding], + data_format="NCHW", ceil_mode=ceil_mode, count_include_pad=count_include_pad, divisor_override=divisor_override, ) +@with_unsupported_dtypes( + {"2.1.0 and below": ("float16", "bfloat16")}, + "torch", +) @to_ivy_arrays_and_back def avg_pool3d( input, @@ -163,23 +145,11 @@ def avg_pool3d( count_include_pad=True, divisor_override=None, ): - if stride is None: - stride = kernel_size - # TODO: remove the broadcasting and padding string specification when ivy.avg_pool - # support explicit padding - kernel_size = _broadcast_pooling_helper(kernel_size, "3d", name="kernel_size") - padding = _broadcast_pooling_helper(padding, "3d", name="padding") - if all( - [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] - ): - padding = "SAME" - else: - padding = "VALID" return ivy.avg_pool3d( input, kernel_size, - stride, - padding, + stride if stride is not None else kernel_size, + [(pad, pad) for pad in padding], data_format="NCDHW", ceil_mode=ceil_mode, count_include_pad=count_include_pad, diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 19daa2b1affe3..1542c1fe575aa 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -297,7 +297,7 @@ def avg_pool1d( x: Union[ivy.Array, ivy.NativeArray], kernel: Union[int, Tuple[int]], strides: Union[int, Tuple[int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NWC", @@ -380,7 +380,7 @@ def avg_pool2d( x: Union[ivy.Array, ivy.NativeArray], kernel: Union[int, Tuple[int], Tuple[int, int]], strides: Union[int, Tuple[int], Tuple[int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NHWC", @@ -403,7 +403,7 @@ def avg_pool2d( The stride of the sliding window for each dimension of input. padding SAME" or "VALID" indicating the algorithm, or list - indicating the per-dimensio paddings. + indicating the per-dimension paddings. data_format NHWC" or "NCHW". Defaults to "NHWC". count_include_pad @@ -468,7 +468,7 @@ def avg_pool3d( x: Union[ivy.Array, ivy.NativeArray], kernel: Union[int, Tuple[int], Tuple[int, int, int]], strides: Union[int, Tuple[int], Tuple[int, int, int]], - padding: str, + padding: Union[str, int, List[Tuple[int, int]]], /, *, data_format: str = "NDHWC", diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py index 8d940f3f91acd..e7f32c9b13168 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py @@ -193,14 +193,7 @@ def test_torch_avg_pool1d( on_device, ): input_dtype, x, kernel_size, stride, padding = dtype_x_k_s - # TODO: remove the processing of padding attribute when ivy.avg_pool - # support explicit padding - x_shape = [x[0].shape[2]] - padding = [pad[i] for i, pad in enumerate(padding)] - # figuring out the exact kernel_size for SAME and VALID padding - # As ivy.avg_pool1d doesn't support explicit padding scheme - if not sum(padding) == 0: - padding = calculate_same_padding(kernel_size, stride, x_shape) + padding = [pad[0] for pad in padding] helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, From d9d805a461e8fb2b55d02b80dfd88ca1561bf8cd Mon Sep 17 00:00:00 2001 From: NripeshN Date: Wed, 1 Nov 2023 15:58:42 +0400 Subject: [PATCH 091/978] Chore: Fix all lints --- ivy/compiler/compiler.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index a89084d8b0dbe..97f8ada162541 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,7 @@ def trace_graph( v=None ): """ - Takes `fn` and traces it into a more efficient composition of backend operations. + Take `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -90,7 +90,6 @@ def trace_graph( >>> print(time.time() - start) 0.0001785755157470703 """ - from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -153,7 +152,6 @@ def transpile( ------- Either a transpiled Graph or a non-initialized LazyGraph. """ - from ._compiler import transpile as _transpile return _transpile( From 902ae4b2c441b2375f20ce8df16789e0a144f74a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 1 Nov 2023 17:45:06 +0530 Subject: [PATCH 092/978] refactor: Refactoring for efficiency and better readability (#27090) --- ivy/data_classes/array/array.py | 4 +- ivy/data_classes/container/base.py | 6 +-- .../backends/jax/experimental/elementwise.py | 2 +- .../backends/jax/experimental/layers.py | 26 +++++----- ivy/functional/backends/numpy/__init__.py | 2 +- .../backends/numpy/experimental/layers.py | 12 ++--- ivy/functional/backends/paddle/data_type.py | 2 +- .../paddle/experimental/elementwise.py | 2 +- ivy/functional/backends/paddle/layers.py | 2 +- .../backends/tensorflow/control_flow_ops.py | 2 +- .../backends/tensorflow/data_type.py | 2 +- .../tensorflow/experimental/elementwise.py | 2 +- ivy/functional/backends/torch/data_type.py | 2 +- .../backends/torch/experimental/gradients.py | 20 +++----- .../backends/torch/experimental/layers.py | 18 +++---- .../torch/experimental/manipulation.py | 2 +- .../torch/experimental/sparse_array.py | 4 +- ivy/functional/backends/torch/gradients.py | 2 +- ivy/functional/backends/torch/layers.py | 4 +- ivy/functional/backends/torch/statistical.py | 2 +- ivy/functional/frontends/jax/numpy/dtype.py | 2 +- .../mindspore/ops/function/nn_func.py | 16 +++--- .../numpy/data_type_routines/general.py | 2 +- .../frontends/numpy/matrix/methods.py | 2 +- ivy/functional/frontends/paddle/fft.py | 2 +- ivy/functional/frontends/paddle/linalg.py | 2 +- .../frontends/paddle/manipulation.py | 2 +- .../frontends/paddle/nn/functional/pooling.py | 4 +- .../frontends/tensorflow/general_functions.py | 3 +- .../frontends/torch/func_wrapper.py | 2 +- .../torch/nn/functional/pooling_functions.py | 6 +-- ivy/functional/ivy/experimental/layers.py | 4 +- ivy/functional/ivy/general.py | 2 +- ivy/functional/ivy/layers.py | 4 +- .../write_array_api_tests_k_flag.py | 6 +-- ivy_tests/test_ivy/conftest.py | 2 +- .../hypothesis_helpers/dtype_helpers.py | 4 +- .../hypothesis_helpers/general_helpers.py | 2 +- .../test_numpy/test_mathematical_functions.py | 5 +- .../test_function/test_mindspore_nn_func.py | 26 ++++------ .../test_frontends/test_numpy/helpers.py | 6 +-- .../test_numpy/test_func_wrapper.py | 2 +- .../test_inserting_data_into_arrays.py | 3 +- .../test_padding_arrays.py | 2 +- .../test_tensorflow/test_tensor.py | 2 +- .../test_torch/test_func_wrapper.py | 2 +- .../test_frontends/test_torch/test_linalg.py | 2 +- .../test_functional/test_pooling_functions.py | 30 +++++------- .../test_torch/test_reduction_ops.py | 2 +- .../test_functional/test_core/test_device.py | 2 +- .../test_functional/test_core/test_general.py | 2 +- .../test_core/test_gradients.py | 4 +- .../test_functional/test_core/test_meta.py | 49 +++++++++---------- .../test_ivy/test_misc/test_exceptions.py | 44 ++++++++--------- .../test_factorized_tensor/test_cp_tensor.py | 2 +- .../test_tucker_tensor.py | 2 +- scripts/run_tests/run_tests.py | 2 +- scripts/setup_tests/synchronize_db.py | 2 +- 58 files changed, 173 insertions(+), 203 deletions(-) diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 0694b3dada2f6..546c2b6504175 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -671,10 +671,10 @@ def __imod__(self, other): return ivy.remainder(self._data, other) def __divmod__(self, other): - return tuple([ivy.divide(self._data, other), ivy.remainder(self._data, other)]) + return ivy.divide(self._data, other), ivy.remainder(self._data, other) def __rdivmod__(self, other): - return tuple([ivy.divide(other, self._data), ivy.remainder(other, self._data)]) + return ivy.divide(other, self._data), ivy.remainder(other, self._data) def __truediv__(self, other): """ diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index ea9ebfce7853e..bb90cef214b1d 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -2249,7 +2249,7 @@ def cont_to_flat_list(self): ret Container as flat list. """ - return list([item for key, item in self.cont_to_iterator()]) + return list(item for key, item in self.cont_to_iterator()) def cont_from_flat_list(self, flat_list): """ @@ -3803,7 +3803,7 @@ def _pre_pad_alpha_line(str_in): s[0].isnumeric() or s[0] == "-" or s[0:3] == "..." - or max([ss in s[0:6] for ss in ["nan, ", "inf, "]]) + or max(ss in s[0:6] for ss in ["nan, ", "inf, "]) ) else ( indent_str + indented_key_str + s @@ -4279,7 +4279,7 @@ def cont_max_depth(self): kcs = [kc for kc in self.cont_to_iterator_keys(include_empty=True)] if not kcs: return 0 - return max([len(kc.split("/")) for kc in kcs]) + return max(len(kc.split("/")) for kc in kcs) @property def dynamic_backend(self): diff --git a/ivy/functional/backends/jax/experimental/elementwise.py b/ivy/functional/backends/jax/experimental/elementwise.py index c39c5910f34f1..6ee0c250ecb32 100644 --- a/ivy/functional/backends/jax/experimental/elementwise.py +++ b/ivy/functional/backends/jax/experimental/elementwise.py @@ -253,7 +253,7 @@ def _normalize_axis_tuple(axis: Union[int, list, tuple], ndim: int) -> Tuple[int axis = [operator.index(axis)] except TypeError: pass - axis = tuple([_normalize_axis_index(ax, ndim) for ax in axis]) + axis = tuple(_normalize_axis_index(ax, ndim) for ax in axis) if len(set(axis)) != len(axis): raise ValueError("repeated axis") return axis diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 735ccd390c3dd..bbd16bfd92f3e 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -83,10 +83,8 @@ def general_pool( # shape of window after dilation new_window_shape = tuple( - [ - window_shape[i - 1] + (dilation[i] - 1) * (window_shape[i - 1] - 1) - for i in range(1, len(dims) - 1) - ] + window_shape[i - 1] + (dilation[i] - 1) * (window_shape[i - 1] - 1) + for i in range(1, len(dims) - 1) ) inputs, window_shape, strides, depth_pooling = _determine_depth_max_pooling( inputs, window_shape, strides, dim, data_format="channel_last" @@ -136,13 +134,13 @@ def general_pool( # because they are counted in average calculation inputs = jnp.pad(inputs, pad_list, mode="constant", constant_values=1.0) pad_list = [(0, 0)] * len(pad_list) + elif isinstance(padding, list) and any( + item != 0 for sublist in padding for item in sublist + ): + raise NotImplementedError( + "Nonzero explicit padding is not supported for depthwise max pooling" + ) else: - if isinstance(padding, list) and any( - [item != 0 for sublist in padding for item in sublist] - ): - raise NotImplementedError( - "Nonzero explicit padding is not supported for depthwise max pooling" - ) pad_list = [(0, 0)] * (dim + 2) if not ivy.is_array(inputs): @@ -455,7 +453,7 @@ def dct( if norm not in (None, "ortho"): raise ValueError("Norm must be either None or 'ortho'") if axis < 0: - axis = axis + len(x.shape) + axis += len(x.shape) if n is not None: signal_len = x.shape[axis] if n <= signal_len: @@ -558,7 +556,7 @@ def fft( raise ivy.utils.exceptions.IvyError( f"Invalid data points {n}, expecting more than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") return jnp.fft.fft(x, n, dim, norm) @@ -670,7 +668,7 @@ def ifft( raise ivy.utils.exceptions.IvyError( f"Invalid data points {n}, expecting more than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") return jnp.fft.ifft(x, n, dim, norm) @@ -899,7 +897,7 @@ def rfftn( raise ivy.utils.exceptions.IvyError( f"Invalid data points {s}, expecting s points larger than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") return jnp.fft.rfftn(x, s, axes, norm).astype(jnp.complex128) diff --git a/ivy/functional/backends/numpy/__init__.py b/ivy/functional/backends/numpy/__init__.py index 8752de1a73117..163da57f6a834 100644 --- a/ivy/functional/backends/numpy/__init__.py +++ b/ivy/functional/backends/numpy/__init__.py @@ -37,7 +37,7 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): "subtract": "subtract", "add": "add", } - if ufunc.__name__ in methods.keys(): + if ufunc.__name__ in methods: return eval("ivy." + methods[ufunc.__name__] + "(*inputs, **kwargs)") return func(self, ufunc, method, *inputs, **kwargs) diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index 832a1c872eda7..91f9a73a1d087 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -97,7 +97,7 @@ def max_pool1d( ) else: if isinstance(padding, list) and any( - [item != 0 for sublist in padding for item in sublist] + item != 0 for sublist in padding for item in sublist ): raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" @@ -203,7 +203,7 @@ def max_pool2d( ) else: if isinstance(padding, list) and any( - [item != 0 for sublist in padding for item in sublist] + item != 0 for sublist in padding for item in sublist ): raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" @@ -317,7 +317,7 @@ def max_pool3d( ) else: if isinstance(padding, list) and any( - [item != 0 for sublist in padding for item in sublist] + item != 0 for sublist in padding for item in sublist ): raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" @@ -717,7 +717,7 @@ def fft( raise ivy.utils.exceptions.IvyError( f"Invalid data points {n}, expecting more than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") if x.dtype in [np.uint64, np.int64, np.float64, np.complex128]: out_dtype = np.complex128 @@ -940,7 +940,7 @@ def ifft( raise ivy.utils.exceptions.IvyError( f"Invalid data points {n}, expecting more than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") return np.asarray(np.fft.ifft(x, n, dim, norm), dtype=x.dtype) @@ -1063,7 +1063,7 @@ def rfftn( raise ivy.utils.exceptions.IvyError( f"Invalid data points {s}, expecting s points larger than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") return np.fft.rfftn(x, s, axes, norm).astype(np.complex128) diff --git a/ivy/functional/backends/paddle/data_type.py b/ivy/functional/backends/paddle/data_type.py index 5127217dc85a0..e358136c6d612 100644 --- a/ivy/functional/backends/paddle/data_type.py +++ b/ivy/functional/backends/paddle/data_type.py @@ -237,7 +237,7 @@ def as_native_dtype( return paddle.bool if not isinstance(dtype_in, str): return dtype_in - if dtype_in in native_dtype_dict.keys(): + if dtype_in in native_dtype_dict: return native_dtype_dict[ivy.Dtype(dtype_in)] else: raise ivy.utils.exceptions.IvyException( diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index bb7843015e089..0c6a26baa15fe 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -385,7 +385,7 @@ def _normalize_axis_tuple(axis: Union[int, list, tuple], ndim: int) -> Tuple[int axis = [operator.index(axis)] except TypeError: pass - axis = tuple([_normalize_axis_index(ax, ndim) for ax in axis]) + axis = tuple(_normalize_axis_index(ax, ndim) for ax in axis) if len(set(axis)) != len(axis): raise ValueError("repeated axis") return axis diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index d970754ef63f1..9a27ab9272cb1 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -70,7 +70,7 @@ def _pad_before_conv(x, filters, strides, padding, dims, dilations, data_format) else: raise ValueError(f"Invalid padding format: {padding}") - if not all([p >= 0 for p in padding]): + if not all(p >= 0 for p in padding): raise ValueError( "Invalid padding, all values should be larger than" f"or equal to 0, but received: {padding}." diff --git a/ivy/functional/backends/tensorflow/control_flow_ops.py b/ivy/functional/backends/tensorflow/control_flow_ops.py index ba6cacc5820da..e56beb4e35731 100644 --- a/ivy/functional/backends/tensorflow/control_flow_ops.py +++ b/ivy/functional/backends/tensorflow/control_flow_ops.py @@ -65,4 +65,4 @@ def _tuple_to_dict(t): def _dict_to_tuple(d): - return tuple([d[k] for k in d]) + return tuple(d[k] for k in d) diff --git a/ivy/functional/backends/tensorflow/data_type.py b/ivy/functional/backends/tensorflow/data_type.py index ef083ebb3f6c4..b5fb0f80784fe 100644 --- a/ivy/functional/backends/tensorflow/data_type.py +++ b/ivy/functional/backends/tensorflow/data_type.py @@ -239,7 +239,7 @@ def as_native_dtype( dtype_in = dtype_in.name if not isinstance(dtype_in, str): return dtype_in - if dtype_in in native_dtype_dict.keys(): + if dtype_in in native_dtype_dict: return native_dtype_dict[ivy.Dtype(dtype_in)] else: raise ivy.utils.exceptions.IvyException( diff --git a/ivy/functional/backends/tensorflow/experimental/elementwise.py b/ivy/functional/backends/tensorflow/experimental/elementwise.py index 9fb8df7bd3f1d..97841a300cd43 100644 --- a/ivy/functional/backends/tensorflow/experimental/elementwise.py +++ b/ivy/functional/backends/tensorflow/experimental/elementwise.py @@ -282,7 +282,7 @@ def _normalize_axis_tuple(axis: Union[int, list, tuple], ndim: int) -> Tuple[int axis = [operator.index(axis)] except TypeError: pass - axis = tuple([_normalize_axis_index(ax, ndim) for ax in axis]) + axis = tuple(_normalize_axis_index(ax, ndim) for ax in axis) if len(set(axis)) != len(axis): raise ValueError("repeated axis") return axis diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index 901acc1e5b19d..31265bff3577e 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -196,7 +196,7 @@ def as_native_dtype( dtype_in = dtype_in.name if not isinstance(dtype_in, str): return dtype_in - if dtype_in in native_dtype_dict.keys(): + if dtype_in in native_dtype_dict: return native_dtype_dict[ivy.Dtype(dtype_in)] else: raise ivy.utils.exceptions.IvyException( diff --git a/ivy/functional/backends/torch/experimental/gradients.py b/ivy/functional/backends/torch/experimental/gradients.py index 3234a5f342953..b6c0a7cedf6e4 100644 --- a/ivy/functional/backends/torch/experimental/gradients.py +++ b/ivy/functional/backends/torch/experimental/gradients.py @@ -35,12 +35,10 @@ def backward(ctx, upstream): def vjp(func: Callable, *primals): flattened_primals, ret_idxs = _flatten_containers(primals) unique_keys = list( - set( - [ - ivy.index_nest(ret_idxs, i) - for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) - ] - ) + { + ivy.index_nest(ret_idxs, i) + for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) + } ) def grad_fn(*x_in): @@ -98,12 +96,10 @@ def jvp(func: Callable, primals, tangents): flattened_primals, ret_idxs = _flatten_containers(primals) flattened_tangents, _ = _flatten_containers(tangents) unique_keys = list( - set( - [ - ivy.index_nest(ret_idxs, i) - for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) - ] - ) + { + ivy.index_nest(ret_idxs, i) + for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) + } ) def grad_fn(*x_in): diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 7f0924891cec0..99800f9b366e8 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -29,10 +29,10 @@ def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_ def _broadcast_pooling_helper(x, pool_dims: str = "2d", name: str = "padding"): dims = {"1d": 1, "2d": 2, "3d": 3} if isinstance(x, int): - return tuple([x for _ in range(dims[pool_dims])]) + return tuple(x for _ in range(dims[pool_dims])) if len(x) == 1: - return tuple([x[0] for _ in range(dims[pool_dims])]) + return tuple(x[0] for _ in range(dims[pool_dims])) elif len(x) == dims[pool_dims]: return tuple(x) @@ -95,7 +95,7 @@ def max_pool1d( ) else: if isinstance(padding, list) and any( - [item != 0 for sublist in padding for item in sublist] + item != 0 for sublist in padding for item in sublist ): raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" @@ -177,7 +177,7 @@ def max_pool2d( ) else: if isinstance(padding, list) and any( - [item != 0 for sublist in padding for item in sublist] + item != 0 for sublist in padding for item in sublist ): raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" @@ -268,7 +268,7 @@ def max_pool3d( ) else: if isinstance(padding, list) and any( - [item != 0 for sublist in padding for item in sublist] + item != 0 for sublist in padding for item in sublist ): raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" @@ -716,7 +716,7 @@ def fft( raise ivy.utils.exceptions.IvyError( f"Invalid data points {n}, expecting more than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") if x.dtype in [torch.int64, torch.float64, torch.complex128]: out_dtype = torch.complex128 @@ -861,7 +861,7 @@ def ifft( raise ivy.utils.exceptions.IvyError( f"Invalid data points {n}, expecting more than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") return torch.fft.ifft(x, n, dim, norm, out=out).resolve_conj() @@ -984,7 +984,7 @@ def fft2( raise ivy.utils.exceptions.IvyError( f"Invalid data points {s}, expecting s points larger than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") return torch.tensor( torch.fft.fft2(x, s, dim, norm, out=out), dtype=torch.complex128 @@ -1050,7 +1050,7 @@ def rfftn( raise ivy.utils.exceptions.IvyError( f"Invalid data points {s}, expecting s points larger than 1" ) - if norm != "backward" and norm != "ortho" and norm != "forward": + if norm not in {"backward", "ortho", "forward"}: raise ivy.utils.exceptions.IvyError(f"Unrecognized normalization mode {norm}") return torch.tensor( torch.fft.rfftn(x, s, axes, norm=norm, out=out), dtype=torch.complex128 diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index c25dfdb1ad220..589441629ccbd 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -346,7 +346,7 @@ def take_along_axis( if mode == "clip": max_index = arr.shape[axis] - 1 indices = torch.clamp(indices, 0, max_index) - elif mode == "fill" or mode == "drop": + elif mode in {"fill", "drop"}: if "float" in str(arr.dtype) or "complex" in str(arr.dtype): fill_value = float("nan") elif "uint" in str(arr.dtype): diff --git a/ivy/functional/backends/torch/experimental/sparse_array.py b/ivy/functional/backends/torch/experimental/sparse_array.py index 809ac1cd5f997..809913ac67828 100644 --- a/ivy/functional/backends/torch/experimental/sparse_array.py +++ b/ivy/functional/backends/torch/experimental/sparse_array.py @@ -102,13 +102,13 @@ def native_sparse_array_to_indices_values_and_shape(x): if x.layout == torch.sparse_coo: x = x.coalesce() return {"coo_indices": x.indices()}, x.values(), x.size() - elif x.layout == torch.sparse_csr or x.layout == torch.sparse_bsr: + elif x.layout in [torch.sparse_csr, torch.sparse_bsr]: return ( {"crow_indices": x.crow_indices(), "col_indices": x.col_indices()}, x.values(), x.size(), ) - elif x.layout == torch.sparse_bsc or x.layout == torch.sparse_csc: + elif x.layout in [torch.sparse_bsc, torch.sparse_csc]: return ( {"ccol_indices": x.crow_indices(), "row_indices": x.col_indices()}, x.values(), diff --git a/ivy/functional/backends/torch/gradients.py b/ivy/functional/backends/torch/gradients.py index af9b5e0b8a403..3434409fa0509 100644 --- a/ivy/functional/backends/torch/gradients.py +++ b/ivy/functional/backends/torch/gradients.py @@ -239,7 +239,7 @@ def _inner(*args, **kwargs): # Avoid zero gradients setting requires_grads as False if isinstance(y, tuple): - y_ones = tuple([torch.ones_like(y_) for y_ in y]) + y_ones = tuple(torch.ones_like(y_) for y_ in y) [y_.requires_grad_() for y_ in y if y_.requires_grad is False] elif y.requires_grad is False: y.requires_grad_() diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index 2d4b35c5afc60..bb69a79915748 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -102,9 +102,7 @@ def multi_head_attention( and (not is_causal or not return_attention_weights) and ( ivy.exists(in_proj_weights) - or all( - [ivy.exists(x) for x in [q_proj_weights, k_proj_weights, v_proj_weights]] - ) + or all(ivy.exists(x) for x in [q_proj_weights, k_proj_weights, v_proj_weights]) ) and len( set( diff --git a/ivy/functional/backends/torch/statistical.py b/ivy/functional/backends/torch/statistical.py index 33ef586c05b28..dc28d9a86e2e6 100644 --- a/ivy/functional/backends/torch/statistical.py +++ b/ivy/functional/backends/torch/statistical.py @@ -78,7 +78,7 @@ def mean( if axis is None: num_dims = len(x.shape) axis = list(range(num_dims)) - if axis == () or axis == []: + if axis in [(), []]: if ivy.exists(out): return ivy.inplace_update(out, x) else: diff --git a/ivy/functional/frontends/jax/numpy/dtype.py b/ivy/functional/frontends/jax/numpy/dtype.py index 966610e2464e4..8a7a1d39e5f46 100644 --- a/ivy/functional/frontends/jax/numpy/dtype.py +++ b/ivy/functional/frontends/jax/numpy/dtype.py @@ -37,7 +37,7 @@ def can_cast(from_, to, casting="safe"): "to must be one of dtype, or dtype specifier" ) - if casting == "no" or casting == "equiv": + if casting in ["no", "equiv"]: return from_ == to if casting == "safe": diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index 329c1808e1fa3..18cff733e9baf 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -12,13 +12,13 @@ def _broadcast_pooling_helper(x, pool_dims: str = "2d", name: str = "padding"): dims = {"1d": 1, "2d": 2, "3d": 3} if isinstance(x, int): - return tuple([x for _ in range(dims[pool_dims])]) + return tuple(x for _ in range(dims[pool_dims])) if len(x) == 1: - return tuple([x[0] for _ in range(dims[pool_dims])]) + return tuple(x[0] for _ in range(dims[pool_dims])) elif len(x) == dims[pool_dims]: return tuple(x) - elif len(x) != dims[pool_dims]: + else: raise ValueError( f"`{name}` must either be a single int, " f"or a tuple of {dims[pool_dims]} ints. " @@ -147,14 +147,14 @@ def avg_pool2d( kernel_pads = list(zip(kernel_size, padding)) # Padding should be less than or equal to half of kernel size - if not all([pad <= kernel / 2 for kernel, pad in kernel_pads]): + if not all(pad <= kernel / 2 for kernel, pad in kernel_pads): raise ValueError( "pad should be smaller than or equal to half of kernel size, " f"but got padding={padding}, kernel_size={kernel_size}. " ) # Figure out padding string - if all([pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in kernel_pads]): + if all(pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in kernel_pads): padding_str = "SAME" else: padding_str = "VALID" @@ -183,7 +183,7 @@ def conv1d( dilation=1, groups=1, ): - if pad_mode == "valid" or pad_mode == "same": + if pad_mode in ["valid", "same"]: padding = pad_mode elif pad_mode == "pad": padding = padding @@ -204,7 +204,7 @@ def conv2d( dilation=1, groups=1, ): - if pad_mode == "valid" or pad_mode == "same": + if pad_mode in ["valid", "same"]: padding = pad_mode elif pad_mode == "pad": padding = padding @@ -225,7 +225,7 @@ def conv3d( dilation=1, groups=1, ): - if pad_mode == "valid" or pad_mode == "same": + if pad_mode in ["valid", "same"]: padding = pad_mode elif pad_mode == "pad": padding = padding diff --git a/ivy/functional/frontends/numpy/data_type_routines/general.py b/ivy/functional/frontends/numpy/data_type_routines/general.py index 8cd3433e82a5d..73695f02f35b9 100644 --- a/ivy/functional/frontends/numpy/data_type_routines/general.py +++ b/ivy/functional/frontends/numpy/data_type_routines/general.py @@ -39,7 +39,7 @@ def can_cast(from_, to, casting="safe"): else: raise ivy.utils.exceptions.IvyException("to must be dtype or dtype specifier") - if casting == "no" or casting == "equiv": + if casting in ["no", "equiv"]: return from_ == to if casting == "safe" and to in np_frontend.numpy_casting_rules[from_]: diff --git a/ivy/functional/frontends/numpy/matrix/methods.py b/ivy/functional/frontends/numpy/matrix/methods.py index 6b49256111058..864bf94b9708b 100644 --- a/ivy/functional/frontends/numpy/matrix/methods.py +++ b/ivy/functional/frontends/numpy/matrix/methods.py @@ -32,7 +32,7 @@ def _init_data(self, data, dtype, copy): if self._data.ndim < 2: self._data = self._data.reshape((1, -1)) elif self._data.ndim > 2: - newshape = tuple([x for x in self._data.shape if x > 1]) + newshape = tuple(x for x in self._data.shape if x > 1) ndim = len(newshape) if ndim == 2: self._data = self._data.reshape(newshape) diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 361b616afe789..6687cadf7cd0d 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -192,7 +192,7 @@ def ihfft2(x, s=None, axes=(-2, -1), norm="backward", name=None): if norm == "ortho": ihfft2_result = ivy.conj(ivy.rfftn(x_, s=s, axes=axes, norm="ortho")) - if x.dtype == ivy.float32 or x.dtype == ivy.int32 or x.dtype == ivy.int64: + if x.dtype in [ivy.float32, ivy.int32, ivy.int64]: return ivy.astype(ihfft2_result, ivy.complex64) if x.dtype == ivy.float64: return ivy.astype(ihfft2_result, ivy.complex128) diff --git a/ivy/functional/frontends/paddle/linalg.py b/ivy/functional/frontends/paddle/linalg.py index acd78acb75823..23d7e51f918de 100644 --- a/ivy/functional/frontends/paddle/linalg.py +++ b/ivy/functional/frontends/paddle/linalg.py @@ -205,7 +205,7 @@ def norm(x, p="fro", axis=None, keepdim=False, name=None): raise ValueError elif p == 1: ret = ivy.sum(ivy.abs(x), axis=axis, keepdims=keepdim) - elif p == 2 or p == "fro": + elif p in [2, "fro"]: ret = ivy.matrix_norm(x, ord="fro", axis=axis, keepdims=keepdim) elif p == ivy.inf: ret = ivy.max(ivy.abs(x), axis=axis, keepdims=keepdim) diff --git a/ivy/functional/frontends/paddle/manipulation.py b/ivy/functional/frontends/paddle/manipulation.py index 2e3e24fea4c90..69e9f6c22dbb3 100644 --- a/ivy/functional/frontends/paddle/manipulation.py +++ b/ivy/functional/frontends/paddle/manipulation.py @@ -194,7 +194,7 @@ def unbind(input, axis=0): shape = list(input.shape) num_splits = shape[axis] shape.pop(axis) - return tuple([x.reshape(tuple(shape)) for x in split(input, num_splits, axis=axis)]) + return tuple(x.reshape(tuple(shape)) for x in split(input, num_splits, axis=axis)) @with_supported_dtypes( diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index 46af2f9787402..d48e270d8ccb2 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -45,7 +45,7 @@ def avg_pool1d( padding = _broadcast_pooling_helper(padding, "1d", name="padding") # Figure out padding string if all( - [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] + pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding) ): padding = "SAME" else: @@ -81,7 +81,7 @@ def avg_pool2d( padding = _broadcast_pooling_helper(padding, "2d", name="padding") # Figure out padding string if all( - [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] + pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding) ): padding = "SAME" else: diff --git a/ivy/functional/frontends/tensorflow/general_functions.py b/ivy/functional/frontends/tensorflow/general_functions.py index 01a03cedd3dc6..4464816ce98f1 100644 --- a/ivy/functional/frontends/tensorflow/general_functions.py +++ b/ivy/functional/frontends/tensorflow/general_functions.py @@ -255,8 +255,7 @@ def gather(params, indices, validate_indices=None, axis=None, batch_dims=0, name axis = batch_dims else: axis = axis % len(params.shape) - if axis < batch_dims: - axis = batch_dims + axis = max(axis, batch_dims) return ivy.gather(params, indices, axis=axis, batch_dims=batch_dims) diff --git a/ivy/functional/frontends/torch/func_wrapper.py b/ivy/functional/frontends/torch/func_wrapper.py index a9ba80dbff517..ba537854f87bd 100644 --- a/ivy/functional/frontends/torch/func_wrapper.py +++ b/ivy/functional/frontends/torch/func_wrapper.py @@ -186,7 +186,7 @@ def outputs_to_frontend_arrays_torch(*args, **kwargs): # once frontend specific backend setting is added set_default_dtype = False if not ("dtype" in kwargs and ivy.exists(kwargs["dtype"])) and all( - [not (ivy.is_array(i) or hasattr(i, "ivy_array")) for i in args] + not (ivy.is_array(i) or hasattr(i, "ivy_array")) for i in args ): if ivy.current_backend_str() == "jax": import jax diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 8f4825bd2b2f1..46f2dec6a5dea 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -17,13 +17,13 @@ def _broadcast_pooling_helper(x, pool_dims: str = "2d", name: str = "padding"): dims = {"1d": 1, "2d": 2, "3d": 3} if isinstance(x, int): - return tuple([x for _ in range(dims[pool_dims])]) + return tuple(x for _ in range(dims[pool_dims])) if len(x) == 1: - return tuple([x[0] for _ in range(dims[pool_dims])]) + return tuple(x[0] for _ in range(dims[pool_dims])) elif len(x) == dims[pool_dims]: return tuple(x) - elif len(x) != dims[pool_dims]: + else: raise ValueError( f"`{name}` must either be a single int, " f"or a tuple of {dims[pool_dims]} ints. " diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 1542c1fe575aa..6c88cd35bc5c6 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -3127,10 +3127,10 @@ def stft( def _broadcast_pooling_helper(x, pool_dims: str = "2d", name: str = "padding"): dims = {"1d": 1, "2d": 2, "3d": 3} if isinstance(x, int): - return tuple([x for _ in range(dims[pool_dims])]) + return tuple(x for _ in range(dims[pool_dims])) if len(x) == 1: - return tuple([x[0] for _ in range(dims[pool_dims])]) + return tuple(x[0] for _ in range(dims[pool_dims])) elif len(x) == dims[pool_dims]: return tuple(x) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index 2003e4094007e..f8f1694dbaf2c 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -1326,7 +1326,7 @@ def value_is_nan( x_scalar = ivy.to_scalar(x) if ivy.is_array(x) else x if x_scalar != x: return True - if include_infs and (x_scalar == INF or x_scalar == -INF): + if include_infs and (x_scalar in [INF, -INF]): return True return False diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 7b1a320a4b003..c685716fdc4cf 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -2439,9 +2439,7 @@ def _validate_max_pool_params( kernel = [1, 1, *kernel] else: kernel = [1, *kernel, 1] - new_kernel = tuple( - [dilation[i] * (kernel[i] - 1) + 1 for i in range(1, len(kernel))] - ) + new_kernel = tuple(dilation[i] * (kernel[i] - 1) + 1 for i in range(1, len(kernel))) new_kernel = tuple(dilation[i] * (kernel[i] - 1) + 1 for i in range(1, len(kernel))) if isinstance(padding, list) and len(padding) == len(new_kernel): ivy.utils.assertions.check_kernel_padding_size(new_kernel, padding) diff --git a/ivy_tests/array_api_testing/write_array_api_tests_k_flag.py b/ivy_tests/array_api_testing/write_array_api_tests_k_flag.py index 0269fd5a42f96..02d639cda2189 100644 --- a/ivy_tests/array_api_testing/write_array_api_tests_k_flag.py +++ b/ivy_tests/array_api_testing/write_array_api_tests_k_flag.py @@ -44,8 +44,8 @@ and any(f in s.lower() for f in framework_tests_to_run) ): tests_to_run += ( - ["test_" + s] - if ("#" not in s) + [f"test_{s}"] + if "#" not in s else ["test_" + s.split("#")[1].split(" ")[0]] ) else: @@ -58,7 +58,7 @@ framework_tests_to_skip[framework] = [ tts for tts in framework_tests_to_skip[framework] - if not max([tts in ttr for ttr in framework_tests_to_run[framework]]) + if not max(tts in ttr for ttr in framework_tests_to_run[framework]) ] diff --git a/ivy_tests/test_ivy/conftest.py b/ivy_tests/test_ivy/conftest.py index cb66bbf670211..6316ce57043c8 100644 --- a/ivy_tests/test_ivy/conftest.py +++ b/ivy_tests/test_ivy/conftest.py @@ -191,7 +191,7 @@ def pytest_configure(config): if "/" in backend_str: backend_str = backend_str.split("/")[0] if ( - backend_str in UNSUPPORTED_FRAEMWORK_DEVICES.keys() + backend_str in UNSUPPORTED_FRAEMWORK_DEVICES and device.partition(":")[0] in UNSUPPORTED_FRAEMWORK_DEVICES[backend_str] ): diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py index 9502ce60aaf0a..31742e5519501 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py @@ -351,9 +351,9 @@ def array_dtypes( else: pairs = ivy.promotion_table.keys() # added to avoid complex dtypes from being sampled if they are not available. - pairs = [pair for pair in pairs if all([d in available_dtypes for d in pair])] + [pair for pair in pairs if all(d in available_dtypes for d in pair)] available_dtypes = [ - pair for pair in pairs if not any([d in pair for d in unwanted_types]) + pair for pair in pairs if not any(d in pair for d in unwanted_types) ] dtypes = list(draw(st.sampled_from(available_dtypes))) if num_arrays > 2: diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 9bfc7505092b8..4b91dad3f58cf 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -430,7 +430,7 @@ def get_axis( axis = draw( st.one_of(*valid_strategies).filter( lambda x: ( - all([i != axes + j for i in x for j in x]) + all(i != axes + j for i in x for j in x) if (isinstance(x, list) and unique and allow_neg) else True ) diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py index 3b4fa7d8b941d..36beb16e72fd4 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py @@ -896,8 +896,7 @@ def test_jax_diff( axis, ): input_dtype, x = dtype_and_x - if axis > (x[0].ndim - 1): - axis = x[0].ndim - 1 + axis = min(axis, x[0].ndim - 1) helpers.test_frontend_function( input_dtypes=input_dtype, test_flags=test_flags, @@ -1508,7 +1507,7 @@ def test_jax_frexp( min_dim_size=1, max_dim_size=3, num_arrays=2, - ).filter(lambda x: all([dtype != "uint64" for dtype in x[0]])), + ).filter(lambda x: all(dtype != "uint64" for dtype in x[0])), test_with_out=st.just(False), ) def test_jax_gcd( diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py index bcde9284d6eae..46a0d22c152cd 100644 --- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py +++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py @@ -18,15 +18,13 @@ def _calculate_same_padding(kernel_size, stride, shape): padding = tuple( - [ - max( - 0, - math.ceil(((shape[i] - 1) * stride[i] + kernel_size[i] - shape[i]) / 2), - ) - for i in range(len(kernel_size)) - ] + max( + 0, + math.ceil(((shape[i] - 1) * stride[i] + kernel_size[i] - shape[i]) / 2), + ) + for i in range(len(kernel_size)) ) - if all([kernel_size[i] / 2 >= padding[i] for i in range(len(kernel_size))]): + if all(kernel_size[i] / 2 >= padding[i] for i in range(len(kernel_size))): if _is_same_padding(padding, stride, kernel_size, shape): return padding return (0, 0) @@ -34,16 +32,12 @@ def _calculate_same_padding(kernel_size, stride, shape): def _is_same_padding(padding, stride, kernel_size, input_shape): output_shape = tuple( - [ - (input_shape[i] + 2 * padding[i] - kernel_size[i]) // stride[i] + 1 - for i in range(len(padding)) - ] + (input_shape[i] + 2 * padding[i] - kernel_size[i]) // stride[i] + 1 + for i in range(len(padding)) ) return all( - [ - output_shape[i] == math.ceil(input_shape[i] / stride[i]) - for i in range(len(padding)) - ] + output_shape[i] == math.ceil(input_shape[i] / stride[i]) + for i in range(len(padding)) ) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py index b4c5650786cef..1f5dfc83c2c22 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py @@ -86,7 +86,7 @@ def _flatten_frontend_return(*, ret, backend): else: ret_np_flat = _flatten_fw_return(ret=ret, backend=backend) else: - if any([not ivy_backend.is_ivy_array(x) for x in ret]): + if any(not ivy_backend.is_ivy_array(x) for x in ret): ret_np_flat = helpers.flatten_frontend_to_np(backend=backend, ret=ret) else: ret_np_flat = _flatten_fw_return(ret=ret, backend=backend) @@ -222,11 +222,11 @@ def _test_frontend_function_ignoring_uninitialized(*args, **kwargs): frontend_ret_flat = [ np.where(where, x, np.zeros_like(x)) for x in frontend_ret_np_flat ] - if "rtol" in kwargs.keys(): + if "rtol" in kwargs: rtol = kwargs["rtol"] else: rtol = 1e-4 - if "atol" in kwargs.keys(): + if "atol" in kwargs: atol = kwargs["atol"] else: atol = 1e-6 diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py index 0df77d4cac224..d93895355b185 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py @@ -46,7 +46,7 @@ def _dtype_helper(draw): def _fn(*args, check_default=False, dtype=None): if ( check_default - and any([not (ivy.is_array(i) or hasattr(i, "ivy_array")) for i in args]) + and any(not (ivy.is_array(i) or hasattr(i, "ivy_array")) for i in args) and not ivy.exists(dtype) ): ivy.utils.assertions.check_equal( diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_inserting_data_into_arrays.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_inserting_data_into_arrays.py index 186794403dc41..a03cc96ee21a4 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_inserting_data_into_arrays.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_inserting_data_into_arrays.py @@ -51,8 +51,7 @@ def _helper_r_(draw): to_mat = draw(st.booleans()) if to_mat: elem = draw(st.sampled_from(["c", "r"])) - if dim > 2: - dim = 2 + dim = min(dim, 2) else: num = draw(st.integers(1, 3)) elem = "" diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py index 2fa46f5db1cf2..8fe30ac7ca58f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py @@ -46,7 +46,7 @@ def _pad_helper(draw): ndim = len(shape) pad_width = draw(_st_tuples_or_int(ndim, min_val=0)) kwargs = {} - if mode == "reflect" or mode == "symmetric": + if mode in ["reflect", "symmetric"]: kwargs["reflect_type"] = draw(st.sampled_from(["even", "odd"])) if mode in ["maximum", "mean", "median", "minimum"]: kwargs["stat_length"] = draw(_st_tuples_or_int(ndim, min_val=2)) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py index 2192af794be99..66acd2020de79 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py @@ -916,7 +916,7 @@ def test_tensorflow__pow__( on_device, ): input_dtype, x = dtype_and_x - if x[1].dtype == "int32" or x[1].dtype == "int64": + if x[1].dtype in ["int32", "int64"]: if x[1].ndim == 0: if x[1] < 0: x[1] *= -1 diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_func_wrapper.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_func_wrapper.py index fd7255b9aaed4..4f731ff5d246c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_func_wrapper.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_func_wrapper.py @@ -21,7 +21,7 @@ def _fn(*args, dtype=None, check_default=False, inplace=False): if ( check_default - and all([not (ivy.is_array(i) or hasattr(i, "ivy_array")) for i in args]) + and all(not (ivy.is_array(i) or hasattr(i, "ivy_array")) for i in args) and not ivy.exists(dtype) ): ivy.utils.assertions.check_equal( diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 590ee6c770cfc..40e88dbcda2cc 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -63,7 +63,7 @@ def _generate_multi_dot_dtype_and_arrays(draw): @st.composite def _get_axis_and_p(draw): p = draw(st.sampled_from(["fro", "nuc", 1, 2, -1, -2, float("inf"), -float("inf")])) - if p == "fro" or p == "nuc": + if p in ["fro", "nuc"]: max_axes_size = 2 min_axes_size = 2 else: diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py index e7f32c9b13168..a18769d922b1d 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py @@ -9,15 +9,13 @@ def calculate_same_padding(kernel_size, stride, shape): padding = tuple( - [ - max( - 0, - math.ceil(((shape[i] - 1) * stride[i] + kernel_size[i] - shape[i]) / 2), - ) - for i in range(len(kernel_size)) - ] + max( + 0, + math.ceil(((shape[i] - 1) * stride[i] + kernel_size[i] - shape[i]) / 2), + ) + for i in range(len(kernel_size)) ) - if all([kernel_size[i] / 2 >= padding[i] for i in range(len(kernel_size))]): + if all(kernel_size[i] / 2 >= padding[i] for i in range(len(kernel_size))): if is_same_padding(padding, stride, kernel_size, shape): return padding return [0] * len(shape) @@ -25,16 +23,12 @@ def calculate_same_padding(kernel_size, stride, shape): def is_same_padding(padding, stride, kernel_size, input_shape): output_shape = tuple( - [ - (input_shape[i] + 2 * padding[i] - kernel_size[i]) // stride[i] + 1 - for i in range(len(padding)) - ] + (input_shape[i] + 2 * padding[i] - kernel_size[i]) // stride[i] + 1 + for i in range(len(padding)) ) return all( - [ - output_shape[i] == math.ceil(input_shape[i] / stride[i]) - for i in range(len(padding)) - ] + output_shape[i] == math.ceil(input_shape[i] / stride[i]) + for i in range(len(padding)) ) @@ -241,7 +235,7 @@ def test_torch_avg_pool2d( # support explicit padding padding = [pad[i] for i, pad in enumerate(padding)] x_shape = x[0].shape[2:] - if not sum(padding) == 0: + if sum(padding) != 0: padding = calculate_same_padding(kernel_size, [stride[0]] * 2, x_shape) helpers.test_frontend_function( input_dtypes=input_dtype, @@ -293,7 +287,7 @@ def test_torch_avg_pool3d( # support explicit padding x_shape = x[0].shape[2:] padding = [pad[0] for pad in padding] - if not sum(padding) == 0: + if sum(padding) != 0: stride_broad = (stride[0],) * 3 if len(stride) == 1 else stride padding = calculate_same_padding(kernel_size, stride_broad, x_shape) helpers.test_frontend_function( diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index 213bcb0c14909..9d3f52db9a672 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -21,7 +21,7 @@ @st.composite def _get_axis_and_p(draw, kind="valid"): p = draw(st.sampled_from(["fro", "nuc", 1, 2, -1, -2, float("inf"), -float("inf")])) - if p == "fro" or p == "nuc": + if p in ["fro", "nuc"]: max_axes_size = 2 min_axes_size = 2 else: diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_device.py b/ivy_tests/test_ivy/test_functional/test_core/test_device.py index ec6c8b6a84351..2459f41ac1552 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_device.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_device.py @@ -460,7 +460,7 @@ def test_print_all_ivy_arrays_on_dev( del item # Apply the regex search - assert all([re.match(regex, line) for line in written]) + assert all(re.match(regex, line) for line in written) # profiler diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index 7e4b981143978..7170cb1196af0 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -1762,7 +1762,7 @@ def test_stable_pow( *, dtypes_and_xs, min_base, test_flags, backend_fw, fn_name, on_device ): dtypes, xs = dtypes_and_xs - assume(all(["bfloat16" not in x for x in dtypes])) + assume(all("bfloat16" not in x for x in dtypes)) helpers.test_function( input_dtypes=dtypes, test_flags=test_flags, diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_gradients.py b/ivy_tests/test_ivy/test_functional/test_core/test_gradients.py index 38a1553183f6e..5556747a2f82b 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_gradients.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_gradients.py @@ -239,9 +239,7 @@ def func(xs): @pytest.mark.parametrize("nth", [1, 2, 3]) def test_grad(x, dtype, func, backend_fw, nth): # ToDo: Remove skipping for paddle and jax for nth > 1 - if backend_fw == "numpy" or ( - (backend_fw == "paddle" or backend_fw == "jax") and nth > 1 - ): + if backend_fw == "numpy" or (backend_fw in ["paddle", "jax"] and nth > 1): return with BackendHandler.update_backend(backend_fw) as ivy_backend: diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_meta.py b/ivy_tests/test_ivy/test_functional/test_core/test_meta.py index 0c9a28d0d0236..a0b3cc5723e1c 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_meta.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_meta.py @@ -118,10 +118,10 @@ def outer_cost_fn(batch_in, v): ) if average_across_steps: true_weight_grad = ( - sum([sum(og) / len(og) for og in all_outer_grads]) / num_tasks + sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks ) else: - true_weight_grad = sum([og[-1] for og in all_outer_grads]) / num_tasks + true_weight_grad = sum(og[-1] for og in all_outer_grads) / num_tasks # true latent gradient true_latent_grad = np.array( @@ -482,10 +482,10 @@ def outer_cost_fn(batch_in, v): ) if average_across_steps: true_weight_grad = ( - sum([sum(og) / len(og) for og in all_outer_grads]) / num_tasks + sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks ) else: - true_weight_grad = sum([og[-1] for og in all_outer_grads]) / num_tasks + true_weight_grad = sum(og[-1] for og in all_outer_grads) / num_tasks # true cost true_cost_dict = { @@ -650,10 +650,10 @@ def outer_cost_fn(batch_in, v): ) if average_across_steps: true_weight_grad = ( - sum([sum(og) / len(og) for og in all_outer_grads]) / num_tasks + sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks ) else: - true_weight_grad = sum([og[-1] for og in all_outer_grads]) / num_tasks + true_weight_grad = sum(og[-1] for og in all_outer_grads) / num_tasks # true latent gradient true_latent_grad = np.array( @@ -816,21 +816,19 @@ def update_grad_fn(w_init, sub_batch_in, num_steps, average=False): collection_of_terms.append([t for t in terms]) if average: return [ - sum( - [ + ( + sum( t * inner_learning_rate ** (num_steps - i) for i, t in enumerate(tms) - ] + ) + * w_init.latent ) - * w_init.latent for tms in collection_of_terms ] return ( sum( - [ - t * inner_learning_rate ** (num_steps - i) - for i, t in enumerate(terms) - ] + t * inner_learning_rate ** (num_steps - i) + for i, t in enumerate(terms) ) * w_init.latent ) @@ -857,15 +855,16 @@ def update_grad_fn(w_init, sub_batch_in, num_steps, average=False): # true outer grad if average_across_steps: true_outer_grad = sum( - [ - ig.latent * ug - for ig, ug in zip( - grads, - update_grad_fn( - variables_np, sub_batch, inner_grad_steps, average=True - ), - ) - ] + ig.latent * ug + for ig, ug in zip( + grads, + update_grad_fn( + variables_np, + sub_batch, + inner_grad_steps, + average=True, + ), + ) ) / len(grads) else: true_outer_grad = ivy_backend.multiply( @@ -1058,10 +1057,10 @@ def outer_cost_fn(batch_in, v): ) if average_across_steps: true_outer_grad = ( - sum([sum(og) / len(og) for og in all_outer_grads]) / num_tasks + sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks ) else: - true_outer_grad = sum([og[-1] for og in all_outer_grads]) / num_tasks + true_outer_grad = sum(og[-1] for og in all_outer_grads) / num_tasks # true cost true_cost_dict = { diff --git a/ivy_tests/test_ivy/test_misc/test_exceptions.py b/ivy_tests/test_ivy/test_misc/test_exceptions.py index d08a3c3fffa81..68520ed026efb 100644 --- a/ivy_tests/test_ivy/test_misc/test_exceptions.py +++ b/ivy_tests/test_ivy/test_misc/test_exceptions.py @@ -30,20 +30,18 @@ def test_trace_modes(backend_fw, trace_mode, show_func_wrapper): ivy.set_backend(backend_fw) filename = "excep_out.txt" orig_stdout = sys.stdout - f = open(filename, "w") - sys.stdout = f - ivy.set_exception_trace_mode(trace_mode) - ivy.set_show_func_wrapper_trace_mode(show_func_wrapper) - x = ivy.array([]) - y = ivy.array([1.0, 3.0, 4.0]) - lines = "" - try: - ivy.divide(x, y) - except Exception as e: - print(e) - sys.stdout = orig_stdout - f.close() - + with open(filename, "w") as f: + sys.stdout = f + ivy.set_exception_trace_mode(trace_mode) + ivy.set_show_func_wrapper_trace_mode(show_func_wrapper) + x = ivy.array([]) + y = ivy.array([1.0, 3.0, 4.0]) + lines = "" + try: + ivy.divide(x, y) + except Exception as e: + print(e) + sys.stdout = orig_stdout with open(filename) as f: lines += f.read() @@ -59,16 +57,16 @@ def test_trace_modes(backend_fw, trace_mode, show_func_wrapper): if backend_fw.current_backend_str() not in ["torch", "numpy"]: assert "/dist-packages" in lines - if (trace_mode == "ivy" or trace_mode == "frontend") and not show_func_wrapper: - assert "/func_wrapper.py" not in lines - assert "/dist-packages" not in lines - - if (trace_mode == "ivy" or trace_mode == "frontend") and show_func_wrapper: - if trace_mode == "ivy": - assert "/func_wrapper.py" in lines + if trace_mode in ["ivy", "frontend"]: + if not show_func_wrapper: + assert "/func_wrapper.py" not in lines assert "/dist-packages" not in lines - if trace_mode == "frontend": - assert "/ivy/functional/backends" not in lines + + if show_func_wrapper: + if trace_mode == "frontend": + assert "/ivy/functional/backends" not in lines + else: + assert "/func_wrapper.py" in lines assert "/dist-packages" not in lines with contextlib.suppress(FileNotFoundError): diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_cp_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_cp_tensor.py index 4d35c8f115716..38107062a8127 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_cp_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_cp_tensor.py @@ -78,7 +78,7 @@ def test_cp_mode_dot(shape, rank): # matrix for mode 1 matrix = ivy.random_uniform(shape=(7, shape[1])) # vec for mode 2 - vec = ivy.random_uniform(shape=(shape[2])) + vec = ivy.random_uniform(shape=shape[2]) # Test cp_mode_dot with matrix res = ivy.CPTensor.cp_mode_dot(cp_ten, matrix, mode=1, copy=True) diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py index 3601d740e4b51..636e7814f08ef 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py @@ -35,7 +35,7 @@ def test_tucker_mode_dot(shape, ranks): # matrix for mode 1 matrix = ivy.random_uniform(shape=(7, shape[1])) # vec for mode 2 - vec = ivy.random_uniform(shape=(shape[2])) + vec = ivy.random_uniform(shape=shape[2]) # Test tucker_mode_dot with matrix res = ivy.TuckerTensor.tucker_mode_dot(tucker_ten, matrix, mode=1, copy=True) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 3d331333ce467..1dadc0d123b45 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -244,7 +244,7 @@ def get_submodule_and_function_name(test_path, is_frontend_test=False): # create a prefix str for the update query for frontend tests # (with frontend version) - test_info = dict() + test_info = {} prefix_str = "" if is_frontend_test: frontend = test_path[test_path.find("test_frontends") :].split(os.sep)[ diff --git a/scripts/setup_tests/synchronize_db.py b/scripts/setup_tests/synchronize_db.py index 1e68a842358d9..fa5d53e924b0d 100644 --- a/scripts/setup_tests/synchronize_db.py +++ b/scripts/setup_tests/synchronize_db.py @@ -131,7 +131,7 @@ def remove_empty_objects(document, key_prefix=""): def main(): all_tests = get_all_tests() - all_tests = set([process_test(test.split(",")[0].strip()) for test in all_tests]) + all_tests = {process_test(test.split(",")[0].strip()) for test in all_tests} mongo_key = sys.argv[1] cluster = MongoClient( f"mongodb+srv://deep-ivy:{mongo_key}@cluster0.qdvf8q3.mongodb.net/?retryWrites=true&w=majority" # noqa From 8ff4895740872c96c31b1b0de97066afea19d773 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 1 Nov 2023 17:51:20 +0530 Subject: [PATCH 093/978] style: Consistent style for `pytest.mark.parametrize` arguments. (#27176) --- .../test_utils/test_multiclass.py | 2 +- .../test_core/test_linalg.py | 30 ++++++++++++------- .../test_ivy/test_misc/test_assertions.py | 30 +++++++++---------- .../test_backend_handler.py | 3 +- .../test_factorized_tensor/test_cp_tensor.py | 22 +++++++------- .../test_parafac2_tensor.py | 14 ++++----- .../test_factorized_tensor/test_tr_tensor.py | 6 ++-- .../test_factorized_tensor/test_tt_tensor.py | 6 ++-- .../test_tucker_tensor.py | 16 +++++----- .../test_misc/test_handle_exceptions.py | 6 ++-- 10 files changed, 73 insertions(+), 62 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_utils/test_multiclass.py b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_utils/test_multiclass.py index 28c93f02fa8a2..f989c8d21d1d3 100644 --- a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_utils/test_multiclass.py +++ b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_utils/test_multiclass.py @@ -5,7 +5,7 @@ # not suitable for usual frontend testing @pytest.mark.parametrize( - "y, label", + ("y", "label"), [ ([1.2], "continuous"), ([1], "binary"), diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py index b1c09ac50fd19..fe2f805d4759b 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py @@ -1292,7 +1292,7 @@ def test_khatri_rao(*, data, test_flags, backend_fw, fn_name, on_device): # The following two tests have been adapted from TensorLy # https://github.com/tensorly/tensorly/blob/main/tensorly/tenalg/tests/test_khatri_rao.py -@pytest.mark.parametrize("columns, rows", [(4, [3, 4, 2])]) +@pytest.mark.parametrize(("columns", "rows"), [(4, [3, 4, 2])]) def test_khatri_rao_tensorly_1(columns, rows): columns = columns rows = rows @@ -1306,7 +1306,7 @@ def test_khatri_rao_tensorly_1(columns, rows): @pytest.mark.parametrize( - "t1, t2, true_res", + ("t1", "t2", "true_res"), [ ( [[1, 2, 3], [4, 5, 6], [7, 8, 9]], @@ -1477,7 +1477,7 @@ def test_mode_dot(*, data, test_flags, backend_fw, fn_name, on_device): @pytest.mark.parametrize( - "X, U, true_res", + ("X", "U", "true_res"), [ ( [ @@ -1545,7 +1545,7 @@ def test_multi_mode_dot(*, data, test_flags, backend_fw, fn_name, on_device): # The following 2 tests have been adapted from TensorLy # https://github.com/tensorly/tensorly/blob/main/tensorly/tenalg/tests/test_n_mode_product.py#L81 @pytest.mark.parametrize( - "X, U, true_res", + ("X", "U", "true_res"), [ ([[1, 2], [0, -1]], [[2, 1], [-1, 1]], [1]), ], @@ -1556,7 +1556,12 @@ def test_multi_mode_dot_tensorly_1(X, U, true_res): assert np.allclose(true_res, res) -@pytest.mark.parametrize("shape", ((3, 5, 4, 2),)) +@pytest.mark.parametrize( + "shape", + [ + (3, 5, 4, 2), + ], +) def test_multi_mode_dot_tensorly_2(shape): print(shape) X = ivy.ones(shape) @@ -1624,7 +1629,7 @@ def test_partial_tucker(*, data, test_flags, backend_fw, fn_name, on_device): # test adapted from TensorLy # https://github.com/tensorly/tensorly/blob/main/tensorly/decomposition/tests/test_tucker.py#L24 @pytest.mark.parametrize( - "tol_norm_2, tol_max_abs, modes, shape", + ("tol_norm_2", "tol_max_abs", "modes", "shape"), [ ( 10e-3, @@ -1775,7 +1780,9 @@ def test_tensor_train(*, data, svd, test_flags, backend_fw, fn_name, on_device): # The following 3 tests have been adapted from TensorLy # https://github.com/tensorly/tensorly/blob/main/tensorly/decomposition/tests/test_tt_decomposition.py -@pytest.mark.parametrize("shape, rank", [((3, 4, 5, 6, 2, 10), (1, 3, 3, 4, 2, 2, 1))]) +@pytest.mark.parametrize( + ("shape", "rank"), [((3, 4, 5, 6, 2, 10), (1, 3, 3, 4, 2, 2, 1))] +) def test_tensor_train_tensorly_1(shape, rank): tensor = ivy.random_uniform(shape=shape) tensor_shape = tensor.shape @@ -1800,7 +1807,9 @@ def test_tensor_train_tensorly_1(shape, rank): r_prev_iteration = r_k -@pytest.mark.parametrize("shape, rank", [((3, 4, 5, 6, 2, 10), (1, 5, 4, 3, 8, 10, 1))]) +@pytest.mark.parametrize( + ("shape", "rank"), [((3, 4, 5, 6, 2, 10), (1, 5, 4, 3, 8, 10, 1))] +) def test_tensor_train_tensorly_2(shape, rank): tensor = ivy.random_uniform(shape=shape) factors = ivy.tensor_train(tensor, rank) @@ -1821,7 +1830,7 @@ def test_tensor_train_tensorly_2(shape, rank): assert r_k <= rank[k + 1], first_error_message -@pytest.mark.parametrize("shape, rank, tol", [((3, 3, 3), (1, 3, 3, 1), (10e-5))]) +@pytest.mark.parametrize(("shape", "rank", "tol"), [((3, 3, 3), (1, 3, 3, 1), (10e-5))]) def test_tensor_train_tensorly_3(shape, rank, tol): tensor = ivy.random_uniform(shape=shape) factors = ivy.tensor_train(tensor, rank) @@ -1989,7 +1998,8 @@ def test_tucker(*, data, test_flags, backend_fw, fn_name, on_device): # test adapted from tensorly # https://github.com/tensorly/tensorly/blob/main/tensorly/decomposition/tests/test_tucker.py#L71 @pytest.mark.parametrize( - "tol_norm_2, tol_max_abs, shape, ranks", [(10e-3, 10e-1, (3, 4, 3), [2, 3, 1])] + ("tol_norm_2", "tol_max_abs", "shape", "ranks"), + [(10e-3, 10e-1, (3, 4, 3), [2, 3, 1])], ) def test_tucker_tensorly(tol_norm_2, tol_max_abs, shape, ranks): tensor = ivy.random_uniform(shape=shape) diff --git a/ivy_tests/test_ivy/test_misc/test_assertions.py b/ivy_tests/test_ivy/test_misc/test_assertions.py index 8d6484d4bacb4..986190041034d 100644 --- a/ivy_tests/test_ivy/test_misc/test_assertions.py +++ b/ivy_tests/test_ivy/test_misc/test_assertions.py @@ -64,7 +64,7 @@ def test_check_all(results): @pytest.mark.parametrize( - "args, fn, type, limit", + ("args", "fn", "type", "limit"), [ # INVALID CASES ((1, 2, 0), ivy.array, "all", [3]), @@ -198,7 +198,7 @@ def test_check_dimensions(x): @pytest.mark.parametrize( - "elem, list, inverse", + ("elem", "list", "inverse"), [ (1, [1, 2], False), ("a", [1, 2], False), @@ -240,7 +240,7 @@ def test_check_elem_in_list(elem, list, inverse): @pytest.mark.parametrize( - "x1, x2, inverse", + ("x1", "x2", "inverse"), [ (5, 10, False), (10, 10, False), @@ -283,7 +283,7 @@ def test_check_equal(x1, x2, inverse): @pytest.mark.parametrize( - "x, inverse", + ("x", "inverse"), [(None, False), ([], False), (None, True), ("abc", True)], ) def test_check_exists(x, inverse): @@ -356,7 +356,7 @@ def test_check_false(expression): @pytest.mark.parametrize( - "params, indices, axis, batch_dims", + ("params", "indices", "axis", "batch_dims"), [ # INVALID CASES (ivy.array([1, 2, 3]), ivy.array([1]), 2, 3), @@ -402,7 +402,7 @@ def test_check_gather_input_valid(params, indices, axis, batch_dims): @pytest.mark.parametrize( - "params, indices, batch_dims", + ("params", "indices", "batch_dims"), [ # INVALID CASES (ivy.array([1, 2, 3]), ivy.array([1]), 2), @@ -450,7 +450,7 @@ def test_check_gather_nd_input_valid(params, indices, batch_dims): @pytest.mark.parametrize( - "x1, x2, allow_equal", + ("x1", "x2", "allow_equal"), [ (5, 10, False), (10, 5, False), @@ -488,7 +488,7 @@ def test_check_greater(x1, x2, allow_equal): @pytest.mark.parametrize( - "var, data", + ("var", "data"), [ # INVALID CASES (ivy.array([1]), ivy.array([1, 2])), @@ -528,7 +528,7 @@ def test_check_inplace_sizes_valid(var, data): @pytest.mark.parametrize( - "x, allowed_types", + ("x", "allowed_types"), [(5.0, float), (ivy.array(5), type(ivy.array(8))), (5, float), ([5, 10], tuple)], ) def test_check_isinstance(x, allowed_types): @@ -602,7 +602,7 @@ def test_check_jax_x64_flag(dtype): @pytest.mark.parametrize( - "kernel_size, padding_size", + ("kernel_size", "padding_size"), [ # INVALID CASES (((2, 2), ((2, 2), (1, 1)))), @@ -642,7 +642,7 @@ def test_check_kernel_padding_size(kernel_size, padding_size): @pytest.mark.parametrize( - "x1, x2, allow_equal", + ("x1", "x2", "allow_equal"), [ (5, 10, False), (10, 5, False), @@ -680,7 +680,7 @@ def test_check_less(x1, x2, allow_equal): @pytest.mark.parametrize( - "x1, x2", + ("x1", "x2"), [ (ivy.array([1, 2, 3]), ivy.array([4, 5, 6])), (ivy.array([1.0, 2.0, 3.0]), ivy.array([4, 5, 6])), @@ -718,7 +718,7 @@ def test_check_same_dtype(x1, x2): @pytest.mark.parametrize( - "x1, x2", + ("x1", "x2"), [ (ivy.array([1, 2, 3]), ivy.array([[4, 5, 6], [2, 3, 1]])), (ivy.array([[1.0, 2.0], [3.0, 4.0]]), ivy.array([4, 5, 6])), @@ -757,7 +757,7 @@ def test_check_shape(x1, x2): @pytest.mark.parametrize( - "var, data", + ("var", "data"), [ # INVALID CASES ((2, 1), (1, 2, 1)), @@ -832,7 +832,7 @@ def test_check_true(expression): @pytest.mark.parametrize( - "data, segment_ids, num_segments", + ("data", "segment_ids", "num_segments"), [ # INVALID CASES (ivy.array([1, 2, 3]), ivy.array([0, 1, 0], dtype=ivy.int32), 2.0), diff --git a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py index a839509b8284a..50b5aaeb7e4c2 100644 --- a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py +++ b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py @@ -88,7 +88,8 @@ def test_current_backend(backend, array_type): @pytest.mark.parametrize( - "middle_backend,end_backend", [(a, b) for a in backends for b in backends if a != b] + ("middle_backend", "end_backend"), + [(a, b) for a in backends for b in backends if a != b], ) def test_dynamic_backend_all_combos(middle_backend, end_backend): # create an ivy array, container and native container diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_cp_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_cp_tensor.py index 38107062a8127..526ce9761b152 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_cp_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_cp_tensor.py @@ -5,7 +5,7 @@ @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [ ( (3, 4, 5), @@ -28,7 +28,7 @@ def test_cp_flip_sign(shape, rank): @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [ ( (8, 5, 6, 4), @@ -64,7 +64,7 @@ def test_cp_lstsq_grad(shape, rank): @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [ ( (5, 4, 6), @@ -101,7 +101,7 @@ def test_cp_mode_dot(shape, rank): @pytest.mark.parametrize( - "shape, rank, tol", + ("shape", "rank", "tol"), [ ( (8, 5, 6, 4), @@ -123,7 +123,7 @@ def test_cp_norm(shape, rank, tol): @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [ ( (3, 4, 5), @@ -145,7 +145,7 @@ def test_cp_normalize(shape, rank): @pytest.mark.parametrize( - "shapeU1, shapeU2, shapeU3, shapeU4, true_res, columns, rows", + ("shapeU1", "shapeU2", "shapeU3", "shapeU4", "true_res", "columns", "rows"), [ ( (3, 3), @@ -201,7 +201,7 @@ def test_cp_to_tensor(shapeU1, shapeU2, shapeU3, shapeU4, true_res, columns, row matrices.insert(i, U_i) -@pytest.mark.parametrize("shape, expected", [((2, 2), [[-2, -2], [6, 10]])]) +@pytest.mark.parametrize(("shape", "expected"), [((2, 2), [[-2, -2], [6, 10]])]) def test_cp_to_tensor_with_weights(shape, expected): A = ivy.reshape(ivy.arange(1, 5, dtype=float), shape) B = ivy.reshape(ivy.arange(5, 9, dtype=float), shape) @@ -222,7 +222,7 @@ def test_cp_to_tensor_with_weights(shape, expected): @pytest.mark.parametrize( - "shapeU1, shapeU2, shapeU3, shapeU4", [((3, 3), (4, 3), (2, 3), (2, 3))] + ("shapeU1", "shapeU2", "shapeU3", "shapeU4"), [((3, 3), (4, 3), (2, 3), (2, 3))] ) def test_cp_to_unfolded(shapeU1, shapeU2, shapeU3, shapeU4): U1 = ivy.reshape(ivy.arange(1, 10, dtype=float), shapeU1) @@ -243,7 +243,7 @@ def test_cp_to_unfolded(shapeU1, shapeU2, shapeU3, shapeU4): @pytest.mark.parametrize( - "shapeU1, shapeU2, shapeU3, shapeU4", [((3, 3), (4, 3), (2, 3), (2, 3))] + ("shapeU1", "shapeU2", "shapeU3", "shapeU4"), [((3, 3), (4, 3), (2, 3), (2, 3))] ) def test_cp_to_vec(shapeU1, shapeU2, shapeU3, shapeU4): """Test for cp_to_vec.""" @@ -267,7 +267,7 @@ def test_cp_to_vec(shapeU1, shapeU2, shapeU3, shapeU4): @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [ ( (10, 10, 10, 4), @@ -307,7 +307,7 @@ def test_validate_cp_rank(size): @pytest.mark.parametrize( - "true_shape, true_rank", + ("true_shape", "true_rank"), [ ( (3, 4, 5), diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_parafac2_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_parafac2_tensor.py index 11769f5719785..3f7b3e6bc19e7 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_parafac2_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_parafac2_tensor.py @@ -5,7 +5,7 @@ @pytest.mark.parametrize( - "weights, factors, projections, true_res", + ("weights", "factors", "projections", "true_res"), [ ( (2, 3), @@ -29,7 +29,7 @@ def test_apply_parafac2_projections(weights, factors, projections, true_res): @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [ ( [(4, 5)] * 3, @@ -54,7 +54,7 @@ def test_parafac2_normalise(shape, rank): @pytest.mark.parametrize( - "weights, factors, projections, true_res", + ("weights", "factors", "projections", "true_res"), [ ( (2, 3), @@ -82,7 +82,7 @@ def test_parafac2_to_slices(weights, factors, projections, true_res): @pytest.mark.parametrize( - "weights, factors, projections, true_res", + ("weights", "factors", "projections", "true_res"), [ ( (2, 3), @@ -103,7 +103,7 @@ def test_parafac2_to_tensor(weights, factors, projections, true_res): @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [ ( [(4, 5)] * 3, @@ -122,7 +122,7 @@ def test_parafac2_to_unfolded(shape, rank): @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [ ( [(4, 5)] * 3, @@ -140,7 +140,7 @@ def test_parafac2_to_vec(shape, rank): @pytest.mark.parametrize( - "true_shape, true_rank", + ("true_shape", "true_rank"), [ ( [(4, 5)] * 3, diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tr_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tr_tensor.py index e48dca6ccb866..d7923f83e6cf6 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tr_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tr_tensor.py @@ -5,7 +5,7 @@ @pytest.mark.parametrize( - "shape1, shape2, shape3", + ("shape1", "shape2", "shape3"), [ ( (2, 4, 3), @@ -30,7 +30,7 @@ def test_tr_to_tensor(shape1, shape2, shape3): @pytest.mark.parametrize( - "rank1, rank2", + ("rank1", "rank2"), [((2, 3, 4, 2), (2, 3, 4, 2, 3))], ) def test_validate_tr_rank(rank1, rank2): @@ -60,7 +60,7 @@ def test_validate_tr_rank(rank1, rank2): @pytest.mark.parametrize( - "true_shape, true_rank", + ("true_shape", "true_rank"), [ ( (6, 4, 5), diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tt_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tt_tensor.py index d82b9b0bdfc6d..0cd275121816c 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tt_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tt_tensor.py @@ -42,7 +42,7 @@ def test_pad_tt_rank(n_pad): @pytest.mark.parametrize( - "shape, rank", + ("shape", "rank"), [((4, 5, 4, 8, 5), (1, 3, 2, 2, 4, 1))], ) def test_tt_n_param(shape, rank): @@ -53,7 +53,7 @@ def test_tt_n_param(shape, rank): @pytest.mark.parametrize( - "n1, n2, n3, shape1, shape2, shape3", + ("n1", "n2", "n3", "shape1", "shape2", "shape3"), [(3, 4, 2, (1, 3, 2), (2, 4, 2), (2, 2, 1))], ) def test_tt_to_tensor(n1, n2, n3, shape1, shape2, shape3): @@ -109,7 +109,7 @@ def test_validate_tt_rank(coef): @pytest.mark.parametrize( - "true_shape, true_rank", + ("true_shape", "true_rank"), [ ( (3, 4, 5), diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py index 636e7814f08ef..bb03df0116781 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py @@ -4,7 +4,7 @@ import pytest -@pytest.mark.parametrize("shape, rank", [((5, 4, 6), (3, 2, 3))]) +@pytest.mark.parametrize(("shape", "rank"), [((5, 4, 6), (3, 2, 3))]) def test_n_param_tucker(shape, rank): tucker_tensor = ivy.random_tucker(shape, rank) true_n_param = ivy.prod(ivy.shape(tucker_tensor[0])) + ivy.sum( @@ -14,7 +14,7 @@ def test_n_param_tucker(shape, rank): assert np.allclose(n_param, true_n_param) -@pytest.mark.parametrize("shape, rank", [((3, 4, 5), 4)]) +@pytest.mark.parametrize(("shape", "rank"), [((3, 4, 5), 4)]) def test_tucker_copy(shape, rank): tucker_tensor = ivy.random_tucker(shape, rank) core, factors = tucker_tensor @@ -28,7 +28,7 @@ def test_tucker_copy(shape, rank): ) -@pytest.mark.parametrize("shape, ranks", [((5, 4, 6), (3, 2, 3))]) +@pytest.mark.parametrize(("shape", "ranks"), [((5, 4, 6), (3, 2, 3))]) def test_tucker_mode_dot(shape, ranks): tucker_ten = ivy.random_tucker(shape, ranks, full=False) full_tensor = ivy.TuckerTensor.tucker_to_tensor(tucker_ten) @@ -57,7 +57,7 @@ def test_tucker_mode_dot(shape, ranks): assert np.allclose(true_res, res) -@pytest.mark.parametrize("shape, rank", [((3, 4, 5), (3, 2, 4))]) +@pytest.mark.parametrize(("shape", "rank"), [((3, 4, 5), (3, 2, 4))]) def test_tucker_normalize(shape, rank): tucker_ten = ivy.random_tucker(shape, rank) core, factors = ivy.TuckerTensor.tucker_normalize(tucker_ten) @@ -71,7 +71,7 @@ def test_tucker_normalize(shape, rank): @pytest.mark.parametrize( - "X, ranks, true_res", + ("X", "ranks", "true_res"), [ ( [ @@ -107,7 +107,7 @@ def test_tucker_to_tensor(X, ranks, true_res): assert np.allclose(true_res, res) -@pytest.mark.parametrize("shape, ranks", [((4, 3, 5, 2), (2, 2, 3, 4))]) +@pytest.mark.parametrize(("shape", "ranks"), [((4, 3, 5, 2), (2, 2, 3, 4))]) def test_tucker_to_unfolded(shape, ranks): G = ivy.random_uniform(shape=shape) U = [ivy.random_uniform(shape=(ranks[i], G.shape[i])) for i in range(4)] @@ -126,7 +126,7 @@ def test_tucker_to_unfolded(shape, ranks): ) -@pytest.mark.parametrize("shape, ranks", [((4, 3, 5, 2), (2, 2, 3, 4))]) +@pytest.mark.parametrize(("shape", "ranks"), [((4, 3, 5, 2), (2, 2, 3, 4))]) def test_tucker_to_vec(shape, ranks): G = ivy.random_uniform(shape=shape) ranks = [2, 2, 3, 4] @@ -191,7 +191,7 @@ def test_validate_tucker_rank(tol): # These tests have been adapted from TensorLy # https://github.com/tensorly/tensorly/blob/main/tensorly/tests/test_tucker_tensor.py -@pytest.mark.parametrize("true_shape, true_rank", [((3, 4, 5), (3, 2, 4))]) +@pytest.mark.parametrize(("true_shape", "true_rank"), [((3, 4, 5), (3, 2, 4))]) def test_validate_tucker_tensor(true_shape, true_rank): core, factors = ivy.random_tucker(true_shape, true_rank) diff --git a/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py b/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py index 79cfe53b1a547..2c379e20e8b51 100644 --- a/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py +++ b/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py @@ -30,7 +30,7 @@ def func(e): @pytest.mark.parametrize( "e", - ( + [ IvyError, IvyNotImplementedException, IvyBroadcastShapeError, @@ -43,7 +43,7 @@ def func(e): IvyDeviceError, IvyInvalidBackendException, IvyDtypePromotionError, - ), + ], ) def test_ivy_errors_raising(e): with pytest.raises(e): @@ -55,7 +55,7 @@ def test_no_exception(): @pytest.mark.parametrize( - "e, to_be_raised", + ("e", "to_be_raised"), _non_ivy_exceptions_mapping.items(), ) def test_non_ivy_errors_mapping(e, to_be_raised): From e2b0b1d7fcd454f12bfae94b03213457460276c8 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Wed, 1 Nov 2023 20:05:31 +0300 Subject: [PATCH 094/978] refactor dynamic backend to make use of DLPack (#27191) --- docs/overview/deep_dive/backend_setting.rst | 25 +---- ivy/__init__.py | 2 +- ivy/data_classes/array/array.py | 37 +++---- ivy/functional/backends/paddle/gradients.py | 2 - ivy/functional/ivy/device.py | 3 +- ivy/utils/backend/handler.py | 102 ++++++------------ .../test_backend_handler.py | 32 +++--- 7 files changed, 67 insertions(+), 136 deletions(-) diff --git a/docs/overview/deep_dive/backend_setting.rst b/docs/overview/deep_dive/backend_setting.rst index b2be3a2f0a7a5..2b6e3d8ba2c84 100644 --- a/docs/overview/deep_dive/backend_setting.rst +++ b/docs/overview/deep_dive/backend_setting.rst @@ -70,9 +70,7 @@ To make this easier, users can make use of the dynamic backend attribute of :cla Essentially, when the user calls :code:`ivy.set_backend(, dynamic=True)`, the following steps are performed: #. First, all live objects in the current project scope are found and then filtered to only include :class:`ivy.Array`/:class:`ivy.Container` objects. -#. Then, these objects are iterated through and `converted to numpy`_ as an intermediary using the current backend. -#. Next, the global :code:`ivy.__dict__` is updated to the new backend as mentioned in the Backend Setting section above. -#. Finally, the objects are `converted from numpy`_ to the target backend using the newly set backend. +#. Then, these objects are iterated through and converted to the target backend using DLPack or numpy as an intermediary. By default, the dynamic backend attribute is set to True when you create an ivy array (e.g., :code:`x = ivy.array([1,2,3])`), but the attribute is mutable and can be changed after the ivy array is created (e.g., :code:`x.dynamic_backend= True`). Here's an example to illustrate how this works in practice: @@ -91,7 +89,7 @@ Here's an example to illustrate how this works in practice: x.data # will be a jax array y.data # will still be a torch tensor since dynamic_backend=False -In addition to setting the dynamic backend attribute for individual ivy arrays, you can also set or unset the dynamic backend feature globally for all such instances using `ivy.set_dynamic_backend`_ and `ivy.unset_dynamic_backend`_ respectively. +Setting the attribute to True converts the array to the current backend even if the backend was set with `dynamic=False`. In addition to setting the dynamic backend attribute for individual ivy arrays, you can also set or unset the dynamic backend feature globally for all such instances using `ivy.set_dynamic_backend`_ and `ivy.unset_dynamic_backend`_ respectively. Another useful feature of the dynamic backend is the `ivy.dynamic_backend_as`_ context manager. This allows you to write code like this: @@ -107,25 +105,6 @@ Another useful feature of the dynamic backend is the `ivy.dynamic_backend_as`_ c This makes it easy to define different sections of your project with different settings, without having to explicitly call :code:`ivy.set_` and :code:`ivy.unset_` etc. -There is one technical point to keep in mind when using the dynamic backend attribute. Consider the following example: - -.. code-block:: python - - ivy.set_backend("tensorflow") - arr = ivy.array([1,2,3]) - arr.dynamic_backend= False - - ivy.set_backend("torch") - - # arr.data should still be a tf.Tensor - - arr.dynamic_backend = True - - ivy.set_backend("jax") - - # This would cause a problem since the conversion goes from TF -> JAX, whereas the backend stack goes from Torch -> Jax. - -To avoid the above issue, we update the :attr:`.data` attribute to be a native array for the current set backend framework in the setter method for dynamic_backend attribute for `ivy.Array`_ and `ivy.Container`_ classes. So after the line :code:`arr.dynamic_backend = True` in the example above, then :attr:`arr.data` would be a torch.Tensor and not a tf.Tensor. Backend and Frontend Version Support ------------------------------------ diff --git a/ivy/__init__.py b/ivy/__init__.py index 6be47bf340ff1..073894dff6aa1 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -441,7 +441,7 @@ def unknown_shape(rank=None, **kwargs): def with_rank(self, rank): try: - return self.merge_with(unknown_shape(rank=rank)) + return self.merge_with(self.unknown_shape(rank=rank)) except ValueError: raise ValueError(f"Shape {self} must have rank {rank}") diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 546c2b6504175..46aa785c67afe 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -160,7 +160,7 @@ def _init(self, data, dynamic_backend=None): self._dev_str = None self._pre_repr = None self._post_repr = None - self._backend = ivy.backend + self._backend = ivy.current_backend(self._data).backend if dynamic_backend is not None: self._dynamic_backend = dynamic_backend else: @@ -188,28 +188,27 @@ def dynamic_backend(self): @dynamic_backend.setter def dynamic_backend(self, value): - from ivy.functional.ivy.gradients import _variable, _is_variable, _variable_data - from ivy.utils.backend.handler import _determine_backend_from_args + from ivy.functional.ivy.gradients import _variable + from ivy.utils.backend.handler import _data_to_new_backend, _get_backend_for_arg - if value == False: - self._backend = _determine_backend_from_args(self).backend - - else: + if value: ivy_backend = ivy.with_backend(self._backend) - to_numpy = ivy_backend.to_numpy - if _is_variable(self.data) and self._backend not in ["jax", "numpy"]: - native_data = _variable_data(self.data) - np_data = to_numpy(native_data) - new_arr = ivy.array(np_data) - self._data = _variable(new_arr).data + if ivy_backend.gradients._is_variable(self.data): + native_var = ivy_backend.gradients._variable_data( + self, + ) + data = _data_to_new_backend(native_var, ivy_backend).data + self._data = _variable(data).data else: - np_data = to_numpy(self.data) - self._data = ivy.array(np_data).data + self._data = _data_to_new_backend(self, ivy_backend).data self._backend = ivy.backend + else: + self._backend = _get_backend_for_arg(self.data.__class__.__module__).backend + self._dynamic_backend = value @property @@ -401,13 +400,7 @@ def __repr__(self): self._post_repr = ")" sig_fig = ivy.array_significant_figures dec_vals = ivy.array_decimal_values - if self.backend == "" or ivy.is_local(): - # If the array was constructed using implicit backend - backend = ivy.current_backend() - else: - # Requirerd in the case that backend is different - # from the currently set backend - backend = ivy.with_backend(self.backend) + backend = ivy.with_backend(self.backend) arr_np = backend.to_numpy(self._data) rep = ( np.array(ivy.vec_sig_fig(arr_np, sig_fig)) diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index 5a428da2517dd..33016d51a5346 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -21,8 +21,6 @@ def variable(x, /): - if ivy.is_int_dtype(x.dtype): - x = x.astype(ivy.default_float_dtype()) if not x.is_leaf: ret = x.detach() ret.stop_gradient = False diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index 1aa1c82e7dc5e..3e35a572b8799 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -33,6 +33,7 @@ from ivy.func_wrapper import ( handle_out_argument, to_native_arrays_and_back, + inputs_to_native_arrays, handle_nestable, handle_array_like_without_promotion, handle_backend_invalid, @@ -345,7 +346,7 @@ def unset_soft_device_mode() -> None: @handle_exceptions @handle_backend_invalid @handle_nestable -@to_native_arrays_and_back +@inputs_to_native_arrays def dev( x: Union[ivy.Array, ivy.NativeArray], /, *, as_native: bool = False ) -> Union[ivy.Device, ivy.NativeDevice]: diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index f07d3f2b5225c..5a58a649c19fe 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -238,11 +238,21 @@ def _handle_backend_specific_vars(target, backend): target.set_global_attr("RNG", target.functional.backends.jax.random.RNG) -def convert_from_source_backend_to_numpy(variable_ids, numpy_objs, devices): - # Dynamic Backend - from ivy.functional.ivy.gradients import _is_variable, _variable_data +def _data_to_new_backend(x, previous_backend): + device = previous_backend.dev(x.data) + try: + result = ivy.from_dlpack(previous_backend.to_dlpack(x.data)) + result = ivy.to_device(result, device) + except Exception: + np_res = previous_backend.to_numpy(x.data) + result = ivy.asarray(np_res, device=device) + return result + - def _is_var(obj): +def dynamic_backend_converter(backend_stack): + from ivy.functional.ivy.gradients import _variable + + def _is_var(obj, backend): if isinstance(obj, ivy.Container): def _map_fn(x): @@ -254,7 +264,7 @@ def _map_fn(x): ): return False - return _is_variable(x) + return backend.gradients._is_variable(x) return obj.cont_map(lambda x, kc: _map_fn(x)).cont_all_true() @@ -266,7 +276,7 @@ def _map_fn(x): "jaxlib.xla_extension", ): return False - return _is_variable(obj) + return backend.gradients._is_variable(obj) # get all ivy array instances in the project scope container_list = [ @@ -275,7 +285,8 @@ def _map_fn(x): if "ivy" in type(obj).__module__ and isinstance(obj, ivy.Container) ] cont_array_idxs = ivy.nested_argwhere( - container_list, lambda x: isinstance(x, ivy.Array) + container_list, + lambda x: isinstance(x, ivy.Array) and x.backend != ivy.current_backend_str(), ) cont_array_vals = ivy.multi_index_nest(container_list, cont_array_idxs) array_list = [ @@ -289,65 +300,30 @@ def _map_fn(x): array_list = [ arr for arr in array_list - if arr.__dict__ and arr.backend == ivy.current_backend_str() + if arr.__dict__ and arr.backend != ivy.current_backend_str() ] - arr_ids = [id(item.data) for item in array_list] - new_objs = dict(zip(arr_ids, array_list)) - new_objs = list(new_objs.values()) + new_objs = [obj for obj in array_list if obj.dynamic_backend] # now convert all ivy.Array and ivy.Container instances - # to numpy using the current backend + # to the new backend + for obj in new_objs: - if obj.dynamic_backend: - numpy_objs.append(obj) - devices.append(obj.device) - if _is_var(obj): - # add variable object id to set - variable_ids.add(id(obj)) - native_var = _variable_data(obj) - np_data = ivy.to_numpy(native_var) + # the following if condition avoids converting arrays that were already + # updated inplace i.e. are references to other arrays + if obj.backend != ivy.current_backend_str(): + backend = ivy.with_backend(obj.backend, cached=True) + if _is_var(obj, backend): + native_var = backend.gradients._variable_data(obj) + data = _data_to_new_backend(native_var, backend) + new_data = _variable(data) else: - np_data = obj.to_numpy() + new_data = _data_to_new_backend(obj, backend) if isinstance(obj, ivy.Container): - obj.cont_inplace_update(np_data) + obj.cont_inplace_update(new_data) else: - obj._data = np_data - - return variable_ids, numpy_objs, devices - - -def convert_from_numpy_to_target_backend(variable_ids, numpy_objs, devices): - # Dynamic Backend - from ivy.functional.ivy.gradients import _variable - - # convert all ivy.Array and ivy.Container instances from numpy - # to native arrays using the newly set backend - for obj, device in zip(numpy_objs, devices): - np_arr = obj.data if isinstance(obj, ivy.Array) else obj - # check if object was originally a variable - if id(obj) in variable_ids: - native_arr = ivy.nested_map( - lambda x: ivy.asarray(x, device=device), - np_arr, - include_derived=True, - shallow=False, - ) - new_data = _variable(native_arr) - - else: - new_data = ivy.nested_map( - lambda x: ivy.asarray(x, device=device), - np_arr, - include_derived=True, - shallow=False, - ) - - if isinstance(obj, ivy.Container): - obj.cont_inplace_update(new_data) - else: - obj.data = new_data.data + obj.data = new_data.data @prevent_access_locally @@ -380,16 +356,6 @@ def set_backend(backend: str, dynamic: bool = False): f"backend must be one from {list(_backend_dict.keys())}", ) - variable_ids = set() # create an empty set to store variable object ids - numpy_objs = [] # create an empty list to store numpy objects - devices = [] # create an empty list to store device strings - # created during 1st conversion step - - if dynamic: - variable_ids, numpy_objs, devices = convert_from_source_backend_to_numpy( - variable_ids, numpy_objs, devices - ) - # update the global dict with the new backend with ivy.locks["backend_setter"]: global ivy_original_dict @@ -418,7 +384,7 @@ def set_backend(backend: str, dynamic: bool = False): ivy.functional.__dict__[key] = ivy.__dict__[key] if dynamic: - convert_from_numpy_to_target_backend(variable_ids, numpy_objs, devices) + dynamic_backend_converter(backend_stack) for sub_backend in ivy.available_sub_backends: ivy.set_sub_backend(sub_backend) if verbosity.level > 0: diff --git a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py index 50b5aaeb7e4c2..f44835ada15d6 100644 --- a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py +++ b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py @@ -88,33 +88,33 @@ def test_current_backend(backend, array_type): @pytest.mark.parametrize( - ("middle_backend", "end_backend"), - [(a, b) for a in backends for b in backends if a != b], + ["middle_backend", "end_backend"], + [(a, b) for a in backends for b in backends if (a != b and "mxnet" not in [a, b])], ) def test_dynamic_backend_all_combos(middle_backend, end_backend): # create an ivy array, container and native container a = ivy.array([1, 2, 3]) b = ivy.array([4, 5, 6]) ivy_cont = ivy.Container({"w": a, "b": b}) - nativ_cont = ivy.Container( - {"w": tf.Variable([1, 2, 3]), "b": tf.Variable([4, 5, 6])} - ) # clear the backend stack after initialization of inputs ivy.unset_backend() # set dynamic_backend to false for all objects ivy_cont.dynamic_backend = False - nativ_cont.dynamic_backend = False a.dynamic_backend = False b.dynamic_backend = False # set the middle backend ivy.set_backend(middle_backend, dynamic=True) - + var_cont = ivy.Container( + { + "w": ivy.gradients._variable(ivy.array([10, 20, 30])), + "b": ivy.gradients._variable(ivy.array([40, 50, 60])), + } + ) # set dynamic_backend to true for all objects ivy_cont.dynamic_backend = True - nativ_cont.dynamic_backend = True a.dynamic_backend = True b.dynamic_backend = True @@ -124,20 +124,14 @@ def test_dynamic_backend_all_combos(middle_backend, end_backend): # add the necessary asserts to check if the data # of the objects are in the correct format - assert isinstance(a.data, ivy.current_backend().NativeArray) - assert isinstance(ivy_cont["b"].data, ivy.current_backend().NativeArray) + assert isinstance(a.data, ivy.NativeArray) + assert isinstance(ivy_cont["b"].data, ivy.NativeArray) - if end_backend == "numpy": - assert isinstance(nativ_cont["b"].data, np.ndarray) - elif end_backend == "jax": - assert isinstance(nativ_cont["b"].data, jax.Array) - - if middle_backend not in ("jax", "numpy") and end_backend not in ("jax", "numpy"): + if set(["numpy", "jax"]).intersection([middle_backend, end_backend]): # these frameworks don't support native variables - assert ivy.current_backend().gradients.is_variable(nativ_cont["b"].data) - + assert isinstance(var_cont["b"].data, ivy.NativeArray) else: - assert isinstance(nativ_cont["b"].data, ivy.current_backend().NativeArray) + assert ivy.gradients._is_variable(var_cont["b"]) def test_dynamic_backend_context_manager(): From 4626cb1c480ae2f021d92a07452cdb2d91d25795 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Wed, 1 Nov 2023 20:12:45 +0300 Subject: [PATCH 095/978] Update links in backend settings deep dive --- docs/overview/deep_dive/backend_setting.rst | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/docs/overview/deep_dive/backend_setting.rst b/docs/overview/deep_dive/backend_setting.rst index 2b6e3d8ba2c84..6a7565ec335f0 100644 --- a/docs/overview/deep_dive/backend_setting.rst +++ b/docs/overview/deep_dive/backend_setting.rst @@ -57,13 +57,12 @@ In addition, all the previously set backends can be cleared by calling :func:`iv Dynamic Backend Setting ----------------------- -.. _`ivy.set_dynamic_backend`: https://github.com/unifyai/ivy/blob/main/ivy/__init__.py#L1134. -.. _`ivy.unset_dynamic_backend`: https://github.com/unifyai/ivy/blob/main/ivy/__init__.py#L1143. -.. _`ivy.dynamic_backend_as`: https://github.com/unifyai/ivy/blob/main/ivy/__init__.py#L1174. -.. _`ivy.Array`: https://github.com/unifyai/ivy/blob/main/ivy/data_classes/array/array.py#L186. -.. _`ivy.Container`: https://github.com/unifyai/ivy/blob/main/ivy/data_classes/container/base.py#L4166. -.. _`converted to numpy`: https://github.com/unifyai/ivy/blob/main/ivy/utils/backend/handler.py#L283. -.. _`converted from numpy`: https://github.com/unifyai/ivy/blob/main/ivy/utils/backend/handler.py#L363. +.. _`ivy.set_dynamic_backend`: https://github.com/unifyai/ivy/blob/e2b0b1d7fcd454f12bfae94b03213457460276c8/ivy/__init__.py#L1150. +.. _`ivy.unset_dynamic_backend`: https://github.com/unifyai/ivy/blob/e2b0b1d7fcd454f12bfae94b03213457460276c8/ivy/__init__.py#L1187. +.. _`ivy.dynamic_backend_as`: https://github.com/unifyai/ivy/blob/e2b0b1d7fcd454f12bfae94b03213457460276c8/ivy/__init__.py#L1190. +.. _`ivy.Array`: https://github.com/unifyai/ivy/blob/e2b0b1d7fcd454f12bfae94b03213457460276c8/ivy/data_classes/array/array.py#L190. +.. _`ivy.Container`: https://github.com/unifyai/ivy/blob/e2b0b1d7fcd454f12bfae94b03213457460276c8/ivy/data_classes/container/base.py#L4285. +.. _`dynamic_backend_converter`: https://github.com/unifyai/ivy/blob/e2b0b1d7fcd454f12bfae94b03213457460276c8/ivy/utils/backend/handler.py#L252. Working with different backends in Ivy can be challenging, especially when you need to switch between backends frequently. To make this easier, users can make use of the dynamic backend attribute of :class:`ivy.Array` and :class:`ivy.Container` classes which allow you to automatically convert ivy arrays to the new backend whenever the backend is changed. From 6e1f438cbe6d3cf7077f805648920074a8f15792 Mon Sep 17 00:00:00 2001 From: Aaryan562 <82304628+Aaryan562@users.noreply.github.com> Date: Thu, 2 Nov 2023 00:04:53 +0530 Subject: [PATCH 096/978] fix(jax-backend): fix failing test for mean (#27084) --- ivy/functional/backends/jax/statistical.py | 7 +++++-- ivy/functional/backends/numpy/statistical.py | 4 +--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/ivy/functional/backends/jax/statistical.py b/ivy/functional/backends/jax/statistical.py index f4d9ad910256e..43b7d097136d9 100644 --- a/ivy/functional/backends/jax/statistical.py +++ b/ivy/functional/backends/jax/statistical.py @@ -37,7 +37,10 @@ def max( return jnp.max(a=jnp.asarray(x), axis=axis, keepdims=keepdims) -@with_unsupported_dtypes({"0.4.14 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes( + {"0.4.19 and below": "bfloat16"}, + backend_version, +) def mean( x: JaxArray, /, @@ -47,7 +50,7 @@ def mean( out: Optional[JaxArray] = None, ) -> JaxArray: axis = tuple(axis) if isinstance(axis, list) else axis - return jnp.mean(x, axis=axis, keepdims=keepdims) + return jnp.mean(x, axis=axis, keepdims=keepdims, dtype=x.dtype) def _infer_dtype(dtype: jnp.dtype): diff --git a/ivy/functional/backends/numpy/statistical.py b/ivy/functional/backends/numpy/statistical.py index 581731585c069..d63277c355bb0 100644 --- a/ivy/functional/backends/numpy/statistical.py +++ b/ivy/functional/backends/numpy/statistical.py @@ -54,9 +54,7 @@ def mean( out: Optional[np.ndarray] = None, ) -> np.ndarray: axis = tuple(axis) if isinstance(axis, list) else axis - return ivy.astype( - np.mean(x, axis=axis, keepdims=keepdims, out=out), x.dtype, copy=False - ) + return np.mean(x, axis=axis, keepdims=keepdims, dtype=x.dtype, out=out) mean.support_native_out = True From 4bf62f383f8f3a9fd742a71236c83e4dcf37757a Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Thu, 2 Nov 2023 04:54:04 +0000 Subject: [PATCH 097/978] feat: Paddle Frontend: max_pool2d (#23493) --- .../frontends/paddle/nn/functional/pooling.py | 35 ++++++++++++ .../test_nn/test_functional/test_pooling.py | 54 +++++++++++++++++++ 2 files changed, 89 insertions(+) diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index d48e270d8ccb2..9d8e02c90b86e 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -100,6 +100,41 @@ def avg_pool2d( ) +@to_ivy_arrays_and_back +@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +def max_pool2d( + x, + kernel_size, + stride=None, + padding=0, + return_mask=False, + ceil_mode=False, + data_format="NCHW", + name=None, +): + if stride is None: + stride = kernel_size + kernel_size = _broadcast_pooling_helper(kernel_size, "2d", name="kernel_size") + padding = _broadcast_pooling_helper(padding, "2d", name="padding") + + if data_format not in ["NCHW", "NHWC"]: + raise ValueError( + "Attr(data_format) should be 'NCHW' or 'NHWC'. Received " + "Attr(data_format): %s." + % str(data_format) + ) + + if data_format == "NHWC" and return_mask: + raise ValueError( + "When setting return_mask to true, data_format must be set to NCHW in" + " API:max_pool2d" + ) + + return ivy.max_pool2d( + x, kernel_size, stride, padding, data_format=data_format, ceil_mode=ceil_mode + ) + + @to_ivy_arrays_and_back @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def max_unpool1d( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py index 881592b4e143a..129f4f502591c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py @@ -276,6 +276,60 @@ def test_paddle_avg_pool2d( ) +# max_pool2d +@handle_frontend_test( + fn_tree="paddle.nn.functional.pooling.max_pool2d", + dtype_x_k_s=helpers.arrays_for_pooling( + min_dims=4, max_dims=4, min_side=2, max_side=4 + ), + ceil_mode=st.sampled_from([True]), + data_format=st.sampled_from(["NCHW", "NHWC"]), +) +def test_paddle_max_pool2d( + dtype_x_k_s, + ceil_mode, + data_format, + *, + test_flags, + backend_fw, + frontend, + fn_tree, + on_device, +): + input_dtype, x, kernel, stride, padding = dtype_x_k_s + + if data_format == "NCHW": + x[0] = x[0].reshape( + (x[0].shape[0], x[0].shape[3], x[0].shape[1], x[0].shape[2]) + ) + if len(stride) == 1: + stride = (stride[0], stride[0]) + if padding == "SAME": + padding = test_pooling_functions.calculate_same_padding( + kernel, stride, x[0].shape[2:] + ) + else: + padding = (0, 0) + + if padding == "VALID" and ceil_mode: + ceil_mode = False + + helpers.test_frontend_function( + input_dtypes=input_dtype, + test_flags=test_flags, + backend_to_test=backend_fw, + frontend=frontend, + fn_tree=fn_tree, + on_device=on_device, + x=x[0], + kernel_size=kernel, + stride=stride, + padding=padding, + ceil_mode=ceil_mode, + data_format=data_format, + ) + + # max_unpool1d @handle_frontend_test( fn_tree="paddle.nn.functional.max_unpool1d", From 5546e382df0ef6a8ae5ece7edc846b2db23fbfdc Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 2 Nov 2023 13:23:38 +0530 Subject: [PATCH 098/978] fix: the array api intelligent tests now use 4 runners (#27193) To avoid the 6 hour timeout when running the coverage workflow, also added the display-test-results job for summarizing the results similar to that in the regular intelligent tests. --- .github/workflows/array-api-det-coverage.yml | 8 ++- .../array-api-intelligent-tests-pr.yml | 65 ++++++++++++++++--- .../workflows/array-api-intelligent-tests.yml | 38 +++++++++-- .../determine_tests/array_api_det_coverage.py | 9 ++- scripts/run_tests/array_api_run_tests_pr.py | 26 ++++---- 5 files changed, 117 insertions(+), 29 deletions(-) diff --git a/.github/workflows/array-api-det-coverage.yml b/.github/workflows/array-api-det-coverage.yml index 11c5d88b7fc08..254fb28e548a0 100644 --- a/.github/workflows/array-api-det-coverage.yml +++ b/.github/workflows/array-api-det-coverage.yml @@ -9,6 +9,10 @@ permissions: jobs: determine_coverage: runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + branch: [ 1, 2, 3, 4 ] steps: - name: Checkout Ivy 🛎 uses: actions/checkout@v2 @@ -22,7 +26,7 @@ jobs: run: | pip install pydriller tqdm cd ivy - python scripts/determine_tests/array_api_det_coverage.py + python scripts/determine_tests/array_api_det_coverage.py ${{ matrix.branch }} cd .. mkdir tests cp ivy/tests.pbz2 tests/ @@ -37,4 +41,4 @@ jobs: destination-repository-name: 'Mapping' user-email: ivy.branch@lets-unify.ai commit-message: Update Array API Tests Mapping - target-branch: main + target-branch: main${{ matrix.branch }} diff --git a/.github/workflows/array-api-intelligent-tests-pr.yml b/.github/workflows/array-api-intelligent-tests-pr.yml index 5345703c5e6e1..2bb007f86ba61 100644 --- a/.github/workflows/array-api-intelligent-tests-pr.yml +++ b/.github/workflows/array-api-intelligent-tests-pr.yml @@ -5,33 +5,80 @@ on: permissions: actions: read + jobs: + display_test_results: + if: ${{ always() }} + runs-on: ubuntu-latest + needs: + - run_tests + + steps: + - name: Download all test results + uses: actions/download-artifact@v3 + + - name: Combined Test Results + run: | + find . -name "test_results_*.txt" -exec cat {} + > combined_test_results.txt + echo "Test results summary:" + cat combined_test_results.txt + + - name: New Failures Introduced + run: | + find . -name "new_failures_*.txt" -exec cat {} + > combined_failures.txt + if [ -s combined_failures.txt ] + then + echo "This PR introduces the following new failing tests:" + cat combined_failures.txt + else + echo "This PR does not introduce any new test failures! Yippee!" + fi + run_tests: runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + branch: [ 1, 2, 3, 4 ] + steps: - name: Checkout Ivy 🛎 - uses: actions/checkout@v2 + uses: actions/checkout@v3 with: path: ivy persist-credentials: false submodules: "recursive" fetch-depth: 100 - - name: Determine Tests + - name: Get Job URL + uses: Tiryoh/gha-jobid-action@v0 + id: jobs + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + job_name: ${{ github.job }} + + - name: Determine and Run Tests run: | - git clone -b main https://github.com/unifyai/Mapping.git --depth 1 + git clone -b main${{ matrix.branch }} https://github.com/unifyai/Mapping.git --depth 1 pip install pydriller cp Mapping/tests.pbz2 ivy/ cd ivy python scripts/determine_tests/array_api_determine_tests.py + python scripts/run_tests/array_api_run_tests_pr.py new_failures_${{ matrix.branch }}.txt | tee test_results_${{ matrix.branch }}.txt + cd .. continue-on-error: true - - name: Run Tests - id: tests - run: | - cd ivy - python scripts/run_tests/array_api_run_tests_pr.py - continue-on-error: true + - name: Upload test results + uses: actions/upload-artifact@v3 + with: + name: test_results_${{ matrix.branch }} + path: ivy/test_results_${{ matrix.branch }}.txt + + - name: Upload New Failures + uses: actions/upload-artifact@v3 + with: + name: new_failures_${{ matrix.branch }} + path: ivy/new_failures_${{ matrix.branch }}.txt - name: Check on failures if: steps.tests.outcome != 'success' diff --git a/.github/workflows/array-api-intelligent-tests.yml b/.github/workflows/array-api-intelligent-tests.yml index 7cb92eab1a105..576bbe9475e16 100644 --- a/.github/workflows/array-api-intelligent-tests.yml +++ b/.github/workflows/array-api-intelligent-tests.yml @@ -7,11 +7,32 @@ on: permissions: actions: read jobs: + display_test_results: + if: ${{ always() }} + runs-on: ubuntu-latest + needs: + - run_tests + + steps: + - name: Download all test results + uses: actions/download-artifact@v3 + + - name: Combined Test Results + run: | + find . -name "test_results_*.txt" -exec cat {} + > combined_test_results.txt + echo "Test results summary:" + cat combined_test_results.txt + run_tests: runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + branch: [ 1, 2, 3, 4 ] + steps: - name: Checkout Ivy 🛎 - uses: actions/checkout@v2 + uses: actions/checkout@v3 with: path: ivy persist-credentials: false @@ -29,26 +50,33 @@ jobs: env: SSH_DEPLOY_KEY: ${{ secrets.SSH_DEPLOY_KEY }} run: | - source ./ivy/scripts/shell/clone_mapping.sh main + source ./ivy/scripts/shell/clone_mapping.sh main${{ matrix.branch }} pip install pydriller pymongo cp Mapping/tests.pbz2 ivy/ cd ivy - python scripts/determine_tests/array_api_determine_tests.py + python scripts/determine_tests/array_api_determine_tests.py ${{ matrix.branch }} cd .. cp ivy/tests.pbz2 Mapping/ cd Mapping git add . git commit -m "Update Mapping" - git push origin main + git push origin main${{ matrix.branch }} continue-on-error: true - name: Run Tests id: tests run: | cd ivy - python scripts/run_tests/array_api_run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} ${{ github.run_id }} ${{ steps.jobs.outputs.html_url }} + set -o pipefail + python scripts/run_tests/array_api_run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} ${{ github.run_id }} ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt continue-on-error: true + - name: Upload test results + uses: actions/upload-artifact@v3 + with: + name: test_results_${{ matrix.branch }} + path: ivy/test_results_${{ matrix.branch }}.txt + - name: Check on failures if: steps.tests.outcome != 'success' run: exit 1 diff --git a/scripts/determine_tests/array_api_det_coverage.py b/scripts/determine_tests/array_api_det_coverage.py index b17b4775fd7cf..0315a04139e79 100644 --- a/scripts/determine_tests/array_api_det_coverage.py +++ b/scripts/determine_tests/array_api_det_coverage.py @@ -1,4 +1,5 @@ import os +import sys import subprocess from pydriller import Repository from tqdm import tqdm @@ -8,6 +9,8 @@ def main(): BACKENDS = ["numpy", "jax", "tensorflow", "torch"] + N = 4 + run_iter = int(sys.argv[1]) - 1 test_names = [] func_folder = "ivy_tests/array_api_testing/array_api_methods_to_test" @@ -77,7 +80,11 @@ def main(): x for x in directories if not (x.endswith("__pycache__") or "hypothesis" in x) ] directories = set(directories_filtered) - for test_backend in tqdm(test_names): + num_tests = len(test_names) + tests_per_run = num_tests // N + start = run_iter * tests_per_run + end = num_tests if run_iter == N - 1 else (run_iter + 1) * tests_per_run + for test_backend in tqdm(test_names[start:end]): test_name, backend = test_backend.split(",") command = ( f"docker run --rm --env IVY_BACKEND={backend} --env " diff --git a/scripts/run_tests/array_api_run_tests_pr.py b/scripts/run_tests/array_api_run_tests_pr.py index d13eddf88c2cd..72c774b85a0e6 100644 --- a/scripts/run_tests/array_api_run_tests_pr.py +++ b/scripts/run_tests/array_api_run_tests_pr.py @@ -21,18 +21,20 @@ def main(): array_api_tests_k_flag += " and not (uint16 or uint32 or uint64)" k_flag[backend] = array_api_tests_k_flag - with open("tests_to_run", "r") as f: - for line in f: - test, backend = line.split(",") - backend = backend.strip("\n") - command = f'docker run --rm --env IVY_BACKEND={backend} --env ARRAY_API_TESTS_MODULE="ivy" -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis unifyai/ivy:latest timeout 30m python3 -m pytest {test} -k "{k_flag[backend]}" --tb=short -vv' # noqa - print(f"\n{'*' * 100}") - print(f"{line[:-1]}") - print(f"{'*' * 100}\n") - sys.stdout.flush() - ret = os.system(command) - if ret != 0: - failed = True + with open(sys.argv[1], "w") as f_write: + with open("tests_to_run", "r") as f: + for line in f: + test, backend = line.split(",") + backend = backend.strip("\n") + command = f'docker run --rm --env IVY_BACKEND={backend} --env ARRAY_API_TESTS_MODULE="ivy" -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis unifyai/ivy:latest timeout 30m python3 -m pytest {test} -k "{k_flag[backend]}" --tb=short -vv' # noqa + print(f"\n{'*' * 100}") + print(f"{line[:-1]}") + print(f"{'*' * 100}\n") + sys.stdout.flush() + ret = os.system(command) + if ret != 0: + failed = True + f_write.write(line) if failed: sys.exit(1) From 1967cb292fa5736cda8082ba6ae6982386b71149 Mon Sep 17 00:00:00 2001 From: chinmay7016 <75988613+chinmay7016@users.noreply.github.com> Date: Thu, 2 Nov 2023 16:24:56 +0530 Subject: [PATCH 099/978] docs: add comma in README.md (#27184) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index bad25c53f71eb..db5af64f902c0 100644 --- a/README.md +++ b/README.md @@ -1589,7 +1589,7 @@ our journey to unify all ML frameworks! # Community -In order to achieve the ambitious goal of unifying AI we definitely need +In order to achieve the ambitious goal of unifying AI, we definitely need as many hands as possible on it! Whether you are a seasoned developer or just starting out, you\'ll find a place here! Join the Ivy community on our [Discord](https://discord.gg/sXyFF8tDtm) 👾 server, which is the From f1519ceceb4c8aa0aaa5c9216effa193c33f8d83 Mon Sep 17 00:00:00 2001 From: Bhargav Shirin Nalamati Date: Thu, 2 Nov 2023 16:47:11 +0530 Subject: [PATCH 100/978] docs: Updated sentence in README.md (#27177) Co-authored-by: guillesanbri --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index db5af64f902c0..91ae3f63899a5 100644 --- a/README.md +++ b/README.md @@ -1337,7 +1337,7 @@ train(images, classes, num_epochs, model, device, num_classes = num_classes, bat # Diving deeper -Although the [Docs](https://unify.ai/docs/ivy/) are the best place to learn more, in the next section we will take a look at how Ivy works as both a transpiler and a framework in a bit more detail to get an idea of why and where to use it. +Although the [Docs](https://unify.ai/docs/ivy/) are the best place to learn more, in the next section we will take a look at how Ivy works both as a transpiler and a framework in a bit more detail to get an idea of why and where to use it.
Ivy as a transpiler From 84092d30c6177fe2282823919ce89254b2cf35cf Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 2 Nov 2023 18:24:28 +0530 Subject: [PATCH 101/978] fix: replaced gpu device error by a warning in the numpy backend to avoid breaking the code when a gpu is passed as device, similar to the gradients functions (#27197) --- ivy/functional/backends/numpy/device.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/numpy/device.py b/ivy/functional/backends/numpy/device.py index 995280edffbca..d636feb8d8f25 100644 --- a/ivy/functional/backends/numpy/device.py +++ b/ivy/functional/backends/numpy/device.py @@ -3,6 +3,7 @@ # global import os import time +import logging import numpy as np from typing import Union, Optional, Any @@ -19,20 +20,18 @@ def dev(x: np.ndarray, /, *, as_native: bool = False) -> Union[ivy.Device, str]: def as_ivy_dev(device: str, /): if "gpu" in device: - raise ivy.utils.exceptions.IvyException( + logging.warning( "Native Numpy does not support GPU placement, consider using Jax instead" ) - elif "cpu" in device: - return ivy.Device("cpu") + return ivy.Device("cpu") def as_native_dev(device: str, /): if "gpu" in device: - raise ivy.utils.exceptions.IvyException( + logging.warning( "Native Numpy does not support GPU placement, consider using Jax instead" ) - elif "cpu" in device: - return "cpu" + return "cpu" def clear_cached_mem_on_dev(device: str, /): From 02e14d6c9bc1315b2980ad7931cc6d7d1bb84054 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 2 Nov 2023 22:03:57 +0530 Subject: [PATCH 102/978] fix: replaced pip._vendor.packaging by packaging in binaries utils as it breaks torch.compile due to a distutils hack --- ivy/utils/binaries.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/utils/binaries.py b/ivy/utils/binaries.py index 62ec97d849ccc..2a971ae00c5a7 100644 --- a/ivy/utils/binaries.py +++ b/ivy/utils/binaries.py @@ -1,7 +1,7 @@ import os import logging import json -from pip._vendor.packaging import tags +from packaging import tags from urllib import request from tqdm import tqdm From 948cc0bc14dcaca6a8c6715d7f88b429f0bd297d Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 3 Nov 2023 02:44:13 +0530 Subject: [PATCH 103/978] fix: Remove duplicate `union members` (#27203) --- ivy/data_classes/container/data_type.py | 4 ++-- ivy/data_classes/container/elementwise.py | 2 +- ivy/functional/backends/mxnet/data_type.py | 4 +--- .../sub_backends/tf_probability/experimental/random.py | 2 +- 4 files changed, 5 insertions(+), 7 deletions(-) diff --git a/ivy/data_classes/container/data_type.py b/ivy/data_classes/container/data_type.py index b5a911d5e4407..c8d7533d64006 100644 --- a/ivy/data_classes/container/data_type.py +++ b/ivy/data_classes/container/data_type.py @@ -156,7 +156,7 @@ def astype( @staticmethod def _static_broadcast_arrays( - *arrays: Union[ivy.Container, ivy.Array, ivy.NativeArray, ivy.Container], + *arrays: Union[ivy.Container, ivy.Array, ivy.NativeArray], key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, to_apply: Union[bool, ivy.Container] = True, prune_unapplied: Union[bool, ivy.Container] = False, @@ -232,7 +232,7 @@ def _static_broadcast_arrays( def broadcast_arrays( self: ivy.Container, - *arrays: Union[ivy.Container, ivy.Array, ivy.NativeArray, ivy.Container], + *arrays: Union[ivy.Container, ivy.Array, ivy.NativeArray], key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, to_apply: Union[bool, ivy.Container] = True, prune_unapplied: Union[bool, ivy.Container] = False, diff --git a/ivy/data_classes/container/elementwise.py b/ivy/data_classes/container/elementwise.py index fc417b47a0ea4..4586bf4774a32 100644 --- a/ivy/data_classes/container/elementwise.py +++ b/ivy/data_classes/container/elementwise.py @@ -9,7 +9,7 @@ class _ContainerWithElementwise(ContainerBase): @staticmethod def _static_abs( - x: Union[ivy.Container, ivy.Array, ivy.NativeArray, ivy.Container], + x: Union[ivy.Container, ivy.Array, ivy.NativeArray], /, *, key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, diff --git a/ivy/functional/backends/mxnet/data_type.py b/ivy/functional/backends/mxnet/data_type.py index 1ec0e1174ceec..74ab7b6cb71dd 100644 --- a/ivy/functional/backends/mxnet/data_type.py +++ b/ivy/functional/backends/mxnet/data_type.py @@ -129,9 +129,7 @@ def iinfo(type: Union[str, mx.ndarray.NDArray, np.dtype], /) -> np.iinfo: return np.iinfo(ivy.as_native_dtype(type)) -def result_type( - *arrays_and_dtypes: Union[(None, mx.ndarray.NDArray, None)] -) -> ivy.Dtype: +def result_type(*arrays_and_dtypes: Union[(None, mx.ndarray.NDArray)]) -> ivy.Dtype: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py index a13fb5768917d..75f4bd49eabd7 100644 --- a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py +++ b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py @@ -20,7 +20,7 @@ def beta( *, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, device: Optional[str] = None, - dtype: Optional[Union[ivy.Dtype, ivy.Dtype]] = None, + dtype: Optional[Union[ivy.Dtype]] = None, seed: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: From 78f5f4e911706f077bf6bf54dacfe8adb23c4e3a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 3 Nov 2023 02:46:32 +0530 Subject: [PATCH 104/978] refactor: Reformatted and Refactored some files. (#27160) --- ivy/data_classes/container/base.py | 50 +++++++++---------- ivy/data_classes/container/elementwise.py | 1 - .../container/experimental/elementwise.py | 3 ++ ivy/data_classes/container/general.py | 1 + .../backends/jax/experimental/activations.py | 2 +- .../backends/jax/experimental/layers.py | 2 +- ivy/functional/backends/jax/layers.py | 14 +++--- ivy/functional/backends/jax/linear_algebra.py | 2 +- ivy/functional/backends/mxnet/general.py | 2 +- .../numpy/experimental/elementwise.py | 2 +- .../backends/numpy/experimental/layers.py | 2 +- .../numpy/experimental/statistical.py | 2 +- ivy/functional/backends/numpy/sorting.py | 2 +- .../paddle/experimental/elementwise.py | 2 +- .../backends/paddle/experimental/layers.py | 2 +- .../paddle/experimental/statistical.py | 4 +- ivy/functional/backends/paddle/general.py | 2 +- .../backends/paddle/manipulation.py | 4 +- ivy/functional/backends/tensorflow/device.py | 4 +- .../tensorflow/experimental/statistical.py | 2 +- ivy/functional/backends/tensorflow/general.py | 2 +- .../backends/torch/experimental/layers.py | 4 +- .../torch/experimental/statistical.py | 2 +- ivy/functional/frontends/__init__.py | 1 + .../frontends/jax/numpy/__init__.py | 1 + .../frontends/jax/numpy/statistical.py | 2 +- ivy/functional/frontends/numpy/__init__.py | 4 +- .../frontends/numpy/broadcast/methods.py | 2 +- .../frontends/numpy/random/functions.py | 2 +- .../numpy/statistics/order_statistics.py | 2 +- ivy/functional/frontends/pandas/index.py | 2 +- ivy/functional/frontends/tensorflow/linalg.py | 4 +- ivy/functional/frontends/torch/__init__.py | 4 +- .../frontends/torch/func_wrapper.py | 18 +++---- .../indexing_slicing_joining_mutating_ops.py | 4 +- .../torch/nn/functional/vision_functions.py | 6 ++- .../frontends/torch/random_sampling.py | 4 +- ivy/functional/frontends/torch/tensor.py | 2 +- ivy/functional/ivy/elementwise.py | 1 - ivy/functional/ivy/experimental/creation.py | 1 + ivy/functional/ivy/experimental/layers.py | 8 +-- .../ivy/experimental/linear_algebra.py | 4 +- ivy/functional/ivy/general.py | 1 + ivy/functional/ivy/layers.py | 6 +-- ivy/functional/ivy/nest.py | 3 +- ivy/stateful/activations.py | 1 + ivy/utils/backend/sub_backend_handler.py | 2 + ivy/utils/binaries.py | 2 +- ivy/utils/einsum_parser.py | 1 + ivy_tests/test_ivy/helpers/multiprocessing.py | 10 ++-- .../test_jax/test_lax/test_operators.py | 4 +- .../test_numpy/test_mathematical_functions.py | 2 +- .../test_frontends/test_numpy/helpers.py | 1 + .../test_functional/test_core/test_device.py | 2 +- .../test_core/test_manipulation.py | 2 +- .../test_factorized_tensor/test_tt_tensor.py | 2 +- 56 files changed, 114 insertions(+), 110 deletions(-) diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index bb90cef214b1d..26f4623eceaca 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -151,19 +151,19 @@ def __init__( "dict_in and **kwargs cannot both be specified for ivy.Container " "constructor, please specify one or the other, not both." ) - self._config_in = dict( - print_limit=print_limit, - print_indent=print_indent, - key_length_limit=key_length_limit, - print_line_spacing=print_line_spacing, - ivyh=ivyh, - default_key_color=default_key_color, - keyword_color_dict=keyword_color_dict, - rebuild_child_containers=rebuild_child_containers, - build_callable=build_callable, - types_to_iteratively_nest=types_to_iteratively_nest, - alphabetical_keys=alphabetical_keys, - ) + self._config_in = { + "print_limit": print_limit, + "print_indent": print_indent, + "key_length_limit": key_length_limit, + "print_line_spacing": print_line_spacing, + "ivyh": ivyh, + "default_key_color": default_key_color, + "keyword_color_dict": keyword_color_dict, + "rebuild_child_containers": rebuild_child_containers, + "build_callable": build_callable, + "types_to_iteratively_nest": types_to_iteratively_nest, + "alphabetical_keys": alphabetical_keys, + } self._config = {} self.cont_inplace_update(dict_in, **self._config_in) @@ -848,6 +848,7 @@ def cont_identical( assert_and_assign if true, then the container being compared with is updated with the value in the container being compared to given that the structures are congruent + Returns ------- Boolean @@ -1009,6 +1010,7 @@ def cont_identical_structure( assert_and_assign if true, then the container being compared with is updated with the value in the container being compared to given that the structures are congruent + Returns ------- Boolean @@ -2052,9 +2054,9 @@ def cont_to_disk_as_hdf5( value_shape = value_as_np.shape this_batch_size = value_shape[0] max_bs = ( - starting_index + this_batch_size - if not max_batch_size - else max_batch_size + max_batch_size + if max_batch_size + else starting_index + this_batch_size ) if key not in h5_obj.keys(): dataset_shape = [max_bs] + list(value_shape[1:]) @@ -2130,16 +2132,14 @@ def cont_to_raw(self): Container data in its raw form. """ return_item = {} - for i, (key, value) in enumerate(self.items()): + for key, value in self.items(): if isinstance(value, ivy.Container): return_item[key] = value.cont_to_raw() elif key[0:3] == "it_" and tuple(self._types_to_iteratively_nest): - return_item = list( - [ - v.cont_to_raw() if isinstance(v, ivy.Container) else v - for v in self.values() - ] - ) + return_item = [ + v.cont_to_raw() if isinstance(v, ivy.Container) else v + for v in self.values() + ] break else: return_item[key] = value @@ -2249,7 +2249,7 @@ def cont_to_flat_list(self): ret Container as flat list. """ - return list(item for key, item in self.cont_to_iterator()) + return [item for key, item in self.cont_to_iterator()] def cont_from_flat_list(self, flat_list): """ @@ -4099,7 +4099,7 @@ def __getitem__(self, query): return_dict[key] = value[query] else: # noinspection PyBroadException - if isinstance(value, list) or isinstance(value, tuple): + if isinstance(value, (list, tuple)): if len(value) == 0: return_dict[key] = value else: diff --git a/ivy/data_classes/container/elementwise.py b/ivy/data_classes/container/elementwise.py index 4586bf4774a32..c52a3f42ba646 100644 --- a/ivy/data_classes/container/elementwise.py +++ b/ivy/data_classes/container/elementwise.py @@ -59,7 +59,6 @@ def _static_abs( b: ivy.array([4.5, 5.3, 0, 2.3]) } """ - return ContainerBase.cont_multi_map_in_function( "abs", x, diff --git a/ivy/data_classes/container/experimental/elementwise.py b/ivy/data_classes/container/experimental/elementwise.py index f334e74ef5dff..45cf7674adbb0 100644 --- a/ivy/data_classes/container/experimental/elementwise.py +++ b/ivy/data_classes/container/experimental/elementwise.py @@ -3278,6 +3278,7 @@ def static_digamma( ------- ret container including the digamma function computed element-wise + Examples -------- >>> x = ivy.Container(a=ivy.array([1, 0.5]),\ @@ -3340,6 +3341,7 @@ def digamma( ------- ret container including the digamma function computed element-wise + Examples -------- >>> x = ivy.Container(a=ivy.array([1, 0.5]), b=ivy.array([2.0, 3.0]) @@ -3400,6 +3402,7 @@ def static_sparsify_tensor( ------- ret container including the sparsified tensor computed element-wise + Examples -------- >>> x = ivy.Container( diff --git a/ivy/data_classes/container/general.py b/ivy/data_classes/container/general.py index 54c798a70d165..4dff39400124c 100644 --- a/ivy/data_classes/container/general.py +++ b/ivy/data_classes/container/general.py @@ -1019,6 +1019,7 @@ def assert_supports_inplace( ret An ivy.Container instance of True bool values if nodes of the Container \ support in-place operations, raises IvyBackendException otherwise + Examples -------- >>> ivy.set_backend("numpy") diff --git a/ivy/functional/backends/jax/experimental/activations.py b/ivy/functional/backends/jax/experimental/activations.py index d06d11a7ad8a7..f2e298cf4400c 100644 --- a/ivy/functional/backends/jax/experimental/activations.py +++ b/ivy/functional/backends/jax/experimental/activations.py @@ -35,7 +35,7 @@ def relu6( # https://github.com/google/jax/pull/14682 def custom_grad_func(x_and_grad, one): return lax.select( - (6 > x_and_grad[0]) & (x_and_grad[0] > 0), one, lax.full_like(one, 0) + (x_and_grad[0] < 6) & (x_and_grad[0] > 0), one, lax.full_like(one, 0) ) new_func = ivy.bind_custom_gradient_function(relu6_func, custom_grad_func) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index bbd16bfd92f3e..c409337ed7df0 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -991,7 +991,7 @@ def stft_1D(signals, frame_length, frame_step, fft_length, pad_end): windowed_frame = jnp.asarray(windowed_frame, dtype=dtype) fft_frame = jnp.fft.fft(windowed_frame, axis=-1) - slit = int((fft_length // 2 + 1)) + slit = int(fft_length // 2 + 1) stft_result.append(fft_frame[..., 0:slit]) stft = jnp.stack(stft_result, axis=0) diff --git a/ivy/functional/backends/jax/layers.py b/ivy/functional/backends/jax/layers.py index fe6a369ba8d24..001de4a03d0ff 100644 --- a/ivy/functional/backends/jax/layers.py +++ b/ivy/functional/backends/jax/layers.py @@ -63,7 +63,7 @@ def _get_new_padding_before_conv( dilations, x_dilations, ): - if not len(x_dilations) == x_dilations.count(1): + if len(x_dilations) != x_dilations.count(1): new_pad = [0] * dims x_shape = ( list(x.shape[1 : dims + 1]) @@ -332,11 +332,11 @@ def conv3d_transpose( def _get_filter_dataformat(dims: int = 2, filter_format: str = "channel_last"): first = True if filter_format == "channel_first" else False if dims == 1: - return "WIO" if not first else "OIW" + return "OIW" if first else "WIO" if dims == 2: - return "HWIO" if not first else "OIHW" + return "OIHW" if first else "HWIO" elif dims == 3: - return "DHWIO" if not first else "OIDHW" + return "OIDHW" if first else "DHWIO" def conv_general_dilated( @@ -361,7 +361,7 @@ def conv_general_dilated( if isinstance(padding, int): padding = [(padding, padding)] * dims filter_df = _get_filter_dataformat(dims, filter_format) - if not len(x_dilations) == x_dilations.count(1): + if len(x_dilations) != x_dilations.count(1): new_pad = [0] * dims x_shape = ( list(x.shape[1 : dims + 1]) @@ -464,7 +464,7 @@ def nms( score_threshold=float("-inf"), ): change_id = False - if score_threshold is not float("-inf") and scores is not None: + if score_threshold != float("-inf") and scores is not None: keep_idx = scores > score_threshold boxes = boxes[keep_idx] scores = scores[keep_idx] @@ -480,7 +480,7 @@ def nms( ret = jnp.array([], dtype=ivy.int64) else: areas = jnp.prod(boxes[:, 2:4] - boxes[:, :2], axis=1) - order = jnp.argsort((-1 * scores)) # get boxes with more ious first + order = jnp.argsort(-1 * scores) # get boxes with more ious first boxes = boxes[order] areas = areas[order] size = order.size diff --git a/ivy/functional/backends/jax/linear_algebra.py b/ivy/functional/backends/jax/linear_algebra.py index dea93a65efc0b..68aeb20ed53bf 100644 --- a/ivy/functional/backends/jax/linear_algebra.py +++ b/ivy/functional/backends/jax/linear_algebra.py @@ -77,7 +77,7 @@ def diagonal( axis2: int = -1, out: Optional[JaxArray] = None, ) -> JaxArray: - if not x.dtype == bool and not jnp.issubdtype(x.dtype, jnp.integer): + if x.dtype != bool and not jnp.issubdtype(x.dtype, jnp.integer): ret = jnp.diagonal(x, offset=offset, axis1=axis1, axis2=axis2) ret_edited = jnp.diagonal( x.at[1 / x == -jnp.inf].set(-jnp.inf), diff --git a/ivy/functional/backends/mxnet/general.py b/ivy/functional/backends/mxnet/general.py index c469b517c47c1..9f8e0e707cc8f 100644 --- a/ivy/functional/backends/mxnet/general.py +++ b/ivy/functional/backends/mxnet/general.py @@ -18,7 +18,7 @@ def is_native_array( if exclusive: return isinstance(x, mx.ndarray.NDArray) else: - return isinstance(x, mx.ndarray.NDArray) or isinstance(x, np.ndarray) + return isinstance(x, (mx.ndarray.NDArray, np.ndarray)) def to_numpy(x: mx.ndarray.NDArray, /, *, copy: bool = True) -> np.ndarray: diff --git a/ivy/functional/backends/numpy/experimental/elementwise.py b/ivy/functional/backends/numpy/experimental/elementwise.py index 35022ad6b77b2..ca0ecc4bad310 100644 --- a/ivy/functional/backends/numpy/experimental/elementwise.py +++ b/ivy/functional/backends/numpy/experimental/elementwise.py @@ -438,7 +438,7 @@ def digamma( def sinpi(x): y = np.abs(x) % 2.0 n = np.round(2.0 * y) - assert 0 <= n and n <= 4 + assert n >= 0 and n <= 4 if n == 0: r = np.sin(np.pi * y) diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index 91f9a73a1d087..7f11ed19c4848 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -1157,7 +1157,7 @@ def stft_1D(signals, frame_length, frame_step, fft_length, pad_end): windowed_frame = np.array(windowed_frame, dtype=dtype) fft_frame = np.fft.fft(windowed_frame, axis=-1) - slit = int((fft_length // 2 + 1)) + slit = int(fft_length // 2 + 1) stft_result.append(fft_frame[..., 0:slit]) stft = np.stack(stft_result, axis=0) diff --git a/ivy/functional/backends/numpy/experimental/statistical.py b/ivy/functional/backends/numpy/experimental/statistical.py index fcbb77c0afb37..b150ff89ff775 100644 --- a/ivy/functional/backends/numpy/experimental/statistical.py +++ b/ivy/functional/backends/numpy/experimental/statistical.py @@ -226,7 +226,7 @@ def _validate_quantile(q): if not (0.0 <= q[i] <= 1.0): return False else: - if not (np.all(0 <= q) and np.all(q <= 1)): + if not (np.all(q >= 0) and np.all(q <= 1)): return False return True diff --git a/ivy/functional/backends/numpy/sorting.py b/ivy/functional/backends/numpy/sorting.py index 1603485ee1f32..3edced7e06096 100644 --- a/ivy/functional/backends/numpy/sorting.py +++ b/ivy/functional/backends/numpy/sorting.py @@ -37,7 +37,7 @@ def sort( kind = "stable" if stable else "quicksort" ret = np.asarray(np.sort(x, axis=axis, kind=kind)) if descending: - ret = np.asarray((np.flip(ret, axis))) + ret = np.asarray(np.flip(ret, axis)) return ret diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 0c6a26baa15fe..eb49701742a33 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -348,7 +348,7 @@ def zeta( if q.dtype == paddle.float32 else paddle.to_tensor(8.0, dtype="float64") ) - assert M <= len(_BERNOULLI_COEFS) + assert len(_BERNOULLI_COEFS) >= M k = paddle.unsqueeze(ivy.arange(N, dtype=q.dtype), tuple(range(q.ndim))) S = paddle.sum((a_ + k) ** -s_, -1) Q = ivy.divide((q + N) ** (1 - x), x - 1) diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index 16a36c4979fa6..999e01ef87bf3 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -643,7 +643,7 @@ def stft_1D(signals, frame_length, frame_step, fft_length, pad_end): windowed_frame = paddle.to_tensor(windowed_frame) fft_frame = fft(windowed_frame, -1) - slit = int((fft_length // 2 + 1)) + slit = int(fft_length // 2 + 1) stft_result.append(fft_frame[..., 0:slit]) stft = paddle.to_tensor(stft_result) diff --git a/ivy/functional/backends/paddle/experimental/statistical.py b/ivy/functional/backends/paddle/experimental/statistical.py index 7cd409e19532d..7572b28f0e8d0 100644 --- a/ivy/functional/backends/paddle/experimental/statistical.py +++ b/ivy/functional/backends/paddle/experimental/statistical.py @@ -94,7 +94,7 @@ def _validate_quantile(q): if not (0.0 <= q[i] <= 1.0): return False else: - if not (paddle.all(0 <= q) and paddle.all(q <= 1)): + if not (paddle.all(q >= 0) and paddle.all(q <= 1)): return False return True @@ -607,7 +607,7 @@ def __find_cummax( if ( isinstance(x.tolist()[0], list) and len(x[0].shape) >= 1 - and (isinstance(x[0], paddle.Tensor) or isinstance(x[0], ivy.Array)) + and (isinstance(x[0], (paddle.Tensor, ivy.Array))) ): if axis >= 1: if not isinstance(x, list): diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 54150e1a75d9f..467d5ffd156f9 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -38,7 +38,7 @@ def current_backend_str() -> str: def _check_query(query): if isinstance(query, Sequence): - return not any([isinstance(item, (Sequence, paddle.Tensor)) for item in query]) + return not any(isinstance(item, (Sequence, paddle.Tensor)) for item in query) else: return True diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index f064728cc7dee..0aa0957ed9863 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -220,7 +220,7 @@ def stack( arrays = list(map(lambda x: x.cast(dtype), arrays)) first_shape = arrays[0].shape - if not all(arr.shape == first_shape for arr in arrays): + if any(arr.shape != first_shape for arr in arrays): raise Exception("Shapes of all inputs must match") if 0 in first_shape: return ivy.empty( @@ -325,7 +325,7 @@ def repeat( repeats = repeats.item() if axis is not None: - axis = axis % x.ndim + axis %= x.ndim if paddle.is_complex(x): return paddle.complex( paddle.repeat_interleave(x.real(), repeats=repeats, axis=axis), diff --git a/ivy/functional/backends/tensorflow/device.py b/ivy/functional/backends/tensorflow/device.py index d5ec902b1db09..09416a79ffc02 100644 --- a/ivy/functional/backends/tensorflow/device.py +++ b/ivy/functional/backends/tensorflow/device.py @@ -48,7 +48,7 @@ def to_device( device = as_native_dev(device) current_dev = dev(x) if not _same_device(current_dev, device): - with tf.device("/" + device.upper()): + with tf.device(f"/{device.upper()}"): return tf.identity(x) return x @@ -69,7 +69,7 @@ def as_ivy_dev(device: str, /): def as_native_dev(device: str, /): if isinstance(device, str) and "/" in device: return device - ret = "/" + ivy.Device(device).upper() + ret = f"/{ivy.Device(device).upper()}" if not ret[-1].isnumeric(): ret += ":0" return ret diff --git a/ivy/functional/backends/tensorflow/experimental/statistical.py b/ivy/functional/backends/tensorflow/experimental/statistical.py index e4f699d454aff..8bc2357b31b39 100644 --- a/ivy/functional/backends/tensorflow/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/experimental/statistical.py @@ -129,7 +129,7 @@ def _validate_quantile(q): if not (0.0 <= q[i] <= 1.0): return False else: - if not (tf.math.reduce_all(0 <= q) and tf.math.reduce_all(q <= 1)): + if not (tf.math.reduce_all(q >= 0) and tf.math.reduce_all(q <= 1)): return False return True diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 7f398216b74f0..bc70f80919cac 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -66,7 +66,7 @@ def get_item( get_item.partial_mixed_handler = lambda x, query, **kwargs: ( all(_check_query(i) for i in query) - and len(set(i.shape for i in query if ivy.is_array(i))) == 1 + and len({i.shape for i in query if ivy.is_array(i)}) == 1 if isinstance(query, tuple) else _check_query(query) ) diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 99800f9b366e8..6fd6b8e7aac07 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -749,7 +749,7 @@ def dropout( ) -> torch.Tensor: x = ivy.astype(x, dtype) if dtype else x res = torch.nn.functional.dropout(x, prob, training=training) - res = torch.multiply(res, (1.0 - prob)) if not scale else res + res = res if scale else torch.multiply(res, (1.0 - prob)) return res @@ -1155,7 +1155,7 @@ def stft_1D(signals, frame_length, frame_step, fft_length, pad_end): windowed_frame = torch.tensor(windowed_frame, dtype=dtype) fft_frame = torch.fft.fft(windowed_frame, axis=-1) - slit = int((fft_length // 2 + 1)) + slit = int(fft_length // 2 + 1) stft_result.append(fft_frame[..., 0:slit]) stft = torch.stack(stft_result, axis=0) diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index 7191a00f41227..d9757720b8e53 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -254,7 +254,7 @@ def _validate_quantile(q): if not (0.0 <= q[i] <= 1.0): return False else: - if not (torch.all(0 <= q) and torch.all(q <= 1)): + if not (torch.all(q >= 0) and torch.all(q <= 1)): return False return True diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 73478b8f9c43c..923e5029fa248 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -27,6 +27,7 @@ def fn_name_from_version_specific_fn_name(name, version): the version is inferred by importing the framework in the case of frontend version support and defaults to the highest available version in case of import failure + Returns ------- the name of the original function which will then point to the version specific diff --git a/ivy/functional/frontends/jax/numpy/__init__.py b/ivy/functional/frontends/jax/numpy/__init__.py index ec899befa786d..6972b2d115109 100644 --- a/ivy/functional/frontends/jax/numpy/__init__.py +++ b/ivy/functional/frontends/jax/numpy/__init__.py @@ -399,6 +399,7 @@ def promote_types_jax( the first of the two types to promote type2 the second of the two types to promote + Returns ------- ret diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py index dc30b31757c61..96a10c56c0053 100644 --- a/ivy/functional/frontends/jax/numpy/statistical.py +++ b/ivy/functional/frontends/jax/numpy/statistical.py @@ -516,7 +516,7 @@ def _nanquantile_unchecked( ivy.logging.warning("percentile s must be in the range [0, 100]") return [] else: - if not (ivy.all(0 <= q) and ivy.all(q <= 1)): + if not (ivy.all(q >= 0) and ivy.all(q <= 1)): ivy.logging.warning("percentile s must be in the range [0, 100]") return [] return _nanquantile_unchecked(a, q, axis, out, overwrite_input, method, keepdims) diff --git a/ivy/functional/frontends/numpy/__init__.py b/ivy/functional/frontends/numpy/__init__.py index 9ec0d91d489aa..8d2eac7018fd3 100644 --- a/ivy/functional/frontends/numpy/__init__.py +++ b/ivy/functional/frontends/numpy/__init__.py @@ -454,11 +454,11 @@ def promote_types_of_numpy_inputs( type1 = ivy.default_dtype(item=x1).strip("u123456789") type2 = ivy.default_dtype(item=x2).strip("u123456789") # Ignore type of 0-dim arrays or scalars to mimic numpy - if not x1.shape == () and x2.shape == () and type1 == type2: + if x1.shape != () and x2.shape == () and type1 == type2: x2 = ivy.asarray( x2, dtype=x1.dtype, device=ivy.default_device(item=x1, as_native=False) ) - elif x1.shape == () and not x2.shape == () and type1 == type2: + elif x1.shape == () and x2.shape != () and type1 == type2: x1 = ivy.asarray( x1, dtype=x2.dtype, device=ivy.default_device(item=x2, as_native=False) ) diff --git a/ivy/functional/frontends/numpy/broadcast/methods.py b/ivy/functional/frontends/numpy/broadcast/methods.py index fdb0d592ce97f..c029d51abdf3f 100644 --- a/ivy/functional/frontends/numpy/broadcast/methods.py +++ b/ivy/functional/frontends/numpy/broadcast/methods.py @@ -13,7 +13,7 @@ def __init__(self, *args): self._numiter = len(data) self._size = data[0].size self._data = tuple((*zip(*(ivy.flatten(i) for i in data)),)) - self._iters = tuple((iter(ivy.flatten(i)) for i in data)) + self._iters = tuple(iter(ivy.flatten(i)) for i in data) @property def shape(self): diff --git a/ivy/functional/frontends/numpy/random/functions.py b/ivy/functional/frontends/numpy/random/functions.py index be88c43ea6b25..b6d0e7a6c668a 100644 --- a/ivy/functional/frontends/numpy/random/functions.py +++ b/ivy/functional/frontends/numpy/random/functions.py @@ -355,7 +355,7 @@ def wald(mean, scale, size=None): Y = mean * ivy.square(Y) X = mean + mu_2l * (Y - ivy.sqrt(((4 * scale) * Y) + ivy.square(Y))) - condition = U <= mean / (mean + X) + condition = mean / (mean + X) >= U value1 = X value2 = mean * mean / X diff --git a/ivy/functional/frontends/numpy/statistics/order_statistics.py b/ivy/functional/frontends/numpy/statistics/order_statistics.py index 9139b4b3b422f..1484182c4f62a 100644 --- a/ivy/functional/frontends/numpy/statistics/order_statistics.py +++ b/ivy/functional/frontends/numpy/statistics/order_statistics.py @@ -38,7 +38,7 @@ def _quantile_is_valid(q): if not (0.0 <= q[i] <= 1.0): return False else: - if not (ivy.all(0 <= q) and ivy.all(q <= 1)): + if not (ivy.all(q >= 0) and ivy.all(q <= 1)): return False return True diff --git a/ivy/functional/frontends/pandas/index.py b/ivy/functional/frontends/pandas/index.py index f8cfef5e30010..44b4cefdf3def 100644 --- a/ivy/functional/frontends/pandas/index.py +++ b/ivy/functional/frontends/pandas/index.py @@ -30,7 +30,7 @@ def __init__(self, data, dtype=None, copy=False, name=None, tupleize_cols=True): @staticmethod def _tokenize_1d(x: Iterable): - return ivy.array(list(v for v, _ in enumerate(x))) + return ivy.array([v for v, _ in enumerate(x)]) def __repr__(self): if self.tokens_exist: diff --git a/ivy/functional/frontends/tensorflow/linalg.py b/ivy/functional/frontends/tensorflow/linalg.py index 6236fa4196cc7..fdbe33455fb1c 100644 --- a/ivy/functional/frontends/tensorflow/linalg.py +++ b/ivy/functional/frontends/tensorflow/linalg.py @@ -138,9 +138,7 @@ def eye(num_rows, num_columns=None, batch_shape=None, dtype=ivy.float32, name=No @with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") @to_ivy_arrays_and_back def global_norm(t_list, name=None): - l2_norms = [ - ivy.sqrt((ivy.sum(ivy.square(t)))) ** 2 for t in t_list if t is not None - ] + l2_norms = [ivy.sqrt(ivy.sum(ivy.square(t))) ** 2 for t in t_list if t is not None] return ivy.sqrt(ivy.sum(ivy.asarray(l2_norms, dtype=ivy.dtype(l2_norms[0])))) diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index 0052993309e65..e871198f0a823 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -241,11 +241,11 @@ def promote_types_of_torch_inputs( x2 = ivy.asarray(x2) type1 = ivy.default_dtype(item=x1).strip("u123456789") type2 = ivy.default_dtype(item=x2).strip("u123456789") - if not x1.shape == () and x2.shape == () and type1 == type2: + if x1.shape != () and x2.shape == () and type1 == type2: x2 = ivy.asarray( x2, dtype=x1.dtype, device=ivy.default_device(item=x1, as_native=False) ) - elif x1.shape == () and not x2.shape == () and type1 == type2: + elif x1.shape == () and x2.shape != () and type1 == type2: x1 = ivy.asarray( x1, dtype=x2.dtype, device=ivy.default_device(item=x2, as_native=False) ) diff --git a/ivy/functional/frontends/torch/func_wrapper.py b/ivy/functional/frontends/torch/func_wrapper.py index ba537854f87bd..8f97234a60295 100644 --- a/ivy/functional/frontends/torch/func_wrapper.py +++ b/ivy/functional/frontends/torch/func_wrapper.py @@ -209,10 +209,8 @@ def outputs_to_frontend_arrays_torch(*args, **kwargs): requires_grad=kwargs.get( "requires_grad", any( - [ - isinstance(i, torch_frontend.Tensor) and i.requires_grad - for i in args - ] + isinstance(i, torch_frontend.Tensor) and i.requires_grad + for i in args ), ), ) @@ -239,19 +237,15 @@ def array_fn(x): if fn.__name__ in dir(torch_frontend.creation_ops): ret.is_leaf = True elif all( - [ - not isinstance(i, torch_frontend.Tensor) - or (not i.requires_grad and not i.grad_fn) - for i in args - ] + not isinstance(i, torch_frontend.Tensor) + or (not i.requires_grad and not i.grad_fn) + for i in args ): ret.is_leaf = True else: ret.is_leaf = False # set grad_fn - if any( - [isinstance(i, torch_frontend.Tensor) and i.requires_grad for i in args] - ): + if any(isinstance(i, torch_frontend.Tensor) and i.requires_grad for i in args): # ToDo: Implement for unbind grad_fn = GradFn(fn, args) grad_fn.__self__ = ret diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py index 99e62dc19e67a..1682e5e4f1961 100644 --- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py +++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py @@ -174,7 +174,7 @@ def index_add(input, dim, index, source, *, alpha=1, out=None): while len(_to_adds) < _curr_idx: _to_adds.append(ivy.zeros_like(source[0])) _to_add_cum = ivy.get_item(source, index[0][1]) - while (1 < len(index)) and (index[0][0] == index[1][0]): + while (len(index) > 1) and (index[0][0] == index[1][0]): _to_add_cum = _to_add_cum + ivy.get_item(source, index.pop(1)[1]) index.pop(0) _to_adds.append(_to_add_cum) @@ -200,7 +200,7 @@ def index_copy(input, dim, index, source, *, out=None): _curr_idx = index[0][0] for i in range(len(res), _curr_idx): res.append(ivy.get_item(input, i)) - while (1 < len(index)) and (index[0][0] == index[1][0]): + while (len(index) > 1) and (index[0][0] == index[1][0]): index.pop(0) res.append(ivy.get_item(source, index[0][1])) index.pop(0) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index 0603d89982c0a..39e5ce64eb99d 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -415,8 +415,10 @@ def pixel_shuffle(input, upscale_factor): ivy.utils.assertions.check_equal( ivy.get_num_dims(input), 4, - message="pixel_shuffle expects 4D input, but got input with sizes " - + str(input_shape), + message=( + "pixel_shuffle expects 4D input, but got input with sizes" + f" {str(input_shape)}" + ), as_array=False, ) b = input_shape[0] diff --git a/ivy/functional/frontends/torch/random_sampling.py b/ivy/functional/frontends/torch/random_sampling.py index aaeff665c3618..9ce4b6822bc25 100644 --- a/ivy/functional/frontends/torch/random_sampling.py +++ b/ivy/functional/frontends/torch/random_sampling.py @@ -91,7 +91,7 @@ def rand( ): if not size and "size" not in kwargs: raise ValueError("Missing 1 required positional/keyword argument: size") - size = kwargs["size"] if not size else size + size = size if size else kwargs["size"] if ( isinstance(size, (list, tuple)) and len(size) == 1 @@ -191,7 +191,7 @@ def randn( ): if not size and "size" not in kwargs: raise ValueError("Missing 1 required positional/keyword argument: size") - size = kwargs["size"] if not size else size + size = size if size else kwargs["size"] if ( isinstance(size, (list, tuple)) and len(size) == 1 diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index fd4d15663ea81..d430edb6105c5 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2213,7 +2213,7 @@ def __new__(cls, iterable=()): new_iterable.append(int(item)) except Exception: raise TypeError(f"Expected int, but got {type(item)} at index {i}") - return super(Size, cls).__new__(cls, tuple(new_iterable)) + return super().__new__(cls, tuple(new_iterable)) def __init__(self, shape) -> None: self._ivy_shape = shape if isinstance(shape, ivy.Shape) else ivy.shape(shape) diff --git a/ivy/functional/ivy/elementwise.py b/ivy/functional/ivy/elementwise.py index 3e19091c21cba..6a250ecb3053f 100644 --- a/ivy/functional/ivy/elementwise.py +++ b/ivy/functional/ivy/elementwise.py @@ -123,7 +123,6 @@ def abs( b: ivy.array([4.5, 5.3, 0., 2.3]) } """ - return ivy.current_backend(x).abs(x, out=out) diff --git a/ivy/functional/ivy/experimental/creation.py b/ivy/functional/ivy/experimental/creation.py index db01811743ebb..bbda425e2ccbe 100644 --- a/ivy/functional/ivy/experimental/creation.py +++ b/ivy/functional/ivy/experimental/creation.py @@ -945,6 +945,7 @@ def random_parafac2( the decomposed tensor is returned seed seed for generating random numbers + Returns ------- ivy.Parafac2Tensor diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 6c88cd35bc5c6..b710032ecf31e 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1410,7 +1410,7 @@ def _tf_area_indices(dim_index, scale): def _tf_area_interpolate(x, size, scale, dims): - ret = ivy.zeros((x.shape[:2] + size)) + ret = ivy.zeros(x.shape[:2] + size) area = 1.0 / ivy.prod(scale) for i, ba in enumerate(x): for j, ch in enumerate(ba): @@ -1634,17 +1634,17 @@ def load_bounded(ys, xs): return a[N_idx, C_idx, y_idx, x_idx] def get_x_interp(y): - coeffs_x = tuple((load_bounded(y, x_ofs) for x_ofs in ixs_ofs)) + coeffs_x = tuple(load_bounded(y, x_ofs) for x_ofs in ixs_ofs) return _upsample_cubic_interp1d(coeffs_x, t_x) - coeffs_y = tuple((get_x_interp(y_ofs) for y_ofs in iys_ofs)) + coeffs_y = tuple(get_x_interp(y_ofs) for y_ofs in iys_ofs) result = _upsample_cubic_interp1d(coeffs_y, t_y) return result def area_interpolate(x, dims, size, scale): - ret = ivy.zeros((x.shape[:2] + size)) + ret = ivy.zeros(x.shape[:2] + size) for i, ba in enumerate(x): for j, ch in enumerate(ba): if dims == 3: diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index 10d611287f198..6eccd78b3af87 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -1160,8 +1160,8 @@ def make_svd_non_negative( H = ivy.soft_thresholding(H, eps) elif nntype == "nndsvda": avg = ivy.mean(x) - W = ivy.where(W < eps, ivy.ones(ivy.shape(W)) * avg, W) - H = ivy.where(H < eps, ivy.ones(ivy.shape(H)) * avg, H) + W = ivy.where(eps > W, ivy.ones(ivy.shape(W)) * avg, W) + H = ivy.where(eps > H, ivy.ones(ivy.shape(H)) * avg, H) else: raise ValueError( f'Invalid nntype parameter: got {nntype} instead of one of ("nndsvd",' diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index f8f1694dbaf2c..aa26607723101 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -4389,6 +4389,7 @@ def is_ivy_nested_array(x: Any, /) -> bool: ---------- x The input to check + Returns ------- ret diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index c685716fdc4cf..3ff5ea2d4dccb 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -30,7 +30,7 @@ def _get_embed_dim( pre_embed_dim = query.shape[-1] if ivy.exists(in_proj_weights): embed_dim = in_proj_weights.shape[0] / 3 - elif all([ivy.exists(x) for x in [q_proj_weights, k_proj_weights, v_proj_weights]]): + elif all(ivy.exists(x) for x in [q_proj_weights, k_proj_weights, v_proj_weights]): embed_dim = q_proj_weights.shape[0] else: embed_dim = None @@ -864,7 +864,7 @@ def multi_head_attention( if ivy.exists(in_proj_weights): q, k, v = _in_projection(query, key, value, w=in_proj_weights, b=in_proj_bias) emb_dim = int(in_proj_weights.shape[0] / 3) - elif all([ivy.exists(x) for x in [q_proj_weights, k_proj_weights, v_proj_weights]]): + elif all(ivy.exists(x) for x in [q_proj_weights, k_proj_weights, v_proj_weights]): if ivy.exists(in_proj_bias): b_q, b_k, b_v = ivy.split(in_proj_bias, num_or_size_splits=3) else: @@ -919,7 +919,7 @@ def multi_head_attention( # get attention scores attn_scores = ivy.matmul(q, ivy.swapaxes(k, 1, 2)) - scale = 1 / (head_dim**0.5) if not scale else scale + scale = scale if scale else 1 / (head_dim**0.5) attn_scores *= scale # mask the attention scores diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index a8c64db178806..cfe5a0a7f537b 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -245,7 +245,7 @@ def insert_into_nest_at_index(nest: Iterable, index: Tuple, value) -> None: >>> print(nest) [[1, 2], [3, 99, 4]] """ - if isinstance(nest, dict) or isinstance(nest, ivy.Container): + if isinstance(nest, (dict, ivy.Container)): if len(index) == 1: key = index[0] if isinstance(nest, dict): @@ -1417,6 +1417,7 @@ def nested_multi_map( The configuration for the nests. Default is the same as nest0. to_ivy convert the output to ivy_arrays. Default is ``True`` + Returns ------- nest containing the result of the function. The structure of the output is the diff --git a/ivy/stateful/activations.py b/ivy/stateful/activations.py index a2a789701a64b..635aa7dc30161 100644 --- a/ivy/stateful/activations.py +++ b/ivy/stateful/activations.py @@ -514,6 +514,7 @@ def _forward(self, x): Inputs to process *[batch_shape, d]*. alpha scaler for controlling the slope of the function for x <= 0 Default: 1.0 + Returns ------- ret diff --git a/ivy/utils/backend/sub_backend_handler.py b/ivy/utils/backend/sub_backend_handler.py index ee30f18862736..525c52ff6eacc 100644 --- a/ivy/utils/backend/sub_backend_handler.py +++ b/ivy/utils/backend/sub_backend_handler.py @@ -44,6 +44,7 @@ def fn_name_from_version_specific_fn_name(name, version): version the version of the current framework for which the support is to be provided, the version is inferred by importing the framework + Returns ------- the name of the original function which will then point to the version @@ -93,6 +94,7 @@ def fn_name_from_version_specific_fn_name_sub_backend( version the version of the current framework for which the support is to be provided, the version is inferred by importing the framework + Returns ------- the name of the original function which will then point to the version diff --git a/ivy/utils/binaries.py b/ivy/utils/binaries.py index 2a971ae00c5a7..d56ec9a9c35a3 100644 --- a/ivy/utils/binaries.py +++ b/ivy/utils/binaries.py @@ -65,7 +65,7 @@ def cleanup_and_fetch_binaries(clean=True): binaries_dict = json.load(open(binaries_path)) available_configs = json.load(open(available_configs_path)) binaries_paths = _get_paths_from_binaries(binaries_dict, folder_path) - binaries_exts = set([path.split(".")[-1] for path in binaries_paths]) + binaries_exts = {path.split(".")[-1] for path in binaries_paths} # clean up existing binaries if clean: diff --git a/ivy/utils/einsum_parser.py b/ivy/utils/einsum_parser.py index 53f3af0bba445..b7b20b89fc22c 100644 --- a/ivy/utils/einsum_parser.py +++ b/ivy/utils/einsum_parser.py @@ -238,6 +238,7 @@ def legalise_einsum_expr(*operands: Any) -> str: ------- einsum_eqn : str Legalised einsum equation + Examples -------- The operand list is simplified to reduce printing: diff --git a/ivy_tests/test_ivy/helpers/multiprocessing.py b/ivy_tests/test_ivy/helpers/multiprocessing.py index 4b832bf2c7b19..39234c644de27 100644 --- a/ivy_tests/test_ivy/helpers/multiprocessing.py +++ b/ivy_tests/test_ivy/helpers/multiprocessing.py @@ -49,7 +49,7 @@ def backend_proc(input_queue, output_queue): _, fn_module, fn_name, b = data output_queue.put( - (_get_supported_devices_dtypes_helper(b, fn_module, fn_name)) + _get_supported_devices_dtypes_helper(b, fn_module, fn_name) ) elif data[0] == "method supported dtypes": # again stage 1, calculating and returning supported dtypes @@ -69,17 +69,17 @@ def backend_proc(input_queue, output_queue): elif data[0] == "_get_type_dict_helper": _, framework, kind, is_frontend_test = data dtype_ret = _get_type_dict_helper(framework, kind, is_frontend_test) - output_queue.put((dtype_ret)) + output_queue.put(dtype_ret) elif data[0] == "num_positional_args_helper": _, fn_name, framework = data dtype_ret = num_positional_args_helper(fn_name, framework) - output_queue.put((dtype_ret)) + output_queue.put(dtype_ret) elif data[0] == "cast_filter_helper": _, d, dtype, x, current_backend = data dtype_ret = cast_filter_helper(d, dtype, x, current_backend) - output_queue.put((dtype_ret)) + output_queue.put(dtype_ret) elif data[0] == "function_backend_computation": # it's the backend return computation @@ -196,7 +196,7 @@ def backend_proc(input_queue, output_queue): xs_grad_idxs, ret_grad_idxs, ) - output_queue.put((grads_np_flat)) + output_queue.put(grads_np_flat) elif data[0] == "gradient_ground_truth_computation": # gradient testing, part where it uses ground truth diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py index a77cb042f578f..183a13d742a6c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py @@ -1250,9 +1250,7 @@ def test_jax_conv_general_dilated( ): dtype, x, filters, dilations, dim_num, stride, pad, fc, pref = x_f_d_other _assume_tf_dilation_gt_1(ivy.current_backend_str(), on_device, dilations[0]) - assume( - not (isinstance(pad, str) and not len(dilations[1]) == dilations[1].count(1)) - ) + assume(not isinstance(pad, str) or len(dilations[1]) == dilations[1].count(1)) helpers.test_frontend_function( input_dtypes=dtype, backend_to_test=backend_fw, diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py index 36beb16e72fd4..7ff6a267a5b4b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py @@ -1089,7 +1089,7 @@ def test_jax_einsum_path( kw = {} for i, x_ in enumerate(operands): dtype = dtypes[i][0] - kw["x{}".format(i)] = np.array(x_).astype(dtype) + kw[f"x{i}"] = np.array(x_).astype(dtype) test_flags.num_positional_args = len(operands) + 1 ret, ret_gt = helpers.test_frontend_function( input_dtypes=dtypes, diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py index 1f5dfc83c2c22..878ed7e54c44d 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py @@ -43,6 +43,7 @@ def _array_and_axes_permute_helper( minimum size of the dimension max_dim_size maximum size of the dimension + Returns ------- A strategy that draws an array, its dtype and axes (or None). diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_device.py b/ivy_tests/test_ivy/test_functional/test_core/test_device.py index 2459f41ac1552..016373f599baa 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_device.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_device.py @@ -258,7 +258,7 @@ def test_dev_util(backend_fw): devices = _get_possible_devices() for device in devices: # The internally called psutil.cpu_percent() has a unique behavior where it - # returns 0 as usage when run the second time in same line so simple + # returns 0 as usage when run the second time in same line so simple # assert psutil.cpu_percent() == ivy.dev_util(device) isn't possible if "cpu" in device: assert 100 >= ivy_backend.dev_util(device) >= 0 diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py index 3e3c6f3fdfba0..c008dcb0b4cf6 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py @@ -194,7 +194,7 @@ def _matricize_data(draw): ) ) ndims = len(shape) - dims = set([*range(ndims)]) + dims = {*range(ndims)} row_modes = set( draw(st.lists(helpers.ints(min_value=0, max_value=ndims - 1), min_size=1)) ) diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tt_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tt_tensor.py index 0cd275121816c..273e697b927de 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tt_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tt_tensor.py @@ -93,7 +93,7 @@ def test_tt_to_tensor(n1, n2, n3, shape1, shape2, shape3): @pytest.mark.parametrize( "coef", - [((0.2))], + [(0.2)], ) def test_validate_tt_rank(coef): tensor_shape = tuple(ivy.random.randint(5, 10, shape=(4,))) From b68e1386125f17f3b188d1a24f9bf62a3aea467d Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 3 Nov 2023 12:15:31 +0530 Subject: [PATCH 105/978] fix: set the default value of options to be None for setuptools.setup unless the TAG environment variable is set --- setup.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 2179054eec8bd..ae87c18254b6b 100644 --- a/setup.py +++ b/setup.py @@ -51,9 +51,10 @@ def _strip(line): terminate = False fixed_tag = os.environ["TAG"] if "TAG" in os.environ else None all_tags = list(tags.sys_tags()) -python_tag, plat_name = None, None +python_tag, plat_name, options = None, None, None if fixed_tag: python_tag, _, plat_name = str(fixed_tag).split("-") + options = {"bdist_wheel": {"python_tag": python_tag, "plat_name": plat_name}} all_tags = [fixed_tag] # download binaries for the tag with highest precedence @@ -131,5 +132,5 @@ def _strip(line): "License :: OSI Approved :: Apache Software License", ], license="Apache 2.0", - options={"bdist_wheel": {"python_tag": python_tag, "plat_name": plat_name}}, + options=options, ) From f887c76c08c161c8aecc284ecd74a4503c4d717f Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 3 Nov 2023 09:06:58 +0000 Subject: [PATCH 106/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index c068c12656952..8aa5a9d3427db 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit c068c12656952b7c223c9d34308efc9d58a71157 +Subproject commit 8aa5a9d3427db3a48e31b254ac9be6dc1fa5a078 From 712b7ac829cc2f13b7d86311903278d6538018d9 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 3 Nov 2023 09:07:14 +0000 Subject: [PATCH 107/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 8aa5a9d3427db..33b7a65c72885 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 8aa5a9d3427db3a48e31b254ac9be6dc1fa5a078 +Subproject commit 33b7a65c728854c811f52e954189ac53323441b4 From 2def0c8beed2c277f990db69623809fd36616990 Mon Sep 17 00:00:00 2001 From: Madjid Chergui <100947451+Madjid-CH@users.noreply.github.com> Date: Fri, 3 Nov 2023 10:28:47 +0100 Subject: [PATCH 108/978] feat: manual dtype casting removal (#22700) Co-authored-by: ivy-branch --- ivy/functional/backends/paddle/activations.py | 77 +- ivy/functional/backends/paddle/data_type.py | 24 +- ivy/functional/backends/paddle/elementwise.py | 918 +++++++----------- 3 files changed, 421 insertions(+), 598 deletions(-) diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index 3ff01325f8c31..8182b0ef2263a 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/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) diff --git a/ivy/functional/backends/paddle/data_type.py b/ivy/functional/backends/paddle/data_type.py index e358136c6d612..2aca8cca43f87 100644 --- a/ivy/functional/backends/paddle/data_type.py +++ b/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) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index b6244a0e1c254..146d7e53ee102 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -1,12 +1,17 @@ # global -from typing import Union, Optional, Tuple, Type +from typing import Union, Optional -import paddle import math +import paddle import ivy.functional.backends.paddle as paddle_backend import ivy from ivy import promote_types_of_inputs -from ivy.func_wrapper import with_unsupported_device_and_dtypes, with_supported_dtypes +from ivy.func_wrapper import ( + with_unsupported_device_and_dtypes, + with_supported_device_and_dtypes, + with_supported_dtypes, + with_unsupported_dtypes, +) # local from . import backend_version @@ -22,6 +27,10 @@ def _elementwise_helper(x1, x2): return x1, x2, x1.dtype +@with_unsupported_dtypes( + {"2.5.1 and below": ("int8", "uint8", "float16", "bool", "bfloat16")}, + backend_version, +) def add( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -31,14 +40,6 @@ def add( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [ - paddle.int8, - paddle.uint8, - paddle.float16, - paddle.bool, - paddle.bfloat16, - ]: - x1, x2 = x1.astype("float32"), x2.astype("float32") if alpha not in (1, None): x2 = paddle_backend.multiply(x2, alpha) x1, x2 = ivy.promote_types_of_inputs(x1, x2) @@ -56,10 +57,18 @@ def bitwise_xor( return paddle.bitwise_xor(x1, x2) +@with_supported_dtypes( + { + "2.5.1 and below": ( + "float16", + "float32", + "float64", + ) + }, + backend_version, +) def expm1(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [paddle.float16, paddle.float32, paddle.float64]: - return paddle.expm1(x) - return paddle_backend.subtract(paddle_backend.exp(x), 1.0).astype(x.dtype) + return paddle.expm1(x) def bitwise_invert( @@ -127,6 +136,10 @@ def equal( ) +@with_unsupported_dtypes( + {"2.5.1 and below": ("int8", "int16", "bfloat16", "unsigned", "float16")}, + backend_version, +) def less_equal( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -135,13 +148,11 @@ def less_equal( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.int8, paddle.uint8, paddle.complex64, paddle.complex128]: + if paddle.is_complex(x1): if paddle.is_complex(x1): - if paddle.is_complex(x1): - real = paddle.less_equal(x1.real(), x2.real()) - imag = paddle.less_equal(x1.imag(), x2.imag()) - return paddle_backend.logical_and(real, imag) - return paddle.less_equal(x1.astype("float32"), x2.astype("float32")) + real = paddle.less_equal(x1.real(), x2.real()) + imag = paddle.less_equal(x1.imag(), x2.imag()) + return paddle_backend.logical_and(real, imag) return paddle.less_equal(x1, x2) @@ -157,95 +168,57 @@ def bitwise_and( return paddle.bitwise_and(x1, x2) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "complex")}, + backend_version, +) def ceil(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - x_dtype = x.dtype - if x_dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x): - return paddle.complex(paddle.ceil(x.real()), paddle.ceil(x.imag())) - return paddle.ceil(x.astype("float32")).astype(x_dtype) - elif x_dtype == paddle.int64: - return paddle.ceil(x.astype("float64")).astype(x_dtype) + if paddle.is_complex(x): + return paddle.complex(paddle.ceil(x.real()), paddle.ceil(x.imag())) return paddle.ceil(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float16", "float32", "float64", "complex")}, + backend_version, +) def floor(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - x_dtype = x.dtype - if x_dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x): - return paddle.complex(paddle.floor(x.real()), paddle.floor(x.imag())) - return paddle.floor(x.astype("float32")).astype(x_dtype) - elif x_dtype == paddle.int64: - return paddle.floor(x.astype("float64")).astype(x_dtype) + if paddle.is_complex(x): + return paddle.complex(paddle.floor(x.real()), paddle.floor(x.imag())) return paddle.floor(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ( + "float32", + "float64", + ) + } + }, backend_version, ) def asin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - ret_dtype = x.dtype - return paddle.asin(x.astype("float32")).astype(ret_dtype) - if paddle.is_complex(x): - asinh_iz = paddle_backend.asinh(paddle.complex(-x.imag(), x.real())) - return paddle.complex(asinh_iz.imag(), -asinh_iz.real()) return paddle.asin(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_dtypes( + { + "2.5.2 and below": ( + "float16", + "float32", + "float64", + ) + }, backend_version, ) def asinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - ret_dtype = x.dtype - return paddle.asinh(x.astype("float32")).astype(ret_dtype) - if paddle.is_complex(x): - # From https://github.com/python/cpython/blob/39ef93edb9802dccdb6555d4209ac2e60875a011/Modules/cmathmodule.c#L276 # noqa - s1 = paddle_backend.sqrt(paddle.complex(1 + x.imag(), -x.real())) - s2 = paddle_backend.sqrt(paddle.complex(1 - x.imag(), x.real())) - return paddle.complex( - paddle.asinh(s1.real() * s2.imag() - s2.real() * s1.imag()), - paddle.atan2(x.imag(), s1.real() * s2.real() - s1.imag() * s2.imag()), - ) return paddle.asinh(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("float16", "float32", "float64", "complex")}}, backend_version, ) def sign( @@ -255,50 +228,12 @@ def sign( np_variant: Optional[bool] = True, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - paddle.bfloat16, - paddle.bool, - ]: - return paddle.sgn(x.astype("float32")).astype(x.dtype) return paddle.sgn(x) -# TODO: Remove `float16` from the list once paddle add it's supporting kernel to `CPU`. -def _determine_sqrt_dtype_cast( - dtype: Type[paddle.Tensor], -) -> Tuple[Optional[str], Optional[str]]: - """ - Determine the appropriate casting dtype for sqrt operations. - - Returns: - (intermediate_dtype, output_dtype) - """ - cast_and_return_float32_dtype = { - paddle.int8, - paddle.int16, - paddle.int32, - paddle.uint8, - paddle.bool, - } - - if dtype in cast_and_return_float32_dtype: - return "float32", "float32" - elif dtype == paddle.int64: - return "float64", "float64" - elif dtype == paddle.float16: - return "float32", "float16" - elif dtype == paddle.bfloat16: - return "float32", "bfloat16" - else: - return None, None - - +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "complex")}, backend_version +) def sqrt(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: """Calculate the square root with type handling.""" if paddle.is_complex(x): @@ -307,116 +242,85 @@ def sqrt(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. paddle.cos(angle / 2), paddle.sin(angle / 2) ) * paddle.sqrt(paddle.abs(x)) - if x.dtype in {paddle.float32, paddle.float64}: - return paddle.sqrt(x) - - intermediate_dtype, output_dtype = _determine_sqrt_dtype_cast(x.dtype) - if intermediate_dtype: - result = paddle.sqrt(x.astype(intermediate_dtype)) - return result.astype(output_dtype) - - raise ValueError(f"Unsupported data type for sqrt: {x.dtype}") + return paddle.sqrt(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ( + "float32", + "float64", + ) + } + }, backend_version, ) def cosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - ret_dtype = x.dtype - return paddle.cosh(x.astype("float32")).astype(ret_dtype) - if paddle.is_complex(x): - re = x.real() - im = x.imag() - return paddle.complex( - paddle.cosh(re) * paddle.cos(im), paddle.sinh(re) * paddle.sin(im) - ) return paddle.cosh(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "complex")}, backend_version +) def log10(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x): - base = paddle.to_tensor(10.0).squeeze() - return paddle_backend.divide( - paddle_backend.log(x), paddle_backend.log(base) - ).astype(x.dtype) - return paddle.log10(x.astype("float32")).astype(x.dtype) + if paddle.is_complex(x): + base = paddle.to_tensor(10.0).squeeze() + return paddle_backend.divide( + paddle_backend.log(x), paddle_backend.log(base) + ).astype(x.dtype) return paddle.log10(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "complex")}, + backend_version, +) def log2(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x): - base = paddle.to_tensor(2.0).squeeze() - return paddle_backend.divide( - paddle_backend.log(x), paddle_backend.log(base) - ).astype(x.dtype) - return paddle.log2(x.astype("float32")).astype(x.dtype) + if paddle.is_complex(x): + base = paddle.to_tensor(2.0).squeeze() + return paddle_backend.divide( + paddle_backend.log(x), paddle_backend.log(base) + ).astype(x.dtype) return paddle.log2(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "complex")}, + backend_version, +) def log1p(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x): - return paddle_backend.log(x + 1) - return paddle.log1p(x.astype("float32")).astype(x.dtype) + if paddle.is_complex(x): + return paddle.complex(paddle.log1p(paddle.abs(x)), paddle.angle(x + 1)) return paddle.log1p(x) +@with_supported_dtypes( + { + "2.5.1 and below": ( + "float", + "int32", + "int64", + "complex", + ) + }, + backend_version, +) def isnan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.uint8, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x): - return paddle.logical_or(paddle.isnan(x.real()), paddle.isnan(x.imag())) - return paddle.isnan(x.astype("float32")) + if paddle.is_complex(x): + return paddle.logical_or(paddle.isnan(x.real()), paddle.isnan(x.imag())) return paddle.isnan(x) +@with_unsupported_dtypes( + { + "2.5.1 and below": ( + "int8", + "uint8", + ) + }, + backend_version, +) def less( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -425,16 +329,25 @@ def less( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.int8, paddle.uint8, paddle.complex64, paddle.complex128]: - if paddle.is_complex(x1): - real = paddle.less_than(x1.real(), x2.real()) - imag = paddle.less_than(x1.imag(), x2.imag()) - return logical_and(real, imag) - return paddle.less_than(x1.astype("float32"), x2.astype("float32")) + if paddle.is_complex(x1): + real = paddle.less_than(x1.real(), x2.real()) + imag = paddle.less_than(x1.imag(), x2.imag()) + return logical_and(real, imag) return paddle.less_than(x1, x2) +@with_unsupported_dtypes( + { + "2.5.1 and below": ( + "int8", + "int16", + "uint8", + "float16", + ) + }, + backend_version, +) def multiply( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -443,48 +356,39 @@ def multiply( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.int8, paddle.int16, paddle.uint8, paddle.float16]: - x1, x2 = x1.astype("float32"), x2.astype("float32") return paddle.multiply(x1, x2).astype(ret_dtype) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ( + "float32", + "float64", + ) + } + }, backend_version, ) def cos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - ret_dtype = x.dtype - return paddle.cos(x.astype("float32")).astype(ret_dtype) - if paddle.is_complex(x): - re = x.real() - im = x.imag() - return paddle.complex( - paddle.cos(re) * paddle.cosh(im), - -paddle.sin(re) * paddle.sinh(im), - ) return paddle.cos(x) +@with_unsupported_dtypes({"2.5.1 and below": ("uint", "float16")}, backend_version) def logical_not( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: - if x.dtype in [paddle.uint8, paddle.float16, paddle.complex64, paddle.complex128]: - if paddle.is_complex(x): - return paddle.logical_and( - paddle.logical_not(x.real()), paddle.logical_not(x.imag()) - ) - return paddle.logical_not(x.astype("float32")) + if paddle.is_complex(x): + return paddle.logical_and( + paddle.logical_not(x.real()), paddle.logical_not(x.imag()) + ) return paddle.logical_not(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "int32", "int64", "complex")}, + backend_version, +) def divide( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -492,16 +396,18 @@ def divide( *, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: + if paddle.is_complex(x1) or paddle.is_complex(x2): + angle_value = paddle.angle(x1) - paddle.angle(x2) + abs_value = paddle.abs(x1) / paddle.abs(x2) + return paddle.complex( + abs_value * paddle.cos(angle_value), abs_value * paddle.sin(angle_value) + ) x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.float16, paddle.bfloat16]: - x1, x2 = x1.astype("float32"), x2.astype("float32") - if not (ivy.is_float_dtype(ret_dtype) or ivy.is_complex_dtype(ret_dtype)): - ret_dtype = ivy.default_float_dtype(as_native=True) return (x1 / x2).astype(ret_dtype) @with_supported_dtypes( - {"2.5.2 and below": ("float64", "float32", "int64", "int64")}, + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version, ) def fmin( @@ -516,6 +422,27 @@ def fmin( return paddle.fmin(x1, x2) +def _apply_for_real_and_imag(fn, x1, x2): + return fn( + fn(x1.real(), x2.real()), + fn(x1.imag(), x2.imag()), + ) + + +@with_supported_dtypes( + { + "2.5.1 and below": ( + "bool", + "float32", + "float64", + "int16", + "int32", + "int64", + "complex", + ) + }, + backend_version, +) def greater( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -524,16 +451,28 @@ def greater( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.int8, paddle.uint8, paddle.complex64, paddle.complex128]: + if paddle.is_complex(x1): if paddle.is_complex(x1): - if paddle.is_complex(x1): - real = paddle.greater_than(x1.real(), x2.real()) - imag = paddle.greater_than(x1.imag(), x2.imag()) - return paddle.logical_and(real, imag) - return paddle.greater_than(x1.astype("float32"), x2.astype("float32")) + real = paddle.greater_than(x1.real(), x2.real()) + imag = paddle.greater_than(x1.imag(), x2.imag()) + return paddle.logical_and(real, imag) return paddle.greater_than(x1, x2) +@with_supported_dtypes( + { + "2.5.1 and below": ( + "bool", + "float32", + "float64", + "int16", + "int32", + "int64", + "complex", + ) + }, + backend_version, +) def greater_equal( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -542,30 +481,27 @@ def greater_equal( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.int8, paddle.uint8, paddle.complex64, paddle.complex128]: + if paddle.is_complex(x1): if paddle.is_complex(x1): - if paddle.is_complex(x1): - real = paddle.greater_equal(x1.real(), x2.real()) - imag = paddle.greater_equal(x1.imag(), x2.imag()) - return paddle.logical_and(real, imag) - return paddle.greater_equal(x1.astype("float32"), x2.astype("float32")) + real = paddle.greater_equal(x1.real(), x2.real()) + imag = paddle.greater_equal(x1.imag(), x2.imag()) + return paddle.logical_and(real, imag) return paddle.greater_equal(x1, x2) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ( + "float32", + "float64", + "complex", + ) + } + }, backend_version, ) def acos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - return paddle.acos(x.astype("float32")).astype(x.dtype) if paddle.is_complex(x): # From https://github.com/python/cpython/blob/39ef93edb9802dccdb6555d4209ac2e60875a011/Modules/cmathmodule.c#L178 # noqa s1 = paddle_backend.sqrt(1 - x) @@ -577,75 +513,66 @@ def acos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. return paddle.acos(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ("bool", "float32", "int32", "float64", "int64", "complex") + } + }, backend_version, ) def logical_xor( x1: paddle.Tensor, x2: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if ret_dtype in [paddle.uint8, paddle.float16, paddle.complex64, paddle.complex128]: - # this logic works well when both inputs are complex but when one of them - # is casted from real to complex, the imaginary part is zero which messes - # with the XOR logic - # if paddle.is_complex(x1): - # return paddle.logical_xor( - # paddle.logical_xor(x1.real(), x2.real()), - # paddle.logical_xor(x1.imag(), x2.imag()), - # ) - return paddle.logical_xor(x1.astype("float32"), x2.astype("float32")) + if paddle.is_complex(x1): + return _apply_for_real_and_imag(paddle.logical_xor, x1, x2) return paddle.logical_xor(x1, x2) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ("bool", "float32", "int32", "float64", "int64", "complex") + } + }, backend_version, ) def logical_and( x1: paddle.Tensor, x2: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if ret_dtype in [paddle.uint8, paddle.float16, paddle.complex64, paddle.complex128]: - # this logic works well when both inputs are complex but when one of them - # is casted from real to complex, the imaginary part is zero which messes - # if paddle.is_complex(x1): - # return paddle.logical_and( - # paddle.logical_and(x1.real(), x2.real()), - # paddle.logical_and(x1.imag(), x2.imag()), - # ) - return paddle.logical_and(x1.astype("float32"), x2.astype("float32")) + if paddle.is_complex(x1): + return _apply_for_real_and_imag(paddle.logical_and, x1, x2) return paddle.logical_and(x1, x2) +@with_supported_dtypes( + {"2.5.1 and below": ("bool", "float32", "int32", "float64", "int64", "complex")}, + backend_version, +) def logical_or( x1: paddle.Tensor, x2: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if ret_dtype in [paddle.uint8, paddle.float16, paddle.complex64, paddle.complex128]: - if paddle.is_complex(x1): - return paddle.logical_or( - paddle.logical_or(x1.real(), x2.real()), - paddle.logical_or(x1.imag(), x2.imag()), - ) - return paddle.logical_or(x1.astype("float32"), x2.astype("float32")) + if paddle.is_complex(x1): + return _apply_for_real_and_imag(paddle.logical_or, x1, x2) return paddle.logical_or(x1, x2) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ( + "float32", + "float64", + "complex", + ) + } + }, backend_version, ) def acosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - return paddle.acosh(x.astype("float32")).astype(x.dtype) if paddle.is_complex(x): # From https://github.com/python/cpython/blob/39ef93edb9802dccdb6555d4209ac2e60875a011/Modules/cmathmodule.c#L221 # noqa s1 = paddle_backend.sqrt(paddle.complex(x.real() - 1, x.imag())) @@ -657,20 +584,11 @@ def acosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle return paddle.acosh(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def sin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - return paddle.sin(x.astype("float32")).astype(x.dtype) if paddle.is_complex(x): re = x.real() im = x.imag() @@ -680,15 +598,13 @@ def sin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T return paddle.sin(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, + backend_version, +) def negative( x: Union[float, paddle.Tensor], /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: - if not isinstance(x, paddle.Tensor): - x = paddle.to_tensor( - x, dtype=ivy.default_dtype(item=x, as_native=True) - ).squeeze() - if x.dtype == paddle.bool: - return paddle.logical_not(x) return paddle.neg(x) @@ -702,22 +618,11 @@ def not_equal( return paddle.logical_not(paddle_backend.equal(x1, x2)) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("bfloat16", "float32", "float64", "complex")}}, backend_version, ) -def tanh( - x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None -) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - return paddle.tanh(x.astype("float32")).astype(x.dtype) +def tanh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): tanh_a = paddle.tanh(x.real()) tan_b = paddle.tan(x.imag()) @@ -731,6 +636,21 @@ def tanh( return paddle.tanh(x) +@with_supported_dtypes( + { + "2.5.1 and below": ( + "uint8", + "int8", + "int32", + "int64", + "float32", + "float64", + "float16", + "bfloat16", + ) + }, + backend_version, +) def floor_divide( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -739,11 +659,13 @@ def floor_divide( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.int32, paddle.int64]: - return paddle.floor_divide(x1, x2) - return paddle_backend.floor(paddle_backend.divide(x1, x2)).astype(ret_dtype) + return paddle.floor_divide(x1, x2) +@with_supported_dtypes( + {"2.5.1 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, + backend_version, +) def bitwise_or( x1: Union[int, bool, paddle.Tensor], x2: Union[int, bool, paddle.Tensor], @@ -755,21 +677,10 @@ def bitwise_or( return paddle.bitwise_or(x1, x2) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, - backend_version, +@with_supported_dtypes( + {"2.5.2 and below": ("float32", "float64", "complex")}, backend_version ) def sinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - ret_dtype = x.dtype - return paddle.sinh(x.astype("float32")).astype(ret_dtype) if paddle.is_complex(x): re = x.real() im = x.imag() @@ -789,21 +700,27 @@ def positive( return x.clone() +@with_supported_dtypes( + { + "2.5.1 and below": ( + "int32", + "int64", + "float32", + "float64", + "complex", + ) + }, + backend_version, +) def square( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: - if x.dtype in [paddle.int32, paddle.int64, paddle.float32, paddle.float64]: - return paddle.square(x) - if paddle.is_complex(x): - return paddle.complex( - paddle.square(paddle.real(x)) - paddle.square(paddle.imag(x)), - 2.0 * paddle.real(x) * paddle.imag(x), - ) - return paddle_backend.pow(x, 2).astype(x.dtype) + return paddle.square(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", "int32", "int64", "complex")}}, + backend_version, ) def pow( x1: paddle.Tensor, @@ -813,14 +730,6 @@ def pow( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [ - paddle.int8, - paddle.int16, - paddle.uint8, - paddle.float16, - paddle.bool, - ]: - return paddle.pow(x1.astype("float32"), x2.astype("float32")).astype(ret_dtype) if paddle.is_complex(x1): # https://math.stackexchange.com/questions/476968/complex-power-of-a-complex-number r = paddle.abs(x1) @@ -876,26 +785,16 @@ def round( return x.astype(dtype_) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "complex")}, backend_version +) def trunc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x): - return paddle.complex(paddle.trunc(x.real()), paddle.trunc(x.imag())) - return paddle.trunc(x.astype("float32")).astype(x.dtype) + if paddle.is_complex(x): + return paddle.complex(paddle.trunc(x.real()), paddle.trunc(x.imag())) return paddle.trunc(x) -@with_supported_dtypes( - {"2.5.2 and below": ("float64", "float32")}, - backend_version, -) +@with_supported_dtypes({"2.5.2 and below": ("float64", "float32")}, backend_version) def trapz( y: paddle.Tensor, /, @@ -950,15 +849,6 @@ def abs( ) -> paddle.Tensor: if not isinstance(x, paddle.Tensor): x = paddle.to_tensor(x, dtype=ivy.default_dtype(item=x)).squeeze() - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.uint8, - paddle.float16, - paddle.bfloat16, - paddle.bool, - ]: - return paddle.abs(x.astype("float32")).astype(x.dtype) return paddle.abs(x) @@ -1011,88 +901,69 @@ def real(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. return paddle.real(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def tan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - ret_dtype = x.dtype - return paddle.tan(x.astype("float32")).astype(ret_dtype) if paddle.is_complex(x): tanh_ix = paddle_backend.tanh(paddle.complex(-x.imag(), x.real())) return paddle.complex(tanh_ix.imag(), -tanh_ix.real()) return paddle.tan(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def atan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - ret_dtype = x.dtype - return paddle.atan(x.astype("float32")).astype(ret_dtype) if x.dtype in [paddle.complex64, paddle.complex128]: atanh_iz = paddle_backend.atanh(paddle.complex(-x.imag(), x.real())) return paddle.complex(atanh_iz.imag(), -atanh_iz.real()) return paddle.atan(x) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ( + "int32", + "int64", + "float32", + "float64", + ) + } + }, backend_version, ) def atan2( x1: paddle.Tensor, x2: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.int8, paddle.int16, paddle.uint8]: - x1, x2 = x1.astype("float32"), x2.astype("float32") return paddle.atan2(x1, x2).astype(ret_dtype) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "complex")}, + backend_version, +) def log(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x): - return paddle.complex(paddle.log(paddle.abs(x)), paddle.angle(x)) - return paddle.log(x.astype("float32")).astype(x.dtype) + if paddle.is_complex(x): + return paddle.complex(paddle.log(paddle.abs(x)), paddle.angle(x)) return paddle.log(x) +@with_supported_dtypes( + {"2.5.1 and below": ("int32", "int64", "float32", "float64", "complex")}, + backend_version, +) def exp(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [paddle.int32, paddle.int64, paddle.float32, paddle.float64]: - return paddle.exp(x) if paddle.is_complex(x): return paddle.multiply( paddle.exp(x.real()), paddle.complex(paddle.cos(x.imag()), paddle.sin(x.imag())), ) - return paddle_backend.pow(math.e, x).astype(x.dtype) + return paddle.exp(x) def exp2( @@ -1105,6 +976,9 @@ def exp2( return ivy.pow(2, x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version +) def subtract( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -1114,16 +988,14 @@ def subtract( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [paddle.int8, paddle.uint8, paddle.float16, paddle.bool]: - x1, x2 = x1.astype("float32"), x2.astype("float32") if alpha not in (1, None): x2 = paddle_backend.multiply(x2, alpha) x1, x2 = ivy.promote_types_of_inputs(x1, x2) return paddle.subtract(x1, x2).astype(ret_dtype) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("float32", "float64", "int32", "int64")}}, backend_version, ) def remainder( @@ -1145,26 +1017,14 @@ def remainder( diff = paddle_backend.subtract(res, res_floored).astype(res.dtype) return paddle_backend.round(paddle_backend.multiply(diff, x2)).astype(x1.dtype) - if x1.dtype in [paddle.int8, paddle.int16, paddle.uint8, paddle.float16]: - x1, x2 = x1.astype("float32"), x2.astype("float32") return paddle.remainder(x1, x2).astype(ret_dtype) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bool", "bfloat16")}}, +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def atanh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - if x.dtype in [ - paddle.int8, - paddle.int16, - paddle.int32, - paddle.int64, - paddle.uint8, - paddle.float16, - ]: - ret_dtype = x.dtype - return paddle.atanh(x.astype("float32")).astype(ret_dtype) if paddle.is_complex(x): return 0.5 * (paddle_backend.log(1 + x) - paddle_backend.log(1 - x)) return paddle.atanh(x) @@ -1200,17 +1060,15 @@ def bitwise_left_shift( # ------# -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128", "bool")}}, - backend_version, -) +@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) def erf(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: - # TODO: add support for complex x, supported in scipy only atm - if x.dtype in [paddle.int8, paddle.int16, paddle.int32, paddle.int64, paddle.uint8]: - return paddle.erf(x.astype("float32")).astype(x.dtype) return paddle.erf(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "int32", "int64", "complex")}, + backend_version, +) def minimum( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -1220,19 +1078,8 @@ def minimum( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [ - paddle.int8, - paddle.int16, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x1): - use_where = True - else: - x1, x2 = x1.astype("float32"), x2.astype("float32") + if paddle.is_complex(x1): + use_where = True if use_where: return paddle_backend.where(paddle_backend.less_equal(x1, x2), x1, x2).astype( @@ -1242,6 +1089,10 @@ def minimum( return paddle.minimum(x1, x2).astype(ret_dtype) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "int32", "int64", "complex")}, + backend_version, +) def maximum( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], @@ -1251,19 +1102,8 @@ def maximum( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if x1.dtype in [ - paddle.int8, - paddle.int16, - paddle.uint8, - paddle.float16, - paddle.complex64, - paddle.complex128, - paddle.bool, - ]: - if paddle.is_complex(x1): - use_where = True - else: - x1, x2 = x1.astype("float32"), x2.astype("float32") + if paddle.is_complex(x1): + use_where = True if use_where: return paddle_backend.where( paddle_backend.greater_equal(x1, x2), x1, x2 @@ -1271,27 +1111,36 @@ def maximum( return paddle.maximum(x1, x2).astype(ret_dtype) +@with_supported_dtypes( + { + "2.5.1 and below": ( + "float32", + "float64", + ) + }, + backend_version, +) def reciprocal( x: Union[float, paddle.Tensor], /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: - if x.dtype in [paddle.float32, paddle.float64]: - return paddle.reciprocal(x) - return paddle_backend.divide(1, x) + return paddle.reciprocal(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version +) def deg2rad( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: - if x.dtype in [paddle.int32, paddle.int64, paddle.bool]: - return paddle.deg2rad(x.astype("float32")).astype(x.dtype) return paddle.deg2rad(x) +@with_supported_dtypes( + {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version +) def rad2deg( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: - if x.dtype in [paddle.int32, paddle.int64, paddle.bool]: - return paddle.rad2deg(x.astype("float32")).astype(x.dtype) return paddle.rad2deg(x) @@ -1326,10 +1175,7 @@ def fmod( return paddle_backend.where(paddle_backend.less(x1, 0), -res, res) -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8", "uint8")}}, - backend_version, -) +@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, backend_version) def lcm( x1: paddle.Tensor, x2: paddle.Tensor, @@ -1337,18 +1183,19 @@ def lcm( *, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: - x1_dtype = x1.dtype - x2_dtype = x2.dtype - if (x1_dtype, x2_dtype) == (paddle.int16, paddle.int16): - return paddle.cast( - paddle.lcm(paddle.cast(x1, paddle.int32), paddle.cast(x2, paddle.int32)), - paddle.int16, - ) - elif x1_dtype != x2_dtype: - x1, x2 = ivy.promote_types_of_inputs(x1, x2) return paddle.lcm(x1, x2) +@with_supported_dtypes( + { + "2.5.1 and below": ( + "float32", + "float64", + "complex", + ) + }, + backend_version, +) def angle( input: paddle.Tensor, /, @@ -1362,8 +1209,8 @@ def angle( return result -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("int32", "int64")}}, backend_version ) def gcd( x1: Union[paddle.Tensor, int, list, tuple], @@ -1376,24 +1223,7 @@ def gcd( return paddle.gcd(x1, x2) -@with_unsupported_device_and_dtypes( - { - "2.5.2 and below": { - "cpu": ( - "int8", - "int16", - "int32", - "int64", - "uint8", - "float16", - "float32", - "float64", - "bool", - ) - } - }, - backend_version, -) +@with_supported_dtypes({"2.5.2 and below": ("complex",)}, backend_version) def imag( val: paddle.Tensor, /, From 7af38de5bbb7125672a7fdb3d7da4bf193f9353f Mon Sep 17 00:00:00 2001 From: Aaryan562 <82304628+Aaryan562@users.noreply.github.com> Date: Fri, 3 Nov 2023 15:39:46 +0530 Subject: [PATCH 109/978] fix(jax-backend): fix failing test for sum (#27087) --- ivy/functional/backends/paddle/statistical.py | 5 ++++- .../test_ivy/test_functional/test_core/test_statistical.py | 4 ++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/statistical.py b/ivy/functional/backends/paddle/statistical.py index 8869dcfe888e7..9cc49c2733942 100644 --- a/ivy/functional/backends/paddle/statistical.py +++ b/ivy/functional/backends/paddle/statistical.py @@ -167,7 +167,10 @@ def std( return _std(x, axis, correction, keepdims).cast(x.dtype) -@with_unsupported_dtypes({"2.5.2 and below": ("int8", "uint8")}, backend_version) +@with_unsupported_dtypes( + {"2.5.2 and below": ("int8", "int16", "uint8")}, + backend_version, +) def sum( x: paddle.Tensor, /, diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py index f5c82c9b4c1db..87b230fdf9649 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py @@ -332,6 +332,7 @@ def test_std(*, dtype_and_x, keep_dims, test_flags, backend_fw, fn_name, on_devi fn_tree="functional.ivy.sum", dtype_x_axis_castable=_get_castable_dtype(), keep_dims=st.booleans(), + test_gradients=st.just(False), ) def test_sum( *, dtype_x_axis_castable, keep_dims, test_flags, backend_fw, fn_name, on_device @@ -342,6 +343,9 @@ def test_sum( if "torch" in backend_fw: assume(not test_flags.as_variable[0]) assume(not test_flags.test_gradients) + if "jax" in backend_fw and castable_dtype in ["complex64", "complex128"]: + assume(not test_flags.test_gradients) + helpers.test_function( input_dtypes=[input_dtype], test_flags=test_flags, From 7ec99e31fb016e4418402ca44621e7a90d488be8 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 3 Nov 2023 11:53:14 +0000 Subject: [PATCH 110/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 33b7a65c72885..8c17db6cee4e3 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 33b7a65c728854c811f52e954189ac53323441b4 +Subproject commit 8c17db6cee4e321c6315374c21e60f8d0c20da02 From 7fb48d419912ccf1aaad1956f70ae7f8d30fabcb Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 3 Nov 2023 12:14:47 +0000 Subject: [PATCH 111/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 8c17db6cee4e3..2bf43d222424b 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 8c17db6cee4e321c6315374c21e60f8d0c20da02 +Subproject commit 2bf43d222424bacfe88ed5746870d5ba5528aed1 From 8d0ad8159312695e7eba129cfb787a1ad947eddd Mon Sep 17 00:00:00 2001 From: gfggithubleet <144522681+gfggithubleet@users.noreply.github.com> Date: Fri, 3 Nov 2023 18:32:51 +0530 Subject: [PATCH 112/978] Update CONTRIBUTING.md (#27185) Co-authored-by: NripeshN --- CONTRIBUTING.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 85913821888c8..89d573f39917f 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -9,8 +9,8 @@ Please, follow the next process when you work on your subtask: 1. **Choosing a Task:** - Choose a task to work on which: - - is not marked as completed with a tick - - does not have an issue created + - is not marked as completed with a tick. + - does not have an issue created. - is not mentioned in the comments. Currently, there are three open tasks: @@ -39,7 +39,7 @@ Please, follow the next process when you work on your subtask: ### Important Notes -- if your PR is not created within 7 days of creating the issue, then a warning message will appear on the issue, we do this in order to keep our ToDo lists moving quickly, +- If your PR is not created within 7 days of creating the issue, then a warning message will appear on the issue, we do this in order to keep our ToDo lists moving quickly, - Please don't take it personally if your issue or PR gets closed because of this 7-day inactivity time limit. - Finally, we limit the maximum number of open and incomplete sub-task issues to three per person. From fe8827ba8c586daa067148b2793b9f0254da218a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sat, 4 Nov 2023 16:29:03 +0530 Subject: [PATCH 113/978] fix: Removed useless statements in few files. (#27209) --- ivy/__init__.py | 3 +-- ivy/functional/backends/tensorflow/experimental/elementwise.py | 1 - .../test_misc/test_factorized_tensor/test_parafac2_tensor.py | 1 - 3 files changed, 1 insertion(+), 4 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 073894dff6aa1..1faf53a31acdf 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -480,8 +480,7 @@ def is_fully_defined(self): shape is not None for shape in self._shape ) - property - + @property def num_elements(self): if not self.is_fully_defined(): return None diff --git a/ivy/functional/backends/tensorflow/experimental/elementwise.py b/ivy/functional/backends/tensorflow/experimental/elementwise.py index 97841a300cd43..f23d1aa615677 100644 --- a/ivy/functional/backends/tensorflow/experimental/elementwise.py +++ b/ivy/functional/backends/tensorflow/experimental/elementwise.py @@ -297,7 +297,6 @@ def gradient( edge_order: int = 1, ) -> Union[tf.Tensor, List[tf.Tensor]]: # https://github.com/numpy/numpy/blob/v1.24.3/numpy/lib/function_base.py#L969-L1312 - x.device x = tf.experimental.numpy.asanyarray(x) N = x.ndim # number of dimensions if axis is None: diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_parafac2_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_parafac2_tensor.py index 3f7b3e6bc19e7..8992e92efa2f6 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_parafac2_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_parafac2_tensor.py @@ -98,7 +98,6 @@ def test_parafac2_to_tensor(weights, factors, projections, true_res): projections = [ivy.array(p) for p in projections] true_res = ivy.array(true_res) res = ivy.Parafac2Tensor.parafac2_to_tensor((weights, factors, projections)) - (true_res, res) assert np.allclose(res, true_res) From 3458152aa1d34eb0eb3719aa15e9d1e50bb2aaf7 Mon Sep 17 00:00:00 2001 From: akshatvishu <33392262+akshatvishu@users.noreply.github.com> Date: Sat, 4 Nov 2023 16:43:55 +0530 Subject: [PATCH 114/978] feat(paddle frontend): added paddle.mod to ivy paddle frontend (#26321) Co-authored-by: Mahmoud Ashraf --- ivy/functional/frontends/paddle/math.py | 13 ++++++- .../test_frontends/test_paddle/test_math.py | 39 ++++++++++++++++++- 2 files changed, 49 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index 9d21b5e4f9445..f8cd603766781 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -271,8 +271,14 @@ def floor_divide(x, y, name=None): return ivy.floor_divide(x, y) -@with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" +@with_supported_device_and_dtypes( + { + "2.5.2 and below": { + "cpu": ("float32", "float64", "int32", "int64"), + "gpu": ("float16", "float32", "float64", "int32", "int64"), + } + }, + "paddle", ) @to_ivy_arrays_and_back def floor_mod(x, y, name=None): @@ -667,3 +673,6 @@ def trace(x, offset=0, axis1=0, axis2=1, name=None): @to_ivy_arrays_and_back def trunc(x, name=None): return ivy.trunc(x) + + +mod = remainder diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py index 21ed49947fc08..c4b40e6a715d9 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py @@ -1,5 +1,5 @@ # global -from hypothesis import strategies as st +from hypothesis import strategies as st, assume import hypothesis.extra.numpy as nph import numpy as np import sys @@ -1876,6 +1876,43 @@ def test_paddle_mm( ) +# mod +@handle_frontend_test( + fn_tree="paddle.mod", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=2, + allow_inf=False, + large_abs_safety_factor=2, + small_abs_safety_factor=2, + safety_factor_scale="log", + shared_dtype=True, + ), +) +def test_paddle_mod( + *, + dtype_and_x, + on_device, + fn_tree, + frontend, + backend_fw, + test_flags, +): + input_dtype, x = dtype_and_x + assume(not np.any(np.isclose(x[0], 0))) + assume(not np.any(np.isclose(x[1], 0))) + helpers.test_frontend_function( + input_dtypes=input_dtype, + frontend=frontend, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x=x[0], + y=x[1], + ) + + # multiply @handle_frontend_test( fn_tree="paddle.multiply", From 8b0032bac8dd35f148bd9e6de72ccd7d51392399 Mon Sep 17 00:00:00 2001 From: Mahmoud Ashraf Date: Sat, 4 Nov 2023 12:30:55 +0000 Subject: [PATCH 115/978] fix: fixed the versioning intervals for paddle backend --- ivy/functional/backends/paddle/__init__.py | 29 ++++++++-------------- 1 file changed, 11 insertions(+), 18 deletions(-) diff --git a/ivy/functional/backends/paddle/__init__.py b/ivy/functional/backends/paddle/__init__.py index e63c5c3183202..86deeb0c9b9d6 100644 --- a/ivy/functional/backends/paddle/__init__.py +++ b/ivy/functional/backends/paddle/__init__.py @@ -117,7 +117,7 @@ def rep_method(*args, **kwargs): # update these to add new dtypes valid_dtypes = { - "2.4.0 and below": ( + "2.4.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -130,7 +130,7 @@ def rep_method(*args, **kwargs): ivy.complex128, ivy.bool, ), - "2.4.1 and above": ( + "2.5.0 and above": ( ivy.int8, ivy.int16, ivy.int32, @@ -146,7 +146,7 @@ def rep_method(*args, **kwargs): ), } valid_numeric_dtypes = { - "2.4.0 and below": ( + "2.4.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -159,7 +159,7 @@ def rep_method(*args, **kwargs): ivy.complex128, ivy.bool, ), - "2.4.1 and above": ( + "2.5.0 and above": ( ivy.int8, ivy.int16, ivy.int32, @@ -182,17 +182,10 @@ def rep_method(*args, **kwargs): ivy.int64, ivy.uint8, ), - "2.5.2 and above": ( - ivy.int8, - ivy.int16, - ivy.int32, - ivy.int64, - ivy.uint8, - ), } valid_float_dtypes = { - "2.4.0 and below": (ivy.float16, ivy.float32, ivy.float64), - "2.4.1 and above": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64), + "2.4.2 and below": (ivy.float16, ivy.float32, ivy.float64), + "2.5.0 and above": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64), } valid_uint_dtypes = {"2.5.2 and below": (ivy.uint8,)} valid_complex_dtypes = {"2.5.2 and below": (ivy.complex64, ivy.complex128)} @@ -208,13 +201,13 @@ def rep_method(*args, **kwargs): # update these to add new dtypes invalid_dtypes = { - "2.4.0 and below": ( + "2.4.2 and below": ( ivy.uint16, ivy.uint32, ivy.uint64, ivy.bfloat16, ), - "2.4.1 and above": ( + "2.5.0 and above": ( ivy.uint16, ivy.uint32, ivy.uint64, @@ -222,13 +215,13 @@ def rep_method(*args, **kwargs): } invalid_numeric_dtypes = { - "2.4.0 and below": ( + "2.4.2 and below": ( ivy.uint16, ivy.uint32, ivy.uint64, ivy.bfloat16, ), - "2.4.1 and above": ( + "2.5.0 and above": ( ivy.uint16, ivy.uint32, ivy.uint64, @@ -236,7 +229,7 @@ def rep_method(*args, **kwargs): } invalid_int_dtypes = {"2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_float_dtypes = {"2.4.0 and below": (ivy.bfloat16,), "2.4.1 and above": ()} +invalid_float_dtypes = {"2.4.2 and below": (ivy.bfloat16,), "2.5.0 and above": ()} invalid_uint_dtypes = {"2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} invalid_complex_dtypes = {"2.5.2 and below": ()} From 48044a4e6ab6af025778ebc963a31f620df99ef4 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Sat, 4 Nov 2023 13:07:51 -0700 Subject: [PATCH 116/978] Add `torch.nn.Parameter`, `torch.nn.Module` and `ivy.Module.to_keras_module` for KLA (#27210) --- ivy/data_classes/array/conversions.py | 121 +++ ivy/functional/frontends/torch/__init__.py | 1 + ivy/functional/frontends/torch/nn/__init__.py | 4 + .../frontends/torch/nn/modules/__init__.py | 2 + .../frontends/torch/nn/modules/module.py | 997 ++++++++++++++++++ .../frontends/torch/nn/parameter.py | 18 + ivy/functional/frontends/torch/tensor.py | 14 + .../frontends/torch/utils/__init__.py | 1 + ivy/functional/frontends/torch/utils/hooks.py | 231 ++++ ivy/stateful/converters.py | 84 ++ 10 files changed, 1473 insertions(+) create mode 100644 ivy/functional/frontends/torch/nn/modules/__init__.py create mode 100644 ivy/functional/frontends/torch/nn/modules/module.py create mode 100644 ivy/functional/frontends/torch/nn/parameter.py create mode 100644 ivy/functional/frontends/torch/utils/__init__.py create mode 100644 ivy/functional/frontends/torch/utils/hooks.py diff --git a/ivy/data_classes/array/conversions.py b/ivy/data_classes/array/conversions.py index a78e7bdae4311..e92947cf2dfcf 100644 --- a/ivy/data_classes/array/conversions.py +++ b/ivy/data_classes/array/conversions.py @@ -17,6 +17,23 @@ # --------# +# TODO: Need to find a better way to do this. +# Temporarily adding as is for the +# `ivy.Module.to_keras_module`method +# for the KLA demo. Do not move/remove. +ARRAY_TO_BACKEND = { + "ndarray": "numpy", + "Tensor": ["torch", "paddle"], + "Parameter": "torch", + "EagerTensor": "tensorflow", + "ResourceVariable": "tensorflow", + "DeviceArray": "jax", + "Array": "jax", + "ArrayImpl": "jax", + "EagerParamBase": "paddle", +} + + def _to_native(x: Any, inplace: bool = False, to_ignore: tuple = ()) -> Any: to_ignore = ivy.default(to_ignore, ()) if isinstance(x, to_ignore): @@ -200,3 +217,107 @@ def args_to_native( shallow=False, ) return native_args, native_kwargs + + +# TODO: Need to find a better way to do this. +# Temporarily adding as is for the +# `ivy.Module.to_keras_module`method +# for the . Do not move/remove. +def array_to_new_backend( + x: Union[ivy.Array, ivy.NativeArray], + native: bool = False, +) -> Union[ivy.Array, ivy.NativeArray]: + native_x = x.data if isinstance(x, ivy.Array) else x + native_x_type = type(native_x).__name__ + + # Modify native_type here since @tf.function converts tf.EagerTensor into + # tf.Tensor when running @tf.function on a transpiled graph + if ivy.current_backend_str() == "tensorflow": + import importlib + + native_x_type = ( + "EagerTensor" + if not importlib.import_module("tensorflow").executing_eagerly() + and isinstance(native_x, importlib.import_module("tensorflow").Tensor) + else native_x_type + ) + + # Check for paddle first, as it shares the 'Tensor' native_x_type with torch + if "paddle" in str(native_x.__class__) and ivy.current_backend_str() == "paddle": + if native: + return native_x + else: + return x + + if hasattr(x, "_ivy_array"): + return x + + # Check if the other possible backends match with the native data type + if ( + native_x_type in ARRAY_TO_BACKEND + and ivy.current_backend_str() in ARRAY_TO_BACKEND[native_x_type] + ): + if ivy.current_backend_str() == "torch": + if "torch" in str(native_x.__class__): + # torch and paddle both use 'Tensor', return if this is torch + return x + else: + # if it's actually a paddle tensor, convert to an ivy array + ret = ivy.array(native_x.numpy()) + return ret.data if native else ret + if ivy.current_backend_str() == "paddle": + if "paddle" in str(native_x.__class__): + # torch and paddle both use 'Tensor', return if this is paddle + return x + else: + # if it's actually a torch tensor, convert to an ivy array + ret = ivy.array(native_x.numpy()) + return ret.data if native else ret + return x + + if native_x_type not in ARRAY_TO_BACKEND: + return x + native_x = ( + native_x.detach().cpu() + if native_x_type in ["Parameter", "Tensor"] + else native_x + ) + np_intermediary = np.array(native_x) + ret = ivy.array(np_intermediary) + return ret.data if native else ret + + +# TODO: Need to find a better way to do this. +# Temporarily adding as is for the +# `ivy.Module.to_keras_module()`method +# for the KLA demo. Do not move/remove. +def nest_array_to_new_backend( + nest: Iterable[Union[ivy.Array, ivy.NativeArray]], + native: bool = True, + shallow: bool = True, +) -> Iterable[Union[ivy.Array, ivy.NativeArray]]: + """ + Convert a given ivy.Array or ivy.NativeArray to a new backend framework. + + Parameters + ---------- + nest + Input nest with the leaves to be converted to a new backend. + native + Whether to return the new array as a ivy.NativeArray or an ivy.Array. + Default is ``True``. + shallow + Whether to inplace update the input nest or not + Only works if nest is a mutable type. Default is ``True``. + + Returns + ------- + ret + The input nest with leaves converted to the new backend framework. + """ + return ivy.nested_map( + lambda x: array_to_new_backend(x, native=native), + nest, + include_derived=True, + shallow=shallow, + ) diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index e871198f0a823..963e9894d24af 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -258,6 +258,7 @@ def promote_types_of_torch_inputs( return x1, x2 +from . import utils from . import nn from .nn.functional import softmax, relu, lstm from . import tensor diff --git a/ivy/functional/frontends/torch/nn/__init__.py b/ivy/functional/frontends/torch/nn/__init__.py index 61af1a48a161f..3de7cfe7ef368 100644 --- a/ivy/functional/frontends/torch/nn/__init__.py +++ b/ivy/functional/frontends/torch/nn/__init__.py @@ -1 +1,5 @@ from . import functional +from . import modules +from .modules import * +from . import parameter +from .parameter import Parameter diff --git a/ivy/functional/frontends/torch/nn/modules/__init__.py b/ivy/functional/frontends/torch/nn/modules/__init__.py new file mode 100644 index 0000000000000..369789978e4b6 --- /dev/null +++ b/ivy/functional/frontends/torch/nn/modules/__init__.py @@ -0,0 +1,2 @@ +from . import module +from .module import Module diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py new file mode 100644 index 0000000000000..160fc399da40a --- /dev/null +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -0,0 +1,997 @@ +from collections import OrderedDict +import functools +from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Union +import warnings +import weakref +import ivy +from ivy.functional.frontends.torch.nn.parameter import Parameter + +from ivy.functional.frontends.torch.tensor import Tensor +from ivy.functional.frontends.torch.utils import hooks + +_grad_t = Union[Tuple[Tensor, ...], Tensor] + + +class _WrappedHook: + def __init__(self, hook: Callable, module: Optional["Module"] = None): + self.hook: Callable = hook + functools.update_wrapper(self, hook) + + self.with_module: bool = False + + if module is not None: + self.module: weakref.ReferenceType[Module] = weakref.ref(module) + self.with_module = True + + def __call__(self, *args: Any, **kwargs: Any) -> Any: + if self.with_module: + module = self.module() + if module is None: + raise RuntimeError("You are trying to call the hook of a dead Module!") + return self.hook(module, *args, **kwargs) + return self.hook(*args, **kwargs) + + def __getstate__(self) -> Dict: + result = {"hook": self.hook, "with_module": self.with_module} + if self.with_module: + result["module"] = self.module() + + return result + + def __setstate__(self, state: Dict): + self.hook = state["hook"] + self.with_module = state["with_module"] + + if self.with_module: + if state["module"] is None: + raise RuntimeError( + "You are trying to revive the hook of a dead Module!" + ) + self.module = weakref.ref(state["module"]) + + +class Module(ivy.Module): + dump_patches: bool = False + _version: int = 1 + training: bool + _parameters: Dict[str, Optional[Parameter]] + _buffers: Dict[str, Optional[Tensor]] + _non_persistent_buffers_set: Set[str] + _backward_pre_hooks: Dict[int, Callable] + _backward_hooks: Dict[int, Callable] + _is_full_backward_hook: Optional[bool] + _forward_hooks: Dict[int, Callable] + _forward_hooks_with_kwargs: Dict[int, bool] + _forward_hooks_always_called: Dict[int, bool] + _forward_pre_hooks: Dict[int, Callable] + _forward_pre_hooks_with_kwargs: Dict[int, bool] + _state_dict_hooks: Dict[int, Callable] + _load_state_dict_pre_hooks: Dict[int, Callable] + _state_dict_pre_hooks: Dict[int, Callable] + _load_state_dict_post_hooks: Dict[int, Callable] + _modules: Dict[str, Optional["Module"]] + call_super_init: bool = False + _compiled_call_impl: Optional[Callable] = None + + def __init__( + self, *args, device=None, devices=None, inplace_update=False, **kwargs + ) -> None: + self.__setattr__("_args", args) + self.__setattr__("_kwargs", kwargs) + self.__setattr__( + "_update_v", + self._inplace_update_v if inplace_update else self._replace_update_v, + ) + self.__setattr__("training", True) + self.__setattr__("_parameters", OrderedDict()) + self.__setattr__("_buffers", OrderedDict()) + self.__setattr__("_non_persistent_buffers_set", set()) + self.__setattr__("_backward_pre_hooks", OrderedDict()) + self.__setattr__("_backward_hooks", OrderedDict()) + self.__setattr__("_is_full_backward_hook", None) + self.__setattr__("_forward_hooks", OrderedDict()) + self.__setattr__("_forward_hooks_with_kwargs", OrderedDict()) + self.__setattr__("_forward_hooks_always_called", OrderedDict()) + self.__setattr__("_forward_pre_hooks", OrderedDict()) + self.__setattr__("_forward_pre_hooks_with_kwargs", OrderedDict()) + self.__setattr__("_state_dict_hooks", OrderedDict()) + self.__setattr__("_state_dict_pre_hooks", OrderedDict()) + self.__setattr__("_load_state_dict_pre_hooks", OrderedDict()) + self.__setattr__("_load_state_dict_post_hooks", OrderedDict()) + self.__setattr__("_modules", OrderedDict()) + ivy.Module.__init__( + self, *args, device=device, devices=devices, build_mode="explicit", **kwargs + ) + + def _create_variables(self, device=None, dtype=None): + return self._native_params + + def _build(self, *args, **kwargs): + self._native_params = ivy.Container( + OrderedDict( + sorted( + [ + (k.replace(".", "/"), v) + for k, v in dict(self.named_parameters()).items() + ] + ) + ), + dynamic_backend=False, + ) + + @staticmethod + def _inplace_update(p, v): + p.data = v.data + + def _inplace_update_v(self, new_v): + ivy.Container.cont_multi_map( + lambda xs, kc: self._inplace_update(xs[0], xs[1]), + [self._native_params, new_v], + ) + + def _replace_update_v(self, new_v, native=None): + from ivy.functional.ivy.gradients import _is_variable + + native = ivy.default(native, self) + for k, v in new_v.items(): + if isinstance(v, ivy.Container): + # noinspection PyProtectedMember + native._modules[k] = self._replace_update_v(v, native._modules[k]) + elif _is_variable(v): + # noinspection PyProtectedMember + native.__setattr__(k, v) + elif isinstance(v, Tensor): + # noinspection PyProtectedMember + native.__setattr__(k, Parameter(v, requires_grad=v.requires_grad)) + else: + raise ivy.utils.exceptions.IvyException( + f"found item in variable container {v} which was neither a sub" + " ivy.Container nor a variable." + ) + return native + + def forward(self, *input: Any) -> None: + raise NotImplementedError( + f'Module [{type(self).__name__}] is missing the required "forward" function' + ) + + def _forward(self, *a, **kw): + self._update_v(self.v) + ret = self(*a, **kw) + return ret + + def register_buffer( + self, name: str, tensor: Optional[Tensor], persistent: bool = True + ) -> None: + if "_buffers" not in self.__dict__: + raise AttributeError("cannot assign buffer before Module.__init__() call") + elif not isinstance(name, str): + raise TypeError(f"buffer name should be a string. Got {type(name)}") + elif "." in name: + raise KeyError('buffer name can\'t contain "."') + elif name == "": + raise KeyError('buffer name can\'t be empty string ""') + elif hasattr(self, name) and name not in self._buffers: + raise KeyError(f"attribute '{name}' already exists") + elif tensor is not None and not isinstance(tensor, Tensor): + raise TypeError( + f"cannot assign '{type(tensor)}' object to buffer '{name}' " + "(torch Tensor or None required)" + ) + else: + for hook in _global_buffer_registration_hooks.values(): + output = hook(self, name, tensor) + if output is not None: + tensor = output + self._buffers[name] = tensor + if persistent: + self._non_persistent_buffers_set.discard(name) + else: + self._non_persistent_buffers_set.add(name) + + def register_parameter(self, name: str, param: Optional[Parameter]) -> None: + if "_parameters" not in self.__dict__: + raise AttributeError( + "cannot assign parameter before Module.__init__() call" + ) + + elif not isinstance(name, str): + raise TypeError(f"parameter name should be a string. Got {type(name)}") + elif "." in name: + raise KeyError('parameter name can\'t contain "."') + elif name == "": + raise KeyError('parameter name can\'t be empty string ""') + + if param is None: + self._parameters[name] = None + elif not isinstance(param, Parameter): + raise TypeError( + f"cannot assign '{type(param)}' object to parameter '{name}' " + "(torch.nn.Parameter or None required)" + ) + elif param.grad_fn: + raise ValueError( + f"Cannot assign non-leaf Tensor to parameter '{name}'. Model " + f"parameters must be created explicitly. To express '{name}' " + "as a function of another Tensor, compute the value in " + "the forward() method." + ) + else: + for hook in _global_parameter_registration_hooks.values(): + output = hook(self, name, param) + if output is not None: + param = output + self._parameters[name] = param + + def add_module(self, name: str, module: Optional["Module"]) -> None: + if not isinstance(module, Module) and module is not None: + raise TypeError(f"{type(module)} is not a Module subclass") + elif not isinstance(name, str): + raise TypeError(f"module name should be a string. Got {type(name)}") + elif hasattr(self, name) and name not in self._modules: + raise KeyError(f"attribute '{name}' already exists") + elif "." in name: + raise KeyError(f'module name can\'t contain ".", got: {name}') + elif name == "": + raise KeyError('module name can\'t be empty string ""') + for hook in _global_module_registration_hooks.values(): + output = hook(self, name, module) + if output is not None: + module = output + self._modules[name] = module + + def register_module(self, name: str, module: Optional["Module"]) -> None: + r"""Alias for :func:`add_module`.""" + self.add_module(name, module) + + def get_submodule(self, target: str) -> "Module": + if target == "": + return self + + atoms: List[str] = target.split(".") + mod: Module = self + + for item in atoms: + + if not hasattr(mod, item): + raise AttributeError( + mod._get_name() + " has no attribute `" + item + "`" + ) + + mod = getattr(mod, item) + + if not isinstance(mod, Module): + raise AttributeError("`" + item + "` is not an nn.Module") + + return mod + + def get_parameter(self, target: str): + module_path, _, param_name = target.rpartition(".") + + mod: Module = self.get_submodule(module_path) + + if not hasattr(mod, param_name): + raise AttributeError( + mod._get_name() + " has no attribute `" + param_name + "`" + ) + + param: Parameter = getattr(mod, param_name) + + if not isinstance(param, Parameter): + raise AttributeError("`" + param_name + "` is not an nn.Parameter") + + return param + + def get_buffer(self, target: str): + module_path, _, buffer_name = target.rpartition(".") + + mod: Module = self.get_submodule(module_path) + + if not hasattr(mod, buffer_name): + raise AttributeError( + mod._get_name() + " has no attribute `" + buffer_name + "`" + ) + + buffer: Tensor = getattr(mod, buffer_name) + + if buffer_name not in mod._buffers: + raise AttributeError("`" + buffer_name + "` is not a buffer") + + return buffer + + def _named_members( + self, get_members_fn, prefix="", recurse=True, remove_duplicate: bool = True + ): + r"""Helper method for yielding various names + members of modules.""" + memo = set() + modules = ( + self.named_modules(prefix=prefix, remove_duplicate=remove_duplicate) + if recurse + else [(prefix, self)] + ) + for module_prefix, module in modules: + members = get_members_fn(module) + for k, v in members: + if v is None or v in memo: + continue + if remove_duplicate: + memo.add(v) + name = module_prefix + ("." if module_prefix else "") + k + yield name, v + + def parameters(self, recurse: bool = True) -> Iterator[Parameter]: + for name, param in self.named_parameters(recurse=recurse): + yield param + + def named_parameters( + self, prefix: str = "", recurse: bool = True, remove_duplicate: bool = True + ) -> Iterator[Tuple[str, Parameter]]: + gen = self._named_members( + lambda module: module._parameters.items(), + prefix=prefix, + recurse=recurse, + remove_duplicate=remove_duplicate, + ) + yield from gen + + def children(self) -> Iterator["Module"]: + for name, module in self.named_children(): + yield module + + def named_children(self) -> Iterator[Tuple[str, "Module"]]: + memo = set() + for name, module in self._modules.items(): + if module is not None and module not in memo: + memo.add(module) + yield name, module + + def modules(self) -> Iterator["Module"]: + for _, module in self.named_modules(): + yield module + + def named_modules( + self, + memo: Optional[Set["Module"]] = None, + prefix: str = "", + remove_duplicate: bool = True, + ): + if memo is None: + memo = set() + if self not in memo: + if remove_duplicate: + memo.add(self) + yield prefix, self + for name, module in self._modules.items(): + if module is None: + continue + submodule_prefix = prefix + ("." if prefix else "") + name + yield from module.named_modules( + memo, submodule_prefix, remove_duplicate + ) + + def train(self, mode: bool = True): + if not isinstance(mode, bool): + raise ValueError("training mode is expected to be boolean") + self.training = mode + for module in self.children(): + module.train(mode) + return self + + def eval(self): + return self.train(False) + + def requires_grad_(self, requires_grad: bool = True): + for p in self.parameters(): + p.requires_grad_(requires_grad) + return self + + def _get_name(self): + return self.__class__.__name__ + + def extra_repr(self) -> str: + return "" + + def register_full_backward_pre_hook( + self, + hook: Callable[["Module", _grad_t], Union[None, _grad_t]], + prepend: bool = False, + ) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle(self._backward_pre_hooks) + self._backward_pre_hooks[handle.id] = hook + if prepend: + self._backward_pre_hooks.move_to_end(handle.id, last=False) + return handle + + def register_backward_hook( + self, hook: Callable[["Module", _grad_t, _grad_t], Union[None, _grad_t]] + ) -> hooks.RemovableHandle: + if self._is_full_backward_hook is True: + raise RuntimeError( + "Cannot use both regular backward hooks and full backward hooks on a " + "single Module. Please use only one of them." + ) + + self._is_full_backward_hook = False + + handle = hooks.RemovableHandle(self._backward_hooks) + self._backward_hooks[handle.id] = hook + return handle + + def register_full_backward_hook( + self, + hook: Callable[["Module", _grad_t, _grad_t], Union[None, _grad_t]], + prepend: bool = False, + ) -> hooks.RemovableHandle: + if self._is_full_backward_hook is False: + raise RuntimeError( + "Cannot use both regular backward hooks and full backward hooks on a " + "single Module. Please use only one of them." + ) + + self._is_full_backward_hook = True + + handle = hooks.RemovableHandle(self._backward_hooks) + self._backward_hooks[handle.id] = hook + if prepend: + self._backward_hooks.move_to_end(handle.id, last=False) + return handle + + def _get_backward_hooks(self): + full_backward_hooks: List[Callable] = [] + if _global_is_full_backward_hook is True: + full_backward_hooks += _global_backward_hooks.values() + if self._is_full_backward_hook is True: + full_backward_hooks += self._backward_hooks.values() + + non_full_backward_hooks: List[Callable] = [] + if _global_is_full_backward_hook is False: + non_full_backward_hooks += _global_backward_hooks.values() + if self._is_full_backward_hook is False: + non_full_backward_hooks += self._backward_hooks.values() + + return full_backward_hooks, non_full_backward_hooks + + def _get_backward_pre_hooks(self): + backward_pre_hooks: List[Callable] = [] + backward_pre_hooks += _global_backward_pre_hooks.values() + backward_pre_hooks += self._backward_pre_hooks.values() + return backward_pre_hooks + + def _maybe_warn_non_full_backward_hook(self, inputs, result, grad_fn): + if not isinstance(result, Tensor): + if not ( + isinstance(result, tuple) and all(isinstance(r, Tensor) for r in result) + ): + warnings.warn( + "Using non-full backward hooks on a Module that does not return a" + " single Tensor or a tuple of Tensors is deprecated and will be" + " removed in future versions. This hook will be missing some of the" + " grad_output. Please use register_full_backward_hook to get the" + " documented behavior." + ) + return + else: + result = (result,) + + if not isinstance(inputs, Tensor): + if not ( + isinstance(inputs, tuple) and all(isinstance(i, Tensor) for i in inputs) + ): + warnings.warn( + "Using non-full backward hooks on a Module that does not take as" + " input a single Tensor or a tuple of Tensors is deprecated and" + " will be removed in future versions. This hook will be missing" + " some of the grad_input. Please use register_full_backward_hook to" + " get the documented behavior." + ) + return + else: + inputs = (inputs,) + + # At this point we are sure that inputs and result are tuple of Tensors + out_grad_fn = {r.grad_fn for r in result if r.grad_fn is not None} + if len(out_grad_fn) == 0 or ( + len(out_grad_fn) == 1 and grad_fn not in out_grad_fn + ): + warnings.warn( + "Using a non-full backward hook when outputs are nested in python data" + " structure is deprecated and will be removed in future versions. This" + " hook will be missing some grad_output." + ) + elif len(out_grad_fn) > 1: + warnings.warn( + "Using a non-full backward hook when outputs are generated by different" + " autograd Nodes is deprecated and will be removed in future versions." + " This hook will be missing some grad_output. Please use" + " register_full_backward_hook to get the documented behavior." + ) + else: + # At this point the grad_output part of the hook will most likely be correct + inputs_grad_fn = {i.grad_fn for i in inputs if i.grad_fn is not None} + + next_functions = {n[0] for n in grad_fn.next_functions} + + if inputs_grad_fn != next_functions: + warnings.warn( + "Using a non-full backward hook when the forward contains multiple" + " autograd Nodes is deprecated and will be removed in future" + " versions. This hook will be missing some grad_input. Please use" + " register_full_backward_hook to get the documented behavior." + ) + + def register_forward_pre_hook( + self, hook, *, prepend: bool = False, with_kwargs: bool = False + ) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle( + self._forward_pre_hooks, extra_dict=self._forward_pre_hooks_with_kwargs + ) + self._forward_pre_hooks[handle.id] = hook + if with_kwargs: + self._forward_pre_hooks_with_kwargs[handle.id] = True + + if prepend: + self._forward_pre_hooks.move_to_end(handle.id, last=False) + return handle + + def register_forward_hook( + self, + hook, + *, + prepend: bool = False, + with_kwargs: bool = False, + always_call: bool = False, + ) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle( + self._forward_hooks, + extra_dict=[ + self._forward_hooks_with_kwargs, + self._forward_hooks_always_called, + ], + ) + self._forward_hooks[handle.id] = hook + if with_kwargs: + self._forward_hooks_with_kwargs[handle.id] = True + if always_call: + self._forward_hooks_always_called[handle.id] = True + if prepend: + self._forward_hooks.move_to_end(handle.id, last=False) + return handle + + def _wrapped_call_impl(self, *args, **kwargs): + if self._compiled_call_impl is not None: + return self._compiled_call_impl(*args, **kwargs) + else: + return self._call_impl(*args, **kwargs) + + def _call_impl(self, *args, **kwargs): + forward_call = self.forward + # If we don't have any hooks, we want to skip the rest of the logic in + # this function, and just call forward. + if not ( + self._backward_hooks + or self._backward_pre_hooks + or self._forward_hooks + or self._forward_pre_hooks + or _global_backward_pre_hooks + or _global_backward_hooks + or _global_forward_hooks + or _global_forward_pre_hooks + ): + return forward_call(*args, **kwargs) + + try: + result = None + called_always_called_hooks = set() + + full_backward_hooks, non_full_backward_hooks = [], [] + backward_pre_hooks = [] + if self._backward_pre_hooks or _global_backward_pre_hooks: + backward_pre_hooks = self._get_backward_pre_hooks() + + if self._backward_hooks or _global_backward_hooks: + full_backward_hooks, non_full_backward_hooks = ( + self._get_backward_hooks() + ) + + if _global_forward_pre_hooks or self._forward_pre_hooks: + for hook_id, hook in ( + *_global_forward_pre_hooks.items(), + *self._forward_pre_hooks.items(), + ): + if hook_id in self._forward_pre_hooks_with_kwargs: + args_kwargs_result = hook(self, args, kwargs) + if args_kwargs_result is not None: + if ( + isinstance(args_kwargs_result, tuple) + and len(args_kwargs_result) == 2 + ): + args, kwargs = args_kwargs_result + else: + raise RuntimeError( + "forward pre-hook must return None or a tuple of" + " (new_args, new_kwargs), but got" + f" {args_kwargs_result}." + ) + else: + args_result = hook(self, args) + if args_result is not None: + if not isinstance(args_result, tuple): + args_result = (args_result,) + args = args_result + + bw_hook = None + if full_backward_hooks or backward_pre_hooks: + bw_hook = hooks.BackwardHook( + self, full_backward_hooks, backward_pre_hooks + ) + args = bw_hook.setup_input_hook(args) + + result = forward_call(*args, **kwargs) + if _global_forward_hooks or self._forward_hooks: + for hook_id, hook in ( + *_global_forward_hooks.items(), + *self._forward_hooks.items(), + ): + # mark that always called hook is run + if ( + hook_id in self._forward_hooks_always_called + or hook_id in _global_forward_hooks_always_called + ): + called_always_called_hooks.add(hook_id) + + if hook_id in self._forward_hooks_with_kwargs: + hook_result = hook(self, args, kwargs, result) + else: + hook_result = hook(self, args, result) + + if hook_result is not None: + result = hook_result + + if bw_hook: + if not isinstance(result, (Tensor, tuple)): + warnings.warn( + "For backward hooks to be called," + " module output should be a Tensor or a tuple of Tensors" + f" but received {type(result)}" + ) + result = bw_hook.setup_output_hook(result) + + # Handle the non-full backward hooks + if non_full_backward_hooks: + var = result + while not isinstance(var, Tensor): + if isinstance(var, dict): + var = next(v for v in var.values() if isinstance(v, Tensor)) + else: + var = var[0] + grad_fn = var.grad_fn + if grad_fn is not None: + for hook in non_full_backward_hooks: + grad_fn.register_hook(_WrappedHook(hook, self)) + self._maybe_warn_non_full_backward_hook(args, result, grad_fn) + + return result + + except Exception: + # run always called hooks if they have not already been run + # For now only forward hooks have the always_call option but perhaps + # this functionality should be added to full backward hooks as well. + for hook_id, hook in _global_forward_hooks.items(): + if ( + hook_id in _global_forward_hooks_always_called + and hook_id not in called_always_called_hooks + ): + try: + hook_result = hook(self, args, result) + if hook_result is not None: + result = hook_result + except Exception as e: + warnings.warn( + "global module forward hook with ``always_call=True``" + " raised an exception that was silenced as another error" + f" was raised in forward: {str(e)}" + ) + continue + + for hook_id, hook in self._forward_hooks.items(): + if ( + hook_id in self._forward_hooks_always_called + and hook_id not in called_always_called_hooks + ): + try: + if hook_id in self._forward_hooks_with_kwargs: + hook_result = hook(self, args, kwargs, result) + else: + hook_result = hook(self, args, result) + if hook_result is not None: + result = hook_result + except Exception as e: + warnings.warn( + "module forward hook with ``always_call=True`` raised an" + " exception that was silenced as another error was raised" + f" in forward: {str(e)}" + ) + continue + # raise exception raised in try block + raise + + __call__: Callable[..., Any] = _wrapped_call_impl + + def __getattribute__(self, name: str) -> Any: + if name in ("__dict__", "v", "buffers"): + return super(Module, self).__getattribute__(name) + if "_parameters" in self.__dict__: + _parameters = self.__dict__["_parameters"] + if name in _parameters: + return _parameters[name] + if "_buffers" in self.__dict__: + _buffers = self.__dict__["_buffers"] + if name in _buffers: + return _buffers[name] + if "_modules" in self.__dict__: + modules = self.__dict__["_modules"] + if name in modules: + return modules[name] + return super(Module, self).__getattribute__(name) + + def __setattr__(self, name: str, value: Union[Tensor, "Module"]) -> None: + if name == "weight": + pass + + def remove_from(*dicts_or_sets): + for d in dicts_or_sets: + if name in d: + if isinstance(d, dict): + del d[name] + else: + d.discard(name) + + params = self.__dict__.get("_parameters") + if isinstance(value, Parameter): + if params is None: + raise AttributeError( + "cannot assign parameters before Module.__init__() call" + ) + remove_from( + self.__dict__, + self._buffers, + self._modules, + self._non_persistent_buffers_set, + ) + self.register_parameter(name, value) + elif params is not None and name in params: + if value is not None: + raise TypeError( + f"cannot assign '{type(value)}' as parameter '{name}' " + "(torch.nn.Parameter or None expected)" + ) + self.register_parameter(name, value) + else: + modules = self.__dict__.get("_modules") + if isinstance(value, Module): + if modules is None: + raise AttributeError( + "cannot assign module before Module.__init__() call" + ) + remove_from( + self.__dict__, + self._parameters, + self._buffers, + self._non_persistent_buffers_set, + ) + for hook in _global_module_registration_hooks.values(): + output = hook(self, name, value) + if output is not None: + value = output + modules[name] = value + elif modules is not None and name in modules: + if value is not None: + raise TypeError( + f"cannot assign '{type(value)}' as child module '{name}' " + "(torch.nn.Module or None expected)" + ) + for hook in _global_module_registration_hooks.values(): + output = hook(self, name, value) + if output is not None: + value = output + modules[name] = value + else: + buffers = self.__dict__.get("_buffers") + if buffers is not None and name in buffers: + if value is not None and not isinstance(value, Tensor): + raise TypeError( + f"cannot assign '{type(value)}' as buffer '{name}' " + "(torch.Tensor or None expected)" + ) + for hook in _global_buffer_registration_hooks.values(): + output = hook(self, name, value) + if output is not None: + value = output + buffers[name] = value + else: + super().__setattr__(name, value) + + def __delattr__(self, name): + if name in self._parameters: + del self._parameters[name] + elif name in self._buffers: + del self._buffers[name] + self._non_persistent_buffers_set.discard(name) + elif name in self._modules: + del self._modules[name] + else: + super().__delattr__(name) + + def _register_state_dict_hook(self, hook): + handle = hooks.RemovableHandle(self._state_dict_hooks) + self._state_dict_hooks[handle.id] = hook + return handle + + def register_state_dict_pre_hook(self, hook): + handle = hooks.RemovableHandle(self._state_dict_pre_hooks) + self._state_dict_pre_hooks[handle.id] = hook + return handle + + def __repr__(self): + # We treat the extra repr like the sub-module, one item per line + extra_lines = [] + extra_repr = self.extra_repr() + # empty string will be split into list [''] + if extra_repr: + extra_lines = extra_repr.split("\n") + child_lines = [] + for key, module in self._modules.items(): + mod_str = repr(module) + mod_str = _addindent(mod_str, 2) + child_lines.append("(" + key + "): " + mod_str) + lines = extra_lines + child_lines + + main_str = self._get_name() + "(" + if lines: + # simple one-liner info, which most builtin Modules will use + if len(extra_lines) == 1 and not child_lines: + main_str += extra_lines[0] + else: + main_str += "\n " + "\n ".join(lines) + "\n" + + main_str += ")" + return main_str + + def __dir__(self): + module_attrs = dir(self.__class__) + attrs = list(self.__dict__.keys()) + parameters = list(self._parameters.keys()) + modules = list(self._modules.keys()) + buffers = list(self._buffers.keys()) + keys = module_attrs + attrs + parameters + modules + buffers + + # Eliminate attrs that are not legal Python variable names + keys = [key for key in keys if not key[0].isdigit()] + + return sorted(keys) + + +# --- Helpers --- # +# --------------- # + + +def _addindent(s_, numSpaces): + s = s_.split("\n") + # don't do anything for single-line stuff + if len(s) == 1: + return s_ + first = s.pop(0) + s = [(numSpaces * " ") + line for line in s] + s = "\n".join(s) + s = first + "\n" + s + + return s + + +# --- Main --- # +# ------------ # + + +def register_module_backward_hook( + hook: Callable[["Module", _grad_t, _grad_t], Union[None, _grad_t]] +) -> hooks.RemovableHandle: + global _global_is_full_backward_hook + if _global_is_full_backward_hook is True: + raise RuntimeError( + "Cannot use both regular backward hooks and full backward hooks as a " + "global Module hook. Please use only one of them." + ) + + _global_is_full_backward_hook = False + + handle = hooks.RemovableHandle(_global_backward_hooks) + _global_backward_hooks[handle.id] = hook + return handle + + +def register_module_buffer_registration_hook( + hook: Callable[..., None] +) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle(_global_buffer_registration_hooks) + _global_buffer_registration_hooks[handle.id] = hook + return handle + + +def register_module_forward_hook( + hook: Callable[..., None], *, always_call: bool = False +) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle( + _global_forward_hooks, extra_dict=_global_forward_hooks_always_called + ) + _global_forward_hooks[handle.id] = hook + if always_call: + _global_forward_hooks_always_called[handle.id] = True + return handle + + +def register_module_forward_pre_hook( + hook: Callable[..., None] +) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle(_global_forward_pre_hooks) + _global_forward_pre_hooks[handle.id] = hook + return handle + + +def register_module_full_backward_hook( + hook: Callable[["Module", _grad_t, _grad_t], Union[None, _grad_t]] +) -> hooks.RemovableHandle: + global _global_is_full_backward_hook + if _global_is_full_backward_hook is False: + raise RuntimeError( + "Cannot use both regular backward hooks and full backward hooks as a " + "global Module hook. Please use only one of them." + ) + + _global_is_full_backward_hook = True + + handle = hooks.RemovableHandle(_global_backward_hooks) + _global_backward_hooks[handle.id] = hook + return handle + + +def register_module_full_backward_pre_hook( + hook: Callable[["Module", _grad_t], Union[None, _grad_t]] +) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle(_global_backward_pre_hooks) + _global_backward_pre_hooks[handle.id] = hook + return handle + + +def register_module_module_registration_hook( + hook: Callable[..., None] +) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle(_global_module_registration_hooks) + _global_module_registration_hooks[handle.id] = hook + return handle + + +def register_module_parameter_registration_hook( + hook: Callable[..., None] +) -> hooks.RemovableHandle: + handle = hooks.RemovableHandle(_global_parameter_registration_hooks) + _global_parameter_registration_hooks[handle.id] = hook + return handle + + +r"""This tracks hooks common to all modules that are executed immediately before +.registering the buffer/module/parameter""" +_global_buffer_registration_hooks: Dict[int, Callable] = OrderedDict() +_global_module_registration_hooks: Dict[int, Callable] = OrderedDict() +_global_parameter_registration_hooks: Dict[int, Callable] = OrderedDict() +r""" +This tracks hooks common to all modules that are executed before/after calling forward +and backward. + +This is global state used for debugging/profiling purposes +""" +_global_backward_pre_hooks: Dict[int, Callable] = OrderedDict() +_global_backward_hooks: Dict[int, Callable] = OrderedDict() +_global_is_full_backward_hook: Optional[bool] = None +_global_forward_pre_hooks: Dict[int, Callable] = OrderedDict() +_global_forward_hooks: Dict[int, Callable] = OrderedDict() +_global_forward_hooks_always_called: Dict[int, bool] = OrderedDict() diff --git a/ivy/functional/frontends/torch/nn/parameter.py b/ivy/functional/frontends/torch/nn/parameter.py new file mode 100644 index 0000000000000..d50820f01035d --- /dev/null +++ b/ivy/functional/frontends/torch/nn/parameter.py @@ -0,0 +1,18 @@ +from ivy.functional.frontends.torch.tensor import Tensor + + +class Parameter(Tensor): + def __init__(self, array, device=None, _init_overload=False, requires_grad=True): + super().__init__(array, device, _init_overload, requires_grad) + + def __deepcopy__(self, memo): + # TODO: Need to add test. Adding for KLA demo (priority) + if id(self) in memo: + return memo[id(self)] + else: + result = type(self)(self.data.clone(), self.requires_grad) + memo[id(self)] = result + return result + + def __repr__(self): + return "Parameter containing:\n" + super().__repr__() diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index d430edb6105c5..e25fcd6ecb11b 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -44,6 +44,10 @@ def __repr__(self): "ivy.array", "ivy.frontends.torch.Tensor" ) + def __hash__(self): + # TODO: Need to add test. Adding for KLA demo (priority) + return id(self) + # Properties # # ---------- # @@ -1991,6 +1995,16 @@ def random_( ) return self.ivy_array + def uniform_(self, from_=0, to=1, *, generator=None): + # TODO: Need to add test. Adding for KLA demo (priority) + ret = ivy.random_uniform( + low=from_, high=to, shape=self.shape, dtype=self.dtype, seed=generator + ) + self._ivy_array = ivy.inplace_update( + self._ivy_array, ivy.astype(ret, self._ivy_array.dtype) + ) + return self + @with_unsupported_dtypes( { "2.1.0 and below": ( diff --git a/ivy/functional/frontends/torch/utils/__init__.py b/ivy/functional/frontends/torch/utils/__init__.py new file mode 100644 index 0000000000000..88be3837977fe --- /dev/null +++ b/ivy/functional/frontends/torch/utils/__init__.py @@ -0,0 +1 @@ +from . import hooks diff --git a/ivy/functional/frontends/torch/utils/hooks.py b/ivy/functional/frontends/torch/utils/hooks.py new file mode 100644 index 0000000000000..dccc79e3560ce --- /dev/null +++ b/ivy/functional/frontends/torch/utils/hooks.py @@ -0,0 +1,231 @@ +import torch +from collections import OrderedDict +import weakref +from typing import Any, Tuple + + +class RemovableHandle: + id: int + next_id: int = 0 + + def __init__(self, hooks_dict: Any, *, extra_dict: Any = None) -> None: + self.hooks_dict_ref = weakref.ref(hooks_dict) + self.id = RemovableHandle.next_id + RemovableHandle.next_id += 1 + + self.extra_dict_ref: Tuple = () + if isinstance(extra_dict, dict): + self.extra_dict_ref = (weakref.ref(extra_dict),) + elif isinstance(extra_dict, list): + self.extra_dict_ref = tuple(weakref.ref(d) for d in extra_dict) + + def remove(self) -> None: + hooks_dict = self.hooks_dict_ref() + if hooks_dict is not None and self.id in hooks_dict: + del hooks_dict[self.id] + + for ref in self.extra_dict_ref: + extra_dict = ref() + if extra_dict is not None and self.id in extra_dict: + del extra_dict[self.id] + + def __getstate__(self): + if self.extra_dict_ref is None: + return (self.hooks_dict_ref(), self.id) + else: + return ( + self.hooks_dict_ref(), + self.id, + tuple(ref() for ref in self.extra_dict_ref), + ) + + def __setstate__(self, state) -> None: + if state[0] is None: + # create a dead reference + self.hooks_dict_ref = weakref.ref(OrderedDict()) + else: + self.hooks_dict_ref = weakref.ref(state[0]) + self.id = state[1] + RemovableHandle.next_id = max(RemovableHandle.next_id, self.id + 1) + + if len(state) < 3 or state[2] is None: + self.extra_dict_ref = () + else: + self.extra_dict_ref = tuple(weakref.ref(d) for d in state[2]) + + def __enter__(self) -> "RemovableHandle": + return self + + def __exit__(self, type: Any, value: Any, tb: Any) -> None: + self.remove() + + +class BackwardHook: + def __init__(self, module, user_hooks, user_pre_hooks): + self.user_hooks = user_hooks + self.user_pre_hooks = user_pre_hooks + self.module = module + + self.grad_outputs = None + self.n_outputs = -1 + self.output_tensors_index = None + self.n_inputs = -1 + self.input_tensors_index = None + + def _pack_with_none(self, indices, values, size): + res = [None] * size + for idx, val in zip(indices, values): + res[idx] = val + + return tuple(res) + + def _unpack_none(self, indices, values): + res = [] + for idx in indices: + res.append(values[idx]) + + return tuple(res) + + def _set_user_hook(self, grad_fn): + def hook(grad_input, _): + if self.grad_outputs is None: + # This happens because the gradient in your nn.Module flows to + # the Module's input without " passing through the Module's + # output, e.g. when you're doing double backward. + return + res = self._pack_with_none( + self.input_tensors_index, grad_input, self.n_inputs + ) + + for hook in self.user_hooks: + out = hook(self.module, res, self.grad_outputs) + + if out is None: + continue + + if len(out) != len(res): + raise RuntimeError( + "Backward hook returned an invalid number of grad_input, " + f"got {len(out)}, but expected {len(res)}" + ) + + res = out + + self.grad_outputs = None + + return self._unpack_none(self.input_tensors_index, res) + + grad_fn.register_hook(hook) + + def _apply_on_tensors(self, fn, args): + # Can be used to apply the given function to the tensors contained in the + # args. Will return updated args and the tensors indices + tensors_idx = [] + tensors = [] + + requires_grad = False + for i, arg in enumerate(args): + if isinstance(arg, torch.Tensor): + tensors_idx.append(i) + tensors.append(arg) + requires_grad |= arg.requires_grad + + if not (requires_grad and torch.is_grad_enabled()): + return args, None + + new_tensors = torch.nn.modules._functions.BackwardHookFunction.apply(*tensors) + if len(new_tensors) == 0: + raise RuntimeError( + "Cannot set Module backward hook for a Module with no input Tensors." + ) + + grad_fns = [ + t.grad_fn + for t in new_tensors + if t.grad_fn is not None + and t.grad_fn.name() == "BackwardHookFunctionBackward" + ] + if len(grad_fns) == 0: + raise RuntimeError( + "Error while setting up backward hooks. Please open " + "an issue with a code sample to reproduce this." + ) + + fn(grad_fns[0]) + + arg_list = list(args) + for idx, val in zip(tensors_idx, new_tensors): + arg_list[idx] = val + + return tuple(arg_list), tensors_idx + + def setup_input_hook(self, args): + def fn(grad_fn): + self._set_user_hook(grad_fn) + + res, input_idx = self._apply_on_tensors(fn, args) + self.n_inputs = len(args) + self.input_tensors_index = input_idx + return res + + def setup_output_hook(self, args): + def fn(grad_fn): + def hook(_, grad_output): + self.grad_outputs = self._pack_with_none( + self.output_tensors_index, grad_output, self.n_outputs + ) + + if self.user_pre_hooks: + expected_len = len(self.grad_outputs) + for user_pre_hook in self.user_pre_hooks: + hook_grad_outputs = user_pre_hook( + self.module, self.grad_outputs + ) + if hook_grad_outputs is None: + continue + + actual_len = len(hook_grad_outputs) + if actual_len != expected_len: + raise RuntimeError( + "Backward pre hook returned an invalid number of" + f" grad_output, got {actual_len}, but expected" + f" {expected_len}" + ) + self.grad_outputs = hook_grad_outputs + + # Special case if no input required gradients, + # this hook should call the user hook directly + if self.input_tensors_index is None: + grad_inputs = self._pack_with_none([], [], self.n_inputs) + for user_hook in self.user_hooks: + res = user_hook(self.module, grad_inputs, self.grad_outputs) + if res is not None and not ( + isinstance(res, tuple) and all(el is None for el in res) + ): + raise RuntimeError( + "Backward hook for Modules where no input requires" + " gradient should always return None or None for all" + " gradients." + ) + self.grad_outputs = None + + if self.grad_outputs is not None: + assert self.output_tensors_index is not None # mypy + return tuple( + self.grad_outputs[i] for i in self.output_tensors_index + ) + + grad_fn.register_hook(hook) + + is_tuple = True + if not isinstance(args, tuple): + args = (args,) + is_tuple = False + + res, output_idx = self._apply_on_tensors(fn, args) + self.n_outputs = len(args) + self.output_tensors_index = output_idx + + if not is_tuple: + res = res[0] + return res diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index cb573bfb8ee9d..b787df41c5253 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -1,6 +1,7 @@ """Converters from Native Modules to Ivy Modules.""" # global +import importlib from typing import Optional, Dict, List import re # noqa import inspect @@ -437,3 +438,86 @@ def from_torch_module( inplace_update=inplace_update, **i_kwargs, ) + + def to_keras_module(self): + class KerasModel(importlib.import_module("tensorflow").keras.Model): + def __init__(self, ivy_module): + super(KerasModel, self).__init__() + self._ivy_module = ivy_module + self._parameters_converted = False + self._assign_variables() + + def _assign_variables(self): + ivy.set_backend("tensorflow") + + self._ivy_module.v = self._ivy_module.v.cont_map( + lambda x, kc: ( + x.ivy_array.data + if hasattr(x, "_ivy_array") + else ivy.to_native(x, nested=False, cont_inplace=True) + ) + ) + + self._ivy_module.v = self._ivy_module.v.cont_map( + lambda x, kc: ivy.array_to_new_backend(x, native=True) + ) + self._ivy_module.v.cont_map( + lambda x, kc: self.add_weight( + name=kc, shape=x.shape, dtype=x.dtype, trainable=True + ) + ) + model_weights = list() + self._ivy_module.v.cont_map( + lambda x, kc: model_weights.append(ivy.to_numpy(x)) + ) + self.set_weights(model_weights) + + ivy.previous_backend() + + def call(self, *args, **kwargs): + if not self._parameters_converted: + params = { + re.sub(r":([0-9]+)$", "", param.name).replace( + f"{self.name}/", "" + ): param + for param in self.variables + } + self._ivy_module.v = self._ivy_module.v.cont_map( + lambda _, kc: params[kc] + ) + self._parameters_converted = True + if "training" in kwargs: + del kwargs["training"] + ret = self._ivy_module(*args, **kwargs) + ret = ivy.nested_map( + lambda x: ( + x.ivy_array.data + if hasattr(x, "_ivy_array") + else ivy.to_native(x, nested=False) + ), + ret, + ) + return ret + + def __call__(self, *args, **kwargs): + ivy.set_backend("tensorflow") + args = ivy.nest_array_to_new_backend(args, native=True) + kwargs = ivy.nest_array_to_new_backend(kwargs, native=True) + ivy.previous_backend() + + return super(KerasModel, self).__call__(*args, **kwargs) + + def to_device(self, device): + self._ivy_module._module_graph.to_device(device) + model_weights = ivy.nested_map( + lambda x: ( + ivy.to_native(ivy.to_device(x, device)) + if ivy.is_array(x) + else x + ), + self.weights, + ) + self.set_weights(model_weights) + + keras_module = KerasModel(self) + return keras_module From 786130a81b2af83e3815dc8eaaddf9e9b99ebc1e Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Sun, 5 Nov 2023 05:24:24 -0800 Subject: [PATCH 117/978] Revert back recent changes made to avg_pool functions (#27211) --- .../torch/nn/functional/pooling_functions.py | 30 +++++++++++++++++-- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 46f2dec6a5dea..f2cd213d9b0ee 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -94,11 +94,19 @@ def avg_pool1d( ceil_mode=False, count_include_pad=True, ): + kernel_size = _broadcast_pooling_helper(kernel_size, "1d", name="kernel_size") + padding = _broadcast_pooling_helper(padding, "1d", name="padding") + if all( + [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] + ): + padding = "SAME" + else: + padding = "VALID" return ivy.avg_pool1d( input, kernel_size, stride if stride is not None else kernel_size, - [(pad, pad) for pad in padding], + padding, data_format="NCW", count_include_pad=count_include_pad, ceil_mode=ceil_mode, @@ -119,11 +127,19 @@ def avg_pool2d( count_include_pad=True, divisor_override=None, ): + kernel_size = _broadcast_pooling_helper(kernel_size, "2d", name="kernel_size") + padding = _broadcast_pooling_helper(padding, "2d", name="padding") + if all( + [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] + ): + padding = "SAME" + else: + padding = "VALID" return ivy.avg_pool2d( input, kernel_size, stride if stride is not None else kernel_size, - [(pad, pad) for pad in padding], + padding, data_format="NCHW", ceil_mode=ceil_mode, count_include_pad=count_include_pad, @@ -145,11 +161,19 @@ def avg_pool3d( count_include_pad=True, divisor_override=None, ): + kernel_size = _broadcast_pooling_helper(kernel_size, "3d", name="kernel_size") + padding = _broadcast_pooling_helper(padding, "3d", name="padding") + if all( + [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] + ): + padding = "SAME" + else: + padding = "VALID" return ivy.avg_pool3d( input, kernel_size, stride if stride is not None else kernel_size, - [(pad, pad) for pad in padding], + padding, data_format="NCDHW", ceil_mode=ceil_mode, count_include_pad=count_include_pad, From 82986f40c8f2e72dbfd5aee902dc34cb478348d9 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Sun, 5 Nov 2023 05:29:35 -0800 Subject: [PATCH 118/978] fix: Explicitly set requires_grad=False on torch Modules until backprop through the frontends has been fixed (#27212) --- ivy/functional/frontends/torch/nn/modules/module.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 160fc399da40a..c0a43fd8475b0 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -564,6 +564,8 @@ def _wrapped_call_impl(self, *args, **kwargs): return self._call_impl(*args, **kwargs) def _call_impl(self, *args, **kwargs): + # TODO: Remove this once backprop through the frontends is fixed + self.requires_grad_(False) forward_call = self.forward # If we don't have any hooks, we want to skip the rest of the logic in # this function, and just call forward. From db29ee5d603d25be7cb0c15700154c86557e01e0 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 6 Nov 2023 22:08:22 +0530 Subject: [PATCH 119/978] fix: Removed duplicate Data Type Attributes in `class SupportedDtypes` (#27214) --- ivy_tests/test_ivy/test_frontends/config/base.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/config/base.py b/ivy_tests/test_ivy/test_frontends/config/base.py index 30c279418d94b..12c0eaeaee15b 100644 --- a/ivy_tests/test_ivy/test_frontends/config/base.py +++ b/ivy_tests/test_ivy/test_frontends/config/base.py @@ -25,9 +25,6 @@ class SupportedDtypes: valid_uint_dtypes: List[str] invalid_uint_dtypes: List[str] - valid_uint_dtypes: List[str] - invalid_uint_dtypes: List[str] - valid_float_dtypes: List[str] invalid_float_dtypes: List[str] From ba94b15ee45f1b333c3f31739025525acb390c9b Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 7 Nov 2023 12:28:07 +0530 Subject: [PATCH 120/978] fix: some fixes to torch.autograd.backward (#27216) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1. Updated the torch frontend GradFn to allow more than 2 inputs and also keyword arguments to be leaf nodes in the graph based on the function being called. 2. Made changes to the logic used for computing jacobians in the chain where the current computed jacobian is of shape (layer_out_dim, layer_in_dim) and the prev_grads is of shape (out_dim, layer_out_dim) and also added missing checks to avoid generating a ivy.jac callback for inputs which don’t require grad. --- .../frontends/torch/func_wrapper.py | 93 +++++++++---------- 1 file changed, 45 insertions(+), 48 deletions(-) diff --git a/ivy/functional/frontends/torch/func_wrapper.py b/ivy/functional/frontends/torch/func_wrapper.py index 8f97234a60295..c79cdd9782ceb 100644 --- a/ivy/functional/frontends/torch/func_wrapper.py +++ b/ivy/functional/frontends/torch/func_wrapper.py @@ -29,65 +29,59 @@ def __eq__(self, __value: object) -> bool: return self.__name__ == __value def __call__(self, grads): - for i in range(self.__self__.ndim): - grads = grads.sum(-1) self.__self__._grads = grads return None class GradFn: - def __init__(self, fn, inputs) -> None: + def __init__(self, fn, args, kwargs) -> None: self._inputs = [] self._fns = [] self.next_functions = [] - assert len(inputs) <= 2 - if len(inputs) == 1 and isinstance(inputs[0], torch_frontend.Tensor): - self._inputs.append(inputs[0].detach()) - - def d_fn(x): - return fn(x) - - self._fns.append(to_ivy_arrays_and_back(ivy.jac(d_fn))) - if inputs[0].grad_fn is not None: - self.next_functions.append(inputs[0].grad_fn) - elif inputs[0].requires_grad and inputs[0].is_leaf: - acc_grad = AccumulateGrad() - acc_grad.__self__ = inputs[0] - self.next_functions.append(acc_grad) - elif len(inputs) == 2: - if isinstance(inputs[0], torch_frontend.Tensor): - self._inputs.append(inputs[0].detach()) - - def d_fn(x): - return fn(x, inputs[1]) - - self._fns.append(to_ivy_arrays_and_back(ivy.jac(d_fn))) - if inputs[0].grad_fn is not None: - self.next_functions.append(inputs[0].grad_fn) - elif inputs[0].requires_grad and inputs[0].is_leaf: + for idx, input in [*enumerate(args), *kwargs.items()]: + if isinstance(input, torch_frontend.Tensor) and input.requires_grad: + self._inputs.append(input.detach()) + + def wrap_fn(idx): + def d_fn(x): + if idx in kwargs: + return fn( + *args, + **{ + key: value + for key, value in kwargs.items() + if key != idx + }, + idx=x, + ) + return fn(*args[:idx], x, *args[idx + 1 :], **kwargs) + + return d_fn + + self._fns.append(to_ivy_arrays_and_back(ivy.jac(wrap_fn(idx)))) + if input.grad_fn is not None: + self.next_functions.append(input.grad_fn) + elif input.is_leaf: acc_grad = AccumulateGrad() - acc_grad.__self__ = inputs[0] - self.next_functions.append(acc_grad) - if isinstance(inputs[1], torch_frontend.Tensor): - self._inputs.append(inputs[1].detach()) - - def d_fn(x): - return fn(inputs[0], x) - - self._fns.append(to_ivy_arrays_and_back(ivy.jac(d_fn))) - if inputs[1].grad_fn is not None: - self.next_functions.append(inputs[1].grad_fn) - elif inputs[1].requires_grad and inputs[1].is_leaf: - acc_grad = AccumulateGrad() - acc_grad.__self__ = inputs[1] + acc_grad.__self__ = input self.next_functions.append(acc_grad) self.__name__ = fn.__name__.capitalize() + "Backward" def __call__(self, prev_grads): - return [ - jac_fn(input_tensor) * prev_grads - for input_tensor, jac_fn in zip(self._inputs, self._fns) - ] + result = [] + for input_tensor, jac_fn in zip(self._inputs, self._fns): + jacobian = jac_fn(input_tensor) + dims = list(range(jacobian.dim())) + permuted_dims = dims[input_tensor.dim() :] + dims[: input_tensor.dim()] + result.append( + ( + jacobian.permute(dims=permuted_dims).reshape( + shape=(*input_tensor.shape, -1) + ) + * prev_grads.ravel() + ).sum(-1) + ) + return result def __repr__(self): return self.__name__ @@ -245,9 +239,12 @@ def array_fn(x): else: ret.is_leaf = False # set grad_fn - if any(isinstance(i, torch_frontend.Tensor) and i.requires_grad for i in args): + if any( + isinstance(i, torch_frontend.Tensor) and i.requires_grad + for i in [*args, *kwargs.values()] + ): # ToDo: Implement for unbind - grad_fn = GradFn(fn, args) + grad_fn = GradFn(fn, args, kwargs) grad_fn.__self__ = ret ret.grad_fn = grad_fn From d0fe54dfe2fe6e8436168c36b92599aa628f2210 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Tue, 7 Nov 2023 02:55:07 -0800 Subject: [PATCH 121/978] feat: Add checks to handle `tf.TensorArrays` used extensively by `tf.keras.LSTM` (#27222) --- ivy/data_classes/array/array.py | 3 +++ ivy/functional/backends/tensorflow/creation.py | 12 +++++++++--- ivy/functional/backends/tensorflow/device.py | 5 ++++- ivy/functional/backends/tensorflow/general.py | 2 +- 4 files changed, 17 insertions(+), 5 deletions(-) diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 46aa785c67afe..df2981fc2b9f3 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -262,6 +262,9 @@ def shape(self) -> ivy.Shape: def size(self) -> Optional[int]: """Number of elements in the array.""" if self._size is None: + if hasattr(self._data, "size") and callable(self._data.size): + self._size = self._data.size() + return self._size self._size = ( functools.reduce(mul, self._data.shape) if len(self._data.shape) > 0 diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py index 7bd7f0b2d6b14..614f8a9153950 100644 --- a/ivy/functional/backends/tensorflow/creation.py +++ b/ivy/functional/backends/tensorflow/creation.py @@ -350,14 +350,20 @@ def zeros_like( def copy_array( - x: Union[tf.Tensor, tf.Variable], + x: Union[tf.Tensor, tf.Variable, tf.TensorArray], *, to_ivy_array: bool = True, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: + if isinstance(x, tf.TensorArray): + x_wrapped = x.stack() + y = tf.TensorArray(x.dtype, x.size()) + x = y.unstack(ivy.copy_array(x_wrapped)) + else: + x = tf.identity(x) if to_ivy_array: - return ivy.to_ivy(tf.identity(x)) - return tf.identity(x) + return ivy.to_ivy(x) + return x def one_hot( diff --git a/ivy/functional/backends/tensorflow/device.py b/ivy/functional/backends/tensorflow/device.py index 09416a79ffc02..cff1e2e23c627 100644 --- a/ivy/functional/backends/tensorflow/device.py +++ b/ivy/functional/backends/tensorflow/device.py @@ -24,11 +24,14 @@ def _same_device(dev_a, dev_b): def dev( - x: Union[tf.Tensor, tf.Variable], + x: Union[tf.Tensor, tf.Variable, tf.TensorArray], /, *, as_native: bool = False, ) -> Union[ivy.Device, str]: + if isinstance(x, tf.TensorArray): + # Read the underlying tensor being wrapped to get the device. + x = x.stack() dv = x.device if as_native: return dv diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index bc70f80919cac..861d3322d5bd4 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -24,7 +24,7 @@ def is_native_array(x, /, *, exclusive=False): - if isinstance(x, (tf.Tensor, tf.Variable)): + if isinstance(x, (tf.Tensor, tf.Variable, tf.TensorArray)): if exclusive and isinstance(x, tf.Variable): return False return True From f10e5a960b07a008dc02e426da745a4248235d99 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 7 Nov 2023 12:37:24 +0000 Subject: [PATCH 122/978] fix: Fixed missing argument error in ivy avg_pool1d --- .../backends/jax/experimental/layers.py | 1 + .../backends/mxnet/experimental/layers.py | 1 + .../backends/numpy/experimental/layers.py | 1 + .../backends/paddle/experimental/layers.py | 1 + .../backends/tensorflow/experimental/layers.py | 17 +++++++++-------- .../backends/torch/experimental/layers.py | 1 + 6 files changed, 14 insertions(+), 8 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index c409337ed7df0..5ed9c2809931d 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -295,6 +295,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, + divisor_override: Optional[int] = None, out: Optional[JaxArray] = None, ) -> JaxArray: if data_format in ("NCW", "NCL"): diff --git a/ivy/functional/backends/mxnet/experimental/layers.py b/ivy/functional/backends/mxnet/experimental/layers.py index 618f365a0e65b..854cc5d46dfbb 100644 --- a/ivy/functional/backends/mxnet/experimental/layers.py +++ b/ivy/functional/backends/mxnet/experimental/layers.py @@ -80,6 +80,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, + divisor_override: Optional[int] = None, out: Optional[mx.nd.NDArray] = None, ) -> mx.nd.NDArray: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index 7f11ed19c4848..7491303384df3 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -392,6 +392,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, + divisor_override: Optional[int] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: if isinstance(kernel, int): diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index 999e01ef87bf3..fabf837f023f0 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -249,6 +249,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, + divisor_override: Optional[int] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index a75fd79321f50..6613eb3e12947 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -288,6 +288,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, + divisor_override: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: if isinstance(kernel, int): @@ -364,14 +365,14 @@ def avg_pool2d( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: if isinstance(kernel, int): - kernel = [kernel] * 2 + kernel = (kernel,) * 2 elif len(kernel) == 1: - kernel = [kernel[0]] * 2 + kernel = (kernel[0],) * 2 if isinstance(strides, int): - strides = [strides] * 2 + strides = (strides,) * 2 elif len(strides) == 1: - strides = [strides[0]] * 2 + strides = (strides[0],) * 2 if data_format == "NCHW": x = tf.transpose(x, (0, 2, 3, 1)) @@ -456,14 +457,14 @@ def avg_pool3d( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: if isinstance(kernel, int): - kernel = [kernel] * 3 + kernel = (kernel,) * 3 elif len(kernel) == 1: - kernel = [kernel[0]] * 3 + kernel = (kernel[0],) * 3 if isinstance(strides, int): - strides = [strides] * 3 + strides = (strides,) * 3 elif len(strides) == 1: - strides = [strides[0]] * 3 + strides = (strides[0],) * 3 if data_format == "NCDHW": x = tf.transpose(x, (0, 2, 3, 4, 1)) diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 6fd6b8e7aac07..efd3547ce4142 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -322,6 +322,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, + divisor_override: Optional[int] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if isinstance(strides, int): From 90cf3ae0be1c9dce78b6c2a54f774d0be57de714 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 7 Nov 2023 12:42:50 +0000 Subject: [PATCH 123/978] fix: Fixed mispelled argument --- ivy/functional/backends/jax/experimental/layers.py | 2 +- ivy/functional/backends/mxnet/experimental/layers.py | 2 +- ivy/functional/backends/numpy/experimental/layers.py | 2 +- ivy/functional/backends/paddle/experimental/layers.py | 2 +- ivy/functional/backends/tensorflow/experimental/layers.py | 2 +- ivy/functional/backends/torch/experimental/layers.py | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 5ed9c2809931d..2b355189505eb 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -295,7 +295,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - divisor_override: Optional[int] = None, + division_override: Optional[int] = None, out: Optional[JaxArray] = None, ) -> JaxArray: if data_format in ("NCW", "NCL"): diff --git a/ivy/functional/backends/mxnet/experimental/layers.py b/ivy/functional/backends/mxnet/experimental/layers.py index 854cc5d46dfbb..955a02e69b9ea 100644 --- a/ivy/functional/backends/mxnet/experimental/layers.py +++ b/ivy/functional/backends/mxnet/experimental/layers.py @@ -80,7 +80,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - divisor_override: Optional[int] = None, + division_override: Optional[int] = None, out: Optional[mx.nd.NDArray] = None, ) -> mx.nd.NDArray: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index 7491303384df3..8d3b704ed006a 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -392,7 +392,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - divisor_override: Optional[int] = None, + division_override: Optional[int] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: if isinstance(kernel, int): diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index fabf837f023f0..c9b604e69ecfa 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -249,7 +249,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - divisor_override: Optional[int] = None, + division_override: Optional[int] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 6613eb3e12947..3aaceead903de 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -288,7 +288,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - divisor_override: Optional[int] = None, + division_override: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: if isinstance(kernel, int): diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index efd3547ce4142..499e50dd2c271 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -322,7 +322,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - divisor_override: Optional[int] = None, + division_override: Optional[int] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if isinstance(strides, int): From b2dd1ee9cdd7c9593be6d4cfa772b48eb912e9ca Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 7 Nov 2023 13:22:21 +0000 Subject: [PATCH 124/978] fix: Fixed error conv_general_dilated error in ivy.avg_pool3d. Only list can be concatenated to list. --- ivy/functional/backends/tensorflow/experimental/layers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 3aaceead903de..221e3438fc577 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -484,7 +484,7 @@ def avg_pool3d( res = ivy.conv_general_dilated( x, tf.ones(kernel + (1, x.shape[-1])), - strides, + list(strides), padding, dims=3, feature_group_count=x.shape[-1], From 4d9e2c9ca80ac55627108967b205659492f03ce6 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 7 Nov 2023 13:23:13 +0000 Subject: [PATCH 125/978] fix: Fixed tf.scatter_nd InvalidArgumentError in ivy.avg_pool1d. --- ivy/functional/backends/tensorflow/experimental/layers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 221e3438fc577..7f0072811be67 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -338,7 +338,7 @@ def avg_pool1d( else: num_padded_values = tf.scatter_nd( tf.constant([[res.shape[1] - 1]]), - tf.constant([c], dtype=res.dtype), + tf.constant([c[0]], dtype=res.dtype), tf.constant([res.shape[1]], dtype=tf.int32), ) res = (kernel[0] * res) / (kernel[0] - num_padded_values[:, None]) From 906f02ad5be01d965bd2bfa1dd6ebb196ecffdf6 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 7 Nov 2023 14:31:16 +0000 Subject: [PATCH 126/978] fix: Fixed incorrect inference of ivy array's size. In the torch and paddle backends the native size() returned the shape not the number of elements. --- ivy/data_classes/array/array.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index df2981fc2b9f3..d833affffc76c 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -262,7 +262,7 @@ def shape(self) -> ivy.Shape: def size(self) -> Optional[int]: """Number of elements in the array.""" if self._size is None: - if hasattr(self._data, "size") and callable(self._data.size): + if ivy.current_backend_str() in ["numpy", "jax"]: self._size = self._data.size() return self._size self._size = ( From da8540e25ac544b2c93a88f91cb7d027b5704884 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 7 Nov 2023 14:47:24 +0000 Subject: [PATCH 127/978] fix: Expanded the pooling test helper to include the int padding case, fixed some errors in the ivy backends and the torch frontend for that case and re-applied the refactor that was reverted in 786130a --- .../backends/numpy/experimental/layers.py | 2 + .../backends/torch/experimental/layers.py | 36 ++------- .../mindspore/ops/function/nn_func.py | 18 +---- .../frontends/paddle/nn/functional/pooling.py | 4 +- .../torch/nn/functional/pooling_functions.py | 75 ++++++------------- .../hypothesis_helpers/array_helpers.py | 22 +++--- .../test_functional/test_pooling_functions.py | 40 +++++----- 7 files changed, 63 insertions(+), 134 deletions(-) diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index 8d3b704ed006a..2f846805feb6d 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -369,6 +369,8 @@ def _get_padded_values(x_shape, kernel, strides, padding, ceil_mode, dim): for i in range(dim) ] else: + if isinstance(padding, int): + padding = [(padding,) * 2] * dim pad_specific = [sum(padding[i]) for i in range(dim)] c = [] diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 499e50dd2c271..f9ddbb410f0d1 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -13,7 +13,10 @@ _validate_max_pool_params, _depth_max_pooling_helper, ) -from ivy.functional.ivy.experimental.layers import _padding_ceil_mode +from ivy.functional.ivy.experimental.layers import ( + _padding_ceil_mode, + _broadcast_pooling_helper, +) def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_first"): @@ -26,24 +29,6 @@ def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_ return x, kernel, strides, depth_pooling -def _broadcast_pooling_helper(x, pool_dims: str = "2d", name: str = "padding"): - dims = {"1d": 1, "2d": 2, "3d": 3} - if isinstance(x, int): - return tuple(x for _ in range(dims[pool_dims])) - - if len(x) == 1: - return tuple(x[0] for _ in range(dims[pool_dims])) - - elif len(x) == dims[pool_dims]: - return tuple(x) - - elif len(x) != dims[pool_dims]: - raise ValueError( - f"`{name}` must either be a single int, " - f"or a tuple of {dims[pool_dims]} ints. " - ) - - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) def max_pool1d( x: torch.Tensor, @@ -339,17 +324,8 @@ def avg_pool1d( x = x.permute(0, 2, 1) x_shape = x.shape[2] - if isinstance(padding, str): - pad_specific = [ - _handle_padding(x_shape, strides[i], kernel[i], padding) for i in range(1) - ] - padding = [ - (pad_specific[i] // 2, pad_specific[i] - pad_specific[i] // 2) - for i in range(1) - ] - else: - pad_specific = [sum(padding[i]) for i in range(1)] - x = torch.nn.functional.pad(x, *padding, value=0.0) + padding, pad_specific = _get_specific_pad(x_shape, kernel, strides, padding, 1) + x = torch.nn.functional.pad(x, padding, value=0.0) res = torch.nn.functional.avg_pool1d(x, kernel, strides, 0, ceil_mode) diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index 18cff733e9baf..43ec4a6d18c7d 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -2,29 +2,13 @@ import ivy from ivy.func_wrapper import with_supported_dtypes from ivy.functional.frontends.paddle.func_wrapper import to_ivy_arrays_and_back +from ivy.functional.ivy.experimental.layers import _broadcast_pooling_helper # --- Helpers --- # # --------------- # -def _broadcast_pooling_helper(x, pool_dims: str = "2d", name: str = "padding"): - dims = {"1d": 1, "2d": 2, "3d": 3} - - if isinstance(x, int): - return tuple(x for _ in range(dims[pool_dims])) - - if len(x) == 1: - return tuple(x[0] for _ in range(dims[pool_dims])) - elif len(x) == dims[pool_dims]: - return tuple(x) - else: - raise ValueError( - f"`{name}` must either be a single int, " - f"or a tuple of {dims[pool_dims]} ints. " - ) - - def _conv(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): dims = len(input.shape) - 2 _valid_shapes(input, weight, bias, stride, padding, groups) diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index 9d8e02c90b86e..910946dfbaf6e 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -2,9 +2,7 @@ import ivy from ivy.func_wrapper import with_supported_dtypes from ivy.functional.frontends.paddle.func_wrapper import to_ivy_arrays_and_back -from ivy.functional.frontends.torch.nn.functional.pooling_functions import ( - _broadcast_pooling_helper, -) +from ivy.functional.ivy.experimental.layers import _broadcast_pooling_helper from ivy.func_wrapper import with_unsupported_dtypes diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index f2cd213d9b0ee..b8b70ed93bff4 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -9,31 +9,6 @@ ) -# --- Helpers --- # -# --------------- # - - -def _broadcast_pooling_helper(x, pool_dims: str = "2d", name: str = "padding"): - dims = {"1d": 1, "2d": 2, "3d": 3} - - if isinstance(x, int): - return tuple(x for _ in range(dims[pool_dims])) - - if len(x) == 1: - return tuple(x[0] for _ in range(dims[pool_dims])) - elif len(x) == dims[pool_dims]: - return tuple(x) - else: - raise ValueError( - f"`{name}` must either be a single int, " - f"or a tuple of {dims[pool_dims]} ints. " - ) - - -# --- Main --- # -# ------------ # - - @with_unsupported_dtypes( { "2.1.0 and below": ( @@ -94,14 +69,8 @@ def avg_pool1d( ceil_mode=False, count_include_pad=True, ): - kernel_size = _broadcast_pooling_helper(kernel_size, "1d", name="kernel_size") - padding = _broadcast_pooling_helper(padding, "1d", name="padding") - if all( - [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] - ): - padding = "SAME" - else: - padding = "VALID" + if not isinstance(padding, int): + padding = [(pad, pad) for pad in padding] return ivy.avg_pool1d( input, kernel_size, @@ -127,14 +96,8 @@ def avg_pool2d( count_include_pad=True, divisor_override=None, ): - kernel_size = _broadcast_pooling_helper(kernel_size, "2d", name="kernel_size") - padding = _broadcast_pooling_helper(padding, "2d", name="padding") - if all( - [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] - ): - padding = "SAME" - else: - padding = "VALID" + if not isinstance(padding, int): + padding = [(pad, pad) for pad in padding] return ivy.avg_pool2d( input, kernel_size, @@ -161,14 +124,8 @@ def avg_pool3d( count_include_pad=True, divisor_override=None, ): - kernel_size = _broadcast_pooling_helper(kernel_size, "3d", name="kernel_size") - padding = _broadcast_pooling_helper(padding, "3d", name="padding") - if all( - [pad == ivy.ceil((kernel - 1) / 2) for kernel, pad in zip(kernel_size, padding)] - ): - padding = "SAME" - else: - padding = "VALID" + if not isinstance(padding, int): + padding = [(pad, pad) for pad in padding] return ivy.avg_pool3d( input, kernel_size, @@ -213,6 +170,15 @@ def lp_pool1d(input, norm_type, kernel_size, stride=None, ceil_mode=False): return ivy.pow(ivy.multiply(out, kernel_mul), p) +@with_unsupported_dtypes( + { + "2.1.0 and below": ( + "float16", + "bfloat16", + ) + }, + "torch", +) @to_ivy_arrays_and_back def lp_pool2d(input, norm_type, kernel_size, stride=None, ceil_mode=False): data_format = "NCHW" @@ -235,6 +201,7 @@ def lp_pool2d(input, norm_type, kernel_size, stride=None, ceil_mode=False): return ivy.pow(ivy.multiply(out, kernel_mul), p).astype(input.dtype) +@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool1d( input, @@ -247,13 +214,14 @@ def max_pool1d( ): if stride is None: stride = kernel_size - data_format = "NCW" + if not isinstance(padding, int): + padding = [(pad, pad) for pad in padding] return ivy.max_pool1d( input, kernel_size, stride, padding, - data_format=data_format, + data_format="NCW", dilation=dilation, ceil_mode=ceil_mode, ) @@ -272,6 +240,8 @@ def max_pool2d( ): if stride is None: stride = kernel_size + if not isinstance(padding, int): + padding = [(pad, pad) for pad in padding] return ivy.max_pool2d( input, kernel_size, @@ -296,7 +266,8 @@ def max_pool3d( ): if stride is None: stride = kernel_size - + if not isinstance(padding, int): + padding = [(pad, pad) for pad in padding] return ivy.max_pool3d( input, kernel_size, diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py index 51a5dbcf99f8a..fe9eb99c44bdb 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py @@ -1799,17 +1799,21 @@ def arrays_for_pooling( else: dilations.append(1) if explicit_or_str_padding or only_explicit_padding: - padding = [] - for i in range(array_dim - 2): - max_pad = kernel[i] // 2 - padding.append( - draw( - st.tuples( - st.integers(0, max_pad), - st.integers(0, max_pad), + if draw(st.booleans()): + max_pad = min(kernel[i] // 2 for i in range(array_dim - 2)) + padding = draw(st.integers(0, max_pad)) + else: + padding = [] + for i in range(array_dim - 2): + max_pad = kernel[i] // 2 + padding.append( + draw( + st.tuples( + st.integers(0, max_pad), + st.integers(0, max_pad), + ) ) ) - ) if explicit_or_str_padding: padding = draw( st.one_of(st.just(padding), st.sampled_from(["VALID", "SAME"])) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py index a18769d922b1d..34b91f0d80852 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py @@ -187,7 +187,8 @@ def test_torch_avg_pool1d( on_device, ): input_dtype, x, kernel_size, stride, padding = dtype_x_k_s - padding = [pad[0] for pad in padding] + if not isinstance(padding, int): + padding = [pad[0] for pad in padding] helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -231,12 +232,8 @@ def test_torch_avg_pool2d( on_device, ): input_dtype, x, kernel_size, stride, padding = dtype_x_k_s - # TODO: remove the processing of padding attribute when ivy.avg_pool - # support explicit padding - padding = [pad[i] for i, pad in enumerate(padding)] - x_shape = x[0].shape[2:] - if sum(padding) != 0: - padding = calculate_same_padding(kernel_size, [stride[0]] * 2, x_shape) + if not isinstance(padding, int): + padding = [pad[0] for pad in padding] helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -283,13 +280,8 @@ def test_torch_avg_pool3d( on_device, ): input_dtype, x, kernel_size, stride, padding = dtype_x_k_s - # TODO: remove the processing of padding and strides attributes when ivy.avg_pool - # support explicit padding - x_shape = x[0].shape[2:] - padding = [pad[0] for pad in padding] - if sum(padding) != 0: - stride_broad = (stride[0],) * 3 if len(stride) == 1 else stride - padding = calculate_same_padding(kernel_size, stride_broad, x_shape) + if not isinstance(padding, int): + padding = [pad[0] for pad in padding] helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -307,7 +299,7 @@ def test_torch_avg_pool3d( ) -# avg_pool1d +# lp_pool1d @handle_frontend_test( fn_tree="torch.nn.functional.lp_pool1d", dtype_x_k_s=helpers.arrays_for_pooling( @@ -347,7 +339,7 @@ def test_torch_lp_pool1d( ) -# avg_pool2d +# lp_pool2d @handle_frontend_test( fn_tree="torch.nn.functional.lp_pool2d", dtype_x_k_s=helpers.arrays_for_pooling( @@ -409,7 +401,8 @@ def test_torch_max_pool1d( on_device, ): input_dtype, x, kernel_size, stride, padding = dtype_x_k_s - padding = (padding[0][0],) + if not isinstance(padding, int): + padding = [pad[0] for pad in padding] helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -449,9 +442,9 @@ def test_torch_max_pool2d( fn_tree, on_device, ): - dtype, x, kernel, stride, pad, dilation = x_k_s_p - pad = (pad[0][0], pad[1][0]) - + dtype, x, kernel, stride, padding, dilation = x_k_s_p + if not isinstance(padding, int): + padding = [pad[0] for pad in padding] helpers.test_frontend_function( input_dtypes=dtype, backend_to_test=backend_fw, @@ -462,7 +455,7 @@ def test_torch_max_pool2d( input=x[0], kernel_size=kernel, stride=stride, - padding=pad, + padding=padding, dilation=dilation, ceil_mode=ceil_mode, ) @@ -493,8 +486,9 @@ def test_torch_max_pool3d( fn_tree, on_device, ): - dtype, x, kernel, stride, pad, dilation = x_k_s_p - padding = (pad[0][0], pad[1][0], pad[2][0]) + dtype, x, kernel, stride, padding, dilation = x_k_s_p + if not isinstance(padding, int): + padding = [pad[0] for pad in padding] helpers.test_frontend_function( input_dtypes=dtype, backend_to_test=backend_fw, From 719fa9d0a0007581dea2151fffc1be66ca7d8fc6 Mon Sep 17 00:00:00 2001 From: yopknopixx <30761130+yopknopixx@users.noreply.github.com> Date: Tue, 7 Nov 2023 21:07:51 +0530 Subject: [PATCH 128/978] fix(torch-frontend): fix failing test for torch.nn.functional.relu_ (#27098) --- .../torch/nn/functional/non_linear_activation_functions.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py index c49e44d7218f7..bca71b8bb220b 100644 --- a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py @@ -213,6 +213,7 @@ def relu6(input, inplace=False): return ivy.relu6(input) +@to_ivy_arrays_and_back def relu_(input): return relu(input, inplace=True) From 9c8bd50d897e2151297ea0e7d560ecd4fa0123e9 Mon Sep 17 00:00:00 2001 From: Olawale Onabola Date: Tue, 7 Nov 2023 07:39:51 -0800 Subject: [PATCH 129/978] Hamming window (#21059) Co-authored-by: ivy-branch --- .../frontends/torch/spectral_ops.py | 14 +++++- .../test_torch/test_spectral_ops.py | 50 +++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/spectral_ops.py b/ivy/functional/frontends/torch/spectral_ops.py index 8727252e94d46..2be73d67a4dfa 100644 --- a/ivy/functional/frontends/torch/spectral_ops.py +++ b/ivy/functional/frontends/torch/spectral_ops.py @@ -1,6 +1,6 @@ import ivy +from ivy.func_wrapper import with_supported_dtypes, with_unsupported_dtypes from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back -from ivy.func_wrapper import with_supported_dtypes @to_ivy_arrays_and_back @@ -59,3 +59,15 @@ def kaiser_window( requires_grad=False ): return ivy.kaiser_window(window_length, periodic=periodic, beta=beta, dtype=dtype) + + +@to_ivy_arrays_and_back +@with_unsupported_dtypes({"1.11.0 and below": ("float16",)}, "torch") +def hamming_window( + window_length, + periodic=True, + alpha=0.54, + beta=0.46, + return ivy.hamming_window( + window_length, periodic=periodic, alpha=alpha, beta=beta, dtype=dtype + ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_spectral_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_spectral_ops.py index 6e6376537f430..50d1d3f49a6d4 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_spectral_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_spectral_ops.py @@ -66,6 +66,56 @@ def test_torch_blackman_window( ) +# hamming_window +@handle_frontend_test( + fn_tree="torch.hamming_window", + dtype_and_window_length=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("integer"), + max_num_dims=0, + min_value=1, + max_value=20, + ), + periodic=st.booleans(), + dtype_and_coefficients=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + max_num_dims=0, + num_arrays=2, + min_value=0, + max_value=5, + ), + dtype=helpers.get_dtypes("float"), + test_with_out=st.just(False), +) +def test_torch_hamming_window( + dtype_and_window_length, + periodic, + dtype_and_coefficients, + *, + dtype, + fn_tree, + frontend, + test_flags, + backend_fw, +): + window_length_dtype, window_length = dtype_and_window_length + coefficients_dtypes, coefficients = dtype_and_coefficients + + helpers.test_frontend_function( + input_dtypes=window_length_dtype + coefficients_dtypes, + window_length=int(window_length[0]), + periodic=periodic, + alpha=float(coefficients[0]), + beta=float(coefficients[1]), + dtype=dtype[0], + fn_tree=fn_tree, + frontend=frontend, + test_flags=test_flags, + backend_to_test=backend_fw, + rtol=1e-1, + atol=1e-1, + ) + + @handle_frontend_test( window_length=helpers.ints(min_value=1, max_value=100), dtype=helpers.get_dtypes("float", full=False), From b0a744e8d5ca7ed57ede50d7be4b0a9bc8867480 Mon Sep 17 00:00:00 2001 From: Anudeep Sanapala <71971574+anudeeps0306@users.noreply.github.com> Date: Tue, 7 Nov 2023 21:16:27 +0530 Subject: [PATCH 130/978] feat: Implement is_complex tensor Instance Methods to paddle Frontend (#26762) Co-authored-by: ivy-branch --- .../frontends/paddle/tensor/tensor.py | 3 ++ .../test_paddle/test_tensor/test_tensor.py | 33 +++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 870269f06a9f3..7c685e982066b 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -930,6 +930,9 @@ def frac(self, name=None): def gather(self, y, name=None): return paddle_frontend.gather(self, y) + def is_complex(self): + return paddle_frontend.is_complex(self) + @with_unsupported_dtypes( {"2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" ) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index ff869ce9ca229..c71150207e675 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -411,6 +411,39 @@ def test_paddle__reshape( ) +# is_complex +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="is_complex", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + ), +) +def test_paddle_is_complex( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + init_all_as_kwargs_np={"data": x[0]}, + method_input_dtypes=input_dtype, + backend_to_test=backend_fw, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # abs @handle_frontend_method( class_tree=CLASS_TREE, From fcdbca66c4381b4fa0c44879c19959eba691cd91 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 7 Nov 2023 15:49:28 +0000 Subject: [PATCH 131/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../test_paddle/test_tensor/test_tensor.py | 66 +++++++++---------- 1 file changed, 33 insertions(+), 33 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index c71150207e675..e9516c2bf5342 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -411,39 +411,6 @@ def test_paddle__reshape( ) -# is_complex -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="is_complex", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), - ), -) -def test_paddle_is_complex( - dtype_and_x, - frontend_method_data, - init_flags, - method_flags, - frontend, - backend_fw, - on_device, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - init_all_as_kwargs_np={"data": x[0]}, - method_input_dtypes=input_dtype, - backend_to_test=backend_fw, - method_all_as_kwargs_np={}, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - - # abs @handle_frontend_method( class_tree=CLASS_TREE, @@ -2615,6 +2582,39 @@ def test_paddle_inner( ) +# is_complex +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="is_complex", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + ), +) +def test_paddle_is_complex( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + init_all_as_kwargs_np={"data": x[0]}, + method_input_dtypes=input_dtype, + backend_to_test=backend_fw, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # is_floating_point @handle_frontend_method( class_tree=CLASS_TREE, From 42f4338337d71923ed358d5432031572b071fd85 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 7 Nov 2023 16:04:28 +0000 Subject: [PATCH 132/978] fix: Fixed error in ivy.array's size. size is not a callable in numpy and jax --- ivy/data_classes/array/array.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index d833affffc76c..06b5cb4d4615a 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -263,7 +263,7 @@ def size(self) -> Optional[int]: """Number of elements in the array.""" if self._size is None: if ivy.current_backend_str() in ["numpy", "jax"]: - self._size = self._data.size() + self._size = self._data.size return self._size self._size = ( functools.reduce(mul, self._data.shape) From c271b4c20117a519f9e37aa5319a440887972da4 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 7 Nov 2023 16:09:05 +0000 Subject: [PATCH 133/978] fix: Added missing parenthesis and removed undefined variable reference. --- .../frontends/torch/spectral_ops.py | 28 +++++++++++-------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/ivy/functional/frontends/torch/spectral_ops.py b/ivy/functional/frontends/torch/spectral_ops.py index 2be73d67a4dfa..65d0e10d1b3ca 100644 --- a/ivy/functional/frontends/torch/spectral_ops.py +++ b/ivy/functional/frontends/torch/spectral_ops.py @@ -46,6 +46,22 @@ def blackman_window( return ivy.blackman_window(window_length, periodic=periodic, dtype=dtype) +@to_ivy_arrays_and_back +@with_unsupported_dtypes({"1.11.0 and below": ("float16",)}, "torch") +def hamming_window( + window_length, + periodic=True, + alpha=0.54, + beta=0.46, +): + return ivy.hamming_window( + window_length, + periodic=periodic, + alpha=alpha, + beta=beta, + ) + + @to_ivy_arrays_and_back @with_supported_dtypes({"2.51.0 and below": ("float32", "float64")}, "torch") def kaiser_window( @@ -59,15 +75,3 @@ def kaiser_window( requires_grad=False ): return ivy.kaiser_window(window_length, periodic=periodic, beta=beta, dtype=dtype) - - -@to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.11.0 and below": ("float16",)}, "torch") -def hamming_window( - window_length, - periodic=True, - alpha=0.54, - beta=0.46, - return ivy.hamming_window( - window_length, periodic=periodic, alpha=alpha, beta=beta, dtype=dtype - ) From 4bac90a244be1b2eb3ac01ba8b6dbd2542d53f0d Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 8 Nov 2023 04:30:32 +0000 Subject: [PATCH 134/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 2bf43d222424b..b5104bb51e8c8 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 2bf43d222424bacfe88ed5746870d5ba5528aed1 +Subproject commit b5104bb51e8c80cbb971a5d25340cc6906d6bf39 From ecf795821b1e29a2b48e2e153d935e0a7493a270 Mon Sep 17 00:00:00 2001 From: Eddy Oyieko <67474838+mobley-trent@users.noreply.github.com> Date: Wed, 8 Nov 2023 13:50:44 +0300 Subject: [PATCH 135/978] fix: fix np.around frontend (#27228) --- .../frontends/numpy/mathematical_functions/rounding.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/ivy/functional/frontends/numpy/mathematical_functions/rounding.py b/ivy/functional/frontends/numpy/mathematical_functions/rounding.py index 090977102cb62..a785e218f6395 100644 --- a/ivy/functional/frontends/numpy/mathematical_functions/rounding.py +++ b/ivy/functional/frontends/numpy/mathematical_functions/rounding.py @@ -111,8 +111,6 @@ def _trunc( @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar def around(a, decimals=0, out=None): - if ivy.shape(a) == (): - a = ivy.expand_dims(a, axis=0) return ivy.round(a, decimals=decimals, out=out) From 952be3d674a1eaac5e9cda3e1bf4fdf229631be0 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 8 Nov 2023 16:41:03 +0530 Subject: [PATCH 136/978] refactor: Refactored few files to make the code better. (#27218) Co-authored-by: @AnnaTz --- ivy/func_wrapper.py | 2 +- ivy/functional/backends/jax/experimental/creation.py | 4 ++-- ivy/functional/backends/numpy/experimental/creation.py | 4 ++-- ivy/functional/backends/paddle/experimental/norms.py | 4 ++-- ivy/functional/backends/paddle/set.py | 2 +- ivy/functional/backends/tensorflow/set.py | 2 +- ivy/functional/backends/torch/experimental/creation.py | 4 ++-- ivy/functional/backends/torch/layers.py | 2 +- ivy/functional/backends/torch/set.py | 2 +- ivy/functional/frontends/jax/numpy/mathematical_functions.py | 2 +- .../numpy/indexing_routines/inserting_data_into_arrays.py | 2 +- ivy/functional/frontends/tensorflow/math.py | 2 +- ivy/functional/ivy/layers.py | 4 ++-- ivy/stateful/converters.py | 2 +- .../test_nn/test_functional/test_layer_functions.py | 4 ++-- ivy_tests/test_ivy/test_functional/test_core/test_device.py | 4 ++-- ivy_tests/test_ivy/test_functional/test_core/test_dtype.py | 4 ++-- ivy_tests/test_ivy/test_functional/test_nn/test_layers.py | 2 +- .../test_misc/test_backend_utils/test_backend_handler.py | 2 +- 19 files changed, 27 insertions(+), 27 deletions(-) diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index d13bdf675606e..c831c9aae4add 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -46,7 +46,7 @@ casting_modes_dict = { "uint": lambda: ivy.valid_uint_dtypes, "int": lambda: sorted( - tuple(set(ivy.valid_int_dtypes).difference(set(ivy.valid_uint_dtypes))) + set(ivy.valid_int_dtypes).difference(set(ivy.valid_uint_dtypes)) ), "float": lambda: ivy.valid_float_dtypes, "complex": lambda: ivy.valid_complex_dtypes, diff --git a/ivy/functional/backends/jax/experimental/creation.py b/ivy/functional/backends/jax/experimental/creation.py index 19e1833db5e4f..42d285a045f95 100644 --- a/ivy/functional/backends/jax/experimental/creation.py +++ b/ivy/functional/backends/jax/experimental/creation.py @@ -156,9 +156,9 @@ def hz_to_mel(f): dtype=jnp.float32, ) mel_edges = jnp.stack([mel_edges[i : i + 3] for i in range(num_mel_bins)]) - lower_edge_mel, center_mel, upper_edge_mel = [ + lower_edge_mel, center_mel, upper_edge_mel = ( t.reshape((1, num_mel_bins)) for t in jnp.split(mel_edges, 3, axis=1) - ] + ) lower_slopes = (spec_bin_mels - lower_edge_mel) / (center_mel - lower_edge_mel) upper_slopes = (upper_edge_mel - spec_bin_mels) / (upper_edge_mel - center_mel) mel_weights = jnp.maximum(zero, jnp.minimum(lower_slopes, upper_slopes)) diff --git a/ivy/functional/backends/numpy/experimental/creation.py b/ivy/functional/backends/numpy/experimental/creation.py index e6c4b5a064779..b073258c74c80 100644 --- a/ivy/functional/backends/numpy/experimental/creation.py +++ b/ivy/functional/backends/numpy/experimental/creation.py @@ -194,9 +194,9 @@ def hz_to_mel(f): dtype=np.float32, ) mel_edges = np.stack([mel_edges[i : i + 3] for i in range(num_mel_bins)]) - lower_edge_mel, center_mel, upper_edge_mel = [ + lower_edge_mel, center_mel, upper_edge_mel = ( t.reshape((1, num_mel_bins)) for t in np.split(mel_edges, 3, axis=1) - ] + ) lower_slopes = (spec_bin_mels - lower_edge_mel) / (center_mel - lower_edge_mel) upper_slopes = (upper_edge_mel - spec_bin_mels) / (upper_edge_mel - center_mel) mel_weights = np.maximum(zero, np.minimum(lower_slopes, upper_slopes)) diff --git a/ivy/functional/backends/paddle/experimental/norms.py b/ivy/functional/backends/paddle/experimental/norms.py index 2ffebad9ed2eb..d187a2535b028 100644 --- a/ivy/functional/backends/paddle/experimental/norms.py +++ b/ivy/functional/backends/paddle/experimental/norms.py @@ -42,9 +42,9 @@ def batch_norm( out: Optional[Tuple[paddle.Tensor, paddle.Tensor, paddle.Tensor]] = None, ) -> Tuple[paddle.Tensor, paddle.Tensor, paddle.Tensor]: if x.dtype not in [paddle.float32, paddle.float64]: - x, mean, variance, scale, offset = [ + x, mean, variance, scale, offset = ( t.cast("float32") for t in [x, mean, variance, scale, offset] - ] + ) runningmean = mean runningvariance = variance data_formats = ["NC", "NCL", "NCHW", "NCDHW", "NLC", "NHWC", "NDHWC"] diff --git a/ivy/functional/backends/paddle/set.py b/ivy/functional/backends/paddle/set.py index 3825cf5914731..d0c47eb3242d7 100644 --- a/ivy/functional/backends/paddle/set.py +++ b/ivy/functional/backends/paddle/set.py @@ -67,7 +67,7 @@ def unique_all( [ i[0] for i in sorted( - list(enumerate(values_.numpy().tolist())), key=lambda x: tuple(x[1]) + enumerate(values_.numpy().tolist()), key=lambda x: tuple(x[1]) ) ] ) diff --git a/ivy/functional/backends/tensorflow/set.py b/ivy/functional/backends/tensorflow/set.py index abb0c8d90e8f6..24379eb109d90 100644 --- a/ivy/functional/backends/tensorflow/set.py +++ b/ivy/functional/backends/tensorflow/set.py @@ -59,7 +59,7 @@ def unique_all( values_ = tf.experimental.numpy.moveaxis(values, axis, 0) values_ = tf.reshape(values_, (values_.shape[0], -1)) sort_idx = tf.stack( - [i[0] for i in sorted(list(enumerate(values_)), key=lambda x: tuple(x[1]))] + [i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1]))] ) sort_idx = tf.cast(sort_idx, tf.int32) values = tf.gather(values, sort_idx, axis=axis) diff --git a/ivy/functional/backends/torch/experimental/creation.py b/ivy/functional/backends/torch/experimental/creation.py index 953970525fd66..e56fd57cf39d6 100644 --- a/ivy/functional/backends/torch/experimental/creation.py +++ b/ivy/functional/backends/torch/experimental/creation.py @@ -238,9 +238,9 @@ def hz_to_mel(f): ) # create overlapping frames of size 3 mel_edges = mel_edges.unfold(0, size=3, step=1) - lower_edge_mel, center_mel, upper_edge_mel = [ + lower_edge_mel, center_mel, upper_edge_mel = ( t.reshape((1, num_mel_bins)) for t in mel_edges.split(1, dim=1) - ] + ) lower_slopes = (spec_bin_mels - lower_edge_mel) / (center_mel - lower_edge_mel) upper_slopes = (upper_edge_mel - spec_bin_mels) / (upper_edge_mel - center_mel) mel_weights = torch.maximum(zero, torch.minimum(lower_slopes, upper_slopes)) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index bb69a79915748..ea15c1be27c59 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -57,7 +57,7 @@ def multi_head_attention( )[1] num_dims = query.ndim if num_dims == 3 and batch_first: - query, key, value = [torch.swapaxes(x, 0, 1) for x in [query, key, value]] + query, key, value = (torch.swapaxes(x, 0, 1) for x in [query, key, value]) ret = torch.nn.functional.multi_head_attention_forward( query, key, diff --git a/ivy/functional/backends/torch/set.py b/ivy/functional/backends/torch/set.py index 5eb412bab77be..7f50cc332157d 100644 --- a/ivy/functional/backends/torch/set.py +++ b/ivy/functional/backends/torch/set.py @@ -63,7 +63,7 @@ def unique_all( values_ = torch.moveaxis(values, axis, 0) values_ = torch.reshape(values_, (values_.shape[0], -1)) sort_idx = torch.tensor( - [i[0] for i in sorted(list(enumerate(values_)), key=lambda x: tuple(x[1]))] + [i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1]))] ) ivy_torch = ivy.current_backend() values = ivy_torch.gather(values, sort_idx, axis=axis) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index c8a429121b7c7..5776a660bee33 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -322,7 +322,7 @@ def einsum_path(subscripts, *operands, optimize="greedy"): # Build contraction tuple (positions, gemm, einsum_str, remaining) for cnum, contract_inds in enumerate(path): # Make sure we remove inds from right to left - contract_inds = tuple(sorted(list(contract_inds), reverse=True)) + contract_inds = tuple(sorted(contract_inds, reverse=True)) contract = find_contraction(contract_inds, input_sets, output_set) out_inds, input_sets, idx_removed, idx_contract = contract diff --git a/ivy/functional/frontends/numpy/indexing_routines/inserting_data_into_arrays.py b/ivy/functional/frontends/numpy/indexing_routines/inserting_data_into_arrays.py index 19d474e01f35a..1aea91f0c99c6 100644 --- a/ivy/functional/frontends/numpy/indexing_routines/inserting_data_into_arrays.py +++ b/ivy/functional/frontends/numpy/indexing_routines/inserting_data_into_arrays.py @@ -61,7 +61,7 @@ def __getitem__(self, key): if "," in item: vec = item.split(",") try: - axis, ndmin = [int(x) for x in vec[:2]] + axis, ndmin = (int(x) for x in vec[:2]) if len(vec) == 3: trans1d = int(vec[2]) continue diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index 9dd3a44045d53..6519f0794502c 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -845,7 +845,7 @@ def xlogy(x, y, name=None): @to_ivy_arrays_and_back def zero_fraction(value, name="zero_fraction"): - zero = ivy.zeros(tuple(list(value.shape)), dtype=ivy.float32) + zero = ivy.zeros(tuple(value.shape), dtype=ivy.float32) x = ivy.array(value, dtype=ivy.float32) count_zero = ivy.sum(ivy.equal(x, zero)) count_nonzero = ivy.sum(ivy.not_equal(x, zero)) diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 3ff5ea2d4dccb..e3e1c354577dd 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -856,9 +856,9 @@ def multi_head_attention( if key is None and value is None: key = value = query if num_dims == 2: - query, key, value = [ivy.expand_dims(x, axis=0) for x in [query, key, value]] + query, key, value = (ivy.expand_dims(x, axis=0) for x in [query, key, value]) elif not batch_first: - query, key, value = [ivy.swapaxes(x, 0, 1) for x in [query, key, value]] + query, key, value = (ivy.swapaxes(x, 0, 1) for x in [query, key, value]) # project query, key and value if ivy.exists(in_proj_weights): diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index b787df41c5253..59cfc5e5ba15d 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -466,7 +466,7 @@ def _assign_variables(self): name=kc, shape=x.shape, dtype=x.dtype, trainable=True ) ) - model_weights = list() + model_weights = [] self._ivy_module.v.cont_map( lambda x, kc: model_weights.append(ivy.to_numpy(x)) ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py index 32f7508490e1b..1395d00bb080b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py @@ -120,9 +120,9 @@ def _lstm_helper(draw): ) ) batch_sizes = np.array(draw(st.permutations(batch_sizes))) - input, batch_sizes = [ + input, batch_sizes = ( ivy.to_numpy(p) for p in _pack_padded_sequence(input, batch_sizes) - ] + ) else: batch_sizes = None diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_device.py b/ivy_tests/test_ivy/test_functional/test_core/test_device.py index 016373f599baa..8145e909d85ad 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_device.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_device.py @@ -289,7 +289,7 @@ def test_function_supported_devices( res = ivy_backend.function_supported_devices(func) exp = set(expected) - assert sorted(tuple(exp)) == sorted(res) + assert sorted(exp) == sorted(res) # function_unsupported_devices @@ -308,7 +308,7 @@ def test_function_unsupported_devices( res = ivy_backend.function_unsupported_devices(func) exp = set(expected) - assert sorted(tuple(exp)) == sorted(res) + assert sorted(exp) == sorted(res) @handle_test( diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_dtype.py b/ivy_tests/test_ivy/test_functional/test_core/test_dtype.py index 576ab01a6e393..2859d678c445d 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_dtype.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_dtype.py @@ -655,7 +655,7 @@ def test_function_supported_dtypes(*, func, backend_fw): exp = set(ivy_backend.all_dtypes).difference( set(func.test_unsupported_dtypes[backend_fw]) ) - assert set(tuple(exp)) == set(res) + assert set(exp) == set(res) # function_unsupported_dtypes @@ -667,7 +667,7 @@ def test_function_unsupported_dtypes(*, func, backend_fw): with BackendHandler.update_backend(backend_fw) as ivy_backend: res = ivy_backend.function_unsupported_dtypes(func) exp = func.test_unsupported_dtypes[backend_fw] - assert set(tuple(exp)) == set(res) + assert set(exp) == set(res) # iinfo diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index 988d6e7ac78fa..f72187b0101c7 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -307,7 +307,7 @@ def _mha_helper(draw, same_pre_embed_dim=False, batch_second=False): average_attention_weights = draw(st.booleans()) if len(q.shape) == 3 and not batch_first: - q, k, v = [np.swapaxes(x, 0, 1) if x is not None else x for x in [q, k, v]] + q, k, v = (np.swapaxes(x, 0, 1) if x is not None else x for x in [q, k, v]) ret = ( q, diff --git a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py index f44835ada15d6..d9f7c2cfdebba 100644 --- a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py +++ b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py @@ -127,7 +127,7 @@ def test_dynamic_backend_all_combos(middle_backend, end_backend): assert isinstance(a.data, ivy.NativeArray) assert isinstance(ivy_cont["b"].data, ivy.NativeArray) - if set(["numpy", "jax"]).intersection([middle_backend, end_backend]): + if {"numpy", "jax"}.intersection([middle_backend, end_backend]): # these frameworks don't support native variables assert isinstance(var_cont["b"].data, ivy.NativeArray) else: From 96a8ce70c7c8dde5589e62f639f3ec90c4229db9 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 8 Nov 2023 13:15:06 +0000 Subject: [PATCH 137/978] fix: Fixed some errors in the ivy and torch avg_pool functions + Shortened the torch backend implementation to use the native function directly when possible. --- .../backends/jax/experimental/layers.py | 2 +- .../backends/mxnet/experimental/layers.py | 2 +- .../backends/numpy/experimental/layers.py | 2 +- .../backends/paddle/experimental/layers.py | 2 +- .../tensorflow/experimental/layers.py | 2 +- .../backends/torch/experimental/layers.py | 284 ++++++++++-------- .../torch/nn/functional/pooling_functions.py | 2 +- ivy/functional/ivy/experimental/layers.py | 8 +- .../test_functional/test_pooling_functions.py | 15 +- 9 files changed, 187 insertions(+), 132 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 2b355189505eb..5ed9c2809931d 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -295,7 +295,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - division_override: Optional[int] = None, + divisor_override: Optional[int] = None, out: Optional[JaxArray] = None, ) -> JaxArray: if data_format in ("NCW", "NCL"): diff --git a/ivy/functional/backends/mxnet/experimental/layers.py b/ivy/functional/backends/mxnet/experimental/layers.py index 955a02e69b9ea..854cc5d46dfbb 100644 --- a/ivy/functional/backends/mxnet/experimental/layers.py +++ b/ivy/functional/backends/mxnet/experimental/layers.py @@ -80,7 +80,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - division_override: Optional[int] = None, + divisor_override: Optional[int] = None, out: Optional[mx.nd.NDArray] = None, ) -> mx.nd.NDArray: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index 2f846805feb6d..80cc3fd3d5588 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -394,7 +394,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - division_override: Optional[int] = None, + divisor_override: Optional[int] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: if isinstance(kernel, int): diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index c9b604e69ecfa..fabf837f023f0 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -249,7 +249,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - division_override: Optional[int] = None, + divisor_override: Optional[int] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 7f0072811be67..823f27f73f15c 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -288,7 +288,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - division_override: Optional[int] = None, + divisor_override: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: if isinstance(kernel, int): diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index f9ddbb410f0d1..01c771dd9d2b2 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -307,7 +307,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - division_override: Optional[int] = None, + divisor_override: Optional[int] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if isinstance(strides, int): @@ -323,34 +323,50 @@ def avg_pool1d( if data_format in ("NWC", "NCL"): x = x.permute(0, 2, 1) - x_shape = x.shape[2] - padding, pad_specific = _get_specific_pad(x_shape, kernel, strides, padding, 1) - x = torch.nn.functional.pad(x, padding, value=0.0) - - res = torch.nn.functional.avg_pool1d(x, kernel, strides, 0, ceil_mode) - - if not count_include_pad and any(pad_specific): - num_padded_values = ivy.map( - _get_num_padded_values, - constant={ - "p": pad_specific[0], - "n": x_shape, - "k": kernel[0], - "s": strides[0], - }, - unique={ - "i": torch.arange(res.shape[2]), - }, + if ( + isinstance(padding, int) + or not isinstance(padding, str) + and padding[0][0] == padding[0][1] + ) and not divisor_override: + if not isinstance(padding, int): + padding = padding[0][0] + res = torch.nn.functional.avg_pool1d( + x, + kernel, + strides, + padding, + count_include_pad=count_include_pad, + ceil_mode=ceil_mode, ) - num_padded_values = torch.tensor(num_padded_values, dtype=res.dtype) + else: + x_shape = x.shape[2] + padding, pad_specific = _get_specific_pad( + [x_shape], kernel, strides, padding, 1 + ) + x = torch.nn.functional.pad(x, padding, value=0.0) - if ceil_mode: - _, c = _padding_ceil_mode(x_shape, kernel[0], padding[0], strides[0], True) - num_padded_values[-1] = _add_ceil_pad_to_pad_list( - num_padded_values[-1], kernel[0], c - ) + res = torch.nn.functional.avg_pool1d(x, kernel, strides, 0, ceil_mode) - res = (kernel[0] * res) / (kernel[0] - num_padded_values) + if not count_include_pad and any(pad_specific): + num_padded_values = ivy.map( + _get_num_padded_values, + constant={ + "p": pad_specific[0], + "n": x_shape, + "k": kernel[0], + "s": strides[0], + }, + unique={ + "i": torch.arange(res.shape[2]), + }, + ) + num_padded_values = torch.tensor(num_padded_values, dtype=res.dtype) + if ceil_mode: + _, c = _padding_ceil_mode(x_shape, kernel[0], padding, strides[0], True) + num_padded_values[-1] = _add_ceil_pad_to_pad_list( + num_padded_values[-1], kernel[0], c + ) + res = (kernel[0] * res) / (kernel[0] - num_padded_values) if data_format in ("NWC", "NCL"): res = res.permute(0, 2, 1) @@ -404,54 +420,71 @@ def avg_pool2d( if data_format == "NHWC": x = x.permute(0, 3, 1, 2) - x_shape = list(x.shape[2:]) - padding, pad_specific = _get_specific_pad(x_shape, kernel, strides, padding, 2) - x = torch.nn.functional.pad( - x, - padding, - value=0.0, - ) - res = torch.nn.functional.avg_pool2d( - x, kernel, strides, 0, ceil_mode, divisor_override=divisor_override - ) - if not count_include_pad and any(pad_specific) and not divisor_override: - num_padded_values = [ - ivy.map( - _get_num_padded_values, - constant={ - "p": pad_specific[i], - "n": x_shape[i], - "k": kernel[i], - "s": strides[i], - }, - unique={ - "i": torch.arange(res.shape[i + 2]), - }, - ) - for i in range(2) - ] + if ( + isinstance(padding, int) + or not isinstance(padding, str) + and all(pad[0] == pad[1] for pad in padding) + ): + if not isinstance(padding, int): + padding = [padding[0][0], padding[1][0]] + res = torch.nn.functional.avg_pool2d( + x, + kernel, + strides, + padding, + count_include_pad=count_include_pad, + ceil_mode=ceil_mode, + divisor_override=divisor_override, + ) + else: + x_shape = list(x.shape[2:]) + padding, pad_specific = _get_specific_pad(x_shape, kernel, strides, padding, 2) + x = torch.nn.functional.pad( + x, + padding, + value=0.0, + ) + res = torch.nn.functional.avg_pool2d( + x, kernel, strides, 0, ceil_mode, divisor_override=divisor_override + ) - if ceil_mode: - for i in range(2): - num_padded_values = _adjust_num_padded_values_to_ceil( - pad_specific, num_padded_values, x_shape, kernel, strides, 2 + if not count_include_pad and any(pad_specific) and not divisor_override: + num_padded_values = [ + ivy.map( + _get_num_padded_values, + constant={ + "p": pad_specific[i], + "n": x_shape[i], + "k": kernel[i], + "s": strides[i], + }, + unique={ + "i": torch.arange(res.shape[i + 2]), + }, ) + for i in range(2) + ] + if ceil_mode: + for i in range(2): + num_padded_values = _adjust_num_padded_values_to_ceil( + pad_specific, num_padded_values, x_shape, kernel, strides, 2 + ) + num_padded_values1 = torch.tensor(num_padded_values[0], dtype=res.dtype)[ + :, None + ] + num_padded_values2 = torch.tensor(num_padded_values[1], dtype=res.dtype)[ + None, : + ] + num_padded_values = ( + num_padded_values1 * kernel[1] + + num_padded_values2 * kernel[0] + - num_padded_values1 * num_padded_values2 + ) + res = (kernel[0] * kernel[1] * res) / ( + kernel[0] * kernel[1] - num_padded_values + ) - num_padded_values1 = torch.tensor(num_padded_values[0], dtype=res.dtype)[ - :, None - ] - num_padded_values2 = torch.tensor(num_padded_values[1], dtype=res.dtype)[ - None, : - ] - num_padded_values = ( - num_padded_values1 * kernel[1] - + num_padded_values2 * kernel[0] - - num_padded_values1 * num_padded_values2 - ) - res = (kernel[0] * kernel[1] * res) / ( - kernel[0] * kernel[1] - num_padded_values - ) if data_format == "NHWC": return res.permute(0, 2, 3, 1) return res @@ -489,56 +522,73 @@ def avg_pool3d( kernel = (kernel[0], kernel[0], kernel[0]) if data_format == "NDHWC": x = x.permute(0, 4, 1, 2, 3) - x_shape = list(x.shape[2:]) - padding, pad_specific = _get_specific_pad(x_shape, kernel, strides, padding, 3) - x = torch.nn.functional.pad( - x, - padding, - value=0.0, - ) - res = torch.nn.functional.avg_pool3d( - x, kernel, strides, 0, ceil_mode, divisor_override=divisor_override - ) - if not count_include_pad and any(pad_specific) and not divisor_override: - num_padded_values = [ - torch.tensor( - ivy.map( - _get_num_padded_values, - constant={ - "p": pad_specific[i], - "n": x_shape[i], - "k": kernel[i], - "s": strides[i], - }, - unique={ - "i": torch.arange(res.shape[i + 2]), - }, - ), - dtype=res.dtype, - ) - for i in range(3) - ] + if ( + isinstance(padding, int) + or not isinstance(padding, str) + and all(pad[0] == pad[1] for pad in padding) + ): + if not isinstance(padding, int): + padding = [padding[0][0], padding[1][0], padding[2][0]] + res = torch.nn.functional.avg_pool3d( + x, + kernel, + strides, + padding, + count_include_pad=count_include_pad, + ceil_mode=ceil_mode, + divisor_override=divisor_override, + ) + else: + x_shape = list(x.shape[2:]) + padding, pad_specific = _get_specific_pad(x_shape, kernel, strides, padding, 3) + x = torch.nn.functional.pad( + x, + padding, + value=0.0, + ) + res = torch.nn.functional.avg_pool3d( + x, kernel, strides, 0, ceil_mode, divisor_override=divisor_override + ) - if ceil_mode: - for i in range(3): - num_padded_values = _adjust_num_padded_values_to_ceil( - pad_specific, num_padded_values, x_shape, kernel, strides, 3 + if not count_include_pad and any(pad_specific) and not divisor_override: + num_padded_values = [ + torch.tensor( + ivy.map( + _get_num_padded_values, + constant={ + "p": pad_specific[i], + "n": x_shape[i], + "k": kernel[i], + "s": strides[i], + }, + unique={ + "i": torch.arange(res.shape[i + 2]), + }, + ), + dtype=res.dtype, ) - num_padded_values1 = num_padded_values[0].reshape((-1, 1, 1)) - num_padded_values2 = num_padded_values[1].reshape((1, -1, 1)) - num_padded_values3 = num_padded_values[2].reshape((1, 1, -1)) - num_padded_values = ( - num_padded_values1 * kernel[1] * kernel[2] - + num_padded_values2 * kernel[0] * kernel[2] - + num_padded_values3 * kernel[0] * kernel[1] - + num_padded_values1 * num_padded_values2 * num_padded_values3 - - num_padded_values1 * num_padded_values2 * kernel[2] - - num_padded_values1 * num_padded_values3 * kernel[1] - - num_padded_values2 * num_padded_values3 * kernel[0] - ) - kernel_mul = kernel[0] * kernel[1] * kernel[2] - res = (kernel_mul * res) / (kernel_mul - num_padded_values) + for i in range(3) + ] + if ceil_mode: + for i in range(3): + num_padded_values = _adjust_num_padded_values_to_ceil( + pad_specific, num_padded_values, x_shape, kernel, strides, 3 + ) + num_padded_values1 = num_padded_values[0].reshape((-1, 1, 1)) + num_padded_values2 = num_padded_values[1].reshape((1, -1, 1)) + num_padded_values3 = num_padded_values[2].reshape((1, 1, -1)) + num_padded_values = ( + num_padded_values1 * kernel[1] * kernel[2] + + num_padded_values2 * kernel[0] * kernel[2] + + num_padded_values3 * kernel[0] * kernel[1] + + num_padded_values1 * num_padded_values2 * num_padded_values3 + - num_padded_values1 * num_padded_values2 * kernel[2] + - num_padded_values1 * num_padded_values3 * kernel[1] + - num_padded_values2 * num_padded_values3 * kernel[0] + ) + kernel_mul = kernel[0] * kernel[1] * kernel[2] + res = (kernel_mul * res) / (kernel_mul - num_padded_values) if data_format == "NDHWC": res = res.permute(0, 2, 3, 4, 1) diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index b8b70ed93bff4..827b5e8815851 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -208,8 +208,8 @@ def max_pool1d( kernel_size, stride=None, padding=0, - ceil_mode=False, dilation=1, + ceil_mode=False, return_indices=False, ): if stride is None: diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index b710032ecf31e..987781d4d27d2 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -303,7 +303,7 @@ def avg_pool1d( data_format: str = "NWC", count_include_pad: bool = False, ceil_mode: bool = False, - division_override: Optional[int] = None, + divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: """ @@ -327,7 +327,7 @@ def avg_pool1d( Whether to include padding in the averaging calculation. ceil_mode Whether to use ceil or floor for creating the output shape. - division_override + divisor_override If specified, it will be used as the divisor, otherwise kernel_size will be used. out @@ -366,7 +366,7 @@ def avg_pool1d( data_format=data_format, count_include_pad=count_include_pad, ceil_mode=ceil_mode, - division_override=division_override, + divisor_override=divisor_override, out=out, ) @@ -2025,7 +2025,7 @@ def _output_ceil_shape(w, f, p, s): def _padding_ceil_mode(w, f, p, s, return_added_padding=False): - remaining_pixels = (w - f + sum(p)) % s + remaining_pixels = (w - f + p[0]) % s added_padding = 0 if s > 1 and remaining_pixels != 0 and f > 1: input_size = w + sum(p) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py index 34b91f0d80852..7abe0b623de58 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py @@ -171,7 +171,7 @@ def test_torch_adaptive_max_pool2d( data_format="channel_first", only_explicit_padding=True, ), - count_include_pad=st.just(False), + count_include_pad=st.booleans(), ceil_mode=st.booleans(), test_with_out=st.just(False), ) @@ -387,12 +387,15 @@ def test_torch_lp_pool2d( min_side=1, max_side=3, only_explicit_padding=True, + return_dilation=True, data_format="channel_first", ), test_with_out=st.just(False), + ceil_mode=st.booleans(), ) def test_torch_max_pool1d( dtype_x_k_s, + ceil_mode, *, test_flags, frontend, @@ -400,20 +403,22 @@ def test_torch_max_pool1d( fn_tree, on_device, ): - input_dtype, x, kernel_size, stride, padding = dtype_x_k_s + dtype, x, kernel, stride, padding, dilation = dtype_x_k_s if not isinstance(padding, int): padding = [pad[0] for pad in padding] helpers.test_frontend_function( - input_dtypes=input_dtype, + input_dtypes=dtype, backend_to_test=backend_fw, test_flags=test_flags, frontend=frontend, fn_tree=fn_tree, on_device=on_device, input=x[0], - kernel_size=kernel_size, + kernel_size=kernel, stride=stride, padding=padding, + dilation=dilation, + ceil_mode=ceil_mode, ) @@ -430,7 +435,7 @@ def test_torch_max_pool1d( data_format="channel_first", ), test_with_out=st.just(False), - ceil_mode=st.just(True), + ceil_mode=st.booleans(), ) def test_torch_max_pool2d( x_k_s_p, From 2d953925bbc9860451ce4201e4c3272d3fef1c32 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 8 Nov 2023 14:29:36 +0000 Subject: [PATCH 138/978] refactor: Reduced calls in torch and tf backends of ivy.concat --- .../backends/tensorflow/manipulation.py | 39 +++++++++---------- ivy/functional/backends/torch/manipulation.py | 9 +---- 2 files changed, 20 insertions(+), 28 deletions(-) diff --git a/ivy/functional/backends/tensorflow/manipulation.py b/ivy/functional/backends/tensorflow/manipulation.py index 2350017b1931e..3800ed8580297 100644 --- a/ivy/functional/backends/tensorflow/manipulation.py +++ b/ivy/functional/backends/tensorflow/manipulation.py @@ -32,26 +32,25 @@ def concat( axis: int = 0, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - is_tuple = type(xs) is tuple - is_axis_none = axis is None - if is_tuple: - xs = list(xs) - highest_dtype = xs[0].dtype - for i in xs: - highest_dtype = ivy.as_native_dtype(ivy.promote_types(highest_dtype, i.dtype)) - - for i in range(len(xs)): - if is_axis_none: - xs[i] = tf.reshape(xs[i], -1) - xs[i] = ivy.astype(xs[i], highest_dtype, copy=False).to_native() - if is_axis_none: - axis = 0 - if is_tuple: - xs = tuple(xs) - try: - return tf.concat(xs, axis) - except (tf.errors.InvalidArgumentError, np.AxisError) as error: - raise ivy.utils.exceptions.IvyIndexError(error) + if axis is not None: + try: + return tf.concat(xs, axis) + except tf.errors.InvalidArgumentError as error: + if "(zero-based) was expected to be" in error.message: + highest_dtype = xs[0].dtype + for i in xs: + highest_dtype = ivy.promote_types(highest_dtype, i.dtype) + highest_dtype = ivy.as_native_dtype(highest_dtype) + return tf.concat( + [ + tf.cast(x, highest_dtype) if x.dtype != highest_dtype else x + for x in xs + ], + axis, + ) + else: + raise + return concat([tf.reshape(x, -1) for x in xs], axis=0) def expand_dims( diff --git a/ivy/functional/backends/torch/manipulation.py b/ivy/functional/backends/torch/manipulation.py index b1676faacc2f5..741b1d81a5a02 100644 --- a/ivy/functional/backends/torch/manipulation.py +++ b/ivy/functional/backends/torch/manipulation.py @@ -32,14 +32,7 @@ def concat( out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if axis is None: - is_tuple = type(xs) is tuple - if is_tuple: - xs = list(xs) - for i in range(len(xs)): - xs[i] = torch.flatten(xs[i]) - if is_tuple: - xs = tuple(xs) - axis = 0 + return torch.cat([torch.flatten(x) for x in xs], dim=0, out=out) return torch.cat(xs, dim=axis, out=out) From 567093e891fd4da8a9d5031dbb4c851310b7e182 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 8 Nov 2023 14:49:33 +0000 Subject: [PATCH 139/978] refactor: Added an extra condition to avoid unneccesary ivy.astype call in ivy.dropout's backends --- ivy/functional/backends/tensorflow/experimental/layers.py | 2 +- ivy/functional/backends/torch/experimental/layers.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 823f27f73f15c..99f387c5af6d2 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -723,7 +723,7 @@ def dropout( noise_shape: Optional[Sequence[int]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - x = ivy.astype(x, dtype) if dtype else x + x = ivy.astype(x, dtype) if dtype and x.dtype != dtype else x res = tf.nn.dropout(x, prob, noise_shape=noise_shape, seed=seed) if training else x res = res if scale else tf.multiply(res, (1.0 - prob)) return res diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 01c771dd9d2b2..b6dc35c313747 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -774,7 +774,7 @@ def dropout( noise_shape: Optional[Sequence[int]] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: - x = ivy.astype(x, dtype) if dtype else x + x = ivy.astype(x, dtype) if dtype and x.dtype != dtype else x res = torch.nn.functional.dropout(x, prob, training=training) res = res if scale else torch.multiply(res, (1.0 - prob)) return res From b790ee04b0117161d063cbe3638af4e975812eaf Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 9 Nov 2023 10:33:36 +0000 Subject: [PATCH 140/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index b5104bb51e8c8..f0fc2b6e8ddf5 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit b5104bb51e8c80cbb971a5d25340cc6906d6bf39 +Subproject commit f0fc2b6e8ddf5aa28093a55a755d14f04e628973 From 5d4d0a5c7dd6e540de5b7e383be1a73ed0afd9c9 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 9 Nov 2023 19:53:35 +0530 Subject: [PATCH 141/978] fix: Removed un-necessary trailing comma on bare `tuple`. (#27232) --- .../frontends/torch/nn/functional/vision_functions.py | 2 +- ivy_tests/test_ivy/test_misc/test_assertions.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index 39e5ce64eb99d..d1c61a2175f7c 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -461,7 +461,7 @@ def pixel_unshuffle(input, downscale_factor): f"pixel_unshuffle expects 4D input, but got input with sizes {input_shape}" ), as_array=False, - ), + ) b = input_shape[0] c = input_shape[1] diff --git a/ivy_tests/test_ivy/test_misc/test_assertions.py b/ivy_tests/test_ivy/test_misc/test_assertions.py index 986190041034d..d9530fcd6ebe6 100644 --- a/ivy_tests/test_ivy/test_misc/test_assertions.py +++ b/ivy_tests/test_ivy/test_misc/test_assertions.py @@ -838,7 +838,6 @@ def test_check_true(expression): (ivy.array([1, 2, 3]), ivy.array([0, 1, 0], dtype=ivy.int32), 2.0), (ivy.array([1, 2, 3]), ivy.array([0, 1, 0], dtype=ivy.int32), 0), (ivy.array([1, 2, 3]), ivy.array([0, 1, 0], dtype=ivy.int32), -2), - (ivy.array([1, 2, 3]), ivy.array([0, 1, 0], dtype=ivy.int32), 0), (ivy.array([1, 2, 3]), ivy.array([0.0, 1.0, 0.0], dtype=ivy.float16), 0), (ivy.array([1, 2]), ivy.array([0, 1, 0], dtype=ivy.int32), 0), (ivy.array([1, 2, 3]), ivy.array([0, 1], dtype=ivy.int32), 0), From 6e030d933f7d16752a6bbb3855243c29a4ad1bed Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 9 Nov 2023 14:51:59 +0000 Subject: [PATCH 142/978] refactor: Avoid while loop in torch pad --- .../frontends/torch/nn/functional/vision_functions.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index d1c61a2175f7c..b9976f54fbac0 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -17,11 +17,10 @@ def _handle_padding_shape(padding, n, mode): for i in range(int(len(padding) / 2) - 1, -1, -1) ] ) - while len(padding) < n: - if mode == "circular": - padding = padding + ((0, 0),) - else: - padding = ((0, 0),) + padding + if mode == "circular": + padding = padding + ((0, 0),) * (n - len(padding)) + else: + padding = ((0, 0),) * (n - len(padding)) + padding if mode == "circular": padding = tuple(list(padding)[::-1]) return padding From 1ff45b8f437ed06bff1416c0e8c7e03c16c6d766 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 9 Nov 2023 15:41:31 +0000 Subject: [PATCH 143/978] refactor: Shortened torch's partial_mixed_handler of ivy.pad --- .../torch/experimental/manipulation.py | 18 ++++++++++-------- .../ivy/experimental/manipulation.py | 5 +++-- 2 files changed, 13 insertions(+), 10 deletions(-) diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index 589441629ccbd..5603bf44ad13f 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -122,16 +122,18 @@ def pad( def _check_torch_pad(mode, reflect_type, pad_width, input_shape, constant_values): - pad_width = _to_tf_padding(pad_width, len(input_shape)) - if mode != "constant" and ( - len(input_shape) > 4 - or (len(input_shape) == 4 and len(pad_width) > 3) - or (len(input_shape) == 3 and len(pad_width) > 2) - or (len(input_shape) == 2 and len(pad_width) > 1) - ): + ndim = len(input_shape) + pad_width = _to_tf_padding(pad_width, ndim) + if mode != "constant" and (ndim > 4 or (ndim > 1 and len(pad_width) > ndim - 1)): return False return _check_paddle_pad( - mode, reflect_type, pad_width, input_shape, constant_values, 4 + mode, + reflect_type, + pad_width, + input_shape, + constant_values, + 4, + extend=False, ) and ( mode != "wrap" or all( diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index 94a6360ecc4ce..282d90a5f6a6b 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -53,9 +53,10 @@ def _to_tf_padding(pad_width, ndim): def _check_paddle_pad( - mode, reflect_type, pad_width, input_shape, constant_values, ndim_limit + mode, reflect_type, pad_width, input_shape, constant_values, ndim_limit, extend=True ): - pad_width = _to_tf_padding(pad_width, len(input_shape)) + if extend: + pad_width = _to_tf_padding(pad_width, len(input_shape)) return isinstance(constant_values, Number) and ( mode == "constant" or ( From 6672f530958fcce662b19456b252182703983115 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 9 Nov 2023 17:48:26 +0000 Subject: [PATCH 144/978] refactor: removed some redundant calls from ivy.batch_norm --- ivy/functional/backends/tensorflow/experimental/norms.py | 8 ++------ ivy/functional/ivy/experimental/norms.py | 8 +++----- .../test_experimental/test_nn/test_norms.py | 2 ++ 3 files changed, 7 insertions(+), 11 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/norms.py b/ivy/functional/backends/tensorflow/experimental/norms.py index d589909759f28..dc5b2b747d9f9 100644 --- a/ivy/functional/backends/tensorflow/experimental/norms.py +++ b/ivy/functional/backends/tensorflow/experimental/norms.py @@ -61,12 +61,8 @@ def batch_norm( runningmean = mean runningvariance = variance if training: - n = ( - tf.size(x) - if xdims == 1 - else tf.cast(tf.divide(tf.size(x), tf.shape(x)[-1]), x.dtype) - ) - n = tf.cast(n, x.dtype) + n = tf.size(x) if xdims == 1 else tf.divide(tf.size(x), tf.shape(x)[-1]) + n = tf.cast(n, x.dtype) if n.dtype != x.dtype else n dims = (0, *range(1, xdims - 1)) mean = tf.math.reduce_mean(x, axis=dims) variance = tf.math.reduce_variance(x, axis=dims) diff --git a/ivy/functional/ivy/experimental/norms.py b/ivy/functional/ivy/experimental/norms.py index ae7951baac434..071eebec14b9a 100644 --- a/ivy/functional/ivy/experimental/norms.py +++ b/ivy/functional/ivy/experimental/norms.py @@ -183,8 +183,7 @@ def batch_norm( runningvariance = variance if training: - numel = int(ivy.prod(x.shape)) - n = numel if xdims == 1 else numel / x.shape[-1] + n = x.size if xdims == 1 else x.size / x.shape[-1] dims = (0, *range(1, xdims - 1)) mean = ivy.mean(x, axis=dims) variance = ivy.var(x, axis=dims) @@ -193,11 +192,10 @@ def batch_norm( n - 1 ) inv = 1.0 / ivy.sqrt(variance + eps) + offset = 0 if offset is None else offset if scale is not None: inv = inv * scale - xnormalized = x * inv.astype(x.dtype, copy=False) + ivy.astype( - offset - mean * inv if offset is not None else -mean * inv, x.dtype, copy=False - ) + xnormalized = x * inv + offset - mean * inv if data_format == "NCS": xnormalized = ivy.permute_dims( diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_norms.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_norms.py index 014305269a51e..3eb57f5149736 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_norms.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_norms.py @@ -170,6 +170,8 @@ def _instance_and_batch_norm_helper(draw, *, min_dims=1, test_function="instance fn_tree="functional.ivy.experimental.batch_norm", data=_instance_and_batch_norm_helper(min_dims=2, test_function="batch_norm"), training=st.booleans(), + test_instance_method=st.just(False), + container_flags=st.just([False]), ) def test_batch_norm(*, data, training, test_flags, backend_fw, fn_name, on_device): x_dtype, x, mean, variance, offset, scale, eps, momentum, data_format = data From ef4c3559822aa87819582bef97bbc1718c600231 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 9 Nov 2023 17:59:31 +0000 Subject: [PATCH 145/978] feat: Added ivy.local_response_norm to optimize the corresponding torch and tensorflow frontend functions --- .../backends/tensorflow/experimental/norms.py | 41 ++++++++- .../backends/torch/experimental/norms.py | 28 +++++- ivy/functional/frontends/tensorflow/nn.py | 21 +---- .../non_linear_activation_functions.py | 40 +++------ ivy/functional/ivy/experimental/norms.py | 85 ++++++++++++++++++- .../test_frontends/test_tensorflow/test_nn.py | 12 ++- .../test_non_linear_activation_functions.py | 14 +-- .../test_experimental/test_nn/test_norms.py | 54 ++++++++++++ 8 files changed, 229 insertions(+), 66 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/norms.py b/ivy/functional/backends/tensorflow/experimental/norms.py index dc5b2b747d9f9..91a6f46ad4259 100644 --- a/ivy/functional/backends/tensorflow/experimental/norms.py +++ b/ivy/functional/backends/tensorflow/experimental/norms.py @@ -1,7 +1,8 @@ import tensorflow as tf -from typing import Union, Optional, Tuple -from ivy.func_wrapper import with_unsupported_dtypes +from typing import Literal, Union, Optional, Tuple +from ivy.func_wrapper import with_supported_dtypes, with_unsupported_dtypes from . import backend_version +import math @with_unsupported_dtypes({"2.14.0 and below": "uint8"}, backend_version) @@ -29,6 +30,42 @@ def l2_normalize( return tf.math.divide(x, denorm) +@with_supported_dtypes({"2.14.0 and below": ("float32", "float16")}, backend_version) +def local_response_norm( + x: Union[tf.Tensor, tf.Variable], + size, + /, + *, + bias: Optional[float] = 1.0, + alpha: Optional[float] = 1.0, + beta: Optional[float] = 0.5, + average: bool = False, + data_format: Optional[Literal["NHWC", "NCHW"]] = "NHWC", + out: Optional[tf.Tensor] = None, +) -> tf.Tensor: + if data_format == "NCHW": + x = tf.transpose(x, (0, 2, 3, 1)) + # `alpha = alpha/size if average else alpha` was causing numerical instability + if average: + ret = tf.nn.local_response_normalization( + x / math.sqrt(size), + depth_radius=size // 2, + bias=bias, + alpha=alpha, + beta=beta, + ) * math.sqrt(size) + else: + ret = tf.nn.local_response_normalization( + x, depth_radius=size // 2, bias=bias, alpha=alpha, beta=beta + ) + if data_format == "NCHW": + ret = tf.transpose(ret, (0, 3, 1, 2)) + return ret + + +local_response_norm.partial_mixed_handler = lambda x, size, **kwargs: size % 2 != 0 + + @with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) def batch_norm( x: Union[tf.Tensor, tf.Variable], diff --git a/ivy/functional/backends/torch/experimental/norms.py b/ivy/functional/backends/torch/experimental/norms.py index 97ec9ae1d02ab..88c86d28de10d 100644 --- a/ivy/functional/backends/torch/experimental/norms.py +++ b/ivy/functional/backends/torch/experimental/norms.py @@ -1,7 +1,7 @@ import torch -from typing import Optional, Tuple +from typing import Literal, Optional, Tuple -from ivy.func_wrapper import with_unsupported_dtypes +from ivy.func_wrapper import with_supported_dtypes, with_unsupported_dtypes from .. import backend_version @@ -32,6 +32,30 @@ def l2_normalize( l2_normalize.support_native_out = True +@with_supported_dtypes({"2.1.0 and below": ("float",)}, backend_version) +def local_response_norm( + x: torch.Tensor, + size, + /, + *, + bias: Optional[float] = 1.0, + alpha: Optional[float] = 1.0, + beta: Optional[float] = 0.5, + average: bool = False, + data_format: Optional[Literal["NHWC", "NCHW"]] = "NHWC", + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + if data_format == "NHWC": + x = torch.permute(x, (0, 3, 1, 2)) + alpha = alpha * size if not average else alpha + ret = torch.nn.functional.local_response_norm( + x, size, alpha=alpha, beta=beta, k=bias + ) + if data_format == "NHWC": + ret = torch.permute(ret, (0, 2, 3, 1)) + return ret + + @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) def batch_norm( x: torch.Tensor, diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index 1402aa0ec7f21..1334725919ca4 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -342,31 +342,16 @@ def leaky_relu(features, alpha=0.2, name=None): return ivy.leaky_relu(features, alpha=alpha) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, "tensorflow") +@with_supported_dtypes({"2.14.0 and below": ("float32", "float16")}, "tensorflow") @to_ivy_arrays_and_back def local_response_normalization( input, depth_radius=5, bias=1.0, alpha=1.0, beta=0.5, name=None ): - input_shape = ivy.shape(input) - depth = input_shape[-1] - ivy.utils.assertions.check_equal( - ivy.get_num_dims(input), - 4, - message="4D input, but got input with sizes " + str(input_shape), - as_array=False, + return ivy.local_response_norm( + input, 2 * depth_radius + 1, bias=bias, alpha=alpha, beta=beta ) - sqr_sum = ivy.empty(input_shape[:-1] + (0,), dtype=ivy.dtype(input)) - for d in range(depth): - start = max(0, d - depth_radius) - end = min(d + depth_radius + 1, depth) - inter_channel_sum = ivy.sum( - input[:, :, :, start:end] ** 2, axis=3, keepdims=True - ) - sqr_sum = ivy.concat([sqr_sum, inter_channel_sum], axis=-1) - return ivy.divide(input, ivy.pow(ivy.add(sqr_sum * alpha, bias), beta)) -# log_poisson_loss @to_ivy_arrays_and_back def log_poisson_loss(targets, log_input, compute_full_loss=False, name=None): return ivy.log_poisson_loss(targets, log_input, compute_full_loss=compute_full_loss) diff --git a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py index bca71b8bb220b..d62b2a0151ff9 100644 --- a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py @@ -123,37 +123,17 @@ def leaky_relu_(input, negative_slope=0.01): @to_ivy_arrays_and_back +@with_supported_dtypes({"2.1.0 and below": ("float",)}, "torch") def local_response_norm(input, size, alpha=0.0001, beta=0.75, k=1.0): - dim = len(ivy.shape(input)) - if dim < 3: - raise ValueError( - f"Expected 3D or higher dimensionality input (got {dim} dimensions)" - ) - if input.size == 0: - return input - div = ivy.multiply(input, input) - - if dim == 3: - div = ivy.expand_dims(div, axis=1) - div = ivy.zero_pad(div, ((0, 0), (0, 0), (size // 2, (size - 1) // 2), (0, 0))) - div = ivy.avg_pool2d( - div, (size, 1), 1, "VALID", count_include_pad=True, data_format="NCHW" - ) - div = ivy.squeeze(div, axis=1) - else: - sizes = ivy.shape(input) - div = ivy.reshape(div, (sizes[0], 1, sizes[1], sizes[2], -1)) - div = ivy.zero_pad( - div, ((0, 0), (0, 0), (size // 2, (size - 1) // 2), (0, 0), (0, 0)) - ) - div = ivy.avg_pool3d( - div, (size, 1, 1), 1, "VALID", count_include_pad=True, data_format="NCDHW" - ) - div = ivy.squeeze(div, axis=1) - div = ivy.reshape(div, sizes) - - div = ivy.pow(ivy.add(ivy.multiply(div, alpha), k), beta) - return ivy.divide(input, div) + non_batched = input.ndim == 3 + if non_batched: + input = ivy.expand_dims(input, axis=2) + ret = ivy.local_response_norm( + input, size, bias=k, alpha=alpha, beta=beta, average=True, data_format="NCHW" + ) + if non_batched: + ret = ivy.squeeze(ret, axis=2) + return ret @to_ivy_arrays_and_back diff --git a/ivy/functional/ivy/experimental/norms.py b/ivy/functional/ivy/experimental/norms.py index 071eebec14b9a..ddc8a1520cbb6 100644 --- a/ivy/functional/ivy/experimental/norms.py +++ b/ivy/functional/ivy/experimental/norms.py @@ -1,4 +1,4 @@ -from typing import Union, Optional, Tuple +from typing import Literal, Union, Optional, Tuple # local import ivy @@ -102,6 +102,89 @@ def l2_normalize( return current_backend(x).l2_normalize(x, axis=axis, out=out) +@handle_exceptions +@handle_nestable +@handle_partial_mixed_function +@handle_array_like_without_promotion +@inputs_to_ivy_arrays +@handle_array_function +def local_response_norm( + x: Union[ivy.NativeArray, ivy.Array], + size, + /, + *, + bias: Optional[float] = 1.0, + alpha: Optional[float] = 1.0, + beta: Optional[float] = 0.5, + average: bool = False, + data_format: Optional[Literal["NHWC", "NCHW"]] = "NHWC", + out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, +) -> ivy.Array: + """ + Apply local response normalization across the channels of a 4D input array. The 4-D + array is treated as a 3-D array of 1-D vectors (along the channel dimension), and + each vector is normalized independently. Within a given vector, each component is + divided by the squared sum of the neighbouring components. + + Parameters + ---------- + x + Input array of default shape (N, H, W, C), where N is the batch dimension, + H and W correspond to the spatial dimensions and C corresponds to the + channel dimension. + size + The width of the normalization window. + alpha + The multiplicative factor. + beta + The exponent. + bias + An additive factor. + average + If True, each component is divided by the **averaged** squared sum. + data_format + The ordering of the dimensions in the input, either "NHWC" or "NCHW". + out + optional output arrays, for writing the result to. + + Returns + ------- + ret + The normalized array. + """ + if data_format == "NHWC": + x = ivy.permute_dims(x, axes=(0, 3, 1, 2)) + x_shape = x.shape + alpha = alpha * size if not average else alpha + ret = ivy.square(x) + ret = ivy.reshape(ret, (x_shape[0], 1, x_shape[1], x_shape[2], -1)) + ret = ivy.zero_pad( + ret, ((0, 0), (0, 0), (size // 2, (size - 1) // 2), (0, 0), (0, 0)) + ) + ret = ivy.avg_pool3d( + ret, (size, 1, 1), 1, "VALID", count_include_pad=True, data_format="NCDHW" + ) + ret = ivy.squeeze(ret, axis=1) + ret = ivy.reshape(ret, x_shape) + ret = ivy.pow(ivy.add(ivy.multiply(ret, alpha), bias), beta) + ret = ivy.divide(x, ret) + if data_format == "NHWC": + ret = ivy.permute_dims(ret, axes=(0, 2, 3, 1)) + return ret + + +local_response_norm.mixed_backend_wrappers = { + "to_add": ( + "handle_backend_invalid", + "handle_out_argument", + "inputs_to_native_arrays", + "outputs_to_ivy_arrays", + "handle_device", + ), + "to_skip": ("inputs_to_ivy_arrays", "handle_partial_mixed_function"), +} + + @handle_exceptions @handle_nestable @handle_partial_mixed_function diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py index c90ef72de9b48..6e31f5673a1cd 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py @@ -1343,14 +1343,13 @@ def test_tensorflow_leaky_relu( @handle_frontend_test( fn_tree="tensorflow.nn.local_response_normalization", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), - min_value=-20, - max_value=20, + available_dtypes=helpers.get_dtypes("valid"), min_num_dims=4, max_num_dims=4, min_dim_size=1, - large_abs_safety_factor=25, - small_abs_safety_factor=25, + large_abs_safety_factor=2, + small_abs_safety_factor=2, + safety_factor_scale="log", ), depth_radius=st.integers(min_value=1, max_value=5), bias=st.floats(min_value=0.1, max_value=1.5), @@ -1379,8 +1378,7 @@ def test_tensorflow_local_response_normalization( test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, - rtol=1e-1, - atol=1e-1, + atol=1e-2, input=x[0], depth_radius=depth_radius, bias=bias, diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py index 2c9dc0c529024..953e6865a11c7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py @@ -583,11 +583,13 @@ def test_torch_leaky_relu_( # local_response_norm @handle_frontend_test( fn_tree="torch.nn.functional.local_response_norm", - dtype_x_and_axis=helpers.dtype_values_axis( - available_dtypes=helpers.get_dtypes("float"), + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), min_num_dims=3, - force_int_axis=True, - valid_axis=True, + max_num_dims=4, + large_abs_safety_factor=2, + small_abs_safety_factor=2, + safety_factor_scale="log", ), size=helpers.ints(min_value=3, max_value=10), alpha=helpers.floats(min_value=1e-4, max_value=1e-3), @@ -596,7 +598,7 @@ def test_torch_leaky_relu_( ) def test_torch_local_response_norm( *, - dtype_x_and_axis, + dtype_and_x, size, alpha, beta, @@ -607,7 +609,7 @@ def test_torch_local_response_norm( test_flags, backend_fw, ): - dtype, x, axis = dtype_x_and_axis + dtype, x = dtype_and_x _filter_dtypes(dtype) helpers.test_frontend_function( input_dtypes=dtype, diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_norms.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_norms.py index 3eb57f5149736..f728d9840769a 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_norms.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_norms.py @@ -273,3 +273,57 @@ def test_l1_normalize(*, dtype_values_axis, test_flags, backend_fw, fn_name, on_ x=x, axis=axis, ) + + +# local_response_norm +@handle_test( + fn_tree="functional.ivy.experimental.local_response_norm", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_num_dims=4, + max_num_dims=4, + min_dim_size=1, + large_abs_safety_factor=2, + small_abs_safety_factor=2, + safety_factor_scale="log", + ), + size=st.integers(min_value=1, max_value=10), + bias=st.floats(min_value=0.1, max_value=1.5), + alpha=st.floats(min_value=1e-4, max_value=1.2), + beta=st.floats(min_value=0.1, max_value=1.5), + average=st.booleans(), + data_format=st.sampled_from(["NHWC", "NCHW"]), + test_with_out=st.just(False), + test_instance_method=st.just(False), + container_flags=st.just([False]), + test_gradients=st.just(False), +) +def test_local_response_norm( + *, + dtype_and_x, + size, + bias, + alpha, + beta, + average, + data_format, + test_flags, + fn_name, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_name=fn_name, + on_device=on_device, + input=x[0], + size=size, + bias=bias, + alpha=alpha, + beta=beta, + average=average, + data_format=data_format, + ) From 1c174218bdc09bb305002e75ef32e4990b2c74f8 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 9 Nov 2023 18:01:29 +0000 Subject: [PATCH 146/978] fix: removed incorrect extra implementation of ivy.pad in torch --- ivy/functional/backends/torch/creation.py | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/ivy/functional/backends/torch/creation.py b/ivy/functional/backends/torch/creation.py index ea34478abeaa8..2a88d7696903c 100644 --- a/ivy/functional/backends/torch/creation.py +++ b/ivy/functional/backends/torch/creation.py @@ -607,15 +607,3 @@ def triu_indices( row=n_rows, col=n_cols, offset=k, dtype=torch.int64, device=device ) ) - - -def pad(tensor, sizes_of_pad, mode="constant", value=0): - if len(sizes_of_pad) == tensor.dim(): - pad_pairs = [] - for size in sizes_of_pad: - if size >= 0: - pad_pairs.append((size // 2, size - size // 2)) - pad_pairs = pad_pairs[::-1] - pad_list = [item for pair in pad_pairs for item in pair] - - return torch.nn.functional.pad(tensor, pad_list, mode, value) From 7cc8b4d81f139216c2986349885ee457697fd1bd Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 10 Nov 2023 12:37:13 +0530 Subject: [PATCH 147/978] fix: removed the dependence on the old dashboard for checking if a failure was newly introduced and removed the new failures introduced section entirely for now (#27234) --- .github/workflows/intelligent-tests-pr.yml | 14 ++--- scripts/run_tests/run_tests_pr.py | 60 +--------------------- 2 files changed, 8 insertions(+), 66 deletions(-) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index fa294f12f12fc..5da9fa05de9f2 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -24,15 +24,15 @@ jobs: echo "Test results summary:" cat combined_test_results.txt - - name: New Failures Introduced + - name: Test Failures run: | - find . -name "new_failures_*.txt" -exec cat {} + > combined_failures.txt + find . -name "test_failures_*.txt" -exec cat {} + > combined_failures.txt if [ -s combined_failures.txt ] then - echo "This PR introduces the following new failing tests:" + echo "The CI captured the following failing tests based on your changes:" cat combined_failures.txt else - echo "This PR does not introduce any new test failures! Yippee!" + echo "No test failures found based on your changes!" fi run_tests: @@ -89,7 +89,7 @@ jobs: cd ivy python scripts/determine_tests/determine_tests.py ${{ matrix.branch }} pr set -o pipefail - python scripts/run_tests/run_tests_pr.py new_failures_${{ matrix.branch }}.txt | tee test_results_${{ matrix.branch }}.txt + python scripts/run_tests/run_tests_pr.py test_failures_${{ matrix.branch }}.txt | tee test_results_${{ matrix.branch }}.txt cd .. continue-on-error: true @@ -102,8 +102,8 @@ jobs: - name: Upload New Failures uses: actions/upload-artifact@v3 with: - name: new_failures_${{ matrix.branch }} - path: ivy/new_failures_${{ matrix.branch }}.txt + name: test_failures_${{ matrix.branch }} + path: ivy/test_failures_${{ matrix.branch }}.txt - name: Check on failures if: steps.tests.outcome != 'success' diff --git a/scripts/run_tests/run_tests_pr.py b/scripts/run_tests/run_tests_pr.py index 3dd5a0a7a3d29..a910ad80f2803 100644 --- a/scripts/run_tests/run_tests_pr.py +++ b/scripts/run_tests/run_tests_pr.py @@ -1,55 +1,6 @@ # Run Tests import os import sys -import requests - -url = "https://ivy-dynamical-dashboards.onrender.com/api/test" - -modules = ( - "test_paddle", - "test_functional", - "test_experimental", - "test_stateful", - "test_tensorflow", - "test_torch", - "test_jax", - "test_numpy", - "test_misc", - "test_scipy", -) - -module_map = { - "test_functional/test_core": "core", - "test_experimental/test_core": "exp_core", - "test_functional/test_nn": "nn", - "test_experimental/test_nn": "exp_nn", - "test_stateful": "stateful", - "test_torch": "torch", - "test_jax": "jax", - "test_tensorflow": "tensorflow", - "test_numpy": "numpy", - "test_misc": "misc", - "test_paddle": "paddle", - "test_scipy": "scipy", -} - - -def get_mod_submod_test(test_path): - test_path = test_path.split("/") - module = "" - for name in modules: - if name in test_path: - if name == "test_functional": - module = module_map[f"test_functional/{test_path[-2]}"] - elif name == "test_experimental": - module = module_map[f"test_experimental/{test_path[-2]}"] - else: - module = module_map[name] - break - submod_test = test_path[-1] - submod, test_fn = submod_test.split("::") - submod = submod.replace("test_", "").replace(".py", "") - return module, submod, test_fn if __name__ == "__main__": @@ -67,16 +18,7 @@ def get_mod_submod_test(test_path): ) if ret != 0: failed = True - module, submodule, test = get_mod_submod_test(test) - params = { - "module": module, - "submodule": submodule, - "backend": backend[:-1], - "test": test, - } - response = requests.get(url, params=params) - if response.status_code == 200 and response.json(): - f_write.write(line) + f_write.write(line) if failed: sys.exit(1) From b349a8d58ae7ed8e92ca55c6638d4015e05b7ef5 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 10 Nov 2023 18:13:10 +0530 Subject: [PATCH 148/978] fix: updated gpu_framework_directory script to install cuda-supported tensorflow in the appropriate folder (#27239) --- docker/gpu_framework_directory.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docker/gpu_framework_directory.py b/docker/gpu_framework_directory.py index e4e185475ea85..21ed1e2fcf989 100644 --- a/docker/gpu_framework_directory.py +++ b/docker/gpu_framework_directory.py @@ -59,6 +59,11 @@ def install_pkg(path, pkg, base="fw/"): " --no-cache-dir", shell=True, ) + elif pkg.split("==")[0] if "==" in pkg else pkg == "tensorflow": + subprocess.run( + f"yes |pip install tensorflow[and-cuda] --target {path}", + shell=True, + ) else: subprocess.run( f"yes |pip3 install --upgrade {pkg} --target" From 568653a461c990cab9620c7780267182e66d87de Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 10 Nov 2023 19:39:05 +0530 Subject: [PATCH 149/978] feat: Updated `black` formatter version and modified all the files according to it. (#27236) --- .pre-commit-config.yaml | 2 +- ivy/__init__.py | 80 +- ivy/data_classes/container/base.py | 193 +-- ivy/data_classes/container/container.py | 12 +- .../factorized_tensor/tucker_tensor.py | 6 +- ivy/data_classes/nested_array/base.py | 6 +- ivy/func_wrapper.py | 108 +- .../numpy/experimental/elementwise.py | 172 +- .../paddle/experimental/elementwise.py | 86 +- ivy/functional/backends/paddle/general.py | 12 +- ivy/functional/backends/paddle/gradients.py | 10 +- ivy/functional/backends/paddle/set.py | 14 +- .../tensorflow/experimental/layers.py | 18 +- ivy/functional/backends/tensorflow/set.py | 12 +- .../backends/torch/experimental/gradients.py | 20 +- .../torch/experimental/statistical.py | 10 +- ivy/functional/backends/torch/general.py | 12 +- ivy/functional/backends/torch/set.py | 6 +- .../frontends/numpy/ma/MaskedArray.py | 10 +- .../arithmetic_operations.py | 10 +- .../frontends/numpy/ufunc/methods.py | 24 +- .../frontends/paddle/nn/functional/vision.py | 30 +- .../sklearn/model_selection/_split.py | 10 +- .../frontends/tensorflow/keras/metrics.py | 13 +- ivy/functional/frontends/tensorflow/nn.py | 6 +- .../torch/nn/functional/distance_functions.py | 12 +- .../torch/nn/functional/loss_functions.py | 10 +- .../torch/nn/functional/vision_functions.py | 10 +- .../frontends/torch/nn/modules/module.py | 10 +- ivy/functional/frontends/xgboost/core.py | 12 +- ivy/functional/frontends/xgboost/gbm/gbm.py | 10 +- ivy/functional/ivy/experimental/layers.py | 20 +- .../ivy/experimental/linear_algebra.py | 12 +- .../ivy/experimental/sparse_array.py | 20 +- ivy/functional/ivy/meta.py | 28 +- ivy/functional/ivy/nest.py | 24 +- ivy/stateful/helpers.py | 14 +- ivy/stateful/module.py | 20 +- ivy/utils/backend/handler.py | 6 +- ivy/utils/binaries.py | 10 +- ivy/utils/exceptions.py | 6 +- .../test_jax/test__src/test_tree_util.py | 18 +- .../test_jax/test_lax/test_operators.py | 28 +- .../test_jax/test_numpy/test_indexing.py | 6 +- .../test_jax/test_numpy/test_linalg.py | 6 +- .../test_jax/test_numpy/test_manipulations.py | 52 +- .../test_jax/test_numpy/test_statistical.py | 24 +- .../test_function/test_mindspore_nn_func.py | 20 +- .../test_numpy/test_func_wrapper.py | 28 +- .../test_matrix_and_vector_products.py | 24 +- ...olving_equations_and_inverting_matrices.py | 6 +- .../test_padding_arrays.py | 26 +- .../test_nn/test_functional/test_common.py | 30 +- .../test_tensorflow/test_func_wrapper.py | 32 +- .../test_tensorflow/test_general_functions.py | 24 +- .../test_functional/test_vision_functions.py | 14 +- .../test_core/test_creation.py | 14 +- .../test_functional/test_core/test_general.py | 54 +- .../test_functional/test_core/test_meta.py | 382 ++--- .../test_core/test_gradients.py | 24 +- .../test_core/test_manipulation.py | 28 +- .../test_experimental/test_nn/test_layers.py | 30 +- ivy_tests/test_ivy/test_misc/test_array.py | 6 +- .../test_backend_handler.py | 10 +- .../test_ivy/test_misc/test_container.py | 1430 ++++++++--------- .../test_tucker_tensor.py | 6 +- .../test_misc/test_handle_exceptions.py | 20 +- .../test_ivy/test_stateful/test_layers.py | 80 +- .../test_ivy/test_stateful/test_modules.py | 186 +-- scripts/backend_generation/generate.py | 6 +- scripts/backend_generation/tree_generation.py | 20 +- scripts/determine_tests/determine_tests.py | 12 +- 72 files changed, 1664 insertions(+), 2088 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c58337243a79e..470cad8c679d6 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: - id: check-toml - id: end-of-file-fixer - repo: https://github.com/psf/black-pre-commit-mirror - rev: 23.10.1 + rev: 23.11.0 hooks: - id: black language_version: python3 diff --git a/ivy/__init__.py b/ivy/__init__.py index 1faf53a31acdf..7f24a893c3d60 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -918,48 +918,44 @@ def __deepcopy__(self, memo): # defines ivy.globals attribute -globals_vars = GlobalsDict( - { - "backend_stack": backend_stack, - "default_device_stack": device.default_device_stack, - "valid_dtypes": valid_dtypes, - "valid_numeric_dtypes": valid_numeric_dtypes, - "valid_int_dtypes": valid_int_dtypes, - "valid_uint_dtypes": valid_uint_dtypes, - "valid_complex_dtypes": valid_complex_dtypes, - "valid_devices": valid_devices, - "invalid_dtypes": invalid_dtypes, - "invalid_numeric_dtypes": invalid_numeric_dtypes, - "invalid_int_dtypes": invalid_int_dtypes, - "invalid_float_dtypes": invalid_float_dtypes, - "invalid_uint_dtypes": invalid_uint_dtypes, - "invalid_complex_dtypes": invalid_complex_dtypes, - "invalid_devices": invalid_devices, - "array_significant_figures_stack": array_significant_figures_stack, - "array_decimal_values_stack": array_decimal_values_stack, - "warning_level_stack": warning_level_stack, - "queue_timeout_stack": general.queue_timeout_stack, - "array_mode_stack": general.array_mode_stack, - "inplace_mode_stack": general.inplace_mode_stack, - "soft_device_mode_stack": device.soft_device_mode_stack, - "shape_array_mode_stack": general.shape_array_mode_stack, - "show_func_wrapper_trace_mode_stack": ( - general.show_func_wrapper_trace_mode_stack - ), - "min_denominator_stack": general.min_denominator_stack, - "min_base_stack": general.min_base_stack, - "tmp_dir_stack": general.tmp_dir_stack, - "precise_mode_stack": general.precise_mode_stack, - "nestable_mode_stack": general.nestable_mode_stack, - "exception_trace_mode_stack": general.exception_trace_mode_stack, - "default_dtype_stack": data_type.default_dtype_stack, - "default_float_dtype_stack": data_type.default_float_dtype_stack, - "default_int_dtype_stack": data_type.default_int_dtype_stack, - "default_uint_dtype_stack": data_type.default_uint_dtype_stack, - "nan_policy_stack": nan_policy_stack, - "dynamic_backend_stack": dynamic_backend_stack, - } -) +globals_vars = GlobalsDict({ + "backend_stack": backend_stack, + "default_device_stack": device.default_device_stack, + "valid_dtypes": valid_dtypes, + "valid_numeric_dtypes": valid_numeric_dtypes, + "valid_int_dtypes": valid_int_dtypes, + "valid_uint_dtypes": valid_uint_dtypes, + "valid_complex_dtypes": valid_complex_dtypes, + "valid_devices": valid_devices, + "invalid_dtypes": invalid_dtypes, + "invalid_numeric_dtypes": invalid_numeric_dtypes, + "invalid_int_dtypes": invalid_int_dtypes, + "invalid_float_dtypes": invalid_float_dtypes, + "invalid_uint_dtypes": invalid_uint_dtypes, + "invalid_complex_dtypes": invalid_complex_dtypes, + "invalid_devices": invalid_devices, + "array_significant_figures_stack": array_significant_figures_stack, + "array_decimal_values_stack": array_decimal_values_stack, + "warning_level_stack": warning_level_stack, + "queue_timeout_stack": general.queue_timeout_stack, + "array_mode_stack": general.array_mode_stack, + "inplace_mode_stack": general.inplace_mode_stack, + "soft_device_mode_stack": device.soft_device_mode_stack, + "shape_array_mode_stack": general.shape_array_mode_stack, + "show_func_wrapper_trace_mode_stack": general.show_func_wrapper_trace_mode_stack, + "min_denominator_stack": general.min_denominator_stack, + "min_base_stack": general.min_base_stack, + "tmp_dir_stack": general.tmp_dir_stack, + "precise_mode_stack": general.precise_mode_stack, + "nestable_mode_stack": general.nestable_mode_stack, + "exception_trace_mode_stack": general.exception_trace_mode_stack, + "default_dtype_stack": data_type.default_dtype_stack, + "default_float_dtype_stack": data_type.default_float_dtype_stack, + "default_int_dtype_stack": data_type.default_int_dtype_stack, + "default_uint_dtype_stack": data_type.default_uint_dtype_stack, + "nan_policy_stack": nan_policy_stack, + "dynamic_backend_stack": dynamic_backend_stack, +}) _default_globals = copy.deepcopy(globals_vars) diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index 26f4623eceaca..b2bc127c40863 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -1388,17 +1388,15 @@ def cont_flatten_key_chain( if below_depth and num_keys > below_depth: pre_keys = flat_keys[0:below_depth] del flat_keys[0:below_depth] - return "/".join( - [ - k - for k in [ - "/".join(pre_keys), - replacement.join(flat_keys), - "/".join(post_keys), - ] - if k + return "/".join([ + k + for k in [ + "/".join(pre_keys), + replacement.join(flat_keys), + "/".join(post_keys), ] - ) + if k + ]) @staticmethod def cont_trim_key(key, max_length): @@ -1512,9 +1510,9 @@ def _cont_get_shape(self): if not sub_shapes: return sub_shapes min_num_dims = min(len(sub_shape) for sub_shape in sub_shapes) - sub_shapes_array = np.asarray( - [sub_shape[0:min_num_dims] for sub_shape in sub_shapes] - ) + sub_shapes_array = np.asarray([ + sub_shape[0:min_num_dims] for sub_shape in sub_shapes + ]) sub_shapes_array = np.where(sub_shapes_array == 0, -1, sub_shapes_array) mask = np.prod(sub_shapes_array / sub_shapes_array[0:1], 0) == 1 # noinspection PyTypeChecker @@ -1722,18 +1720,16 @@ def cont_all_true( Boolean, whether all entries are boolean True. """ return bool( - np.prod( - [ - v - for k, v in self.cont_as_bools( - assert_is_bool, - key_chains, - to_apply, - prune_unapplied, - map_sequences, - ).cont_to_iterator() - ] - ) + np.prod([ + v + for k, v in self.cont_as_bools( + assert_is_bool, + key_chains, + to_apply, + prune_unapplied, + map_sequences, + ).cont_to_iterator() + ]) ) def cont_all_false( @@ -1769,18 +1765,16 @@ def cont_all_false( Boolean, whether all entries are boolean False. """ return not bool( - np.sum( - [ - v - for k, v in self.cont_as_bools( - assert_is_bool, - key_chains, - to_apply, - prune_unapplied, - map_sequences, - ).cont_to_iterator() - ] - ) + np.sum([ + v + for k, v in self.cont_as_bools( + assert_is_bool, + key_chains, + to_apply, + prune_unapplied, + map_sequences, + ).cont_to_iterator() + ]) ) def cont_slice_via_key(self, slice_key): @@ -3736,9 +3730,9 @@ def cont_show_sub_container(self, sub_cont_or_keychain): # prepend these lines to the sub-container sub_repr = ( "\n" - + "\n".join( - [" " * num_spaces_to_add + s for s in sub_repr[1:-1].split("\n")] - ) + + "\n".join([ + " " * num_spaces_to_add + s for s in sub_repr[1:-1].split("\n") + ]) + "\n" ) @@ -3773,12 +3767,10 @@ def _pre_pad_alpha_line(str_in): padded = True return "\\n" + indent_str + indented_key_str + str_in - leading_str_to_keep = ", ".join( - [ - _pre_pad_alpha_line(s) if s[0].isalpha() and i != 0 else s - for i, s in enumerate(leading_str_to_keep.split(", ")) - ] - ) + leading_str_to_keep = ", ".join([ + _pre_pad_alpha_line(s) if s[0].isalpha() and i != 0 else s + for i, s in enumerate(leading_str_to_keep.split(", ")) + ]) local_indent_str = "" if padded else indent_str leading_str = leading_str_to_keep.split("\\n")[-1].replace('"', "") remaining_str = array_str_in_split[1] @@ -3795,32 +3787,30 @@ def _pre_pad_alpha_line(str_in): uniform_indent_wo_overflow_list = list( filter(None, uniform_indent_wo_overflow.split("\\n")) ) - uniform_indent = "\n".join( - [ - ( - local_indent_str + extra_indent + " " + s - if ( - s[0].isnumeric() - or s[0] == "-" - or s[0:3] == "..." - or max(ss in s[0:6] for ss in ["nan, ", "inf, "]) - ) - else ( - indent_str + indented_key_str + s - if (not s[0].isspace() and s[0] != '"') - else s - ) + uniform_indent = "\n".join([ + ( + local_indent_str + extra_indent + " " + s + if ( + s[0].isnumeric() + or s[0] == "-" + or s[0:3] == "..." + or max(ss in s[0:6] for ss in ["nan, ", "inf, "]) ) - for s in uniform_indent_wo_overflow_list - ] - ) + else ( + indent_str + indented_key_str + s + if (not s[0].isspace() and s[0] != '"') + else s + ) + ) + for s in uniform_indent_wo_overflow_list + ]) indented = uniform_indent # 10 dimensions is a sensible upper bound for the number in a single array for i in range(2, 10): indented = indented.replace(" " * (i - 1) + "[" * i, "[" * i) - indented = "\n".join( - [s for s in indented.split("\n") if bool(s) and not s.isspace()] - ) + indented = "\n".join([ + s for s in indented.split("\n") if bool(s) and not s.isspace() + ]) return indented def _align_arrays(str_in): @@ -3919,32 +3909,27 @@ def _align_arrays(str_in): def _add_newline(str_in): str_in_split = str_in.split("\n") str_split_size = len(str_in_split) - return "\n".join( - [ - ( - ("\n" * self._print_line_spacing + ss) - if i == (str_split_size - 1) - else ss - ) - for i, ss in enumerate(str_in_split) - ] - ) + return "\n".join([ + ( + ("\n" * self._print_line_spacing + ss) + if i == (str_split_size - 1) + else ss + ) + for i, ss in enumerate(str_in_split) + ]) - json_dumped_str = '":'.join( - [_add_newline(s) for s in json_dumped_str.split('":')] - ) + json_dumped_str = '":'.join([ + _add_newline(s) for s in json_dumped_str.split('":') + ]) # improve tf formatting if ivy.backend_stack and ivy.current_backend_str() == "tensorflow": json_dumped_str_split = json_dumped_str.split("'Variable:") json_dumped_str = ( json_dumped_str_split[0] + ", " - + ", ".join( - [ - "'".join(ss.split("'")[1:]) - for ss in json_dumped_str_split[1:] - ] - ) + + ", ".join([ + "'".join(ss.split("'")[1:]) for ss in json_dumped_str_split[1:] + ]) ) json_dumped_str = ( json_dumped_str.replace(":shape", ", shape") @@ -3955,26 +3940,24 @@ def _add_newline(str_in): # color keys json_dumped_str_split = json_dumped_str.split('":') split_size = len(json_dumped_str_split) - json_dumped_str = '":'.join( - [ - ( - ' "'.join( - sub_str.split(' "')[:-1] - + [ - termcolor.colored( - ivy.Container.cont_trim_key( - sub_str.split(' "')[-1], self._key_length_limit - ), - self._default_key_color, - ) - ] - ) - if i < split_size - 1 - else sub_str + json_dumped_str = '":'.join([ + ( + ' "'.join( + sub_str.split(' "')[:-1] + + [ + termcolor.colored( + ivy.Container.cont_trim_key( + sub_str.split(' "')[-1], self._key_length_limit + ), + self._default_key_color, + ) + ] ) - for i, sub_str in enumerate(json_dumped_str_split) - ] - ) + if i < split_size - 1 + else sub_str + ) + for i, sub_str in enumerate(json_dumped_str_split) + ]) # remove quotation marks, shape tuple, and color other elements of the dict ret = ( json_dumped_str.replace('"', "") diff --git a/ivy/data_classes/container/container.py b/ivy/data_classes/container/container.py index 2c16ee729687a..b41def052fd73 100644 --- a/ivy/data_classes/container/container.py +++ b/ivy/data_classes/container/container.py @@ -435,18 +435,18 @@ def __imod__(self, other): def __divmod__(self, other): return ivy.Container.cont_multi_map( - lambda xs, _: tuple( - [operator.truediv(xs[0], xs[1]), operator.mod(xs[0], xs[1])] - ), + lambda xs, _: tuple([ + operator.truediv(xs[0], xs[1]), operator.mod(xs[0], xs[1]) + ]), [self, other], map_nests=True, ) def __rdivmod__(self, other): return ivy.Container.cont_multi_map( - lambda xs, _: tuple( - [operator.truediv(xs[0], xs[1]), operator.mod(xs[0], xs[1])] - ), + lambda xs, _: tuple([ + operator.truediv(xs[0], xs[1]), operator.mod(xs[0], xs[1]) + ]), [other, self], map_nests=True, ) diff --git a/ivy/data_classes/factorized_tensor/tucker_tensor.py b/ivy/data_classes/factorized_tensor/tucker_tensor.py index 5984be2efe365..0e329f6b54a53 100644 --- a/ivy/data_classes/factorized_tensor/tucker_tensor.py +++ b/ivy/data_classes/factorized_tensor/tucker_tensor.py @@ -288,9 +288,9 @@ def validate_tucker_rank( # number of parameters coming from the fixed modes # (these don't have a variable size as a fun of fraction_param) - n_fixed_params = ivy.sum( - [s**2 for _, s in fixed_modes] - ) # size of the factors + n_fixed_params = ivy.sum([ + s**2 for _, s in fixed_modes + ]) # size of the factors n_modes_compressed -= len(fixed_modes) else: n_fixed_params = 0 diff --git a/ivy/data_classes/nested_array/base.py b/ivy/data_classes/nested_array/base.py index 188f1c731cfa2..2534a9412706e 100644 --- a/ivy/data_classes/nested_array/base.py +++ b/ivy/data_classes/nested_array/base.py @@ -139,9 +139,9 @@ def ragged_multi_map(fn, ragged_arrays): args.append(ivy.copy_nest(ragged.data)) ret = ivy.nested_multi_map(lambda x, _: fn(x), args) # infer dtype, shape, and device from the first array in the ret data - broadcasted_shape = ivy.NestedArray.broadcast_shapes( - [arg.shape for arg in ragged_arrays] - ) + broadcasted_shape = ivy.NestedArray.broadcast_shapes([ + arg.shape for arg in ragged_arrays + ]) # infer ragged_rank from broadcasted shape for i, dim in enumerate(broadcasted_shape[::-1]): if dim is None: diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index c831c9aae4add..cbd7c6c2a0702 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -1694,16 +1694,14 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func( - [ - item, - ( - _dtype_device_wrapper_creator( - "unsupported_dtypes", tuple - )(*self.args, **self.kwargs) - )(globals_getter_func()[item]), - ] - ) + globals_getter_func([ + item, + ( + _dtype_device_wrapper_creator("unsupported_dtypes", tuple)( + *self.args, **self.kwargs + ) + )(globals_getter_func()[item]), + ]) class with_supported_dtypes(contextlib.ContextDecorator): @@ -1730,16 +1728,14 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func( - [ - item, - ( - _dtype_device_wrapper_creator( - "supported_dtypes", tuple - )(*self.args, **self.kwargs) - )(globals_getter_func()[item]), - ] - ) + globals_getter_func([ + item, + ( + _dtype_device_wrapper_creator("supported_dtypes", tuple)( + *self.args, **self.kwargs + ) + )(globals_getter_func()[item]), + ]) class with_unsupported_devices(contextlib.ContextDecorator): @@ -1766,16 +1762,14 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func( - [ - item, - ( - _dtype_device_wrapper_creator( - "unsupported_devices", tuple - )(*self.args, **self.kwargs) - )(globals_getter_func()[item]), - ] - ) + globals_getter_func([ + item, + ( + _dtype_device_wrapper_creator("unsupported_devices", tuple)( + *self.args, **self.kwargs + ) + )(globals_getter_func()[item]), + ]) class with_supported_devices(contextlib.ContextDecorator): @@ -1802,16 +1796,14 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func( - [ - item, - ( - _dtype_device_wrapper_creator( - "supported_devices", tuple - )(*self.args, **self.kwargs) - )(globals_getter_func()[item]), - ] - ) + globals_getter_func([ + item, + ( + _dtype_device_wrapper_creator("supported_devices", tuple)( + *self.args, **self.kwargs + ) + )(globals_getter_func()[item]), + ]) class with_unsupported_device_and_dtypes(contextlib.ContextDecorator): @@ -1860,16 +1852,14 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func( - [ - item, - ( - _dtype_device_wrapper_creator( - "unsupported_device_and_dtype", tuple - )(*self.args, **self.kwargs) - )(globals_getter_func()[item]), - ] - ) + globals_getter_func([ + item, + ( + _dtype_device_wrapper_creator( + "unsupported_device_and_dtype", tuple + )(*self.args, **self.kwargs) + )(globals_getter_func()[item]), + ]) class with_supported_device_and_dtypes(contextlib.ContextDecorator): @@ -1918,16 +1908,14 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func( - [ - item, - ( - _dtype_device_wrapper_creator( - "supported_device_and_dtype", tuple - )(*self.args, **self.kwargs) - )(globals_getter_func()[item]), - ] - ) + globals_getter_func([ + item, + ( + _dtype_device_wrapper_creator( + "supported_device_and_dtype", tuple + )(*self.args, **self.kwargs) + )(globals_getter_func()[item]), + ]) class override(contextlib.ContextDecorator): diff --git a/ivy/functional/backends/numpy/experimental/elementwise.py b/ivy/functional/backends/numpy/experimental/elementwise.py index ca0ecc4bad310..d5ae82d500a7e 100644 --- a/ivy/functional/backends/numpy/experimental/elementwise.py +++ b/ivy/functional/backends/numpy/experimental/elementwise.py @@ -338,18 +338,16 @@ def modf( # ---digamma---# kLanczosGamma = 7 # aka g kBaseLanczosCoeff = 0.99999999999980993227684700473478 -kLanczosCoefficients = np.array( - [ - 676.520368121885098567009190444019, - -1259.13921672240287047156078755283, - 771.3234287776530788486528258894, - -176.61502916214059906584551354, - 12.507343278686904814458936853, - -0.13857109526572011689554707, - 9.984369578019570859563e-6, - 1.50563273514931155834e-7, - ] -) +kLanczosCoefficients = np.array([ + 676.520368121885098567009190444019, + -1259.13921672240287047156078755283, + 771.3234287776530788486528258894, + -176.61502916214059906584551354, + 12.507343278686904814458936853, + -0.13857109526572011689554707, + 9.984369578019570859563e-6, + 1.50563273514931155834e-7, +]) def digamma( @@ -399,40 +397,36 @@ def digamma( # --- LGAMMA --- # LANCZOS_N = 13 lanczos_g = 6.024680040776729583740234375 -lanczos_num_coeffs = np.array( - [ - 23531376880.410759688572007674451636754734846804940, - 42919803642.649098768957899047001988850926355848959, - 35711959237.355668049440185451547166705960488635843, - 17921034426.037209699919755754458931112671403265390, - 6039542586.3520280050642916443072979210699388420708, - 1439720407.3117216736632230727949123939715485786772, - 248874557.86205415651146038641322942321632125127801, - 31426415.585400194380614231628318205362874684987640, - 2876370.6289353724412254090516208496135991145378768, - 186056.26539522349504029498971604569928220784236328, - 8071.6720023658162106380029022722506138218516325024, - 210.82427775157934587250973392071336271166969580291, - 2.5066282746310002701649081771338373386264310793408, - ] -) -lanczos_den_coeffs = np.array( - [ - 0.0, - 39916800.0, - 120543840.0, - 150917976.0, - 105258076.0, - 45995730.0, - 13339535.0, - 2637558.0, - 357423.0, - 32670.0, - 1925.0, - 66.0, - 1.0, - ] -) +lanczos_num_coeffs = np.array([ + 23531376880.410759688572007674451636754734846804940, + 42919803642.649098768957899047001988850926355848959, + 35711959237.355668049440185451547166705960488635843, + 17921034426.037209699919755754458931112671403265390, + 6039542586.3520280050642916443072979210699388420708, + 1439720407.3117216736632230727949123939715485786772, + 248874557.86205415651146038641322942321632125127801, + 31426415.585400194380614231628318205362874684987640, + 2876370.6289353724412254090516208496135991145378768, + 186056.26539522349504029498971604569928220784236328, + 8071.6720023658162106380029022722506138218516325024, + 210.82427775157934587250973392071336271166969580291, + 2.5066282746310002701649081771338373386264310793408, +]) +lanczos_den_coeffs = np.array([ + 0.0, + 39916800.0, + 120543840.0, + 150917976.0, + 105258076.0, + 45995730.0, + 13339535.0, + 2637558.0, + 357423.0, + 32670.0, + 1925.0, + 66.0, + 1.0, +]) def sinpi(x): @@ -517,53 +511,45 @@ def func(x): # --- erfc --- # # Polynomials for computing erf/erfc. Originally from cephes library. # https://netlib.org/cephes/doubldoc.html -kErfcPCoefficient = np.array( - [ - 2.46196981473530512524e-10, - 5.64189564831068821977e-1, - 7.46321056442269912687e0, - 4.86371970985681366614e1, - 1.96520832956077098242e2, - 5.26445194995477358631e2, - 9.34528527171957607540e2, - 1.02755188689515710272e3, - 5.57535335369399327526e2, - ] -) -kErfcQCoefficient = np.array( - [ - 1.00000000000000000000e0, - 1.32281951154744992508e1, - 8.67072140885989742329e1, - 3.54937778887819891062e2, - 9.75708501743205489753e2, - 1.82390916687909736289e3, - 2.24633760818710981792e3, - 1.65666309194161350182e3, - 5.57535340817727675546e2, - ] -) -kErfcRCoefficient = np.array( - [ - 5.64189583547755073984e-1, - 1.27536670759978104416e0, - 5.01905042251180477414e0, - 6.16021097993053585195e0, - 7.40974269950448939160e0, - 2.97886665372100240670e0, - ] -) -kErfcSCoefficient = np.array( - [ - 1.00000000000000000000e0, - 2.26052863220117276590e0, - 9.39603524938001434673e0, - 1.20489539808096656605e1, - 1.70814450747565897222e1, - 9.60896809063285878198e0, - 3.36907645100081516050e0, - ] -) +kErfcPCoefficient = np.array([ + 2.46196981473530512524e-10, + 5.64189564831068821977e-1, + 7.46321056442269912687e0, + 4.86371970985681366614e1, + 1.96520832956077098242e2, + 5.26445194995477358631e2, + 9.34528527171957607540e2, + 1.02755188689515710272e3, + 5.57535335369399327526e2, +]) +kErfcQCoefficient = np.array([ + 1.00000000000000000000e0, + 1.32281951154744992508e1, + 8.67072140885989742329e1, + 3.54937778887819891062e2, + 9.75708501743205489753e2, + 1.82390916687909736289e3, + 2.24633760818710981792e3, + 1.65666309194161350182e3, + 5.57535340817727675546e2, +]) +kErfcRCoefficient = np.array([ + 5.64189583547755073984e-1, + 1.27536670759978104416e0, + 5.01905042251180477414e0, + 6.16021097993053585195e0, + 7.40974269950448939160e0, + 2.97886665372100240670e0, +]) +kErfcSCoefficient = np.array([ + 1.00000000000000000000e0, + 2.26052863220117276590e0, + 9.39603524938001434673e0, + 1.20489539808096656605e1, + 1.70814450747565897222e1, + 9.60896809063285878198e0, + 3.36907645100081516050e0, +]) # Evaluate the polynomial given coefficients and `x`. diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index eb49701742a33..e73890115fa69 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -697,53 +697,45 @@ def digamma( # --- erfc --- # # Polynomials for computing erf/erfc. Originally from cephes library. # https://netlib.org/cephes/doubldoc.html -kErfcPCoefficient = paddle.to_tensor( - [ - 2.46196981473530512524e-10, - 5.64189564831068821977e-1, - 7.46321056442269912687e0, - 4.86371970985681366614e1, - 1.96520832956077098242e2, - 5.26445194995477358631e2, - 9.34528527171957607540e2, - 1.02755188689515710272e3, - 5.57535335369399327526e2, - ] -) -kErfcQCoefficient = paddle.to_tensor( - [ - 1.00000000000000000000e0, - 1.32281951154744992508e1, - 8.67072140885989742329e1, - 3.54937778887819891062e2, - 9.75708501743205489753e2, - 1.82390916687909736289e3, - 2.24633760818710981792e3, - 1.65666309194161350182e3, - 5.57535340817727675546e2, - ] -) -kErfcRCoefficient = paddle.to_tensor( - [ - 5.64189583547755073984e-1, - 1.27536670759978104416e0, - 5.01905042251180477414e0, - 6.16021097993053585195e0, - 7.40974269950448939160e0, - 2.97886665372100240670e0, - ] -) -kErfcSCoefficient = paddle.to_tensor( - [ - 1.00000000000000000000e0, - 2.26052863220117276590e0, - 9.39603524938001434673e0, - 1.20489539808096656605e1, - 1.70814450747565897222e1, - 9.60896809063285878198e0, - 3.36907645100081516050e0, - ] -) +kErfcPCoefficient = paddle.to_tensor([ + 2.46196981473530512524e-10, + 5.64189564831068821977e-1, + 7.46321056442269912687e0, + 4.86371970985681366614e1, + 1.96520832956077098242e2, + 5.26445194995477358631e2, + 9.34528527171957607540e2, + 1.02755188689515710272e3, + 5.57535335369399327526e2, +]) +kErfcQCoefficient = paddle.to_tensor([ + 1.00000000000000000000e0, + 1.32281951154744992508e1, + 8.67072140885989742329e1, + 3.54937778887819891062e2, + 9.75708501743205489753e2, + 1.82390916687909736289e3, + 2.24633760818710981792e3, + 1.65666309194161350182e3, + 5.57535340817727675546e2, +]) +kErfcRCoefficient = paddle.to_tensor([ + 5.64189583547755073984e-1, + 1.27536670759978104416e0, + 5.01905042251180477414e0, + 6.16021097993053585195e0, + 7.40974269950448939160e0, + 2.97886665372100240670e0, +]) +kErfcSCoefficient = paddle.to_tensor([ + 1.00000000000000000000e0, + 2.26052863220117276590e0, + 9.39603524938001434673e0, + 1.20489539808096656605e1, + 1.70814450747565897222e1, + 9.60896809063285878198e0, + 3.36907645100081516050e0, +]) # Evaluate the polynomial given coefficients and `x`. diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 467d5ffd156f9..024b9110c2603 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -69,13 +69,11 @@ def _squeeze_helper(query, x_ndim): ) if any(slice_squeeze): - squeeze_indices = tuple( - [ - idx - for idx, val in enumerate(slice_squeeze) - if (val is False and query[idx] is not None) - ] - ) + squeeze_indices = tuple([ + idx + for idx, val in enumerate(slice_squeeze) + if (val is False and query[idx] is not None) + ]) elif return_scalar: squeeze_indices = () else: diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index 33016d51a5346..349b8218996ad 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -115,12 +115,10 @@ def execute_with_gradients( xs = xs1 if isinstance(xs, ivy.Container): duplicate_indices = list( - chain.from_iterable( - [ - map(lambda x: x.split("/"), duplicate_index_chain[1:]) - for duplicate_index_chain in required_duplicate_index_chains - ] - ) + chain.from_iterable([ + map(lambda x: x.split("/"), duplicate_index_chain[1:]) + for duplicate_index_chain in required_duplicate_index_chains + ]) ) xs = ivy.set_nest_at_indices(xs, duplicate_indices, None, shallow=False) diff --git a/ivy/functional/backends/paddle/set.py b/ivy/functional/backends/paddle/set.py index d0c47eb3242d7..aeedd6bae6d05 100644 --- a/ivy/functional/backends/paddle/set.py +++ b/ivy/functional/backends/paddle/set.py @@ -63,14 +63,12 @@ def unique_all( axis = 0 values_ = paddle.moveaxis(values, axis, 0) values_ = paddle.reshape(values_, (values_.shape[0], -1)) - sort_idx = paddle.to_tensor( - [ - i[0] - for i in sorted( - enumerate(values_.numpy().tolist()), key=lambda x: tuple(x[1]) - ) - ] - ) + sort_idx = paddle.to_tensor([ + i[0] + for i in sorted( + enumerate(values_.numpy().tolist()), key=lambda x: tuple(x[1]) + ) + ]) values = paddle.gather(values, sort_idx, axis=axis) counts = paddle.gather(counts, sort_idx) indices = paddle.gather(indices, sort_idx) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 99f387c5af6d2..1b2962f8fc158 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -1172,13 +1172,11 @@ def shape_initialization(shape, axes, x): def rank_initialization(axes): rank = tf.size(axes) - with tf.control_dependencies( - [ - tf.debugging.assert_less_equal( - rank, 3, message="N-D FFT supported only up to 3-D." - ) - ] - ): + with tf.control_dependencies([ + tf.debugging.assert_less_equal( + rank, 3, message="N-D FFT supported only up to 3-D." + ) + ]): rank = tf.identity(rank) return rank @@ -1270,9 +1268,9 @@ def static_output_shape(input_shape, shape, axes): def _right_pad_or_crop(tensor, shape): input_shape = tf.shape(tensor) shape = tf.convert_to_tensor(shape, dtype=tf.dtypes.int32) - with tf.control_dependencies( - [tf.debugging.assert_less_equal(tf.size(shape), tf.size(input_shape))] - ): + with tf.control_dependencies([ + tf.debugging.assert_less_equal(tf.size(shape), tf.size(input_shape)) + ]): shape = tf.identity(shape) shape = tf.concat([input_shape[: tf.size(input_shape) - tf.size(shape)], shape], 0) diff --git a/ivy/functional/backends/tensorflow/set.py b/ivy/functional/backends/tensorflow/set.py index 24379eb109d90..eb901c8a76631 100644 --- a/ivy/functional/backends/tensorflow/set.py +++ b/ivy/functional/backends/tensorflow/set.py @@ -37,9 +37,9 @@ def unique_all( if x.dtype.is_floating and tf.reduce_any(tf.math.is_nan(values)): unique_nan = tf.math.is_nan(values) nan_index = tf.reshape(tf.where(tf.math.is_nan(x)), [-1]) - non_nan_index = tf.experimental.numpy.array( - [tensor_list.index(val) for val in values if not tf.math.is_nan(val)] - ) + non_nan_index = tf.experimental.numpy.array([ + tensor_list.index(val) for val in values if not tf.math.is_nan(val) + ]) indices = tf.experimental.numpy.full( fill_value=float("NaN"), shape=values.shape ).numpy() @@ -58,9 +58,9 @@ def unique_all( if by_value: values_ = tf.experimental.numpy.moveaxis(values, axis, 0) values_ = tf.reshape(values_, (values_.shape[0], -1)) - sort_idx = tf.stack( - [i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1]))] - ) + sort_idx = tf.stack([ + i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1])) + ]) sort_idx = tf.cast(sort_idx, tf.int32) values = tf.gather(values, sort_idx, axis=axis) counts = tf.gather(counts, sort_idx) diff --git a/ivy/functional/backends/torch/experimental/gradients.py b/ivy/functional/backends/torch/experimental/gradients.py index b6c0a7cedf6e4..a959d5ab83e03 100644 --- a/ivy/functional/backends/torch/experimental/gradients.py +++ b/ivy/functional/backends/torch/experimental/gradients.py @@ -34,12 +34,10 @@ def backward(ctx, upstream): def vjp(func: Callable, *primals): flattened_primals, ret_idxs = _flatten_containers(primals) - unique_keys = list( - { - ivy.index_nest(ret_idxs, i) - for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) - } - ) + unique_keys = list({ + ivy.index_nest(ret_idxs, i) + for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) + }) def grad_fn(*x_in): ret, idxs = _flatten_containers( @@ -95,12 +93,10 @@ def vjpfun(*x_in): def jvp(func: Callable, primals, tangents): flattened_primals, ret_idxs = _flatten_containers(primals) flattened_tangents, _ = _flatten_containers(tangents) - unique_keys = list( - { - ivy.index_nest(ret_idxs, i) - for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) - } - ) + unique_keys = list({ + ivy.index_nest(ret_idxs, i) + for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) + }) def grad_fn(*x_in): ret, idxs = _flatten_containers( diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index d9757720b8e53..a89bd786aeae2 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -291,12 +291,10 @@ def _handle_axis(a, q, fn, keepdims=False, axis=None): for i, s in enumerate(sorted(keep)): a = torch.moveaxis(a, s, i) - a = a.view( - [ - *a.shape[:nkeep], - -1, - ] - ) + a = a.view([ + *a.shape[:nkeep], + -1, + ]) axis_arg = -1 ret = fn(a, q, axis=axis_arg) diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 41e1a3deb2b26..644b42f28bf7a 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -227,9 +227,9 @@ def gather_nd_helper(params, indices): indices_for_flat_tiled = torch.reshape( torch.sum(indices * indices_scales, -1, keepdim=True), (-1, 1) ).repeat(*[1, implicit_indices_factor]) - implicit_indices = torch.unsqueeze(torch.arange(implicit_indices_factor), 0).repeat( - *[indices_for_flat_tiled.shape[0], 1] - ) + implicit_indices = torch.unsqueeze( + torch.arange(implicit_indices_factor), 0 + ).repeat(*[indices_for_flat_tiled.shape[0], 1]) indices_for_flat = indices_for_flat_tiled + implicit_indices flat_indices_for_flat = torch.reshape(indices_for_flat, (-1,)).type(torch.long) flat_gather = torch.gather(flat_params, 0, flat_indices_for_flat) @@ -466,9 +466,9 @@ def scatter_nd( indices_for_flat_tiled = torch.reshape( torch.sum(indices * indices_scales, -1, keepdim=True), (-1, 1) ).repeat(*[1, implicit_indices_factor]) - implicit_indices = torch.unsqueeze(torch.arange(implicit_indices_factor), 0).repeat( - *[indices_for_flat_tiled.shape[0], 1] - ) + implicit_indices = torch.unsqueeze( + torch.arange(implicit_indices_factor), 0 + ).repeat(*[indices_for_flat_tiled.shape[0], 1]) indices_for_flat = indices_for_flat_tiled + implicit_indices flat_indices_for_flat = torch.reshape(indices_for_flat, (-1,)).type(torch.long) global torch_scatter diff --git a/ivy/functional/backends/torch/set.py b/ivy/functional/backends/torch/set.py index 7f50cc332157d..4ddad1d6bb073 100644 --- a/ivy/functional/backends/torch/set.py +++ b/ivy/functional/backends/torch/set.py @@ -62,9 +62,9 @@ def unique_all( else: values_ = torch.moveaxis(values, axis, 0) values_ = torch.reshape(values_, (values_.shape[0], -1)) - sort_idx = torch.tensor( - [i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1]))] - ) + sort_idx = torch.tensor([ + i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1])) + ]) ivy_torch = ivy.current_backend() values = ivy_torch.gather(values, sort_idx, axis=axis) counts = ivy_torch.gather(counts, sort_idx) diff --git a/ivy/functional/frontends/numpy/ma/MaskedArray.py b/ivy/functional/frontends/numpy/ma/MaskedArray.py index 34ad474a5b58a..2eaf48cae2916 100644 --- a/ivy/functional/frontends/numpy/ma/MaskedArray.py +++ b/ivy/functional/frontends/numpy/ma/MaskedArray.py @@ -177,12 +177,10 @@ def _array_in_str(self): return masked_print_options return str(self._data.to_list()) if ivy.any(self._mask): - return str( - [ - masked_print_options if mask else x - for x, mask in zip(self._data.to_list(), self._mask.to_list()) - ] - ) + return str([ + masked_print_options if mask else x + for x, mask in zip(self._data.to_list(), self._mask.to_list()) + ]) return str(self._data.to_list()) diff --git a/ivy/functional/frontends/numpy/mathematical_functions/arithmetic_operations.py b/ivy/functional/frontends/numpy/mathematical_functions/arithmetic_operations.py index ffe7dde3e21e2..759e76272ca9a 100644 --- a/ivy/functional/frontends/numpy/mathematical_functions/arithmetic_operations.py +++ b/ivy/functional/frontends/numpy/mathematical_functions/arithmetic_operations.py @@ -91,12 +91,10 @@ def _divmod( ret = ivy.where( where, ret, - ( - [ - ivy.default(out, ivy.zeros_like(ret[0])), - ivy.default(out, ivy.zeros_like(ret[1])), - ] - ), + ([ + ivy.default(out, ivy.zeros_like(ret[0])), + ivy.default(out, ivy.zeros_like(ret[1])), + ]), out=out, ) return ret diff --git a/ivy/functional/frontends/numpy/ufunc/methods.py b/ivy/functional/frontends/numpy/ufunc/methods.py index 5d35a7a8a2448..0a4a9c5bfb5c1 100644 --- a/ivy/functional/frontends/numpy/ufunc/methods.py +++ b/ivy/functional/frontends/numpy/ufunc/methods.py @@ -214,24 +214,20 @@ def __init__(self, name) -> None: @property def nargs(self): sig = inspect.signature(self.func) - return len( - [ - param - for param in sig.parameters.values() - if param.kind in [param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD] - ] - ) + return len([ + param + for param in sig.parameters.values() + if param.kind in [param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD] + ]) @property def nin(self): sig = inspect.signature(self.func) - return len( - [ - param - for param in sig.parameters.values() - if param.kind == param.POSITIONAL_ONLY - ] - ) + return len([ + param + for param in sig.parameters.values() + if param.kind == param.POSITIONAL_ONLY + ]) @property def nout(self): diff --git a/ivy/functional/frontends/paddle/nn/functional/vision.py b/ivy/functional/frontends/paddle/nn/functional/vision.py index cf0ad4893580a..5f25344dd0a34 100644 --- a/ivy/functional/frontends/paddle/nn/functional/vision.py +++ b/ivy/functional/frontends/paddle/nn/functional/vision.py @@ -18,9 +18,9 @@ def affine_grid(theta, out_shape, align_corners=True): base_grid[:, :, :, 0] = ivy.linspace(-1, 1, W) base_grid[:, :, :, 1] = ivy.expand_dims(ivy.linspace(-1, 1, H), axis=-1) height_values = ivy.expand_dims(ivy.linspace(-1, 1, H), axis=-1) - base_grid[:, :, :, 1] = ivy.array( - [[[height_values[i]] * W for i in range(H)]] - )[:, :, :, 0] + base_grid[:, :, :, 1] = ivy.array([ + [[height_values[i]] * W for i in range(H)] + ])[:, :, :, 0] base_grid[:, :, :, 2] = ivy.full((H, W), 1) grid = ivy.matmul(base_grid.view((N, H * W, 3)), theta.swapaxes(1, 2)) return grid.view((N, H, W, 2)) @@ -32,9 +32,9 @@ def affine_grid(theta, out_shape, align_corners=True): height_values = ivy.expand_dims( ivy.linspace(-1, 1, H) * (H - 1) / H, axis=-1 ) - base_grid[:, :, :, 1] = ivy.array( - [[[height_values[i]] * W for i in range(H)]] - )[:, :, :, 0] + base_grid[:, :, :, 1] = ivy.array([ + [[height_values[i]] * W for i in range(H)] + ])[:, :, :, 0] base_grid[:, :, :, 2] = ivy.full((H, W), 1) grid = ivy.matmul(base_grid.view((N, H * W, 3)), ivy.swapaxes(theta, 1, 2)) return grid.view((N, H, W, 2)) @@ -45,9 +45,9 @@ def affine_grid(theta, out_shape, align_corners=True): base_grid[:, :, :, :, 0] = ivy.linspace(-1, 1, W) base_grid[:, :, :, :, 1] = ivy.expand_dims(ivy.linspace(-1, 1, H), axis=-1) height_values = ivy.linspace(-1, 1, H) - base_grid[:, :, :, :, 1] = ivy.array( - [[[[height_values[i]] * W for i in range(H)]] * D] - ) + base_grid[:, :, :, :, 1] = ivy.array([ + [[[height_values[i]] * W for i in range(H)]] * D + ]) base_grid[:, :, :, :, 2] = ivy.expand_dims( ivy.expand_dims(ivy.linspace(-1, 1, D), axis=-1), axis=-1 ) @@ -58,17 +58,17 @@ def affine_grid(theta, out_shape, align_corners=True): ivy.linspace(-1, 1, H) * (H - 1) / H, axis=-1 ) height_values = ivy.linspace(-1, 1, H) * (H - 1) / H - base_grid[:, :, :, :, 1] = ivy.array( - [[[[height_values[i]] * W for i in range(H)]] * D] - ) + base_grid[:, :, :, :, 1] = ivy.array([ + [[[height_values[i]] * W for i in range(H)]] * D + ]) base_grid[:, :, :, :, 2] = ivy.expand_dims( ivy.expand_dims(ivy.linspace(-1, 1, D) * (D - 1) / D, axis=-1), axis=-1 ) width_values = ivy.linspace(-1, 1, D) * (D - 1) / D - base_grid[:, :, :, :, 2] = ivy.array( - [[ivy.array([[width_values[i]] * W] * H) for i in range(D)]] - ) + base_grid[:, :, :, :, 2] = ivy.array([ + [ivy.array([[width_values[i]] * W] * H) for i in range(D)] + ]) base_grid[:, :, :, :, 3] = ivy.full((D, H, W), 1) grid = ivy.matmul(base_grid.view((N, D * H * W, 4)), theta.swapaxes(1, 2)) return grid.view((N, D, H, W, 3)) diff --git a/ivy/functional/frontends/sklearn/model_selection/_split.py b/ivy/functional/frontends/sklearn/model_selection/_split.py index 58f68bcc63bf6..406ae7c7d22a2 100644 --- a/ivy/functional/frontends/sklearn/model_selection/_split.py +++ b/ivy/functional/frontends/sklearn/model_selection/_split.py @@ -83,12 +83,10 @@ def _iter_test_indices(self, X=None, y=None, groups=None): n_classes = len(y_idx) y_order = ivy.sort(y_encoded) - allocation = ivy.asarray( - [ - ivy.bincount(y_order[i :: self.n_splits], minlength=n_classes) - for i in range(self.n_splits) - ] - ) + allocation = ivy.asarray([ + ivy.bincount(y_order[i :: self.n_splits], minlength=n_classes) + for i in range(self.n_splits) + ]) test_folds = ivy.empty(len(y), dtype="int64") for k in range(n_classes): folds_for_class = ivy.arange(self.n_splits).repeat(allocation[:, k]) diff --git a/ivy/functional/frontends/tensorflow/keras/metrics.py b/ivy/functional/frontends/tensorflow/keras/metrics.py index d32ef36cf1ebc..2c8402c8b8067 100644 --- a/ivy/functional/frontends/tensorflow/keras/metrics.py +++ b/ivy/functional/frontends/tensorflow/keras/metrics.py @@ -96,15 +96,10 @@ def _top_k(input, topk): labels = ivy.shape(predictions)[1] # float comparison? - return ivy.array( - [ - ( - 0 <= res < labels - and ivy.min(top_k[ind] - predictions[ind, res]) <= 1e-9 - ) - for ind, res in enumerate(targets) - ] - ) + return ivy.array([ + (0 <= res < labels and ivy.min(top_k[ind] - predictions[ind, res]) <= 1e-9) + for ind, res in enumerate(targets) + ]) reshape = False y_true = ivy.array(y_true) diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index 1334725919ca4..c9a799c46f34c 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -306,9 +306,9 @@ def depthwise_conv2d( dilations = 1 if dilations is None else dilations strides, dilations = _reduce_strides_dilations(2, strides, dilations) fc = filter.shape[-2] - filter = filter.reshape( - [*filter.shape[0:2], 1, filter.shape[-2] * filter.shape[-1]] - ) + filter = filter.reshape([ + *filter.shape[0:2], 1, filter.shape[-2] * filter.shape[-1] + ]) return ivy.conv_general_dilated( input, filter, diff --git a/ivy/functional/frontends/torch/nn/functional/distance_functions.py b/ivy/functional/frontends/torch/nn/functional/distance_functions.py index 92be14eeeb922..1059e6e4bb63a 100644 --- a/ivy/functional/frontends/torch/nn/functional/distance_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/distance_functions.py @@ -45,11 +45,9 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def pdist(input, p=2): - x = ivy.array( - [ - abs(input[i] - input[j]) - for i in range(len(input) - 1) - for j in range(i + 1, len(input)) - ] - ) + x = ivy.array([ + abs(input[i] - input[j]) + for i in range(len(input) - 1) + for j in range(i + 1, len(input)) + ]) return ivy.vector_norm(x, ord=p, axis=1) diff --git a/ivy/functional/frontends/torch/nn/functional/loss_functions.py b/ivy/functional/frontends/torch/nn/functional/loss_functions.py index a274d5c5e2434..06e8709bc5ab6 100644 --- a/ivy/functional/frontends/torch/nn/functional/loss_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/loss_functions.py @@ -166,12 +166,10 @@ def calculate_loss(x1, x2, target): if target.ndim == 0: loss = calculate_loss(input1, input2, target) else: - loss = ivy.array( - [ - calculate_loss(input1[i], input2[i], target[i]) - for i in range(input1.shape[0]) - ] - ) + loss = ivy.array([ + calculate_loss(input1[i], input2[i], target[i]) + for i in range(input1.shape[0]) + ]) reduction = _get_reduction(reduction, size_average, reduce) loss = reduction(loss) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index b9976f54fbac0..8d166210c3176 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -11,12 +11,10 @@ def _handle_padding_shape(padding, n, mode): - padding = tuple( - [ - (padding[i * 2], padding[i * 2 + 1]) - for i in range(int(len(padding) / 2) - 1, -1, -1) - ] - ) + padding = tuple([ + (padding[i * 2], padding[i * 2 + 1]) + for i in range(int(len(padding) / 2) - 1, -1, -1) + ]) if mode == "circular": padding = padding + ((0, 0),) * (n - len(padding)) else: diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index c0a43fd8475b0..dc7283f4ac3f4 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -109,12 +109,10 @@ def _create_variables(self, device=None, dtype=None): def _build(self, *args, **kwargs): self._native_params = ivy.Container( OrderedDict( - sorted( - [ - (k.replace(".", "/"), v) - for k, v in dict(self.named_parameters()).items() - ] - ) + sorted([ + (k.replace(".", "/"), v) + for k, v in dict(self.named_parameters()).items() + ]) ), dynamic_backend=False, ) diff --git a/ivy/functional/frontends/xgboost/core.py b/ivy/functional/frontends/xgboost/core.py index 8e8dbf9b557f4..793a3f2f02886 100644 --- a/ivy/functional/frontends/xgboost/core.py +++ b/ivy/functional/frontends/xgboost/core.py @@ -103,13 +103,11 @@ def __init__(self, params=None, cache=None, model_file=None, compile=False): ) # add num_feature, num_target and num_instances to params - params.update( - { - "num_feature": n_feat, - "num_output_group": n_output_group - 1, - "num_instances": n_inst, - } - ) + params.update({ + "num_feature": n_feat, + "num_output_group": n_output_group - 1, + "num_instances": n_inst, + }) # create gbm(as for now only gblinear booster is available) self.gbm = GBLinear(params, compile=compile, cache=cache) diff --git a/ivy/functional/frontends/xgboost/gbm/gbm.py b/ivy/functional/frontends/xgboost/gbm/gbm.py index 41271ea82cc56..8241acf4d29e1 100644 --- a/ivy/functional/frontends/xgboost/gbm/gbm.py +++ b/ivy/functional/frontends/xgboost/gbm/gbm.py @@ -163,12 +163,10 @@ def _get_gradient(obj, pred, label, scale_pos_weight): # group weights for positive class are scaled w_scaled = ivy.where(label == 1.0, w * scale_pos_weight, w) - return ivy.hstack( - [ - obj.first_order_gradient(p, label) * w_scaled, - obj.second_order_gradient(p, label) * w_scaled, - ] - ) + return ivy.hstack([ + obj.first_order_gradient(p, label) * w_scaled, + obj.second_order_gradient(p, label) * w_scaled, + ]) def _pred(dt, w, base): diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 987781d4d27d2..6cdf158f33056 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1918,18 +1918,14 @@ def interpolate( right = int(math.ceil(p_j + 2)) top = int(math.floor(p_i - 2)) bottom = int(math.ceil(p_i + 2)) - kernel_w = ivy.array( - [ - _mitchellcubic_kernel((p_j - j) * scale_w) - for i in range(left, right) - ] - ) - kernel_h = ivy.array( - [ - _mitchellcubic_kernel((p_i - i) * scale_h) - for j in range(top, bottom) - ] - ) + kernel_w = ivy.array([ + _mitchellcubic_kernel((p_j - j) * scale_w) + for i in range(left, right) + ]) + kernel_h = ivy.array([ + _mitchellcubic_kernel((p_i - i) * scale_h) + for j in range(top, bottom) + ]) left_pad = max(0, -left) right_pad = max(0, right - in_width) top_pad = max(0, -top) diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index 6eccd78b3af87..4aea8a58c4c3b 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -1695,13 +1695,13 @@ def tucker( return ivy.TuckerTensor((core, factors)) fixed_factors = sorted(fixed_factors) - modes_fixed, factors_fixed = zip( - *[(i, f) for (i, f) in enumerate(factors) if i in fixed_factors] - ) + modes_fixed, factors_fixed = zip(*[ + (i, f) for (i, f) in enumerate(factors) if i in fixed_factors + ]) core = multi_mode_dot(core, factors_fixed, modes=modes_fixed) - modes, factors = zip( - *[(i, f) for (i, f) in enumerate(factors) if i not in fixed_factors] - ) + modes, factors = zip(*[ + (i, f) for (i, f) in enumerate(factors) if i not in fixed_factors + ]) init = (core, list(factors)) rank = ivy.TuckerTensor.validate_tucker_rank(x.shape, rank=rank) diff --git a/ivy/functional/ivy/experimental/sparse_array.py b/ivy/functional/ivy/experimental/sparse_array.py index 4a82fb4f97ad9..623a38a918afa 100644 --- a/ivy/functional/ivy/experimental/sparse_array.py +++ b/ivy/functional/ivy/experimental/sparse_array.py @@ -766,12 +766,10 @@ def _bsr_to_dense_coordinates(self): for col in cols: for col_index in range(nblockcols): for row_index in range(nblockrows): - all_coordinates.append( - [ - nblockrows * row + row_index, - nblockcols * col + col_index, - ] - ) + all_coordinates.append([ + nblockrows * row + row_index, + nblockcols * col + col_index, + ]) return all_coordinates def _bsc_to_dense_coordinates(self): @@ -787,12 +785,10 @@ def _bsc_to_dense_coordinates(self): for row in rows: for col_index in range(nblockcols): for row_index in range(nblockrows): - all_coordinates.append( - [ - nblockrows * row + row_index, - nblockcols * col + col_index, - ] - ) + all_coordinates.append([ + nblockrows * row + row_index, + nblockcols * col + col_index, + ]) return all_coordinates def to_dense_array(self, *, native=False): diff --git a/ivy/functional/ivy/meta.py b/ivy/functional/ivy/meta.py index 771facb671158..7ba70923ae8e6 100644 --- a/ivy/functional/ivy/meta.py +++ b/ivy/functional/ivy/meta.py @@ -89,12 +89,10 @@ def cost_fn_with_variable(v): else variables.cont_prune_key_chains(outer_v, ignore_none=True) ) - inner_grads = ivy.Container( - { - k: ivy.zeros_like(v) if k not in inner_grads else inner_grads[k] - for k, v in var.cont_to_iterator() - } - ) + inner_grads = ivy.Container({ + k: ivy.zeros_like(v) if k not in inner_grads else inner_grads[k] + for k, v in var.cont_to_iterator() + }) if batched: inner_grads = ivy.multiply(inner_grads, num_tasks) @@ -154,16 +152,14 @@ def _train_task( if keep_innver_v else variables.cont_prune_key_chains(inner_v, ignore_none=True) ) - inner_update_grads = ivy.Container( - { - k: ( - ivy.zeros_like(v) - if k not in inner_update_grads - else inner_update_grads[k] - ) - for k, v in var.cont_to_iterator() - } - ) + inner_update_grads = ivy.Container({ + k: ( + ivy.zeros_like(v) + if k not in inner_update_grads + else inner_update_grads[k] + ) + for k, v in var.cont_to_iterator() + }) if batched: inner_update_grads = ivy.multiply(inner_update_grads, num_tasks) diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index cfe5a0a7f537b..9ed54e924b8f1 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -1356,16 +1356,14 @@ def copy_nest( return class_instance(**dict(zip(nest._fields, ret_list))) return class_instance(tuple(ret_list)) elif check_fn(nest, list): - return class_instance( - [ - copy_nest( - i, - include_derived=include_derived, - to_mutable=to_mutable, - ) - for i in nest - ] - ) + return class_instance([ + copy_nest( + i, + include_derived=include_derived, + to_mutable=to_mutable, + ) + for i in nest + ]) elif check_fn(nest, dict): class_instance = type(nest) dict_ = { @@ -1481,9 +1479,9 @@ def nested_multi_map( ( return_nest.append(ret) if isinstance(return_nest, (list)) - else return_nest.update( - {val if is_dict else list(nest)[index]: ret} - ) + else return_nest.update({ + val if is_dict else list(nest)[index]: ret + }) ) else: values = nests diff --git a/ivy/stateful/helpers.py b/ivy/stateful/helpers.py index b51489772bf0b..7d94f5e0f229f 100644 --- a/ivy/stateful/helpers.py +++ b/ivy/stateful/helpers.py @@ -268,14 +268,12 @@ def sub_mods(self, /, *, show_v=True, depth=None, flatten_key_chains=False): next_depth = depth - 1 else: next_depth = None - ret = ivy.Container( - { - ivy.Container.cont_flatten_key_chain( - sm.__repr__(), replacement="_" - ): sm.sub_mods(show_v=show_v, depth=next_depth) - for sm in self._sub_mods - } - ) + ret = ivy.Container({ + ivy.Container.cont_flatten_key_chain( + sm.__repr__(), replacement="_" + ): sm.sub_mods(show_v=show_v, depth=next_depth) + for sm in self._sub_mods + }) if flatten_key_chains: return ret.cont_flatten_key_chains() return ret diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 68f1c425b7658..6758859cef555 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -1185,12 +1185,10 @@ def _create_variables(self, device=None, dtype=None): def _build(self, *args, **kwargs): self._native_params = ivy.Container( OrderedDict( - sorted( - [ - (k.replace(".", "/"), v) - for k, v in dict(self._native_module.named_parameters()).items() - ] - ) + sorted([ + (k.replace(".", "/"), v) + for k, v in dict(self._native_module.named_parameters()).items() + ]) ), dynamic_backend=False, ) @@ -1218,12 +1216,10 @@ def _create_variables(self, device=None, dtype=None): def _build(self, *args, **kwargs): self._native_params = ivy.Container( OrderedDict( - sorted( - [ - (k.replace(".", "/"), v) - for k, v in dict(self._native_module.named_parameters()).items() - ] - ) + sorted([ + (k.replace(".", "/"), v) + for k, v in dict(self._native_module.named_parameters()).items() + ]) ), dynamic_backend=False, ) diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 5a58a649c19fe..2012d8ed9ec03 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -535,9 +535,9 @@ def choose_random_backend(excluded=None): or not installed.""", as_array=False, ) - f = np.random.choice( - [f_srt for f_srt in list(_backend_dict.keys()) if f_srt not in excluded] - ) + f = np.random.choice([ + f_srt for f_srt in list(_backend_dict.keys()) if f_srt not in excluded + ]) if f is None: excluded.append(f) continue diff --git a/ivy/utils/binaries.py b/ivy/utils/binaries.py index d56ec9a9c35a3..34948140db9c8 100644 --- a/ivy/utils/binaries.py +++ b/ivy/utils/binaries.py @@ -33,12 +33,10 @@ def check_for_binaries(): for path in binaries_paths: if not os.path.exists(path): if initial: - config_str = "\n".join( - [ - f"{module} : {', '.join(configs)}" - for module, configs in available_configs.items() - ] - ) + config_str = "\n".join([ + f"{module} : {', '.join(configs)}" + for module, configs in available_configs.items() + ]) logging.warning( "\tSome binaries seem to be missing in your system. This could " "be either because we don't have compatible binaries for your " diff --git a/ivy/utils/exceptions.py b/ivy/utils/exceptions.py index d95aa7c55a337..872b12b14cc33 100644 --- a/ivy/utils/exceptions.py +++ b/ivy/utils/exceptions.py @@ -120,9 +120,9 @@ def _get_traces(curr_obj, area, local_dict, target_name): curr_obj[3] = rooted_src_list[i] curr_obj[1] += i break - elif builtins.any( - [name in rooted_src_list[i] for name in non_lib_objs_name_list] - ): + elif builtins.any([ + name in rooted_src_list[i] for name in non_lib_objs_name_list + ]): found = False for name in non_lib_objs_name_list: if name in rooted_src_list[i]: diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test__src/test_tree_util.py b/ivy_tests/test_ivy/test_frontends/test_jax/test__src/test_tree_util.py index 171cf37f2d825..5a53c51bd5196 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test__src/test_tree_util.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test__src/test_tree_util.py @@ -87,16 +87,14 @@ def tree_strategy(max_depth=2): return leaf_strategy() else: return st.dictionaries( - keys=st.one_of( - *[ - st.text( - alphabet=st.characters(min_codepoint=97, max_codepoint=122), - min_size=1, - max_size=1, - ).filter(lambda x: x not in used_keys) - for used_keys in [set()] - ] - ), + keys=st.one_of(*[ + st.text( + alphabet=st.characters(min_codepoint=97, max_codepoint=122), + min_size=1, + max_size=1, + ).filter(lambda x: x not in used_keys) + for used_keys in [set()] + ]), values=st.one_of(leaf_strategy(), tree_strategy(max_depth - 1)), min_size=1, max_size=10, diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py index 183a13d742a6c..f355a902382ea 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py @@ -460,22 +460,18 @@ def _x_and_filters(draw, dim=2, transpose=False, general=False): dim_num_st2 = st.sampled_from(["OIDHW", "DHWIO"]) dim_seq = [*range(0, dim + 2)] dimension_numbers = draw( - st.sampled_from( - [ - None, - (draw(dim_num_st1), draw(dim_num_st2), draw(dim_num_st1)), - ConvDimensionNumbers( - *map( - tuple, - draw( - st.lists( - st.permutations(dim_seq), min_size=3, max_size=3 - ) - ), - ) - ), - ] - ) + st.sampled_from([ + None, + (draw(dim_num_st1), draw(dim_num_st2), draw(dim_num_st1)), + ConvDimensionNumbers( + *map( + tuple, + draw( + st.lists(st.permutations(dim_seq), min_size=3, max_size=3) + ), + ) + ), + ]) ) else: dimension_numbers = ( diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py index 4d76bfcc9a139..5ebef754a9aab 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py @@ -113,9 +113,9 @@ def test_jax_choose( on_device, ): dtypes, x, indices, axis, _ = dtype_x_indices_axis - choices = ivy.array( - [np.random.randint(0, 10, size=x.shape) for _ in range(len(dtypes))] - ) + choices = ivy.array([ + np.random.randint(0, 10, size=x.shape) for _ in range(len(dtypes)) + ]) helpers.test_frontend_function( input_dtypes=dtypes, backend_to_test=backend_fw, diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py index cb166b68fb046..721dd7e1fcf70 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py @@ -39,9 +39,9 @@ def _get_inv_square_matrices(draw): ) shape, ind = draw( - st.sampled_from( - [(generated_shape, generated_ind), (handpicked_shape, handpicked_ind)] - ) + st.sampled_from([ + (generated_shape, generated_ind), (handpicked_shape, handpicked_ind) + ]) ) input_dtype = draw( diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py index 2d9d150748115..92b3a644c42bb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py @@ -111,21 +111,19 @@ def _get_input_and_block(draw): max_size=10, ) ) - x_dtypes, xs = zip( - *[ - draw( - helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), - min_num_dims=1, - max_num_dims=5, - min_dim_size=2, - max_dim_size=10, - shape=shape, - ) + x_dtypes, xs = zip(*[ + draw( + helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_num_dims=1, + max_num_dims=5, + min_dim_size=2, + max_dim_size=10, + shape=shape, ) - for shape in shapes - ] - ) + ) + for shape in shapes + ]) return x_dtypes, xs @@ -230,20 +228,18 @@ def _get_input_and_two_swapabble_axes(draw): @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from( - [ - "constant", - "edge", - "linear_ramp", - "maximum", - "mean", - "median", - "minimum", - "reflect", - "symmetric", - "wrap", - ] - ) + st.sampled_from([ + "constant", + "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", + "reflect", + "symmetric", + "wrap", + ]) ) if mode == "median": dtypes = "float" diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py index 28d6388d2af2c..c972407723b23 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py @@ -546,19 +546,17 @@ def test_jax_cumsum( # einsum @handle_frontend_test( fn_tree="jax.numpy.einsum", - eq_n_op=st.sampled_from( - [ - ( - "ii", - np.arange(25).reshape(5, 5), - ), - ( - "ii->i", - np.arange(25).reshape(5, 5), - ), - ("ij,j", np.arange(25).reshape(5, 5), np.arange(5)), - ] - ), + eq_n_op=st.sampled_from([ + ( + "ii", + np.arange(25).reshape(5, 5), + ), + ( + "ii->i", + np.arange(25).reshape(5, 5), + ), + ("ij,j", np.arange(25).reshape(5, 5), np.arange(5)), + ]), dtype=helpers.get_dtypes("float", full=False), ) def test_jax_einsum( diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py index 46a0d22c152cd..8b07920b02287 100644 --- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py +++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py @@ -529,17 +529,15 @@ def test_mindspore_flatten( num_arrays=1, shared_dtype=True, ), - mode=st.sampled_from( - [ - "nearest", - "linear", - "bilinear", - "bicubic", - "trilinear", - "area", - "nearest-exact", - ] - ), + mode=st.sampled_from([ + "nearest", + "linear", + "bilinear", + "bicubic", + "trilinear", + "area", + "nearest-exact", + ]), align_corners=st.booleans(), recompute_scale_factor=st.booleans(), size_and_scale_factor=_size_and_scale_factor_strategy(), diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py index d93895355b185..fc918a1d85da6 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py @@ -23,23 +23,17 @@ @st.composite def _dtype_helper(draw): return draw( - st.sampled_from( - [ - draw(st.sampled_from([int, float, bool])), - ivy.as_native_dtype( - draw(helpers.get_dtypes("valid", full=False, prune_function=False))[ - 0 - ] - ), - np_frontend.dtype( - draw(helpers.get_dtypes("valid", full=False, prune_function=False))[ - 0 - ] - ), - draw(st.sampled_from(list(np_frontend.numpy_scalar_to_dtype.keys()))), - draw(st.sampled_from(list(np_frontend.numpy_str_to_type_table.keys()))), - ] - ) + st.sampled_from([ + draw(st.sampled_from([int, float, bool])), + ivy.as_native_dtype( + draw(helpers.get_dtypes("valid", full=False, prune_function=False))[0] + ), + np_frontend.dtype( + draw(helpers.get_dtypes("valid", full=False, prune_function=False))[0] + ), + draw(st.sampled_from(list(np_frontend.numpy_scalar_to_dtype.keys()))), + draw(st.sampled_from(list(np_frontend.numpy_str_to_type_table.keys()))), + ]) ) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py index 164f698ad8c29..a3dd357e34cfe 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py @@ -161,19 +161,17 @@ def test_numpy_dot( @handle_frontend_test( fn_tree="numpy.linalg.matrix_and_vector_products.einsum", gt_fn_tree="numpy.einsum", - args=st.sampled_from( - [ - ( - "ii", - np.arange(25).reshape(5, 5), - ), - ( - "ii->i", - np.arange(25).reshape(5, 5), - ), - ("ij,j", np.arange(25).reshape(5, 5), np.arange(5)), - ] - ), + args=st.sampled_from([ + ( + "ii", + np.arange(25).reshape(5, 5), + ), + ( + "ii->i", + np.arange(25).reshape(5, 5), + ), + ("ij,j", np.arange(25).reshape(5, 5), np.arange(5)), + ]), dtype=helpers.get_dtypes("float", full=False), ) def test_numpy_einsum( diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py index 4ea7804d3d06b..07e9a06bfbcd2 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py @@ -27,9 +27,9 @@ def _get_inv_square_matrices(draw): ) shape, ind = draw( - st.sampled_from( - [(generated_shape, generated_ind), (handpicked_shape, handpicked_ind)] - ) + st.sampled_from([ + (generated_shape, generated_ind), (handpicked_shape, handpicked_ind) + ]) ) input_dtype = draw( diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py index 8fe30ac7ca58f..6156d1fd3b612 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py @@ -13,20 +13,18 @@ @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from( - [ - "constant", - "edge", - "linear_ramp", - "maximum", - "mean", - "median", - "minimum", - "reflect", - "symmetric", - "wrap", - ] - ) + st.sampled_from([ + "constant", + "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", + "reflect", + "symmetric", + "wrap", + ]) ) if mode in ["median", "mean"]: dtypes = "float" diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py index f020caefc0d57..c70b27ae2e3c2 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py @@ -60,22 +60,20 @@ def _interp_args(draw, mode=None, mode_list=None): mode = draw(st.sampled_from(jax_modes)) else: mode = draw( - st.sampled_from( - [ - "linear", - "bilinear", - "trilinear", - "nearest", - "nearest-exact", - "area", - "tf_area", - "tf_bicubic", - "lanczos3", - "lanczos5", - "mitchellcubic", - "gaussian", - ] - ) + st.sampled_from([ + "linear", + "bilinear", + "trilinear", + "nearest", + "nearest-exact", + "area", + "tf_area", + "tf_bicubic", + "lanczos3", + "lanczos5", + "mitchellcubic", + "gaussian", + ]) ) elif mode_list: mode = draw(st.sampled_from(mode_list)) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_func_wrapper.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_func_wrapper.py index 036a6fa1e8c54..5d0290a5ea5cb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_func_wrapper.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_func_wrapper.py @@ -22,26 +22,18 @@ @st.composite def _dtype_helper(draw): return draw( - st.sampled_from( - [ - draw(helpers.get_dtypes("valid", prune_function=False, full=False))[0], - ivy.as_native_dtype( - draw(helpers.get_dtypes("valid", prune_function=False, full=False))[ - 0 - ] - ), - draw( - st.sampled_from(list(tf_frontend.tensorflow_enum_to_type.values())) - ), - draw(st.sampled_from(list(tf_frontend.tensorflow_enum_to_type.keys()))), - np_frontend.dtype( - draw(helpers.get_dtypes("valid", prune_function=False, full=False))[ - 0 - ] - ), - draw(st.sampled_from(list(np_frontend.numpy_scalar_to_dtype.keys()))), - ] - ) + st.sampled_from([ + draw(helpers.get_dtypes("valid", prune_function=False, full=False))[0], + ivy.as_native_dtype( + draw(helpers.get_dtypes("valid", prune_function=False, full=False))[0] + ), + draw(st.sampled_from(list(tf_frontend.tensorflow_enum_to_type.values()))), + draw(st.sampled_from(list(tf_frontend.tensorflow_enum_to_type.keys()))), + np_frontend.dtype( + draw(helpers.get_dtypes("valid", prune_function=False, full=False))[0] + ), + draw(st.sampled_from(list(np_frontend.numpy_scalar_to_dtype.keys()))), + ]) ) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py index 2fa0da6a6c272..7c506041277e8 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py @@ -228,13 +228,11 @@ def _multiple_shape_helper(draw): @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from( - [ - "CONSTANT", - "REFLECT", - "SYMMETRIC", - ] - ) + st.sampled_from([ + "CONSTANT", + "REFLECT", + "SYMMETRIC", + ]) ) dtype, input, shape = draw( helpers.dtype_and_values( @@ -695,13 +693,11 @@ def test_tensorflow_convert_to_tensor( # einsum @handle_frontend_test( fn_tree="tensorflow.einsum", - eq_n_op_n_shp=st.sampled_from( - [ - ("ii", (np.arange(25).reshape(5, 5),), ()), - ("ii->i", (np.arange(25).reshape(5, 5),), (5,)), - ("ij,j", (np.arange(25).reshape(5, 5), np.arange(5)), (5,)), - ] - ), + eq_n_op_n_shp=st.sampled_from([ + ("ii", (np.arange(25).reshape(5, 5),), ()), + ("ii->i", (np.arange(25).reshape(5, 5),), (5,)), + ("ij,j", (np.arange(25).reshape(5, 5), np.arange(5)), (5,)), + ]), dtype=helpers.get_dtypes("float", full=False), ) def test_tensorflow_einsum( diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py index 912c3e82599be..5d9de4b6aff10 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py @@ -78,14 +78,12 @@ def _pad_generator(draw, shape, mode): @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from( - [ - "constant", - "reflect", - "replicate", - "circular", - ] - ) + st.sampled_from([ + "constant", + "reflect", + "replicate", + "circular", + ]) ) min_v = 1 max_v = 5 diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_creation.py b/ivy_tests/test_ivy/test_functional/test_core/test_creation.py index 99a105e454651..c2686e8d00b35 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_creation.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_creation.py @@ -46,14 +46,12 @@ def _asarray_helper(draw): )[-1] dtype = draw(st.sampled_from([dtype, None])) x = draw( - st.sampled_from( - [ - x, - x_list, - sh, - # nested_values, - ] - ) + st.sampled_from([ + x, + x_list, + sh, + # nested_values, + ]) ) return x_dtype, x, dtype diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index 7170cb1196af0..edf425cb782c1 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -408,12 +408,10 @@ def test_arg_info(): @given( - x_n_value=st.sampled_from( - [ - [ivy.value_is_nan, ["x", "include_infs"]], - [ivy.clip_matrix_norm, ["x", "max_norm", "p", "out"]], - ] - ) + x_n_value=st.sampled_from([ + [ivy.value_is_nan, ["x", "include_infs"]], + [ivy.clip_matrix_norm, ["x", "max_norm", "p", "out"]], + ]) ) def test_arg_names(x_n_value): x, value = x_n_value @@ -712,17 +710,15 @@ def test_default(x, default_val, test_flags, backend_fw): and (ivy.array([x[1][0]], dtype="float32").shape[3] % 2 == 0) and (x[0][0] not in ["float16", "bfloat16"]) ), - pattern_and_axes_lengths=st.sampled_from( - [ - ("b h w c -> b h w c", {}), - ("b h w c -> (b h) w c", {}), - ("b h w c -> b c h w", {}), - ("b h w c -> h (b w) c", {}), - ("b h w c -> b (c h w)", {}), - ("b (h1 h) (w1 w) c -> (b h1 w1) h w c", {"h1": 2, "w1": 2}), - ("b (h h1) (w w1) c -> b h w (c h1 w1)", {"h1": 2, "w1": 2}), - ] - ), + pattern_and_axes_lengths=st.sampled_from([ + ("b h w c -> b h w c", {}), + ("b h w c -> (b h) w c", {}), + ("b h w c -> b c h w", {}), + ("b h w c -> h (b w) c", {}), + ("b h w c -> b (c h w)", {}), + ("b (h1 h) (w1 w) c -> (b h1 w1) h w c", {"h1": 2, "w1": 2}), + ("b (h h1) (w w1) c -> b h w (c h1 w1)", {"h1": 2, "w1": 2}), + ]), ) def test_einops_rearrange( dtype_x, pattern_and_axes_lengths, test_flags, backend_fw, fn_name, on_device @@ -758,11 +754,9 @@ def test_einops_rearrange( and (ivy.array([x[1][0]], dtype="float32").shape[3] % 2 == 0) and (x[0][0] not in ["float16", "bfloat16"]) ), - pattern_and_axes_lengths=st.sampled_from( - [ - ("b c (h1 h2) (w1 w2) -> b c h1 w1", {"h2": 2, "w2": 2}), - ] - ), + pattern_and_axes_lengths=st.sampled_from([ + ("b c (h1 h2) (w1 w2) -> b c h1 w1", {"h2": 2, "w2": 2}), + ]), floattypes=helpers.get_dtypes("float"), reduction=st.sampled_from(["min", "max", "sum", "mean", "prod"]), ) @@ -809,15 +803,13 @@ def test_einops_reduce( max_num_dims=2, min_dim_size=2, ), - pattern_and_axes_lengths=st.sampled_from( - [ - ("h w -> h w repeat", {"repeat": 2}), - ("h w -> (repeat h) w", {"repeat": 2}), - ("h w -> h (repeat w)", {"repeat": 2}), - ("h w -> (h h2) (w w2)", {"h2": 2, "w2": 2}), - ("h w -> w h", {}), - ] - ), + pattern_and_axes_lengths=st.sampled_from([ + ("h w -> h w repeat", {"repeat": 2}), + ("h w -> (repeat h) w", {"repeat": 2}), + ("h w -> h (repeat w)", {"repeat": 2}), + ("h w -> (h h2) (w w2)", {"h2": 2, "w2": 2}), + ("h w -> w h", {}), + ]), ) def test_einops_repeat( *, dtype_x, pattern_and_axes_lengths, test_flags, backend_fw, fn_name, on_device diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_meta.py b/ivy_tests/test_ivy/test_functional/test_core/test_meta.py index a0b3cc5723e1c..54fceaf059e28 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_meta.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_meta.py @@ -45,36 +45,32 @@ def test_fomaml_step_overlapping_vars( # create variables if batched: - variables = ivy_backend.Container( - { - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[0.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - "weight": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - } - ) + variables = ivy_backend.Container({ + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[0.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + "weight": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + }) else: - variables = ivy_backend.Container( - { - "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), - "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), - } - ) + variables = ivy_backend.Container({ + "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), + "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), + }) # batch - batch = ivy_backend.Container( - {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} - ) + batch = ivy_backend.Container({ + "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") + }) # inner cost function def inner_cost_fn(batch_in, v): @@ -106,16 +102,14 @@ def outer_cost_fn(batch_in, v): # true gradient all_outer_grads = [] for sub_batch in batch_np.cont_unstack_conts(0, True, num_tasks): - all_outer_grads.append( - [ - ( - -i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 - - sub_batch["x"][0] * latent_np - ) - * (-1 if with_outer_cost_fn else 1) - for i in range(inner_grad_steps + 1) - ] - ) + all_outer_grads.append([ + ( + -i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 + - sub_batch["x"][0] * latent_np + ) + * (-1 if with_outer_cost_fn else 1) + for i in range(inner_grad_steps + 1) + ]) if average_across_steps: true_weight_grad = ( sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks @@ -124,9 +118,9 @@ def outer_cost_fn(batch_in, v): true_weight_grad = sum(og[-1] for og in all_outer_grads) / num_tasks # true latent gradient - true_latent_grad = np.array( - [(-1 - (num_tasks - 1) / 2) * (-1 if with_outer_cost_fn else 1)] - ) + true_latent_grad = np.array([ + (-1 - (num_tasks - 1) / 2) * (-1 if with_outer_cost_fn else 1) + ]) # true cost true_cost_dict = { @@ -218,26 +212,24 @@ def test_fomaml_step_shared_vars( # create variable if batched: - variables = ivy_backend.Container( - { - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) + variables = ivy_backend.Container({ + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, ) - } - ) + ) + }) else: - variables = ivy_backend.Container( - {"latent": variable_fn(ivy_backend.array([1.0], device=on_device))} - ) + variables = ivy_backend.Container({ + "latent": variable_fn(ivy_backend.array([1.0], device=on_device)) + }) # batch - batch = ivy_backend.Container( - {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} - ) + batch = ivy_backend.Container({ + "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") + }) # inner cost function def inner_cost_fn(batch_in, v): @@ -409,36 +401,32 @@ def test_fomaml_step_unique_vars( # create variables if batched: - variables = ivy_backend.Container( - { - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[0.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - "weight": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - } - ) + variables = ivy_backend.Container({ + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[0.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + "weight": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + }) else: - variables = ivy_backend.Container( - { - "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), - "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), - } - ) + variables = ivy_backend.Container({ + "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), + "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), + }) # batch - batch = ivy_backend.Container( - {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} - ) + batch = ivy_backend.Container({ + "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") + }) # inner cost function def inner_cost_fn(batch_in, v): @@ -470,16 +458,14 @@ def outer_cost_fn(batch_in, v): # true gradient all_outer_grads = [] for sub_batch in batch_np.cont_unstack_conts(0, True, num_tasks): - all_outer_grads.append( - [ - ( - -i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 - - sub_batch["x"][0] * latent_np - ) - * (-1 if with_outer_cost_fn else 1) - for i in range(inner_grad_steps + 1) - ] - ) + all_outer_grads.append([ + ( + -i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 + - sub_batch["x"][0] * latent_np + ) + * (-1 if with_outer_cost_fn else 1) + for i in range(inner_grad_steps + 1) + ]) if average_across_steps: true_weight_grad = ( sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks @@ -573,36 +559,32 @@ def test_maml_step_overlapping_vars( # create variables if batched: - variables = ivy_backend.Container( - { - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[0.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - "weight": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - } - ) + variables = ivy_backend.Container({ + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[0.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + "weight": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + }) else: - variables = ivy_backend.Container( - { - "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), - "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), - } - ) + variables = ivy_backend.Container({ + "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), + "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), + }) # batch - batch = ivy_backend.Container( - {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} - ) + batch = ivy_backend.Container({ + "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") + }) # inner cost function def inner_cost_fn(batch_in, v): @@ -634,20 +616,14 @@ def outer_cost_fn(batch_in, v): # true weight gradient all_outer_grads = [] for sub_batch in batch_np.cont_unstack_conts(0, True, num_tasks): - all_outer_grads.append( - [ - ( - -2 - * i - * inner_learning_rate - * weight_np - * sub_batch["x"][0] ** 2 - - sub_batch["x"][0] * latent_np - ) - * (-1 if with_outer_cost_fn else 1) - for i in range(inner_grad_steps + 1) - ] - ) + all_outer_grads.append([ + ( + -2 * i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 + - sub_batch["x"][0] * latent_np + ) + * (-1 if with_outer_cost_fn else 1) + for i in range(inner_grad_steps + 1) + ]) if average_across_steps: true_weight_grad = ( sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks @@ -656,9 +632,9 @@ def outer_cost_fn(batch_in, v): true_weight_grad = sum(og[-1] for og in all_outer_grads) / num_tasks # true latent gradient - true_latent_grad = np.array( - [(-1 - (num_tasks - 1) / 2) * (-1 if with_outer_cost_fn else 1)] - ) + true_latent_grad = np.array([ + (-1 - (num_tasks - 1) / 2) * (-1 if with_outer_cost_fn else 1) + ]) # true cost true_cost_dict = { @@ -748,26 +724,24 @@ def test_maml_step_shared_vars( # create variable if batched: - variables = ivy_backend.Container( - { - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) + variables = ivy_backend.Container({ + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, ) - } - ) + ) + }) else: - variables = ivy_backend.Container( - {"latent": variable_fn(ivy_backend.array([1.0], device=on_device))} - ) + variables = ivy_backend.Container({ + "latent": variable_fn(ivy_backend.array([1.0], device=on_device)) + }) # batch - batch = ivy_backend.Container( - {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} - ) + batch = ivy_backend.Container({ + "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") + }) # inner cost function def inner_cost_fn(batch_in, v): @@ -980,36 +954,32 @@ def test_maml_step_unique_vars( # create variables if batched: - variables = ivy_backend.Container( - { - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[0.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - "weight": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - } - ) + variables = ivy_backend.Container({ + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[0.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + "weight": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + }) else: - variables = ivy_backend.Container( - { - "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), - "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), - } - ) + variables = ivy_backend.Container({ + "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), + "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), + }) # batch - batch = ivy_backend.Container( - {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} - ) + batch = ivy_backend.Container({ + "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") + }) # inner cost function def inner_cost_fn(batch_in, v): @@ -1041,20 +1011,14 @@ def outer_cost_fn(batch_in, v): # true gradient all_outer_grads = [] for sub_batch in batch_np.cont_unstack_conts(0, True, num_tasks): - all_outer_grads.append( - [ - ( - -2 - * i - * inner_learning_rate - * weight_np - * sub_batch["x"][0] ** 2 - - sub_batch["x"][0] * latent_np - ) - * (-1 if with_outer_cost_fn else 1) - for i in range(inner_grad_steps + 1) - ] - ) + all_outer_grads.append([ + ( + -2 * i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 + - sub_batch["x"][0] * latent_np + ) + * (-1 if with_outer_cost_fn else 1) + for i in range(inner_grad_steps + 1) + ]) if average_across_steps: true_outer_grad = ( sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks @@ -1143,26 +1107,24 @@ def test_reptile_step( # create variable if batched: - variables = ivy_backend.Container( - { - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) + variables = ivy_backend.Container({ + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, ) - } - ) + ) + }) else: - variables = ivy_backend.Container( - {"latent": variable_fn(ivy_backend.array([1.0], device=on_device))} - ) + variables = ivy_backend.Container({ + "latent": variable_fn(ivy_backend.array([1.0], device=on_device)) + }) # batch - batch = ivy_backend.Container( - {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} - ) + batch = ivy_backend.Container({ + "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") + }) # inner cost function def inner_cost_fn(batch_in, v): diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_gradients.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_gradients.py index f34b3513a8290..b5226c371a127 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_gradients.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_gradients.py @@ -13,26 +13,22 @@ def _get_primals_and_tangents(x_, dtype, ivy_backend, primals_cont, tangents_cont): if primals_cont: - primals = ivy_backend.Container( - { - "l": { - "a": ivy_backend.array(x_[0][0], dtype=dtype), - "b": ivy_backend.array(x_[0][1], dtype=dtype), - } + primals = ivy_backend.Container({ + "l": { + "a": ivy_backend.array(x_[0][0], dtype=dtype), + "b": ivy_backend.array(x_[0][1], dtype=dtype), } - ) + }) else: primals = ivy_backend.array(x_[0], dtype=dtype) if tangents_cont: - tangents = ivy_backend.Container( - { - "l": { - "a": ivy_backend.array([t[0] for t in x_[1]], dtype=dtype), - "b": ivy_backend.array([t[0] for t in x_[1]], dtype=dtype), - } + tangents = ivy_backend.Container({ + "l": { + "a": ivy_backend.array([t[0] for t in x_[1]], dtype=dtype), + "b": ivy_backend.array([t[0] for t in x_[1]], dtype=dtype), } - ) + }) else: if primals_cont: tangents = ivy_backend.array([t[0] for t in x_[1]], dtype=dtype) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py index c008dcb0b4cf6..1fe495ad058aa 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py @@ -205,21 +205,19 @@ def _matricize_data(draw): @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from( - [ - "constant", - "dilated", - "edge", - "linear_ramp", - "maximum", - "mean", - "median", - "minimum", - "reflect", - "symmetric", - "wrap", - ] - ) + st.sampled_from([ + "constant", + "dilated", + "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", + "reflect", + "symmetric", + "wrap", + ]) ) if mode in ["median", "minimum", "maximum", "linear_ramp"]: dtypes = "float" diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 1840881cf128c..caafbb8b4252c 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -65,22 +65,20 @@ def _interp_args(draw, mode=None, mode_list=None): mode = draw(st.sampled_from(jax_modes)) else: mode = draw( - st.sampled_from( - [ - "linear", - "bilinear", - "trilinear", - "nearest", - "nearest-exact", - "area", - "tf_area", - "tf_bicubic", - "lanczos3", - "lanczos5", - "mitchellcubic", - "gaussian", - ] - ) + st.sampled_from([ + "linear", + "bilinear", + "trilinear", + "nearest", + "nearest-exact", + "area", + "tf_area", + "tf_bicubic", + "lanczos3", + "lanczos5", + "mitchellcubic", + "gaussian", + ]) ) elif mode_list: mode = draw(st.sampled_from(mode_list)) diff --git a/ivy_tests/test_ivy/test_misc/test_array.py b/ivy_tests/test_ivy/test_misc/test_array.py index 12553cf4da570..1c334ef0ebb92 100644 --- a/ivy_tests/test_ivy/test_misc/test_array.py +++ b/ivy_tests/test_ivy/test_misc/test_array.py @@ -2552,9 +2552,9 @@ def test_array_property_strides(dtype_x, backend_fw): min_value=3.0, max_value=10.0, ), - op=st.sampled_from( - ["!=", ">", "<", ">=", "<=", "*", "/", "%", "==", "&", "@", "**", "/"] - ), + op=st.sampled_from([ + "!=", ">", "<", ">=", "<=", "*", "/", "%", "==", "&", "@", "**", "/" + ]), ) def test_dunder_wrapping( dtype_x, diff --git a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py index d9f7c2cfdebba..ac26cf7ba3906 100644 --- a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py +++ b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py @@ -107,12 +107,10 @@ def test_dynamic_backend_all_combos(middle_backend, end_backend): # set the middle backend ivy.set_backend(middle_backend, dynamic=True) - var_cont = ivy.Container( - { - "w": ivy.gradients._variable(ivy.array([10, 20, 30])), - "b": ivy.gradients._variable(ivy.array([40, 50, 60])), - } - ) + var_cont = ivy.Container({ + "w": ivy.gradients._variable(ivy.array([10, 20, 30])), + "b": ivy.gradients._variable(ivy.array([40, 50, 60])), + }) # set dynamic_backend to true for all objects ivy_cont.dynamic_backend = True a.dynamic_backend = True diff --git a/ivy_tests/test_ivy/test_misc/test_container.py b/ivy_tests/test_ivy/test_misc/test_container.py index ebdea48aa8e94..4e0621b0ef31f 100644 --- a/ivy_tests/test_ivy/test_misc/test_container.py +++ b/ivy_tests/test_ivy/test_misc/test_container.py @@ -19,9 +19,9 @@ def test_container_all_false(on_device): assert not Container({"a": False, "b": {"c": [1], "d": 0}}).cont_all_false() # noinspection PyBroadException try: - assert Container( - {"a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True}} - ).cont_all_false(assert_is_bool=True) + assert Container({ + "a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True} + }).cont_all_false(assert_is_bool=True) error_raised = False except IvyException: error_raised = True @@ -42,17 +42,17 @@ def test_container_all_key_chains(include_empty, on_device): def test_container_all_true(on_device): - assert not Container( - {"a": ivy.array([1], device=on_device), "b": {"c": [], "d": True}} - ).cont_all_true() - assert Container( - {"a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True}} - ).cont_all_true() + assert not Container({ + "a": ivy.array([1], device=on_device), "b": {"c": [], "d": True} + }).cont_all_true() + assert Container({ + "a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True} + }).cont_all_true() # noinspection PyBroadException try: - assert Container( - {"a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True}} - ).cont_all_true(assert_is_bool=True) + assert Container({ + "a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True} + }).cont_all_true(assert_is_bool=True) error_raised = False except IvyException: error_raised = True @@ -103,12 +103,10 @@ def test_container_assert_contains(on_device): error_caught = True assert error_caught # sub-structure - sub_struc = Container( - { - "c": ivy.array([3.0], device=on_device), - "d": ivy.array([4.0], device=on_device), - } - ) + sub_struc = Container({ + "c": ivy.array([3.0], device=on_device), + "d": ivy.array([4.0], device=on_device), + }) try: not container.cont_assert_contains_sub_container(sub_struc) error_caught = False @@ -138,15 +136,13 @@ def test_container_assert_identical(on_device): arr3 = ivy.array([3], device=on_device) container0 = Container({"a": arr1, "b": {"c": arr2, "d": arr3}}) container1 = Container({"a": arr1, "b": {"c": arr2, "d": arr3}}) - container2 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) + container2 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) container3 = Container({"b": {"d": arr3}}) container4 = Container({"d": arr3}) @@ -181,44 +177,36 @@ def test_container_assert_identical(on_device): def test_container_assert_identical_structure(on_device): # without key_chains specification - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container1 = Container( - { - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - } - ) - container2 = Container( - { - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - "e": ivy.array([6], device=on_device), - }, - } - ) - container3 = Container( - { - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container1 = Container({ + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + }) + container2 = Container({ + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), "e": ivy.array([6], device=on_device), - } - ) + }, + }) + container3 = Container({ + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + "e": ivy.array([6], device=on_device), + }) container4 = Container({"b": {"d": ivy.array([4], device=on_device)}}) container5 = Container({"d": ivy.array([4], device=on_device)}) @@ -229,9 +217,9 @@ def test_container_assert_identical_structure(on_device): # without identical try: - ivy.Container.cont_assert_identical_structure( - [container0, container1, container2, container3] - ) + ivy.Container.cont_assert_identical_structure([ + container0, container1, container2, container3 + ]) error_caught = False except IvyException: error_caught = True @@ -326,24 +314,20 @@ def test_container_at_keys(on_device): def test_container_combine(on_device): - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "e": ivy.array([6], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "e": ivy.array([6], device=on_device), + }, + }) container_comb = ivy.Container.cont_combine(container_0, container_1) assert np.equal(ivy.to_numpy(container_comb.a), np.array([4])) assert np.equal(ivy.to_numpy(container_comb.b.c), np.array([5])) @@ -391,25 +375,21 @@ def test_container_common_key_chains(on_device): def test_container_cont_inplace_update(on_device): - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([1], device=on_device), - "d": ivy.array([2], device=on_device), - }, - } - ) + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([1], device=on_device), + "d": ivy.array([2], device=on_device), + }, + }) id0 = id(container0) - container1 = Container( - { - "a": ivy.array([0], device=on_device), - "b": { - "c": ivy.array([0], device=on_device), - "d": ivy.array([0], device=on_device), - }, - } - ) + container1 = Container({ + "a": ivy.array([0], device=on_device), + "b": { + "c": ivy.array([0], device=on_device), + "d": ivy.array([0], device=on_device), + }, + }) id1 = id(container1) assert ivy.Container.cont_all_false(container0.all_equal(container1)) container0.inplace_update(container1) @@ -445,12 +425,10 @@ def test_container_contains(on_device): assert not partial_sub_cont.cont_contains_sub_container(container, partial=True) # sub-structure - sub_struc = Container( - { - "c": ivy.array([3.0], device=on_device), - "d": ivy.array([4.0], device=on_device), - } - ) + sub_struc = Container({ + "c": ivy.array([3.0], device=on_device), + "d": ivy.array([4.0], device=on_device), + }) assert not container.cont_contains_sub_container(sub_struc) assert sub_struc not in container assert container.cont_contains_sub_structure(sub_struc) @@ -607,36 +585,30 @@ def test_container_deep_copy(on_device): def test_container_depth(on_device): - cont_depth1 = Container( - {"a": ivy.array([1], device=on_device), "b": ivy.array([2], device=on_device)} - ) + cont_depth1 = Container({ + "a": ivy.array([1], device=on_device), "b": ivy.array([2], device=on_device) + }) assert cont_depth1.cont_max_depth == 1 - cont_depth2 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) + cont_depth2 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) assert cont_depth2.cont_max_depth == 2 - cont_depth3 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": {"d": ivy.array([2], device=on_device)}, - "e": ivy.array([3], device=on_device), - }, - } - ) + cont_depth3 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": {"d": ivy.array([2], device=on_device)}, + "e": ivy.array([3], device=on_device), + }, + }) assert cont_depth3.cont_max_depth == 3 - cont_depth4 = Container( - { - "a": ivy.array([1], device=on_device), - "b": {"c": {"d": {"e": ivy.array([2], device=on_device)}}}, - } - ) + cont_depth4 = Container({ + "a": ivy.array([1], device=on_device), + "b": {"c": {"d": {"e": ivy.array([2], device=on_device)}}}, + }) assert cont_depth4.cont_max_depth == 4 @@ -654,24 +626,20 @@ def test_container_dev_str(on_device): def test_container_diff(on_device): # all different arrays - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "d": ivy.array([6], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "d": ivy.array([6], device=on_device), + }, + }) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a.diff_0), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.a.diff_1), np.array([4])) @@ -689,24 +657,20 @@ def test_container_diff(on_device): assert container_diff_same_only.cont_to_dict() == {} # some different arrays - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c.diff_0), np.array([2])) @@ -728,24 +692,20 @@ def test_container_diff(on_device): assert "d" in container_diff_same_only["b"] # all different keys - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "e": ivy.array([1], device=on_device), - "f": { - "g": ivy.array([2], device=on_device), - "h": ivy.array([3], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "e": ivy.array([1], device=on_device), + "f": { + "g": ivy.array([2], device=on_device), + "h": ivy.array([3], device=on_device), + }, + }) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a.diff_0), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.diff_0.c), np.array([2])) @@ -763,24 +723,20 @@ def test_container_diff(on_device): assert container_diff_same_only.cont_to_dict() == {} # some different keys - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "e": ivy.array([3], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "e": ivy.array([3], device=on_device), + }, + }) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c), np.array([2])) @@ -804,24 +760,20 @@ def test_container_diff(on_device): assert "e" not in container_diff_same_only["b"] # same containers - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c), np.array([2])) @@ -859,15 +811,13 @@ def test_container_duplicate_array_keychains(on_device): arr1 = ivy.array([1], device=on_device) arr2 = ivy.array([2], device=on_device) container0 = Container({"a": arr1, "b": {"c": arr1, "d": arr2}}) - container1 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([1], device=on_device), - "d": ivy.array([2], device=on_device), - }, - } - ) + container1 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([1], device=on_device), + "d": ivy.array([2], device=on_device), + }, + }) res = ivy.Container.cont_duplicate_array_keychains(container0) assert res == (("a", "b/c"),) res = ivy.Container.cont_duplicate_array_keychains(container1) @@ -911,9 +861,9 @@ def test_container_find_sub_structure(on_device): top_cont = Container(dict_in) # full - sub_cont = Container( - {"c": ivy.array([4], device=on_device), "d": ivy.array([5], device=on_device)} - ) + sub_cont = Container({ + "c": ivy.array([4], device=on_device), "d": ivy.array([5], device=on_device) + }) assert not top_cont.cont_find_sub_container(sub_cont) found_kc = top_cont.cont_find_sub_structure(sub_cont) assert found_kc == "b" @@ -930,15 +880,13 @@ def test_container_find_sub_structure(on_device): def test_container_flatten_key_chains(on_device): - container = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": {"d": ivy.array([2], device=on_device)}, - "e": {"f": {"g": ivy.array([3], device=on_device)}}, - }, - } - ) + container = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": {"d": ivy.array([2], device=on_device)}, + "e": {"f": {"g": ivy.array([3], device=on_device)}}, + }, + }) # full container_flat = container.cont_flatten_key_chains() @@ -1022,12 +970,10 @@ def test_container_from_dict_w_cont_types(on_device): dict_in = { "a": ivy.array([1], device=on_device), - "b": FlatMapping( - { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - } - ), + "b": FlatMapping({ + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }), } container = Container(dict_in) assert np.allclose(ivy.to_numpy(container["a"]), np.array([1])) @@ -1107,14 +1053,12 @@ def worker_fn(in_queue, out_queue, load_size, worker_id): keep_going = in_queue.get(timeout=0.1) except queue.Empty: continue - out_queue.put( - { - "a": [ - ivy.to_native(ivy.array([1.0, 2.0, 3.0], device=on_device)) - * worker_id - ] * load_size - } - ) + out_queue.put({ + "a": [ + ivy.to_native(ivy.array([1.0, 2.0, 3.0], device=on_device)) + * worker_id + ] * load_size + }) workers = [] in_queues = [] @@ -1246,15 +1190,13 @@ def test_container_identical(on_device): arr3 = ivy.array([3], device=on_device) container0 = Container({"a": arr1, "b": {"c": arr2, "d": arr3}}) container1 = Container({"a": arr1, "b": {"c": arr2, "d": arr3}}) - container2 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) + container2 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) container3 = Container({"b": {"d": arr3}}) container4 = Container({"d": arr3}) @@ -1277,40 +1219,34 @@ def test_container_identical(on_device): def test_container_identical_array_shapes(on_device): # without key_chains specification - container0 = Container( - { - "a": ivy.array([1, 2], device=on_device), - "b": { - "c": ivy.array([2, 3, 4], device=on_device), - "d": ivy.array([3, 4, 5, 6], device=on_device), - }, - } - ) - container1 = Container( - { - "a": ivy.array([1, 2, 3, 4], device=on_device), - "b": { - "c": ivy.array([3, 4], device=on_device), - "d": ivy.array([3, 4, 5], device=on_device), - }, - } - ) - container2 = Container( - { - "a": ivy.array([1, 2, 3, 4], device=on_device), - "b": { - "c": ivy.array([3, 4], device=on_device), - "d": ivy.array([3, 4, 5, 6], device=on_device), - }, - } - ) + container0 = Container({ + "a": ivy.array([1, 2], device=on_device), + "b": { + "c": ivy.array([2, 3, 4], device=on_device), + "d": ivy.array([3, 4, 5, 6], device=on_device), + }, + }) + container1 = Container({ + "a": ivy.array([1, 2, 3, 4], device=on_device), + "b": { + "c": ivy.array([3, 4], device=on_device), + "d": ivy.array([3, 4, 5], device=on_device), + }, + }) + container2 = Container({ + "a": ivy.array([1, 2, 3, 4], device=on_device), + "b": { + "c": ivy.array([3, 4], device=on_device), + "d": ivy.array([3, 4, 5, 6], device=on_device), + }, + }) # with identical assert ivy.Container.cont_identical_array_shapes([container0, container1]) assert ivy.Container.cont_identical_array_shapes([container1, container0]) - assert ivy.Container.cont_identical_array_shapes( - [container1, container0, container1] - ) + assert ivy.Container.cont_identical_array_shapes([ + container1, container0, container1 + ]) assert not ivy.Container.cont_identical([container0, container2]) assert not ivy.Container.cont_identical([container1, container2]) assert not ivy.Container.cont_identical([container0, container1, container2]) @@ -1328,51 +1264,43 @@ def test_container_identical_configs(on_device): # without identical assert not ivy.Container.cont_identical_configs([container1, container2]) - assert not ivy.Container.cont_identical_configs( - [container1, container0, container2] - ) + assert not ivy.Container.cont_identical_configs([ + container1, container0, container2 + ]) def test_container_identical_structure(on_device): # without key_chains specification - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container1 = Container( - { - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - } - ) - container2 = Container( - { - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - "e": ivy.array([6], device=on_device), - }, - } - ) - container3 = Container( - { - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container1 = Container({ + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + }) + container2 = Container({ + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), "e": ivy.array([6], device=on_device), - } - ) + }, + }) + container3 = Container({ + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + "e": ivy.array([6], device=on_device), + }) container4 = Container({"b": {"d": ivy.array([4], device=on_device)}}) container5 = Container({"d": ivy.array([4], device=on_device)}) @@ -1385,9 +1313,9 @@ def test_container_identical_structure(on_device): assert not ivy.Container.cont_identical_structure([container2, container3]) assert not ivy.Container.cont_identical_structure([container0, container3]) assert not ivy.Container.cont_identical_structure([container1, container2]) - assert not ivy.Container.cont_identical_structure( - [container1, container0, container2] - ) + assert not ivy.Container.cont_identical_structure([ + container1, container0, container2 + ]) # partial assert ivy.Container.cont_identical_structure( @@ -1448,26 +1376,22 @@ def test_container_if_exists(on_device): def test_container_inplace(on_device): - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([1], device=on_device), - "d": ivy.array([2], device=on_device), - }, - } - ) + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([1], device=on_device), + "d": ivy.array([2], device=on_device), + }, + }) const = 3 arr = ivy.array([1], device=on_device) - container1 = Container( - { - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - } - ) + container1 = Container({ + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + }) special_funcs = [ "__add__", @@ -1519,24 +1443,20 @@ def test_container_key_chains_containing(include_empty, on_device): def test_container_list_join(on_device): - container_0 = Container( - { - "a": [ivy.array([1], device=on_device)], - "b": { - "c": [ivy.array([2], device=on_device)], - "d": [ivy.array([3], device=on_device)], - }, - } - ) - container_1 = Container( - { - "a": [ivy.array([4], device=on_device)], - "b": { - "c": [ivy.array([5], device=on_device)], - "d": [ivy.array([6], device=on_device)], - }, - } - ) + container_0 = Container({ + "a": [ivy.array([1], device=on_device)], + "b": { + "c": [ivy.array([2], device=on_device)], + "d": [ivy.array([3], device=on_device)], + }, + }) + container_1 = Container({ + "a": [ivy.array([4], device=on_device)], + "b": { + "c": [ivy.array([5], device=on_device)], + "d": [ivy.array([6], device=on_device)], + }, + }) container_list_joined = ivy.Container.cont_list_join([container_0, container_1]) assert np.allclose(ivy.to_numpy(container_list_joined["a"][0]), np.array([1])) assert np.allclose(ivy.to_numpy(container_list_joined.a[0]), np.array([1])) @@ -1553,24 +1473,20 @@ def test_container_list_join(on_device): def test_container_list_stack(on_device): - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "d": ivy.array([6], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "d": ivy.array([6], device=on_device), + }, + }) container_list_stacked = ivy.Container.cont_list_stack( [container_0, container_1], 0 ) @@ -1679,12 +1595,10 @@ def test_container_map(inplace, on_device): assert "b/d" not in container_mapped # with sequences - container_orig = Container( - { - "a": ivy.array([1], device=on_device), - "b": [ivy.array([2], device=on_device), ivy.array([3], device=on_device)], - } - ) + container_orig = Container({ + "a": ivy.array([1], device=on_device), + "b": [ivy.array([2], device=on_device), ivy.array([3], device=on_device)], + }) container = container_orig.cont_deep_copy() container_mapped = container.cont_map( lambda x, _: x + 1, inplace=inplace, map_sequences=True @@ -1699,15 +1613,13 @@ def test_container_map(inplace, on_device): @pytest.mark.parametrize("inplace", [True, False]) def test_container_map_sub_conts(inplace, on_device): # without key_chains specification - container_orig = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) + container_orig = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) def _add_e_attr(cont_in): cont_in.e = ivy.array([4], device=on_device) @@ -1739,24 +1651,20 @@ def _add_e_attr(cont_in): def test_container_multi_map(on_device): # without key_chains specification - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container1 = Container( - { - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - } - ) + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container1 = Container({ + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + }) # with key_chains to apply container_mapped = ivy.Container.cont_multi_map( @@ -1770,24 +1678,20 @@ def test_container_multi_map(on_device): assert np.allclose(ivy.to_numpy(container_mapped.b.d), np.array([[8]])) # with sequences - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": [ - ivy.array([2], device=on_device), - ivy.array([3], device=on_device), - ], - } - ) - container1 = Container( - { - "a": ivy.array([3], device=on_device), - "b": [ - ivy.array([4], device=on_device), - ivy.array([5], device=on_device), - ], - } - ) + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": [ + ivy.array([2], device=on_device), + ivy.array([3], device=on_device), + ], + }) + container1 = Container({ + "a": ivy.array([3], device=on_device), + "b": [ + ivy.array([4], device=on_device), + ivy.array([5], device=on_device), + ], + }) container_mapped = ivy.Container.cont_multi_map( lambda x, _: x[0] + x[1], @@ -1865,21 +1769,17 @@ def test_container_overwrite_at_key_chain(on_device): def test_container_overwrite_at_key_chains(on_device): - container = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - target_container = Container( - { - "a": ivy.array([4], device=on_device), - "b": {"d": ivy.array([5], device=on_device)}, - } - ) + container = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + target_container = Container({ + "a": ivy.array([4], device=on_device), + "b": {"d": ivy.array([5], device=on_device)}, + }) new_container = container.cont_overwrite_at_key_chains( target_container, inplace=False ) @@ -2049,19 +1949,17 @@ def _test_bc_exception(container_in): def test_container_prune_key_from_key_chains(on_device): - container = Container( - { - "Ayy": ivy.array([1], device=on_device), - "Bee": { - "Cee": ivy.array([2], device=on_device), - "Dee": ivy.array([3], device=on_device), - }, - "Beh": { - "Ceh": ivy.array([4], device=on_device), - "Deh": ivy.array([5], device=on_device), - }, - } - ) + container = Container({ + "Ayy": ivy.array([1], device=on_device), + "Bee": { + "Cee": ivy.array([2], device=on_device), + "Dee": ivy.array([3], device=on_device), + }, + "Beh": { + "Ceh": ivy.array([4], device=on_device), + "Deh": ivy.array([5], device=on_device), + }, + }) # absolute container_pruned = container.cont_prune_key_from_key_chains("Bee") @@ -2138,16 +2036,14 @@ def _test_bd_exception(container_in): def test_container_prune_keys_from_key_chains(on_device): - container = Container( - { - "Ayy": ivy.array([1], device=on_device), - "Bee": { - "Cee": ivy.array([2], device=on_device), - "Dee": ivy.array([3], device=on_device), - }, - "Eee": {"Fff": ivy.array([4], device=on_device)}, - } - ) + container = Container({ + "Ayy": ivy.array([1], device=on_device), + "Bee": { + "Cee": ivy.array([2], device=on_device), + "Dee": ivy.array([3], device=on_device), + }, + "Eee": {"Fff": ivy.array([4], device=on_device)}, + }) # absolute container_pruned = container.cont_prune_keys_from_key_chains(["Bee", "Eee"]) @@ -2177,24 +2073,20 @@ def test_container_prune_keys_from_key_chains(on_device): def test_container_reduce(on_device): - container_a = ivy.Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_b = ivy.Container( - { - "a": ivy.array([2], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([6], device=on_device), - }, - } - ) + container_a = ivy.Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_b = ivy.Container({ + "a": ivy.array([2], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([6], device=on_device), + }, + }) res = ivy.Container.cont_reduce([container_a, container_b], lambda x: x[0] + x[1]) assert np.allclose(ivy.to_numpy(res.a), np.array([3.0])) assert np.allclose(ivy.to_numpy(res.b.c), np.array([6])) @@ -2202,15 +2094,13 @@ def test_container_reduce(on_device): def test_container_remove_key_length_limit(on_device): - cont = Container( - { - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - } - ) + cont = Container({ + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + }) cont.cont_with_key_length_limit(5, inplace=True) default_key_length_limit = cont._key_length_limit id_cont = id(cont) @@ -2227,15 +2117,13 @@ def test_container_remove_key_length_limit(on_device): def test_container_remove_print_limit(on_device): - cont = Container( - { - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - } - ) + cont = Container({ + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + }) default_print_limit = cont._print_limit id_cont = id(cont) cont1 = cont.cont_remove_print_limit() @@ -2251,15 +2139,13 @@ def test_container_remove_print_limit(on_device): def test_container_reshape_like(on_device): - container = Container( - { - "a": ivy.array([[1.0]], device=on_device), - "b": { - "c": ivy.array([[3.0], [4.0]], device=on_device), - "d": ivy.array([[5.0], [6.0], [7.0]], device=on_device), - }, - } - ) + container = Container({ + "a": ivy.array([[1.0]], device=on_device), + "b": { + "c": ivy.array([[3.0], [4.0]], device=on_device), + "d": ivy.array([[5.0], [6.0], [7.0]], device=on_device), + }, + }) new_shapes = Container({"a": (1,), "b": {"c": (1, 2, 1), "d": (3, 1, 1)}}) # without leading shape @@ -2272,24 +2158,22 @@ def test_container_reshape_like(on_device): assert list(container_reshaped.b.d.shape) == [3, 1, 1] # with leading shape - container = Container( - { - "a": ivy.array([[[1.0]], [[1.0]], [[1.0]]], device=on_device), - "b": { - "c": ivy.array( - [[[3.0], [4.0]], [[3.0], [4.0]], [[3.0], [4.0]]], device=on_device - ), - "d": ivy.array( - [ - [[5.0], [6.0], [7.0]], - [[5.0], [6.0], [7.0]], - [[5.0], [6.0], [7.0]], - ], - device=on_device, - ), - }, - } - ) + container = Container({ + "a": ivy.array([[[1.0]], [[1.0]], [[1.0]]], device=on_device), + "b": { + "c": ivy.array( + [[[3.0], [4.0]], [[3.0], [4.0]], [[3.0], [4.0]]], device=on_device + ), + "d": ivy.array( + [ + [[5.0], [6.0], [7.0]], + [[5.0], [6.0], [7.0]], + [[5.0], [6.0], [7.0]], + ], + device=on_device, + ), + }, + }) container_reshaped = container.cont_reshape_like(new_shapes, leading_shape=[3]) assert list(container_reshaped["a"].shape) == [3, 1] assert list(container_reshaped.a.shape) == [3, 1] @@ -2300,15 +2184,13 @@ def test_container_reshape_like(on_device): def test_container_restructure(on_device): - container = Container( - { - "a": ivy.array([[1, 2], [3, 4]], device=on_device), - "b": { - "c": ivy.array([[2, 4], [6, 8]], device=on_device), - "d": ivy.array([3, 6, 9, 12], device=on_device), - }, - } - ) + container = Container({ + "a": ivy.array([[1, 2], [3, 4]], device=on_device), + "b": { + "c": ivy.array([[2, 4], [6, 8]], device=on_device), + "d": ivy.array([3, 6, 9, 12], device=on_device), + }, + }) container_restructured = container.cont_restructure( { "a": {"key_chain": "A", "pattern": "a b -> b a"}, @@ -2341,15 +2223,13 @@ def test_container_restructure(on_device): def test_container_restructure_key_chains(on_device): # single - container = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) + container = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) container_restructured = container.cont_restructure_key_chains({"a": "A"}) assert np.allclose(ivy.to_numpy(container_restructured["A"]), np.array([[1]])) assert np.allclose(ivy.to_numpy(container_restructured.A), np.array([[1]])) @@ -2359,18 +2239,16 @@ def test_container_restructure_key_chains(on_device): assert np.allclose(ivy.to_numpy(container_restructured.b.d), np.array([[3]])) # full - container = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_restructured = container.cont_restructure_key_chains( - {"a": "A", "b/c": "B/C", "b/d": "B/D"} - ) + container = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_restructured = container.cont_restructure_key_chains({ + "a": "A", "b/c": "B/C", "b/d": "B/D" + }) assert np.allclose(ivy.to_numpy(container_restructured["A"]), np.array([[1]])) assert np.allclose(ivy.to_numpy(container_restructured.A), np.array([[1]])) assert np.allclose(ivy.to_numpy(container_restructured["B/C"]), np.array([[2]])) @@ -2422,21 +2300,17 @@ def test_container_set_at_key_chain(on_device): def test_container_set_at_key_chains(on_device): - container = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - target_container = Container( - { - "a": ivy.array([4], device=on_device), - "b": {"d": ivy.array([5], device=on_device)}, - } - ) + container = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + target_container = Container({ + "a": ivy.array([4], device=on_device), + "b": {"d": ivy.array([5], device=on_device)}, + }) new_container = container.cont_set_at_key_chains(target_container, inplace=False) assert np.allclose(ivy.to_numpy(new_container["a"]), np.array([4])) assert np.allclose(ivy.to_numpy(new_container["b"]["c"]), np.array([2])) @@ -2466,9 +2340,9 @@ def test_container_set_at_keys(on_device): assert np.allclose(ivy.to_numpy(container["b"]), np.array([4])) assert not container.cont_has_key("c") # noqa assert not container.cont_has_key("d") # noqa - container = orig_container.cont_set_at_keys( - {"a": ivy.array([5], device=on_device), "c": ivy.array([6], device=on_device)} - ) + container = orig_container.cont_set_at_keys({ + "a": ivy.array([5], device=on_device), "c": ivy.array([6], device=on_device) + }) assert np.allclose(ivy.to_numpy(container["a"]), np.array([5])) assert np.allclose(ivy.to_numpy(container["b"]["c"]), np.array([6])) assert np.allclose(ivy.to_numpy(container["b"]["d"]), np.array([3])) @@ -2593,9 +2467,9 @@ def test_container_slice_keys(str_slice, on_device): # with dict, depth 0 sub_cont = Container({"a": a_val, "b": b_val, "c": c_val, "d": d_val, "e": e_val}) - cont = Container( - {"a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont} - ) + cont = Container({ + "a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont + }) cont_sliced = cont.cont_slice_keys({0: slc}) assert "a" not in cont_sliced assert Container.cont_identical([cont_sliced.b, sub_cont]) @@ -2606,9 +2480,9 @@ def test_container_slice_keys(str_slice, on_device): # with dict, depth 1 sub_cont = Container({"a": a_val, "b": b_val, "c": c_val, "d": d_val, "e": e_val}) sub_sub_cont = Container({"b": b_val, "c": c_val, "d": d_val}) - cont = Container( - {"a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont} - ) + cont = Container({ + "a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont + }) cont_sliced = cont.cont_slice_keys({1: slc}) assert Container.cont_identical([cont_sliced.a, sub_sub_cont]) assert Container.cont_identical([cont_sliced.b, sub_sub_cont]) @@ -2619,9 +2493,9 @@ def test_container_slice_keys(str_slice, on_device): # with dict, depth 0, 1 sub_cont = Container({"a": a_val, "b": b_val, "c": c_val, "d": d_val, "e": e_val}) sub_sub_cont = Container({"b": b_val, "c": c_val, "d": d_val}) - cont = Container( - {"a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont} - ) + cont = Container({ + "a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont + }) cont_sliced = cont.cont_slice_keys({0: slc, 1: slc}) assert "a" not in cont_sliced assert Container.cont_identical([cont_sliced.b, sub_sub_cont]) @@ -2632,9 +2506,9 @@ def test_container_slice_keys(str_slice, on_device): # all depths sub_cont = Container({"a": a_val, "b": b_val, "c": c_val, "d": d_val, "e": e_val}) sub_sub_cont = Container({"b": b_val, "c": c_val, "d": d_val}) - cont = Container( - {"a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont} - ) + cont = Container({ + "a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont + }) cont_sliced = cont.cont_slice_keys(slc, all_depths=True) assert "a" not in cont_sliced assert Container.cont_identical([cont_sliced.b, sub_sub_cont]) @@ -2716,24 +2590,20 @@ def test_container_split_conts(on_device): def test_container_structural_diff(on_device): # all different keys or shapes - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([[4]], device=on_device), - "b": { - "c": ivy.array([[[5]]], device=on_device), - "e": ivy.array([3], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([[4]], device=on_device), + "b": { + "c": ivy.array([[[5]]], device=on_device), + "e": ivy.array([3], device=on_device), + }, + }) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a.diff_0), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.a.diff_1), np.array([[4]])) @@ -2751,24 +2621,20 @@ def test_container_structural_diff(on_device): assert container_diff_same_only.cont_to_dict() == {} # some different shapes - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([[5]], device=on_device), - "d": ivy.array([6], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([[5]], device=on_device), + "d": ivy.array([6], device=on_device), + }, + }) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c.diff_0), np.array([2])) @@ -2790,24 +2656,20 @@ def test_container_structural_diff(on_device): assert "d" in container_diff_same_only["b"] # all different keys - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "e": ivy.array([4], device=on_device), - "f": { - "g": ivy.array([5], device=on_device), - "h": ivy.array([6], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "e": ivy.array([4], device=on_device), + "f": { + "g": ivy.array([5], device=on_device), + "h": ivy.array([6], device=on_device), + }, + }) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a.diff_0), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.diff_0.c), np.array([2])) @@ -2825,24 +2687,20 @@ def test_container_structural_diff(on_device): assert container_diff_same_only.cont_to_dict() == {} # some different keys - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "e": ivy.array([6], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "e": ivy.array([6], device=on_device), + }, + }) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c), np.array([2])) @@ -2866,24 +2724,20 @@ def test_container_structural_diff(on_device): assert "e" not in container_diff_same_only["b"] # all same - container_0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - } - ) - container_1 = Container( - { - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "d": ivy.array([6], device=on_device), - }, - } - ) + container_0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + }) + container_1 = Container({ + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "d": ivy.array([6], device=on_device), + }, + }) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c), np.array([2])) @@ -3025,18 +2879,16 @@ def test_container_to_and_from_disk_as_pickled(on_device): def test_container_to_dict(on_device): - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([True], device=on_device), - "d": { - "g": ivy.array([2.0], device=on_device), - "h": ivy.array([3], device=on_device), - }, + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([True], device=on_device), + "d": { + "g": ivy.array([2.0], device=on_device), + "h": ivy.array([3], device=on_device), }, - } - ) + }, + }) res = ivy.Container.cont_to_dict(container0) assert res == {"a": 1, "b": {"c": True, "d": {"g": 2.0, "h": 3}}} @@ -3168,18 +3020,16 @@ def test_container_to_iterator_values(include_empty, on_device): def test_container_to_nested_list(on_device): - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([True], device=on_device), - "d": { - "g": ivy.array([2.0], device=on_device), - "h": ivy.array([3], device=on_device), - }, + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([True], device=on_device), + "d": { + "g": ivy.array([2.0], device=on_device), + "h": ivy.array([3], device=on_device), }, - } - ) + }, + }) res = ivy.Container.cont_to_nested_list(container0) assert res == [1, [True, [2.0, 3]]] @@ -3204,15 +3054,13 @@ def test_container_trim_key(on_device): def test_container_try_kc(on_device): - cont = Container( - { - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - } - ) + cont = Container({ + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + }) assert cont.cont_try_kc("a") == cont.a assert cont.cont_try_kc("b/c") == cont.b.c assert cont.cont_try_kc("b/d") == cont.b.d @@ -3225,25 +3073,21 @@ def test_container_unify(on_device): dev0 = on_device on_devices.append(dev0) conts = {} - conts[dev0] = Container( - { - "a": ivy.array([1], device=dev0), - "b": {"c": ivy.array([2], device=dev0), "d": ivy.array([3], device=dev0)}, - } - ) + conts[dev0] = Container({ + "a": ivy.array([1], device=dev0), + "b": {"c": ivy.array([2], device=dev0), "d": ivy.array([3], device=dev0)}, + }) if "gpu" in on_device and ivy.num_gpus() > 1: idx = ivy.num_gpus() - 1 dev1 = on_device[:-1] + str(idx) on_devices.append(dev1) - conts[dev1] = Container( - { - "a": ivy.array([4], device=dev1), - "b": { - "c": ivy.array([5], device=dev1), - "d": ivy.array([6], device=dev1), - }, - } - ) + conts[dev1] = Container({ + "a": ivy.array([4], device=dev1), + "b": { + "c": ivy.array([5], device=dev1), + "d": ivy.array([6], device=dev1), + }, + }) # test container_unified = ivy.Container.cont_unify(conts, dev0, "concat", 0) @@ -3278,15 +3122,13 @@ def test_container_unstack_conts(on_device): def test_container_with_default_key_color(on_device): - cont = Container( - { - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - } - ) + cont = Container({ + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + }) default_default_key_color = cont._default_key_color id_cont = id(cont) cont1 = cont.cont_with_default_key_color("red") @@ -3318,15 +3160,13 @@ def test_container_with_entries_as_lists(on_device): def test_container_with_ivy_backend(on_device): - container0 = Container( - { - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([1], device=on_device), - "d": ivy.array([2], device=on_device), - }, - } - ) + container0 = Container({ + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([1], device=on_device), + "d": ivy.array([2], device=on_device), + }, + }) id_container0 = id(container0) container0 = ivy.Container.cont_with_ivy_backend(container0, "numpy") assert container0.cont_config["ivyh"] == "numpy" @@ -3338,15 +3178,13 @@ def test_container_with_ivy_backend(on_device): def test_container_with_key_length_limit(on_device): - cont = Container( - { - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - } - ) + cont = Container({ + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + }) default_key_length_limit = cont._key_length_limit id_cont = id(cont) cont1 = cont.cont_with_key_length_limit(5) @@ -3362,15 +3200,13 @@ def test_container_with_key_length_limit(on_device): def test_container_with_print_indent(on_device): - cont = Container( - { - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - } - ) + cont = Container({ + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + }) default_print_indent = cont._print_indent id_cont = id(cont) cont1 = cont.cont_with_print_indent(default_print_indent + 5) @@ -3386,15 +3222,13 @@ def test_container_with_print_indent(on_device): def test_container_with_print_limit(on_device): - cont = Container( - { - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - } - ) + cont = Container({ + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + }) default_print_limit = cont._print_limit id_cont = id(cont) cont1 = cont.cont_with_print_limit(default_print_limit + 5) @@ -3409,15 +3243,13 @@ def test_container_with_print_limit(on_device): def test_container_with_print_line_spacing(on_device): - cont = Container( - { - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - } - ) + cont = Container({ + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + }) default_print_line_spacing = cont._print_line_spacing id_cont = id(cont) cont1 = cont.cont_with_print_line_spacing(default_print_line_spacing + 5) diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py index bb03df0116781..1e2efc8fdb98c 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py @@ -7,9 +7,9 @@ @pytest.mark.parametrize(("shape", "rank"), [((5, 4, 6), (3, 2, 3))]) def test_n_param_tucker(shape, rank): tucker_tensor = ivy.random_tucker(shape, rank) - true_n_param = ivy.prod(ivy.shape(tucker_tensor[0])) + ivy.sum( - [ivy.prod(ivy.shape(f)) for f in tucker_tensor[1]] - ) + true_n_param = ivy.prod(ivy.shape(tucker_tensor[0])) + ivy.sum([ + ivy.prod(ivy.shape(f)) for f in tucker_tensor[1] + ]) n_param = tucker_tensor.n_param assert np.allclose(n_param, true_n_param) diff --git a/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py b/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py index 2c379e20e8b51..b13bf4d6915b1 100644 --- a/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py +++ b/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py @@ -67,17 +67,15 @@ def test_non_ivy_errors_mapping(e, to_be_raised): @given( - e=st.sampled_from( - [ - Exception, - ZeroDivisionError, - BufferError, - AssertionError, - ImportError, - KeyError, - LookupError, - ] - ) + e=st.sampled_from([ + Exception, + ZeroDivisionError, + BufferError, + AssertionError, + ImportError, + KeyError, + LookupError, + ]) ) def test_non_ivy_errors_raising(e): with pytest.raises(IvyBackendException): diff --git a/ivy_tests/test_ivy/test_stateful/test_layers.py b/ivy_tests/test_ivy/test_stateful/test_layers.py index 0a11d31645424..1fae883a74d60 100644 --- a/ivy_tests/test_ivy/test_stateful/test_layers.py +++ b/ivy_tests/test_ivy/test_stateful/test_layers.py @@ -1555,20 +1555,18 @@ def test_multi_head_attention_layer( # # Sequential # @handle_method( method_tree="Sequential.__call__", - bs_c_target=st.sampled_from( - [ - ( - [1, 2], - 5, + bs_c_target=st.sampled_from([ + ( + [1, 2], + 5, + [ [ - [ - [-0.34784955, 0.47909835, 0.7241975, -0.82175905, -0.43836743], - [-0.34784955, 0.47909835, 0.7241975, -0.82175905, -0.43836743], - ] - ], - ) - ] - ), + [-0.34784955, 0.47909835, 0.7241975, -0.82175905, -0.43836743], + [-0.34784955, 0.47909835, 0.7241975, -0.82175905, -0.43836743], + ] + ], + ) + ]), with_v=st.booleans(), seq_v=st.booleans(), dtype=helpers.get_dtypes("float", full=False, none=True), @@ -1609,36 +1607,34 @@ def test_sequential_layer( if with_v: np.random.seed(0) wlim = (6 / (channels + channels)) ** 0.5 - v = Container( - { - "submodules": { - "v0": { - "w": _variable( - ivy.array( - np.random.uniform(-wlim, wlim, (channels, channels)), - dtype=dtype, - device=on_device, - ) - ), - "b": _variable( - ivy.zeros([channels], device=on_device, dtype=dtype) - ), - }, - "v2": { - "w": _variable( - ivy.array( - np.random.uniform(-wlim, wlim, (channels, channels)), - dtype=dtype, - device=on_device, - ) - ), - "b": _variable( - ivy.zeros([channels], device=on_device, dtype=dtype) - ), - }, - } + v = Container({ + "submodules": { + "v0": { + "w": _variable( + ivy.array( + np.random.uniform(-wlim, wlim, (channels, channels)), + dtype=dtype, + device=on_device, + ) + ), + "b": _variable( + ivy.zeros([channels], device=on_device, dtype=dtype) + ), + }, + "v2": { + "w": _variable( + ivy.array( + np.random.uniform(-wlim, wlim, (channels, channels)), + dtype=dtype, + device=on_device, + ) + ), + "b": _variable( + ivy.zeros([channels], device=on_device, dtype=dtype) + ), + }, } - ) + }) else: v = None if seq_v: diff --git a/ivy_tests/test_ivy/test_stateful/test_modules.py b/ivy_tests/test_ivy/test_stateful/test_modules.py index 1a361cba5fa42..2b61e72b22645 100644 --- a/ivy_tests/test_ivy/test_stateful/test_modules.py +++ b/ivy_tests/test_ivy/test_stateful/test_modules.py @@ -149,15 +149,13 @@ def _forward(): @given( - buffer=st.just( - [ - { - "var1": [ - ivy.ones((1, 2)), - ] - } - ] - ) + buffer=st.just([ + { + "var1": [ + ivy.ones((1, 2)), + ] + } + ]) ) def test_get_buffers(buffer, backend_fw): with ivy.utils.backend.ContextManager(backend_fw): @@ -479,24 +477,18 @@ def test_module_track_submod_call_order( assert dl1_key_0 in sm_co[root_key_0] assert dl1_key_1 in sm_co[root_key_0] - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl0_key_0], - module._dl0.v.cont_flatten_key_chains().to_numpy(), - ] - ) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl1_key_0], - module._dl1.v.cont_flatten_key_chains().to_numpy(), - ] - ) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl1_key_1], - module._dl1.v.cont_flatten_key_chains().to_numpy(), - ] - ) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl0_key_0], + module._dl0.v.cont_flatten_key_chains().to_numpy(), + ]) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl1_key_0], + module._dl1.v.cont_flatten_key_chains().to_numpy(), + ]) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl1_key_1], + module._dl1.v.cont_flatten_key_chains().to_numpy(), + ]) # depth 2 (full) ret = module(x, track_submod_call_order=True) @@ -517,42 +509,30 @@ def test_module_track_submod_call_order( assert dl1_l0_key_0 in sm_co[root_key_0][dl1_key_1] assert dl1_l1_key_0 in sm_co[root_key_0][dl1_key_1] - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl0_key_0][dl0_l0_key_0], - module._dl0._l0.v.cont_flatten_key_chains().to_numpy(), - ] - ) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl0_key_0][dl0_l1_key_0], - module._dl0._l1.v.cont_flatten_key_chains().to_numpy(), - ] - ) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl1_key_0][dl1_l0_key_0], - module._dl1._l0.v.cont_flatten_key_chains().to_numpy(), - ] - ) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl1_key_0][dl1_l1_key_0], - module._dl1._l1.v.cont_flatten_key_chains().to_numpy(), - ] - ) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl1_key_1][dl1_l0_key_0], - module._dl1._l0.v.cont_flatten_key_chains().to_numpy(), - ] - ) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl1_key_1][dl1_l1_key_0], - module._dl1._l1.v.cont_flatten_key_chains().to_numpy(), - ] - ) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl0_key_0][dl0_l0_key_0], + module._dl0._l0.v.cont_flatten_key_chains().to_numpy(), + ]) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl0_key_0][dl0_l1_key_0], + module._dl0._l1.v.cont_flatten_key_chains().to_numpy(), + ]) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl1_key_0][dl1_l0_key_0], + module._dl1._l0.v.cont_flatten_key_chains().to_numpy(), + ]) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl1_key_0][dl1_l1_key_0], + module._dl1._l1.v.cont_flatten_key_chains().to_numpy(), + ]) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl1_key_1][dl1_l0_key_0], + module._dl1._l0.v.cont_flatten_key_chains().to_numpy(), + ]) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl1_key_1][dl1_l1_key_0], + module._dl1._l1.v.cont_flatten_key_chains().to_numpy(), + ]) # partial submodules ret = module( @@ -572,25 +552,19 @@ def test_module_track_submod_call_order( assert dl0_l0_key_0 in sm_co[root_key_0][dl0_key_0] assert dl0_l1_key_0 not in sm_co[root_key_0][dl0_key_0] - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl1_key_0], - module._dl1.v.cont_flatten_key_chains().to_numpy(), - ] - ) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl1_key_1], - module._dl1.v.cont_flatten_key_chains().to_numpy(), - ] - ) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl1_key_0], + module._dl1.v.cont_flatten_key_chains().to_numpy(), + ]) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl1_key_1], + module._dl1.v.cont_flatten_key_chains().to_numpy(), + ]) - assert ivy.Container.cont_identical( - [ - sm_co[root_key_0][dl0_key_0][dl0_l0_key_0], - module._dl0._l0.v.cont_flatten_key_chains().to_numpy(), - ] - ) + assert ivy.Container.cont_identical([ + sm_co[root_key_0][dl0_key_0][dl0_l0_key_0], + module._dl0._l0.v.cont_flatten_key_chains().to_numpy(), + ]) # track submod returns @@ -936,23 +910,21 @@ def test_module_w_partial_v( ivy.linspace(ivy.zeros(batch_shape), ivy.ones(batch_shape), input_channels), "float32", ) - v = ivy.Container( - { - "linear0": { - "b": _variable(ivy.random_uniform(shape=[64])), - "w": _variable(ivy.random_uniform(shape=[64, 4])), - }, - "linear1": { - "b": _variable(ivy.random_uniform(shape=[64])), - "w": _variable(ivy.random_uniform(shape=[64, 64])), - "extra": _variable(ivy.random_uniform(shape=[64, 64])), - }, - "linear2": { - "b": _variable(ivy.random_uniform(shape=[5])), - "w": _variable(ivy.random_uniform(shape=[5, 64])), - }, - } - ) + v = ivy.Container({ + "linear0": { + "b": _variable(ivy.random_uniform(shape=[64])), + "w": _variable(ivy.random_uniform(shape=[64, 4])), + }, + "linear1": { + "b": _variable(ivy.random_uniform(shape=[64])), + "w": _variable(ivy.random_uniform(shape=[64, 64])), + "extra": _variable(ivy.random_uniform(shape=[64, 64])), + }, + "linear2": { + "b": _variable(ivy.random_uniform(shape=[5])), + "w": _variable(ivy.random_uniform(shape=[5, 64])), + }, + }) try: TrainableModule( input_channels, @@ -967,17 +939,13 @@ def test_module_w_partial_v( ) except ivy.utils.exceptions.IvyException: pass - v = ivy.Container( - { - "linear0": { - "b": _variable(ivy.random_uniform(shape=[64])), - }, - "linear1": {"w": _variable(ivy.random_uniform(shape=[64, 64]))}, - "linear2": { - "b": _variable(ivy.random_uniform(shape=[output_channels])) - }, - } - ) + v = ivy.Container({ + "linear0": { + "b": _variable(ivy.random_uniform(shape=[64])), + }, + "linear1": {"w": _variable(ivy.random_uniform(shape=[64, 64]))}, + "linear2": {"b": _variable(ivy.random_uniform(shape=[output_channels]))}, + }) try: TrainableModule(input_channels, output_channels, device=on_device, v=v) raise Exception( diff --git a/scripts/backend_generation/generate.py b/scripts/backend_generation/generate.py index 152bd5801cdd5..ef2a7af9789f9 100644 --- a/scripts/backend_generation/generate.py +++ b/scripts/backend_generation/generate.py @@ -154,9 +154,9 @@ def _should_install_backend(package_name): if ret.lower() == "y": try: # Install backend - subprocess.check_call( - [sys.executable, "-m", "pip", "install", package_name] - ) + subprocess.check_call([ + sys.executable, "-m", "pip", "install", package_name + ]) global _backend_is_installed _backend_is_installed = True with open("../../requirements/optional.txt", "a") as reqr_file: diff --git a/scripts/backend_generation/tree_generation.py b/scripts/backend_generation/tree_generation.py index c763af66cce48..871ef7abbc343 100644 --- a/scripts/backend_generation/tree_generation.py +++ b/scripts/backend_generation/tree_generation.py @@ -289,17 +289,15 @@ def generate(config_file): generated_file.write(astunparse.unparse(tree_to_write)) subprocess.run(["black", "-q", backend_generation_path]) - subprocess.run( - [ - "autoflake", - "-i", - "--remove-all-unused-imports", - "--ignore-init-module-imports", - "--quiet", - "-r", - backend_generation_path, - ] - ) + subprocess.run([ + "autoflake", + "-i", + "--remove-all-unused-imports", + "--ignore-init-module-imports", + "--quiet", + "-r", + backend_generation_path, + ]) if __name__ == "__main__": diff --git a/scripts/determine_tests/determine_tests.py b/scripts/determine_tests/determine_tests.py index ef60b4d28c335..fb0c284001f11 100644 --- a/scripts/determine_tests/determine_tests.py +++ b/scripts/determine_tests/determine_tests.py @@ -100,13 +100,13 @@ def main(): # if it is a PR, we must check that the tests added were in the files_changes if len(sys.argv) >= 3 and sys.argv[2] == "pr": relevant_added_tests = [] - subprocess.run( - ["git", "remote", "add", "upstream", "https://github.com/unifyai/ivy"] - ) + subprocess.run([ + "git", "remote", "add", "upstream", "https://github.com/unifyai/ivy" + ]) subprocess.run(["git", "fetch", "upstream"]) - lca_sha = subprocess.check_output( - ["git", "merge-base", "HEAD", "upstream/main"] - ) + lca_sha = subprocess.check_output([ + "git", "merge-base", "HEAD", "upstream/main" + ]) lca_hash = lca_sha.decode().strip() for commit in Repository(".", single=lca_hash).traverse_commits(): lca_commit = commit._c_object From 722b91179d0b62bf5204738c7e69b37444f2fdb6 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 10 Nov 2023 19:40:12 +0530 Subject: [PATCH 150/978] fix: Fixed wrong key-word arguments when calling the function `helpers.dtype_and_values()` (#27238) --- .../test_sums_products_differences.py | 2 +- .../test_ivy/test_functional/test_core/test_elementwise.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_sums_products_differences.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_sums_products_differences.py index 76686c58f938d..548b02bbf5dd0 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_sums_products_differences.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_sums_products_differences.py @@ -19,7 +19,7 @@ def _either_x_dx(draw): if rand == 0: either_x_dx = draw( helpers.dtype_and_values( - avaliable_dtypes=st.shared( + available_dtypes=st.shared( helpers.get_dtypes("float"), key="trapz_dtype" ), min_value=-100, diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index bb2fd1c5695bb..fb899fd9a1196 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -42,7 +42,7 @@ def _either_x_dx(draw): if rand == 0: either_x_dx = draw( helpers.dtype_and_values( - avaliable_dtypes=st.shared( + available_dtypes=st.shared( helpers.get_dtypes("float"), key="trapz_dtype" ), min_value=-100, From 3678f56e2d60be5ab5065905a6eb2f4eb008c27c Mon Sep 17 00:00:00 2001 From: Aaryan562 <82304628+Aaryan562@users.noreply.github.com> Date: Sat, 11 Nov 2023 14:01:04 +0530 Subject: [PATCH 151/978] fix: failing test for sin (#27156) --- .../test_ivy/test_functional/test_core/test_elementwise.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index fb899fd9a1196..89071dec7917e 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1775,6 +1775,8 @@ def test_sign(*, dtype_and_x, np_variant, test_flags, backend_fw, fn_name, on_de ) def test_sin(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): input_dtype, x = dtype_and_x + if "paddle" in backend_fw and input_dtype[0] == "float16": + assume(not test_flags.test_gradients) helpers.test_function( input_dtypes=input_dtype, test_flags=test_flags, From 6cb4b26a014c7b839d9eba81f1e7e7415a876cb6 Mon Sep 17 00:00:00 2001 From: usayrimrehman <80469631+usayrimrehman@users.noreply.github.com> Date: Sat, 11 Nov 2023 18:19:51 +0300 Subject: [PATCH 152/978] sequence_mask (#21087) Co-authored-by: ivy-branch Co-authored-by: Kareem Morsy --- .../frontends/tensorflow/general_functions.py | 28 +++++++++ .../test_tensorflow/test_general_functions.py | 62 +++++++++++++++++++ 2 files changed, 90 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/general_functions.py b/ivy/functional/frontends/tensorflow/general_functions.py index 4464816ce98f1..6307a35369870 100644 --- a/ivy/functional/frontends/tensorflow/general_functions.py +++ b/ivy/functional/frontends/tensorflow/general_functions.py @@ -409,6 +409,34 @@ def searchsorted(sorted_sequence, values, side="left", out_type="int32"): return ivy.searchsorted(sorted_sequence, values, side=side, ret_dtype=out_type) +@with_supported_dtypes( + {"2.14.0 and below": ("int8", "int16", "int32", "int64")}, "tensorflow" +) +@to_ivy_arrays_and_back +def sequence_mask(lengths, maxlen=None, dtype=ivy.bool, name=None): + if maxlen is None: + maxlen = ivy.maximum( + ivy.max(lengths), ivy.max(ivy.arange(ivy.get_num_dims(lengths))) + ) + maxlen = ivy.maximum(0, maxlen) + else: + maxlen = ivy.array(maxlen) + if ivy.get_num_dims(maxlen) is not None and ivy.get_num_dims(maxlen) != 0: + raise ValueError( + "Argument `maxlen` must be scalar for sequence_mask, " + f"received `maxlen` = {maxlen} " + f"with shape '{maxlen.get_shape()}' instead" + ) + + row_vector = ivy.arange(0, int(maxlen), 1) + matrix = ivy.expand_dims(lengths, axis=-1) + result = row_vector < matrix + if dtype is None: + return result + else: + return ivy.astype(result, dtype) + + @to_ivy_arrays_and_back def shape(input, out_type=ivy.int32, name=None): out_type = to_ivy_dtype(out_type) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py index 7c506041277e8..b2c34a7f62464 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py @@ -268,6 +268,40 @@ def _reshape_helper(draw): return x, dtype, reshape_shape +# sequence_mask +@st.composite +def _sequence_mask_helper(draw): + max_val = draw(st.integers(min_value=1, max_value=100000)) + in_dtype, lens = draw( + helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=1, + min_value=-max_val, + max_value=max_val, + ) + ) + + max_len = draw(st.integers(min_value=max_val, max_value=max_val)) + dtype = draw( + st.sampled_from( + [ + "float16", + "uint8", + "complex128", + "bool", + "float64", + "int8", + "int16", + "complex64", + "float32", + "int32", + "int64", + ] + ) + ) + return in_dtype, lens, max_len, dtype + + @st.composite def _slice_helper(draw): dtype, x, shape = draw( @@ -1699,6 +1733,34 @@ def test_tensorflow_searchsorted( ) +@handle_frontend_test( + fn_tree="tensorflow.sequence_mask", + dtype_lens_maxlen=_sequence_mask_helper(), + test_with_out=st.just(False), +) +def test_tensorflow_sequence_mask( + *, + dtype_lens_maxlen, + frontend, + test_flags, + fn_tree, + on_device, + backend_fw, +): + input_dtype, lens, max_len, dtype = dtype_lens_maxlen + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + lengths=lens[0], + maxlen=max_len, + dtype=dtype, + ) + + # shape @handle_frontend_test( fn_tree="tensorflow.shape", From 365cfd9b20cc78b009e704bdf0d9de11bb89ba70 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 11 Nov 2023 15:21:25 +0000 Subject: [PATCH 153/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../test_tensorflow/test_general_functions.py | 28 +++++++++---------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py index b2c34a7f62464..436047049f5e4 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py @@ -283,21 +283,19 @@ def _sequence_mask_helper(draw): max_len = draw(st.integers(min_value=max_val, max_value=max_val)) dtype = draw( - st.sampled_from( - [ - "float16", - "uint8", - "complex128", - "bool", - "float64", - "int8", - "int16", - "complex64", - "float32", - "int32", - "int64", - ] - ) + st.sampled_from([ + "float16", + "uint8", + "complex128", + "bool", + "float64", + "int8", + "int16", + "complex64", + "float32", + "int32", + "int64", + ]) ) return in_dtype, lens, max_len, dtype From 3b953739e89b850e3752f9ad1eca321072b9d952 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 13 Nov 2023 14:31:47 +0530 Subject: [PATCH 154/978] feat(ci): Added readonly access to the database from PRs to allow the display of whether a test failure in a PR is a test failure on main as well (#27252) --- scripts/run_tests/run_tests_pr.py | 32 +++++++++++++++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-) diff --git a/scripts/run_tests/run_tests_pr.py b/scripts/run_tests/run_tests_pr.py index a910ad80f2803..1dba125255336 100644 --- a/scripts/run_tests/run_tests_pr.py +++ b/scripts/run_tests/run_tests_pr.py @@ -1,23 +1,51 @@ # Run Tests import os import sys +from pymongo import MongoClient + +from scripts.run_tests.run_tests import ( + get_latest_package_version, + get_submodule_and_function_name, +) if __name__ == "__main__": failed = False + cluster = MongoClient( + "mongodb+srv://readonly-user:hvpwV5yVeZdgyTTm@cluster0.qdvf8q3.mongodb.net" + ) + db = cluster["ci_dashboard"] with open(sys.argv[1], "w") as f_write: with open("tests_to_run", "r") as f: for line in f: - test, backend = line.split(",") + test_path, backend = line.strip().split(",") + is_frontend_test = "test_frontends" in test_path + collection = ( + db["frontend_tests"] if is_frontend_test else db["ivy_tests"] + ) + submodule, function_name = get_submodule_and_function_name( + test_path, is_frontend_test + ) + version = get_latest_package_version(backend).replace(".", "_") print(f"\n{'*' * 100}") print(f"{line[:-1]}") print(f"{'*' * 100}\n") sys.stdout.flush() ret = os.system( - f'docker run --rm -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis unifyai/ivy:latest python3 -m pytest --tb=short {test} --skip-trace-testing --backend {backend}' # noqa + f'docker run --rm -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis unifyai/ivy:latest python3 -m pytest --tb=short {test_path} --skip-trace-testing --backend {backend}' # noqa ) if ret != 0: failed = True + document = collection.find_one({"_id": function_name}) + if document: + try: + if document[backend][version]["status"]["cpu"]: + line = line.strip("\n") + " (main: pass)\n" + except KeyError: + print( + f"Could not find {backend}.{version}.status.cpu for" + f" document : {document}" + ) f_write.write(line) if failed: From 2f8694ed5e649aea1e8bb268f2ac057a82c4ddb6 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 13 Nov 2023 15:48:02 +0530 Subject: [PATCH 155/978] fix(ci): Added pymongo installation to intelligent-tests-pr.yml --- .github/workflows/intelligent-tests-pr.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index 5da9fa05de9f2..2ec7ebd720429 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -83,7 +83,7 @@ jobs: id: tests run: | git clone -b master${{ matrix.branch }} https://github.com/unifyai/Mapping.git --depth 1 - pip install pydriller GitPython + pip install pydriller GitPython pymongo python ivy/scripts/setup_tests/clone-mapping.py cp Mapping/tests.pbz2 ivy/ cd ivy From 084085b3b6e56e3a1b1307ad78de1595173c2dab Mon Sep 17 00:00:00 2001 From: Aaryan562 <82304628+Aaryan562@users.noreply.github.com> Date: Mon, 13 Nov 2023 19:21:23 +0530 Subject: [PATCH 156/978] feat: update jax version to 0.4.20 (#27243) --- ivy/functional/backends/jax/__init__.py | 24 ++++---- ivy/functional/backends/jax/elementwise.py | 28 +++++----- .../backends/jax/experimental/elementwise.py | 2 +- .../backends/jax/experimental/layers.py | 6 +- .../backends/jax/experimental/random.py | 2 +- .../backends/jax/experimental/sorting.py | 2 +- .../backends/jax/experimental/statistical.py | 6 +- ivy/functional/backends/jax/general.py | 4 +- ivy/functional/backends/jax/linear_algebra.py | 56 +++++++++---------- ivy/functional/backends/jax/manipulation.py | 2 +- ivy/functional/backends/jax/random.py | 2 +- ivy/functional/backends/jax/searching.py | 4 +- ivy/functional/backends/jax/sorting.py | 2 +- ivy/functional/backends/jax/statistical.py | 4 +- ivy/functional/frontends/jax/lax/operators.py | 8 +-- .../jax/nn/non_linear_activations.py | 2 +- .../frontends/jax/numpy/creation.py | 6 +- ivy/functional/frontends/jax/numpy/linalg.py | 4 +- ivy/functional/frontends/jax/numpy/logic.py | 4 +- .../jax/numpy/mathematical_functions.py | 12 ++-- .../frontends/jax/numpy/searching_sorting.py | 4 +- .../frontends/jax/numpy/statistical.py | 6 +- ivy/functional/frontends/jax/random.py | 32 +++++------ 23 files changed, 111 insertions(+), 111 deletions(-) diff --git a/ivy/functional/backends/jax/__init__.py b/ivy/functional/backends/jax/__init__.py index 74d697ec9be9c..ca2e47c668e58 100644 --- a/ivy/functional/backends/jax/__init__.py +++ b/ivy/functional/backends/jax/__init__.py @@ -101,7 +101,7 @@ def _array_unflatten(aux_data, children): # update these to add new dtypes valid_dtypes = { - "0.4.19 and below": ( + "0.4.20 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -120,7 +120,7 @@ def _array_unflatten(aux_data, children): ) } valid_numeric_dtypes = { - "0.4.19 and below": ( + "0.4.20 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -139,7 +139,7 @@ def _array_unflatten(aux_data, children): } valid_int_dtypes = { - "0.4.19 and below": ( + "0.4.20 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -152,12 +152,12 @@ def _array_unflatten(aux_data, children): } valid_uint_dtypes = { - "0.4.19 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) + "0.4.20 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) } valid_float_dtypes = { - "0.4.19 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) + "0.4.20 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) } -valid_complex_dtypes = {"0.4.19 and below": (ivy.complex64, ivy.complex128)} +valid_complex_dtypes = {"0.4.20 and below": (ivy.complex64, ivy.complex128)} # leave these untouched @@ -172,12 +172,12 @@ def _array_unflatten(aux_data, children): # invalid data types # update these to add new dtypes -invalid_dtypes = {"0.4.19 and below": ()} -invalid_numeric_dtypes = {"0.4.19 and below": ()} -invalid_int_dtypes = {"0.4.19 and below": ()} -invalid_float_dtypes = {"0.4.19 and below": ()} -invalid_uint_dtypes = {"0.4.19 and below": ()} -invalid_complex_dtypes = {"0.4.19 and below": ()} +invalid_dtypes = {"0.4.20 and below": ()} +invalid_numeric_dtypes = {"0.4.20 and below": ()} +invalid_int_dtypes = {"0.4.20 and below": ()} +invalid_float_dtypes = {"0.4.20 and below": ()} +invalid_uint_dtypes = {"0.4.20 and below": ()} +invalid_complex_dtypes = {"0.4.20 and below": ()} # leave these untouched invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index f00c00b4443bf..23e3211ccffb5 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -72,7 +72,7 @@ def atanh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arctanh(x) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def bitwise_and( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -84,14 +84,14 @@ def bitwise_and( return jnp.bitwise_and(x1, x2) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def bitwise_invert( x: Union[int, JaxArray], /, *, out: Optional[JaxArray] = None ) -> JaxArray: return jnp.bitwise_not(x) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def bitwise_left_shift( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -103,7 +103,7 @@ def bitwise_left_shift( return jnp.left_shift(x1, x2) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def bitwise_or( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -115,7 +115,7 @@ def bitwise_or( return jnp.bitwise_or(x1, x2) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def bitwise_right_shift( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -127,7 +127,7 @@ def bitwise_right_shift( return jnp.right_shift(x1, x2) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def bitwise_xor( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -139,7 +139,7 @@ def bitwise_xor( return jnp.bitwise_xor(x1, x2) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def ceil(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -151,7 +151,7 @@ def cos(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.cos(x) -@with_unsupported_dtypes({"0.4.19 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("float16",)}, backend_version) def cosh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.cosh(x) @@ -191,7 +191,7 @@ def expm1(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.expm1(x) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def floor(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -199,7 +199,7 @@ def floor(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.floor(x) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def floor_divide( x1: Union[float, JaxArray], x2: Union[float, JaxArray], @@ -427,7 +427,7 @@ def pow( return jnp.power(x1, x2) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def remainder( x1: Union[float, JaxArray], x2: Union[float, JaxArray], @@ -524,7 +524,7 @@ def tanh( return jnp.tanh(x) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def trunc(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -564,7 +564,7 @@ def angle( # ------# -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def erf(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jax.scipy.special.erf(x) @@ -615,7 +615,7 @@ def isreal(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.isreal(x) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def fmod( x1: JaxArray, x2: JaxArray, diff --git a/ivy/functional/backends/jax/experimental/elementwise.py b/ivy/functional/backends/jax/experimental/elementwise.py index 6ee0c250ecb32..4a005bd28c203 100644 --- a/ivy/functional/backends/jax/experimental/elementwise.py +++ b/ivy/functional/backends/jax/experimental/elementwise.py @@ -50,7 +50,7 @@ def sinc(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: @with_supported_dtypes( - {"0.4.19 and below": ("float16", "float32", "float64")}, backend_version + {"0.4.20 and below": ("float16", "float32", "float64")}, backend_version ) def lgamma(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jlax.lgamma(x) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 5ed9c2809931d..c5ebfc9adbbb3 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -440,7 +440,7 @@ def avg_pool3d( return res -@with_supported_dtypes({"0.4.19 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"0.4.20 and below": ("float32", "float64")}, backend_version) def dct( x: JaxArray, /, @@ -822,7 +822,7 @@ def ifftn( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, backend_version + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version ) def embedding( weights: JaxArray, @@ -870,7 +870,7 @@ def rfft( return ret -@with_unsupported_dtypes({"0.4.19 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("float16", "complex")}, backend_version) def rfftn( x: JaxArray, s: Sequence[int] = None, diff --git a/ivy/functional/backends/jax/experimental/random.py b/ivy/functional/backends/jax/experimental/random.py index b0148cc1ca30b..0afa2f35dc9a1 100644 --- a/ivy/functional/backends/jax/experimental/random.py +++ b/ivy/functional/backends/jax/experimental/random.py @@ -56,7 +56,7 @@ def beta( return jax.random.beta(rng_input, a, b, shape, dtype) -@with_unsupported_dtypes({"0.4.19 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, backend_version) def gamma( alpha: Union[float, JaxArray], beta: Union[float, JaxArray], diff --git a/ivy/functional/backends/jax/experimental/sorting.py b/ivy/functional/backends/jax/experimental/sorting.py index 27f7994429c51..232bf3d4be6e2 100644 --- a/ivy/functional/backends/jax/experimental/sorting.py +++ b/ivy/functional/backends/jax/experimental/sorting.py @@ -23,7 +23,7 @@ def invert_permutation( # lexsort -@with_unsupported_dtypes({"0.4.19 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, backend_version) def lexsort( keys: JaxArray, /, diff --git a/ivy/functional/backends/jax/experimental/statistical.py b/ivy/functional/backends/jax/experimental/statistical.py index 305eb9649829c..65beaf0363722 100644 --- a/ivy/functional/backends/jax/experimental/statistical.py +++ b/ivy/functional/backends/jax/experimental/statistical.py @@ -10,7 +10,7 @@ @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16",)}, + {"0.4.20 and below": ("bfloat16",)}, backend_version, ) def histogram( @@ -121,7 +121,7 @@ def histogram( @with_unsupported_dtypes( - {"0.4.19 and below": ("complex64", "complex128")}, backend_version + {"0.4.20 and below": ("complex64", "complex128")}, backend_version ) def median( input: JaxArray, @@ -406,7 +406,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "bfloat16", "bool", ) diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index e783eb26fbcbb..38c877eaffd69 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -101,7 +101,7 @@ def array_equal(x0: JaxArray, x1: JaxArray, /) -> bool: return bool(jnp.array_equal(x0, x1)) -@with_unsupported_dtypes({"0.4.19 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, backend_version) def to_numpy(x: JaxArray, /, *, copy: bool = True) -> np.ndarray: if copy: return np.array(_to_array(x)) @@ -420,7 +420,7 @@ def vmap( ) -@with_unsupported_dtypes({"0.4.19 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("float16", "bfloat16")}, backend_version) def isin( elements: JaxArray, test_elements: JaxArray, diff --git a/ivy/functional/backends/jax/linear_algebra.py b/ivy/functional/backends/jax/linear_algebra.py index 68aeb20ed53bf..0e622f58b8bed 100644 --- a/ivy/functional/backends/jax/linear_algebra.py +++ b/ivy/functional/backends/jax/linear_algebra.py @@ -20,7 +20,7 @@ @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def cholesky( @@ -34,7 +34,7 @@ def cholesky( return ret -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def cross( x1: JaxArray, x2: JaxArray, @@ -51,14 +51,14 @@ def cross( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def det(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.linalg.det(x) -@with_unsupported_dtypes({"0.4.19 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("float16", "bfloat16")}, backend_version) def eig(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> Tuple[JaxArray]: result_tuple = NamedTuple( "eig", [("eigenvalues", JaxArray), ("eigenvectors", JaxArray)] @@ -67,7 +67,7 @@ def eig(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> Tuple[JaxArray]: return result_tuple(eigenvalues, eigenvectors) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def diagonal( x: JaxArray, /, @@ -104,7 +104,7 @@ def tensorsolve( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def eigh( @@ -118,7 +118,7 @@ def eigh( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def eigvalsh( @@ -127,14 +127,14 @@ def eigvalsh( return jnp.linalg.eigvalsh(x, UPLO=UPLO) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def inner(x1: JaxArray, x2: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: x1, x2 = ivy.promote_types_of_inputs(x1, x2) return jnp.inner(x1, x2) @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def inv( @@ -155,7 +155,7 @@ def inv( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matmul( @@ -181,7 +181,7 @@ def matmul( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matrix_norm( @@ -202,13 +202,13 @@ def matrix_norm( return jnp.linalg.norm(x, ord=ord, axis=axis, keepdims=keepdims) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def matrix_power(x: JaxArray, n: int, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.linalg.matrix_power(x, n) @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matrix_rank( @@ -239,7 +239,7 @@ def matrix_rank( @with_unsupported_dtypes( - {"0.4.19 and below": ("int", "float16", "complex")}, + {"0.4.20 and below": ("int", "float16", "complex")}, backend_version, ) def matrix_transpose( @@ -251,7 +251,7 @@ def matrix_transpose( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def outer( @@ -266,7 +266,7 @@ def outer( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def pinv( @@ -284,7 +284,7 @@ def pinv( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def qr( @@ -296,7 +296,7 @@ def qr( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def slogdet( @@ -309,7 +309,7 @@ def slogdet( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def solve( @@ -351,7 +351,7 @@ def solve( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svd( @@ -368,7 +368,7 @@ def svd( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svdvals( @@ -378,7 +378,7 @@ def svdvals( return jnp.linalg.svd(x, compute_uv=False) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def tensordot( x1: JaxArray, x2: JaxArray, @@ -392,7 +392,7 @@ def tensordot( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def trace( @@ -407,7 +407,7 @@ def trace( return jnp.trace(x, offset=offset, axis1=axis1, axis2=axis2, out=out) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def vecdot( x1: JaxArray, x2: JaxArray, /, *, axis: int = -1, out: Optional[JaxArray] = None ) -> JaxArray: @@ -415,7 +415,7 @@ def vecdot( return jnp.tensordot(x1, x2, axes=(axis, axis)) -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def vector_norm( x: JaxArray, /, @@ -445,7 +445,7 @@ def vector_norm( # ------# -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def diag( x: JaxArray, /, @@ -457,7 +457,7 @@ def diag( @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "complex")}, + {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def vander( @@ -473,7 +473,7 @@ def vander( @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/jax/manipulation.py b/ivy/functional/backends/jax/manipulation.py index f2e54c5ddfd51..161ba13f9f082 100644 --- a/ivy/functional/backends/jax/manipulation.py +++ b/ivy/functional/backends/jax/manipulation.py @@ -226,7 +226,7 @@ def clip( return x -@with_unsupported_dtypes({"0.4.19 and below": ("uint64",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("uint64",)}, backend_version) def constant_pad( x: JaxArray, /, diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index 9abba4d7bb617..506eb095fae5c 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -82,7 +82,7 @@ def random_normal( return jax.random.normal(rng_input, shape, dtype=dtype) * std + mean -@with_unsupported_dtypes({"0.4.19 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/jax/searching.py b/ivy/functional/backends/jax/searching.py index ffdd22b03e098..679c02981e49e 100644 --- a/ivy/functional/backends/jax/searching.py +++ b/ivy/functional/backends/jax/searching.py @@ -12,7 +12,7 @@ # ------------------ # -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def argmax( x: JaxArray, /, @@ -38,7 +38,7 @@ def argmax( return ret -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def argmin( x: JaxArray, /, diff --git a/ivy/functional/backends/jax/sorting.py b/ivy/functional/backends/jax/sorting.py index 4edfc258954ab..1dc7eecb5b2c4 100644 --- a/ivy/functional/backends/jax/sorting.py +++ b/ivy/functional/backends/jax/sorting.py @@ -80,7 +80,7 @@ def searchsorted( # msort -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) def msort( a: Union[JaxArray, list, tuple], /, diff --git a/ivy/functional/backends/jax/statistical.py b/ivy/functional/backends/jax/statistical.py index 43b7d097136d9..9e0cef560e067 100644 --- a/ivy/functional/backends/jax/statistical.py +++ b/ivy/functional/backends/jax/statistical.py @@ -38,7 +38,7 @@ def max( @with_unsupported_dtypes( - {"0.4.19 and below": "bfloat16"}, + {"0.4.20 and below": "bfloat16"}, backend_version, ) def mean( @@ -143,7 +143,7 @@ def var( # ------# -@with_unsupported_dtypes({"0.4.19 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes({"0.4.20 and below": "bfloat16"}, backend_version) def cumprod( x: JaxArray, /, diff --git a/ivy/functional/frontends/jax/lax/operators.py b/ivy/functional/frontends/jax/lax/operators.py index fb1285179cfe5..b2ce5a8631c81 100644 --- a/ivy/functional/frontends/jax/lax/operators.py +++ b/ivy/functional/frontends/jax/lax/operators.py @@ -157,7 +157,7 @@ def broadcast(operand, sizes): @with_supported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "float32", "float64", @@ -309,7 +309,7 @@ def cosh(x): @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16", "float16", "bool", "complex64", "complex128")}, + {"0.4.20 and below": ("bfloat16", "float16", "bool", "complex64", "complex128")}, "jax", ) @to_ivy_arrays_and_back @@ -400,7 +400,7 @@ def erf(x): @with_supported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "float32", "float64", @@ -465,7 +465,7 @@ def imag(x): @with_unsupported_dtypes( - {"0.4.19 and below": ("bool", "bfloat16")}, + {"0.4.20 and below": ("bool", "bfloat16")}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/nn/non_linear_activations.py b/ivy/functional/frontends/jax/nn/non_linear_activations.py index 7d1cf70ce0660..0cc778cf320cb 100644 --- a/ivy/functional/frontends/jax/nn/non_linear_activations.py +++ b/ivy/functional/frontends/jax/nn/non_linear_activations.py @@ -289,7 +289,7 @@ def sigmoid(x): @with_supported_dtypes( - {"0.4.19 and below": ("complex", "float")}, + {"0.4.20 and below": ("complex", "float")}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/numpy/creation.py b/ivy/functional/frontends/jax/numpy/creation.py index d82c05b0b3569..d426cf6939c7b 100644 --- a/ivy/functional/frontends/jax/numpy/creation.py +++ b/ivy/functional/frontends/jax/numpy/creation.py @@ -17,7 +17,7 @@ @with_unsupported_device_and_dtypes( { - "0.4.19 and below": { + "0.4.20 and below": { "cpu": ( "float16", "bflooat16", @@ -196,7 +196,7 @@ def iterable(y): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -217,7 +217,7 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/frontends/jax/numpy/linalg.py b/ivy/functional/frontends/jax/numpy/linalg.py index 6700c92f33cef..90a1a7449e765 100644 --- a/ivy/functional/frontends/jax/numpy/linalg.py +++ b/ivy/functional/frontends/jax/numpy/linalg.py @@ -88,7 +88,7 @@ def multi_dot(arrays, *, precision=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"0.4.19 and below": ("float32", "float64")}, + {"0.4.20 and below": ("float32", "float64")}, "jax", ) def norm(x, ord=None, axis=None, keepdims=False): @@ -127,7 +127,7 @@ def svd(a, /, *, full_matrices=True, compute_uv=True, hermitian=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.19 and below": ("float16", "bfloat16")}, "jax") +@with_unsupported_dtypes({"0.4.20 and below": ("float16", "bfloat16")}, "jax") def tensorinv(a, ind=2): old_shape = ivy.shape(a) prod = 1 diff --git a/ivy/functional/frontends/jax/numpy/logic.py b/ivy/functional/frontends/jax/numpy/logic.py index 171f864c1dad0..c6d79f193d91d 100644 --- a/ivy/functional/frontends/jax/numpy/logic.py +++ b/ivy/functional/frontends/jax/numpy/logic.py @@ -101,7 +101,7 @@ def equal(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.19 and below": ("bfloat16",)}, "jax") +@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, "jax") def fromfunction(function, shape, *, dtype=float, **kwargs): def canonicalize_shape(shape, context="shape argument"): if isinstance(shape, int): @@ -285,7 +285,7 @@ def right_shift(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.19 and below": ("bfloat16", "bool")}, "jax") +@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16", "bool")}, "jax") def setxor1d(ar1, ar2, assume_unique=False): common_dtype = ivy.promote_types(ivy.dtype(ar1), ivy.dtype(ar2)) ar1 = ivy.asarray(ar1, dtype=common_dtype) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 5776a660bee33..021c2e74659a7 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -76,7 +76,7 @@ def around(a, decimals=0, out=None): @with_unsupported_dtypes( - {"0.4.19 and below": ("bfloat16",)}, + {"0.4.20 and below": ("bfloat16",)}, "jax", ) @to_ivy_arrays_and_back @@ -420,7 +420,7 @@ def expm1( @with_unsupported_dtypes( - {"0.4.19 and below": ("uint16",)}, + {"0.4.20 and below": ("uint16",)}, "jax", ) @to_ivy_arrays_and_back @@ -595,7 +595,7 @@ def minimum(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.19 and below": ("complex",)}, "jax") +@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, "jax") def mod(x1, x2, /): x1, x2 = promote_types_of_jax_inputs(x1, x2) return ivy.remainder(x1, x2) @@ -637,7 +637,7 @@ def negative( @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "bfloat16", "float16", ) @@ -682,7 +682,7 @@ def polyadd(a1, a2): @with_unsupported_dtypes( - {"0.4.19 and below": ("float16",)}, + {"0.4.20 and below": ("float16",)}, "jax", ) @to_ivy_arrays_and_back @@ -724,7 +724,7 @@ def polydiv(u, v, *, trim_leading_zeros=False): @with_unsupported_dtypes( - {"0.4.19 and below": ("float16",)}, + {"0.4.20 and below": ("float16",)}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/numpy/searching_sorting.py b/ivy/functional/frontends/jax/numpy/searching_sorting.py index cf538122e1fc5..3ad8b7b6d835f 100644 --- a/ivy/functional/frontends/jax/numpy/searching_sorting.py +++ b/ivy/functional/frontends/jax/numpy/searching_sorting.py @@ -15,7 +15,7 @@ @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -58,7 +58,7 @@ def argwhere(a, /, *, size=None, fill_value=None): @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "uint8", "int8", "bool", diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py index 96a10c56c0053..845b3bcb3c255 100644 --- a/ivy/functional/frontends/jax/numpy/statistical.py +++ b/ivy/functional/frontends/jax/numpy/statistical.py @@ -103,7 +103,7 @@ def corrcoef(x, y=None, rowvar=True): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.19 and below": ("float16", "bfloat16")}, "jax") +@with_unsupported_dtypes({"0.4.20 and below": ("float16", "bfloat16")}, "jax") def correlate(a, v, mode="valid", precision=None): if ivy.get_num_dims(a) != 1 or ivy.get_num_dims(v) != 1: raise ValueError("correlate() only support 1-dimensional inputs.") @@ -572,7 +572,7 @@ def ptp(a, axis=None, out=None, keepdims=False): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.19 and below": ("complex64", "complex128", "bfloat16", "bool", "float16")}, + {"0.4.20 and below": ("complex64", "complex128", "bfloat16", "bool", "float16")}, "jax", ) def quantile( @@ -597,7 +597,7 @@ def quantile( @handle_jax_dtype -@with_unsupported_dtypes({"0.4.19 and below": ("bfloat16",)}, "jax") +@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, "jax") @to_ivy_arrays_and_back def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=None): axis = tuple(axis) if isinstance(axis, list) else axis diff --git a/ivy/functional/frontends/jax/random.py b/ivy/functional/frontends/jax/random.py index 8a67fe804d687..f8adcc6778a04 100644 --- a/ivy/functional/frontends/jax/random.py +++ b/ivy/functional/frontends/jax/random.py @@ -38,7 +38,7 @@ def PRNGKey(seed): @to_ivy_arrays_and_back @with_supported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float32", "float64", ) @@ -70,7 +70,7 @@ def bernoulli(key, p=0.5, shape=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -85,7 +85,7 @@ def beta(key, a, b, shape=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -133,7 +133,7 @@ def cauchy(key, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -149,7 +149,7 @@ def dirichlet(key, alpha, shape=None, dtype="float32"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.19 and below": "uint32"}, + {"0.4.20 and below": "uint32"}, "jax", ) def double_sided_maxwell(key, loc, scale, shape=(), dtype="float64"): @@ -168,7 +168,7 @@ def double_sided_maxwell(key, loc, scale, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -196,7 +196,7 @@ def fold_in(key, data): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -212,7 +212,7 @@ def gamma(key, a, shape=None, dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -231,7 +231,7 @@ def generalized_normal(key, p, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -255,7 +255,7 @@ def gumbel(key, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -270,7 +270,7 @@ def loggamma(key, a, shape=None, dtype="float64"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.19 and below": ("float16", "bfloat16")}, + {"0.4.20 and below": ("float16", "bfloat16")}, "jax", ) def logistic(key, shape=(), dtype="float64"): @@ -301,7 +301,7 @@ def maxwell(key, shape, dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -358,7 +358,7 @@ def orthogonal(key, n, shape=(), dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.19 and below": ( + "0.4.20 and below": ( "float16", "bfloat16", ) @@ -393,7 +393,7 @@ def permutation(key, x, axis=0, independent=False): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.19 and below": ("unsigned", "int8", "int16")}, + {"0.4.20 and below": ("unsigned", "int8", "int16")}, "jax", ) def poisson(key, lam, shape=None, dtype=None): @@ -404,7 +404,7 @@ def poisson(key, lam, shape=None, dtype=None): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.19 and below": ("unsigned", "int8", "int16")}, + {"0.4.20 and below": ("unsigned", "int8", "int16")}, "jax", ) def rademacher(key, shape, dtype="int64"): @@ -418,7 +418,7 @@ def rademacher(key, shape, dtype="int64"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.19 and below": ("unsigned", "int8", "int16")}, + {"0.4.20 and below": ("unsigned", "int8", "int16")}, "jax", ) def randint(key, shape, minval, maxval, dtype="int64"): From 76065d3134eecb5a6ef17f6dc75c1737f8805778 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 13 Nov 2023 20:29:08 +0530 Subject: [PATCH 157/978] fix: Fixed passing `positional only` arguments in few functions (#27245) --- ivy/functional/frontends/jax/numpy/statistical.py | 2 +- ivy/functional/frontends/mindspore/ops/function/nn_func.py | 2 +- ivy/functional/frontends/mxnet/numpy/random.py | 2 +- ivy/functional/frontends/scipy/spatial/distance.py | 2 +- .../torch/nn/functional/non_linear_activation_functions.py | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py index 845b3bcb3c255..514d077df004c 100644 --- a/ivy/functional/frontends/jax/numpy/statistical.py +++ b/ivy/functional/frontends/jax/numpy/statistical.py @@ -33,7 +33,7 @@ def average(a, axis=None, weights=None, returned=False, keepdims=False): ret = ivy.mean(a, axis=axis, keepdims=keepdims) if axis is None: fill_value = int(a.size) if ivy.is_int_dtype(ret) else float(a.size) - weights_sum = ivy.full(shape=(), fill_value=fill_value, dtype=ret.dtype) + weights_sum = ivy.full((), fill_value, dtype=ret.dtype) else: if isinstance(axis, tuple): # prod with axis has dtype Sequence[int] diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index 43ec4a6d18c7d..92db96fb8a2d2 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -336,7 +336,7 @@ def interpolate( ): return ivy.interpolate( input, - size=size, + size, scale_factor=scale_factor, mode=mode, align_corners=align_corners, diff --git a/ivy/functional/frontends/mxnet/numpy/random.py b/ivy/functional/frontends/mxnet/numpy/random.py index e3bf4f8eea107..6e5f2f202fdca 100644 --- a/ivy/functional/frontends/mxnet/numpy/random.py +++ b/ivy/functional/frontends/mxnet/numpy/random.py @@ -62,7 +62,7 @@ def rand(*size, **kwargs): @to_ivy_arrays_and_back def randint(low, high=None, size=None, dtype=None, device=None, out=None): - return ivy.randint(low, high=high, shape=size, device=device, dtype=dtype, out=out) + return ivy.randint(low, high, shape=size, device=device, dtype=dtype, out=out) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/scipy/spatial/distance.py b/ivy/functional/frontends/scipy/spatial/distance.py index eb38e843c167f..73c1261f45188 100644 --- a/ivy/functional/frontends/scipy/spatial/distance.py +++ b/ivy/functional/frontends/scipy/spatial/distance.py @@ -29,7 +29,7 @@ def _validate_weights(w, dtype="float64"): # euclidean @to_ivy_arrays_and_back def euclidean(u, v, /, *, w=None): - return minkowski(u, v, p=2, w=w) + return minkowski(u, v, 2, w=w) # Functions # diff --git a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py index d62b2a0151ff9..42159e0197ec0 100644 --- a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py @@ -67,7 +67,7 @@ def glu(input, dim=-1): def gumbel_softmax(logits, tau=1, hard=False, eps=1e-10, dim=-1): gumbels = -ivy.empty_like(logits).exponential().log() gumbels = (logits + gumbels) / tau - y_soft = ivy.softmax(x=gumbels, axis=dim) + y_soft = ivy.softmax(gumbels, axis=dim) if hard: indices = y_soft.max(axis=dim, keepdims=True)[1] From c6d37bf19a179edddcb785c7f156da3aa151bb6a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 13 Nov 2023 20:30:15 +0530 Subject: [PATCH 158/978] fix: Fixed key-word arguments in `torch_frontend.quantile()` function call. (#27249) --- ivy/functional/frontends/torch/tensor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index e25fcd6ecb11b..92991c47d1f5e 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1960,7 +1960,7 @@ def triu_(self, diagonal=0): ) def quantile(self, q, dim=None, keepdim=False, *, interpolation="linear", out=None): return torch_frontend.quantile( - self, q, axis=dim, keepdims=keepdim, interpolation=interpolation, out=out + self, q, dim=dim, keepdim=keepdim, interpolation=interpolation, out=out ) @with_unsupported_dtypes( From cdfbf05c2b7d449234526ba1ea72c7440fc382ce Mon Sep 17 00:00:00 2001 From: Mostafa Hani <71686115+CatB1t@users.noreply.github.com> Date: Mon, 13 Nov 2023 17:52:42 +0200 Subject: [PATCH 159/978] feat: update NumPy version to 1.26.2 (#27259) --- ivy/functional/backends/numpy/__init__.py | 24 ++++++------ ivy/functional/backends/numpy/data_type.py | 4 +- ivy/functional/backends/numpy/elementwise.py | 32 ++++++++-------- .../numpy/experimental/activations.py | 2 +- .../numpy/experimental/elementwise.py | 2 +- .../backends/numpy/experimental/general.py | 2 +- .../backends/numpy/experimental/layers.py | 4 +- .../numpy/experimental/linear_algebra.py | 6 +-- .../backends/numpy/experimental/losses.py | 6 +-- .../backends/numpy/experimental/norms.py | 2 +- .../backends/numpy/experimental/searching.py | 2 +- .../numpy/experimental/statistical.py | 4 +- ivy/functional/backends/numpy/general.py | 2 +- .../backends/numpy/linear_algebra.py | 38 +++++++++---------- ivy/functional/backends/numpy/manipulation.py | 2 +- ivy/functional/backends/numpy/random.py | 2 +- ivy/functional/backends/numpy/sorting.py | 2 +- ivy/functional/backends/numpy/statistical.py | 2 +- .../numpy/fft/discrete_fourier_transform.py | 10 ++--- .../numpy/linalg/norms_and_other_numbers.py | 4 +- ...olving_equations_and_inverting_matrices.py | 10 ++--- .../mathematical_functions/miscellaneous.py | 2 +- .../frontends/numpy/statistics/histograms.py | 2 +- 23 files changed, 83 insertions(+), 83 deletions(-) diff --git a/ivy/functional/backends/numpy/__init__.py b/ivy/functional/backends/numpy/__init__.py index 163da57f6a834..0939aa145f73c 100644 --- a/ivy/functional/backends/numpy/__init__.py +++ b/ivy/functional/backends/numpy/__init__.py @@ -81,7 +81,7 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): # update these to add new dtypes valid_dtypes = { - "1.26.1 and below": ( + "1.26.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -99,7 +99,7 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): ) } valid_numeric_dtypes = { - "1.26.1 and below": ( + "1.26.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -116,7 +116,7 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): ) } valid_int_dtypes = { - "1.26.1 and below": ( + "1.26.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -127,11 +127,11 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): ivy.uint64, ) } -valid_float_dtypes = {"1.26.1 and below": (ivy.float16, ivy.float32, ivy.float64)} +valid_float_dtypes = {"1.26.2 and below": (ivy.float16, ivy.float32, ivy.float64)} valid_uint_dtypes = { - "1.26.1 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) + "1.26.2 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) } -valid_complex_dtypes = {"1.26.1 and below": (ivy.complex64, ivy.complex128)} +valid_complex_dtypes = {"1.26.2 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -143,12 +143,12 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): # invalid data types # update these to add new dtypes -invalid_dtypes = {"1.26.1 and below": (ivy.bfloat16,)} -invalid_numeric_dtypes = {"1.26.1 and below": (ivy.bfloat16,)} -invalid_int_dtypes = {"1.26.1 and below": ()} -invalid_float_dtypes = {"1.26.1 and below": (ivy.bfloat16,)} -invalid_uint_dtypes = {"1.26.1 and below": ()} -invalid_complex_dtypes = {"1.26.1 and below": ()} +invalid_dtypes = {"1.26.2 and below": (ivy.bfloat16,)} +invalid_numeric_dtypes = {"1.26.2 and below": (ivy.bfloat16,)} +invalid_int_dtypes = {"1.26.2 and below": ()} +invalid_float_dtypes = {"1.26.2 and below": (ivy.bfloat16,)} +invalid_uint_dtypes = {"1.26.2 and below": ()} +invalid_complex_dtypes = {"1.26.2 and below": ()} # leave these untouched diff --git a/ivy/functional/backends/numpy/data_type.py b/ivy/functional/backends/numpy/data_type.py index 4246f695a2493..a748843b6513e 100644 --- a/ivy/functional/backends/numpy/data_type.py +++ b/ivy/functional/backends/numpy/data_type.py @@ -133,7 +133,7 @@ def broadcast_arrays(*arrays: np.ndarray) -> List[np.ndarray]: raise ivy.utils.exceptions.IvyBroadcastShapeError(e) -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def broadcast_to( x: np.ndarray, /, @@ -216,7 +216,7 @@ def as_ivy_dtype( ) -@with_unsupported_dtypes({"1.26.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) def as_native_dtype(dtype_in: Union[np.dtype, str, bool, int, float], /) -> np.dtype: if dtype_in is int: return ivy.default_int_dtype(as_native=True) diff --git a/ivy/functional/backends/numpy/elementwise.py b/ivy/functional/backends/numpy/elementwise.py index 9a6dfde82b98a..0d0c6e8ce9022 100644 --- a/ivy/functional/backends/numpy/elementwise.py +++ b/ivy/functional/backends/numpy/elementwise.py @@ -83,7 +83,7 @@ def atan(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def atan2( x1: np.ndarray, x2: np.ndarray, /, *, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -103,7 +103,7 @@ def atanh(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def bitwise_and( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -119,7 +119,7 @@ def bitwise_and( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def bitwise_invert( x: Union[int, bool, np.ndarray], /, *, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -130,7 +130,7 @@ def bitwise_invert( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def bitwise_left_shift( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -146,7 +146,7 @@ def bitwise_left_shift( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def bitwise_or( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -162,7 +162,7 @@ def bitwise_or( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def bitwise_right_shift( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -178,7 +178,7 @@ def bitwise_right_shift( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def bitwise_xor( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -193,7 +193,7 @@ def bitwise_xor( bitwise_xor.support_native_out = True -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) @_scalar_output_to_0d_array def ceil(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: if "int" in str(x.dtype): @@ -216,7 +216,7 @@ def cos(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: cos.support_native_out = True -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) @_scalar_output_to_0d_array def cosh(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.cosh(x, out=out) @@ -289,7 +289,7 @@ def expm1(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def floor(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: if "int" in str(x.dtype): ret = np.copy(x) @@ -304,7 +304,7 @@ def floor(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def floor_divide( x1: Union[float, np.ndarray], x2: Union[float, np.ndarray], @@ -486,7 +486,7 @@ def log2(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def logaddexp( x1: np.ndarray, x2: np.ndarray, /, *, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -623,7 +623,7 @@ def pow( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def remainder( x1: Union[float, np.ndarray], x2: Union[float, np.ndarray], @@ -865,7 +865,7 @@ def reciprocal( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def deg2rad(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.deg2rad(x, out=out) @@ -874,7 +874,7 @@ def deg2rad(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def rad2deg(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.rad2deg(x, out=out) @@ -891,7 +891,7 @@ def isreal(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def fmod( x1: np.ndarray, x2: np.ndarray, diff --git a/ivy/functional/backends/numpy/experimental/activations.py b/ivy/functional/backends/numpy/experimental/activations.py index 721365d16b7b5..e48bbedb99b28 100644 --- a/ivy/functional/backends/numpy/experimental/activations.py +++ b/ivy/functional/backends/numpy/experimental/activations.py @@ -55,7 +55,7 @@ def relu6( relu6.support_native_out = True -@with_unsupported_dtypes({"1.26.1 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bool",)}, backend_version) @_scalar_output_to_0d_array def logsigmoid( input: np.ndarray, /, *, complex_mode="jax", out: Optional[np.ndarray] = None diff --git a/ivy/functional/backends/numpy/experimental/elementwise.py b/ivy/functional/backends/numpy/experimental/elementwise.py index d5ae82d500a7e..d81989479ff5c 100644 --- a/ivy/functional/backends/numpy/experimental/elementwise.py +++ b/ivy/functional/backends/numpy/experimental/elementwise.py @@ -42,7 +42,7 @@ def amin( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) def sinc(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.sinc(x).astype(x.dtype) diff --git a/ivy/functional/backends/numpy/experimental/general.py b/ivy/functional/backends/numpy/experimental/general.py index 74fe96dd63423..2077d276631c9 100644 --- a/ivy/functional/backends/numpy/experimental/general.py +++ b/ivy/functional/backends/numpy/experimental/general.py @@ -7,7 +7,7 @@ from ivy import with_unsupported_dtypes -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def reduce( operand: np.ndarray, init_value: Union[int, float], diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index 80cc3fd3d5588..b48661d78e361 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -729,7 +729,7 @@ def fft( return np.fft.fft(x, n, dim, norm).astype(out_dtype) -@with_supported_dtypes({"1.26.1 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"1.26.2 and below": ("float32", "float64")}, backend_version) def dct( x: np.ndarray, /, @@ -994,7 +994,7 @@ def ifftn( return np.fft.ifftn(x, s, axes, norm).astype(x.dtype) -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def embedding( weights: np.ndarray, indices: np.ndarray, diff --git a/ivy/functional/backends/numpy/experimental/linear_algebra.py b/ivy/functional/backends/numpy/experimental/linear_algebra.py index 2f054e1cb586b..1fc7eb964c89e 100644 --- a/ivy/functional/backends/numpy/experimental/linear_algebra.py +++ b/ivy/functional/backends/numpy/experimental/linear_algebra.py @@ -90,7 +90,7 @@ def kron( @with_supported_dtypes( - {"1.26.1 and below": ("float32", "float64", "complex64", "complex128")}, + {"1.26.2 and below": ("float32", "float64", "complex64", "complex128")}, backend_version, ) def matrix_exp( @@ -106,7 +106,7 @@ def matrix_exp( return exp_mat.astype(x.dtype) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def eig( x: np.ndarray, /, @@ -120,7 +120,7 @@ def eig( eig.support_native_out = False -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def eigvals(x: np.ndarray, /) -> np.ndarray: e = np.linalg.eigvals(x) return e.astype(complex) diff --git a/ivy/functional/backends/numpy/experimental/losses.py b/ivy/functional/backends/numpy/experimental/losses.py index 363916ca62353..9da5beb3a95f8 100644 --- a/ivy/functional/backends/numpy/experimental/losses.py +++ b/ivy/functional/backends/numpy/experimental/losses.py @@ -8,7 +8,7 @@ from . import backend_version -@with_unsupported_dtypes({"1.26.1 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bool",)}, backend_version) @_scalar_output_to_0d_array def huber_loss( input: np.ndarray, @@ -32,7 +32,7 @@ def huber_loss( # Implementation of smooth_l1_loss in the given format -@with_unsupported_dtypes({"1.26.1 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bool",)}, backend_version) @_scalar_output_to_0d_array def smooth_l1_loss( input: np.ndarray, @@ -56,7 +56,7 @@ def smooth_l1_loss( return loss -@with_unsupported_dtypes({"1.26.1 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bool",)}, backend_version) @_scalar_output_to_0d_array def soft_margin_loss( input: np.ndarray, diff --git a/ivy/functional/backends/numpy/experimental/norms.py b/ivy/functional/backends/numpy/experimental/norms.py index 3d1b549283d13..a8f2ec9b6a8a3 100644 --- a/ivy/functional/backends/numpy/experimental/norms.py +++ b/ivy/functional/backends/numpy/experimental/norms.py @@ -4,7 +4,7 @@ from . import backend_version -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def l1_normalize( x: np.ndarray, /, diff --git a/ivy/functional/backends/numpy/experimental/searching.py b/ivy/functional/backends/numpy/experimental/searching.py index ce66a03b0b2b9..f49b9c9c3a8fd 100644 --- a/ivy/functional/backends/numpy/experimental/searching.py +++ b/ivy/functional/backends/numpy/experimental/searching.py @@ -7,7 +7,7 @@ from . import backend_version -@with_supported_dtypes({"1.26.1 and below": ("int32", "int64")}, backend_version) +@with_supported_dtypes({"1.26.2 and below": ("int32", "int64")}, backend_version) def unravel_index( indices: np.ndarray, shape: Tuple[int], diff --git a/ivy/functional/backends/numpy/experimental/statistical.py b/ivy/functional/backends/numpy/experimental/statistical.py index b150ff89ff775..a69b2a58bd10e 100644 --- a/ivy/functional/backends/numpy/experimental/statistical.py +++ b/ivy/functional/backends/numpy/experimental/statistical.py @@ -9,7 +9,7 @@ @with_unsupported_dtypes( - {"1.26.1 and below": ("bfloat16",)}, + {"1.26.2 and below": ("bfloat16",)}, backend_version, ) def histogram( @@ -534,7 +534,7 @@ def __get_index(lst, indices=None, prefix=None): return indices -@with_unsupported_dtypes({"1.26.1 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": "bfloat16"}, backend_version) def cummin( x: np.ndarray, /, diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index b984c8ab8dec8..e2da9e512a31d 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -434,7 +434,7 @@ def _vmap(*args): return _vmap -@with_unsupported_dtypes({"1.26.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) def isin( elements: np.ndarray, test_elements: np.ndarray, diff --git a/ivy/functional/backends/numpy/linear_algebra.py b/ivy/functional/backends/numpy/linear_algebra.py index 26257efbba19f..d5fe77211f752 100644 --- a/ivy/functional/backends/numpy/linear_algebra.py +++ b/ivy/functional/backends/numpy/linear_algebra.py @@ -18,7 +18,7 @@ # -------------------# -@with_unsupported_dtypes({"1.26.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16", "complex")}, backend_version) def cholesky( x: np.ndarray, /, *, upper: bool = False, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -30,7 +30,7 @@ def cholesky( return ret -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def cross( x1: np.ndarray, x2: np.ndarray, @@ -46,7 +46,7 @@ def cross( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def det(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.linalg.det(x) @@ -63,7 +63,7 @@ def diagonal( return np.diagonal(x, offset=offset, axis1=axis1, axis2=axis2) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def eigh( x: np.ndarray, /, *, UPLO: str = "L", out: Optional[np.ndarray] = None ) -> Tuple[np.ndarray]: @@ -74,7 +74,7 @@ def eigh( return result_tuple(eigenvalues, eigenvectors) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def eigvalsh( x: np.ndarray, /, *, UPLO: str = "L", out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -90,7 +90,7 @@ def inner( @with_unsupported_dtypes( - {"1.26.1 and below": ("bfloat16", "float16", "complex")}, + {"1.26.2 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def inv( @@ -110,7 +110,7 @@ def inv( return np.linalg.inv(x) -@with_unsupported_dtypes({"1.26.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16", "bfloat16")}, backend_version) def matmul( x1: np.ndarray, x2: np.ndarray, @@ -140,7 +140,7 @@ def matmul( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16", "bfloat16")}, backend_version) def matrix_norm( x: np.ndarray, /, @@ -162,7 +162,7 @@ def matrix_power( @with_unsupported_dtypes( - {"1.26.1 and below": ("float16", "bfloat16", "complex")}, + {"1.26.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) @_scalar_output_to_0d_array @@ -201,7 +201,7 @@ def matrix_transpose( return np.swapaxes(x, -1, -2) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def outer( x1: np.ndarray, x2: np.ndarray, @@ -216,7 +216,7 @@ def outer( outer.support_native_out = True -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def pinv( x: np.ndarray, /, @@ -230,7 +230,7 @@ def pinv( return np.linalg.pinv(x, rtol) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def qr( x: np.ndarray, /, @@ -243,7 +243,7 @@ def qr( return res(q, r) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def slogdet( x: np.ndarray, /, @@ -258,7 +258,7 @@ def slogdet( return results(sign, logabsdet) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def solve( x1: np.ndarray, x2: np.ndarray, @@ -283,7 +283,7 @@ def solve( return ret -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def svd( x: np.ndarray, /, *, compute_uv: bool = True, full_matrices: bool = True ) -> Union[np.ndarray, Tuple[np.ndarray, ...]]: @@ -297,7 +297,7 @@ def svd( return results(D) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def svdvals( x: np.ndarray, /, *, driver: Optional[str] = None, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -330,7 +330,7 @@ def tensordot( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16", "bfloat16")}, backend_version) def trace( x: np.ndarray, /, @@ -358,7 +358,7 @@ def vecdot( return np.tensordot(x1, x2, axes=(axis, axis)) -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) def eig(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> Tuple[np.ndarray]: result_tuple = NamedTuple( "eig", [("eigenvalues", np.ndarray), ("eigenvectors", np.ndarray)] @@ -435,7 +435,7 @@ def vander( @with_unsupported_dtypes( { - "1.26.1 and below": ( + "1.26.2 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/numpy/manipulation.py b/ivy/functional/backends/numpy/manipulation.py index 2bc593bfcbe37..0f59794f34ad9 100644 --- a/ivy/functional/backends/numpy/manipulation.py +++ b/ivy/functional/backends/numpy/manipulation.py @@ -189,7 +189,7 @@ def split( return np.split(x, num_or_size_splits, axis) -@with_unsupported_dtypes({"1.26.1 and below": ("uint64",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("uint64",)}, backend_version) def repeat( x: np.ndarray, /, diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index a398c6a63db41..a9e06e8c1dbbc 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -51,7 +51,7 @@ def random_normal( return np.asarray(np.random.normal(mean, std, shape), dtype=dtype) -@with_unsupported_dtypes({"1.26.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/numpy/sorting.py b/ivy/functional/backends/numpy/sorting.py index 3edced7e06096..a79ffbd715153 100644 --- a/ivy/functional/backends/numpy/sorting.py +++ b/ivy/functional/backends/numpy/sorting.py @@ -42,7 +42,7 @@ def sort( # msort -@with_unsupported_dtypes({"1.26.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) def msort( a: Union[np.ndarray, list, tuple], /, *, out: Optional[np.ndarray] = None ) -> np.ndarray: diff --git a/ivy/functional/backends/numpy/statistical.py b/ivy/functional/backends/numpy/statistical.py index d63277c355bb0..e2028c726d2b5 100644 --- a/ivy/functional/backends/numpy/statistical.py +++ b/ivy/functional/backends/numpy/statistical.py @@ -169,7 +169,7 @@ def var( # ------# -@with_unsupported_dtypes({"1.26.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) def cumprod( x: np.ndarray, /, diff --git a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py index 67755d6fe3419..609d4e303072b 100644 --- a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py +++ b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py @@ -25,7 +25,7 @@ def fft(a, n=None, axis=-1, norm=None): return ivy.fft(ivy.astype(a, ivy.complex128), axis, norm=norm, n=n) -@with_unsupported_dtypes({"1.26.1 and below": ("int",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("int",)}, "numpy") @to_ivy_arrays_and_back def fftfreq(n, d=1.0): if not isinstance( @@ -46,7 +46,7 @@ def fftfreq(n, d=1.0): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") def fftshift(x, axes=None): x = ivy.asarray(x) @@ -91,7 +91,7 @@ def ifftn(a, s=None, axes=None, norm=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") def ifftshift(x, axes=None): x = ivy.asarray(x) @@ -111,7 +111,7 @@ def ifftshift(x, axes=None): return roll -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def ihfft(a, n=None, axis=-1, norm=None): if n is None: @@ -121,7 +121,7 @@ def ihfft(a, n=None, axis=-1, norm=None): return output -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def rfft(a, n=None, axis=-1, norm=None): if norm is None: diff --git a/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py b/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py index 9f80975cbfcdd..e1d492dddfe2d 100644 --- a/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py +++ b/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py @@ -23,7 +23,7 @@ def matrix_rank(A, tol=None, hermitian=False): # solve -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar def norm(x, ord=None, axis=None, keepdims=False): @@ -46,7 +46,7 @@ def norm(x, ord=None, axis=None, keepdims=False): # slogdet -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar def slogdet(a): diff --git a/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py b/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py index e97015cde5f8b..5aff9e9fa56f3 100644 --- a/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py +++ b/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py @@ -10,7 +10,7 @@ # inv -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def inv(a): return ivy.inv(a) @@ -19,7 +19,7 @@ def inv(a): # TODO: replace this with function from API # As the compositon provides unstable results @to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") def lstsq(a, b, rcond="warn"): solution = ivy.matmul( ivy.pinv(a, rtol=1e-15).astype(ivy.float64), b.astype(ivy.float64) @@ -32,14 +32,14 @@ def lstsq(a, b, rcond="warn"): # pinv # TODO: add hermitian functionality -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def pinv(a, rcond=1e-15, hermitian=False): return ivy.pinv(a, rtol=rcond) # solve -@with_unsupported_dtypes({"1.26.1 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def solve(a, b): a, b = promote_types_of_numpy_inputs(a, b) @@ -47,7 +47,7 @@ def solve(a, b): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.26.1 and below": ("float16", "blfloat16")}, "numpy") +@with_unsupported_dtypes({"1.26.2 and below": ("float16", "blfloat16")}, "numpy") def tensorinv(a, ind=2): old_shape = ivy.shape(a) prod = 1 diff --git a/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py b/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py index 15e7a81552e49..43da4792f5f9d 100644 --- a/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py +++ b/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py @@ -147,7 +147,7 @@ def _fabs( @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar @with_supported_dtypes( - {"1.26.1 and below": ("int8", "int16", "int32", "int64")}, "numpy" + {"1.26.2 and below": ("int8", "int16", "int32", "int64")}, "numpy" ) # Add def _gcd( x1, diff --git a/ivy/functional/frontends/numpy/statistics/histograms.py b/ivy/functional/frontends/numpy/statistics/histograms.py index 57d3ae685cb2f..fb0795ec8750c 100644 --- a/ivy/functional/frontends/numpy/statistics/histograms.py +++ b/ivy/functional/frontends/numpy/statistics/histograms.py @@ -3,7 +3,7 @@ from ivy.func_wrapper import with_supported_dtypes -@with_supported_dtypes({"1.26.1 and below": ("int64",)}, "numpy") +@with_supported_dtypes({"1.26.2 and below": ("int64",)}, "numpy") @to_ivy_arrays_and_back def bincount(x, /, weights=None, minlength=0): return ivy.bincount(x, weights=weights, minlength=minlength) From acdc1f43614d56a75ae0c6c082ec9ac5170e2dce Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 13 Nov 2023 21:25:52 +0530 Subject: [PATCH 160/978] perf(ci): improved the number of mongodb connnections (#27260) To avoid connecting once for each runner but just once for each time the intelligent-tests-pr workflow was triggered --- .github/workflows/intelligent-tests-pr.yml | 11 ++++-- scripts/run_tests/label_failures.py | 39 ++++++++++++++++++++++ scripts/run_tests/run_tests_pr.py | 28 ---------------- 3 files changed, 48 insertions(+), 30 deletions(-) create mode 100644 scripts/run_tests/label_failures.py diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index 2ec7ebd720429..f160334b5db6e 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -27,10 +27,11 @@ jobs: - name: Test Failures run: | find . -name "test_failures_*.txt" -exec cat {} + > combined_failures.txt - if [ -s combined_failures.txt ] + python3 scripts/run_tests/label_failures.py combined_failures.txt labeled_combined_failures.txt + if [ -s labeled_combined_failures.txt ] then echo "The CI captured the following failing tests based on your changes:" - cat combined_failures.txt + cat labeled_combined_failures.txt else echo "No test failures found based on your changes!" fi @@ -105,6 +106,12 @@ jobs: name: test_failures_${{ matrix.branch }} path: ivy/test_failures_${{ matrix.branch }}.txt + - name: Upload Labelling Script + uses: actions/upload-artifact@v3 + with: + name: scripts + path: ivy/scripts + - name: Check on failures if: steps.tests.outcome != 'success' run: exit 1 diff --git a/scripts/run_tests/label_failures.py b/scripts/run_tests/label_failures.py new file mode 100644 index 0000000000000..8e97d0891b3bd --- /dev/null +++ b/scripts/run_tests/label_failures.py @@ -0,0 +1,39 @@ +# Run Tests +import sys +from pymongo import MongoClient + +from scripts.run_tests.run_tests import ( + get_latest_package_version, + get_submodule_and_function_name, +) + + +if __name__ == "__main__": + failed = False + cluster = MongoClient( + "mongodb+srv://readonly-user:hvpwV5yVeZdgyTTm@cluster0.qdvf8q3.mongodb.net" + ) + db = cluster["ci_dashboard"] + with open(sys.argv[2], "w") as f_write: + with open(sys.argv[1], "r") as f: + for line in f: + test_path, backend = line.strip().split(",") + is_frontend_test = "test_frontends" in test_path + collection = ( + db["frontend_tests"] if is_frontend_test else db["ivy_tests"] + ) + submodule, function_name = get_submodule_and_function_name( + test_path, is_frontend_test + ) + version = get_latest_package_version(backend).replace(".", "_") + document = collection.find_one({"_id": function_name}) + if document: + try: + if document[backend][version]["status"]["cpu"]: + line = line.strip("\n") + " (main: pass)\n" + except KeyError: + print( + f"Could not find {backend}.{version}.status.cpu for" + " document" + ) + f_write.write(line) diff --git a/scripts/run_tests/run_tests_pr.py b/scripts/run_tests/run_tests_pr.py index 1dba125255336..3d78479544b55 100644 --- a/scripts/run_tests/run_tests_pr.py +++ b/scripts/run_tests/run_tests_pr.py @@ -1,32 +1,14 @@ # Run Tests import os import sys -from pymongo import MongoClient - -from scripts.run_tests.run_tests import ( - get_latest_package_version, - get_submodule_and_function_name, -) if __name__ == "__main__": failed = False - cluster = MongoClient( - "mongodb+srv://readonly-user:hvpwV5yVeZdgyTTm@cluster0.qdvf8q3.mongodb.net" - ) - db = cluster["ci_dashboard"] with open(sys.argv[1], "w") as f_write: with open("tests_to_run", "r") as f: for line in f: test_path, backend = line.strip().split(",") - is_frontend_test = "test_frontends" in test_path - collection = ( - db["frontend_tests"] if is_frontend_test else db["ivy_tests"] - ) - submodule, function_name = get_submodule_and_function_name( - test_path, is_frontend_test - ) - version = get_latest_package_version(backend).replace(".", "_") print(f"\n{'*' * 100}") print(f"{line[:-1]}") print(f"{'*' * 100}\n") @@ -36,16 +18,6 @@ ) if ret != 0: failed = True - document = collection.find_one({"_id": function_name}) - if document: - try: - if document[backend][version]["status"]["cpu"]: - line = line.strip("\n") + " (main: pass)\n" - except KeyError: - print( - f"Could not find {backend}.{version}.status.cpu for" - f" document : {document}" - ) f_write.write(line) if failed: From e62eb4355eaf15f4c1616839ef1d8f0a4854f834 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kacper=20Ko=C5=BCdo=C5=84?= <102428159+Kacper-W-Kozdon@users.noreply.github.com> Date: Mon, 13 Nov 2023 19:55:17 +0100 Subject: [PATCH 161/978] fix: Reformatted gather to use torch backend for its backend-specific implementation. Updated docstrings. (#27071) Co-authored-by: @AnnaTz --- ivy/data_classes/array/general.py | 32 ++++++++++++++++++++++-- ivy/data_classes/container/general.py | 4 +-- ivy/functional/backends/torch/general.py | 13 +++++----- ivy/functional/ivy/general.py | 7 +++--- 4 files changed, 43 insertions(+), 13 deletions(-) diff --git a/ivy/data_classes/array/general.py b/ivy/data_classes/array/general.py index b17c29e0168d5..87d5bae046c94 100644 --- a/ivy/data_classes/array/general.py +++ b/ivy/data_classes/array/general.py @@ -219,9 +219,10 @@ def gather( axis The axis from which the indices will be gathered. Default is ``-1``. batch_dims - optional int, lets you gather different items from each element of a batch. + Optional int, lets you gather different items from each element of a batch. + Default is ``0``. out - optional array, for writing the result to. It must have a shape + Optional array, for writing the result to. It must have a shape that the inputs broadcast to. Returns @@ -237,6 +238,33 @@ def gather( >>> gather = x.gather(y) >>> print(gather) ivy.array([0., 1.]) + + >>> x = ivy.array([[0., 1., 2.],[3., 4., 5.]]) + >>> y = ivy.array([[0, 1],[1, 2]]) + >>> z = ivy.zeros((2, 2, 2)) + >>> gather = x.gather(y, out=z) + >>> print(z) + ivy.array([[[0., 1.],[1., 2.]],[[3., 4.],[4., 5.]]]) + + >>> x = ivy.array([[[0., 1.], [2., 3.]], + ... [[8., 9.], [10., 11.]]]) + >>> y = ivy.array([[0, 1]]) + >>> z = ivy.zeros((1, 2, 2, 2)) + >>> gather = x.gather(y, axis=0, out=z) + >>> print(z) + ivy.array( + [[[[ 0., 1.], + [ 2., 3.]], + [[ 8., 9.], + [10., 11.]]]]) + + >>> x = ivy.array([[0, 10, 20, 0, 0], + ... [0, 0, 0, 30, 40], + ... [0, 10, 0, 0, 40]]) + >>> y = ivy.array([[1, 2],[3, 4],[1, 4]]) + >>> gather = x.gather(y, batch_dims=1) + >>> print(gather) + ivy.array([[10, 20], [30, 40],[10, 40]]) """ return ivy.gather(self, indices, axis=axis, batch_dims=batch_dims, out=out) diff --git a/ivy/data_classes/container/general.py b/ivy/data_classes/container/general.py index 4dff39400124c..7d80783f03536 100644 --- a/ivy/data_classes/container/general.py +++ b/ivy/data_classes/container/general.py @@ -1437,7 +1437,7 @@ def _static_gather( Whether to also map method to sequences (lists, tuples). Default is ``False``. out - optional array, for writing the result to. It must have a shape + Optional array, for writing the result to. It must have a shape that the inputs broadcast to. @@ -1527,7 +1527,7 @@ def gather( Whether to also map method to sequences (lists, tuples). Default is False. out - optional array, for writing the result to. It must have a shape + Optional array, for writing the result to. It must have a shape that the inputs broadcast to. Returns diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 644b42f28bf7a..e907e93ee4a0b 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -187,9 +187,7 @@ def gather( ivy.utils.assertions.check_gather_input_valid(params, indices, axis, batch_dims) result = [] if batch_dims == 0: - result = params[ - (slice(None),) * (axis % params.ndim) + (indices.type(torch.int64),) - ] + result = torch.gather(params, axis, indices, sparse_grad=False, out=out) else: for b in range(batch_dims): if b == 0: @@ -200,12 +198,15 @@ def gather( ] for z in zip_list: p, i = z - r = p[ - (slice(None),) * ((axis - batch_dims) % p.ndim) + (i.type(torch.int64),) - ] + r = torch.gather( + p, (axis - batch_dims) % p.ndim, i, sparse_grad=False, out=False + ) + result.append(r) result = torch.stack(result) result = result.reshape([*params.shape[0:batch_dims], *result.shape[1:]]) + if out: + out[:] = result return result diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index aa26607723101..eb24eba85ff0e 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -3524,12 +3524,13 @@ def gather( The array which indicates the indices that will be gathered along the specified axis. axis - optional int, the axis from which to gather from. + Optional int, the axis from which to gather from. Default is ``-1``. batch_dims - optional int, lets you gather different items from each element of a batch. + Optional int, lets you gather different items from each element of a batch. + Default is ``0``. out - optional array, for writing the result to. It must have a shape + Optional array, for writing the result to. It must have a shape that the inputs broadcast to. Returns From d07e75117bf5b5bb7a7f7945448f238442508347 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 10:49:33 +0530 Subject: [PATCH 162/978] fix(ci): added missing pymongo installation to the intelligent-tests-pr display-test-results job (#27264) --- .github/workflows/intelligent-tests-pr.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index f160334b5db6e..5ac1abef6adb7 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -27,6 +27,7 @@ jobs: - name: Test Failures run: | find . -name "test_failures_*.txt" -exec cat {} + > combined_failures.txt + pip install pymongo python3 scripts/run_tests/label_failures.py combined_failures.txt labeled_combined_failures.txt if [ -s labeled_combined_failures.txt ] then @@ -84,7 +85,7 @@ jobs: id: tests run: | git clone -b master${{ matrix.branch }} https://github.com/unifyai/Mapping.git --depth 1 - pip install pydriller GitPython pymongo + pip install pydriller GitPython python ivy/scripts/setup_tests/clone-mapping.py cp Mapping/tests.pbz2 ivy/ cd ivy From 87d9aa0f6ed5525901fc79d92d8ef172bd6f734e Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 14 Nov 2023 05:43:14 +0000 Subject: [PATCH 163/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index f0fc2b6e8ddf5..6ce352f01c67c 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit f0fc2b6e8ddf5aa28093a55a755d14f04e628973 +Subproject commit 6ce352f01c67c70f08dcee7c4c46d1b6ae582b22 From 31fea87b54191e5c420e69beca38156dd84849b0 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 14 Nov 2023 05:45:34 +0000 Subject: [PATCH 164/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 6ce352f01c67c..2074a4c63877f 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 6ce352f01c67c70f08dcee7c4c46d1b6ae582b22 +Subproject commit 2074a4c63877fbf04dbd6aba14a5d9e188f009c5 From cd115929c2a3f69663aae83d72480493bc1945c1 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 09:18:45 +0300 Subject: [PATCH 165/978] fix: updated the import in label_failures.py --- scripts/run_tests/label_failures.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/run_tests/label_failures.py b/scripts/run_tests/label_failures.py index 8e97d0891b3bd..1540776d4d20a 100644 --- a/scripts/run_tests/label_failures.py +++ b/scripts/run_tests/label_failures.py @@ -2,7 +2,7 @@ import sys from pymongo import MongoClient -from scripts.run_tests.run_tests import ( +from run_tests import ( get_latest_package_version, get_submodule_and_function_name, ) From 42a2243bd9225585a901469a2b2860f08315e28c Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 13:26:17 +0530 Subject: [PATCH 166/978] fix(ci): Added a helpers file to run_tests (#27265) Moved the helpers for getting the latest package version and the submodule and function name to a separate file as they're required by both run_tests and label_failures --- scripts/run_tests/helpers.py | 64 +++++++++++++++++++++++++++ scripts/run_tests/label_failures.py | 2 +- scripts/run_tests/run_tests.py | 68 ++--------------------------- 3 files changed, 69 insertions(+), 65 deletions(-) create mode 100644 scripts/run_tests/helpers.py diff --git a/scripts/run_tests/helpers.py b/scripts/run_tests/helpers.py new file mode 100644 index 0000000000000..9d2f1a7928571 --- /dev/null +++ b/scripts/run_tests/helpers.py @@ -0,0 +1,64 @@ +import requests + + +def get_latest_package_version(package_name): + try: + url = f"https://pypi.org/pypi/{package_name}/json" + response = requests.get(url) + response.raise_for_status() + package_info = response.json() + return package_info["info"]["version"] + except requests.exceptions.RequestException: + print(f"Error: Failed to fetch package information for {package_name}.") + return None + + +def get_submodule_and_function_name(test_path, is_frontend_test=False): + submodule_test = test_path.split("/")[-1] + submodule, test_function = submodule_test.split("::") + submodule = submodule.replace("test_", "").replace(".py", "") + + with open(test_path.split("::")[0]) as test_file: + test_file_content = test_file.read() + test_function_idx = test_file_content.find(f"def {test_function}") + test_function_block_idx = test_file_content[:test_function_idx].rfind("\n\n") + if test_function_block_idx == -1: + return submodule, None + relevant_file_content = test_file_content[ + test_function_block_idx:test_function_idx + ] + fn_tree_idx = relevant_file_content.rfind('fn_tree="') + + # frontend test + if is_frontend_test: + function_name = relevant_file_content[fn_tree_idx + 9 :].split('"')[0] + + # instance method test + if fn_tree_idx == -1: + class_tree_idx = test_file_content.find('CLASS_TREE = "') + method_name_idx = relevant_file_content.rfind('method_name="') + if class_tree_idx == -1 or method_name_idx == -1: + return submodule, None + class_tree = test_file_content[class_tree_idx + 14 :].split('"')[0] + class_name = ".".join(class_tree.split(".")[3:]) + method_name = relevant_file_content[method_name_idx + 13 :].split('"')[ + 0 + ] + function_name = f"{class_name}.{method_name}" + + # ivy test + else: + function_name = test_function[5:] + + # instance method test + if fn_tree_idx == -1: + method_name_idx = relevant_file_content.rfind('method_tree="') + if method_name_idx != -1: + method_name = relevant_file_content[method_name_idx + 13 :].split( + '"' + )[0] + function_name = f"ivy.{method_name}" + else: + return submodule, None + + return submodule, function_name diff --git a/scripts/run_tests/label_failures.py b/scripts/run_tests/label_failures.py index 1540776d4d20a..2753e86192fa4 100644 --- a/scripts/run_tests/label_failures.py +++ b/scripts/run_tests/label_failures.py @@ -2,7 +2,7 @@ import sys from pymongo import MongoClient -from run_tests import ( +from helpers import ( get_latest_package_version, get_submodule_and_function_name, ) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 1dadc0d123b45..de43288296102 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -3,75 +3,15 @@ import sys from pymongo import MongoClient from pymongo.errors import WriteError -import requests import json import old_run_test_helpers as old_helpers +from helpers import ( + get_latest_package_version, + get_submodule_and_function_name, +) from get_all_tests import BACKENDS -def get_latest_package_version(package_name): - try: - url = f"https://pypi.org/pypi/{package_name}/json" - response = requests.get(url) - response.raise_for_status() - package_info = response.json() - return package_info["info"]["version"] - except requests.exceptions.RequestException: - print(f"Error: Failed to fetch package information for {package_name}.") - return None - - -def get_submodule_and_function_name(test_path, is_frontend_test=False): - submodule_test = test_path.split("/")[-1] - submodule, test_function = submodule_test.split("::") - submodule = submodule.replace("test_", "").replace(".py", "") - - with open(test_path.split("::")[0]) as test_file: - test_file_content = test_file.read() - test_function_idx = test_file_content.find(f"def {test_function}") - test_function_block_idx = test_file_content[:test_function_idx].rfind("\n\n") - if test_function_block_idx == -1: - return submodule, None - relevant_file_content = test_file_content[ - test_function_block_idx:test_function_idx - ] - fn_tree_idx = relevant_file_content.rfind('fn_tree="') - - # frontend test - if is_frontend_test: - function_name = relevant_file_content[fn_tree_idx + 9 :].split('"')[0] - - # instance method test - if fn_tree_idx == -1: - class_tree_idx = test_file_content.find('CLASS_TREE = "') - method_name_idx = relevant_file_content.rfind('method_name="') - if class_tree_idx == -1 or method_name_idx == -1: - return submodule, None - class_tree = test_file_content[class_tree_idx + 14 :].split('"')[0] - class_name = ".".join(class_tree.split(".")[3:]) - method_name = relevant_file_content[method_name_idx + 13 :].split('"')[ - 0 - ] - function_name = f"{class_name}.{method_name}" - - # ivy test - else: - function_name = test_function[5:] - - # instance method test - if fn_tree_idx == -1: - method_name_idx = relevant_file_content.rfind('method_tree="') - if method_name_idx != -1: - method_name = relevant_file_content[method_name_idx + 13 :].split( - '"' - )[0] - function_name = f"ivy.{method_name}" - else: - return submodule, None - - return submodule, function_name - - if __name__ == "__main__": redis_url = sys.argv[1] redis_pass = sys.argv[2] From 97062afff1c80461eda58735380ddfa82d1ed156 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 13:28:14 +0530 Subject: [PATCH 167/978] fix: Updated setup.py so that pip._vendor.packaging isn't required if the TAG for building is explicitly set (#27266) --- setup.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/setup.py b/setup.py index ae87c18254b6b..f2b6becbeb976 100644 --- a/setup.py +++ b/setup.py @@ -18,7 +18,6 @@ import setuptools from setuptools import setup from pathlib import Path -from pip._vendor.packaging import tags from urllib import request import os import json @@ -50,12 +49,15 @@ def _strip(line): version = os.environ["VERSION"] if "VERSION" in os.environ else "main" terminate = False fixed_tag = os.environ["TAG"] if "TAG" in os.environ else None -all_tags = list(tags.sys_tags()) -python_tag, plat_name, options = None, None, None +all_tags, python_tag, plat_name, options = None, None, None, None if fixed_tag: python_tag, _, plat_name = str(fixed_tag).split("-") options = {"bdist_wheel": {"python_tag": python_tag, "plat_name": plat_name}} all_tags = [fixed_tag] +else: + from pip._vendor.packaging import tags + + all_tags = list(tags.sys_tags()) # download binaries for the tag with highest precedence for tag in all_tags: From 4d2ca0a311b2c02cf42201adefc3a20b088e8d72 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 14 Nov 2023 08:12:13 +0000 Subject: [PATCH 168/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 2074a4c63877f..a9df14de2a800 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 2074a4c63877fbf04dbd6aba14a5d9e188f009c5 +Subproject commit a9df14de2a8006161528ef0df609eb201914a0cb From 0f6f56e6f2ab92670f69bc5719ebc3706f94c2ff Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 13:49:15 +0530 Subject: [PATCH 169/978] fix(ivy): removed the python_requires restriction in setup.py as ivy can still be installed with other versions though without the binaries --- setup.py | 1 - 1 file changed, 1 deletion(-) diff --git a/setup.py b/setup.py index f2b6becbeb976..e98695ecf1b84 100644 --- a/setup.py +++ b/setup.py @@ -129,7 +129,6 @@ def _strip(line): _strip(line) for line in open("requirements/requirements.txt", "r", encoding="utf-8") ], - python_requires=">=3.8,<=3.11", classifiers=[ "License :: OSI Approved :: Apache Software License", ], From 95fda4a850aeb5bbf732760d77c25f92a58ca545 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 14 Nov 2023 08:20:48 +0000 Subject: [PATCH 170/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index a9df14de2a800..11e672f8576c4 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit a9df14de2a8006161528ef0df609eb201914a0cb +Subproject commit 11e672f8576c4d49969ae1402d41f1c8b63746eb From 3260ec4308298bed5149e5abd92add5bf923a0f1 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 17:26:08 +0530 Subject: [PATCH 171/978] fix: Added the auth code to use the same logic for the gpu cron jobs like the demos tests (#27233) --- .github/workflows/test-ivy-cron-gpu.yml | 60 ++++++++++++++++++++++--- scripts/run_tests/run_tests.py | 10 +++-- 2 files changed, 60 insertions(+), 10 deletions(-) diff --git a/.github/workflows/test-ivy-cron-gpu.yml b/.github/workflows/test-ivy-cron-gpu.yml index fd1c3b592a06b..f1a8cd769e1cc 100644 --- a/.github/workflows/test-ivy-cron-gpu.yml +++ b/.github/workflows/test-ivy-cron-gpu.yml @@ -6,24 +6,53 @@ on: permissions: actions: read jobs: + start-vm: + runs-on: ubuntu-latest + if: always() # Run this job always, regardless of the status of run-test-basics + steps: + - name: Checkout Demos🛎 + uses: actions/checkout@v4 + with: + repository: unifyai/demos + path: demos + persist-credentials: false + submodules: "recursive" + fetch-depth: 1 + + - name: Install clients for GCP/Mongo + run: | + pip3 install pymongo google-api-python-client paramiko + + - name: Start GPU VM + run: | + cd demos/tests/auth + mkdir -p ~/.ssh + touch ~/.ssh/id_rsa + echo -n "${{ secrets.GPU_SSH_KEY }}" > ~/.ssh/id_rsa + chmod +x ~/.ssh/id_rsa + python3 db_auth.py ${{ secrets.GPU_DB_ENDPOINT }} ${{ secrets.GPU_DB_OBJ_ID }} + python3 vm_auth.py ${{ secrets.GPU_SSH_USERNAME }} ${{ secrets.GPU_SSH_PASSPHRASE }} "false" "ivy-repo-gpu-testing" + run-gpu-tests: + needs: start-vm runs-on: self-hosted steps: - name: Clean Repository run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE - - name: Checkout Ivy 🛎 + - name: Checkout 🛎️Ivy uses: actions/checkout@v2 with: path: ivy persist-credentials: false submodules: "recursive" - set-safe-directory: false + fetch-depth: 2 - name: Install ivy and fetch binaries run: | cd ivy + export TAG="cp310-cp310-manylinux_2_17_x86_64" pip3 install -e . mkdir .ivy touch .ivy/key.pem @@ -44,8 +73,27 @@ jobs: cd ivy python3 scripts/setup_tests/cron_tests.py ${{ github.run_number }} python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} - continue-on-error: true - - name: Check on failures - if: steps.tests.outcome != 'success' - run: exit 1 + stop-vm: + needs: run-gpu-tests + runs-on: ubuntu-latest + if: always() # Run this job always, regardless of the status of run-test + steps: + - name: Checkout Demos🛎 + uses: actions/checkout@v4 + with: + repository: unifyai/demos + path: demos + persist-credentials: false + submodules: "recursive" + fetch-depth: 1 + + - name: Install clients for GCP/Mongo + run: | + pip3 install pymongo google-api-python-client paramiko + + - name: Stop GPU VM + run: | + cd demos/tests/auth + python3 db_auth.py ${{ secrets.GPU_DB_ENDPOINT }} ${{ secrets.GPU_DB_OBJ_ID }} + python3 vm_auth.py ${{ secrets.GPU_SSH_USERNAME }} ${{ secrets.GPU_SSH_PASSPHRASE }} "true" "ivy-repo-gpu-testing" diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index de43288296102..c86ac15803e5f 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -95,21 +95,23 @@ else: device_str = "" + device_access_str = "" image = "unifyai/ivy:latest" # gpu tests if device == "gpu": image = "unifyai/ivy:latest-gpu" device_str = " --device=gpu:0" + device_access_str = " --gpus all" os.system( - 'docker run --name test-container -v "$(pwd)":/ivy -v ' - f'"$(pwd)"/.hypothesis:/.hypothesis -e REDIS_URL={redis_url} ' - f"-e REDIS_PASSWD={redis_pass} -itd {image}" + f"docker run{device_access_str} --name test-container -v " + '"$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis -e ' + f"REDIS_URL={redis_url} -e REDIS_PASSWD={redis_pass} -itd {image}" ) command = ( "docker exec test-container python3 -m pytest --tb=short" - f" {test_path} {device_str} --backend {backend}" + f" {test_path}{device_str} --backend {backend}" ) os.system(command) From bfa806ced8a6fd3e9b8e74884238a2934cc7681a Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 17:46:42 +0530 Subject: [PATCH 172/978] chore(ci): Added workflow concurrency to test-ivy-cron-gpu.yml --- .github/workflows/test-ivy-cron-gpu.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/test-ivy-cron-gpu.yml b/.github/workflows/test-ivy-cron-gpu.yml index f1a8cd769e1cc..f28b6aa6bf566 100644 --- a/.github/workflows/test-ivy-cron-gpu.yml +++ b/.github/workflows/test-ivy-cron-gpu.yml @@ -5,6 +5,9 @@ on: - cron: '25 * * * *' permissions: actions: read +concurrency: + group: ${{ github.workflow }} + cancel-in-progress: false jobs: start-vm: runs-on: ubuntu-latest From 8a255afc20ed0a30710a4cf516867f9a29a89fe4 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 17:52:21 +0530 Subject: [PATCH 173/978] fix: Added shallow ivy checkout in intelligent-tests-pr display-test-results job for using the scripts (#27277) --- .github/workflows/intelligent-tests-pr.yml | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index 5ac1abef6adb7..811f44d46a1b5 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -18,6 +18,14 @@ jobs: - name: Download all test results uses: actions/download-artifact@v3 + - name: Checkout Ivy 🛎 + uses: actions/checkout@v3 + with: + path: ivy + persist-credentials: false + submodules: "recursive" + fetch-depth: 1 + - name: Combined Test Results run: | find . -name "test_results_*.txt" -exec cat {} + > combined_test_results.txt @@ -26,8 +34,9 @@ jobs: - name: Test Failures run: | - find . -name "test_failures_*.txt" -exec cat {} + > combined_failures.txt + find . -name "test_failures_*.txt" -exec cat {} + > ivy/combined_failures.txt pip install pymongo + cd ivy python3 scripts/run_tests/label_failures.py combined_failures.txt labeled_combined_failures.txt if [ -s labeled_combined_failures.txt ] then @@ -107,12 +116,6 @@ jobs: name: test_failures_${{ matrix.branch }} path: ivy/test_failures_${{ matrix.branch }}.txt - - name: Upload Labelling Script - uses: actions/upload-artifact@v3 - with: - name: scripts - path: ivy/scripts - - name: Check on failures if: steps.tests.outcome != 'success' run: exit 1 From a5c9eae4532b198e5f229d6324142b2caf643ed5 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 17:57:17 +0530 Subject: [PATCH 174/978] fix: updated conftest.py to not skip the test for ground truth backend (#27278) Because it's required to record transpilation metrics for the ground truth backend --- ivy_tests/test_ivy/conftest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/conftest.py b/ivy_tests/test_ivy/conftest.py index 6316ce57043c8..eed878de15f5b 100644 --- a/ivy_tests/test_ivy/conftest.py +++ b/ivy_tests/test_ivy/conftest.py @@ -28,7 +28,7 @@ UNSET_TEST_API_CONFIG = {"list": [], "flag": []} TEST_PARAMS_CONFIG = [] -SKIP_GROUND_TRUTH = True +SKIP_GROUND_TRUTH = False UNSUPPORTED_FRAEMWORK_DEVICES = {"numpy": ["gpu", "tpu"]} if "ARRAY_API_TESTS_MODULE" not in os.environ: os.environ["ARRAY_API_TESTS_MODULE"] = "ivy.functional.backends.numpy" From 62242b34f040bb612b7594f0cacd82e0abed3cc5 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 18:18:51 +0530 Subject: [PATCH 175/978] fix: commented out the skipping of ground truth backend tests without transpilation tests for now --- ivy_tests/test_ivy/conftest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/conftest.py b/ivy_tests/test_ivy/conftest.py index eed878de15f5b..9cb8e15586fb8 100644 --- a/ivy_tests/test_ivy/conftest.py +++ b/ivy_tests/test_ivy/conftest.py @@ -297,8 +297,8 @@ def process_cl_flags(config) -> Dict[str, bool]: } # whether to skip gt testing or not - global SKIP_GROUND_TRUTH - SKIP_GROUND_TRUTH = not tmp_config["transpile"][1] + # global SKIP_GROUND_TRUTH + # SKIP_GROUND_TRUTH = not tmp_config["transpile"][1] # final mapping for hypothesis value generation for k, v in tmp_config.items(): From f2a0224f9895dc3d78d6216a17024b3490bf52e4 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 14 Nov 2023 13:21:03 +0000 Subject: [PATCH 176/978] refactor: Re-arranged conditions to avoid unnecessary operations and pad calls in max_pool functions. --- .../tensorflow/experimental/layers.py | 120 +++++++++--------- .../backends/torch/experimental/layers.py | 113 ++++++++--------- 2 files changed, 111 insertions(+), 122 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 1b2962f8fc158..ffa8da38b5333 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -65,25 +65,26 @@ def max_pool1d( ) if not depth_pooling: - new_kernel = [kernel[0] + (kernel[0] - 1) * (dilation[0] - 1)] - if isinstance(padding, str): - pad_w = _handle_padding(x.shape[1], strides[0], new_kernel[0], padding) - padding = [(pad_w // 2, pad_w - pad_w // 2)] - if ceil_mode: + new_kernel = [kernel[0] + (kernel[0] - 1) * (dilation[0] - 1)] + if isinstance(padding, str): + pad_w = _handle_padding(x.shape[1], strides[0], new_kernel[0], padding) + padding = [(pad_w // 2, pad_w - pad_w // 2)] padding[0] = _padding_ceil_mode( x.shape[1], new_kernel[0], padding[0], strides[0] ) - padding = [(0, 0)] + list(padding) + [(0, 0)] - x = tf.pad(x, padding, constant_values=-math.inf) - elif isinstance(padding, list) and any( - item != 0 for sublist in padding for item in sublist - ): - raise NotImplementedError( - "Nonzero explicit padding is not supported for depthwise max pooling" - ) - - res = tf.nn.pool(x, kernel, "MAX", strides, "VALID", dilations=dilation) + if ceil_mode or not isinstance(padding, str): + padding = [(0, 0)] + list(padding) + [(0, 0)] + x = tf.pad(x, padding, constant_values=-math.inf) + padding = "VALID" + elif isinstance(padding, list): + if any(item != 0 for sublist in padding for item in sublist): + raise NotImplementedError( + "Nonzero explicit padding is not supported for depthwise max pooling" + ) + else: + padding = "VALID" + res = tf.nn.pool(x, kernel, "MAX", strides, padding, dilations=dilation) if depth_pooling: res = tf.transpose(res, (0, 2, 1)) @@ -133,34 +134,34 @@ def max_pool2d( ) if not depth_pooling: - new_kernel = [ - kernel[i] + (kernel[i] - 1) * (dilation[i] - 1) for i in range(dims) - ] - if isinstance(padding, str): - pad_h = _handle_padding(x.shape[1], strides[0], new_kernel[0], padding) - pad_w = _handle_padding(x.shape[2], strides[1], new_kernel[1], padding) - padding = [ - (pad_h // 2, pad_h - pad_h // 2), - (pad_w // 2, pad_w - pad_w // 2), - ] - if ceil_mode: + new_kernel = [ + kernel[i] + (kernel[i] - 1) * (dilation[i] - 1) for i in range(dims) + ] + if isinstance(padding, str): + pad_h = _handle_padding(x.shape[1], strides[0], new_kernel[0], padding) + pad_w = _handle_padding(x.shape[2], strides[1], new_kernel[1], padding) + padding = [ + (pad_h // 2, pad_h - pad_h // 2), + (pad_w // 2, pad_w - pad_w // 2), + ] x_shape = x.shape[1:-1] - for i in range(dims): padding[i] = _padding_ceil_mode( x_shape[i], new_kernel[i], padding[i], strides[i] ) - padding = [(0, 0)] + list(padding) + [(0, 0)] - x = tf.pad(x, padding, constant_values=-math.inf) - elif isinstance(padding, list) and any( - item != 0 for sublist in padding for item in sublist - ): - raise NotImplementedError( - "Nonzero explicit padding is not supported for depthwise max pooling" - ) - - res = tf.nn.pool(x, kernel, "MAX", strides, "VALID", dilations=dilation) + if ceil_mode or not isinstance(padding, str): + padding = [(0, 0)] + list(padding) + [(0, 0)] + x = tf.pad(x, padding, constant_values=-math.inf) + padding = "VALID" + elif isinstance(padding, list): + if any(item != 0 for sublist in padding for item in sublist): + raise NotImplementedError( + "Nonzero explicit padding is not supported for depthwise max pooling" + ) + else: + padding = "VALID" + res = tf.nn.pool(x, kernel, "MAX", strides, padding, dilations=dilation) if depth_pooling: res = tf.transpose(res, (0, 2, 3, 1)) @@ -215,33 +216,34 @@ def max_pool3d( ) if not depth_pooling: - new_kernel = [dilation[i] * (kernel[i] - 1) + 1 for i in range(dims)] - x_shape = x.shape[1:-1] - if isinstance(padding, str): - pad_d = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) - pad_h = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) - pad_w = _handle_padding(x_shape[2], strides[2], new_kernel[2], padding) - padding = [ - (pad_d // 2, pad_d - pad_d // 2), - (pad_h // 2, pad_h - pad_h // 2), - (pad_w // 2, pad_w - pad_w // 2), - ] - if ceil_mode: + new_kernel = [dilation[i] * (kernel[i] - 1) + 1 for i in range(dims)] + x_shape = x.shape[1:-1] + if isinstance(padding, str): + pad_d = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) + pad_h = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) + pad_w = _handle_padding(x_shape[2], strides[2], new_kernel[2], padding) + padding = [ + (pad_d // 2, pad_d - pad_d // 2), + (pad_h // 2, pad_h - pad_h // 2), + (pad_w // 2, pad_w - pad_w // 2), + ] for i in range(dims): padding[i] = _padding_ceil_mode( x_shape[i], new_kernel[i], padding[i], strides[i] ) - padding = [(0, 0)] + list(padding) + [(0, 0)] - x = tf.pad(x, padding, constant_values=-math.inf) - elif isinstance(padding, list) and any( - item != 0 for sublist in padding for item in sublist - ): - raise NotImplementedError( - "Nonzero explicit padding is not supported for depthwise max pooling" - ) - - res = tf.nn.pool(x, kernel, "MAX", strides, "VALID", dilations=dilation) + if ceil_mode or not isinstance(padding, str): + padding = [(0, 0)] + list(padding) + [(0, 0)] + x = tf.pad(x, padding, constant_values=-math.inf) + padding = "VALID" + elif isinstance(padding, list): + if any(item != 0 for sublist in padding for item in sublist): + raise NotImplementedError( + "Nonzero explicit padding is not supported for depthwise max pooling" + ) + else: + padding = "VALID" + res = tf.nn.pool(x, kernel, "MAX", strides, padding, dilations=dilation) if depth_pooling: res = tf.transpose(res, (0, 2, 3, 4, 1)) diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index b6dc35c313747..69a55000cd6b6 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -64,24 +64,21 @@ def max_pool1d( x, kernel, strides, dims, data_format="channel_first" ) - if not depth_pooling: + if isinstance(padding, str): new_kernel = [dilation[0] * (kernel[0] - 1) + 1] - - if isinstance(padding, str): - pad_w = _handle_padding(x.shape[2], strides[0], new_kernel[0], padding) - pad_list = [pad_w // 2, pad_w - pad_w // 2] - else: - pad_list = [item for sublist in padding for item in sublist] - - x = torch.nn.functional.pad( - x, - pad_list, - value=float("-inf"), - ) + pad_w = _handle_padding(x.shape[2], strides[0], new_kernel[0], padding) + pad_list = [pad_w // 2, pad_w - pad_w // 2] else: - if isinstance(padding, list) and any( - item != 0 for sublist in padding for item in sublist - ): + pad_list = [item for sublist in padding for item in sublist] + + if any(pad > 0 for pad in pad_list): + if not depth_pooling: + x = torch.nn.functional.pad( + x, + pad_list, + value=float("-inf"), + ) + else: raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" ) @@ -142,28 +139,23 @@ def max_pool2d( x, kernel, strides, dims, data_format="channel_first" ) - x_shape = list(x.shape[2:]) - if not depth_pooling: + if isinstance(padding, str): + x_shape = list(x.shape[2:]) new_kernel = [kernel[i] + (kernel[i] - 1) * (dilation[i] - 1) for i in range(2)] - - if isinstance(padding, str): - pad_h = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) - pad_w = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) - pad_list = [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2] - else: - # torch pad takes width padding first, then height padding - padding = (padding[1], padding[0]) - pad_list = [item for sublist in padding for item in sublist] - - x = torch.nn.functional.pad( - x, - pad_list, - value=float("-inf"), - ) + pad_h = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) + pad_w = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) + pad_list = [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2] else: - if isinstance(padding, list) and any( - item != 0 for sublist in padding for item in sublist - ): + pad_list = [item for sublist in padding[::-1] for item in sublist] + + if any(pad > 0 for pad in pad_list): + if not depth_pooling: + x = torch.nn.functional.pad( + x, + pad_list, + value=float("-inf"), + ) + else: raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" ) @@ -225,36 +217,31 @@ def max_pool3d( x, kernel, strides, dims, data_format="channel_first" ) - if not depth_pooling: + if isinstance(padding, str): x_shape = x.shape[2:] new_kernel = [dilation[i] * (kernel[i] - 1) + 1 for i in range(dims)] - - if isinstance(padding, str): - pad_d = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) - pad_h = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) - pad_w = _handle_padding(x_shape[2], strides[2], new_kernel[2], padding) - pad_list = [ - pad_w // 2, - pad_w - pad_w // 2, - pad_h // 2, - pad_h - pad_h // 2, - pad_d // 2, - pad_d - pad_d // 2, - ] - else: - # torch pad takes width padding first, then height, then depth - padding = (padding[2], padding[1], padding[0]) - pad_list = [item for sublist in padding for item in sublist] - - x = torch.nn.functional.pad( - x, - pad_list, - value=float("-inf"), - ) + pad_d = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) + pad_h = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) + pad_w = _handle_padding(x_shape[2], strides[2], new_kernel[2], padding) + pad_list = [ + pad_w // 2, + pad_w - pad_w // 2, + pad_h // 2, + pad_h - pad_h // 2, + pad_d // 2, + pad_d - pad_d // 2, + ] else: - if isinstance(padding, list) and any( - item != 0 for sublist in padding for item in sublist - ): + pad_list = [item for sublist in padding[::-1] for item in sublist] + + if any(pad > 0 for pad in pad_list): + if not depth_pooling: + x = torch.nn.functional.pad( + x, + pad_list, + value=float("-inf"), + ) + else: raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" ) From b1cb146dc63c419e758d8485d6617f796321a388 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 14 Nov 2023 13:22:14 +0000 Subject: [PATCH 177/978] refactor: Removed duplicate line. --- ivy/functional/ivy/layers.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index e3e1c354577dd..72a999a9809d7 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -2440,7 +2440,6 @@ def _validate_max_pool_params( else: kernel = [1, *kernel, 1] new_kernel = tuple(dilation[i] * (kernel[i] - 1) + 1 for i in range(1, len(kernel))) - new_kernel = tuple(dilation[i] * (kernel[i] - 1) + 1 for i in range(1, len(kernel))) if isinstance(padding, list) and len(padding) == len(new_kernel): ivy.utils.assertions.check_kernel_padding_size(new_kernel, padding) From 83f3c41e2724361882365f12f14c8e4e6fe716c1 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 19:07:46 +0530 Subject: [PATCH 178/978] chore(ci): separated the labelling failures and displaying failures sections in the intelligent tests to clean up the logs (#27282) --- .github/workflows/intelligent-tests-pr.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index 811f44d46a1b5..66c3af4eb79c9 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -32,12 +32,16 @@ jobs: echo "Test results summary:" cat combined_test_results.txt - - name: Test Failures + - name: Label Test Failures run: | find . -name "test_failures_*.txt" -exec cat {} + > ivy/combined_failures.txt pip install pymongo cd ivy python3 scripts/run_tests/label_failures.py combined_failures.txt labeled_combined_failures.txt + + - name: Display Test Failures + run: | + cd ivy if [ -s labeled_combined_failures.txt ] then echo "The CI captured the following failing tests based on your changes:" From 4d914cbb251d868dcb63f488f00f47568a69e641 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 14 Nov 2023 14:28:51 +0000 Subject: [PATCH 179/978] fix: Fixed dtype error in tf backend of pad and updated docstrings --- .../backends/jax/experimental/manipulation.py | 9 +++++---- .../numpy/experimental/manipulation.py | 9 +++++---- .../paddle/experimental/manipulation.py | 17 ++++++++++++---- .../tensorflow/experimental/manipulation.py | 20 +++++++++++++++---- .../torch/experimental/manipulation.py | 17 ++++++++++++---- 5 files changed, 52 insertions(+), 20 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/manipulation.py b/ivy/functional/backends/jax/experimental/manipulation.py index fc760a9929655..1eb7c5ac75315 100644 --- a/ivy/functional/backends/jax/experimental/manipulation.py +++ b/ivy/functional/backends/jax/experimental/manipulation.py @@ -1,5 +1,6 @@ # local from typing import ( + Iterable, Optional, Union, Sequence, @@ -146,7 +147,7 @@ def _to_nested_tuple(nested_list): def pad( input: JaxArray, - pad_width: Union[Sequence[Sequence[int]], JaxArray, int], + pad_width: Union[Iterable[Tuple[int]], int], /, *, mode: Union[ @@ -166,9 +167,9 @@ def pad( ], Callable, ] = "constant", - stat_length: Union[Sequence[Sequence[int]], int] = 1, - constant_values: Union[Sequence[Sequence[Number]], Number] = 0, - end_values: Union[Sequence[Sequence[Number]], Number] = 0, + stat_length: Union[Iterable[Tuple[int]], int] = 1, + constant_values: Union[Iterable[Tuple[Number]], Number] = 0, + end_values: Union[Iterable[Tuple[Number]], Number] = 0, reflect_type: Literal["even", "odd"] = "even", **kwargs: Optional[Any], ) -> JaxArray: diff --git a/ivy/functional/backends/numpy/experimental/manipulation.py b/ivy/functional/backends/numpy/experimental/manipulation.py index cefc371fedb26..9a86855d16ec6 100644 --- a/ivy/functional/backends/numpy/experimental/manipulation.py +++ b/ivy/functional/backends/numpy/experimental/manipulation.py @@ -1,5 +1,6 @@ # global from typing import ( + Iterable, Optional, Union, Sequence, @@ -201,7 +202,7 @@ def _interior_pad(operand, padding_value, padding_config): def pad( input: np.ndarray, - pad_width: Union[Sequence[Sequence[int]], np.ndarray, int], + pad_width: Union[Iterable[Tuple[int]], int], /, *, mode: Union[ @@ -221,9 +222,9 @@ def pad( ], Callable, ] = "constant", - stat_length: Union[Sequence[Sequence[int]], int] = 1, - constant_values: Union[Sequence[Sequence[Number]], Number] = 0, - end_values: Union[Sequence[Sequence[Number]], Number] = 0, + stat_length: Union[Iterable[Tuple[int]], int] = 1, + constant_values: Union[Iterable[Tuple[Number]], Number] = 0, + end_values: Union[Iterable[Tuple[Number]], Number] = 0, reflect_type: Literal["even", "odd"] = "even", **kwargs: Optional[Any], ) -> np.ndarray: diff --git a/ivy/functional/backends/paddle/experimental/manipulation.py b/ivy/functional/backends/paddle/experimental/manipulation.py index 9fa5e60405ac0..61fdaae94fd93 100644 --- a/ivy/functional/backends/paddle/experimental/manipulation.py +++ b/ivy/functional/backends/paddle/experimental/manipulation.py @@ -1,5 +1,6 @@ from collections import namedtuple from typing import ( + Iterable, Optional, Union, Sequence, @@ -125,21 +126,29 @@ def moveaxis( ) def pad( input: paddle.Tensor, - pad_width: Union[Sequence[Sequence[int]], paddle.Tensor, int], + pad_width: Union[Iterable[Tuple[int]], int], /, *, mode: Union[ Literal[ "constant", + "dilated", "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", "reflect", + "symmetric", "wrap", + "empty", ], Callable, ] = "constant", - stat_length: Union[Sequence[paddle.Tensor], int] = 1, - constant_values: Number = 0, - end_values: Number = 0, + stat_length: Union[Iterable[Tuple[int]], int] = 1, + constant_values: Union[Iterable[Tuple[Number]], Number] = 0, + end_values: Union[Iterable[Tuple[Number]], Number] = 0, reflect_type: Literal["even", "odd"] = "even", **kwargs: Optional[Any], ) -> paddle.Tensor: diff --git a/ivy/functional/backends/tensorflow/experimental/manipulation.py b/ivy/functional/backends/tensorflow/experimental/manipulation.py index 17fff8ff50f42..67119d4cf2b8c 100644 --- a/ivy/functional/backends/tensorflow/experimental/manipulation.py +++ b/ivy/functional/backends/tensorflow/experimental/manipulation.py @@ -1,6 +1,7 @@ # global from collections import namedtuple from typing import ( + Iterable, Union, Optional, Sequence, @@ -266,27 +267,38 @@ def broadcast_shapes( def pad( input: Union[tf.Tensor, tf.Variable], - pad_width: Union[Sequence[Sequence[int]], Union[tf.Tensor, tf.Variable], int], + pad_width: Union[Iterable[Tuple[int]], int], /, *, mode: Union[ Literal[ "constant", + "dilated", "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", "reflect", + "symmetric", "wrap", + "empty", ], Callable, ] = "constant", - stat_length: Union[Sequence[Union[tf.Tensor, tf.Variable]], int] = 1, - constant_values: Number = 0, - end_values: Number = 0, + stat_length: Union[Iterable[Tuple[int]], int] = 1, + constant_values: Union[Iterable[Tuple[Number]], Number] = 0, + end_values: Union[Iterable[Tuple[Number]], Number] = 0, reflect_type: Literal["even", "odd"] = "even", **kwargs: Optional[Any], ) -> Union[tf.Tensor, tf.Variable]: pad_width = _to_tf_padding(pad_width, len(input.shape)) if not isinstance(pad_width, (tf.Variable, tf.Tensor)): pad_width = tf.constant(pad_width) + constant_values = tf.constant(constant_values) + if constant_values.dtype != input.dtype: + constant_values = tf.cast(constant_values, input.dtype) return tf.pad( input, pad_width, diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index 5603bf44ad13f..57280e23e3cb4 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -1,5 +1,6 @@ # global from typing import ( + Iterable, Optional, Union, Sequence, @@ -64,21 +65,29 @@ def heaviside( ) def pad( input: torch.Tensor, - pad_width: Union[Sequence[Sequence[int]], torch.Tensor, int], + pad_width: Union[Iterable[Tuple[int]], int], /, *, mode: Union[ Literal[ "constant", + "dilated", "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", "reflect", + "symmetric", "wrap", + "empty", ], Callable, ] = "constant", - stat_length: Union[Sequence[torch.Tensor], int] = 1, - constant_values: Number = 0, - end_values: Number = 0, + stat_length: Union[Iterable[Tuple[int]], int] = 1, + constant_values: Union[Iterable[Tuple[Number]], Number] = 0, + end_values: Union[Iterable[Tuple[Number]], Number] = 0, reflect_type: Literal["even", "odd"] = "even", **kwargs: Optional[Any], ) -> torch.Tensor: From 58d31d29e8bb6fb72394de54ed15afa5fda9c6ed Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 14 Nov 2023 14:36:27 +0000 Subject: [PATCH 180/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 11e672f8576c4..78234f4a95502 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 11e672f8576c4d49969ae1402d41f1c8b63746eb +Subproject commit 78234f4a9550251550c0b296c4340c2bb04f9609 From 788e2fb8a413c41444382bf0d8984bc5641b3b77 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 14 Nov 2023 14:41:34 +0000 Subject: [PATCH 181/978] refactor: Minor changes in the compositional implementation of ivy.pad. Refactored argument checks and removed a few unnecessary operations. --- .../ivy/experimental/manipulation.py | 181 ++++++++---------- 1 file changed, 84 insertions(+), 97 deletions(-) diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index 282d90a5f6a6b..3f3fd22d9c0cf 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -902,29 +902,30 @@ def _set_wrap_both(padded, axis, width_pair): return padded -def _pad_simple(array, pad_width, fill_value=None): +def _init_pad(array, pad_width, fill_value=None): new_shape = tuple( left + size + right for size, (left, right) in zip(array.shape, pad_width) ) - padded = ivy.zeros(new_shape, dtype=array.dtype) if fill_value is not None: - padded = ivy.ones_like(padded) * fill_value + padded = ivy.ones(new_shape, dtype=array.dtype) * fill_value + else: + padded = ivy.zeros(new_shape, dtype=array.dtype) original_area_slice = tuple( slice(left, left + size) for size, (left, right) in zip(array.shape, pad_width) ) padded[original_area_slice] = array - return padded, original_area_slice + return padded -def _to_pairs(x, n): +def _to_pairs(x, n, m=2): if ivy.isscalar(x): - return ((x, x),) * n - elif len(x) == 2 and ivy.isscalar(x[0]): - return ((x[0], x[1]),) * n + return ((x,) * m,) * n + elif len(x) == m and ivy.isscalar(x[0]): + return ((*x[:m],),) * n elif len(x) != n: ivy.utils.assertions.check_equal( ivy.asarray(list(x)).shape, - (n, 2), + (n, m), message=( "tuple argument should contain " "ndim pairs where ndim is the number of " @@ -935,47 +936,40 @@ def _to_pairs(x, n): return x -def _to_dilated(x, n): - if ivy.isscalar(x): - return ((x, x, x),) * n - elif len(x) == 3 and ivy.isscalar(x[0]): - return ((x[0], x[1], x[2]),) * n - elif len(x) != n: - ivy.utils.assertions.check_equal( - ivy.asarray(list(x)).shape, - (n, 3), - message=( - "tuple argument should contain " - "ndim groups where ndim is the number of " - "the input's dimensions" - ), - as_array=False, - ) - return x +def check_scalar(x, force_integer, force_positive): + return ( + ivy.isscalar(x) + and (ivy.is_int_dtype(x) if force_integer else True) + and (x >= 0 if force_positive else True) + ) -def _check_tuple_arg(arg, name, force_integer=True): - is_scalar = ivy.is_int_dtype if force_integer else ivy.isscalar - flag_assert = False - if isinstance(arg, (tuple, list)): - for nested in arg: - if isinstance(nested, (tuple, list)): - for sub_nested in nested: - if not is_scalar(sub_nested): - flag_assert = True - break - elif not is_scalar(nested): - flag_assert = True - elif not is_scalar(arg): - flag_assert = True - if flag_assert: +def _check_tuple_arg(arg, arg_name, force_integer=False, force_positive=False): + if not ( + check_scalar(arg, force_integer, force_positive) + or ( + isinstance(arg, (tuple, list)) + and ( + all(check_scalar(elem, force_integer, force_positive) for elem in arg) + or ( + isinstance(elem, (tuple, list)) + and all( + check_scalar(sub_elem, force_integer, force_positive) + for sub_elem in elem + ) + ) + for elem in arg + ) + ) + ): if force_integer: raise ivy.utils.exceptions.IvyException( - f"{name} should be int, tuple of ints or tuple of int tuples" + f"{arg_name} should be int, tuple of ints or tuple of int tuples" ) else: raise ivy.utils.exceptions.IvyException( - f"{name} should be scalar, tuple of scalars or tuple of scalar tuples" + f"{arg_name} should be scalar, tuple of scalars or tuple of scalar" + " tuples" ) @@ -987,45 +981,42 @@ def _check_arguments( end_values, reflect_type, ): + supported_modes = [ + "constant", + "dilated", + "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", + "reflect", + "symmetric", + "wrap", + "empty", + ] ivy.utils.assertions.check_true( - callable(mode) - or mode - in [ - "constant", - "dilated", - "edge", - "linear_ramp", - "maximum", - "mean", - "median", - "minimum", - "reflect", - "symmetric", - "wrap", - "empty", - ], - message="the provided mode is not supported", + callable(mode) or mode in supported_modes, + message=f"Only modes {supported_modes} are supported. Got {mode}.", + ) + _check_tuple_arg( + pad_width, "pad_width", force_positive=mode != "dilated", force_integer=True ) - _check_tuple_arg(pad_width, "pad_width") - if mode not in ["dilated"]: - ivy.utils.assertions.check_true( - all(element[1] >= 0 for element in ivy.ndenumerate(pad_width)), - message="the pad_widths must be greater or equal to zero", - ) if mode in ["maximum", "mean", "median", "minimum"]: - _check_tuple_arg(stat_length, "stat_length") - ivy.utils.assertions.check_true( - all(element[1] > 0 for element in ivy.ndenumerate(stat_length)), - message="the stat lengths must be greater than zero", + _check_tuple_arg( + stat_length, "stat_length", force_positive=True, force_integer=True ) - elif mode == "constant": - _check_tuple_arg(constant_values, "constant_values", force_integer=False) + elif mode in ["constant", "dilated"]: + _check_tuple_arg(constant_values, "constant_values") elif mode == "linear_ramp": - _check_tuple_arg(end_values, "end_values", force_integer=False) - ivy.utils.assertions.check_true( - reflect_type in ["even", "odd"], - message="the provided reflect_type is not supported", - ) + _check_tuple_arg(end_values, "end_values") + elif mode in ["reflect", "symmetric"]: + ivy.utils.assertions.check_true( + reflect_type in ["even", "odd"], + message=( + f"Only reflect types ['even', 'odd'] are supported. Got {reflect_type}." + ), + ) @handle_exceptions @@ -1211,23 +1202,23 @@ def pad( end_values, reflect_type, ) + ndim = input.ndim if mode == "dilated": - pad_width = _to_dilated(pad_width, input.ndim) + pad_width = _to_pairs(pad_width, ndim, m=3) if not ivy.is_array(constant_values) or constant_values.dtype != input.dtype: constant_values = ivy.asarray(constant_values, dtype=input.dtype) return _interior_pad(input, constant_values, pad_width) pad_width = _to_pairs(pad_width, len(input.shape)) if callable(mode): func = mode - padded, _ = _pad_simple(input, pad_width, fill_value=0) - for axis in range(padded.ndim): + padded = _init_pad(input, pad_width, fill_value=0) + for axis in range(ndim): padded = ivy.moveaxis(padded, axis, -1) inds = ivy.ndindex(padded.shape[:-1]) for ind in inds: padded[ind] = func(padded[ind], pad_width[axis], axis, kwargs) return padded - padded, original_area_slice = _pad_simple(input, pad_width) - axes = range(padded.ndim) + padded = _init_pad(input, pad_width) stat_functions = { "maximum": ivy.max, "minimum": ivy.min, @@ -1235,35 +1226,31 @@ def pad( "median": ivy.median, } if mode == "constant": - constant_values = _to_pairs(constant_values, padded.ndim) - constant_values = tuple(tuple(map(ivy.array, pair)) for pair in constant_values) - for axis, width_pair, value_pair in zip(axes, pad_width, constant_values): + constant_values = _to_pairs(constant_values, ndim) + for axis, (width_pair, value_pair) in enumerate( + zip(pad_width, constant_values) + ): padded = _set_pad_area(padded, axis, width_pair, value_pair) elif mode == "empty": pass elif mode == "edge": - for axis, width_pair in zip(axes, pad_width): + for axis, width_pair in enumerate(pad_width): edge_pair = _get_edges(padded, axis, width_pair) padded = _set_pad_area(padded, axis, width_pair, edge_pair) elif mode == "linear_ramp": - end_values = _to_pairs(end_values, padded.ndim) - for axis, width_pair, value_pair in zip(axes, pad_width, end_values): + end_values = _to_pairs(end_values, ndim) + for axis, (width_pair, value_pair) in enumerate(zip(pad_width, end_values)): ramp_pair = _get_linear_ramps(padded, axis, width_pair, value_pair) padded = _set_pad_area(padded, axis, width_pair, ramp_pair) elif mode in stat_functions: func = stat_functions[mode] - stat_length = _to_pairs(stat_length, padded.ndim) - if mode == "median": - ivy.utils.assertions.check_true( - ivy.is_float_dtype(input), - message="median interpolation is only supported for floats", - ) - for axis, width_pair, length_pair in zip(axes, pad_width, stat_length): + stat_length = _to_pairs(stat_length, ndim) + for axis, (width_pair, length_pair) in enumerate(zip(pad_width, stat_length)): stat_pair = _get_stats(padded, axis, width_pair, length_pair, func) padded = _set_pad_area(padded, axis, width_pair, stat_pair) elif mode in {"reflect", "symmetric"}: include_edge = True if mode == "symmetric" else False - for axis, (left_index, right_index) in zip(axes, pad_width): + for axis, (left_index, right_index) in enumerate(pad_width): if input.shape[axis] == 1 and (left_index > 0 or right_index > 0): edge_pair = _get_edges(padded, axis, (left_index, right_index)) padded = _set_pad_area( @@ -1275,7 +1262,7 @@ def pad( padded, axis, (left_index, right_index), reflect_type, include_edge ) elif mode == "wrap": - for axis, (left_index, right_index) in zip(axes, pad_width): + for axis, (left_index, right_index) in enumerate(pad_width): padded = _set_wrap_both(padded, axis, (left_index, right_index)) return padded From b37bfd9f25078b001e87787f882bd42b8652195e Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 14 Nov 2023 15:39:29 +0000 Subject: [PATCH 182/978] refactor: Pass bias to ivy rather than applying it manually in torch conv functions --- .../frontends/torch/nn/functional/convolution_functions.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index d118282135f0b..e04aa97cd998c 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -23,7 +23,7 @@ def _conv(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): else: padding = [*[(p, p) for p in padding]] - ret = ivy.conv( + ret = ivy.conv_general_dilated( input, weight, stride, @@ -33,9 +33,8 @@ def _conv(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): filter_format="channel_first", dilations=dilation, feature_group_count=groups, + bias=bias, ) - if bias is not None: - return ivy.add(ret, ivy.expand_dims(bias, axis=(0, *range(2, dims + 2)))) return ret From 0875a9c360597046a5dcf67722f382ce6b2cde2f Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 14 Nov 2023 16:03:52 +0000 Subject: [PATCH 183/978] refactor: Renamed x dilation helper for clarity and modified it to limit the for loop. Also updated the padding helper to avoid manual pad calls in cases supported by the original conv functions. --- ivy/functional/backends/tensorflow/layers.py | 109 ++++++++----------- ivy/functional/backends/torch/layers.py | 40 +++---- 2 files changed, 63 insertions(+), 86 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index cc37b00bade0a..8cabf9c4ebf03 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -13,54 +13,42 @@ from ivy.functional.ivy.layers import ( _deconv_length, _get_x_data_format, - _handle_padding, ) -def _ff_xd_before_conv(x, filters, dims, filter_format, x_dilations): - if filter_format == "channel_first": - filters = tf.transpose(filters, (*range(2, dims + 2), 1, 0)) +def _x_dil_before_conv(x, dims, x_dilations): # adding dilation in input x_dilations = [x_dilations] * dims if isinstance(x_dilations, int) else x_dilations - for i in range(dims): - if x_dilations[i] > 1: + x_dilations_idxs = [i for i, x_dil in enumerate(x_dilations) if x_dil > 1] + if x_dilations_idxs: + for i in x_dilations_idxs: h = x.shape[1 + i] new_height = h + (h - 1) * (x_dilations[i] - 1) h = tf.eye(new_height, dtype=x.dtype)[:: x_dilations[i]] x = tf.experimental.numpy.swapaxes(x, 1 + i, -1) x = tf.matmul(x, h) x = tf.experimental.numpy.swapaxes(x, -1, 1 + i) - return x, filters + return x -def _pad_before_conv(x, filters, strides, padding, dims, dilations): - dilations = [dilations] * dims if isinstance(dilations, int) else dilations - strides = [strides] * dims if isinstance(strides, int) else strides +def _pad_before_conv(x, padding, dims): if isinstance(padding, str): - filter_shape = list(filters.shape[:dims]) - filter_shape = [ - filter_shape[i] + (filter_shape[i] - 1) * (dilations[i] - 1) - for i in range(dims) - ] - new_pad = [ - _handle_padding(x.shape[1 + i], strides[i], filter_shape[i], padding) - for i in range(dims) - ] - pad_list = [ - (new_pad[i] // 2, new_pad[i] - new_pad[i] // 2) for i in range(dims) - ] + return x, padding elif isinstance(padding, int): pad_list = [(padding, padding)] * dims else: pad_list = padding - return tf.pad( - x, - [ - (0, 0), - *pad_list, - (0, 0), - ], - "CONSTANT", + return ( + tf.pad( + x, + [ + (0, 0), + *pad_list, + (0, 0), + ], + "CONSTANT", + ), + "VALID", ) @@ -99,9 +87,11 @@ def conv1d( ) -> Union[tf.Tensor, tf.Variable]: if data_format == "NCW": x = tf.transpose(x, (0, 2, 1)) - x, filters = _ff_xd_before_conv(x, filters, 1, filter_format, x_dilations) - x = _pad_before_conv(x, filters, strides, padding, 1, dilations) - res = tf.nn.conv1d(x, filters, strides, "VALID", "NWC", dilations) + if filter_format == "channel_first": + filters = tf.transpose(filters, (2, 1, 0)) + x = _x_dil_before_conv(x, 1, x_dilations) + x, padding = _pad_before_conv(x, padding, 1) + res = tf.nn.conv1d(x, filters, strides, padding, "NWC", dilations) res = tf.math.add(res, bias) if bias is not None else res if data_format == "NCW": res = tf.transpose(res, (0, 2, 1)) @@ -161,9 +151,11 @@ def conv2d( ) -> Union[tf.Tensor, tf.Variable]: if data_format == "NCHW": x = tf.transpose(x, (0, 2, 3, 1)) - x, filters = _ff_xd_before_conv(x, filters, 2, filter_format, x_dilations) - x = _pad_before_conv(x, filters, strides, padding, 2, dilations) - res = tf.nn.conv2d(x, filters, strides, "VALID", "NHWC", dilations) + if filter_format == "channel_first": + filters = tf.transpose(filters, (2, 3, 1, 0)) + x = _x_dil_before_conv(x, 2, x_dilations) + x, padding = _pad_before_conv(x, padding, 2) + res = tf.nn.conv2d(x, filters, strides, padding, "NHWC", dilations) res = tf.math.add(res, bias) if bias is not None else res if data_format == "NCHW": return tf.transpose(res, (0, 3, 1, 2)) @@ -223,9 +215,9 @@ def depthwise_conv2d( x = tf.transpose(x, (0, 2, 3, 1)) if tf.rank(filters) == 3: filters = tf.expand_dims(filters, -1) - x = _pad_before_conv(x, filters, strides, padding, 2, dilations) + x, padding = _pad_before_conv(x, padding, 2) strides = [1, strides[0], strides[1], 1] - res = tf.nn.depthwise_conv2d(x, filters, strides, "VALID", "NHWC", dilations) + res = tf.nn.depthwise_conv2d(x, filters, strides, padding, "NHWC", dilations) if data_format == "NCHW": return tf.transpose(res, (0, 3, 1, 2)) return res @@ -248,13 +240,15 @@ def conv3d( ): if data_format == "NCDHW": x = tf.transpose(x, (0, 2, 3, 4, 1)) - x, filters = _ff_xd_before_conv(x, filters, 3, filter_format, x_dilations) - x = _pad_before_conv(x, filters, strides, padding, 3, dilations) + if filter_format == "channel_first": + filters = tf.transpose(filters, (2, 3, 4, 1, 0)) + x = _x_dil_before_conv(x, 3, x_dilations) + x, padding = _pad_before_conv(x, padding, 3) strides = [1] + ([strides] * 3 if isinstance(strides, int) else strides) + [1] dilations = ( [1] + ([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] ) - res = tf.nn.conv3d(x, filters, strides, "VALID", "NDHWC", dilations) + res = tf.nn.conv3d(x, filters, strides, padding, "NDHWC", dilations) res = tf.math.add(res, bias) if bias is not None else res if data_format == "NCDHW": return tf.transpose(res, (0, 4, 1, 2, 3)) @@ -324,42 +318,29 @@ def conv_general_dilated( if filter_format == "channel_first": filters = tf.transpose(filters, (*range(2, dims + 2), 1, 0)) - # adding dilation in input - x_dilations = [x_dilations] * dims if isinstance(x_dilations, int) else x_dilations - for i in range(dims): - if x_dilations[i] > 1: - h = x.shape[1 + i] - new_height = h + (h - 1) * (x_dilations[i] - 1) - h = tf.eye(new_height, dtype=x.dtype)[:: x_dilations[i]] - x = tf.experimental.numpy.swapaxes(x, 1 + i, -1) - x = tf.matmul(x, h) - x = tf.experimental.numpy.swapaxes(x, -1, 1 + i) + x = _x_dil_before_conv(x, dims, x_dilations) + x, padding = _pad_before_conv(x, padding, dims) - x = _pad_before_conv(x, filters, strides, padding, dims, dilations) df = _get_x_data_format(dims, "channel_last") - if dims == 3: - strides = [1] + ([strides] * 3 if isinstance(strides, int) else strides) + [1] - dilations = ( - [1] + ([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] - ) + if filters.shape[-2] != (x.shape[-1] // feature_group_count): raise ivy.utils.exceptions.IvyError( f"given feature_group_count {feature_group_count} expected input channel of" f" the filter to be {x.shape[-1] // feature_group_count} but got" f" {filters.shape[-2]}" ) - if x.shape[-1] % feature_group_count != 0: raise ivy.utils.exceptions.IvyError( "input channel should be divisible by feature group count" f" {feature_group_count} but got input channel {x.shape[-1]}" ) + if dims == 1: res = tf.nn.conv1d( x, filters, strides, - "VALID", + padding, df, dilations, ) @@ -368,11 +349,15 @@ def conv_general_dilated( x, filters, strides, - "VALID", + padding, df, dilations, ) else: + strides = [1] + ([strides] * 3 if isinstance(strides, int) else strides) + [1] + dilations = ( + [1] + ([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] + ) # grouped conv3d is not supported on CPU # ToDO: change the condition of GPU when automatic device shifting # is implemented in ivy @@ -381,7 +366,7 @@ def conv_general_dilated( x, filters, strides, - "VALID", + padding, df, dilations, ) @@ -394,7 +379,7 @@ def conv_general_dilated( :, :, :, :, j : j + filters.shape[-1] // feature_group_count ], strides, - "VALID", + padding, df, dilations, ) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index ea15c1be27c59..8bc42e5f625ea 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -133,14 +133,12 @@ def linear( linear.partial_mixed_handler = lambda x, weight, **kwargs: weight.ndim == 2 -def _ff_xd_before_conv(x, filters, dims, filter_format, x_dilations): - if filter_format == "channel_last": - filters = filters.permute(-1, -2, *range(dims)) - +def _x_dil_before_conv(x, dims, x_dilations): # adding dilation to input x_dilations = [x_dilations] * dims if isinstance(x_dilations, int) else x_dilations - for i in range(dims): - if x_dilations[i] > 1: + x_dilations_idxs = [i for i, x_dil in enumerate(x_dilations) if x_dil > 1] + if x_dilations_idxs: + for i in x_dilations_idxs: h = x.shape[2 + i] new_height = h + (h - 1) * (x_dilations[i] - 1) h = torch.eye( @@ -151,7 +149,7 @@ def _ff_xd_before_conv(x, filters, dims, filter_format, x_dilations): x = torch.swapaxes(x, 2 + i, -1) x = torch.matmul(x, h) x = torch.swapaxes(x, -1, 2 + i) - return x, filters + return x def _pad_before_conv( @@ -251,7 +249,9 @@ def conv1d( ) -> torch.Tensor: if data_format == "NWC": x = x.permute(0, 2, 1) - x, filters = _ff_xd_before_conv(x, filters, 1, filter_format, x_dilations) + if filter_format == "channel_last": + filters = filters.permute(2, 1, 0) + x = _x_dil_before_conv(x, 1, x_dilations) x, padding = _pad_before_conv( x, filters, strides, padding, 1, dilations, "channel_first" ) @@ -330,7 +330,9 @@ def conv2d( ) -> torch.Tensor: if data_format == "NHWC": x = x.permute(0, 3, 1, 2) - x, filters = _ff_xd_before_conv(x, filters, 2, filter_format, x_dilations) + if filter_format == "channel_last": + filters = filters.permute(3, 2, 0, 1) + x = _x_dil_before_conv(x, 2, x_dilations) x, padding = _pad_before_conv( x, filters, strides, padding, 2, dilations, "channel_first" ) @@ -454,7 +456,9 @@ def conv3d( ): if data_format == "NDHWC": x = x.permute(0, 4, 1, 2, 3) - x, filters = _ff_xd_before_conv(x, filters, 3, filter_format, x_dilations) + if filter_format == "channel_last": + filters = filters.permute(4, 3, 0, 1, 2) + x = _x_dil_before_conv(x, 3, x_dilations) x, padding = _pad_before_conv( x, filters, strides, padding, 3, dilations, "channel_first" ) @@ -537,20 +541,7 @@ def conv_general_dilated( if filter_format == "channel_last": filters = filters.permute(-1, -2, *range(dims)) - # adding dilation to input - x_dilations = [x_dilations] * dims if isinstance(x_dilations, int) else x_dilations - for i in range(dims): - if x_dilations[i] > 1: - h = x.shape[2 + i] - new_height = h + (h - 1) * (x_dilations[i] - 1) - h = torch.eye( - new_height, - dtype=x.dtype, - device=ivy.as_native_dev(ivy.default_device()), - )[:: x_dilations[i]] - x = torch.swapaxes(x, 2 + i, -1) - x = torch.matmul(x, h) - x = torch.swapaxes(x, -1, 2 + i) + x = _x_dil_before_conv(x, dims, x_dilations) x, padding = _pad_before_conv( x, filters, strides, padding, dims, dilations, "channel_first" @@ -568,6 +559,7 @@ def conv_general_dilated( res = torch.nn.functional.conv3d( x, filters, bias, strides, padding, dilations, feature_group_count ) + if data_format == "channel_last": return res.permute(0, *range(2, dims + 2), 1) return res From 4b508b90e5305d7660c36ad8d86c2692677e14e8 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 14 Nov 2023 21:54:42 +0530 Subject: [PATCH 184/978] Updated the gpu cron tests to only run for the priority functions as it's infeasible to run all tests (#27283) --- .github/workflows/pre-release.yml | 2 +- .github/workflows/test-ivy-cron-gpu.yml | 2 +- .github/workflows/test-ivy-cron.yml | 2 +- scripts/setup_tests/cron_tests.py | 16 ++++++++++++---- scripts/setup_tests/setup_priority_tests.py | 4 +--- 5 files changed, 16 insertions(+), 10 deletions(-) diff --git a/.github/workflows/pre-release.yml b/.github/workflows/pre-release.yml index 483440add140b..c7ccc919b6e61 100644 --- a/.github/workflows/pre-release.yml +++ b/.github/workflows/pre-release.yml @@ -30,7 +30,7 @@ jobs: mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - python scripts/setup_tests/setup_priority_tests.py ${{ secrets.MONGODB_PASSWORD }} + python scripts/setup_tests/setup_priority_tests.py - name: Run CPU Tests run: | diff --git a/.github/workflows/test-ivy-cron-gpu.yml b/.github/workflows/test-ivy-cron-gpu.yml index f28b6aa6bf566..b4cd6719fbe58 100644 --- a/.github/workflows/test-ivy-cron-gpu.yml +++ b/.github/workflows/test-ivy-cron-gpu.yml @@ -74,7 +74,7 @@ jobs: run: | pip3 install pymongo cd ivy - python3 scripts/setup_tests/cron_tests.py ${{ github.run_number }} + python3 scripts/setup_tests/cron_tests.py ${{ github.run_number }} true python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} stop-vm: diff --git a/.github/workflows/test-ivy-cron.yml b/.github/workflows/test-ivy-cron.yml index c5ca96ab9dbfb..8e9e62f3faf35 100644 --- a/.github/workflows/test-ivy-cron.yml +++ b/.github/workflows/test-ivy-cron.yml @@ -37,7 +37,7 @@ jobs: run: | cd ivy pip3 install pymongo - python scripts/setup_tests/cron_tests.py ${{ github.run_number }} + python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true diff --git a/scripts/setup_tests/cron_tests.py b/scripts/setup_tests/cron_tests.py index cd401609c330c..b57e54dd3dc7e 100644 --- a/scripts/setup_tests/cron_tests.py +++ b/scripts/setup_tests/cron_tests.py @@ -1,11 +1,19 @@ import sys from get_all_tests import get_all_tests -run_iter = int(sys.argv[1]) -test_names = get_all_tests() -# Run 150 tests in each iteration of the cron job + +run_iter, gpu = int(sys.argv[1]), sys.argv[2] +if gpu == "true": + from setup_priority_tests import main + + main() + with open("tests_to_run", "r") as f: + test_names = [line.strip() for line in f.readlines()] + tests_per_run = 10 +else: + test_names = get_all_tests() + tests_per_run = 150 num_tests = len(test_names) -tests_per_run = 150 start = run_iter * tests_per_run end = (run_iter + 1) * tests_per_run print("Running Tests:") diff --git a/scripts/setup_tests/setup_priority_tests.py b/scripts/setup_tests/setup_priority_tests.py index 509b641289804..6f1f85ea30e9e 100644 --- a/scripts/setup_tests/setup_priority_tests.py +++ b/scripts/setup_tests/setup_priority_tests.py @@ -1,13 +1,11 @@ -import sys from pymongo import MongoClient from get_all_tests import BACKENDS def main(): # connect to the database - mongo_key = sys.argv[1] cluster = MongoClient( - f"mongodb+srv://deep-ivy:{mongo_key}@cluster0.qdvf8q3.mongodb.net/?retryWrites=true&w=majority" # noqa + "mongodb+srv://readonly-user:hvpwV5yVeZdgyTTm@cluster0.qdvf8q3.mongodb.net" ) ci_dashboard_db = cluster["ci_dashboard"] ivy_tests_collection = ci_dashboard_db["ivy_tests"] From 11060a9c7ba19d78aa4ea5c81fa28cbc5fe5d144 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 14 Nov 2023 17:19:51 +0000 Subject: [PATCH 185/978] fix: Copied array-api helper to general helpers to avoid CI failure. --- .../hypothesis_helpers/general_helpers.py | 61 ++++++++++++++++++- .../test_torch/test_pointwise_ops.py | 6 +- 2 files changed, 63 insertions(+), 4 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 4b91dad3f58cf..971a19bdee0b2 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -1,5 +1,6 @@ # global -from hypothesis import strategies as st +from hypothesis import assume, strategies as st +from typing import Tuple from functools import lru_cache import math import numpy as np @@ -162,6 +163,64 @@ def general_helpers_dtype_info_helper(backend, kind_dtype, dtype): # -----------# +# from array-api repo +class BroadcastError(ValueError): + """Shapes do not broadcast with eachother.""" + + +# from array-api repo +def _broadcast_shapes( + shape1: Tuple[int, ...], shape2: Tuple[int, ...] +) -> Tuple[int, ...]: + N1 = len(shape1) + N2 = len(shape2) + N = max(N1, N2) + shape = [None for _ in range(N)] + i = N - 1 + while i >= 0: + n1 = N1 - N + i + if N1 - N + i >= 0: + d1 = shape1[n1] + else: + d1 = 1 + n2 = N2 - N + i + if N2 - N + i >= 0: + d2 = shape2[n2] + else: + d2 = 1 + + if d1 == 1: + shape[i] = d2 + elif d2 == 1: + shape[i] = d1 + elif d1 == d2: + shape[i] = d1 + else: + raise BroadcastError() + i = i - 1 + return tuple(shape) + + +# from array-api repo +def broadcast_shapes(*shapes: Tuple[int, ...]): + if len(shapes) == 0: + raise ValueError("shapes=[] must be non-empty") + elif len(shapes) == 1: + return shapes[0] + result = _broadcast_shapes(shapes[0], shapes[1]) + for i in range(2, len(shapes)): + result = _broadcast_shapes(result, shapes[i]) + return result + + +# from array-api repo +@st.composite +def two_broadcastable_shapes(draw): + shape1, shape2 = draw(array_helpers.mutually_broadcastable_shapes(2)) + assume(broadcast_shapes(shape1, shape2) == shape1) + return (shape1, shape2) + + # taken from # https://github.com/data-apis/array-api-tests/array_api_tests/test_manipulation_functions.py @st.composite diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py index 678aaad47bd17..ac5d352ee8925 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py @@ -5,8 +5,8 @@ # local import ivy import ivy_tests.test_ivy.helpers as helpers -from ivy_tests.array_api_testing.test_array_api.array_api_tests import ( - hypothesis_helpers as hh, +from ivy_tests.test_ivy.helpers.hypothesis_helpers.general_helpers import ( + two_broadcastable_shapes, ) from ivy_tests.test_ivy.helpers import handle_frontend_test from ivy_tests.test_ivy.test_functional.test_core.test_elementwise import pow_helper @@ -86,7 +86,7 @@ def _get_clip_inputs(draw): @st.composite def _masked_fill_helper(draw): - shape_1, shape_2 = draw(hh.two_broadcastable_shapes()) + shape_1, shape_2 = draw(two_broadcastable_shapes()) dtype, x = draw( helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("valid"), From 6458919793fe7420225d190b1ff4580e103acd09 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Tue, 14 Nov 2023 18:49:16 +0000 Subject: [PATCH 186/978] feat: Added new version implementations for some tf and torch backend conv functions that natively support more padding cases. --- ivy/functional/backends/tensorflow/layers.py | 54 ++++-- ivy/functional/backends/torch/layers.py | 181 ++++++++++++++++++- 2 files changed, 220 insertions(+), 15 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 8cabf9c4ebf03..5f449c500473d 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -8,7 +8,7 @@ # local import ivy -from ivy.func_wrapper import with_unsupported_dtypes +from ivy.func_wrapper import with_supported_dtypes, with_unsupported_dtypes from . import backend_version from ivy.functional.ivy.layers import ( _deconv_length, @@ -52,6 +52,17 @@ def _pad_before_conv(x, padding, dims): ) +def _to_explicit_padding(padding, dims): + if isinstance(padding, str): + return padding, [] + if isinstance(padding, int): + explicit_pad = [padding] * dims * 2 + else: + explicit_pad = [item for sublist in padding for item in sublist] + explicit_pad = [0, 0] + explicit_pad + [0, 0] + return "EXPLICIT", explicit_pad + + def _output_shape( x_shape, filter_shape, output_shape, strides, padding, dims, dilations ): @@ -134,7 +145,7 @@ def conv1d_transpose( return res -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_supported_dtypes({"2.14.0 and below": ("float", "int32")}, backend_version) def conv2d( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], @@ -154,8 +165,20 @@ def conv2d( if filter_format == "channel_first": filters = tf.transpose(filters, (2, 3, 1, 0)) x = _x_dil_before_conv(x, 2, x_dilations) - x, padding = _pad_before_conv(x, padding, 2) - res = tf.nn.conv2d(x, filters, strides, padding, "NHWC", dilations) + padding, explicit_padding = _to_explicit_padding(padding, 2) + strides = [1] + ([strides] * 2 if isinstance(strides, int) else strides) + [1] + dilations = ( + [1] + ([dilations] * 2 if isinstance(dilations, int) else dilations) + [1] + ) + res = tf.raw_ops.Conv2D( + input=x, + filter=filters, + strides=strides, + padding=padding, + explicit_paddings=explicit_padding, + data_format="NHWC", + dilations=dilations, + ) res = tf.math.add(res, bias) if bias is not None else res if data_format == "NCHW": return tf.transpose(res, (0, 3, 1, 2)) @@ -319,7 +342,6 @@ def conv_general_dilated( filters = tf.transpose(filters, (*range(2, dims + 2), 1, 0)) x = _x_dil_before_conv(x, dims, x_dilations) - x, padding = _pad_before_conv(x, padding, dims) df = _get_x_data_format(dims, "channel_last") @@ -336,6 +358,7 @@ def conv_general_dilated( ) if dims == 1: + x, padding = _pad_before_conv(x, padding, dims) res = tf.nn.conv1d( x, filters, @@ -345,15 +368,22 @@ def conv_general_dilated( dilations, ) elif dims == 2: - res = tf.nn.conv2d( - x, - filters, - strides, - padding, - df, - dilations, + padding, explicit_padding = _to_explicit_padding(padding, 2) + strides = [1] + ([strides] * 2 if isinstance(strides, int) else strides) + [1] + dilations = ( + [1] + ([dilations] * 2 if isinstance(dilations, int) else dilations) + [1] + ) + res = tf.raw_ops.Conv2D( + input=x, + filter=filters, + strides=strides, + padding=padding, + explicit_paddings=explicit_padding, + data_format="NHWC", + dilations=dilations, ) else: + x, padding = _pad_before_conv(x, padding, dims) strides = [1] + ([strides] * 3 if isinstance(strides, int) else strides) + [1] dilations = ( [1] + ([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index 8bc42e5f625ea..cc2bf3913c9e2 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -184,7 +184,20 @@ def _pad_before_conv( if all(pad[0] == pad[1] for pad in padding): return x, [pad[0] for pad in padding] pad_list = [item for sublist in padding for item in sublist[::-1]][::-1] - return torch.nn.functional.pad(x, pad_list), "valid" + return torch.nn.functional.pad(x, pad_list), 0 + + +def _new_pad_before_conv(x, padding): + if isinstance(padding, str): + return x, padding.lower() + elif isinstance(padding, int): + return x, padding + else: + # if symmetric padding is used, use torch's padding in conv function + if all(pad[0] == pad[1] for pad in padding): + return x, [pad[0] for pad in padding] + pad_list = [item for sublist in padding for item in sublist[::-1]][::-1] + return torch.nn.functional.pad(x, pad_list), "valid" def _pad_before_conv_tranpose( @@ -261,6 +274,43 @@ def conv1d( return res +@with_unsupported_dtypes( + {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + backend_version, +) +def conv1d_v_1p9p0_and_above( + x: torch.Tensor, + filters: torch.Tensor, + strides: Union[int, Tuple[int]], + padding: Union[str, int, Sequence[Tuple[int, int]]], + /, + *, + data_format: str = "NWC", + filter_format: str = "channel_last", + x_dilations: Union[int, Tuple[int]] = 1, + dilations: Union[int, Tuple[int]] = 1, + bias: Optional[torch.Tensor] = None, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + if data_format == "NWC": + x = x.permute(0, 2, 1) + if filter_format == "channel_last": + filters = filters.permute(2, 1, 0) + x = _x_dil_before_conv(x, 1, x_dilations) + if padding != "SAME" or all( + s == 1 for s in ([strides] if isinstance(strides, int) else strides) + ): + x, padding = _new_pad_before_conv(x, padding) + else: + x, padding = _pad_before_conv( + x, filters, strides, padding, 1, dilations, "channel_first" + ) + res = torch.nn.functional.conv1d(x, filters, bias, strides, padding, dilations) + if data_format == "NWC": + res = res.permute(0, 2, 1) + return res + + @with_unsupported_dtypes( { "2.1.0 and below": ( @@ -342,6 +392,43 @@ def conv2d( return res +@with_unsupported_dtypes( + {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + backend_version, +) +def conv2d_v_1p9p0_and_above( + x: torch.Tensor, + filters: torch.Tensor, + strides: Union[int, Tuple[int, int]], + padding: Union[str, int, Sequence[Tuple[int, int]]], + /, + *, + data_format: str = "NHWC", + filter_format: str = "channel_last", + x_dilations: Union[int, Tuple[int, int]] = 1, + dilations: Union[int, Tuple[int, int]] = 1, + bias: Optional[torch.Tensor] = None, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + if data_format == "NHWC": + x = x.permute(0, 3, 1, 2) + if filter_format == "channel_last": + filters = filters.permute(3, 2, 0, 1) + x = _x_dil_before_conv(x, 2, x_dilations) + if padding != "SAME" or all( + s == 1 for s in ([strides] if isinstance(strides, int) else strides) + ): + x, padding = _new_pad_before_conv(x, padding) + else: + x, padding = _pad_before_conv( + x, filters, strides, padding, 2, dilations, "channel_first" + ) + res = torch.nn.functional.conv2d(x, filters, bias, strides, padding, dilations) + if data_format == "NHWC": + return res.permute(0, 2, 3, 1) + return res + + @with_unsupported_dtypes( { "2.1.0 and below": ( @@ -468,6 +555,42 @@ def conv3d( return res +@with_unsupported_dtypes( + {"2.1.0 and below": ("float16", "bfloat16", "complex")}, backend_version +) +def conv3d_v_1p9p0_and_above( + x: torch.Tensor, + filters: torch.Tensor, + strides: Union[int, Tuple[int, int, int]], + padding: Union[str, int, Sequence[Tuple[int, int]]], + /, + *, + data_format: str = "NDHWC", + filter_format: str = "channel_last", + x_dilations: Union[int, Tuple[int, int, int]] = 1, + dilations: Union[int, Tuple[int, int, int]] = 1, + bias: Optional[torch.Tensor] = None, + out: Optional[torch.Tensor] = None, +): + if data_format == "NDHWC": + x = x.permute(0, 4, 1, 2, 3) + if filter_format == "channel_last": + filters = filters.permute(4, 3, 0, 1, 2) + x = _x_dil_before_conv(x, 3, x_dilations) + if padding != "SAME" or all( + s == 1 for s in ([strides] if isinstance(strides, int) else strides) + ): + x, padding = _new_pad_before_conv(x, padding) + else: + x, padding = _pad_before_conv( + x, filters, strides, padding, 3, dilations, "channel_first" + ) + res = torch.nn.functional.conv3d(x, filters, bias, strides, padding, dilations) + if data_format == "NDHWC": + res = res.permute(0, 2, 3, 4, 1) + return res + + @with_unsupported_dtypes( {"2.1.0 and below": ("float16", "bfloat16", "complex")}, backend_version, @@ -537,12 +660,10 @@ def conv_general_dilated( # permuting dims based on formats if data_format == "channel_last": x = x.permute(0, dims + 1, *range(1, dims + 1)) - if filter_format == "channel_last": filters = filters.permute(-1, -2, *range(dims)) x = _x_dil_before_conv(x, dims, x_dilations) - x, padding = _pad_before_conv( x, filters, strides, padding, dims, dilations, "channel_first" ) @@ -565,6 +686,60 @@ def conv_general_dilated( return res +@with_unsupported_dtypes( + {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + backend_version, +) +def conv_general_dilated_v_1p9p0_and_above( + x: torch.Tensor, + filters: torch.Tensor, + strides: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]], + padding: Union[str, int, Sequence[Tuple[int, int]]], + /, + *, + dims: int = 2, + data_format: str = "channel_last", + filter_format: str = "channel_last", + feature_group_count: int = 1, + x_dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, + dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, + bias: Optional[torch.Tensor] = None, + out: Optional[torch.Tensor] = None, +): + # permuting dims based on formats + if data_format == "channel_last": + x = x.permute(0, dims + 1, *range(1, dims + 1)) + if filter_format == "channel_last": + filters = filters.permute(-1, -2, *range(dims)) + + x = _x_dil_before_conv(x, dims, x_dilations) + if padding != "SAME" or all( + s == 1 for s in ([strides] if isinstance(strides, int) else strides) + ): + x, padding = _new_pad_before_conv(x, padding) + else: + x, padding = _pad_before_conv( + x, filters, strides, padding, dims, dilations, "channel_first" + ) + + if dims == 1: + res = torch.nn.functional.conv1d( + x, filters, bias, strides, padding, dilations, feature_group_count + ) + elif dims == 2: + res = torch.nn.functional.conv2d( + x, filters, bias, strides, padding, dilations, feature_group_count + ) + else: + res = torch.nn.functional.conv3d( + x, filters, bias, strides, padding, dilations, feature_group_count + ) + + if data_format == "channel_last": + return res.permute(0, *range(2, dims + 2), 1) + return res + + @with_unsupported_dtypes( {"2.1.0 and below": ("float16", "bfloat16", "complex")}, backend_version, From d1d471d0268491589181f8c7c068ef7e041b72f0 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 15 Nov 2023 01:48:35 +0530 Subject: [PATCH 187/978] fix: Raised `exception` statements that are Unraised (#27279) --- ivy/functional/backends/torch/elementwise.py | 2 +- ivy/functional/frontends/tensorflow/ragged/ragged.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/torch/elementwise.py b/ivy/functional/backends/torch/elementwise.py index 9fba80a8d5c8a..83f820c588557 100644 --- a/ivy/functional/backends/torch/elementwise.py +++ b/ivy/functional/backends/torch/elementwise.py @@ -647,7 +647,7 @@ def trapz( return torch.trapezoid(y, dx=dx, dim=axis) else: if dx is not None: - TypeError( + raise TypeError( "trapezoid() received an invalid combination of arguments - got " "(Tensor, Tensor, int), but expected one of: *(Tensor " "y, Tensor x, *, int dim) * (Tensor y, *, Number dx, int dim)" diff --git a/ivy/functional/frontends/tensorflow/ragged/ragged.py b/ivy/functional/frontends/tensorflow/ragged/ragged.py index ac0e210ec328f..44835ff245a0b 100644 --- a/ivy/functional/frontends/tensorflow/ragged/ragged.py +++ b/ivy/functional/frontends/tensorflow/ragged/ragged.py @@ -25,12 +25,12 @@ def from_row_splits(cls, values, row_splits, name=None, validate=True): if values.shape[0] != row_splits[-1] or row_splits[0] != 0: if values.shape[0] != row_splits[-1]: - ivy.utils.exceptions.IvyException( + raise ivy.utils.exceptions.IvyException( "first dimension of shape of values should be equal to the" " last dimension of row_splits" ) else: - ivy.utils.exceptions.IvyException( + raise ivy.utils.exceptions.IvyException( "first value of row_splits should be equal to zero." ) data = [ @@ -49,7 +49,7 @@ def from_row_lengths( ): # TODO : modify this, if necessary, to accept raggedTensor inputs too if sum(row_lengths) != values.shape[0]: - ivy.utils.exceptions.IvyException( + raise ivy.utils.exceptions.IvyException( "first dimension of values should be equal to sum(row_lengths) " ) data = [] From cb8d76f04929e216fafc11528a25ce1c6baa2078 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 15 Nov 2023 01:49:35 +0530 Subject: [PATCH 188/978] fix: Updated type annotations to use `Optional` when default parameter is `None`. (#27255) --- ivy/data_classes/array/conversions.py | 2 +- ivy/data_classes/array/experimental/layers.py | 8 ++--- .../array/experimental/manipulation.py | 2 +- .../container/experimental/layers.py | 4 +-- .../backends/jax/experimental/layers.py | 6 ++-- ivy/functional/backends/jax/general.py | 2 +- ivy/functional/backends/mxnet/manipulation.py | 2 +- ivy/functional/backends/numpy/creation.py | 28 ++++++++--------- .../backends/numpy/experimental/creation.py | 2 +- .../backends/numpy/experimental/layers.py | 6 ++-- ivy/functional/backends/numpy/general.py | 2 +- ivy/functional/backends/numpy/random.py | 8 ++--- .../backends/paddle/experimental/layers.py | 4 +-- .../backends/paddle/experimental/norms.py | 11 +++++-- ivy/functional/backends/paddle/general.py | 2 +- .../backends/paddle/linear_algebra.py | 4 +-- .../backends/paddle/manipulation.py | 2 +- .../backends/tensorflow/creation.py | 28 ++++++++--------- .../tensorflow/experimental/creation.py | 2 +- .../tensorflow/experimental/layers.py | 10 +++---- .../tensorflow/experimental/random.py | 4 +-- ivy/functional/backends/tensorflow/general.py | 2 +- .../backends/tensorflow/manipulation.py | 2 +- ivy/functional/backends/tensorflow/random.py | 8 ++--- .../tf_probability/experimental/random.py | 2 +- .../backends/torch/experimental/layers.py | 12 ++++---- ivy/functional/backends/torch/general.py | 2 +- .../frontends/tensorflow/func_wrapper.py | 6 ++-- ivy/functional/ivy/device.py | 2 +- ivy/functional/ivy/experimental/layers.py | 4 +-- ivy/functional/ivy/general.py | 8 ++--- ivy/functional/ivy/manipulation.py | 2 +- .../test_ivy/helpers/function_testing.py | 30 +++++++++---------- ivy_tests/test_ivy/helpers/testing_helpers.py | 12 ++++---- .../test_keras/test_activations.py | 3 +- .../test_ivy/test_misc/test_inspection.py | 4 +-- scripts/eager_mode_benchmark/benchmark.py | 6 ++-- 37 files changed, 126 insertions(+), 118 deletions(-) diff --git a/ivy/data_classes/array/conversions.py b/ivy/data_classes/array/conversions.py index e92947cf2dfcf..7fb765f6f7c01 100644 --- a/ivy/data_classes/array/conversions.py +++ b/ivy/data_classes/array/conversions.py @@ -174,7 +174,7 @@ def to_native( def args_to_native( *args: Iterable[Any], - include_derived: Dict[str, bool] = None, + include_derived: Optional[Dict[str, bool]] = None, cont_inplace: bool = False, to_ignore: Optional[Union[type, Tuple[type]]] = None, **kwargs: Dict[str, Any], diff --git a/ivy/data_classes/array/experimental/layers.py b/ivy/data_classes/array/experimental/layers.py index eefb667184fb4..2e1bb60a33d05 100644 --- a/ivy/data_classes/array/experimental/layers.py +++ b/ivy/data_classes/array/experimental/layers.py @@ -952,7 +952,7 @@ def reduce_window( def fft2( self: ivy.Array, *, - s: Sequence[int] = None, + s: Optional[Sequence[int]] = None, dim: Sequence[int] = (-2, -1), norm: str = "backward", out: Optional[ivy.Array] = None, @@ -1144,8 +1144,8 @@ def rfft( def rfftn( self: ivy.Array, - s: Sequence[int] = None, - axes: Sequence[int] = None, + s: Optional[Sequence[int]] = None, + axes: Optional[Sequence[int]] = None, *, norm: str = "backward", out: Optional[ivy.Array] = None, @@ -1291,7 +1291,7 @@ def max_unpool1d( kernel_size: Union[Tuple[int], int], /, *, - strides: Union[int, Tuple[int]] = None, + strides: Optional[Union[int, Tuple[int]]] = None, padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Array: diff --git a/ivy/data_classes/array/experimental/manipulation.py b/ivy/data_classes/array/experimental/manipulation.py index 017df89bd4b6b..f7027eafa78ab 100644 --- a/ivy/data_classes/array/experimental/manipulation.py +++ b/ivy/data_classes/array/experimental/manipulation.py @@ -217,7 +217,7 @@ def rot90( self: ivy.Array, /, *, - copy: bool = None, + copy: Optional[bool] = None, k: int = 1, axes: Tuple[int, int] = (0, 1), out: Optional[ivy.Array] = None, diff --git a/ivy/data_classes/container/experimental/layers.py b/ivy/data_classes/container/experimental/layers.py index fc61b0caa19dd..ce2f0c1ffc3cf 100644 --- a/ivy/data_classes/container/experimental/layers.py +++ b/ivy/data_classes/container/experimental/layers.py @@ -2753,7 +2753,7 @@ def static_max_unpool1d( kernel_size: Union[Tuple[int], int], /, *, - strides: Union[int, Tuple[int]] = None, + strides: Optional[Union[int, Tuple[int]]] = None, padding: Union[int, Tuple[int]] = 0, data_format: Union[str, ivy.Container] = "NCW", key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, @@ -2817,7 +2817,7 @@ def max_unpool1d( kernel_size: Union[Tuple[int], int], /, *, - strides: Union[int, Tuple[int]] = None, + strides: Optional[Union[int, Tuple[int]]] = None, padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Container: diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index c5ebfc9adbbb3..95fbb1277a19c 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -778,7 +778,7 @@ def reduce_window( def fft2( x: JaxArray, *, - s: Sequence[int] = None, + s: Optional[Sequence[int]] = None, dim: Sequence[int] = (-2, -1), norm: str = "backward", out: Optional[JaxArray] = None, @@ -873,8 +873,8 @@ def rfft( @with_unsupported_dtypes({"0.4.20 and below": ("float16", "complex")}, backend_version) def rfftn( x: JaxArray, - s: Sequence[int] = None, - axes: Sequence[int] = None, + s: Optional[Sequence[int]] = None, + axes: Optional[Sequence[int]] = None, *, norm: str = "backward", out: Optional[JaxArray] = None, diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index 38c877eaffd69..c2f643afcd9cc 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -66,7 +66,7 @@ def get_item( /, query: Union[JaxArray, Tuple], *, - copy: bool = None, + copy: Optional[bool] = None, ) -> JaxArray: if ivy.is_array(query) and ivy.is_bool_dtype(query): if not len(query.shape): diff --git a/ivy/functional/backends/mxnet/manipulation.py b/ivy/functional/backends/mxnet/manipulation.py index feb262db2a152..7c07a7435c9cb 100644 --- a/ivy/functional/backends/mxnet/manipulation.py +++ b/ivy/functional/backends/mxnet/manipulation.py @@ -111,7 +111,7 @@ def repeat( /, repeats: Union[(int, List[int])], *, - axis: int = None, + axis: Optional[int] = None, out: Optional[Union[(None, mx.ndarray.NDArray)]] = None, ) -> Union[(None, mx.ndarray.NDArray)]: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/numpy/creation.py b/ivy/functional/backends/numpy/creation.py index 4ce48b5332d57..8c238118f24ad 100644 --- a/ivy/functional/backends/numpy/creation.py +++ b/ivy/functional/backends/numpy/creation.py @@ -29,7 +29,7 @@ def arange( step: float = 1, *, dtype: Optional[np.dtype] = None, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: if dtype: @@ -56,7 +56,7 @@ def asarray( *, copy: Optional[bool] = None, dtype: Optional[np.dtype] = None, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: ret = np.asarray(obj, dtype=dtype) @@ -67,7 +67,7 @@ def empty( shape: Union[ivy.NativeShape, Sequence[int]], *, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: return np.empty(shape, dtype) @@ -78,7 +78,7 @@ def empty_like( /, *, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: return np.empty_like(x, dtype=dtype) @@ -92,7 +92,7 @@ def eye( k: int = 0, batch_shape: Optional[Union[int, Sequence[int]]] = None, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: if n_cols is None: @@ -132,7 +132,7 @@ def full( fill_value: Union[int, float, bool], *, dtype: Optional[Union[ivy.Dtype, np.dtype]] = None, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: dtype = ivy.default_dtype(dtype=dtype, item=fill_value, as_native=True) @@ -145,7 +145,7 @@ def full_like( fill_value: Number, *, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: return np.full_like(x, fill_value, dtype=dtype) @@ -160,7 +160,7 @@ def linspace( axis: Optional[int] = None, endpoint: bool = True, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: if axis is None: @@ -189,7 +189,7 @@ def ones( shape: Union[ivy.NativeShape, Sequence[int]], *, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: return np.ones(shape, dtype) @@ -200,7 +200,7 @@ def ones_like( /, *, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: return np.ones_like(x, dtype=dtype) @@ -222,7 +222,7 @@ def zeros( shape: Union[ivy.NativeShape, Sequence[int]], *, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: return np.zeros(shape, dtype) @@ -233,7 +233,7 @@ def zeros_like( /, *, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: return np.zeros_like(x, dtype=dtype) @@ -266,7 +266,7 @@ def one_hot( off_value: Optional[Number] = None, axis: Optional[int] = None, dtype: Optional[np.dtype] = None, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: on_none = on_value is None @@ -310,6 +310,6 @@ def triu_indices( k: int = 0, /, *, - device: str = None, + device: Optional[str] = None, ) -> Tuple[np.ndarray]: return tuple(np.asarray(np.triu_indices(n=n_rows, k=k, m=n_cols))) diff --git a/ivy/functional/backends/numpy/experimental/creation.py b/ivy/functional/backends/numpy/experimental/creation.py index b073258c74c80..97d6325605a41 100644 --- a/ivy/functional/backends/numpy/experimental/creation.py +++ b/ivy/functional/backends/numpy/experimental/creation.py @@ -32,7 +32,7 @@ def tril_indices( k: int = 0, /, *, - device: str = None, + device: Optional[str] = None, ) -> Tuple[np.ndarray, ...]: return tuple(np.asarray(np.tril_indices(n=n_rows, k=k, m=n_cols))) diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index b48661d78e361..8672a0d49f587 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -951,7 +951,7 @@ def ifft( def fft2( x: np.ndarray, *, - s: Sequence[int] = None, + s: Optional[Sequence[int]] = None, dim: Sequence[int] = (-2, -1), norm: str = "backward", out: Optional[np.ndarray] = None, @@ -1041,8 +1041,8 @@ def rfft( def rfftn( x: np.ndarray, - s: Sequence[int] = None, - axes: Sequence[int] = None, + s: Optional[Sequence[int]] = None, + axes: Optional[Sequence[int]] = None, *, norm: str = "backward", out: Optional[np.ndarray] = None, diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index e2da9e512a31d..1b80e19a657cf 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -34,7 +34,7 @@ def get_item( /, query: Union[np.ndarray, Tuple], *, - copy: bool = None, + copy: Optional[bool] = None, ) -> np.ndarray: return x.__getitem__(query) diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index a9e06e8c1dbbc..203e283b1009f 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -24,7 +24,7 @@ def random_uniform( high: Union[float, np.ndarray] = 1.0, shape: Optional[Union[ivy.NativeShape, Sequence[int], np.ndarray]] = None, dtype: np.dtype, - device: str = None, + device: Optional[str] = None, out: Optional[np.ndarray] = None, seed: Optional[int] = None, ) -> np.ndarray: @@ -39,7 +39,7 @@ def random_normal( mean: Union[float, np.ndarray] = 0.0, std: Union[float, np.ndarray] = 1.0, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - device: str = None, + device: Optional[str] = None, dtype: np.dtype, seed: Optional[int] = None, out: Optional[np.ndarray] = None, @@ -60,7 +60,7 @@ def multinomial( batch_size: int = 1, probs: Optional[np.ndarray] = None, replace: bool = True, - device: str = None, + device: Optional[str] = None, seed: Optional[int] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: @@ -95,7 +95,7 @@ def randint( /, *, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - device: str = None, + device: Optional[str] = None, dtype: Optional[Union[np.dtype, ivy.Dtype]] = None, seed: Optional[int] = None, out: Optional[np.ndarray] = None, diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index fabf837f023f0..4adb2e37d3a9b 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -309,7 +309,7 @@ def fft( /, *, norm: Optional[str] = "backward", - n: Union[int, Tuple[int]] = None, + n: Optional[Union[int, Tuple[int]]] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: if not isinstance(dim, int): @@ -414,7 +414,7 @@ def ifft( dim: int, *, norm: Optional[str] = "backward", - n: Union[int, Tuple[int]] = None, + n: Optional[Union[int, Tuple[int]]] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/paddle/experimental/norms.py b/ivy/functional/backends/paddle/experimental/norms.py index d187a2535b028..c36bf0dda786f 100644 --- a/ivy/functional/backends/paddle/experimental/norms.py +++ b/ivy/functional/backends/paddle/experimental/norms.py @@ -107,7 +107,7 @@ def batch_norm( @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) def l1_normalize( - x: paddle.Tensor, /, *, axis: int = None, out: paddle.Tensor = None + x: paddle.Tensor, /, *, axis: Optional[int] = None, out: paddle.Tensor = None ) -> paddle.Tensor: if not isinstance(x, paddle.Tensor): x = paddle.to_tensor(x) @@ -131,7 +131,7 @@ def l1_normalize( def l2_normalize( - x: paddle.Tensor, /, *, axis: int = None, out: paddle.Tensor = None + x: paddle.Tensor, /, *, axis: Optional[int] = None, out: paddle.Tensor = None ) -> paddle.Tensor: raise IvyNotImplementedException() @@ -164,6 +164,11 @@ def instance_norm( def lp_normalize( - x: paddle.Tensor, /, *, p: float = 2, axis: int = None, out: paddle.Tensor = None + x: paddle.Tensor, + /, + *, + p: float = 2, + axis: Optional[int] = None, + out: paddle.Tensor = None, ) -> paddle.Tensor: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 024b9110c2603..88a2e8c591409 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -95,7 +95,7 @@ def get_item( /, query: Union[paddle.Tensor, Tuple], *, - copy: bool = None, + copy: Optional[bool] = None, ) -> paddle.Tensor: if copy: x = paddle.clone(x) diff --git a/ivy/functional/backends/paddle/linear_algebra.py b/ivy/functional/backends/paddle/linear_algebra.py index 83b274820b503..16592ed2f4e1d 100644 --- a/ivy/functional/backends/paddle/linear_algebra.py +++ b/ivy/functional/backends/paddle/linear_algebra.py @@ -53,7 +53,7 @@ def cross( axisa: int = -1, axisb: int = -1, axisc: int = -1, - axis: int = None, + axis: Optional[int] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: def _cross(x1, x2, axisa, axisb, axisc, axis): @@ -433,7 +433,7 @@ def tensorsolve( x2: paddle.Tensor, /, *, - axes: Union[int, Tuple[List[int], List[int]]] = None, + axes: Optional[Union[int, Tuple[List[int], List[int]]]] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: # Implemented as a composite function in ivy.functional.ivy.linear_algebra diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index 0aa0957ed9863..03dc9acca403a 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -307,7 +307,7 @@ def repeat( /, repeats: Union[int, Iterable[int]], *, - axis: int = None, + axis: Optional[int] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: # handle the case when repeats contains 0 as paddle doesn't support it diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py index 614f8a9153950..a560441a94540 100644 --- a/ivy/functional/backends/tensorflow/creation.py +++ b/ivy/functional/backends/tensorflow/creation.py @@ -41,7 +41,7 @@ def arange( step: float = 1, *, dtype: Optional[tf.DType] = None, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: if stop is None: @@ -86,7 +86,7 @@ def asarray( *, copy: Optional[bool] = None, dtype: Optional[tf.DType] = None, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: # convert the input to a tensor using the appropriate function @@ -102,7 +102,7 @@ def empty( shape: Union[ivy.NativeShape, Sequence[int]], *, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.experimental.numpy.empty(shape, dtype) @@ -113,7 +113,7 @@ def empty_like( /, *, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.experimental.numpy.empty_like(x, dtype=dtype) @@ -128,7 +128,7 @@ def eye( k: int = 0, batch_shape: Optional[Union[int, Sequence[int]]] = None, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: if n_cols is None: @@ -202,7 +202,7 @@ def full( fill_value: Union[int, float, bool], *, dtype: Optional[Union[ivy.Dtype, tf.DType]] = None, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: dtype = ivy.default_dtype(dtype=dtype, item=fill_value, as_native=True) @@ -215,7 +215,7 @@ def full_like( fill_value: Number, *, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.experimental.numpy.full_like(x, fill_value, dtype=dtype) @@ -234,7 +234,7 @@ def linspace( axis: Optional[int] = None, endpoint: bool = True, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ): if axis is None: @@ -280,7 +280,7 @@ def ones( shape: Union[ivy.NativeShape, Sequence[int]], *, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.ones(shape, dtype) @@ -291,7 +291,7 @@ def ones_like( /, *, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.ones_like(x, dtype=dtype) @@ -325,7 +325,7 @@ def zeros( shape: Union[ivy.NativeShape, Sequence[int]], *, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.zeros(shape, dtype) @@ -336,7 +336,7 @@ def zeros_like( /, *, dtype: tf.DType, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.zeros_like(x, dtype=dtype) @@ -375,7 +375,7 @@ def one_hot( off_value: Optional[Number] = None, axis: Optional[int] = None, dtype: Optional[tf.DType] = None, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.one_hot( @@ -410,7 +410,7 @@ def triu_indices( k: int = 0, /, *, - device: str = None, + device: Optional[str] = None, ) -> Tuple[Union[tf.Tensor, tf.Variable]]: n_cols = n_rows if n_cols is None else n_cols diff --git a/ivy/functional/backends/tensorflow/experimental/creation.py b/ivy/functional/backends/tensorflow/experimental/creation.py index 86af4561091c2..e5c3884477515 100644 --- a/ivy/functional/backends/tensorflow/experimental/creation.py +++ b/ivy/functional/backends/tensorflow/experimental/creation.py @@ -73,7 +73,7 @@ def tril_indices( k: int = 0, /, *, - device: str = None, + device: Optional[str] = None, ) -> Tuple[Union[tf.Tensor, tf.Variable], ...]: n_cols = n_rows if n_cols is None else n_cols diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index ffa8da38b5333..5fe49de82d4df 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -657,7 +657,7 @@ def fft( /, *, norm: str = "backward", - n: Union[int, Tuple[int]] = None, + n: Optional[Union[int, Tuple[int]]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: # ToDo: Remove conversion from float to complex when casting mode is working @@ -804,7 +804,7 @@ def ifft( dim: int, *, norm: str = "backward", - n: Union[int, Tuple[int]] = None, + n: Optional[Union[int, Tuple[int]]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: if not isinstance(dim, int): @@ -947,7 +947,7 @@ def interpolate( def _fft2_norm( x: Union[tf.Tensor, tf.Variable], - s: Sequence[int] = None, + s: Optional[Sequence[int]] = None, dim: Sequence[int] = (-2, -1), norm: str = "backward", ): @@ -964,7 +964,7 @@ def _fft2_norm( def trans_x_to_s( x: Union[tf.Tensor, tf.Variable], - s: Sequence[int] = None, + s: Optional[Sequence[int]] = None, dim: Sequence[int] = (-2, -1), ) -> Union[tf.Tensor, tf.Variable]: """Change the shape of the input array x to the desired output shape s.""" @@ -1056,7 +1056,7 @@ def _fft2_helper(x, shape, axes): def fft2( x: Union[tf.Tensor, tf.Variable], *, - s: Sequence[int] = None, + s: Optional[Sequence[int]] = None, dim: Sequence[int] = (-2, -1), norm: str = "backward", out: Optional[Union[tf.Tensor, tf.Variable]] = None, diff --git a/ivy/functional/backends/tensorflow/experimental/random.py b/ivy/functional/backends/tensorflow/experimental/random.py index d07cd3504420b..edb1a93721246 100644 --- a/ivy/functional/backends/tensorflow/experimental/random.py +++ b/ivy/functional/backends/tensorflow/experimental/random.py @@ -70,7 +70,7 @@ def poisson( lam: Union[float, tf.Tensor, tf.Variable], *, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - device: str = None, + device: Optional[str] = None, dtype: DType, seed: Optional[int] = None, fill_value: Optional[Union[float, int]] = 0, @@ -95,7 +95,7 @@ def bernoulli( *, logits: Union[float, tf.Tensor, tf.Variable] = None, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - device: str = None, + device: Optional[str] = None, dtype: DType, seed: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 861d3322d5bd4..3fa251d958b35 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -59,7 +59,7 @@ def get_item( /, query: Union[tf.Tensor, tf.Variable, Tuple], *, - copy: bool = None, + copy: Optional[bool] = None, ) -> Union[tf.Tensor, tf.Variable]: return x.__getitem__(query) diff --git a/ivy/functional/backends/tensorflow/manipulation.py b/ivy/functional/backends/tensorflow/manipulation.py index 3800ed8580297..c03e976a84cad 100644 --- a/ivy/functional/backends/tensorflow/manipulation.py +++ b/ivy/functional/backends/tensorflow/manipulation.py @@ -244,7 +244,7 @@ def repeat( /, repeats: Union[int, List[int]], *, - axis: int = None, + axis: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.repeat(x, repeats, axis) diff --git a/ivy/functional/backends/tensorflow/random.py b/ivy/functional/backends/tensorflow/random.py index 6508a5ac2603b..c9579e3ff19f5 100644 --- a/ivy/functional/backends/tensorflow/random.py +++ b/ivy/functional/backends/tensorflow/random.py @@ -35,7 +35,7 @@ def random_uniform( high: Union[float, tf.Tensor, tf.Variable] = 1.0, shape: Optional[Union[ivy.NativeShape, Sequence[int], tf.Tensor]] = None, dtype: DType, - device: str = None, + device: Optional[str] = None, seed: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: @@ -54,7 +54,7 @@ def random_normal( shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, dtype: DType, seed: Optional[int] = None, - device: str = None, + device: Optional[str] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: _check_valid_scale(std) @@ -75,7 +75,7 @@ def multinomial( batch_size: int = 1, probs: Optional[Union[tf.Tensor, tf.Variable]] = None, replace: bool = True, - device: str = None, + device: Optional[str] = None, seed: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: @@ -128,7 +128,7 @@ def randint( /, *, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - device: str = None, + device: Optional[str] = None, dtype: Optional[Union[DType, ivy.Dtype]] = None, seed: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, diff --git a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py index 75f4bd49eabd7..85b10db40b9ad 100644 --- a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py +++ b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py @@ -58,7 +58,7 @@ def bernoulli( *, logits: Union[float, tf.Tensor, tf.Variable] = None, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - device: str = None, + device: Optional[str] = None, dtype: DType, seed: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 69a55000cd6b6..ad2ca77c5ebeb 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -708,7 +708,7 @@ def fft( /, *, norm: str = "backward", - n: Union[int, Tuple[int]] = None, + n: Optional[Union[int, Tuple[int]]] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if not isinstance(dim, int): @@ -853,7 +853,7 @@ def ifft( dim: int, *, norm: str = "backward", - n: Union[int, Tuple[int]] = None, + n: Optional[Union[int, Tuple[int]]] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if not isinstance(dim, int): @@ -974,7 +974,7 @@ def adaptive_avg_pool2d(input, output_size): def fft2( x: torch.Tensor, *, - s: Sequence[int] = None, + s: Optional[Sequence[int]] = None, dim: Sequence[int] = (-2, -1), norm: str = "backward", out: Optional[torch.Tensor] = None, @@ -1039,8 +1039,8 @@ def rfft( @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) def rfftn( x: torch.Tensor, - s: Sequence[int] = None, - axes: Sequence[int] = None, + s: Optional[Sequence[int]] = None, + axes: Optional[Sequence[int]] = None, *, norm: str = "backward", out: Optional[torch.Tensor] = None, @@ -1250,7 +1250,7 @@ def max_unpool1d( kernel_size: Union[Tuple[int], int], /, *, - strides: Union[int, Tuple[int]] = None, + strides: Optional[Union[int, Tuple[int]]] = None, padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> torch.Tensor: diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index e907e93ee4a0b..f667829c69534 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -91,7 +91,7 @@ def get_item( /, query: Union[torch.Tensor, Tuple], *, - copy: bool = None, + copy: Optional[bool] = None, ) -> torch.Tensor: return x.__getitem__(query) diff --git a/ivy/functional/frontends/tensorflow/func_wrapper.py b/ivy/functional/frontends/tensorflow/func_wrapper.py index 86fa25e0bc2d1..c72ff5565a19d 100644 --- a/ivy/functional/frontends/tensorflow/func_wrapper.py +++ b/ivy/functional/frontends/tensorflow/func_wrapper.py @@ -1,6 +1,6 @@ # global import inspect -from typing import Callable, Dict +from typing import Callable, Dict, Optional import functools # local @@ -139,7 +139,9 @@ def _inputs_to_ivy_arrays_tf(*args, **kwargs): return _inputs_to_ivy_arrays_tf -def map_raw_ops_alias(alias: callable, kwargs_to_update: Dict = None) -> callable: +def map_raw_ops_alias( + alias: callable, kwargs_to_update: Optional[Dict] = None +) -> callable: """ Map the raw_ops function with its respective frontend alias function, as the implementations of raw_ops is way similar to that of frontend functions, except that diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index 3e35a572b8799..0454871cb9f2f 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -776,7 +776,7 @@ def default_device( /, *, item: Optional[Union[list, tuple, dict, ivy.Array, ivy.NativeArray]] = None, - as_native: bool = None, + as_native: Optional[bool] = None, ) -> Union[ivy.Device, ivy.NativeDevice]: """ Return the input device or the default device. If the as_native flag is set, the diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 6cdf158f33056..b88ac84f01efd 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -2704,7 +2704,7 @@ def reduce_window( def fft2( x: Union[ivy.Array, ivy.NativeArray], *, - s: Sequence[int] = None, + s: Optional[Sequence[int]] = None, dim: Sequence[int] = (-2, -1), norm: str = "backward", out: Optional[ivy.Array] = None, @@ -3162,7 +3162,7 @@ def max_unpool1d( kernel_size: Union[Tuple[int], int], /, *, - strides: Union[int, Tuple[int]] = None, + strides: Optional[Union[int, Tuple[int]]] = None, padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Array: diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index eb24eba85ff0e..f0e7ad7af4f76 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -183,9 +183,9 @@ def get_referrers_recursive( item: object, *, depth: int = 0, - max_depth: int = None, - seen_set: set = None, - local_set: set = None, + max_depth: Optional[int] = None, + seen_set: Optional[set] = None, + local_set: Optional[set] = None, ) -> ivy.Container: """ Recursively retrieve referrers for an object. @@ -2341,7 +2341,7 @@ def stable_pow( exponent: Union[Number, ivy.Array, ivy.NativeArray], /, *, - min_base: float = None, + min_base: Optional[float] = None, ) -> Any: """ Raise the base by the power, with ivy.min_base added to the base when exponent > 1 diff --git a/ivy/functional/ivy/manipulation.py b/ivy/functional/ivy/manipulation.py index 49bd0c36db1c4..318c663b739b7 100644 --- a/ivy/functional/ivy/manipulation.py +++ b/ivy/functional/ivy/manipulation.py @@ -1091,7 +1091,7 @@ def repeat( /, repeats: Union[int, Iterable[int]], *, - axis: int = None, + axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: """ diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 4529bfd2e9a8a..7f21c0bc413ab 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -1,7 +1,7 @@ # global import copy import time -from typing import Union, List +from typing import Union, List, Optional import numpy as np import types import importlib @@ -376,9 +376,9 @@ def test_function( input_dtypes: Union[ivy.Dtype, List[ivy.Dtype]], test_flags: FunctionTestFlags, fn_name: str, - rtol_: float = None, + rtol_: Optional[float] = None, atol_: float = 1e-06, - tolerance_dict: dict = None, + tolerance_dict: Optional[dict] = None, test_values: bool = True, xs_grad_idxs=None, ret_grad_idxs=None, @@ -720,10 +720,10 @@ def test_frontend_function( on_device="cpu", frontend: str, fn_tree: str, - gt_fn_tree: str = None, - rtol: float = None, + gt_fn_tree: Optional[str] = None, + rtol: Optional[float] = None, atol: float = 1e-06, - tolerance_dict: dict = None, + tolerance_dict: Optional[dict] = None, test_values: bool = True, **all_as_kwargs_np, ): @@ -1208,7 +1208,7 @@ def gradient_test( input_dtypes, test_flags, test_trace: bool = False, - rtol_: float = None, + rtol_: Optional[float] = None, atol_: float = 1e-06, tolerance_dict=None, xs_grad_idxs=None, @@ -1589,17 +1589,17 @@ def test_method_ground_truth_computation( def test_method( *, - init_input_dtypes: List[ivy.Dtype] = None, - method_input_dtypes: List[ivy.Dtype] = None, - init_all_as_kwargs_np: dict = None, - method_all_as_kwargs_np: dict = None, + init_input_dtypes: Optional[List[ivy.Dtype]] = None, + method_input_dtypes: Optional[List[ivy.Dtype]] = None, + init_all_as_kwargs_np: Optional[dict] = None, + method_all_as_kwargs_np: Optional[dict] = None, init_flags: pf.MethodTestFlags, method_flags: pf.MethodTestFlags, class_name: str, method_name: str = "__call__", init_with_v: bool = False, method_with_v: bool = False, - rtol_: float = None, + rtol_: Optional[float] = None, atol_: float = 1e-06, tolerance_dict=None, test_values: Union[bool, str] = True, @@ -1910,15 +1910,15 @@ def test_frontend_method( method_input_dtypes: Union[ivy.Dtype, List[ivy.Dtype]], init_flags, method_flags, - init_all_as_kwargs_np: dict = None, + init_all_as_kwargs_np: Optional[dict] = None, method_all_as_kwargs_np: dict, frontend: str, frontend_method_data: FrontendMethodData, backend_to_test: str, on_device, - rtol_: float = None, + rtol_: Optional[float] = None, atol_: float = 1e-06, - tolerance_dict: dict = None, + tolerance_dict: Optional[dict] = None, test_values: Union[bool, str] = True, ): """ diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index d14b66c59b421..4d20d861e1f17 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -5,7 +5,7 @@ import importlib import inspect import functools -from typing import List +from typing import List, Optional from hypothesis import given, strategies as st @@ -90,7 +90,7 @@ def num_positional_args_method(draw, *, method): @st.composite -def num_positional_args(draw, *, fn_name: str = None): +def num_positional_args(draw, *, fn_name: Optional[str] = None): """ Draws an integers randomly from the minimum and maximum number of positional arguments a given function can take. @@ -331,7 +331,7 @@ def _partition_dtypes_into_kinds(framework: str, dtypes): def handle_test( *, - fn_tree: str = None, + fn_tree: Optional[str] = None, ground_truth_backend: str = "tensorflow", number_positional_args=None, test_instance_method=BuiltInstanceStrategy, @@ -475,8 +475,8 @@ def wrapped_test(*args, **kwargs): def handle_frontend_test( *, fn_tree: str, - gt_fn_tree: str = None, - aliases: List[str] = None, + gt_fn_tree: Optional[str] = None, + aliases: Optional[List[str]] = None, number_positional_args=None, test_with_out=BuiltWithOutStrategy, test_with_copy=BuiltWithCopyStrategy, @@ -626,7 +626,7 @@ def _import_method(method_tree: str): def handle_method( *, init_tree: str = "", - method_tree: str = None, + method_tree: Optional[str] = None, ground_truth_backend: str = "tensorflow", test_gradients=BuiltGradientStrategy, test_trace=BuiltTraceStrategy, diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_activations.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_activations.py index c0b7eaa4a2ce9..7d3fca6e829d7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_activations.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_activations.py @@ -6,6 +6,7 @@ import ivy import ivy_tests.test_ivy.helpers as helpers from ivy_tests.test_ivy.helpers import handle_frontend_test +from typing import Optional try: import tensorflow as tf @@ -34,7 +35,7 @@ def simple_test_two_function( frontend: str, fn_str: str, dtype_data: str, - rtol_: float = None, + rtol_: Optional[float] = None, atol_: float = 1e-06, ivy_submodules: list = [], framework_submodules: list = [], diff --git a/ivy_tests/test_ivy/test_misc/test_inspection.py b/ivy_tests/test_ivy/test_misc/test_inspection.py index a218e77e09928..4ea8449a386c7 100644 --- a/ivy_tests/test_ivy/test_misc/test_inspection.py +++ b/ivy_tests/test_ivy/test_misc/test_inspection.py @@ -17,7 +17,7 @@ def _fn0(xs: Optional[List[ivy.Array]] = None): def _fn1( a: Union[ivy.Array, ivy.NativeArray], b: str = "hello", - c: int = None, + c: Optional[int] = None, d: ivy.NativeArray = None, ): return a, b, c, d @@ -26,7 +26,7 @@ def _fn1( def _fn2( a: Tuple[Union[ivy.Array, ivy.NativeArray, ivy.Container]], bs: Tuple[str] = ("a", "b", "c"), - cs: Dict[str, ivy.Array] = None, + cs: Optional[Dict[str, ivy.Array]] = None, ): return a, bs, cs diff --git a/scripts/eager_mode_benchmark/benchmark.py b/scripts/eager_mode_benchmark/benchmark.py index 049a05a995fab..ba568a18de238 100644 --- a/scripts/eager_mode_benchmark/benchmark.py +++ b/scripts/eager_mode_benchmark/benchmark.py @@ -274,11 +274,11 @@ def eager_benchmark( def visualize_speed_up( - file_path: str = None, - output_path: str = None, + file_path: Optional[str] = None, + output_path: Optional[str] = None, devices: Union[List[str], str] = "all", backends: Union[List[str], str] = "all", - labels: Union[List[str], str] = None, + labels: Optional[Union[List[str], str]] = None, ): """ Visualize the speed up results stored in the csv. From 0aec4ed1da37ce4c46a0cf0637c22699bc06b4a7 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 15 Nov 2023 08:08:55 +0530 Subject: [PATCH 189/978] chore(ci): Updated tests_per_run for the gpu cron tests to be 8 instead of 10 based on the workflow duration --- scripts/setup_tests/cron_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/setup_tests/cron_tests.py b/scripts/setup_tests/cron_tests.py index b57e54dd3dc7e..810401efffb48 100644 --- a/scripts/setup_tests/cron_tests.py +++ b/scripts/setup_tests/cron_tests.py @@ -9,7 +9,7 @@ main() with open("tests_to_run", "r") as f: test_names = [line.strip() for line in f.readlines()] - tests_per_run = 10 + tests_per_run = 8 else: test_names = get_all_tests() tests_per_run = 150 From 056ca9ed9ddf4cddb205cb3a312dbf6d02c305a1 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Wed, 15 Nov 2023 12:33:28 +0400 Subject: [PATCH 190/978] fix: apt does not work in macOS --- install_dependencies.sh | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/install_dependencies.sh b/install_dependencies.sh index d5dbcc660307b..6fa84d7003008 100755 --- a/install_dependencies.sh +++ b/install_dependencies.sh @@ -1,12 +1,13 @@ # This shell script is required by the doc-builder. Moving it might break # the doc-building pipeline -sudo apt-get update -sudo apt-get install pandoc -y pip install -r requirements/requirements.txt if [[ $(arch) == 'arm64' ]]; then + brew install pandoc pip install -r requirements/optional_apple_silicon_1.txt pip install -r requirements/optional_apple_silicon_2.txt else + sudo apt-get update + sudo apt-get install pandoc -y pip install -r requirements/optional.txt fi From a9739338693f228c9d27e882b79b8d55bf70263e Mon Sep 17 00:00:00 2001 From: Eddy Oyieko <67474838+mobley-trent@users.noreply.github.com> Date: Wed, 15 Nov 2023 12:38:19 +0300 Subject: [PATCH 191/978] (fix): Fixed `torch.abs` frontend test (#27284) --- .../test_frontends/test_torch/test_pointwise_ops.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py index ac5d352ee8925..0e7744ac41a41 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py @@ -117,7 +117,14 @@ def _masked_fill_helper(draw): fn_tree="torch.abs", aliases=["torch.absolute"], dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric", full=False), + available_dtypes=helpers.get_dtypes("numeric", full=False).filter( + lambda x: "uint8" not in x[0] + and "int8" not in x[0] + and "uint16" not in x[0] + and "int16" not in x[0] + and "float16" not in x[0] + and "bfloat16" not in x[0] + ), large_abs_safety_factor=2.5, small_abs_safety_factor=2.5, safety_factor_scale="log", From 35a5a4e9eea324ea48645d02b8e1072598e1d36c Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Thu, 16 Nov 2023 08:42:49 +0000 Subject: [PATCH 192/978] fix: Fix tensorflow backend conv functions with incorrect types being casted together --- ivy/functional/backends/tensorflow/layers.py | 28 +++++++++++++------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 5f449c500473d..092bd58ce0f8c 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -166,9 +166,9 @@ def conv2d( filters = tf.transpose(filters, (2, 3, 1, 0)) x = _x_dil_before_conv(x, 2, x_dilations) padding, explicit_padding = _to_explicit_padding(padding, 2) - strides = [1] + ([strides] * 2 if isinstance(strides, int) else strides) + [1] + strides = [1] + list([strides] * 2 if isinstance(strides, int) else strides) + [1] dilations = ( - [1] + ([dilations] * 2 if isinstance(dilations, int) else dilations) + [1] + [1] + list([dilations] * 2 if isinstance(dilations, int) else dilations) + [1] ) res = tf.raw_ops.Conv2D( input=x, @@ -267,9 +267,9 @@ def conv3d( filters = tf.transpose(filters, (2, 3, 4, 1, 0)) x = _x_dil_before_conv(x, 3, x_dilations) x, padding = _pad_before_conv(x, padding, 3) - strides = [1] + ([strides] * 3 if isinstance(strides, int) else strides) + [1] + strides = [1] + list([strides] * 3 if isinstance(strides, int) else strides) + [1] dilations = ( - [1] + ([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] + [1] + list([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] ) res = tf.nn.conv3d(x, filters, strides, padding, "NDHWC", dilations) res = tf.math.add(res, bias) if bias is not None else res @@ -298,9 +298,9 @@ def conv3d_transpose( raise ivy.utils.exceptions.IvyException( "Tensorflow does not support dilations greater than 1 when device is cpu" ) - strides = [1] + ([strides] * 3 if isinstance(strides, int) else strides) + [1] + strides = [1] + list([strides] * 3 if isinstance(strides, int) else strides) + [1] dilations = ( - [1] + ([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] + [1] + list([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] ) if data_format == "NCDHW": x = tf.transpose(x, (0, 2, 3, 4, 1)) @@ -369,9 +369,13 @@ def conv_general_dilated( ) elif dims == 2: padding, explicit_padding = _to_explicit_padding(padding, 2) - strides = [1] + ([strides] * 2 if isinstance(strides, int) else strides) + [1] + strides = ( + [1] + list([strides] * 2 if isinstance(strides, int) else strides) + [1] + ) dilations = ( - [1] + ([dilations] * 2 if isinstance(dilations, int) else dilations) + [1] + [1] + + list([dilations] * 2 if isinstance(dilations, int) else dilations) + + [1] ) res = tf.raw_ops.Conv2D( input=x, @@ -384,9 +388,13 @@ def conv_general_dilated( ) else: x, padding = _pad_before_conv(x, padding, dims) - strides = [1] + ([strides] * 3 if isinstance(strides, int) else strides) + [1] + strides = ( + [1] + list([strides] * 3 if isinstance(strides, int) else strides) + [1] + ) dilations = ( - [1] + ([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] + [1] + + list([dilations] * 3 if isinstance(dilations, int) else dilations) + + [1] ) # grouped conv3d is not supported on CPU # ToDO: change the condition of GPU when automatic device shifting From 8baac2daca1c7ad663fbe38ec44918c01487c725 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Thu, 16 Nov 2023 15:23:32 +0000 Subject: [PATCH 193/978] refactor: Refactor the frontend Parameter class to use gradient helper functions to correctly handle NativeVariable instances underneath --- ivy/functional/frontends/torch/nn/parameter.py | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/parameter.py b/ivy/functional/frontends/torch/nn/parameter.py index d50820f01035d..11f93bdf6e6cb 100644 --- a/ivy/functional/frontends/torch/nn/parameter.py +++ b/ivy/functional/frontends/torch/nn/parameter.py @@ -1,9 +1,23 @@ +import ivy from ivy.functional.frontends.torch.tensor import Tensor +import ivy.functional.frontends.torch as torch_frontend +from ivy.functional.ivy.gradients import _variable, _is_variable, _variable_data class Parameter(Tensor): - def __init__(self, array, device=None, _init_overload=False, requires_grad=True): - super().__init__(array, device, _init_overload, requires_grad) + def __init__(self, data=None, device=None, requires_grad=True): + if data is None: + data = torch_frontend.empty(0) + ivy_array = ( + ivy.array(data) if not hasattr(data, "_ivy_array") else data.ivy_array + ) + ivy_array = _variable(ivy_array) if not _is_variable(data) else ivy_array + self._ivy_array = ivy.to_device(ivy_array, device) if device else ivy_array + self._data = Tensor(_variable_data(self._ivy_array), _init_overload=True) + self._requires_grad = requires_grad + self._is_leaf = True + self._grads = None + self.grad_fn = None def __deepcopy__(self, memo): # TODO: Need to add test. Adding for KLA demo (priority) From 798803574100b8347357ebf9e59ad5c4055aca01 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 16 Nov 2023 15:39:06 +0000 Subject: [PATCH 194/978] feat: Added support for explicit padding to the torch and tf backends of ivy.conv2d_transpose and updated the corresponding frontend functions and the tests --- ivy/functional/backends/tensorflow/layers.py | 203 +++++++++++------- ivy/functional/backends/torch/layers.py | 149 +++++++------ ivy/functional/frontends/tensorflow/nn.py | 11 + .../nn/functional/convolution_functions.py | 27 ++- .../test_frontends/test_tensorflow/test_nn.py | 108 ++++------ .../test_convolution_functions.py | 83 ++++--- .../test_functional/test_nn/test_layers.py | 149 ++++++++----- 7 files changed, 419 insertions(+), 311 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 092bd58ce0f8c..58072a5e1196a 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -63,22 +63,30 @@ def _to_explicit_padding(padding, dims): return "EXPLICIT", explicit_pad -def _output_shape( - x_shape, filter_shape, output_shape, strides, padding, dims, dilations -): +def _transpose_out_pad(x_shape, filter_shape, strides, padding, dims, dilations): dilations = [dilations] * dims if isinstance(dilations, int) else dilations strides = [strides] * dims if isinstance(strides, int) else strides - if output_shape is None: + if isinstance(padding, str): out_shape = [ _deconv_length( - x_shape[i + 1], strides[i], filter_shape[i], padding, dilations[i] + x_shape[1 + i], strides[i], filter_shape[i], padding, dilations[i] ) for i in range(dims) ] - output_shape = [x_shape[0], *out_shape, filter_shape[-2]] - elif len(output_shape) == dims: - output_shape = [x_shape[0]] + output_shape + [filter_shape[-2]] - return output_shape + else: + if isinstance(padding, int): + padding = [[padding, padding]] * dims + out_shape = [ + (x_shape[1 + i] - 1) * strides[i] + - padding[i][0] + - padding[i][1] + + dilations[i] * (filter_shape[i] - 1) + + 1 + for i in range(dims) + ] + padding = [[0, 0], *padding, [0, 0]] + out_shape = [x_shape[0], *out_shape, filter_shape[-2]] + return out_shape, padding @with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) @@ -132,9 +140,8 @@ def conv1d_transpose( if data_format == "NCW": x = tf.transpose(x, (0, 2, 1)) filters = tf.transpose(filters, (0, 2, 1)) - - output_shape = _output_shape( - x.shape, filters.shape, output_shape, strides, padding, 1, dilations + output_shape, padding = _transpose_out_pad( + x.shape, filters.shape, strides, padding, 1, dilations ) res = tf.nn.conv1d_transpose( x, filters, output_shape, strides, padding, "NWC", dilations @@ -190,7 +197,7 @@ def conv2d_transpose( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], strides: Union[int, Tuple[int, int]], - padding: str, + padding: Union[str, int, Sequence[Tuple[int, int]]], /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, @@ -208,8 +215,13 @@ def conv2d_transpose( if data_format == "NCHW": x = tf.transpose(x, (0, 2, 3, 1)) filters = tf.transpose(filters, (0, 1, 3, 2)) - output_shape = _output_shape( - x.shape, filters.shape, output_shape, strides, padding, 2, dilations + output_shape, padding = _transpose_out_pad( + x.shape, + filters.shape, + strides, + padding, + 2, + dilations, ) res = tf.nn.conv2d_transpose( x, filters, output_shape, strides, padding, "NHWC", dilations @@ -298,15 +310,15 @@ def conv3d_transpose( raise ivy.utils.exceptions.IvyException( "Tensorflow does not support dilations greater than 1 when device is cpu" ) - strides = [1] + list([strides] * 3 if isinstance(strides, int) else strides) + [1] - dilations = ( - [1] + list([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] - ) if data_format == "NCDHW": x = tf.transpose(x, (0, 2, 3, 4, 1)) filters = tf.transpose(filters, (0, 1, 2, 4, 3)) - output_shape = _output_shape( - x.shape, filters.shape, output_shape, strides[1:], padding, 3, dilations + output_shape, padding = _transpose_out_pad( + x.shape, filters.shape, strides, padding, 3, dilations + ) + strides = [1] + list([strides] * 3 if isinstance(strides, int) else strides) + [1] + dilations = ( + [1] + list([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] ) res = tf.nn.conv3d_transpose( x, filters, output_shape, strides, padding, "NDHWC", dilations @@ -456,61 +468,102 @@ def conv_general_transpose( ) -> Union[tf.Tensor, tf.Variable]: if data_format == "channel_first": x = tf.transpose(x, (0, *range(2, dims + 2), 1)) - if dims == 1: - res = tf.concat( - [ - conv1d_transpose( - x[..., j : j + filters.shape[-2] // feature_group_count], - filters[..., j : j + filters.shape[-2] // feature_group_count, :], - strides, - padding, - output_shape=output_shape, - data_format="NWC", - dilations=dilations, - ) - for j in range( - 0, filters.shape[-2], filters.shape[-2] // feature_group_count - ) - ], - axis=-1, - ) - elif dims == 2: - res = tf.concat( - [ - conv2d_transpose( - x[..., j : j + filters.shape[-2] // feature_group_count], - filters[..., j : j + filters.shape[-2] // feature_group_count, :], - strides, - padding, - output_shape=output_shape, - data_format="NHWC", - dilations=dilations, - ) - for j in range( - 0, filters.shape[-2], filters.shape[-2] // feature_group_count - ) - ], - axis=-1, - ) + if feature_group_count == 1: + if dims == 1: + res = conv1d_transpose( + x, + filters, + strides, + padding, + output_shape=output_shape, + data_format="NWC", + dilations=dilations, + bias=bias, + ) + elif dims == 2: + res = conv2d_transpose( + x, + filters, + strides, + padding, + output_shape=output_shape, + data_format="NHWC", + dilations=dilations, + bias=bias, + ) + else: + res = conv3d_transpose( + x, + filters, + strides, + padding, + output_shape=output_shape, + data_format="NDHWC", + dilations=dilations, + bias=bias, + ) else: - res = tf.concat( - [ - conv3d_transpose( - x[..., j : j + filters.shape[-2] // feature_group_count], - filters[..., j : j + filters.shape[-2] // feature_group_count, :], - strides, - padding, - output_shape=output_shape, - data_format="NDHWC", - dilations=dilations, - ) - for j in range( - 0, filters.shape[-2], filters.shape[-2] // feature_group_count - ) - ], - axis=-1, - ) - res = tf.math.add(res, bias) if bias is not None else res + if dims == 1: + res = tf.concat( + [ + conv1d_transpose( + x[..., j : j + filters.shape[-2] // feature_group_count], + filters[ + ..., j : j + filters.shape[-2] // feature_group_count, : + ], + strides, + padding, + output_shape=output_shape, + data_format="NWC", + dilations=dilations, + ) + for j in range( + 0, filters.shape[-2], filters.shape[-2] // feature_group_count + ) + ], + axis=-1, + ) + elif dims == 2: + res = tf.concat( + [ + conv2d_transpose( + x[..., j : j + filters.shape[-2] // feature_group_count], + filters[ + ..., j : j + filters.shape[-2] // feature_group_count, : + ], + strides, + padding, + output_shape=output_shape, + data_format="NHWC", + dilations=dilations, + ) + for j in range( + 0, filters.shape[-2], filters.shape[-2] // feature_group_count + ) + ], + axis=-1, + ) + else: + res = tf.concat( + [ + conv3d_transpose( + x[..., j : j + filters.shape[-2] // feature_group_count], + filters[ + ..., j : j + filters.shape[-2] // feature_group_count, : + ], + strides, + padding, + output_shape=output_shape, + data_format="NDHWC", + dilations=dilations, + ) + for j in range( + 0, filters.shape[-2], filters.shape[-2] // feature_group_count + ) + ], + axis=-1, + ) + res = tf.math.add(res, bias) if bias is not None else res if data_format == "channel_first": res = tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) return res diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index cc2bf3913c9e2..a7b71b221b907 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -200,45 +200,56 @@ def _new_pad_before_conv(x, padding): return torch.nn.functional.pad(x, pad_list), "valid" -def _pad_before_conv_tranpose( - x, filters, strides, padding, dims, dilations, output_shape, filter_shape +def _tranpose_padding( + x_shape, filter_shape, strides, padding, dims, dilations, output_shape, data_format ): - if output_shape is None: + if output_shape is not None and len(output_shape) > dims: + if data_format[-1] == "C" or data_format == "channel_last": + output_shape = output_shape[1:-1] + elif data_format[1] == "C" or data_format == "channel_first": + output_shape = output_shape[2:] + strides = [strides] * dims if isinstance(strides, int) else strides + dilations = [dilations] * dims if isinstance(dilations, int) else dilations + not_valid_pad = [False] * dims + if isinstance(padding, str): + if output_shape is None: + output_shape = [ + _deconv_length( + x_shape[i], strides[i], filter_shape[i], padding, dilations[i] + ) + for i in range(dims) + ] + if padding == "VALID": + symmetric_padding = [0] * dims + else: + pad_specific = [ + _handle_padding( + output_shape[i], + strides[i], + filter_shape[i] + (filter_shape[i] - 1) * (dilations[i] - 1), + padding, + ) + for i in range(dims) + ] + for i in range(dims): + if pad_specific[i] % 2 != 0: + pad_specific[i] -= 1 + not_valid_pad[i] = True + symmetric_padding = [pad_specific[i] // 2 for i in range(dims)] out_shape = [ - _deconv_length( - x.shape[i + 2], strides[i], filter_shape[i], padding, dilations[i] - ) + (x_shape[i] - 1) * strides[i] + - 2 * symmetric_padding[i] + + dilations[i] * (filter_shape[i] - 1) + + 1 for i in range(dims) ] - output_shape = [x.shape[0], *out_shape, filters.shape[1]] - elif len(output_shape) == dims: - output_shape = [x.shape[0]] + output_shape + [filters.shape[1]] - not_valid_pad = [False] * dims - filter_shape = [ - filter_shape[i] + (filter_shape[i] - 1) * (dilations[i] - 1) - for i in range(dims) - ] - pad_specific = [ - _handle_padding(output_shape[i + 1], strides[i], filter_shape[i], padding) - for i in range(dims) - ] - if padding == "VALID": - padding_list = [0] * dims + output_padding = [max(output_shape[i] - out_shape[i], 0) for i in range(dims)] else: - for i in range(dims): - if pad_specific[i] % 2 != 0: - pad_specific[i] -= 1 - not_valid_pad[i] = True - padding_list = [pad_specific[i] // 2 for i in range(dims)] - out_shape = [ - (x.shape[i + 2] - 1) * strides[i] - - 2 * padding_list[i] - + dilations[i] * (filters.shape[i + 2] - 1) - + 1 - for i in range(dims) - ] - output_padding = [max(output_shape[i + 1] - out_shape[i], 0) for i in range(dims)] - return not_valid_pad, padding_list, output_padding + if isinstance(padding, int): + padding = [[padding, padding]] * dims + symmetric_padding = [max(pad) for pad in padding] + output_padding = [max(pad) - min(pad) for pad in padding] + return not_valid_pad, symmetric_padding, output_padding @with_unsupported_dtypes( @@ -338,17 +349,22 @@ def conv1d_transpose( if data_format == "NWC": x = x.permute(0, 2, 1) filters = filters.permute(1, 2, 0) - strides = [strides] if isinstance(strides, int) else strides - dilations = [dilations] if isinstance(dilations, int) else dilations - not_valid_pad, padding_list, output_padding = _pad_before_conv_tranpose( - x, filters, strides, padding, 1, dilations, output_shape, filters.shape[2:] + not_valid_pad, symmetric_padding, output_padding = _tranpose_padding( + x.shape[2:], + filters.shape[2:], + strides, + padding, + 1, + dilations, + output_shape, + data_format, ) res = torch.nn.functional.conv_transpose1d( x, filters, bias, strides, - padding_list, + symmetric_padding, dilation=dilations, output_padding=output_padding, ) @@ -444,7 +460,7 @@ def conv2d_transpose( x: torch.Tensor, filters: torch.Tensor, strides: Union[int, Tuple[int, int]], - padding: str, + padding: Union[str, int, Sequence[Tuple[int, int]]], /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, @@ -455,19 +471,23 @@ def conv2d_transpose( ): if data_format == "NHWC": x = x.permute(0, 3, 1, 2) - strides = [strides] * 2 if isinstance(strides, int) else strides - dilations = [dilations] * 2 if isinstance(dilations, int) else dilations filters = filters.permute(2, 3, 0, 1) - not_valid_pad, padding_list, output_padding = _pad_before_conv_tranpose( - x, filters, strides, padding, 2, dilations, output_shape, filters.shape[2:] + not_valid_pad, symmetric_padding, output_padding = _tranpose_padding( + x.shape[2:], + filters.shape[2:], + strides, + padding, + 2, + dilations, + output_shape, + data_format, ) - res = torch.nn.functional.conv_transpose2d( x, filters, bias, strides, - padding_list, + symmetric_padding, dilation=dilations, output_padding=output_padding, ) @@ -477,7 +497,6 @@ def conv2d_transpose( res = res[..., :-1] if data_format == "NHWC": res = res.permute(0, *range(2, 4), 1) - return res @@ -611,18 +630,23 @@ def conv3d_transpose( ) -> torch.Tensor: if data_format == "NDHWC": x = x.permute(0, 4, 1, 2, 3) - strides = [strides] * 3 if isinstance(strides, int) else strides - dilations = [dilations] * 3 if isinstance(dilations, int) else dilations filters = filters.permute(3, 4, 0, 1, 2) - not_valid_pad, padding_list, output_padding = _pad_before_conv_tranpose( - x, filters, strides, padding, 3, dilations, output_shape, filters.shape[2:] + not_valid_pad, symmetric_padding, output_padding = _tranpose_padding( + x.shape[2:], + filters.shape[2:], + strides, + padding, + 3, + dilations, + output_shape, + data_format, ) res = torch.nn.functional.conv_transpose3d( x, filters, bias, strides, - padding_list, + symmetric_padding, dilation=dilations, output_padding=output_padding, ) @@ -753,7 +777,7 @@ def conv_general_transpose( *, dims: int = 2, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - data_format: str = "NDHWC", + data_format: str = "channel_first", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, feature_group_count: int = 1, bias: Optional[torch.Tensor] = None, @@ -761,11 +785,16 @@ def conv_general_transpose( ): if data_format == "channel_last": x = x.permute(0, dims + 1, *range(1, dims + 1)) - strides = [strides] * dims if isinstance(strides, int) else strides - dilations = [dilations] * dims if isinstance(dilations, int) else dilations filters = filters.permute(dims, dims + 1, *range(dims)) - not_valid_pad, padding_list, output_padding = _pad_before_conv_tranpose( - x, filters, strides, padding, dims, dilations, output_shape, filters.shape[2:] + not_valid_pad, symmetric_padding, output_padding = _tranpose_padding( + x.shape[2:], + filters.shape[2:], + strides, + padding, + dims, + dilations, + output_shape, + data_format, ) if dims == 1: res = torch.nn.functional.conv_transpose1d( @@ -773,7 +802,7 @@ def conv_general_transpose( filters, bias, strides, - padding_list, + symmetric_padding, dilation=dilations, output_padding=output_padding, groups=feature_group_count, @@ -786,7 +815,7 @@ def conv_general_transpose( filters, bias, strides, - padding_list, + symmetric_padding, dilation=dilations, output_padding=output_padding, groups=feature_group_count, @@ -801,7 +830,7 @@ def conv_general_transpose( filters, bias, strides, - padding_list, + symmetric_padding, dilation=dilations, output_padding=output_padding, groups=feature_group_count, diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index c9a799c46f34c..f1c249217c7b2 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -42,6 +42,15 @@ def _convolution_broadcast_helper( return [1] + arg + [1] +def _reduce_padding(padding, data_format): + if not isinstance(padding, str): + if data_format[1] == "C": + padding = padding[2:] + else: + padding = padding[1:-1] + return padding + + def _reduce_strides_dilations(dim, stride, dilations): if not isinstance(stride, int): if len(stride) > dim: @@ -169,6 +178,7 @@ def conv2d( ): dilations = 1 if dilations is None else dilations strides, dilations = _reduce_strides_dilations(2, strides, dilations) + padding = _reduce_padding(padding, data_format) return ivy.conv2d( input, filters, strides, padding, data_format=data_format, dilations=dilations ) @@ -187,6 +197,7 @@ def conv2d_transpose( ): dilations = 1 if dilations is None else dilations strides, dilations = _reduce_strides_dilations(2, strides, dilations) + padding = _reduce_padding(padding, data_format) filters = filters.swapaxes(-2, -1) return ivy.conv2d_transpose( input, diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index e04aa97cd998c..a76123d964ef1 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -78,6 +78,19 @@ def _conv_transpose( return ret +def _get_transpose_pad(padding, output_padding, dims): + ( + padding, + output_padding, + ) = map( + lambda x: [x] * dims if isinstance(x, int) else x, [padding, output_padding] + ) + asymmetric_padding = [ + [pad, pad - output_pad] for pad, output_pad in zip(padding, output_padding) + ] + return asymmetric_padding + + def _valid_shapes(input, weight, bias, stride, padding, groups, transpose=False): in_channels = input.shape[1] out_channels = weight.shape[0] if not transpose else weight.shape[1] * groups @@ -219,15 +232,17 @@ def conv_transpose2d( groups=1, dilation=1, ): - return _conv_transpose( + weight = ivy.permute_dims(weight, axes=(2, 3, 0, 1)) + return ivy.conv_general_transpose( input, weight, + stride, + _get_transpose_pad(padding, output_padding, 2), + dims=2, + data_format="channel_first", + dilations=dilation, + feature_group_count=groups, bias=bias, - stride=stride, - padding=padding, - output_padding=output_padding, - groups=groups, - dilation=dilation, ) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py index 6e31f5673a1cd..0ce5569b2f081 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py @@ -1,15 +1,15 @@ # global -from hypothesis import strategies as st +from hypothesis import assume, strategies as st # local import ivy_tests.test_ivy.helpers as helpers -from ivy.functional.ivy.layers import _deconv_length from ivy_tests.test_ivy.helpers import handle_frontend_test from ivy_tests.test_ivy.test_functional.test_core.test_statistical import ( _statistical_dtype_values, ) from ivy_tests.test_ivy.test_functional.test_nn.test_layers import ( _assume_tf_dilation_gt_1, + _output_shape, ) @@ -226,7 +226,7 @@ def _x_and_filters( draw, dtypes, data_format, - padding, + padding=None, stride_min=1, stride_max=4, dilation_min=1, @@ -237,7 +237,6 @@ def _x_and_filters( ): data_format = draw(data_format) dtype = draw(dtypes) - padding = draw(padding) if type is not None: if "1" in type: dim = 1 @@ -249,18 +248,19 @@ def _x_and_filters( dim = 2 else: dim = len(data_format) - 2 - if padding == "EXPLICIT": - padding = draw( - helpers.lists( - x=st.integers(min_value=0, max_value=2), - min_size=dim * 2, - max_size=dim * 2, - ) + if padding is None: + padding = st.one_of( + st.lists( + st.tuples( + st.integers(min_value=0, max_value=3), + st.integers(min_value=0, max_value=3), + ), + min_size=dim, + max_size=dim, + ), + st.sampled_from(["SAME", "VALID"]), ) - if data_format.find("C") == 1: - padding = [1, 1, 1, 1] + padding - else: - padding = [0, 0] + padding + [0, 0] + padding = draw(padding) if atrous: dilations = draw(st.integers(dilation_min, dilation_max)) else: @@ -324,7 +324,6 @@ def _x_and_filters( helpers.ints(min_value=d_in, max_value=d_in), ) ) - x_w = x_shape[1] else: x_shape = draw( st.tuples( @@ -333,15 +332,6 @@ def _x_and_filters( helpers.ints(min_value=min_x_width, max_value=100), ) ) - x_w = x_shape[2] - if transpose: - output_shape = [ - x_shape[0], - _deconv_length( - x_w, fstride[0], filter_shape[0], padding, fdilations[0] - ), - filter_shape[1], - ] elif dim == 2: min_x_height = 1 min_x_width = 1 @@ -369,8 +359,6 @@ def _x_and_filters( helpers.ints(min_value=d_in, max_value=d_in), ) ) - x_h = x_shape[1] - x_w = x_shape[2] else: x_shape = draw( st.tuples( @@ -380,16 +368,6 @@ def _x_and_filters( helpers.ints(min_value=min_x_width, max_value=100), ) ) - x_h = x_shape[2] - x_w = x_shape[3] - if transpose: - output_shape_h = _deconv_length( - x_h, fstride[0], filter_shape[0], padding, fdilations[0] - ) - output_shape_w = _deconv_length( - x_w, fstride[1], filter_shape[1], padding, fdilations[1] - ) - output_shape = [x_shape[0], output_shape_h, output_shape_w, filter_shape[2]] elif dim == 3: filter_shape = draw( st.tuples( @@ -422,9 +400,6 @@ def _x_and_filters( helpers.ints(min_value=d_in, max_value=d_in), ) ) - x_d = x_shape[1] - x_h = x_shape[2] - x_w = x_shape[3] else: x_shape = draw( st.tuples( @@ -435,26 +410,30 @@ def _x_and_filters( helpers.ints(min_value=min_x_width, max_value=100), ) ) - x_d = x_shape[2] - x_h = x_shape[3] - x_w = x_shape[4] - if transpose: - output_shape_d = _deconv_length( - x_d, fstride[0], filter_shape[0], padding, fdilations[0] - ) - output_shape_h = _deconv_length( - x_h, fstride[1], filter_shape[1], padding, fdilations[1] - ) - output_shape_w = _deconv_length( - x_w, fstride[2], filter_shape[2], padding, fdilations[2] + if data_format[-1] == "C": + x_dims = x_shape[1:-1] + else: + x_dims = x_shape[2:] + if transpose: + output_shape = _output_shape( + dim, fdilations, fstride, padding, x_dims, filter_shape + ) + assume(all(s > 0 for s in output_shape)) + if data_format[1] == "C": + output_shape = [x_shape[0], filter_shape[dim], *output_shape] + else: + output_shape = [x_shape[0], *output_shape, filter_shape[dim]] + if not isinstance(padding, str): + assume( + all( + max(pad) - min(pad) < min(stride, dilation) + for pad, stride, dilation in zip(padding, fstride, fdilations) ) - output_shape = [ - x_shape[0], - output_shape_d, - output_shape_h, - output_shape_w, - filter_shape[3], - ] + ) + if data_format[1] == "C": + padding = [(0, 0), (0, 0), *padding] + else: + padding = [(0, 0), *padding, (0, 0)] x = draw( helpers.array_values(dtype=dtype[0], shape=x_shape, min_value=0, max_value=1) ) @@ -806,8 +785,6 @@ def test_tensorflow_bias_add( dtypes=helpers.get_dtypes("float", full=False), data_format=st.sampled_from(["NWC"]), padding=st.sampled_from(["VALID", "SAME"]), - stride_min=3, - stride_max=4, type="1d", ), test_with_out=st.just(False), @@ -844,9 +821,6 @@ def test_tensorflow_conv1d( dtypes=helpers.get_dtypes("float", full=False), data_format=st.sampled_from(["NWC"]), padding=st.sampled_from(["VALID", "SAME"]), - stride_min=3, - stride_max=4, - dilation_max=1, type="1d", transpose=True, ), @@ -894,7 +868,6 @@ def test_tensorflow_conv1d_transpose( x_f_d_df=_x_and_filters( dtypes=helpers.get_dtypes("float", full=False), data_format=st.sampled_from(["NHWC"]), - padding=st.sampled_from(["VALID", "SAME"]), type="2d", ), ) @@ -929,7 +902,6 @@ def test_tensorflow_conv2d( x_f_d_df=_x_and_filters( dtypes=helpers.get_dtypes("float", full=False), data_format=st.sampled_from(["NHWC"]), - padding=st.sampled_from(["VALID", "SAME"]), type="2d", transpose=True, ), @@ -979,7 +951,6 @@ def test_tensorflow_conv2d_transpose( data_format=st.sampled_from(["NDHWC"]), padding=st.sampled_from(["SAME"]), type="3d", - dilation_max=1, ), test_with_out=st.just(False), ) @@ -993,6 +964,7 @@ def test_tensorflow_conv3d( on_device, ): input_dtype, x, filters, dilation, data_format, stride, padding = x_f_d_df + _assume_tf_dilation_gt_1("tensorflow", on_device, dilation) helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1014,7 +986,7 @@ def test_tensorflow_conv3d( x_f_d_df=_x_and_filters( dtypes=helpers.get_dtypes("float", full=False), data_format=st.sampled_from(["NDHWC"]), - padding=st.sampled_from(["SAME"]), + padding=st.sampled_from(["VALID", "SAME"]), type="3d", transpose=True, ), diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py index d61a1440719e1..f8cd1dfcbae57 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py @@ -81,14 +81,14 @@ def _fold_unfold_helper(draw, dim): def _output_shape( dims, dilation, stride, padding, output_padding, input_shape, weight_shape ): - dilation, stride, padding, output_padding = map( + padding, output_padding = map( lambda x: [x] * dims if isinstance(x, int) else x, - [dilation, stride, padding, output_padding], + [padding, output_padding], ) return [ - (input_shape[2 + i] - 1) * stride[i] + (input_shape[i] - 1) * stride[i] - 2 * padding[i] - + dilation[i] * (weight_shape[2 + i] - 1) + + dilation[i] * (weight_shape[i] - 1) + output_padding[i] + 1 for i in range(dims) @@ -119,7 +119,7 @@ def _unfold_helper(draw, dim=2): @st.composite -def _x_and_filters(draw, dim: int = 2, transpose: bool = False): +def _x_and_filters(draw, dim: int = 2, transpose: bool = False, max_dilation=3): if not isinstance(dim, int): dim = draw(dim) strides = draw( @@ -152,7 +152,7 @@ def _x_and_filters(draw, dim: int = 2, transpose: bool = False): ) ) batch_size = draw(st.integers(1, 5)) - filter_shape = draw( + filter_dim = draw( helpers.get_shape( min_num_dims=dim, max_num_dims=dim, min_dim_size=1, max_dim_size=5 ) @@ -168,11 +168,15 @@ def _x_and_filters(draw, dim: int = 2, transpose: bool = False): fc = draw(st.sampled_from(group_list)) dilations = draw( st.one_of( - st.lists(st.integers(min_value=1, max_value=3), min_size=dim, max_size=dim), - st.integers(min_value=1, max_value=3), + st.lists( + st.integers(min_value=1, max_value=max_dilation), + min_size=dim, + max_size=dim, + ), + st.integers(min_value=1, max_value=max_dilation), ) ) - full_dilations = [dilations] * dim if isinstance(dilations, int) else dilations + fdilations = [dilations] * dim if isinstance(dilations, int) else dilations if transpose: x_dim = draw( helpers.get_shape( @@ -182,15 +186,15 @@ def _x_and_filters(draw, dim: int = 2, transpose: bool = False): else: x_dim = [] for i in range(dim): - min_x = filter_shape[i] + (filter_shape[i] - 1) * (full_dilations[i] - 1) + min_x = filter_dim[i] + (filter_dim[i] - 1) * (fdilations[i] - 1) x_dim.append(draw(st.integers(min_x, 15))) x_dim = tuple(x_dim) if not transpose: output_channels = output_channels * fc - filter_shape = (output_channels, input_channels // fc) + filter_shape + filter_shape = (output_channels, input_channels // fc) + filter_dim else: input_channels = input_channels * fc - filter_shape = (input_channels, output_channels // fc) + filter_shape + filter_shape = (input_channels, output_channels // fc) + filter_dim x_shape = (batch_size, input_channels) + x_dim vals = draw( helpers.array_values( @@ -217,18 +221,33 @@ def _x_and_filters(draw, dim: int = 2, transpose: bool = False): ) ) if transpose: - full_strides = [strides] * dim if isinstance(strides, int) else strides + fstrides = [strides] * dim if isinstance(strides, int) else strides output_padding = draw( st.lists(st.integers(min_value=1, max_value=2), min_size=dim, max_size=dim) ) padding = [padding] * dim if isinstance(padding, int) else padding for i in range(len(output_padding)): # ToDo: remove this when support for output_padding > padding is added - output_padding[i] = min(padding[i], output_padding[i]) - m = min(full_strides[i], full_dilations[i]) + if dim != 2: + output_padding[i] = min(padding[i], output_padding[i]) + m = min(fstrides[i], fdilations[i]) output_padding[i] = min(output_padding[i], m - 1) if draw(st.booleans()): output_padding = min(output_padding) + assume( + all( + s > 0 + for s in _output_shape( + dim, + fdilations, + fstrides, + padding, + output_padding, + x_dim, + filter_dim, + ) + ) + ) return ( dtype, vals, @@ -345,7 +364,7 @@ def test_torch_conv3d( @handle_frontend_test( fn_tree="torch.nn.functional.conv_transpose1d", - dtype_vals=_x_and_filters(dim=1, transpose=True), + dtype_vals=_x_and_filters(dim=1, transpose=True, max_dilation=1), ) def test_torch_conv_tranpose1d( *, @@ -357,15 +376,7 @@ def test_torch_conv_tranpose1d( backend_fw, ): dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals - dilations = 1 # ToDo: remove this when support for dilation > 1 is added - assume( - all( - x > 0 - for x in _output_shape( - 1, dilations, strides, padding, output_pad, vals.shape, weight.shape - ) - ) - ) + _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_frontend_function( input_dtypes=dtype, backend_to_test=backend_fw, @@ -398,15 +409,7 @@ def test_torch_conv_tranpose2d( backend_fw, ): dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals - dilations = 1 # ToDo: remove this when support for dilation > 1 is added - assume( - all( - x > 0 - for x in _output_shape( - 2, dilations, strides, padding, output_pad, vals.shape, weight.shape - ) - ) - ) + _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_frontend_function( input_dtypes=dtype, backend_to_test=backend_fw, @@ -427,7 +430,7 @@ def test_torch_conv_tranpose2d( @handle_frontend_test( fn_tree="torch.nn.functional.conv_transpose3d", - dtype_vals=_x_and_filters(dim=3, transpose=True), + dtype_vals=_x_and_filters(dim=3, transpose=True, max_dilation=1), ) def test_torch_conv_tranpose3d( *, @@ -439,15 +442,7 @@ def test_torch_conv_tranpose3d( backend_fw, ): dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals - dilations = 1 # ToDo: remove this when support for dilation > 1 is added - assume( - all( - x > 0 - for x in _output_shape( - 3, dilations, strides, padding, output_pad, vals.shape, weight.shape - ) - ) - ) + _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_frontend_function( input_dtypes=dtype, backend_to_test=backend_fw, diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index f72187b0101c7..6aace4a0abe7e 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -67,6 +67,22 @@ def _dropout_helper(draw): return dtype_and_x, noise_shape, seed, dtype, prob, scale, training +@st.composite +def _general_transpose_helper(draw): + dims = draw(st.integers(1, 3)) + padding = st.sampled_from(["SAME", "VALID"]) if dims != 2 else None + x_f_d_df = draw( + _x_and_filters( + dim=dims, + general=True, + transpose=True, + bias=True, + padding=padding, + ) + ) + return dims, x_f_d_df + + @st.composite def _mha_helper(draw, same_pre_embed_dim=False, batch_second=False): _qkv_same_dim = draw(st.booleans()) @@ -366,6 +382,35 @@ def _nms_helper(draw): ) +# Convolutions # +# -------------# + + +def _output_shape(dims, dilation, stride, padding, x_shape, filter_shape): + if isinstance(padding, str): + return [ + _deconv_length( + x_shape[i], + stride[i], + filter_shape[i], + padding, + dilation[i], + ) + for i in range(dims) + ] + else: + if isinstance(padding, int): + padding = [[padding, padding]] * dims + return [ + (x_shape[i] - 1) * stride[i] + - padding[i][0] + - padding[i][1] + + dilation[i] * (filter_shape[i] - 1) + + 1 + for i in range(dims) + ] + + @st.composite def _roi_align_helper(draw): dtype = draw(helpers.get_dtypes("float", full=False))[0] @@ -411,14 +456,11 @@ def _roi_align_helper(draw): ) -# Convolutions # -# -------------# - - @st.composite def _x_and_filters( draw, dim: int = 2, + padding=None, transpose: bool = False, depthwise=False, general=False, @@ -462,48 +504,45 @@ def _x_and_filters( data_format = draw(st.sampled_from(["NWC", "NCW"])) else: data_format = draw(st.sampled_from(["NDHWC", "NCDHW"])) - - full_strides = [strides] * dim if isinstance(strides, int) else strides - full_dilations = [dilations] * dim if isinstance(dilations, int) else dilations + fdilations = [dilations] * dim if isinstance(dilations, int) else dilations + if padding is None: + padding = st.one_of( + st.lists( + st.tuples( + st.integers(min_value=0, max_value=3), + st.integers(min_value=0, max_value=3), + ), + min_size=dim, + max_size=dim, + ), + st.sampled_from(["SAME", "VALID"]), + st.integers(min_value=0, max_value=3), + ) + padding = draw(padding) if transpose: - padding = draw(st.sampled_from(["SAME", "VALID"])) + fstrides = [strides] * dim if isinstance(strides, int) else strides + if isinstance(padding, list): + assume( + all( + max(pad) - min(pad) < min(stride, dilation) + for pad, stride, dilation in zip(padding, fstrides, fdilations) + ) + ) x_dim = draw( helpers.get_shape( min_num_dims=dim, max_num_dims=dim, min_dim_size=1, max_dim_size=5 ) ) + output_shape = _output_shape( + dim, fdilations, fstrides, padding, x_dim, filter_shape + ) + assume(all(s > 0 for s in output_shape)) if draw(st.booleans()): - output_shape = [] - for i in range(dim): - output_shape.append( - _deconv_length( - x_dim[i], - full_strides[i], - filter_shape[i], - padding, - full_dilations[i], - ) - ) - else: output_shape = None else: - padding = draw( - st.one_of( - st.lists( - st.tuples( - st.integers(min_value=0, max_value=3), - st.integers(min_value=0, max_value=3), - ), - min_size=dim, - max_size=dim, - ), - st.sampled_from(["SAME", "VALID"]), - st.integers(min_value=0, max_value=3), - ) - ) x_dim = [] for i in range(dim): - min_x = filter_shape[i] + (filter_shape[i] - 1) * (full_dilations[i] - 1) + min_x = filter_shape[i] + (filter_shape[i] - 1) * (fdilations[i] - 1) x_dim.append(draw(st.integers(min_x, min_x + 1))) x_dim = tuple(x_dim) if not depthwise: @@ -931,8 +970,9 @@ def test_conv1d(*, x_f_d_df, test_flags, backend_fw, fn_name, on_device): dim=1, transpose=True, bias=True, + padding=st.sampled_from(["SAME", "VALID"]), ), - ground_truth_backend="jax", + ground_truth_backend="torch", ) def test_conv1d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_device): ( @@ -947,7 +987,8 @@ def test_conv1d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic fc, bias, ) = x_f_d_df - _assume_tf_dilation_gt_1(backend_fw, on_device, dilations[0]) + # tensorflow does not work with dilations > 1 on cpu + _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_function( input_dtypes=dtype, test_flags=test_flags, @@ -956,14 +997,13 @@ def test_conv1d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic on_device=on_device, rtol_=1e-2, atol_=1e-2, - # tensorflow does not work with dilations > 1 on cpu x=x, filters=filters, strides=stride, padding=pad, output_shape=output_shape, data_format=data_format, - dilations=dilations[0], + dilations=dilations, bias=bias, ) @@ -1021,8 +1061,7 @@ def test_conv2d(*, x_f_d_df, test_flags, backend_fw, fn_name, on_device): transpose=True, bias=True, ), - # tensorflow does not work with dilations > 1 on cpu - ground_truth_backend="jax", + ground_truth_backend="torch", ) def test_conv2d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_device): ( @@ -1037,8 +1076,7 @@ def test_conv2d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic fc, bias, ) = x_f_d_df - _assume_tf_dilation_gt_1(backend_fw, on_device, dilations[0]) - + _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_function( input_dtypes=dtype, test_flags=test_flags, @@ -1053,7 +1091,7 @@ def test_conv2d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic padding=pad, output_shape=output_shape, data_format=data_format, - dilations=dilations[0], + dilations=dilations, bias=bias, ) @@ -1109,8 +1147,9 @@ def test_conv3d(*, x_f_d_df, test_flags, backend_fw, fn_name, on_device): dim=3, transpose=True, bias=True, + padding=st.sampled_from(["SAME", "VALID"]), ), - ground_truth_backend="jax", + ground_truth_backend="torch", ) def test_conv3d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_device): ( @@ -1125,7 +1164,7 @@ def test_conv3d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic fc, bias, ) = x_f_d_df - _assume_tf_dilation_gt_1(backend_fw, on_device, dilations[0]) + _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_function( input_dtypes=dtype, test_flags=test_flags, @@ -1140,7 +1179,7 @@ def test_conv3d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic padding=pad, output_shape=output_shape, data_format=data_format, - dilations=dilations[0], + dilations=dilations, bias=bias, ) @@ -1197,19 +1236,13 @@ def test_conv_general_dilated( @handle_test( fn_tree="functional.ivy.conv_general_transpose", - dims=st.shared(st.integers(1, 3), key="dims"), - x_f_d_df=_x_and_filters( - dim=st.shared(st.integers(1, 3), key="dims"), - general=True, - transpose=True, - bias=True, - ), - ground_truth_backend="jax", + dim_x_f_d_df=_general_transpose_helper(), + ground_truth_backend="torch", ) def test_conv_general_transpose( - *, dims, x_f_d_df, test_flags, backend_fw, fn_name, on_device + *, dim_x_f_d_df, test_flags, backend_fw, fn_name, on_device ): - ( + dims, ( dtype, x, filters, @@ -1220,7 +1253,7 @@ def test_conv_general_transpose( output_shape, fc, bias, - ) = x_f_d_df + ) = dim_x_f_d_df _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_function( input_dtypes=dtype, From 9947b8ab37e5fcd224803f34d490565993d99da2 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 16 Nov 2023 21:19:13 +0530 Subject: [PATCH 195/978] feat: Updated `torch` version mapping from `2.1.0` to `2.1.1` (#27294) Co-authored-by: @AnnaTz --- ivy/functional/backends/torch/__init__.py | 24 +- ivy/functional/backends/torch/activations.py | 20 +- ivy/functional/backends/torch/creation.py | 8 +- ivy/functional/backends/torch/data_type.py | 2 +- ivy/functional/backends/torch/elementwise.py | 100 ++--- .../torch/experimental/activations.py | 26 +- .../backends/torch/experimental/creation.py | 6 +- .../torch/experimental/elementwise.py | 26 +- .../backends/torch/experimental/layers.py | 38 +- .../torch/experimental/linear_algebra.py | 4 +- .../backends/torch/experimental/losses.py | 10 +- .../torch/experimental/manipulation.py | 10 +- .../backends/torch/experimental/norms.py | 12 +- .../backends/torch/experimental/random.py | 6 +- .../backends/torch/experimental/sorting.py | 4 +- .../torch/experimental/statistical.py | 14 +- ivy/functional/backends/torch/general.py | 10 +- ivy/functional/backends/torch/layers.py | 30 +- .../backends/torch/linear_algebra.py | 52 +-- ivy/functional/backends/torch/manipulation.py | 4 +- ivy/functional/backends/torch/norms.py | 2 +- ivy/functional/backends/torch/random.py | 2 +- ivy/functional/backends/torch/searching.py | 4 +- ivy/functional/backends/torch/set.py | 8 +- ivy/functional/backends/torch/sorting.py | 8 +- ivy/functional/backends/torch/statistical.py | 14 +- ivy/functional/frontends/__init__.py | 2 +- .../frontends/torch/blas_and_lapack_ops.py | 2 +- .../frontends/torch/comparison_ops.py | 18 +- .../frontends/torch/creation_ops.py | 12 +- .../indexing_slicing_joining_mutating_ops.py | 4 +- ivy/functional/frontends/torch/linalg.py | 60 +-- .../frontends/torch/miscellaneous_ops.py | 34 +- .../nn/functional/convolution_functions.py | 12 +- .../torch/nn/functional/distance_functions.py | 6 +- .../torch/nn/functional/dropout_functions.py | 10 +- .../torch/nn/functional/layer_functions.py | 4 +- .../torch/nn/functional/linear_functions.py | 2 +- .../torch/nn/functional/loss_functions.py | 32 +- .../non_linear_activation_functions.py | 46 +- .../frontends/torch/nn/functional/norms.py | 8 +- .../torch/nn/functional/pooling_functions.py | 22 +- .../torch/nn/functional/sparse_functions.py | 2 +- .../torch/nn/functional/vision_functions.py | 12 +- .../frontends/torch/pointwise_ops.py | 106 ++--- .../frontends/torch/random_sampling.py | 8 +- .../frontends/torch/reduction_ops.py | 26 +- ivy/functional/frontends/torch/tensor.py | 402 +++++++++--------- .../frontends/torch/tensor_functions.py | 6 +- ivy/functional/frontends/torch/utilities.py | 2 +- ivy/functional/frontends/torchvision/ops.py | 4 +- 51 files changed, 643 insertions(+), 643 deletions(-) diff --git a/ivy/functional/backends/torch/__init__.py b/ivy/functional/backends/torch/__init__.py index 986b1eace46f7..15cf5702edaac 100644 --- a/ivy/functional/backends/torch/__init__.py +++ b/ivy/functional/backends/torch/__init__.py @@ -129,7 +129,7 @@ def rep_method(*args, **kwargs): # update these to add new dtypes valid_dtypes = { - "2.1.0 and below": ( + "2.1.1 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -147,7 +147,7 @@ def rep_method(*args, **kwargs): valid_numeric_dtypes = { - "2.1.0 and below": ( + "2.1.1 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -163,13 +163,13 @@ def rep_method(*args, **kwargs): } valid_int_dtypes = { - "2.1.0 and below": (ivy.int8, ivy.int16, ivy.int32, ivy.int64, ivy.uint8) + "2.1.1 and below": (ivy.int8, ivy.int16, ivy.int32, ivy.int64, ivy.uint8) } valid_float_dtypes = { - "2.1.0 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) + "2.1.1 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) } -valid_uint_dtypes = {"2.1.0 and below": (ivy.uint8,)} -valid_complex_dtypes = {"2.1.0 and below": (ivy.complex64, ivy.complex128)} +valid_uint_dtypes = {"2.1.1 and below": (ivy.uint8,)} +valid_complex_dtypes = {"2.1.1 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -182,17 +182,17 @@ def rep_method(*args, **kwargs): # invalid data types # update these to add new dtypes invalid_dtypes = { - "2.1.0 and below": ( + "2.1.1 and below": ( ivy.uint16, ivy.uint32, ivy.uint64, ) } -invalid_numeric_dtypes = {"2.1.0 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_int_dtypes = {"2.1.0 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_float_dtypes = {"2.1.0 and below": ()} -invalid_uint_dtypes = {"2.1.0 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_complex_dtypes = {"2.1.0 and below": ()} +invalid_numeric_dtypes = {"2.1.1 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_int_dtypes = {"2.1.1 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_float_dtypes = {"2.1.1 and below": ()} +invalid_uint_dtypes = {"2.1.1 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_complex_dtypes = {"2.1.1 and below": ()} invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) # leave these untouched diff --git a/ivy/functional/backends/torch/activations.py b/ivy/functional/backends/torch/activations.py index dc3fe5e33a5b4..3e955b8aec7a0 100644 --- a/ivy/functional/backends/torch/activations.py +++ b/ivy/functional/backends/torch/activations.py @@ -19,14 +19,14 @@ import ivy.functional.backends.torch as torch_backend -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def relu( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: return torch.relu(x) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def leaky_relu( x: torch.Tensor, /, @@ -38,7 +38,7 @@ def leaky_relu( return torch.nn.functional.leaky_relu(x, alpha) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def gelu( x: torch.Tensor, /, @@ -52,7 +52,7 @@ def gelu( return torch.nn.functional.gelu(x) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def sigmoid( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -64,7 +64,7 @@ def sigmoid( sigmoid.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def softmax( x: torch.Tensor, /, @@ -81,7 +81,7 @@ def softmax( return torch.nn.functional.softmax(x, axis) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def softplus( x: torch.Tensor, /, @@ -98,7 +98,7 @@ def softplus( # Softsign -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def softsign(x: torch.Tensor, /, out: Optional[torch.Tensor] = None) -> torch.Tensor: # return x / (1 + torch.abs(x)) return torch.nn.functional.softsign(x) @@ -108,7 +108,7 @@ def softsign(x: torch.Tensor, /, out: Optional[torch.Tensor] = None) -> torch.Te @with_unsupported_dtypes( - {"2.1.0 and below": ("float16",)}, + {"2.1.1 and below": ("float16",)}, backend_version, ) def log_softmax( @@ -129,7 +129,7 @@ def log_softmax( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16",)}, + {"2.1.1 and below": ("float16",)}, backend_version, ) def mish( @@ -147,7 +147,7 @@ def mish( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "complex", "float16", ) diff --git a/ivy/functional/backends/torch/creation.py b/ivy/functional/backends/torch/creation.py index 2a88d7696903c..e675c1caa6fd0 100644 --- a/ivy/functional/backends/torch/creation.py +++ b/ivy/functional/backends/torch/creation.py @@ -47,7 +47,7 @@ def _differentiable_linspace(start, stop, num, *, device, dtype=None): return res -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def arange( start: float, /, @@ -95,7 +95,7 @@ def _stack_tensors(x, dtype): return x -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) @_asarray_to_native_arrays_and_back @_asarray_infer_device @_asarray_handle_nestable @@ -166,7 +166,7 @@ def empty_like( return torch.empty_like(x, dtype=dtype, device=device) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) def eye( n_rows: int, n_cols: Optional[int] = None, @@ -276,7 +276,7 @@ def _slice_at_axis(sl, axis): @with_unsupported_device_and_dtypes( - {"2.1.0 and below": {"cpu": ("float16",)}}, backend_version + {"2.1.1 and below": {"cpu": ("float16",)}}, backend_version ) def linspace( start: Union[torch.Tensor, float], diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index 31265bff3577e..37087890c10fa 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -180,7 +180,7 @@ def as_ivy_dtype( ) -@with_unsupported_dtypes({"2.1.0 and below": ("uint16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("uint16",)}, backend_version) def as_native_dtype( dtype_in: Union[torch.dtype, str, bool, int, float, np.dtype] ) -> torch.dtype: diff --git a/ivy/functional/backends/torch/elementwise.py b/ivy/functional/backends/torch/elementwise.py index 83f820c588557..6fc4dbee20bd2 100644 --- a/ivy/functional/backends/torch/elementwise.py +++ b/ivy/functional/backends/torch/elementwise.py @@ -38,7 +38,7 @@ def add( add.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_xor( x1: Union[int, bool, torch.Tensor], @@ -54,7 +54,7 @@ def bitwise_xor( bitwise_xor.support_native_out = True -@with_supported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_supported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def imag( val: torch.Tensor, /, @@ -67,7 +67,7 @@ def imag( imag.support_native_out = False -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def expm1(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -77,7 +77,7 @@ def expm1(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te expm1.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_invert( x: Union[int, bool, torch.Tensor], /, *, out: Optional[torch.Tensor] = None @@ -129,7 +129,7 @@ def equal( equal.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def less_equal( x1: Union[float, torch.Tensor], @@ -145,7 +145,7 @@ def less_equal( less_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_and( x1: Union[int, bool, torch.Tensor], @@ -161,7 +161,7 @@ def bitwise_and( bitwise_and.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def ceil(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -175,7 +175,7 @@ def ceil(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten ceil.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def floor(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -189,7 +189,7 @@ def floor(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te floor.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def fmin( x1: torch.Tensor, x2: torch.Tensor, @@ -203,7 +203,7 @@ def fmin( fmin.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def asin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -213,7 +213,7 @@ def asin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten asin.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def asinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -223,7 +223,7 @@ def asinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te asinh.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sign( x: torch.Tensor, @@ -245,7 +245,7 @@ def sign( sign.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sqrt(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -255,7 +255,7 @@ def sqrt(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten sqrt.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def cosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -265,7 +265,7 @@ def cosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten cosh.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log10(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -275,14 +275,14 @@ def log10(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te log10.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log2(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) return torch.log2(x, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def log1p(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -298,7 +298,7 @@ def isnan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te return torch.isnan(x) -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def less( x1: Union[float, torch.Tensor], @@ -329,7 +329,7 @@ def multiply( multiply.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def cos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -370,7 +370,7 @@ def divide( divide.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def greater( x1: Union[float, torch.Tensor], @@ -386,7 +386,7 @@ def greater( greater.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def greater_equal( x1: Union[float, torch.Tensor], @@ -402,7 +402,7 @@ def greater_equal( greater_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def acos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -412,7 +412,7 @@ def acos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten acos.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float",)}, backend_version) @handle_numpy_arrays_in_specific_backend def lcm( x1: torch.Tensor, @@ -458,7 +458,7 @@ def logical_or( logical_or.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def acosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -468,7 +468,7 @@ def acosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te acosh.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -504,7 +504,7 @@ def not_equal( not_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def tanh( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None @@ -516,7 +516,7 @@ def tanh( tanh.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def floor_divide( x1: Union[float, torch.Tensor], @@ -537,7 +537,7 @@ def floor_divide( floor_divide.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_or( x1: Union[int, bool, torch.Tensor], @@ -553,7 +553,7 @@ def bitwise_or( bitwise_or.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -618,7 +618,7 @@ def pow( pow.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def round( x: torch.Tensor, /, *, decimals: int = 0, out: Optional[torch.Tensor] = None @@ -659,7 +659,7 @@ def trapz( trapz.support_native_out = False -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def trunc(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -692,7 +692,7 @@ def abs( abs.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def logaddexp( x1: torch.Tensor, x2: torch.Tensor, /, *, out: Optional[torch.Tensor] = None @@ -704,7 +704,7 @@ def logaddexp( logaddexp.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def logaddexp2( x1: Union[torch.Tensor, float, list, tuple], @@ -723,7 +723,7 @@ def logaddexp2( logaddexp2.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def tan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -733,7 +733,7 @@ def tan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens tan.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def atan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -744,7 +744,7 @@ def atan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version ) # TODO Fixed in PyTorch 1.12.1 (this note excludes complex) @handle_numpy_arrays_in_specific_backend def atan2( @@ -757,7 +757,7 @@ def atan2( atan2.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -767,7 +767,7 @@ def log(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens log.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def exp(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -808,7 +808,7 @@ def subtract( subtract.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def remainder( x1: Union[float, torch.Tensor], @@ -836,7 +836,7 @@ def remainder( remainder.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def atanh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -846,7 +846,7 @@ def atanh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te atanh.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_right_shift( x1: Union[int, bool, torch.Tensor], @@ -863,7 +863,7 @@ def bitwise_right_shift( bitwise_right_shift.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_left_shift( x1: Union[int, bool, torch.Tensor], @@ -883,7 +883,7 @@ def bitwise_left_shift( # ------# -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def erf(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -893,7 +893,7 @@ def erf(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens erf.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def minimum( x1: Union[float, torch.Tensor], @@ -912,7 +912,7 @@ def minimum( minimum.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def maximum( x1: Union[float, torch.Tensor], @@ -931,7 +931,7 @@ def maximum( maximum.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def reciprocal( x: Union[float, torch.Tensor], /, *, out: Optional[torch.Tensor] = None @@ -944,7 +944,7 @@ def reciprocal( @with_unsupported_dtypes( - {"2.1.0 and below": ("complex64", "complex128")}, backend_version + {"2.1.1 and below": ("complex64", "complex128")}, backend_version ) @handle_numpy_arrays_in_specific_backend def deg2rad(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: @@ -955,7 +955,7 @@ def deg2rad(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch. @with_unsupported_dtypes( - {"2.1.0 and below": ("complex64", "complex128")}, backend_version + {"2.1.1 and below": ("complex64", "complex128")}, backend_version ) @handle_numpy_arrays_in_specific_backend def rad2deg(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: @@ -965,7 +965,7 @@ def rad2deg(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch. rad2deg.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def trunc_divide( x1: Union[float, torch.Tensor], @@ -989,7 +989,7 @@ def isreal(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.T @with_unsupported_dtypes( - {"2.1.0 and below": ("bfloat16", "complex")}, + {"2.1.1 and below": ("bfloat16", "complex")}, backend_version, ) @handle_numpy_arrays_in_specific_backend diff --git a/ivy/functional/backends/torch/experimental/activations.py b/ivy/functional/backends/torch/experimental/activations.py index a883a4f1fbbb7..e4717f870ad2d 100644 --- a/ivy/functional/backends/torch/experimental/activations.py +++ b/ivy/functional/backends/torch/experimental/activations.py @@ -10,7 +10,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def logit( x: torch.Tensor, /, @@ -22,7 +22,7 @@ def logit( return torch.logit(x, eps=eps, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("complex", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex", "float16")}, backend_version) def thresholded_relu( x: torch.Tensor, /, @@ -33,14 +33,14 @@ def thresholded_relu( return torch.threshold(x, threshold=threshold, value=0) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def relu6( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: return torch.nn.functional.relu6(x) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def logsigmoid( input: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -49,7 +49,7 @@ def logsigmoid( return torch.nn.functional.logsigmoid(input) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def selu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: ret = torch.nn.functional.selu(x) if ivy.exists(out): @@ -57,12 +57,12 @@ def selu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def silu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.nn.functional.silu(x) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def elu( x: torch.Tensor, /, *, alpha: float = 1.0, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -74,7 +74,7 @@ def elu( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "complex", "float16", "bfloat16", @@ -93,7 +93,7 @@ def celu( return torch.celu(x, alpha=alpha) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def hardtanh( x: torch.Tensor, /, @@ -108,7 +108,7 @@ def hardtanh( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def tanhshrink( x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -118,7 +118,7 @@ def tanhshrink( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def threshold( x: torch.Tensor, /, @@ -133,7 +133,7 @@ def threshold( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def softshrink( x: torch.Tensor, /, *, lambd: float = 0.5, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -154,7 +154,7 @@ def scaled_tanh( return alpha * torch.nn.functional.tanh(beta * x) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def hardshrink( x: torch.Tensor, /, *, lambd: float = 0.5, out: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/ivy/functional/backends/torch/experimental/creation.py b/ivy/functional/backends/torch/experimental/creation.py index e56fd57cf39d6..09ce3fbd05694 100644 --- a/ivy/functional/backends/torch/experimental/creation.py +++ b/ivy/functional/backends/torch/experimental/creation.py @@ -20,7 +20,7 @@ @with_unsupported_device_and_dtypes( - {"2.1.0 and below": {"cpu": ("float16",)}}, + {"2.1.1 and below": {"cpu": ("float16",)}}, backend_version, ) def kaiser_window( @@ -87,7 +87,7 @@ def vorbis_window( vorbis_window.support_native_out = False -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def hann_window( size: int, /, @@ -152,7 +152,7 @@ def unsorted_segment_min( return res -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def blackman_window( size: int, /, diff --git a/ivy/functional/backends/torch/experimental/elementwise.py b/ivy/functional/backends/torch/experimental/elementwise.py index 2c6fb41c8b1a5..c7b1188fa34e5 100644 --- a/ivy/functional/backends/torch/experimental/elementwise.py +++ b/ivy/functional/backends/torch/experimental/elementwise.py @@ -16,7 +16,7 @@ @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "complex64", "complex128", ) @@ -40,7 +40,7 @@ def amax( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "complex64", "complex128", ) @@ -62,12 +62,12 @@ def amin( amin.support_native_out = True -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, backend_version) def lgamma(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.lgamma(x, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def fmax( x1: torch.Tensor, x2: torch.Tensor, @@ -82,7 +82,7 @@ def fmax( fmax.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def sinc(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) return torch.sinc(x, out=out) @@ -158,7 +158,7 @@ def count_nonzero( count_nonzero.support_native_out = False -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def nansum( x: torch.Tensor, /, @@ -227,7 +227,7 @@ def signbit( signbit.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def hypot( x1: torch.Tensor, x2: torch.Tensor, @@ -252,7 +252,7 @@ def allclose( return torch.tensor(ret) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def fix( x: torch.Tensor, /, @@ -265,7 +265,7 @@ def fix( fix.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def nextafter( x1: torch.Tensor, x2: torch.Tensor, @@ -319,7 +319,7 @@ def gradient( @with_supported_dtypes( - {"2.1.0 and below": ("float16", "float32", "float64")}, + {"2.1.1 and below": ("float16", "float32", "float64")}, backend_version, ) def xlogy( @@ -382,7 +382,7 @@ def _are_suitable_types_for_torch_lerp(input, end, weight): return True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def lerp( input: torch.Tensor, end: torch.Tensor, @@ -420,7 +420,7 @@ def modf( return torch.resolve_modf(input=modf_x) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def digamma( x: torch.Tensor, /, @@ -433,7 +433,7 @@ def digamma( digamma.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def erfc( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index ad2ca77c5ebeb..ebf85483ded22 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -29,7 +29,7 @@ def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_ return x, kernel, strides, depth_pooling -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def max_pool1d( x: torch.Tensor, kernel: Union[int, Tuple[int, ...]], @@ -94,7 +94,7 @@ def max_pool1d( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -170,7 +170,7 @@ def max_pool2d( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -283,7 +283,7 @@ def _get_specific_pad(x_shape, kernel, strides, padding, dims): return padding, pad_specific -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def avg_pool1d( x: torch.Tensor, kernel: Union[int, Tuple[int]], @@ -375,7 +375,7 @@ def _adjust_num_padded_values_to_ceil( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -479,7 +479,7 @@ def avg_pool2d( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -582,7 +582,7 @@ def avg_pool3d( return res -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, backend_version) def dct( x: torch.Tensor, /, @@ -695,7 +695,7 @@ def idct( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -741,7 +741,7 @@ def fft( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", "complex", @@ -773,7 +773,7 @@ def dropout( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16",)}, + {"2.1.1 and below": ("float16",)}, backend_version, ) def dropout1d( @@ -796,7 +796,7 @@ def dropout1d( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16",)}, + {"2.1.1 and below": ("float16",)}, backend_version, ) def dropout2d( @@ -821,7 +821,7 @@ def dropout2d( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -880,7 +880,7 @@ def ifft( return torch.fft.ifft(x, n, dim, norm, out=out).resolve_conj() -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def embedding( weights: torch.Tensor, indices: torch.Tensor, @@ -953,24 +953,24 @@ def interpolate( ) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def adaptive_max_pool2d( input: torch.Tensor, output_size: Union[Sequence[int], int] ) -> torch.Tensor: return torch.nn.functional.adaptive_max_pool2d(input, output_size) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def adaptive_avg_pool1d(input, output_size): return torch.nn.functional.adaptive_avg_pool1d(input, output_size) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def adaptive_avg_pool2d(input, output_size): return torch.nn.functional.adaptive_avg_pool2d(input, output_size) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def fft2( x: torch.Tensor, *, @@ -1036,7 +1036,7 @@ def rfft( return ret -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def rfftn( x: torch.Tensor, s: Optional[Sequence[int]] = None, @@ -1074,7 +1074,7 @@ def rfftn( # stft @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index 9ae68a74b6af5..53cb4e04c7063 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -12,7 +12,7 @@ from ivy.functional.ivy.experimental.linear_algebra import _check_valid_dimension_size -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def diagflat( x: torch.Tensor, /, @@ -176,7 +176,7 @@ def solve_triangular( solve_triangular.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def multi_dot( x: Sequence[torch.Tensor], /, diff --git a/ivy/functional/backends/torch/experimental/losses.py b/ivy/functional/backends/torch/experimental/losses.py index adb6d6e76510b..2a0edce437b2d 100644 --- a/ivy/functional/backends/torch/experimental/losses.py +++ b/ivy/functional/backends/torch/experimental/losses.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( - {"2.1.0 and below": ("unit8", "int8", "int16", "int32", "int64", "bool")}, + {"2.1.1 and below": ("unit8", "int8", "int16", "int32", "int64", "bool")}, backend_version, ) def l1_loss( @@ -30,7 +30,7 @@ def l1_loss( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "complex", "uint8", "int8", @@ -59,7 +59,7 @@ def smooth_l1_loss( @with_unsupported_dtypes( - {"2.1.0 and below": ("uint8", "int8", "int16", "int32", "int64", "bool")}, + {"2.1.1 and below": ("uint8", "int8", "int16", "int32", "int64", "bool")}, backend_version, ) def huber_loss( @@ -77,7 +77,7 @@ def huber_loss( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "uint8", "int8", @@ -104,7 +104,7 @@ def soft_margin_loss( @with_supported_dtypes( - {"2.1.0 and below": ("float",)}, + {"2.1.1 and below": ("float",)}, backend_version, ) def kl_div( diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index 57280e23e3cb4..62162125e9137 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -60,7 +60,7 @@ def heaviside( @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex64", "complex128")}, + {"2.1.1 and below": ("float32", "float64", "complex64", "complex128")}, backend_version, ) def pad( @@ -238,7 +238,7 @@ def fliplr( fliplr.support_native_out = False -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def i0( x: torch.Tensor, /, @@ -331,7 +331,7 @@ def atleast_3d( return transformed -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def take_along_axis( arr: torch.Tensor, indices: torch.Tensor, @@ -409,7 +409,7 @@ def expand( expand.support_native_out = False -@with_unsupported_dtypes({"2.1.0 and below": ("complex", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex", "float16")}, backend_version) def unique_consecutive( x: torch.Tensor, /, @@ -439,7 +439,7 @@ def column_stack( return torch.column_stack(arrays) -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, backend_version) def put_along_axis( arr: torch.Tensor, indices: torch.Tensor, diff --git a/ivy/functional/backends/torch/experimental/norms.py b/ivy/functional/backends/torch/experimental/norms.py index 88c86d28de10d..6861955d2f652 100644 --- a/ivy/functional/backends/torch/experimental/norms.py +++ b/ivy/functional/backends/torch/experimental/norms.py @@ -18,7 +18,7 @@ def l1_normalize( l1_normalize.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def l2_normalize( x: torch.Tensor, /, @@ -32,7 +32,7 @@ def l2_normalize( l2_normalize.support_native_out = True -@with_supported_dtypes({"2.1.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.1.1 and below": ("float",)}, backend_version) def local_response_norm( x: torch.Tensor, size, @@ -56,7 +56,7 @@ def local_response_norm( return ret -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def batch_norm( x: torch.Tensor, mean: torch.Tensor, @@ -102,7 +102,7 @@ def batch_norm( ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def instance_norm( x: torch.Tensor, mean: torch.Tensor, @@ -150,7 +150,7 @@ def instance_norm( ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def group_norm( x: torch.Tensor, num_groups: int = 1, @@ -175,7 +175,7 @@ def group_norm( return xnormalized -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def lp_normalize( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/experimental/random.py b/ivy/functional/backends/torch/experimental/random.py index 7dc5f4b295913..cfc13707667a7 100644 --- a/ivy/functional/backends/torch/experimental/random.py +++ b/ivy/functional/backends/torch/experimental/random.py @@ -13,7 +13,7 @@ # dirichlet -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def dirichlet( alpha: Union[torch.tensor, float, Sequence[float]], /, @@ -32,7 +32,7 @@ def dirichlet( ) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) def beta( alpha: Union[float, torch.Tensor], beta: Union[float, torch.Tensor], @@ -53,7 +53,7 @@ def beta( return ret -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) def gamma( alpha: Union[float, torch.Tensor], beta: Union[float, torch.Tensor], diff --git a/ivy/functional/backends/torch/experimental/sorting.py b/ivy/functional/backends/torch/experimental/sorting.py index b7af8ee599db1..10b9ce8defd1e 100644 --- a/ivy/functional/backends/torch/experimental/sorting.py +++ b/ivy/functional/backends/torch/experimental/sorting.py @@ -33,7 +33,7 @@ def lexsort( return torch.tensor([0]) _, result = torch.sort(keys[0], dim=axis, stable=True) # result = torch.argsort(keys[0], dim=axis, stable=True) - # only valid for torch > 2.1.0 + # only valid for torch > 2.1.1 if shape[0] == 1: return result for i in range(1, shape[0]): @@ -41,7 +41,7 @@ def lexsort( ind = key[result] _, temp = torch.sort(ind, dim=axis, stable=True) # temp = torch.argsort(ind, dim=axis, stable=True) - # only valid for torch > 2.1.0 + # only valid for torch > 2.1.1 result = result[temp] return result diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index a89bd786aeae2..3c89b0a90d592 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -12,7 +12,7 @@ @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "uint8", "int8", "int16", @@ -139,7 +139,7 @@ def histogram( histogram.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bool")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bool")}, backend_version) def median( input: torch.Tensor, /, @@ -364,7 +364,7 @@ def _compute_quantile_wrapper( ) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def quantile( a: torch.Tensor, q: Union[torch.Tensor, float], @@ -445,7 +445,7 @@ def _nanmedian(input, axis, keepdims): return ret -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def nanmedian( input: torch.Tensor, /, @@ -533,7 +533,7 @@ def igamma( igamma.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def cov( x1: torch.Tensor, x2: torch.Tensor = None, @@ -590,7 +590,7 @@ def cov( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "complex")}, + {"2.1.1 and below": ("float16", "complex")}, backend_version, ) def cummax( @@ -627,7 +627,7 @@ def cummax( @with_unsupported_dtypes( { - "2.1.0 and below": ("uint8", "float16", "bfloat16"), + "2.1.1 and below": ("uint8", "float16", "bfloat16"), "1.12.1 and above": ("uint8", "float16"), }, backend_version, diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index f667829c69534..beeab509335a7 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -53,7 +53,7 @@ def is_native_array(x, /, *, exclusive=False): return False -@with_unsupported_dtypes({"2.1.0 and below": ("complex", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex", "bfloat16")}, backend_version) def array_equal(x0: torch.Tensor, x1: torch.Tensor, /) -> bool: x0, x1 = ivy.promote_types_of_inputs(x0, x1) return torch.equal(x0, x1) @@ -352,7 +352,7 @@ def multiprocessing(context: Optional[str] = None): @with_unsupported_dtypes( { - "2.1.0 and below": ("bfloat16",), + "2.1.1 and below": ("bfloat16",), }, backend_version, ) @@ -404,7 +404,7 @@ def scatter_flat( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -511,7 +511,7 @@ def shape( return ivy.Shape(x.shape) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) def vmap( func: Callable, in_axes: Union[int, Sequence[int], Sequence[None]] = 0, @@ -530,7 +530,7 @@ def new_fun(*args): @with_unsupported_dtypes( - {"2.1.0 and below": ("bfloat16", "float16", "complex", "bool")}, backend_version + {"2.1.1 and below": ("bfloat16", "float16", "complex", "bool")}, backend_version ) def isin( elements: torch.tensor, diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index a7b71b221b907..bf5a8eb70a17b 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -13,7 +13,7 @@ @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex")}, + {"2.1.1 and below": ("float32", "float64", "complex")}, backend_version, ) def multi_head_attention( @@ -116,7 +116,7 @@ def multi_head_attention( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def linear( @@ -253,7 +253,7 @@ def _tranpose_padding( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -286,7 +286,7 @@ def conv1d( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv1d_v_1p9p0_and_above( @@ -324,7 +324,7 @@ def conv1d_v_1p9p0_and_above( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", "complex", @@ -376,7 +376,7 @@ def conv1d_transpose( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -409,7 +409,7 @@ def conv2d( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv2d_v_1p9p0_and_above( @@ -447,7 +447,7 @@ def conv2d_v_1p9p0_and_above( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", "complex", @@ -502,7 +502,7 @@ def conv2d_transpose( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", "complex", @@ -543,7 +543,7 @@ def depthwise_conv2d( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version ) # noinspection PyUnresolvedReferences def conv3d( @@ -575,7 +575,7 @@ def conv3d( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version ) def conv3d_v_1p9p0_and_above( x: torch.Tensor, @@ -611,7 +611,7 @@ def conv3d_v_1p9p0_and_above( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -662,7 +662,7 @@ def conv3d_transpose( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_dilated( @@ -711,7 +711,7 @@ def conv_general_dilated( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_dilated_v_1p9p0_and_above( @@ -765,7 +765,7 @@ def conv_general_dilated_v_1p9p0_and_above( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_transpose( diff --git a/ivy/functional/backends/torch/linear_algebra.py b/ivy/functional/backends/torch/linear_algebra.py index d01aad788a9a8..763b1f07a28dd 100644 --- a/ivy/functional/backends/torch/linear_algebra.py +++ b/ivy/functional/backends/torch/linear_algebra.py @@ -18,7 +18,7 @@ @with_unsupported_dtypes( - {"2.1.0 and below": ("bfloat16", "float16", "complex")}, + {"2.1.1 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def cholesky( @@ -42,7 +42,7 @@ def cholesky( cholesky.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) def cross( x1: torch.Tensor, x2: torch.Tensor, @@ -70,7 +70,7 @@ def cross( cross.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def det(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.linalg.det(x, out=out) @@ -90,7 +90,7 @@ def diagonal( return torch.diagonal(x, offset=offset, dim1=axis1, dim2=axis2) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def eigh( x: torch.Tensor, /, *, UPLO: str = "L", out: Optional[torch.Tensor] = None ) -> Tuple[torch.Tensor]: @@ -104,7 +104,7 @@ def eigh( eigh.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def eigvalsh( x: torch.Tensor, /, *, UPLO: str = "L", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -114,7 +114,7 @@ def eigvalsh( eigvalsh.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def inner( x1: torch.Tensor, x2: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -134,7 +134,7 @@ def inner( inner.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def inv( x: torch.Tensor, /, @@ -160,7 +160,7 @@ def inv( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "bool")}, backend_version + {"2.1.1 and below": ("float16", "bfloat16", "bool")}, backend_version ) def matmul( x1: torch.Tensor, @@ -193,7 +193,7 @@ def matmul( matmul.support_native_out = True -@with_supported_dtypes({"2.1.0 and below": ("float", "complex")}, backend_version) +@with_supported_dtypes({"2.1.1 and below": ("float", "complex")}, backend_version) def matrix_norm( x: torch.Tensor, /, @@ -209,7 +209,7 @@ def matrix_norm( matrix_norm.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def eig( x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> Tuple[torch.Tensor]: @@ -223,7 +223,7 @@ def eig( eig.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def matrix_power( x: torch.Tensor, n: int, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -233,7 +233,7 @@ def matrix_power( matrix_power.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def matrix_rank( x: torch.Tensor, /, @@ -281,7 +281,7 @@ def matrix_transpose( return torch.swapaxes(x, -1, -2) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def outer( x1: torch.Tensor, x2: torch.Tensor, @@ -296,7 +296,7 @@ def outer( outer.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def pinv( x: torch.Tensor, /, @@ -312,7 +312,7 @@ def pinv( pinv.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def tensorsolve( x1: torch.Tensor, x2: torch.Tensor, @@ -324,7 +324,7 @@ def tensorsolve( return torch.linalg.tensorsolve(x1, x2, dims=axes) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def qr( x: torch.Tensor, /, @@ -346,7 +346,7 @@ def qr( return ret -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def slogdet( x: torch.Tensor, /, @@ -361,7 +361,7 @@ def slogdet( slogdet.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def solve( x1: torch.Tensor, x2: torch.Tensor, @@ -397,7 +397,7 @@ def solve( return ret -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def svd( x: torch.Tensor, /, *, full_matrices: bool = True, compute_uv: bool = True ) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]: @@ -414,7 +414,7 @@ def svd( return results(D) -@with_unsupported_dtypes({"2.0.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def svdvals( x: torch.Tensor, /, @@ -430,7 +430,7 @@ def svdvals( # ToDo: re-add int32 support once # (https://github.com/pytorch/pytorch/issues/84530) is fixed -@with_supported_dtypes({"2.1.0 and below": ("float32",)}, backend_version) +@with_supported_dtypes({"2.1.1 and below": ("float32",)}, backend_version) def tensordot( x1: torch.Tensor, x2: torch.Tensor, @@ -449,7 +449,7 @@ def tensordot( return ret -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def trace( x: torch.Tensor, /, @@ -489,7 +489,7 @@ def vecdot( vecdot.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("integer",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("integer",)}, backend_version) def vector_norm( x: torch.Tensor, /, @@ -515,7 +515,7 @@ def vector_norm( # ----- # -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def diag( x: torch.Tensor, /, @@ -526,7 +526,7 @@ def diag( return torch.diag(x, diagonal=k) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) def vander( x: torch.tensor, /, @@ -552,7 +552,7 @@ def vander( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/torch/manipulation.py b/ivy/functional/backends/torch/manipulation.py index 741b1d81a5a02..4cfb62addec6e 100644 --- a/ivy/functional/backends/torch/manipulation.py +++ b/ivy/functional/backends/torch/manipulation.py @@ -239,7 +239,7 @@ def split( @with_unsupported_dtypes( - {"2.1.0 and below": ("int8", "int16", "uint8")}, backend_version + {"2.1.1 and below": ("int8", "int16", "uint8")}, backend_version ) def repeat( x: torch.Tensor, @@ -308,7 +308,7 @@ def swapaxes( @with_unsupported_dtypes( - {"2.1.0 and below": ("bool", "float16", "complex")}, backend_version + {"2.1.1 and below": ("bool", "float16", "complex")}, backend_version ) def clip( x: torch.Tensor, diff --git a/ivy/functional/backends/torch/norms.py b/ivy/functional/backends/torch/norms.py index 704a2a4d506c0..6f24af1ad998f 100644 --- a/ivy/functional/backends/torch/norms.py +++ b/ivy/functional/backends/torch/norms.py @@ -5,7 +5,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) def layer_norm( x: torch.Tensor, normalized_idxs: List[int], diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index 2fac63ffdd2af..df83aee7eb286 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -62,7 +62,7 @@ def random_normal( random_normal.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/torch/searching.py b/ivy/functional/backends/torch/searching.py index 05951657703f7..b3d436fff5618 100644 --- a/ivy/functional/backends/torch/searching.py +++ b/ivy/functional/backends/torch/searching.py @@ -13,7 +13,7 @@ # ------------------ # -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def argmax( x: torch.Tensor, /, @@ -41,7 +41,7 @@ def argmax( return ret -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def argmin( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/set.py b/ivy/functional/backends/torch/set.py index 4ddad1d6bb073..6f232ee2864a3 100644 --- a/ivy/functional/backends/torch/set.py +++ b/ivy/functional/backends/torch/set.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( { - "2.1.0 and below": ("complex", "float16"), + "2.1.1 and below": ("complex", "float16"), }, backend_version, ) @@ -84,7 +84,7 @@ def unique_all( @with_unsupported_dtypes( { - "2.1.0 and below": ("float16",), + "2.1.1 and below": ("float16",), }, backend_version, ) @@ -98,7 +98,7 @@ def unique_counts(x: torch.Tensor, /) -> Tuple[torch.Tensor, torch.Tensor]: @with_unsupported_dtypes( { - "2.1.0 and below": ("float16",), + "2.1.1 and below": ("float16",), }, backend_version, ) @@ -124,7 +124,7 @@ def unique_inverse( @with_unsupported_dtypes( { - "2.1.0 and below": ("float16", "complex"), + "2.1.1 and below": ("float16", "complex"), }, backend_version, ) diff --git a/ivy/functional/backends/torch/sorting.py b/ivy/functional/backends/torch/sorting.py index fa9e1c85254ca..9e474c01d1816 100644 --- a/ivy/functional/backends/torch/sorting.py +++ b/ivy/functional/backends/torch/sorting.py @@ -8,7 +8,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def argsort( x: torch.Tensor, /, @@ -29,7 +29,7 @@ def argsort( argsort.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def sort( x: torch.Tensor, /, @@ -51,7 +51,7 @@ def sort( # msort -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def msort( a: Union[torch.Tensor, list, tuple], /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -61,7 +61,7 @@ def msort( msort.support_native_out = True -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def searchsorted( x: torch.Tensor, v: torch.Tensor, diff --git a/ivy/functional/backends/torch/statistical.py b/ivy/functional/backends/torch/statistical.py index dc28d9a86e2e6..a7651c255b030 100644 --- a/ivy/functional/backends/torch/statistical.py +++ b/ivy/functional/backends/torch/statistical.py @@ -14,7 +14,7 @@ # -------------------# -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) def min( x: torch.Tensor, /, @@ -66,7 +66,7 @@ def max( max.support_native_out = True -@with_supported_dtypes({"2.1.0 and below": ("float", "complex")}, backend_version) +@with_supported_dtypes({"2.1.1 and below": ("float", "complex")}, backend_version) def mean( x: torch.Tensor, /, @@ -101,7 +101,7 @@ def _infer_dtype(dtype: torch.dtype) -> torch.dtype: # the function to break the upcasting rule defined in the Array API Standard @with_unsupported_dtypes( { - "2.1.0 and below": ("uint8", "float16", "bfloat16"), + "2.1.1 and below": ("uint8", "float16", "bfloat16"), }, backend_version, ) @@ -129,7 +129,7 @@ def prod( @with_unsupported_dtypes( - {"2.1.0 and below": ("int8", "int16", "int32", "int64", "float16")}, + {"2.1.1 and below": ("int8", "int16", "int32", "int64", "float16")}, backend_version, ) def std( @@ -166,7 +166,7 @@ def std( # Function does support uint8, but allowing support for unsigned will cause # the function to break the upcasting rule defined in the Array API Standard -@with_unsupported_dtypes({"2.1.0 and below": ("uint8",)}, backend_version) +@with_unsupported_dtypes({"2.1.1 and below": ("uint8",)}, backend_version) def sum( x: torch.Tensor, /, @@ -228,7 +228,7 @@ def var( # TODO: bfloat16 support is added in PyTorch 1.12.1 @with_unsupported_dtypes( { - "2.1.0 and below": ("uint8", "float16", "bfloat16"), + "2.1.1 and below": ("uint8", "float16", "bfloat16"), }, backend_version, ) @@ -319,7 +319,7 @@ def cumsum( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16",)}, + {"2.1.1 and below": ("float16",)}, backend_version, ) def einsum( diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 923e5029fa248..9ac07666a8ed0 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -2,7 +2,7 @@ versions = { - "torch": "2.1.0", + "torch": "2.1.1", "tensorflow": "2.14.0", "numpy": "1.25.2", "jax": "0.4.14", diff --git a/ivy/functional/frontends/torch/blas_and_lapack_ops.py b/ivy/functional/frontends/torch/blas_and_lapack_ops.py index d25125a87de83..9cc767415b192 100644 --- a/ivy/functional/frontends/torch/blas_and_lapack_ops.py +++ b/ivy/functional/frontends/torch/blas_and_lapack_ops.py @@ -201,7 +201,7 @@ def svd(input, some=True, compute_uv=True, *, out=None): return ret -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def trapezoid(y, x=None, *, dx=None, dim=-1): if x is not None: diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 1f9241ab37948..80d55d6957f39 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -98,14 +98,14 @@ def fmin(input, other, *, out=None): ) -@with_unsupported_dtypes({"2.1.0 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def greater(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.greater(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def greater_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -142,7 +142,7 @@ def isfinite(input): return ivy.isfinite(input) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def isin(elements, test_elements, *, assume_unique=False, invert=False): input_elements_copy = ivy.reshape(ivy.to_ivy(elements), (-1,)) @@ -210,14 +210,14 @@ def isposinf(input, *, out=None): return ivy.logical_and(is_inf, pos_sign_bit, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def isreal(input): return ivy.isreal(input) @with_unsupported_dtypes( - {"2.1.0 and below": ("bfloat16", "float16", "bool", "complex")}, "torch" + {"2.1.1 and below": ("bfloat16", "float16", "bool", "complex")}, "torch" ) @to_ivy_arrays_and_back def kthvalue(input, k, dim=-1, keepdim=False, *, out=None): @@ -241,14 +241,14 @@ def kthvalue(input, k, dim=-1, keepdim=False, *, out=None): return ret -@with_unsupported_dtypes({"2.1.0 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def less(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.less(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def less_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -272,7 +272,7 @@ def msort(input, *, out=None): return ivy.sort(input, axis=0, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def not_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -287,7 +287,7 @@ def sort(input, *, dim=-1, descending=False, stable=False, out=None): return namedtuple("sort", ["values", "indices"])(values, indices) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def topk(input, k, dim=None, largest=True, sorted=True, *, out=None): if dim is None: diff --git a/ivy/functional/frontends/torch/creation_ops.py b/ivy/functional/frontends/torch/creation_ops.py index 30132ec31bad8..866d4a9cb0459 100644 --- a/ivy/functional/frontends/torch/creation_ops.py +++ b/ivy/functional/frontends/torch/creation_ops.py @@ -12,7 +12,7 @@ @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def arange( start=0, end=None, @@ -74,7 +74,7 @@ def asarray( return ivy.asarray(obj, copy=copy, dtype=dtype, device=device) -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def complex( real, @@ -208,7 +208,7 @@ def heaviside(input, values, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def linspace( start, end, @@ -225,7 +225,7 @@ def linspace( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def logspace( start, end, @@ -273,7 +273,7 @@ def ones_like_v_0p4p0_and_above( return ret -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def polar( abs, @@ -285,7 +285,7 @@ def polar( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def range( *args, dtype=None, diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py index 1682e5e4f1961..e904fda02498b 100644 --- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py +++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py @@ -74,7 +74,7 @@ def conj(input): # diagonal_scatter @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "float16", ) @@ -215,7 +215,7 @@ def index_copy(input, dim, index, source, *, out=None): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "uint16", "uint32", "uint64", diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index 57cbfaae05107..7f5e9d87b4de6 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -9,7 +9,7 @@ @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def cholesky(input, *, upper=False, out=None): return ivy.cholesky(input, upper=upper, out=out) @@ -31,14 +31,14 @@ def cholesky_ex(input, *, upper=False, check_errors=False, out=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64", "complex")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64", "complex")}, "torch") def cond(input, p=None, *, out=None): return ivy.cond(input, p=p, out=out) @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def cross(input, other, *, dim=None, out=None): return torch_frontend.miscellaneous_ops.cross(input, other, dim=dim, out=out) @@ -46,7 +46,7 @@ def cross(input, other, *, dim=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def det(A, *, out=None): return ivy.det(A, out=out) @@ -63,13 +63,13 @@ def divide(input, other, *, rounding_mode=None, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") def eig(input, *, out=None): return ivy.eig(input, out=out) @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64", "complex128")}, + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64", "complex128")}, "torch", ) def eigh(A, UPLO="L", *, out=None): @@ -78,7 +78,7 @@ def eigh(A, UPLO="L", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def eigvals(input, *, out=None): ret = ivy.eigvals(input) @@ -89,7 +89,7 @@ def eigvals(input, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def eigvalsh(input, UPLO="L", *, out=None): ret = ivy.eigvalsh(input, UPLO=UPLO, out=out) @@ -102,7 +102,7 @@ def eigvalsh(input, UPLO="L", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def inv(A, *, out=None): return ivy.inv(A, out=out) @@ -110,7 +110,7 @@ def inv(A, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def inv_ex(A, *, check_errors=False, out=None): if ivy.any(ivy.det(A) == 0): @@ -129,7 +129,7 @@ def inv_ex(A, *, check_errors=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def lu_factor(A, *, pivot=True, out=None): return ivy.lu_factor(A, pivot=pivot, out=out) @@ -137,21 +137,21 @@ def lu_factor(A, *, pivot=True, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matmul(input, other, *, out=None): return ivy.matmul(input, other, out=out) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64", "complex")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64", "complex")}, "torch") def matrix_exp(A): return ivy.matrix_exp(A) @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_norm(input, ord="fro", dim=(-2, -1), keepdim=False, *, dtype=None, out=None): if "complex" in ivy.as_ivy_dtype(input.dtype): @@ -163,7 +163,7 @@ def matrix_norm(input, ord="fro", dim=(-2, -1), keepdim=False, *, dtype=None, ou @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_power(A, n, *, out=None): return ivy.matrix_power(A, n, out=out) @@ -171,7 +171,7 @@ def matrix_power(A, n, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_rank(A, *, atol=None, rtol=None, hermitian=False, out=None): return ivy.matrix_rank(A, atol=atol, rtol=rtol, hermitian=hermitian, out=out) @@ -179,7 +179,7 @@ def matrix_rank(A, *, atol=None, rtol=None, hermitian=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def multi_dot(tensors, *, out=None): return ivy.multi_dot(tensors, out=out) @@ -187,7 +187,7 @@ def multi_dot(tensors, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex64", "complex128")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex64", "complex128")}, "torch" ) def norm(input, ord=None, dim=None, keepdim=False, *, dtype=None, out=None): if dim is None and (ord is not None): @@ -207,7 +207,7 @@ def norm(input, ord=None, dim=None, keepdim=False, *, dtype=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def pinv(input, *, atol=None, rtol=None, hermitian=False, out=None): # TODO: add handling for hermitian @@ -226,7 +226,7 @@ def pinv(input, *, atol=None, rtol=None, hermitian=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def qr(A, mode="reduced", *, out=None): if mode == "reduced": @@ -244,7 +244,7 @@ def qr(A, mode="reduced", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def slogdet(A, *, out=None): sign, logabsdet = ivy.slogdet(A) @@ -260,7 +260,7 @@ def slogdet(A, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def solve(A, B, *, left=True, out=None): if left: @@ -274,7 +274,7 @@ def solve(A, B, *, left=True, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def solve_ex(A, B, *, left=True, check_errors=False, out=None): try: @@ -302,7 +302,7 @@ def solve_ex(A, B, *, left=True, check_errors=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def svd(A, /, *, full_matrices=True, driver=None, out=None): # TODO: add handling for driver and out @@ -311,7 +311,7 @@ def svd(A, /, *, full_matrices=True, driver=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def svdvals(A, *, driver=None, out=None): if driver in ["gesvd", "gesvdj", "gesvda", None]: @@ -322,7 +322,7 @@ def svdvals(A, *, driver=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def tensorinv(input, ind=2, *, out=None): not_invertible = "Reshaped tensor is not invertible" @@ -349,14 +349,14 @@ def tensorinv(input, ind=2, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def tensorsolve(A, B, dims=None, *, out=None): return ivy.tensorsolve(A, B, axes=dims, out=out) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("integer", "float", "complex")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("integer", "float", "complex")}, "torch") def vander(x, N=None): if len(x.shape) < 1: raise RuntimeError("Input dim must be greater than or equal to 1.") @@ -389,7 +389,7 @@ def vander(x, N=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def vecdot(x, y, *, dim=-1, out=None): if "complex" in ivy.as_ivy_dtype(x.dtype): @@ -399,7 +399,7 @@ def vecdot(x, y, *, dim=-1, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def vector_norm(input, ord=2, dim=None, keepdim=False, *, dtype=None, out=None): return ivy.vector_norm( diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 7e1f401b5ed59..23eeef185e73e 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -74,7 +74,7 @@ def broadcast_shapes(*shapes): return ivy.broadcast_shapes(*shapes) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def broadcast_to(tensor, shape): return ivy.broadcast_to(tensor, shape) @@ -113,7 +113,7 @@ def cov(input, /, *, correction=1, fweights=None, aweights=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def cross(input, other, dim=None, *, out=None): if dim is None: dim = -1 @@ -124,7 +124,7 @@ def cross(input, other, dim=None, *, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "uint16", "uint32", "uint64", @@ -152,7 +152,7 @@ def cumprod(input, dim, *, dtype=None, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.0 and below": ("uint8", "bfloat16", "float16"), "1.12.1": ()}, + {"2.1.1 and below": ("uint8", "bfloat16", "float16"), "1.12.1": ()}, "torch", ) def cumsum(input, dim, *, dtype=None, out=None): @@ -167,7 +167,7 @@ def diag(input, diagonal=0, *, out=None): @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) @to_ivy_arrays_and_back def diagflat(x, offset=0, name=None): @@ -175,7 +175,7 @@ def diagflat(x, offset=0, name=None): return arr -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def diagonal(input, offset=0, dim1=0, dim2=1): return ivy.diagonal(input, offset=offset, axis1=dim1, axis2=dim2) @@ -183,14 +183,14 @@ def diagonal(input, offset=0, dim1=0, dim2=1): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.0 and below": ("int8", "float16", "bfloat16", "bool")}, "torch" + {"2.1.1 and below": ("int8", "float16", "bfloat16", "bool")}, "torch" ) def diff(input, n=1, dim=-1, prepend=None, append=None): return ivy.diff(input, n=n, axis=dim, prepend=prepend, append=append, out=None) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def einsum(equation, *operands): if len(operands) == 1 and isinstance(operands[0], (list, tuple)): operands = operands[0] @@ -242,14 +242,14 @@ def kron(input, other, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("int8",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("int8",)}, "torch") def lcm(input, other, *, out=None): return ivy.lcm(input, other, out=out) @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", "integer", @@ -287,7 +287,7 @@ def ravel(input): return ivy.reshape(input, (-1,)) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def renorm(input, p, dim, maxnorm, *, out=None): # Torch hardcodes this magic number @@ -328,7 +328,7 @@ def renorm(input, p, dim, maxnorm, *, out=None): @with_supported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "int32", "int64", ) @@ -458,7 +458,7 @@ def searchsorted( return ret -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def tensordot(a, b, dims=2, out=None): a, b = promote_types_of_torch_inputs(a, b) @@ -466,7 +466,7 @@ def tensordot(a, b, dims=2, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def trace(input): if "int" in input.dtype: input = input.astype("int64") @@ -480,7 +480,7 @@ def tril(input, diagonal=0, *, out=None): return ivy.tril(input, k=diagonal, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("int8", "uint8", "int16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("int8", "uint8", "int16")}, "torch") @to_ivy_arrays_and_back def tril_indices(row, col, offset=0, *, dtype=ivy.int64, device="cpu", layout=None): sample_matrix = ivy.tril(ivy.ones((row, col), device=device), k=offset) @@ -511,7 +511,7 @@ def vander(x, N=None, increasing=False): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") def view_as_complex(input): if ivy.shape(input)[-1] != 2: raise ivy.exceptions.IvyError("The last dimension must have a size of 2") @@ -529,7 +529,7 @@ def view_as_complex(input): @with_supported_dtypes( - {"2.1.0 and below": ("complex64", "complex128")}, + {"2.1.1 and below": ("complex64", "complex128")}, "torch", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index a76123d964ef1..6edede79e7009 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -154,7 +154,7 @@ def _valid_shapes(input, weight, bias, stride, padding, groups, transpose=False) # ------------ # -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -168,7 +168,7 @@ def conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -182,7 +182,7 @@ def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -196,7 +196,7 @@ def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose1d( input, @@ -220,7 +220,7 @@ def conv_transpose1d( ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose2d( input, @@ -246,7 +246,7 @@ def conv_transpose2d( ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose3d( input, diff --git a/ivy/functional/frontends/torch/nn/functional/distance_functions.py b/ivy/functional/frontends/torch/nn/functional/distance_functions.py index 1059e6e4bb63a..ba8b6f0930cc1 100644 --- a/ivy/functional/frontends/torch/nn/functional/distance_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/distance_functions.py @@ -4,7 +4,7 @@ from ivy.func_wrapper import with_unsupported_dtypes -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def cosine_similarity(x1, x2, *, dim=1, eps=1e-08): x1, x2 = torch_frontend.promote_types_of_torch_inputs(x1, x2) @@ -28,7 +28,7 @@ def cosine_similarity(x1, x2, *, dim=1, eps=1e-08): return cosine -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): x1, x2 = torch_frontend.promote_types_of_torch_inputs(x1, x2) @@ -42,7 +42,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): return ivy.vector_norm(x1 - x2 + eps, ord=p, axis=output_dim - 1, keepdims=keepdim) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def pdist(input, p=2): x = ivy.array([ diff --git a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py index 5faa28c1e4a7c..ac6fc71dbf4ab 100644 --- a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py @@ -7,7 +7,7 @@ # ToDo: this function will be simplified once ivy.alpha_dropout is implemented @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def alpha_dropout(input, p=0.5, training=False, inplace=False): if p == 0.0 or not training or input.shape == () or input.shape == (0,): @@ -28,13 +28,13 @@ def alpha_dropout(input, p=0.5, training=False, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def dropout(input, p=0.5, training=True, inplace=False): return ivy.dropout(input, p, training=training) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def dropout1d(input, p=0.5, training=True, inplace=False): if inplace: return ivy.dropout1d(input, p, training=training, data_format="NCW", out=input) @@ -42,7 +42,7 @@ def dropout1d(input, p=0.5, training=True, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def dropout2d(input, p=0.5, training=True, inplace=False): if input.ndim < 2: raise ValueError("Feature dropout requires at least 2 dimensions in the input") @@ -55,7 +55,7 @@ def dropout2d(input, p=0.5, training=True, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def dropout3d(input, p=0.5, training=True, inplace=False): if inplace: return ivy.dropout3d( diff --git a/ivy/functional/frontends/torch/nn/functional/layer_functions.py b/ivy/functional/frontends/torch/nn/functional/layer_functions.py index 12f36e34df414..0f3b1cf74a82b 100644 --- a/ivy/functional/frontends/torch/nn/functional/layer_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/layer_functions.py @@ -309,7 +309,7 @@ def _transform_weights_no_bias(layer_weights, layer_index): @with_supported_device_and_dtypes( - {"2.1.0 and below": {"cpu": ("float32", "float64")}}, + {"2.1.1 and below": {"cpu": ("float32", "float64")}}, "torch", ) @to_ivy_arrays_and_back @@ -321,7 +321,7 @@ def lstm(*args, **kwargs): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") def multi_head_attention_forward( query, key, diff --git a/ivy/functional/frontends/torch/nn/functional/linear_functions.py b/ivy/functional/frontends/torch/nn/functional/linear_functions.py index 040cb9652212d..e4bafdaed2e47 100644 --- a/ivy/functional/frontends/torch/nn/functional/linear_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/linear_functions.py @@ -4,7 +4,7 @@ from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def linear(input, weight, bias=None): return ivy.linear(input, weight, bias=bias) diff --git a/ivy/functional/frontends/torch/nn/functional/loss_functions.py b/ivy/functional/frontends/torch/nn/functional/loss_functions.py index 06e8709bc5ab6..2ba4f45d333fa 100644 --- a/ivy/functional/frontends/torch/nn/functional/loss_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/loss_functions.py @@ -72,7 +72,7 @@ def _get_reduction_string(size_average, reduce): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def binary_cross_entropy( input, target, weight=None, size_average=None, reduce=None, reduction="mean" ): @@ -113,7 +113,7 @@ def binary_cross_entropy_with_logits( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def cosine_embedding_loss( input1, input2, target, margin=0.0, size_average=None, reduce=None, reduction="mean" ): @@ -212,7 +212,7 @@ def cross_entropy( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("bool", "integer")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bool", "integer")}, "torch") def gaussian_nll_loss(input, target, var, full=False, eps=1e-6, reduction="mean"): input, target = torch_frontend.promote_types_of_torch_inputs(input, target) target, var = torch_frontend.promote_types_of_torch_inputs(target, var) @@ -244,7 +244,7 @@ def gaussian_nll_loss(input, target, var, full=False, eps=1e-6, reduction="mean" @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def hinge_embedding_loss( input, @@ -279,7 +279,7 @@ def huber_loss( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") def kl_div( input, target, size_average=None, reduce=None, reduction="mean", log_target=False ): @@ -295,7 +295,7 @@ def kl_div( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("float", "complex")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float", "complex")}, "torch") def l1_loss( input, target, @@ -310,7 +310,7 @@ def l1_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def margin_ranking_loss( input1, input2, @@ -329,7 +329,7 @@ def margin_ranking_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def mse_loss(input, target, size_average=None, reduce=None, reduction="mean"): reduction = _get_reduction(reduction, size_average, reduce) result = ivy.square(input - target) @@ -338,7 +338,7 @@ def mse_loss(input, target, size_average=None, reduce=None, reduction="mean"): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def multilabel_margin_loss( input, target, size_average=None, reduce=None, reduction="mean" ): @@ -358,7 +358,7 @@ def multilabel_margin_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def multilabel_soft_margin_loss( input, target, @@ -388,7 +388,7 @@ def multilabel_soft_margin_loss( @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "int8", "int16", "int32")}, "torch" + {"2.1.1 and below": ("float16", "int8", "int16", "int32")}, "torch" ) def nll_loss( input, @@ -434,7 +434,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def poisson_nll_loss( input, target, @@ -461,7 +461,7 @@ def poisson_nll_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def smooth_l1_loss( input, target, @@ -474,7 +474,7 @@ def smooth_l1_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def soft_margin_loss( input, target, @@ -486,7 +486,7 @@ def soft_margin_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def triplet_margin_loss( anchor, positive, @@ -541,7 +541,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def triplet_margin_with_distance_loss( anchor, positive, diff --git a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py index 42159e0197ec0..2c606b3eeee7f 100644 --- a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py @@ -7,7 +7,7 @@ @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "complex", "float16", ) @@ -38,7 +38,7 @@ def elu_(input, alpha=1.0): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -63,7 +63,7 @@ def glu(input, dim=-1): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def gumbel_softmax(logits, tau=1, hard=False, eps=1e-10, dim=-1): gumbels = -ivy.empty_like(logits).exponential().log() gumbels = (logits + gumbels) / tau @@ -100,30 +100,30 @@ def hardswish(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def hardtanh(input, min_val=-1.0, max_val=1.0, inplace=False): less = ivy.where(ivy.less(input, min_val), min_val, input) return ivy.where(ivy.greater(input, max_val), max_val, less).astype(input.dtype) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def hardtanh_(input, min_val=-1.0, max_val=1.0): return hardtanh(input, min_val=min_val, max_val=max_val, inplace=True) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def leaky_relu(input, negative_slope=0.01, inplace=False): return ivy.leaky_relu(input, alpha=negative_slope) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def leaky_relu_(input, negative_slope=0.01): return leaky_relu(input, negative_slope=negative_slope, inplace=True) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("float",)}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float",)}, "torch") def local_response_norm(input, size, alpha=0.0001, beta=0.75, k=1.0): non_batched = input.ndim == 3 if non_batched: @@ -137,7 +137,7 @@ def local_response_norm(input, size, alpha=0.0001, beta=0.75, k=1.0): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def log_softmax(input, dim=None, _stacklevel=3, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -149,7 +149,7 @@ def log_softmax(input, dim=None, _stacklevel=3, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -188,7 +188,7 @@ def relu(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") def relu6(input, inplace=False): return ivy.relu6(input) @@ -199,7 +199,7 @@ def relu_(input): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def rrelu(input, lower=1.0 / 8, upper=1.0 / 3, training=False, inplace=False): if training: # alpha = ivy.random_uniform(low=lower, high=upper) @@ -212,13 +212,13 @@ def rrelu(input, lower=1.0 / 8, upper=1.0 / 3, training=False, inplace=False): ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def rrelu_(input, lower=1.0 / 8, upper=1.0 / 3, training=False): return rrelu(input, lower=lower, upper=upper, training=training, inplace=True) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") def scaled_dot_product_attention( query, key, value, attn_mask=None, dropout_p=0.0, is_causal=False, scale=None ): @@ -239,19 +239,19 @@ def selu(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def sigmoid(input): return ivy.sigmoid(input) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def silu(input, inplace=False): return ivy.multiply(input, ivy.sigmoid(input)) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def softmax(input, dim=None, _stacklevel=3, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -259,7 +259,7 @@ def softmax(input, dim=None, _stacklevel=3, dtype=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def softmin(input, dim=None, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -269,7 +269,7 @@ def softmin(input, dim=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -293,23 +293,23 @@ def softsign(input): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def tanh(input): return ivy.tanh(input) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def tanhshrink(input): return ivy.subtract(input, ivy.tanh(input)) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def threshold(input, threshold, value, inplace=False): return ivy.where(ivy.greater(input, threshold), input, value) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def threshold_(input, threshold, value): return threshold(input, threshold, value, inplace=True) diff --git a/ivy/functional/frontends/torch/nn/functional/norms.py b/ivy/functional/frontends/torch/nn/functional/norms.py index e833142814cbe..bc4bbfabf1083 100644 --- a/ivy/functional/frontends/torch/nn/functional/norms.py +++ b/ivy/functional/frontends/torch/nn/functional/norms.py @@ -5,7 +5,7 @@ @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "float16", ) @@ -42,7 +42,7 @@ def batch_norm( @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -57,7 +57,7 @@ def group_norm(input, num_groups, weight=None, bias=None, eps=1e-05): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "float16", ) @@ -92,7 +92,7 @@ def instance_norm( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-05): shape = ivy.shape(input) if isinstance(normalized_shape, int) and normalized_shape == shape[-1]: diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 827b5e8815851..5b5becf55fd29 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "float16", ) @@ -25,7 +25,7 @@ def adaptive_avg_pool1d(input, output_size): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -39,7 +39,7 @@ def adaptive_avg_pool2d(input, output_size): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "float16", ) @@ -57,7 +57,7 @@ def adaptive_max_pool2d( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16",)}, + {"2.1.1 and below": ("float16",)}, "torch", ) @to_ivy_arrays_and_back @@ -83,7 +83,7 @@ def avg_pool1d( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16",)}, + {"2.1.1 and below": ("float16",)}, "torch", ) @to_ivy_arrays_and_back @@ -111,7 +111,7 @@ def avg_pool2d( @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16")}, + {"2.1.1 and below": ("float16", "bfloat16")}, "torch", ) @to_ivy_arrays_and_back @@ -140,7 +140,7 @@ def avg_pool3d( @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -172,7 +172,7 @@ def lp_pool1d(input, norm_type, kernel_size, stride=None, ceil_mode=False): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -201,7 +201,7 @@ def lp_pool2d(input, norm_type, kernel_size, stride=None, ceil_mode=False): return ivy.pow(ivy.multiply(out, kernel_mul), p).astype(input.dtype) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool1d( input, @@ -227,7 +227,7 @@ def max_pool1d( ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool2d( input, @@ -253,7 +253,7 @@ def max_pool2d( ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool3d( input, diff --git a/ivy/functional/frontends/torch/nn/functional/sparse_functions.py b/ivy/functional/frontends/torch/nn/functional/sparse_functions.py index b50c5b16b5fba..1be9407cd50f9 100644 --- a/ivy/functional/frontends/torch/nn/functional/sparse_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/sparse_functions.py @@ -33,7 +33,7 @@ def embedding( return ret -@with_supported_dtypes({"2.1.0 and below": ("int64",)}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("int64",)}, "torch") @to_ivy_arrays_and_back def one_hot(tensor, num_classes=-1): return ivy.astype(ivy.one_hot(tensor, num_classes), tensor.dtype) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index 8d166210c3176..8b661a78b3fbc 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -28,7 +28,7 @@ def _handle_padding_shape(padding, n, mode): # ------------ # -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def affine_grid(theta, size, align_corners=False): if len(size) == 4: @@ -91,7 +91,7 @@ def cubic_conv2(A, x): return ((A * x - 5 * A) * x + 8 * A) * x - 4 * A -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def grid_sample( input, grid, mode="bilinear", padding_mode="zeros", align_corners=False @@ -346,7 +346,7 @@ def grid_sample_padding(grid, padding_mode, align_corners, borders=None): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "float16", ) @@ -503,7 +503,7 @@ def reflect(x, low2, high2): return x -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample( input, @@ -521,7 +521,7 @@ def upsample( ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample_bilinear(input, size=None, scale_factor=None): return interpolate( @@ -529,7 +529,7 @@ def upsample_bilinear(input, size=None, scale_factor=None): ) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample_nearest(input, size=None, scale_factor=None): return interpolate(input, size=size, scale_factor=scale_factor, mode="nearest") diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py index 999c815825345..ed698fccf6bd9 100644 --- a/ivy/functional/frontends/torch/pointwise_ops.py +++ b/ivy/functional/frontends/torch/pointwise_ops.py @@ -13,13 +13,13 @@ def abs(input, *, out=None): return ivy.abs(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def acos(input, *, out=None): return ivy.acos(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def acosh(input, *, out=None): return ivy.acosh(input, out=out) @@ -35,13 +35,13 @@ def add(input, other, *, alpha=1, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def addcdiv(input, tensor1, tensor2, *, value=1, out=None): return ivy.add(input, ivy.multiply(value, ivy.divide(tensor1, tensor2)), out=out) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def addcmul(input, tensor1, tensor2, *, value=1, out=None): return ivy.add(input, ivy.multiply(value, ivy.multiply(tensor1, tensor2)), out=out) @@ -51,32 +51,32 @@ def angle(input, *, out=None): return ivy.angle(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def asin(input, *, out=None): return ivy.asin(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def asinh(input, *, out=None): return ivy.asinh(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def atan(input, *, out=None): return ivy.atan(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def atan2(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.atan2(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def atanh(input, *, out=None): return ivy.atanh(input, out=out) @@ -117,13 +117,13 @@ def bitwise_xor(input, other, *, out=None): return ivy.bitwise_xor(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def ceil(input, *, out=None): return ivy.ceil(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def clamp(input, min=None, max=None, *, out=None): ivy.utils.assertions.check_all_or_any_fn( @@ -152,7 +152,7 @@ def copysign(input, other, *, out=None): return ivy.copysign(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def cos(input, *, out=None): return ivy.cos(input, out=out) @@ -181,31 +181,31 @@ def div(input, other, *, rounding_mode=None, out=None): return ivy.divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def erf(input, *, out=None): return ivy.erf(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def erfc(input, *, out=None): return 1.0 - ivy.erf(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def exp(input, *, out=None): return ivy.exp(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def exp2(input, out=None): return ivy.exp2(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def expm1(input, out=None): return ivy.expm1(input, out=out) @@ -223,7 +223,7 @@ def float_power(input, exponent, *, out=None): return ivy.float_power(input, exponent, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def floor(input, *, out=None): return ivy.floor(input, out=out) @@ -234,7 +234,7 @@ def floor_divide(input, other, *, out=None): return ivy.floor_divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def fmod(x1, x2, out=None): return ivy.fmod(x1, x2, out=out) @@ -245,31 +245,31 @@ def frac(input, *, out=None): return input - ivy.sign(input) * ivy.floor(ivy.abs(input)) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def frexp(input, *, out=None): return ivy.frexp(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def gradient(input, *, spacing=1, dim=None, edge_order=1): return ivy.gradient(input, spacing=spacing, edge_order=edge_order, axis=dim) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def hypot(input, other, *, out=None): return ivy.hypot(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def i0(input, *, out=None): return ivy.i0(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def igamma(input, other, *, out=None): return ivy.igamma(input, x=other, out=out) @@ -280,7 +280,7 @@ def imag(input): return ivy.imag(input) -@with_supported_dtypes({"2.1.0 and below": ("float16", "float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float16", "float32", "float64")}, "torch") @to_ivy_arrays_and_back def ldexp(input, other, *, out=None): value = ivy.pow(2, other, out=out) @@ -288,49 +288,49 @@ def ldexp(input, other, *, out=None): return value -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def lerp(input, end, weight, *, out=None): return ivy.lerp(input, end, weight, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def lgamma(input, *, out=None): return ivy.lgamma(input, out=out) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def log(input, *, out=None): return ivy.log(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log10(input, *, out=None): return ivy.log10(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log1p(input, *, out=None): return ivy.log1p(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log2(input, *, out=None): return ivy.log2(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def logaddexp(x1, x2, out=None): return ivy.logaddexp(x1, x2, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def logaddexp2(x1, x2, out=None): return ivy.logaddexp2(x1, x2, out=out) @@ -359,13 +359,13 @@ def logical_xor(input, other, *, out=None): return ivy.logical_xor(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def logit(input, eps=None, *, out=None): return ivy.logit(input, eps=eps, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def masked_fill(input, mask, value): return ivy.where(mask, value, input, out=input) @@ -378,7 +378,7 @@ def mul(input, other, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def mvlgamma(input, p, *, out=None): ivy.assertions.check_greater( p, 1, allow_equal=True, message="p has to be greater than or equal to 1" @@ -393,19 +393,19 @@ def mvlgamma(input, p, *, out=None): ) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def nan_to_num(input, nan=0.0, posinf=None, neginf=None, *, out=None): return ivy.nan_to_num(input, nan=nan, posinf=posinf, neginf=neginf, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bool",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bool",)}, "torch") @to_ivy_arrays_and_back def negative(input, *, out=None): return ivy.negative(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") @to_ivy_arrays_and_back def nextafter(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -417,7 +417,7 @@ def positive(input, *, out=None): return ivy.positive(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bool",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bool",)}, "torch") @to_ivy_arrays_and_back def pow(input, exponent, *, out=None): if not ivy.is_array(exponent): @@ -460,7 +460,7 @@ def remainder(input, other, *, out=None): return ivy.remainder(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def round(input, *, decimals=0, out=None): m = ivy.full(input.shape, 10.0**decimals) @@ -469,7 +469,7 @@ def round(input, *, decimals=0, out=None): return ivy.divide(rounded, m, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def rsqrt(input, *, out=None): return ivy.reciprocal(ivy.sqrt(input), out=out) @@ -488,43 +488,43 @@ def sgn(input, *, out=None): return ivy.sign(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sigmoid(input, *, out=None): return ivy.sigmoid(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def sign(input, *, out=None): return ivy.sign(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def signbit(input, *, out=None): return ivy.signbit(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sin(input, *, out=None): return ivy.sin(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sinc(input, *, out=None): return ivy.sinc(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sinh(input, *, out=None): return ivy.sinh(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sqrt(input, *, out=None): return ivy.sqrt(input, out=out) @@ -541,13 +541,13 @@ def subtract(input, other, *, alpha=1, out=None): return ivy.subtract(input, other * alpha, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def tan(input, *, out=None): return ivy.tan(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def tanh(input, *, out=None): return ivy.tanh(input, out=out) @@ -559,13 +559,13 @@ def true_divide(input, other, *, out=None): return ivy.divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def trunc(input, *, out=None): return ivy.trunc(input, out=out) -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def xlogy(input, other, *, out=None): return ivy.xlogy(input, other, out=out) diff --git a/ivy/functional/frontends/torch/random_sampling.py b/ivy/functional/frontends/torch/random_sampling.py index 9ce4b6822bc25..4b3b21bad1160 100644 --- a/ivy/functional/frontends/torch/random_sampling.py +++ b/ivy/functional/frontends/torch/random_sampling.py @@ -5,7 +5,7 @@ @with_supported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float32", "float64", ) @@ -26,7 +26,7 @@ def manual_seed(seed: int): @with_supported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float32", "float64", ) @@ -49,7 +49,7 @@ def multinomial(input, num_samples, replacement=False, *, generator=None, out=No @with_supported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float32", "float64", ) @@ -64,7 +64,7 @@ def normal(mean, std, *, generator=None, out=None): @with_supported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float32", "float64", ) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 6e9aca464b8ed..6870cbece2f72 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -32,7 +32,7 @@ def amin(input, dim=None, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def aminmax(input, *, dim=None, keepdim=False, out=None): minmax_tuple = namedtuple("minmax", ["min", "max"]) return minmax_tuple( @@ -51,7 +51,7 @@ def any(input, dim=None, keepdim=False, *, out=None): return ret -@with_unsupported_dtypes({"2.1.0 and below": ("complex", "bool")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("complex", "bool")}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def argmax(input, dim=None, keepdim=False): @@ -67,7 +67,7 @@ def argmin(input, dim=None, keepdim=False): @numpy_to_torch_style_args @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.0 and below": ("uint8", "int8")}, + {"2.1.1 and below": ("uint8", "int8")}, "torch", ) def count_nonzero(input, dim=None): @@ -163,7 +163,7 @@ def median(input, dim=None, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.0 and below": ("complex64", "complex128")}, + {"2.1.1 and below": ("complex64", "complex128")}, "torch", ) def min(*input, dim=None, keepdim=False, out=None): @@ -234,7 +234,7 @@ def nanmedian(input, dim=None, keepdim=False, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float", "int")}, + {"2.1.1 and below": ("float", "int")}, "torch", ) def nansum(input, dim=None, keepdim=False, *, dtype=None): @@ -244,7 +244,7 @@ def nansum(input, dim=None, keepdim=False, *, dtype=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float", "complex")}, + {"2.1.1 and below": ("float", "complex")}, "torch", ) def norm(input, p="fro", dim=None, keepdim=False, out=None, dtype=None): @@ -270,7 +270,7 @@ def norm(input, p="fro", dim=None, keepdim=False, out=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -286,7 +286,7 @@ def prod(input, dim=None, keepdim=False, *, dtype=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def quantile(input, q, dim=None, keepdim=False, *, interpolation="linear", out=None): return ivy.quantile( input, q, axis=dim, keepdims=keepdim, interpolation=interpolation, out=out @@ -295,14 +295,14 @@ def quantile(input, q, dim=None, keepdim=False, *, interpolation="linear", out=N @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def std(input, dim=None, unbiased=True, keepdim=False, *, out=None): return ivy.std(input, axis=dim, correction=int(unbiased), keepdims=keepdim, out=out) @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def std_mean(input, dim, unbiased, keepdim=False, *, out=None): temp_std = ivy.std( input, axis=dim, correction=int(unbiased), keepdims=keepdim, out=out @@ -347,7 +347,7 @@ def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=No @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "complex", ) @@ -369,7 +369,7 @@ def unique_consecutive(input, return_inverse, return_counts, dim): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -384,7 +384,7 @@ def var(input, dim, unbiased, keepdim=False, *, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 92991c47d1f5e..ca8a0705cb3e6 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -145,20 +145,20 @@ def reshape(self, *args, shape=None): return torch_frontend.reshape(self, args) return torch_frontend.reshape(self) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @with_unsupported_dtypes({"2.5.1 and below": ("float16",)}, "paddle") def reshape_as(self, other): return torch_frontend.reshape(self, other.shape) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def add(self, other, *, alpha=1): return torch_frontend.add(self, other, alpha=alpha) - # @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + # @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def divide(self, other, *, out=None): return torch_frontend.divide(self, other, out=out) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def sub(self, other, *, alpha=1): return torch_frontend.sub(self, other, alpha=alpha) @@ -173,105 +173,105 @@ def any(self, dim=None, keepdim=False): def all(self, dim=None, keepdim=False): return torch_frontend.all(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def add_(self, other, *, alpha=1): self.ivy_array = self.add(other, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addmm(self, mat1, mat2, *, beta=1, alpha=1): return torch_frontend.addmm(self, mat1, mat2, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addmm_(self, mat1, mat2, *, beta=1, alpha=1): self.ivy_array = self.addmm(mat1, mat2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addmv(self, mat, vec, *, beta=1, alpha=1): return torch_frontend.addmv(self, mat, vec, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addmv_(self, mat, vec, *, beta=1, alpha=1): self.ivy_array = torch_frontend.addmv( self, mat, vec, beta=beta, alpha=alpha ).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addbmm(self, batch1, batch2, *, beta=1, alpha=1): return torch_frontend.addbmm(self, batch1, batch2, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addbmm_(self, batch1, batch2, *, beta=1, alpha=1): self.ivy_array = self.addbmm(batch1, batch2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def subtract_(self, other, *, alpha=1): self.ivy_array = self.sub(other, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def asin(self): return torch_frontend.asin(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def asin_(self): self.ivy_array = self.asin().ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def sum(self, dim=None, keepdim=False, *, dtype=None): return torch_frontend.sum(self, dim=dim, keepdim=keepdim, dtype=dtype) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def sin(self): return torch_frontend.sin(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def sin_(self): self.ivy_array = self.sin().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def sinh(self): return torch_frontend.sinh(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def sinh_(self): self.ivy_array = self.sinh().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def cos(self): return torch_frontend.cos(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def cos_(self): self.ivy_array = self.cos().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def cosh(self): return torch_frontend.cosh(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def cosh_(self): self.ivy_array = self.cosh().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def atan(self): return torch_frontend.atan(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def atan_(self): self.ivy_array = self.atan().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def atan2(self, other): return torch_frontend.atan2(self, other) @@ -317,56 +317,56 @@ def float(self, memory_format=None): def double(self): return self.to(torch_frontend.float64) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def asinh(self): return torch_frontend.asinh(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def asinh_(self): self.ivy_array = self.asinh().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def tan(self): return torch_frontend.tan(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def tan_(self): self.ivy_array = self.tan().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def tanh(self): return torch_frontend.tanh(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def tanh_(self): self.ivy_array = self.tanh().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def atanh(self): return torch_frontend.atanh(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def atanh_(self): self.ivy_array = self.atanh().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def log(self): return torch_frontend.log(self) - @with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") def log2_(self): self.ivy_array = self.log2().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def logit(self): return torch_frontend.logit(self) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "uint16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "uint16")}, "torch") def copy_(self, other, non_blocking=False): ivy.utils.assertions.check_one_way_broadcastable( self.ivy_array.shape, torch_frontend.tensor(other).ivy_array.shape @@ -374,31 +374,31 @@ def copy_(self, other, non_blocking=False): self._ivy_array = torch_frontend.tensor(other).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def log_(self): self.ivy_array = self.log().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def log2(self): return torch_frontend.log2(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def relu(self): return torch_frontend_nn.relu(self) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") def amax(self, dim=None, keepdim=False): return torch_frontend.amax(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") def amin(self, dim=None, keepdim=False): return torch_frontend.amin(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("complex", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("complex", "float16")}, "torch") def aminmax(self, dim=None, keepdim=False): return torch_frontend.aminmax(self, dim=dim, keepdim=keepdim) @@ -409,7 +409,7 @@ def abs_(self): self.ivy_array = self.abs().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def logical_and(self, other): return torch_frontend.logical_and(self, other) @@ -420,7 +420,7 @@ def logical_not_(self): self.ivy_array = ivy.astype(self.logical_not().ivy_array, self.dtype) return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def logical_or(self, other): return torch_frontend.logical_or(self, other) @@ -430,14 +430,14 @@ def bitwise_not(self): def bitwise_and(self, other): return torch_frontend.bitwise_and(self, other) - @with_supported_dtypes({"2.1.0 and below": ("integer",)}, "torch") + @with_supported_dtypes({"2.1.1 and below": ("integer",)}, "torch") def bitwise_or(self, other): return torch_frontend.bitwise_or(self, other) def bitwise_left_shift(self, other): return torch_frontend.bitwise_left_shift(self, other) - @with_supported_dtypes({"2.1.0 and below": ("integer",)}, "torch") + @with_supported_dtypes({"2.1.1 and below": ("integer",)}, "torch") def bitwise_or_(self, other): self.ivy_array = self.bitwise_or(other).ivy_array return self @@ -465,13 +465,13 @@ def new_ones( size, dtype=dtype, device=device, requires_grad=requires_grad ) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def floor(self, *, out=None): return torch_frontend.floor(self) @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "uint8", "uint32", @@ -488,7 +488,7 @@ def not_equal(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "uint8", "uint32", @@ -507,12 +507,12 @@ def not_equal_(self, other, *, out=None): def equal(self, other): return torch_frontend.equal(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def erf(self, *, out=None): return torch_frontend.erf(self, out=out) @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "bfloat16")}, "torch" + {"2.1.1 and below": ("float32", "float64", "bfloat16")}, "torch" ) def erf_(self, *, out=None): self.ivy_array = self.erf(out=out).ivy_array @@ -612,11 +612,11 @@ def to(self, *args, **kwargs): ) return cast_tensor - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def acos(self): return torch_frontend.acos(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def acos_(self): self.ivy_array = self.acos().ivy_array return self @@ -636,7 +636,7 @@ def new_tensor( _data = ivy.asarray(data, copy=True, dtype=dtype, device=device) return torch_frontend.tensor(_data) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def view_as(self, other): return self.view(size=other.shape) @@ -665,7 +665,7 @@ def detach_(self): self.ivy_array = self.detach().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("uint16",)}, "torch") @numpy_to_torch_style_args def unsqueeze(self, dim): return torch_frontend.unsqueeze(self, dim) @@ -753,7 +753,7 @@ def max(self, dim=None, keepdim=False): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "complex", "bfloat16", "bool", @@ -779,15 +779,15 @@ def is_cuda(self): def is_meta(self): return "meta" in ivy.dev(self.ivy_array) - @with_unsupported_dtypes({"2.1.0 and below": ("uint16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("uint16", "bool")}, "torch") def positive(self): return torch_frontend.positive(self) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def pow(self, exponent): return torch_frontend.pow(self, exponent) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def pow_(self, exponent): self.ivy_array = self.pow(exponent).ivy_array return self @@ -808,7 +808,7 @@ def matmul(self, other): return torch_frontend.matmul(self, other) @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_power(self, n, *, out=None): return torch_frontend.linalg.matrix_power(self, n, out=out) @@ -817,20 +817,20 @@ def argwhere(self): return torch_frontend.argwhere(self) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("complex", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("complex", "bool")}, "torch") def argmax(self, dim=None, keepdim=False): return torch_frontend.argmax(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") def argmin(self, dim=None, keepdim=False): return torch_frontend.argmin(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") def argsort(self, dim=-1, descending=False): return torch_frontend.argsort(self, dim=dim, descending=descending) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def ceil(self): return torch_frontend.ceil(self) @@ -852,22 +852,22 @@ def permute(self, *args, dims=None): return torch_frontend.permute(self) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def mean(self, dim=None, keepdim=False): return torch_frontend.mean(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @numpy_to_torch_style_args def nanmean(self, dim=None, keepdim=False): return torch_frontend.nanmean(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @numpy_to_torch_style_args def nansum(self, dim=None, keepdim=False): return torch_frontend.nansum(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def median(self, dim=None, keepdim=False): return torch_frontend.median(self, dim=dim, keepdim=keepdim) @@ -885,32 +885,32 @@ def flatten(self, start_dim=0, end_dim=-1): return torch_frontend.flatten(self, start_dim, end_dim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def cumsum(self, dim, *, dtype=None): return torch_frontend.cumsum(self, dim, dtype=dtype) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def cumsum_(self, dim, *, dtype=None): self.ivy_array = self.cumsum(dim, dtype=dtype).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def inverse(self): return torch_frontend.inverse(self) - @with_unsupported_dtypes({"2.1.0 and below": ("bool", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bool", "bfloat16")}, "torch") def neg(self): return torch_frontend.negative(self) - @with_unsupported_dtypes({"2.1.0 and below": ("bool",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bool",)}, "torch") def neg_(self): self.ivy_array = torch_frontend.negative(self).ivy_array return self __neg__ = neg - @with_unsupported_dtypes({"2.1.0 and below": ("bool", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bool", "bfloat16")}, "torch") def negative(self): return torch_frontend.negative(self) @@ -933,7 +933,7 @@ def type(self, dtype=None, non_blocking=False, **kwargs): else: return str(self.dtype) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def type_as(self, other): if self.dtype != other.dtype: self.ivy_array = ivy.astype(self.ivy_array, other.dtype) @@ -948,7 +948,7 @@ def squeeze(self, dim=None): return torch_frontend.squeeze(self, dim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("uint16",)}, "torch") def squeeze_(self, dim=None): self.ivy_array = self.squeeze(dim).ivy_array return self @@ -972,35 +972,35 @@ def tril_(self, diagonal=0): def index_select(self, dim, index): return torch_frontend.index_select(self, dim, index) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def clamp(self, min=None, max=None): return torch_frontend.clamp(self, min=min, max=max) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def clamp_(self, min=None, max=None): self.ivy_array = self.clamp(min=min, max=max).ivy_array return self @with_unsupported_dtypes( - {"2.1.0 and below": ("bool", "bfloat16", "float16", "complex")}, "torch" + {"2.1.1 and below": ("bool", "bfloat16", "float16", "complex")}, "torch" ) def clamp_min(self, min=None): return torch_frontend.clamp(self, min=min) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def sqrt(self): return torch_frontend.sqrt(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def rsqrt(self): return torch_frontend.rsqrt(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def rsqrt_(self): self.ivy_array = self.rsqrt().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def sqrt_(self): self.ivy_array = self.sqrt().ivy_array return self @@ -1011,7 +1011,7 @@ def where(self, condition, other): def clone(self, memory_format=None): return torch_frontend.tensor(ivy.array(self.ivy_array, copy=True)) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def acosh(self): return torch_frontend.acosh(self) @@ -1024,38 +1024,38 @@ def masked_fill_(self, mask, value): self.ivy_array = self.masked_fill(mask, value).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def index_add_(self, dim, index, source, *, alpha=1): self.ivy_array = torch_frontend.index_add( self, dim, index, source, alpha=alpha ).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def index_add(self, dim, index, source, *, alpha=1): return torch_frontend.index_add( self._ivy_array, dim, index, source, alpha=alpha ) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def acosh_(self): self.ivy_array = self.acosh().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def numpy(self): return np_frontend_array(self.ivy_array) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def sigmoid(self): return torch_frontend.sigmoid(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def sigmoid_(self): self.ivy_array = self.sigmoid().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def softmax(self, dim=None, dtype=None): return torch_frontend.nn.functional.softmax(self, dim=dim, dtype=dtype) @@ -1087,7 +1087,7 @@ def remainder(self, other, *, out=None): return torch_frontend.remainder(self, other, out=out) @with_supported_dtypes( - {"2.1.0 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" + {"2.1.1 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" ) def reciprocal_(self): self.ivy_array = torch_frontend.reciprocal(self).ivy_array @@ -1105,12 +1105,12 @@ def bitwise_and_(self, other): self.ivy_array = self.bitwise_and(other).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def atan2_(self, other): self.ivy_array = self.atan2(other).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def fmax(self, other): return torch_frontend.fmax(self, other) @@ -1120,20 +1120,20 @@ def fmin(self, other): def msort(self): return torch_frontend.msort(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def trunc(self): return torch_frontend.trunc(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def trunc_(self): self.ivy_array = self.trunc().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def fix(self): return torch_frontend.fix(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def fix_(self): self.ivy_array = self.fix().ivy_array return self @@ -1144,11 +1144,11 @@ def isinf(self): def is_complex(self): return torch_frontend.is_complex(self._ivy_array) - @with_unsupported_dtypes({"2.1.0 and below": ("uint16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("uint16", "bfloat16")}, "torch") def is_floating_point(self): return torch_frontend.is_floating_point(self._ivy_array) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def isreal(self): return torch_frontend.isreal(self._ivy_array) @@ -1159,11 +1159,11 @@ def addr_(self, vec1, vec2, *, beta=1, alpha=1): self.ivy_array = self.addr(vec1, vec2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def dot(self, tensor): return torch_frontend.dot(self, tensor) - @with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") def bernoulli(self, *, generator=None, out=None): return torch_frontend.bernoulli(self._ivy_array, generator=generator, out=out) @@ -1178,19 +1178,19 @@ def __bool__(self): "Use a.any() or a.all()" ) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __add__(self, other): return torch_frontend.add(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __mod__(self, other): return torch_frontend.remainder(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __pow__(self, exponent): return self.pow(exponent) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __rpow__(self, other): return torch_frontend.pow(other, self) @@ -1212,30 +1212,30 @@ def __iter__(self): for i in range(self.shape[0]): yield self[i] - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __radd__(self, other): return torch_frontend.add(other, self) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __mul__(self, other): return torch_frontend.mul(self, other) - @with_unsupported_dtypes({"2.1.0 and below": "bfloat16"}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": "bfloat16"}, "torch") def __matmul__(self, other): return torch_frontend.matmul(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __rmul__(self, other): return torch_frontend.mul(other, self) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __sub__(self, other): return torch_frontend.subtract(self, other) def __truediv__(self, other): return torch_frontend.div(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def __floordiv__(self, other): return torch_frontend.floor_divide(self, other) @@ -1290,39 +1290,39 @@ def __float__(self): item = item.real return float(item) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __eq__(self, other): return torch_frontend.eq(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") def __gt__(self, other): return torch_frontend.greater(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __ge__(self, other): return torch_frontend.greater_equal(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __ne__(self, other): return self.ne(other) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __rsub__(self, other): return torch_frontend.subtract(other, self) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __lt__(self, other): return torch_frontend.less(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __le__(self, other): return torch_frontend.less_equal(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def __or__(self, other): return torch_frontend.bitwise_or(self, other) - @with_supported_dtypes({"2.1.0 and below": ("integer", "bool")}, "torch") + @with_supported_dtypes({"2.1.1 and below": ("integer", "bool")}, "torch") def __invert__(self): return torch_frontend.bitwise_not(self) @@ -1356,7 +1356,7 @@ def item(self): ) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def cumprod(self, dim, dtype): return torch_frontend.cumprod(self, dim, dtype=dtype) @@ -1369,26 +1369,26 @@ def cov(self, /, *, correction=1, fweights=None, aweights=None): self, correction=correction, fweights=fweights, aweights=aweights ) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") def exp(self): return torch_frontend.exp(self) @with_unsupported_dtypes( - {"2.1.0 and below": ("bfloat16", "float16", "complex")}, "torch" + {"2.1.1 and below": ("bfloat16", "float16", "complex")}, "torch" ) def expm1(self): return torch_frontend.expm1(self) # remove "bfloat16" from the below decorator after fixing ivy.Array.__repr__ method @with_unsupported_dtypes( - {"2.1.0 and below": ("bfloat16", "float16", "complex")}, "torch" + {"2.1.1 and below": ("bfloat16", "float16", "complex")}, "torch" ) def expm1_(self): self.ivy_array = torch_frontend.expm1(self).ivy_array return self # fmt: off - @with_unsupported_dtypes({"2.1.0 and below": ("int8", "int16", "int32", "int64", "uint8", "bool", "float16",)},"torch",) # noqa + @with_unsupported_dtypes({"2.1.1 and below": ("int8", "int16", "int32", "int64", "uint8", "bool", "float16",)},"torch",) # noqa def exp_(self): self.ivy_array = self.exp().ivy_array return self @@ -1397,33 +1397,33 @@ def exp_(self): def mul(self, other): return torch_frontend.mul(self, other) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def ceil_(self): self.ivy_array = torch_frontend.ceil(self).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def mul_(self, other): self.ivy_array = self.mul(other).ivy_array # the return dtype is the same as the input dtype self.ivy_array = self.to(self.dtype).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") def round(self, *, decimals=0): return torch_frontend.round(self, decimals=decimals) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") def round_(self, *, decimals=0): self.ivy_array = self.round(decimals=decimals).ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def cross(self, other, dim=-1): return torch_frontend.cross(self, other, dim=dim) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def det(self): return torch_frontend.det(self) @@ -1442,13 +1442,13 @@ def nonzero(self, as_tuple=False): def mm(self, mat2): return torch_frontend.mm(self, mat2) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") def square(self): return torch_frontend.square(self._ivy_array) @with_supported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "float32", "float64", @@ -1467,16 +1467,16 @@ def square_(self): self.ivy_array = torch_frontend.square(self._ivy_array).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def log10(self): return torch_frontend.log10(self._ivy_array) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def log10_(self): self.ivy_array = self.log10().ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("uint16",)}, "torch") def zero_(self): self.ivy_array = torch_frontend.zeros_like(self).ivy_array return self @@ -1486,7 +1486,7 @@ def short(self, memory_format=None): return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def prod(self, dim=None, keepdim=False, *, dtype=None): return torch_frontend.prod(self, dim=dim, keepdim=keepdim, dtype=dtype) @@ -1498,7 +1498,7 @@ def div_(self, other, *, rounding_mode=None): return self @with_supported_dtypes( - {"2.1.0 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" + {"2.1.1 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" ) def true_divide_(self, other): self.ivy_array = self.div(other, rounding_mode=None).ivy_array @@ -1514,26 +1514,26 @@ def normal_(self, mean=0, std=1, *, generator=None): ) return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addcdiv(self, tensor1, tensor2, *, value=1): return torch_frontend.addcdiv(self, tensor1, tensor2, value=value) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addcmul(self, tensor1, tensor2, *, value=1): return torch_frontend.addcmul(self, tensor1, tensor2, value=value) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addcmul_(self, tensor1, tensor2, *, value=1): self.ivy_array = self.addcmul(tensor1, tensor2, value=value).ivy_array return self sign_decorator_dtypes = ("float16", "complex", "bool") - @with_unsupported_dtypes({"2.1.0 and below": sign_decorator_dtypes}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": sign_decorator_dtypes}, "torch") def sign(self): return torch_frontend.sign(self._ivy_array) - @with_unsupported_dtypes({"2.1.0 and below": sign_decorator_dtypes}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": sign_decorator_dtypes}, "torch") def sign_(self): self.ivy_array = self.sign().ivy_array return self @@ -1544,11 +1544,11 @@ def std(self, dim=None, unbiased=True, keepdim=False, *, out=None): self, dim=dim, unbiased=unbiased, keepdim=keepdim, out=out ) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def fmod(self, other, *, out=None): return torch_frontend.fmod(self, other, out=out) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def fmod_(self, other): self.ivy_array = self.fmod(other).ivy_array return self @@ -1559,96 +1559,96 @@ def norm(self, p="fro", dim=None, keepdim=False, dtype=None): def tolist(self): return self._ivy_array.to_list() - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def multiply(self, other, *, out=None): return torch_frontend.multiply(self, other, out=out) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def multiply_(self, other, *, out=None): self.ivy_array = torch_frontend.multiply(self, other, out=out).ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") def topk(self, k, dim=None, largest=True, sorted=True): return torch_frontend.topk(self, k, dim=dim, largest=largest, sorted=sorted) rshift_dtypes = ("float16", "bfloat16", "float32", "float64", "bool", "complex") - @with_unsupported_dtypes({"2.1.0 and below": rshift_dtypes}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": rshift_dtypes}, "torch") def bitwise_right_shift(self, other, *, out=None): return torch_frontend.bitwise_right_shift(self._ivy_array, other) @with_supported_dtypes( - {"2.1.0 and below": ("uint8", "int8", "int32", "int64")}, "torch" + {"2.1.1 and below": ("uint8", "int8", "int32", "int64")}, "torch" ) def bitwise_right_shift_(self, other, *, out=None): self.ivy_array = self.bitwise_right_shift(other, out=out).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def logdet(self): chol = torch_frontend.cholesky(self) return 2 * torch_frontend.sum( torch_frontend.log(torch_frontend.real(torch_frontend.diagonal(chol))) ) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def copysign(self, other, *, out=None): return torch_frontend.copysign(self, other, out=out) @with_supported_dtypes( - {"2.1.0 and below": ("float16", "float32", "float64")}, "torch" + {"2.1.1 and below": ("float16", "float32", "float64")}, "torch" ) def copysign_(self, other, *, out=None): self.ivy_array = self.copysign(other, out=out).ivy_array return self @with_unsupported_dtypes( - {"2.1.0 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.1.1 and below": ("complex", "bfloat16", "bool")}, "torch" ) def greater(self, other, *, out=None): return torch_frontend.greater(self, other, out=out) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "bool")}, "torch") def greater_(self, other): self.ivy_array = ivy.astype(self.greater(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.0 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.1.1 and below": ("complex", "bfloat16", "bool")}, "torch" ) def greater_equal(self, other, *, out=None): return torch_frontend.greater_equal(self, other, out=out) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "bool")}, "torch") def greater_equal_(self, other): self.ivy_array = ivy.astype(self.greater_equal(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.0 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.1.1 and below": ("complex", "bfloat16", "bool")}, "torch" ) def less(self, other, *, out=None): return torch_frontend.less(self, other, out=out) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "bool")}, "torch") def less_(self, other): self.ivy_array = ivy.astype(self.less(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.0 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.1.1 and below": ("complex", "bfloat16", "bool")}, "torch" ) def less_equal(self, other, *, out=None): return torch_frontend.less_equal(self, other, out=out) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "bool")}, "torch") def less_equal_(self, other): self.ivy_array = ivy.astype(self.less_equal(other).ivy_array, self.dtype) return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def eq_(self, other): self.ivy_array = ivy.astype( torch_frontend.eq(self, other).ivy_array, self.dtype @@ -1677,13 +1677,13 @@ def stride(self, dim=None): return strides @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "bfloat16")}, "torch" + {"2.1.1 and below": ("float32", "float64", "bfloat16")}, "torch" ) def log1p(self): promoted_type = ivy.promote_types(self.dtype, "float32") return torch_frontend.log1p(self).to(promoted_type) - @with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") def log1p_(self): promoted_type = ivy.promote_types(self.dtype, "float32") self.ivy_array = torch_frontend.log1p(self).to(promoted_type).ivy_array @@ -1703,14 +1703,14 @@ def baddbmm_(self, batch1, batch2, *, beta=1, alpha=1): def bmm(self, mat2): return torch_frontend.bmm(self, mat2=mat2) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def floor_(self): self.ivy_array = self.floor().ivy_array return self @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "complex", "float64", @@ -1726,7 +1726,7 @@ def diff(self, n=1, dim=-1, prepend=None, append=None): def diag(self, diagonal=0): return torch_frontend.diag(self, diagonal=diagonal) - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") def diagonal(self, offset=0, dim1=0, dim2=1): return torch_frontend.diagonal(self, offset=offset, dim1=dim1, dim2=dim2) @@ -1734,14 +1734,14 @@ def gather(self, dim, index): return torch_frontend.gather(self, dim=dim, index=index) @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add_(self, dim, index, src): self.ivy_array = ivy.put_along_axis(self.ivy_array, index, src, dim, mode="sum") return self @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_(self, dim, index, src, *, reduce=None): if reduce is None: @@ -1758,7 +1758,7 @@ def scatter_(self, dim, index, src, *, reduce=None): return self @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce_(self, dim, index, src, reduce, *, include_self=True): if reduce == "prod": @@ -1769,19 +1769,19 @@ def scatter_reduce_(self, dim, index, src, reduce, *, include_self=True): return self @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add(self, dim, index, src): return torch_frontend.scatter_add(self, dim, index, src) @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter(self, dim, index, src): return torch_frontend.scatter_reduce(self, dim, index, src, reduce="replace") @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce(self, dim, index, src, reduce, *, include_self=True): return torch_frontend.scatter_reduce(self, dim, index, src, reduce=reduce) @@ -1792,14 +1792,14 @@ def take_along_dim(self, indices, dim): def movedim(self, source, destination): return torch_frontend.movedim(self, source=source, destination=destination) - @with_unsupported_dtypes({"2.1.0 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def addcdiv_(self, tensor1, tensor2, *, value=1): self.ivy_array = self.addcdiv( tensor1=tensor1, tensor2=tensor2, value=value ).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") def cholesky(self, upper=False): return torch_frontend.cholesky(self, upper=upper) @@ -1838,7 +1838,7 @@ def backward(self, gradient=None, retain_graph=None, create_graph=False): else: next_function(_grad_list[idx]) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def logaddexp(self, other): return torch_frontend.logaddexp(self, other) @@ -1862,17 +1862,17 @@ def adjoint(self): return torch_frontend.adjoint(self) @with_unsupported_dtypes( - {"2.1.0 and below": ("int16", "float16", "bfloat16")}, "torch" + {"2.1.1 and below": ("int16", "float16", "bfloat16")}, "torch" ) def conj(self): return torch_frontend.conj(self) - @with_unsupported_dtypes({"2.1.0 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") def svd(self, some=True, compute_uv=True, *, out=None): return torch_frontend.svd(self, some=some, compute_uv=compute_uv, out=out) @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16", "float32", "float64", "complex")}, + {"2.1.1 and below": ("float16", "bfloat16", "float32", "float64", "complex")}, "torch", ) def gcd(self, other, *, out=None): @@ -1880,7 +1880,7 @@ def gcd(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", "uint16", @@ -1900,7 +1900,7 @@ def char(self): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", "float32", @@ -1917,7 +1917,7 @@ def lcm(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", "float32", @@ -1938,7 +1938,7 @@ def lcm_(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "int8", "uint8", @@ -1955,7 +1955,7 @@ def triu_(self, diagonal=0): return self @with_unsupported_dtypes( - {"2.1.0 and below": ("float16", "bfloat16")}, + {"2.1.1 and below": ("float16", "bfloat16")}, "torch", ) def quantile(self, q, dim=None, keepdim=False, *, interpolation="linear", out=None): @@ -1965,7 +1965,7 @@ def quantile(self, q, dim=None, keepdim=False, *, interpolation="linear", out=No @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "int8", "int16", "uint8", @@ -2007,7 +2007,7 @@ def uniform_(self, from_=0, to=1, *, generator=None): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -2019,7 +2019,7 @@ def sinc(self): @with_supported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float32", "float64", "bfloat16", @@ -2031,7 +2031,7 @@ def sinc_(self): self.ivy_array = torch_frontend.sinc(self).ivy_array return self - @with_unsupported_dtypes({"2.1.0 and below": ("uint8",)}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": ("uint8",)}, "torch") def index_fill(self, dim, index, value): arr = torch_frontend.moveaxis(self, dim, 0) arr[ivy.to_list(index)] = value @@ -2040,7 +2040,7 @@ def index_fill(self, dim, index, value): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "int8", "uint8", @@ -2063,7 +2063,7 @@ def unique_consecutive(self, return_inverse, return_counts, dim): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "uint16", "uint32", "uint64", @@ -2080,7 +2080,7 @@ def cummax(self, dim): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "int8", "uint8", @@ -2098,7 +2098,7 @@ def triu(self, diagonal=0): return torch_frontend.triu(self, diagonal) @with_unsupported_dtypes( - {"2.1.0 and below": ("bfloat16",)}, + {"2.1.1 and below": ("bfloat16",)}, "torch", ) def xlogy_(self, *, other, out=None): @@ -2107,7 +2107,7 @@ def xlogy_(self, *, other, out=None): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "uint8", "uint32", @@ -2124,7 +2124,7 @@ def ne(self, other): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "uint8", "uint32", @@ -2141,7 +2141,7 @@ def ne_(self, other): @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "bfloat16", "int8", "uint8", @@ -2161,7 +2161,7 @@ def unique(self, sorted=True, return_inverse=False, return_counts=False, dim=Non @with_unsupported_dtypes( { - "2.1.0 and below": ( + "2.1.1 and below": ( "float16", "bfloat16", ) @@ -2171,7 +2171,7 @@ def unique(self, sorted=True, return_inverse=False, return_counts=False, dim=Non def xlogy(self, *, other, out=None): return torch_frontend.xlogy(self, other, out=out) - @with_unsupported_dtypes({"2.1.0 and below": "complex"}, "torch") + @with_unsupported_dtypes({"2.1.1 and below": "complex"}, "torch") def minimum(self, other, *, out=None): return torch_frontend.minimum(self, other=other, out=out) @@ -2179,7 +2179,7 @@ def rad2deg(self, *, out=None): return torch_frontend.rad2deg(self, out=out) @with_supported_dtypes( - {"2.1.0 and below": "valid"}, + {"2.1.1 and below": "valid"}, "torch", ) def corrcoef(self): diff --git a/ivy/functional/frontends/torch/tensor_functions.py b/ivy/functional/frontends/torch/tensor_functions.py index 135981f71aaee..792e1f2d20c17 100644 --- a/ivy/functional/frontends/torch/tensor_functions.py +++ b/ivy/functional/frontends/torch/tensor_functions.py @@ -31,7 +31,7 @@ def numel(input): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter(input, dim, index, src): return ivy.put_along_axis(input, index, src, dim, mode="replace") @@ -39,7 +39,7 @@ def scatter(input, dim, index, src): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add(input, dim, index, src): return ivy.put_along_axis(input, index, src, dim, mode="sum") @@ -47,7 +47,7 @@ def scatter_add(input, dim, index, src): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.0 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce(input, dim, index, src, reduce, *, include_self=True): mode_mappings = { diff --git a/ivy/functional/frontends/torch/utilities.py b/ivy/functional/frontends/torch/utilities.py index da073c2720660..4ec08129df43e 100644 --- a/ivy/functional/frontends/torch/utilities.py +++ b/ivy/functional/frontends/torch/utilities.py @@ -20,7 +20,7 @@ def _assert(condition, message): # ------------ # -@with_supported_dtypes({"2.1.0 and above": ("int64",)}, "torch") +@with_supported_dtypes({"2.1.1 and above": ("int64",)}, "torch") @to_ivy_arrays_and_back def bincount(x, weights=None, minlength=0): return ivy.bincount(x, weights=weights, minlength=minlength) diff --git a/ivy/functional/frontends/torchvision/ops.py b/ivy/functional/frontends/torchvision/ops.py index 589d0cb22910f..1a4e7fbf49e05 100644 --- a/ivy/functional/frontends/torchvision/ops.py +++ b/ivy/functional/frontends/torchvision/ops.py @@ -25,7 +25,7 @@ def box_area(boxes): @with_unsupported_device_and_dtypes( { - "2.1.0 and below": { + "2.1.1 and below": { "cpu": ("float16",), } }, @@ -51,7 +51,7 @@ def remove_small_boxes(boxes, min_size): return ivy.nonzero((w >= min_size) & (h >= min_size))[0] -@with_supported_dtypes({"2.1.0 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def roi_align( input, boxes, output_size, spatial_scale=1.0, sampling_ratio=1, aligned=False From 1e38c187072ccb974ad46bfc5a1c0613b09f306f Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 16 Nov 2023 19:51:03 +0000 Subject: [PATCH 196/978] refactor: Refactored convolution functions in the tf backend to avoid transposing when possible --- ivy/functional/backends/tensorflow/layers.py | 196 +++++++++++-------- 1 file changed, 110 insertions(+), 86 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 58072a5e1196a..231de76d91c98 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -16,40 +16,37 @@ ) -def _x_dil_before_conv(x, dims, x_dilations): +def _x_dil_before_conv(x, dims, x_dilations, data_format): # adding dilation in input x_dilations = [x_dilations] * dims if isinstance(x_dilations, int) else x_dilations x_dilations_idxs = [i for i, x_dil in enumerate(x_dilations) if x_dil > 1] + if data_format[-1] == "C" or data_format == "channel_last": + offset = 1 + else: + offset = 2 if x_dilations_idxs: for i in x_dilations_idxs: - h = x.shape[1 + i] + h = x.shape[offset + i] new_height = h + (h - 1) * (x_dilations[i] - 1) h = tf.eye(new_height, dtype=x.dtype)[:: x_dilations[i]] - x = tf.experimental.numpy.swapaxes(x, 1 + i, -1) + x = tf.experimental.numpy.swapaxes(x, offset + i, -offset) x = tf.matmul(x, h) - x = tf.experimental.numpy.swapaxes(x, -1, 1 + i) + x = tf.experimental.numpy.swapaxes(x, -offset, offset + i) return x -def _pad_before_conv(x, padding, dims): +def _pad_before_conv(x, padding, dims, data_format): if isinstance(padding, str): return x, padding elif isinstance(padding, int): pad_list = [(padding, padding)] * dims else: pad_list = padding - return ( - tf.pad( - x, - [ - (0, 0), - *pad_list, - (0, 0), - ], - "CONSTANT", - ), - "VALID", - ) + if data_format[-1] == "C" or data_format == "channel_last": + pad_list = [(0, 0), *pad_list, (0, 0)] + else: + pad_list = [(0, 0), (0, 0), *pad_list] + return tf.pad(x, pad_list, "CONSTANT"), "VALID" def _to_explicit_padding(padding, dims): @@ -63,13 +60,19 @@ def _to_explicit_padding(padding, dims): return "EXPLICIT", explicit_pad -def _transpose_out_pad(x_shape, filter_shape, strides, padding, dims, dilations): +def _transpose_out_pad( + x_shape, filter_shape, strides, padding, dims, dilations, data_format +): + if data_format[-1] == "C" or data_format == "channel_last": + offset = 1 + else: + offset = 2 dilations = [dilations] * dims if isinstance(dilations, int) else dilations strides = [strides] * dims if isinstance(strides, int) else strides if isinstance(padding, str): out_shape = [ _deconv_length( - x_shape[1 + i], strides[i], filter_shape[i], padding, dilations[i] + x_shape[offset + i], strides[i], filter_shape[i], padding, dilations[i] ) for i in range(dims) ] @@ -77,7 +80,7 @@ def _transpose_out_pad(x_shape, filter_shape, strides, padding, dims, dilations) if isinstance(padding, int): padding = [[padding, padding]] * dims out_shape = [ - (x_shape[1 + i] - 1) * strides[i] + (x_shape[offset + i] - 1) * strides[i] - padding[i][0] - padding[i][1] + dilations[i] * (filter_shape[i] - 1) @@ -104,15 +107,18 @@ def conv1d( bias: Optional[Union[tf.Tensor, tf.Variable]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - if data_format == "NCW": + permuted_x = False + if data_format == "NCW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 1)) + data_format = "NWC" + permuted_x = True if filter_format == "channel_first": filters = tf.transpose(filters, (2, 1, 0)) - x = _x_dil_before_conv(x, 1, x_dilations) - x, padding = _pad_before_conv(x, padding, 1) - res = tf.nn.conv1d(x, filters, strides, padding, "NWC", dilations) + x = _x_dil_before_conv(x, 1, x_dilations, data_format) + x, padding = _pad_before_conv(x, padding, 1, data_format) + res = tf.nn.conv1d(x, filters, strides, padding, data_format, dilations) res = tf.math.add(res, bias) if bias is not None else res - if data_format == "NCW": + if permuted_x: res = tf.transpose(res, (0, 2, 1)) return res @@ -137,21 +143,42 @@ def conv1d_transpose( raise ivy.utils.exceptions.IvyException( "Tensorflow does not support dilations greater than 1 when device is cpu" ) - if data_format == "NCW": + permuted_x = False + if data_format == "NCW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 1)) + data_format = "NWC" + permuted_x = True filters = tf.transpose(filters, (0, 2, 1)) output_shape, padding = _transpose_out_pad( - x.shape, filters.shape, strides, padding, 1, dilations + x.shape, filters.shape, strides, padding, 1, dilations, data_format ) res = tf.nn.conv1d_transpose( - x, filters, output_shape, strides, padding, "NWC", dilations + x, filters, output_shape, strides, padding, data_format, dilations ) res = tf.math.add(res, bias) if bias is not None else res - if data_format == "NCW": + if permuted_x: res = tf.transpose(res, (0, 2, 1)) return res +def _extend_strides_dilations(strides, dilations, dims, data_format): + if data_format[-1] == "C" or data_format == "channel_last": + strides = [1, *([strides] * dims if isinstance(strides, int) else strides), 1] + dilations = [ + 1, + *([dilations] * dims if isinstance(dilations, int) else dilations), + 1, + ] + else: + strides = [1, 1, *([strides] * dims if isinstance(strides, int) else strides)] + dilations = [ + 1, + 1, + *([dilations] * dims if isinstance(dilations, int) else dilations), + ] + return strides, dilations + + @with_supported_dtypes({"2.14.0 and below": ("float", "int32")}, backend_version) def conv2d( x: Union[tf.Tensor, tf.Variable], @@ -167,27 +194,27 @@ def conv2d( bias: Optional[Union[tf.Tensor, tf.Variable]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - if data_format == "NCHW": + permuted_x = False + if data_format == "NCHW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 3, 1)) + data_format = "NHWC" + permuted_x = True if filter_format == "channel_first": filters = tf.transpose(filters, (2, 3, 1, 0)) - x = _x_dil_before_conv(x, 2, x_dilations) + x = _x_dil_before_conv(x, 2, x_dilations, data_format) padding, explicit_padding = _to_explicit_padding(padding, 2) - strides = [1] + list([strides] * 2 if isinstance(strides, int) else strides) + [1] - dilations = ( - [1] + list([dilations] * 2 if isinstance(dilations, int) else dilations) + [1] - ) + strides, dilations = _extend_strides_dilations(strides, dilations, 2, data_format) res = tf.raw_ops.Conv2D( input=x, filter=filters, strides=strides, padding=padding, explicit_paddings=explicit_padding, - data_format="NHWC", + data_format=data_format, dilations=dilations, ) res = tf.math.add(res, bias) if bias is not None else res - if data_format == "NCHW": + if permuted_x: return tf.transpose(res, (0, 3, 1, 2)) return res @@ -212,8 +239,11 @@ def conv2d_transpose( raise ivy.utils.exceptions.IvyException( "Tensorflow does not support dilations greater than 1 when device is cpu" ) - if data_format == "NCHW": + permuted_x = False + if data_format == "NCHW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 3, 1)) + data_format = "NHWC" + permuted_x = True filters = tf.transpose(filters, (0, 1, 3, 2)) output_shape, padding = _transpose_out_pad( x.shape, @@ -222,12 +252,13 @@ def conv2d_transpose( padding, 2, dilations, + data_format, ) res = tf.nn.conv2d_transpose( - x, filters, output_shape, strides, padding, "NHWC", dilations + x, filters, output_shape, strides, padding, data_format, dilations ) res = tf.math.add(res, bias) if bias is not None else res - if data_format == "NCHW": + if permuted_x: return tf.transpose(res, (0, 3, 1, 2)) return res @@ -246,15 +277,18 @@ def depthwise_conv2d( ) -> Union[tf.Tensor, tf.Variable]: strides = [strides] * 2 if isinstance(strides, int) else strides dilations = [dilations] * 2 if isinstance(dilations, int) else dilations - if data_format == "NCHW": + permuted_x = False + if data_format == "NCHW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 3, 1)) + data_format = "NHWC" + permuted_x = True if tf.rank(filters) == 3: filters = tf.expand_dims(filters, -1) - x, padding = _pad_before_conv(x, padding, 2) + x, padding = _pad_before_conv(x, padding, 2, data_format) strides = [1, strides[0], strides[1], 1] - res = tf.nn.depthwise_conv2d(x, filters, strides, padding, "NHWC", dilations) - if data_format == "NCHW": - return tf.transpose(res, (0, 3, 1, 2)) + res = tf.nn.depthwise_conv2d(x, filters, strides, padding, data_format, dilations) + if permuted_x: + res = tf.transpose(res, (0, 3, 1, 2)) return res @@ -273,19 +307,19 @@ def conv3d( bias: Optional[Union[tf.Tensor, tf.Variable]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ): - if data_format == "NCDHW": + permuted_x = False + if data_format == "NCDHW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 3, 4, 1)) + data_format = "NDHWC" + permuted_x = True if filter_format == "channel_first": filters = tf.transpose(filters, (2, 3, 4, 1, 0)) - x = _x_dil_before_conv(x, 3, x_dilations) - x, padding = _pad_before_conv(x, padding, 3) - strides = [1] + list([strides] * 3 if isinstance(strides, int) else strides) + [1] - dilations = ( - [1] + list([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] - ) - res = tf.nn.conv3d(x, filters, strides, padding, "NDHWC", dilations) + x = _x_dil_before_conv(x, 3, x_dilations, data_format) + x, padding = _pad_before_conv(x, padding, 3, data_format) + strides, dilations = _extend_strides_dilations(strides, dilations, 3, data_format) + res = tf.nn.conv3d(x, filters, strides, padding, data_format, dilations) res = tf.math.add(res, bias) if bias is not None else res - if data_format == "NCDHW": + if permuted_x: return tf.transpose(res, (0, 4, 1, 2, 3)) return res @@ -310,21 +344,21 @@ def conv3d_transpose( raise ivy.utils.exceptions.IvyException( "Tensorflow does not support dilations greater than 1 when device is cpu" ) - if data_format == "NCDHW": + permuted_x = False + if data_format == "NCDHW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 3, 4, 1)) + data_format = "NDHWC" + permuted_x = True filters = tf.transpose(filters, (0, 1, 2, 4, 3)) output_shape, padding = _transpose_out_pad( - x.shape, filters.shape, strides, padding, 3, dilations - ) - strides = [1] + list([strides] * 3 if isinstance(strides, int) else strides) + [1] - dilations = ( - [1] + list([dilations] * 3 if isinstance(dilations, int) else dilations) + [1] + x.shape, filters.shape, strides, padding, 3, dilations, data_format ) + strides, dilations = _extend_strides_dilations(strides, dilations, 3, data_format) res = tf.nn.conv3d_transpose( - x, filters, output_shape, strides, padding, "NDHWC", dilations + x, filters, output_shape, strides, padding, data_format, dilations ) res = tf.math.add(res, bias) if bias is not None else res - if data_format == "NCDHW": + if permuted_x: return tf.transpose(res, (0, 4, 1, 2, 3)) return res @@ -353,7 +387,7 @@ def conv_general_dilated( if filter_format == "channel_first": filters = tf.transpose(filters, (*range(2, dims + 2), 1, 0)) - x = _x_dil_before_conv(x, dims, x_dilations) + x = _x_dil_before_conv(x, dims, x_dilations, "channel_last") df = _get_x_data_format(dims, "channel_last") @@ -370,7 +404,7 @@ def conv_general_dilated( ) if dims == 1: - x, padding = _pad_before_conv(x, padding, dims) + x, padding = _pad_before_conv(x, padding, dims, "channel_last") res = tf.nn.conv1d( x, filters, @@ -381,13 +415,8 @@ def conv_general_dilated( ) elif dims == 2: padding, explicit_padding = _to_explicit_padding(padding, 2) - strides = ( - [1] + list([strides] * 2 if isinstance(strides, int) else strides) + [1] - ) - dilations = ( - [1] - + list([dilations] * 2 if isinstance(dilations, int) else dilations) - + [1] + strides, dilations = _extend_strides_dilations( + strides, dilations, 2, "channel_last" ) res = tf.raw_ops.Conv2D( input=x, @@ -399,14 +428,9 @@ def conv_general_dilated( dilations=dilations, ) else: - x, padding = _pad_before_conv(x, padding, dims) - strides = ( - [1] + list([strides] * 3 if isinstance(strides, int) else strides) + [1] - ) - dilations = ( - [1] - + list([dilations] * 3 if isinstance(dilations, int) else dilations) - + [1] + x, padding = _pad_before_conv(x, padding, dims, "channel_last") + strides, dilations = _extend_strides_dilations( + strides, dilations, 3, "channel_last" ) # grouped conv3d is not supported on CPU # ToDO: change the condition of GPU when automatic device shifting @@ -466,8 +490,6 @@ def conv_general_transpose( bias: Optional[Union[tf.Tensor, tf.Variable]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - if data_format == "channel_first": - x = tf.transpose(x, (0, *range(2, dims + 2), 1)) if feature_group_count == 1: if dims == 1: res = conv1d_transpose( @@ -476,7 +498,7 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, - data_format="NWC", + data_format="NWC" if data_format == "channel_last" else "NCW", dilations=dilations, bias=bias, ) @@ -487,7 +509,7 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, - data_format="NHWC", + data_format="NHWC" if data_format == "channel_last" else "NCHW", dilations=dilations, bias=bias, ) @@ -498,11 +520,13 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, - data_format="NDHWC", + data_format="NDHWC" if data_format == "channel_last" else "NCDHW", dilations=dilations, bias=bias, ) else: + if data_format == "channel_first": + x = tf.transpose(x, (0, *range(2, dims + 2), 1)) if dims == 1: res = tf.concat( [ @@ -564,8 +588,8 @@ def conv_general_transpose( axis=-1, ) res = tf.math.add(res, bias) if bias is not None else res - if data_format == "channel_first": - res = tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) + if data_format == "channel_first": + res = tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) return res From 985e7a1430653c5a046fc7cccc50077080e4688d Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 16 Nov 2023 19:53:54 +0000 Subject: [PATCH 197/978] fix: Updated torch's conv_transpose2d to avoid failure in numpy jax paddle backends since ivy conv tranpose functions don't support explicit padding there. --- .../nn/functional/convolution_functions.py | 37 +++++++++++++------ .../test_functional/test_nn/test_layers.py | 4 +- 2 files changed, 28 insertions(+), 13 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index 6edede79e7009..782efc8e75f9b 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -232,18 +232,31 @@ def conv_transpose2d( groups=1, dilation=1, ): - weight = ivy.permute_dims(weight, axes=(2, 3, 0, 1)) - return ivy.conv_general_transpose( - input, - weight, - stride, - _get_transpose_pad(padding, output_padding, 2), - dims=2, - data_format="channel_first", - dilations=dilation, - feature_group_count=groups, - bias=bias, - ) + if ivy.current_backend_str() in ["torch", "tensorflow"]: + # these two backends support explicit padding, no need for conv_general_dilated + weight = ivy.permute_dims(weight, axes=(2, 3, 0, 1)) + return ivy.conv_general_transpose( + input, + weight, + stride, + _get_transpose_pad(padding, output_padding, 2), + dims=2, + data_format="channel_first", + dilations=dilation, + feature_group_count=groups, + bias=bias, + ) + else: + _conv_transpose( + input, + weight, + bias=bias, + stride=stride, + padding=padding, + output_padding=output_padding, + groups=groups, + dilation=dilation, + ) @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index 6aace4a0abe7e..f33fbd155b80a 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -1076,6 +1076,7 @@ def test_conv2d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic fc, bias, ) = x_f_d_df + assume(isinstance(pad, str) or backend_fw in ["torch", "tensorflow"]) _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_function( input_dtypes=dtype, @@ -1254,6 +1255,7 @@ def test_conv_general_transpose( fc, bias, ) = dim_x_f_d_df + assume(isinstance(pad, str) or backend_fw in ["torch", "tensorflow"]) _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_function( input_dtypes=dtype, @@ -1305,7 +1307,7 @@ def test_depthwise_conv2d(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic strides=stride, padding=pad, data_format=data_format, - dilations=dilations, + dilations=dilations[0], ) From af8db63c36d85c9c02db73bbc3b02ef09b15f29a Mon Sep 17 00:00:00 2001 From: Olaoluwa Date: Fri, 17 Nov 2023 00:17:56 +0100 Subject: [PATCH 198/978] feat: added paddle chunk method with test (#26470) Co-authored-by: ivy-branch Co-authored-by: danielmunioz <47380745+danielmunioz@users.noreply.github.com> --- .../frontends/paddle/tensor/tensor.py | 18 +++++++ .../test_paddle/test_tensor/test_tensor.py | 52 +++++++++++++++++++ 2 files changed, 70 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 7c685e982066b..c251044038bcb 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -970,3 +970,21 @@ def expand(self, shape, name=None): ) def tile(self, repeat_times): return paddle_frontend.Tensor(ivy.tile(self._ivy_array, repeats=repeat_times)) + + @with_supported_dtypes( + { + "2.5.2 and below": ( + "bool", + "float16", + "float32", + "float64", + "int8", + "int16", + "int32", + "int64", + ) + }, + "paddle", + ) + def chunk(self, chunks, axis=0, name=None): + return paddle_frontend.split(self._ivy_array, num_or_sections=chunks, axis=axis) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index e9516c2bf5342..9e9979de0d4e6 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -4607,6 +4607,58 @@ def test_paddle_tanh_( ) +# chunk +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="chunk", + dtype_x_axis=helpers.dtype_values_axis( + available_dtypes=helpers.get_dtypes("float"), + min_num_dims=1, + min_value=0.1, + max_value=1e02, + force_int_axis=True, + valid_axis=True, + ), + chunks=st.integers( + min_value=1, + max_value=8, + ), +) +def test_paddle_tensor_chunk( + dtype_x_axis, + chunks, + frontend, + frontend_method_data, + init_flags, + method_flags, + on_device, + backend_fw, +): + input_dtype, x, axis = dtype_x_axis + is_remainder = x[0].shape[axis] % chunks != 0 + axis_solvable = len(x[0].shape) + axis < 0 + if is_remainder or axis_solvable: + assume(False) + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "chunks": chunks, + "axis": axis, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # expand @handle_frontend_method( class_tree=CLASS_TREE, From d9e8e49e16965a7c0dff22c0cfaad4f4422f6013 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Fri, 17 Nov 2023 01:44:39 -0800 Subject: [PATCH 199/978] feat: Add training support to `ivy.Module` converted `tf.keras.Model` instances (#27297) --- ivy/data_classes/array/conversions.py | 242 ++++++++++++------ .../frontends/torch/nn/modules/module.py | 23 +- ivy/stateful/converters.py | 78 ++++-- 3 files changed, 214 insertions(+), 129 deletions(-) diff --git a/ivy/data_classes/array/conversions.py b/ivy/data_classes/array/conversions.py index 7fb765f6f7c01..2020b1f2306c4 100644 --- a/ivy/data_classes/array/conversions.py +++ b/ivy/data_classes/array/conversions.py @@ -17,10 +17,6 @@ # --------# -# TODO: Need to find a better way to do this. -# Temporarily adding as is for the -# `ivy.Module.to_keras_module`method -# for the KLA demo. Do not move/remove. ARRAY_TO_BACKEND = { "ndarray": "numpy", "Tensor": ["torch", "paddle"], @@ -34,6 +30,79 @@ } +def _array_to_new_backend( + x: Union[ivy.Array, ivy.NativeArray], native: bool = False +) -> Union[ivy.Array, ivy.NativeArray]: + # Frontend instances + if hasattr(x, "_ivy_array"): + return x + + # ivy.Array instances + native_x = x.data if isinstance(x, ivy.Array) else x + native_x_type = type(native_x).__name__ + + # Modify native_type here since @tf.function converts tf.EagerTensor into + # tf.Tensor when running @tf.function enclosed function + if ivy.backend == "tensorflow": + import tensorflow as tf + + native_x_type = ( + "EagerTensor" + if not tf.executing_eagerly() and isinstance(native_x, tf.Tensor) + else native_x_type + ) + + if native_x_type not in ARRAY_TO_BACKEND: + return x + + # Check if the other possible backends match with the native data type + native_x_backend = ARRAY_TO_BACKEND[native_x_type] + + # Handle the `Tensor` name clash in paddle and torch + if not isinstance(native_x_backend, str): + native_x_backend = "torch" if "torch" in str(native_x.__class__) else "paddle" + + # If the current backend and the backend for the given array match, + # simply return the array as is + if ivy.backend == native_x_backend: + if native: + return native_x + np_intermediary = ivy.to_numpy(native_x) + return ivy.array(np_intermediary) + + # Otherwise, convert to the new backend + else: + native_x_backend = ivy.with_backend(native_x_backend) + # Handle native variable instances here + if native_x_backend.gradients._is_variable(native_x): + x_data = native_x_backend.gradients._variable_data(native_x) + # x_data = _array_to_new_backend(x_data, native=True) + from ivy.functional.ivy.gradients import _variable + + return _variable(x_data).data if native else _variable(x_data) + + np_intermediary = native_x_backend.to_numpy(native_x) + ret = ivy.array(np_intermediary) + return ret.data if native else ret + + +def _to_new_backend( + x: Any, + native: bool = False, + inplace: bool = False, + to_ignore: tuple = (), +) -> Any: + if isinstance(x, ivy.Container): + to_ignore = ivy.default(to_ignore, ()) + return x.cont_map( + lambda x_, _: _to_new_backend( + x_, native=native, inplace=inplace, to_ignore=to_ignore + ), + inplace=inplace, + ) + return _array_to_new_backend(x, native=native) + + def _to_native(x: Any, inplace: bool = False, to_ignore: tuple = ()) -> Any: to_ignore = ivy.default(to_ignore, ()) if isinstance(x, to_ignore): @@ -219,105 +288,110 @@ def args_to_native( return native_args, native_kwargs -# TODO: Need to find a better way to do this. -# Temporarily adding as is for the -# `ivy.Module.to_keras_module`method -# for the . Do not move/remove. -def array_to_new_backend( - x: Union[ivy.Array, ivy.NativeArray], - native: bool = False, -) -> Union[ivy.Array, ivy.NativeArray]: - native_x = x.data if isinstance(x, ivy.Array) else x - native_x_type = type(native_x).__name__ +def to_new_backend( + x: Union[ivy.Array, ivy.NativeArray, Iterable], + native: bool = True, + nested: bool = False, + include_derived: Optional[Dict[str, bool]] = None, + cont_inplace: bool = False, + to_ignore: Optional[Union[type, Tuple[type]]] = None, +) -> Union[ivy.Array, ivy.NativeArray, Iterable]: + """ + Return the input array converted to new backend framework form if it is an + `ivy.Array`, `ivy.NativeArray` or NativeVariable instance. If nested is set, the + check is applied to all nested leaves of tuples, lists and dicts contained within + ``x``. - # Modify native_type here since @tf.function converts tf.EagerTensor into - # tf.Tensor when running @tf.function on a transpiled graph - if ivy.current_backend_str() == "tensorflow": - import importlib + Parameters + ---------- + x + The input to maybe convert. + native + Whether to return the new array as a `ivy.NativeArray`, NativeVariable + or an `ivy.Array`. Default is ``True``. + nested + Whether to apply the conversion on arguments in a nested manner. If so, all + dicts, lists and tuples will be traversed to their lowest leaves in search of + ivy.Array instances. Default is ``False``. + include_derived + Whether to also recursive for classes derived from tuple, list and dict. + Default is ``False``. + cont_inplace + Whether to update containers in place. Default is ``False`` + to_ignore + Types to ignore when deciding whether to go deeper into the nest or not - native_x_type = ( - "EagerTensor" - if not importlib.import_module("tensorflow").executing_eagerly() - and isinstance(native_x, importlib.import_module("tensorflow").Tensor) - else native_x_type + Returns + ------- + ret + the input in the new backend framework form in the case of array instances. + """ + if nested: + return ivy.nested_map( + lambda x: _to_new_backend( + x, native=native, inplace=cont_inplace, to_ignore=to_ignore + ), + x, + include_derived, + shallow=False, ) + return _to_new_backend(x, native=native, inplace=cont_inplace, to_ignore=to_ignore) - # Check for paddle first, as it shares the 'Tensor' native_x_type with torch - if "paddle" in str(native_x.__class__) and ivy.current_backend_str() == "paddle": - if native: - return native_x - else: - return x - - if hasattr(x, "_ivy_array"): - return x - # Check if the other possible backends match with the native data type - if ( - native_x_type in ARRAY_TO_BACKEND - and ivy.current_backend_str() in ARRAY_TO_BACKEND[native_x_type] - ): - if ivy.current_backend_str() == "torch": - if "torch" in str(native_x.__class__): - # torch and paddle both use 'Tensor', return if this is torch - return x - else: - # if it's actually a paddle tensor, convert to an ivy array - ret = ivy.array(native_x.numpy()) - return ret.data if native else ret - if ivy.current_backend_str() == "paddle": - if "paddle" in str(native_x.__class__): - # torch and paddle both use 'Tensor', return if this is paddle - return x - else: - # if it's actually a torch tensor, convert to an ivy array - ret = ivy.array(native_x.numpy()) - return ret.data if native else ret - return x - - if native_x_type not in ARRAY_TO_BACKEND: - return x - native_x = ( - native_x.detach().cpu() - if native_x_type in ["Parameter", "Tensor"] - else native_x - ) - np_intermediary = np.array(native_x) - ret = ivy.array(np_intermediary) - return ret.data if native else ret - - -# TODO: Need to find a better way to do this. -# Temporarily adding as is for the -# `ivy.Module.to_keras_module()`method -# for the KLA demo. Do not move/remove. -def nest_array_to_new_backend( - nest: Iterable[Union[ivy.Array, ivy.NativeArray]], +def args_to_new_backend( + *args: Iterable[Any], native: bool = True, shallow: bool = True, -) -> Iterable[Union[ivy.Array, ivy.NativeArray]]: + include_derived: Dict[str, bool] = None, + cont_inplace: bool = False, + to_ignore: Optional[Union[type, Tuple[type]]] = None, + **kwargs: Dict[str, Any], +) -> Tuple[Iterable[Any], Dict[str, Any]]: """ - Convert a given ivy.Array or ivy.NativeArray to a new backend framework. + Return args and keyword args in the new current backend framework for all nested + ivy.Array, ivy.NativeArray or NativeVariable instances. Parameters ---------- - nest - Input nest with the leaves to be converted to a new backend. + args + The positional arguments to check native - Whether to return the new array as a ivy.NativeArray or an ivy.Array. - Default is ``True``. + Whether to return the new array as a ivy.NativeArray, NativeVariable + or an ivy.Array. Default is ``True``. + include_derived + Whether to also recursive for classes derived from tuple, list and dict. + Default is ``False``. + cont_inplace + Whether to update containers in place. + Default is ``False`` + to_ignore + Types to ignore when deciding whether to go deeper into the nest or not shallow Whether to inplace update the input nest or not Only works if nest is a mutable type. Default is ``True``. + kwargs + The key-word arguments to check Returns ------- ret - The input nest with leaves converted to the new backend framework. + The same arguments, with any nested array instances converted + to the new backend. """ - return ivy.nested_map( - lambda x: array_to_new_backend(x, native=native), - nest, - include_derived=True, + new_args = ivy.nested_map( + lambda x: _to_new_backend( + x, native=native, inplace=cont_inplace, to_ignore=to_ignore + ), + args, + include_derived, + shallow=shallow, + ) + new_kwargs = ivy.nested_map( + lambda x: _to_new_backend( + x, native=native, inplace=cont_inplace, to_ignore=to_ignore + ), + kwargs, + include_derived, shallow=shallow, ) + return new_args, new_kwargs diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index dc7283f4ac3f4..5458f50af041a 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -109,7 +109,7 @@ def _create_variables(self, device=None, dtype=None): def _build(self, *args, **kwargs): self._native_params = ivy.Container( OrderedDict( - sorted([ + ([ (k.replace(".", "/"), v) for k, v in dict(self.named_parameters()).items() ]) @@ -135,9 +135,11 @@ def _replace_update_v(self, new_v, native=None): if isinstance(v, ivy.Container): # noinspection PyProtectedMember native._modules[k] = self._replace_update_v(v, native._modules[k]) - elif _is_variable(v): + elif isinstance(v, Parameter): # noinspection PyProtectedMember native.__setattr__(k, v) + elif _is_variable(v): + native.__setattr__(k, Parameter(v)) elif isinstance(v, Tensor): # noinspection PyProtectedMember native.__setattr__(k, Parameter(v, requires_grad=v.requires_grad)) @@ -154,8 +156,7 @@ def forward(self, *input: Any) -> None: ) def _forward(self, *a, **kw): - self._update_v(self.v) - ret = self(*a, **kw) + ret = self._wrapped_call_impl(*a, **kw) return ret def register_buffer( @@ -562,8 +563,6 @@ def _wrapped_call_impl(self, *args, **kwargs): return self._call_impl(*args, **kwargs) def _call_impl(self, *args, **kwargs): - # TODO: Remove this once backprop through the frontends is fixed - self.requires_grad_(False) forward_call = self.forward # If we don't have any hooks, we want to skip the rest of the logic in # this function, and just call forward. @@ -715,8 +714,6 @@ def _call_impl(self, *args, **kwargs): # raise exception raised in try block raise - __call__: Callable[..., Any] = _wrapped_call_impl - def __getattribute__(self, name: str) -> Any: if name in ("__dict__", "v", "buffers"): return super(Module, self).__getattribute__(name) @@ -735,9 +732,6 @@ def __getattribute__(self, name: str) -> Any: return super(Module, self).__getattribute__(name) def __setattr__(self, name: str, value: Union[Tensor, "Module"]) -> None: - if name == "weight": - pass - def remove_from(*dicts_or_sets): for d in dicts_or_sets: if name in d: @@ -759,13 +753,6 @@ def remove_from(*dicts_or_sets): self._non_persistent_buffers_set, ) self.register_parameter(name, value) - elif params is not None and name in params: - if value is not None: - raise TypeError( - f"cannot assign '{type(value)}' as parameter '{name}' " - "(torch.nn.Parameter or None expected)" - ) - self.register_parameter(name, value) else: modules = self.__dict__.get("_modules") if isinstance(value, Module): diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index 59cfc5e5ba15d..0636de01aa7b5 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -1,7 +1,7 @@ """Converters from Native Modules to Ivy Modules.""" # global -import importlib +import functools from typing import Optional, Dict, List import re # noqa import inspect @@ -440,26 +440,40 @@ def from_torch_module( ) def to_keras_module(self): - class KerasModel(importlib.import_module("tensorflow").keras.Model): + """ + Convert a `ivy.Module` module instance to a `tf.keras.Model` instance. + + Returns + ------- + ret + The new trainable `tf.keras.Model` instance. + """ + try: + import tensorflow as tf + except ModuleNotFoundError as exc: + raise ModuleNotFoundError( + "`tensorflow` was not found installed on your system. Please proceed " + "to install it and restart your interpreter to see the changes." + ) from exc + + class KerasModel(tf.keras.Model): def __init__(self, ivy_module): super(KerasModel, self).__init__() self._ivy_module = ivy_module - self._parameters_converted = False + self._parameters = {} self._assign_variables() + self._populate_params() + self._propagate_params() def _assign_variables(self): ivy.set_backend("tensorflow") self._ivy_module.v = self._ivy_module.v.cont_map( lambda x, kc: ( - x.ivy_array.data + ivy.to_new_backend(x.ivy_array.data, native=True) if hasattr(x, "_ivy_array") - else ivy.to_native(x, nested=False, cont_inplace=True) - ) - ) - - self._ivy_module.v = self._ivy_module.v.cont_map( - lambda x, kc: ivy.array_to_new_backend(x, native=True) + else ivy.to_new_backend(x, native=True) + ), ) self._ivy_module.v.cont_map( lambda x, kc: self.add_weight( @@ -474,26 +488,37 @@ def _assign_variables(self): ivy.previous_backend() - def call(self, *args, **kwargs): - if not self._parameters_converted: - params = { - re.sub(r":([0-9]+)$", "", param.name).replace( - f"{self.name}/", "" - ): param - for param in self.variables - } - self._ivy_module.v = self._ivy_module.v.cont_map( - lambda _, kc: params[kc] - ) - self._parameters_converted = True - if "training" in kwargs: - del kwargs["training"] + def _populate_params(self): + self._parameters = { + re.sub(r":([0-9]+)$", "", param.name).replace( + f"{self.name}/", "" + ): param + for param in self.variables + } + + def _propagate_params(self): + def __update_param(ivy_module, x, kc): + # Update param in the underneath ivy module + module = ivy_module + keys = re.split("[/.]", kc) + for key in keys[:-1]: + module = module.__getattribute__(key) + if hasattr(module, "_update_v"): + module._update_v({keys[-1]: self._parameters[kc]}) + return self._parameters[kc] + + self._ivy_module.v = self._ivy_module.v.cont_map( + functools.partial(__update_param, self._ivy_module), + inplace=True, + ) + + def call(self, *args, training=None, **kwargs): ret = self._ivy_module(*args, **kwargs) ret = ivy.nested_map( lambda x: ( x.ivy_array.data if hasattr(x, "_ivy_array") - else ivy.to_native(x, nested=False) + else ivy.to_native(x) ), ret, ) @@ -501,8 +526,7 @@ def call(self, *args, **kwargs): def __call__(self, *args, **kwargs): ivy.set_backend("tensorflow") - args = ivy.nest_array_to_new_backend(args, native=True) - kwargs = ivy.nest_array_to_new_backend(kwargs, native=True) + args, kwargs = ivy.args_to_new_backend(*args, native=True, **kwargs) ivy.previous_backend() return super(KerasModel, self).__call__(*args, **kwargs) From e73a28250627ec70d996d0c594ebc1e070d7ab15 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 17 Nov 2023 17:11:00 +0530 Subject: [PATCH 200/978] feat: Updated `TensorFlow` version mapping from `2.14.0` to `2.15.0` (#27293) Co-authored-by: vedpatwardhan --- .../backends/tensorflow/__init__.py | 24 +++--- .../backends/tensorflow/activations.py | 6 +- .../backends/tensorflow/creation.py | 12 +-- .../backends/tensorflow/data_type.py | 2 +- .../backends/tensorflow/elementwise.py | 76 +++++++++---------- .../tensorflow/experimental/activations.py | 24 +++--- .../tensorflow/experimental/creation.py | 4 +- .../tensorflow/experimental/elementwise.py | 22 +++--- .../tensorflow/experimental/layers.py | 22 +++--- .../tensorflow/experimental/linear_algebra.py | 10 +-- .../tensorflow/experimental/losses.py | 8 +- .../tensorflow/experimental/manipulation.py | 6 +- .../backends/tensorflow/experimental/norms.py | 6 +- .../tensorflow/experimental/random.py | 4 +- .../tensorflow/experimental/searching.py | 2 +- .../tensorflow/experimental/statistical.py | 12 +-- ivy/functional/backends/tensorflow/general.py | 4 +- ivy/functional/backends/tensorflow/layers.py | 16 ++-- .../backends/tensorflow/linear_algebra.py | 56 +++++++------- .../backends/tensorflow/manipulation.py | 8 +- ivy/functional/backends/tensorflow/random.py | 4 +- .../backends/tensorflow/searching.py | 2 +- ivy/functional/backends/tensorflow/set.py | 8 +- ivy/functional/backends/tensorflow/sorting.py | 8 +- .../backends/tensorflow/statistical.py | 8 +- .../tf_probability/experimental/random.py | 2 +- .../experimental/statistical.py | 2 +- .../backends/torch/experimental/losses.py | 2 +- ivy/functional/frontends/__init__.py | 2 +- ivy/functional/frontends/jax/numpy/dtype.py | 4 +- .../frontends/tensorflow/compat/v1/nn.py | 8 +- .../frontends/tensorflow/general_functions.py | 30 ++++---- .../frontends/tensorflow/image/cropping.py | 2 +- .../frontends/tensorflow/keras/activations.py | 8 +- ivy/functional/frontends/tensorflow/linalg.py | 32 ++++---- ivy/functional/frontends/tensorflow/math.py | 32 ++++---- ivy/functional/frontends/tensorflow/nn.py | 26 +++---- ivy/functional/frontends/tensorflow/random.py | 12 +-- .../frontends/tensorflow/raw_ops.py | 48 ++++++------ ivy/functional/frontends/tensorflow/signal.py | 4 +- ivy/functional/frontends/tensorflow/tensor.py | 10 +-- 41 files changed, 289 insertions(+), 289 deletions(-) diff --git a/ivy/functional/backends/tensorflow/__init__.py b/ivy/functional/backends/tensorflow/__init__.py index 4d2a7e97c0398..786e8169f9139 100644 --- a/ivy/functional/backends/tensorflow/__init__.py +++ b/ivy/functional/backends/tensorflow/__init__.py @@ -128,7 +128,7 @@ def rep_method(*args, **kwargs): # update these to add new dtypes valid_dtypes = { - "2.14.0 and below": ( + "2.15.0 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -147,7 +147,7 @@ def rep_method(*args, **kwargs): ) } valid_numeric_dtypes = { - "2.14.0 and below": ( + "2.15.0 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -165,7 +165,7 @@ def rep_method(*args, **kwargs): ) } valid_int_dtypes = { - "2.14.0 and below": ( + "2.15.0 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -177,12 +177,12 @@ def rep_method(*args, **kwargs): ) } valid_float_dtypes = { - "2.14.0 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) + "2.15.0 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) } valid_uint_dtypes = { - "2.14.0 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) + "2.15.0 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) } -valid_complex_dtypes = {"2.14.0 and below": (ivy.complex64, ivy.complex128)} +valid_complex_dtypes = {"2.15.0 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -194,12 +194,12 @@ def rep_method(*args, **kwargs): # invalid data types # update these to add new dtypes -invalid_dtypes = {"2.14.0 and below": ()} -invalid_numeric_dtypes = {"2.14.0 and below": ()} -invalid_int_dtypes = {"2.14.0 and below": ()} -invalid_float_dtypes = {"2.14.0 and below": ()} -invalid_uint_dtypes = {"2.14.0 and below": ()} -invalid_complex_dtypes = {"2.14.0 and below": ()} +invalid_dtypes = {"2.15.0 and below": ()} +invalid_numeric_dtypes = {"2.15.0 and below": ()} +invalid_int_dtypes = {"2.15.0 and below": ()} +invalid_float_dtypes = {"2.15.0 and below": ()} +invalid_uint_dtypes = {"2.15.0 and below": ()} +invalid_complex_dtypes = {"2.15.0 and below": ()} # leave these untouched invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) diff --git a/ivy/functional/backends/tensorflow/activations.py b/ivy/functional/backends/tensorflow/activations.py index 0b1a5e85a99cb..2a9797f11897d 100644 --- a/ivy/functional/backends/tensorflow/activations.py +++ b/ivy/functional/backends/tensorflow/activations.py @@ -68,7 +68,7 @@ def softmax( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bfloat16", "float32", @@ -102,7 +102,7 @@ def softplus( # Softsign @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bfloat16", "float32", @@ -148,7 +148,7 @@ def mish( return tf.multiply(x, tf.math.tanh(x_norm)) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def hardswish( x: Tensor, /, diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py index a560441a94540..8f84e8e3cda1a 100644 --- a/ivy/functional/backends/tensorflow/creation.py +++ b/ivy/functional/backends/tensorflow/creation.py @@ -26,7 +26,7 @@ @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bfloat16", "complex", @@ -119,7 +119,7 @@ def empty_like( return tf.experimental.numpy.empty_like(x, dtype=dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("uint16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("uint16",)}, backend_version) def eye( n_rows: int, n_cols: Optional[int] = None, @@ -253,7 +253,7 @@ def linspace( return tf.cast(ans, dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool",)}, backend_version) def meshgrid( *arrays: Union[tf.Tensor, tf.Variable], sparse: bool = False, @@ -297,7 +297,7 @@ def ones_like( return tf.ones_like(x, dtype=dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool",)}, backend_version) def tril( x: Union[tf.Tensor, tf.Variable], /, @@ -310,7 +310,7 @@ def tril( return tf.experimental.numpy.tril(x, k) -@with_unsupported_dtypes({"2.14.0 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool",)}, backend_version) def triu( x: Union[tf.Tensor, tf.Variable], /, @@ -383,7 +383,7 @@ def one_hot( ) -@with_unsupported_dtypes({"2.14.0 and below": ("uint32", "uint64")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("uint32", "uint64")}, backend_version) def frombuffer( buffer: bytes, dtype: Optional[tf.DType] = float, diff --git a/ivy/functional/backends/tensorflow/data_type.py b/ivy/functional/backends/tensorflow/data_type.py index b5fb0f80784fe..22e8c1f0a78d6 100644 --- a/ivy/functional/backends/tensorflow/data_type.py +++ b/ivy/functional/backends/tensorflow/data_type.py @@ -164,7 +164,7 @@ def iinfo(type: Union[DType, str, tf.Tensor, tf.Variable, np.ndarray], /) -> np. return tf.experimental.numpy.iinfo(ivy.as_ivy_dtype(type)) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def result_type( *arrays_and_dtypes: Union[tf.Tensor, tf.Variable, tf.DType], ) -> ivy.Dtype: diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index 5fd6391aa85b0..ff46eefbf34ed 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -83,7 +83,7 @@ def atan( return tf.math.atan(x) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def atan2( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -104,7 +104,7 @@ def atanh( return tf.math.atanh(x) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def bitwise_and( x1: Union[int, tf.Tensor, tf.Variable], x2: Union[int, tf.Tensor, tf.Variable], @@ -119,7 +119,7 @@ def bitwise_and( return tf.bitwise.bitwise_and(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def bitwise_invert( x: Union[int, tf.Tensor, tf.Variable], /, @@ -132,7 +132,7 @@ def bitwise_invert( return tf.bitwise.invert(x) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def bitwise_left_shift( x1: Union[int, tf.Tensor, tf.Variable], x2: Union[int, tf.Tensor, tf.Variable], @@ -144,7 +144,7 @@ def bitwise_left_shift( return tf.bitwise.left_shift(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def bitwise_or( x1: Union[int, tf.Tensor, tf.Variable], x2: Union[int, tf.Tensor, tf.Variable], @@ -159,7 +159,7 @@ def bitwise_or( return tf.bitwise.bitwise_or(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def bitwise_right_shift( x1: Union[int, tf.Tensor, tf.Variable], x2: Union[int, tf.Tensor, tf.Variable], @@ -171,7 +171,7 @@ def bitwise_right_shift( return tf.bitwise.right_shift(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def bitwise_xor( x1: Union[int, tf.Tensor, tf.Variable], x2: Union[int, tf.Tensor, tf.Variable], @@ -186,7 +186,7 @@ def bitwise_xor( return tf.bitwise.bitwise_xor(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def ceil( x: Union[tf.Tensor, tf.Variable], /, @@ -208,7 +208,7 @@ def cos( return tf.cos(x) -@with_unsupported_dtypes({"2.14.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16",)}, backend_version) def cosh( x: Union[tf.Tensor, tf.Variable], /, @@ -263,7 +263,7 @@ def exp2( return tf.math.pow(2, x, name=None) -@with_supported_dtypes({"2.14.0 and below": ("float", "complex")}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float", "complex")}, backend_version) def expm1( x: Union[tf.Tensor, tf.Variable], /, @@ -273,7 +273,7 @@ def expm1( return tf.math.expm1(x) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def floor( x: Union[tf.Tensor, tf.Variable], /, @@ -286,7 +286,7 @@ def floor( return tf.math.floor(x) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def floor_divide( x1: Union[float, tf.Tensor, tf.Variable], x2: Union[float, tf.Tensor, tf.Variable], @@ -298,7 +298,7 @@ def floor_divide( return tf.experimental.numpy.floor_divide(x1, x2) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def fmin( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -313,7 +313,7 @@ def fmin( return ret -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def greater( x1: Union[float, tf.Tensor, tf.Variable], x2: Union[float, tf.Tensor, tf.Variable], @@ -325,7 +325,7 @@ def greater( return tf.experimental.numpy.greater(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def greater_equal( x1: Union[float, tf.Tensor, tf.Variable], x2: Union[float, tf.Tensor, tf.Variable], @@ -374,7 +374,7 @@ def isinf( return tf.zeros_like(x, tf.bool) -@with_unsupported_dtypes({"2.14.0 and below": ("complex", "bool")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def isnan( x: Union[tf.Tensor, tf.Variable], /, @@ -387,7 +387,7 @@ def isnan( return tf.math.is_nan(x) -@with_unsupported_dtypes({"2.14.0 and below": ("unsigned",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("unsigned",)}, backend_version) def lcm( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -401,7 +401,7 @@ def lcm( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bool", "complex", ) @@ -419,7 +419,7 @@ def less( return tf.math.less(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def less_equal( x1: Union[float, tf.Tensor, tf.Variable], x2: Union[float, tf.Tensor, tf.Variable], @@ -467,7 +467,7 @@ def log2( return tf.math.log(x) / tf.math.log(tf.constant(2.0, x.dtype)) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def logaddexp( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -479,7 +479,7 @@ def logaddexp( return tf.experimental.numpy.logaddexp(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16",)}, backend_version) def real( x: Union[tf.Tensor, tf.Variable], /, @@ -491,7 +491,7 @@ def real( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "uint8", "uint16", "uint32", @@ -563,7 +563,7 @@ def logical_xor( return tf.math.logical_xor(tf.cast(x1, tf.bool), tf.cast(x2, tf.bool)) -@with_unsupported_dtypes({"2.14.0 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool",)}, backend_version) def multiply( x1: Union[float, tf.Tensor, tf.Variable], x2: Union[float, tf.Tensor, tf.Variable], @@ -575,7 +575,7 @@ def multiply( return tf.math.multiply(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("bool", "unsigned")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool", "unsigned")}, backend_version) def negative( x: Union[float, tf.Tensor, tf.Variable], /, @@ -605,7 +605,7 @@ def positive( return tf.experimental.numpy.positive(x) -@with_unsupported_dtypes({"2.14.0 and below": ("bool", "unsigned")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool", "unsigned")}, backend_version) def pow( x1: Union[tf.Tensor, tf.Variable], x2: Union[int, float, tf.Tensor, tf.Variable], @@ -630,7 +630,7 @@ def pow( return tf.experimental.numpy.power(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def remainder( x1: Union[float, tf.Tensor, tf.Variable], x2: Union[float, tf.Tensor, tf.Variable], @@ -649,7 +649,7 @@ def remainder( return tf.experimental.numpy.remainder(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def round( x: Union[tf.Tensor, tf.Variable], /, @@ -670,7 +670,7 @@ def round( return tf.cast(tf.round(x * factor) / factor_deno, ret_dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("bool", "unsigned")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool", "unsigned")}, backend_version) def sign( x: Union[tf.Tensor, tf.Variable], /, @@ -765,7 +765,7 @@ def trapz( # TODO: Implement purely in tensorflow -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def trunc( x: Union[tf.Tensor, tf.Variable], /, @@ -792,7 +792,7 @@ def trunc( # ------# -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def erf( x: Union[tf.Tensor, tf.Variable], /, @@ -802,7 +802,7 @@ def erf( return tf.math.erf(x) -@with_unsupported_dtypes({"2.14.0 and below": ("complex", "bool")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def maximum( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -815,7 +815,7 @@ def maximum( return tf.math.maximum(x1, x2) -@with_unsupported_dtypes({"2.14.0 and below": ("complex", "bool")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def minimum( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -830,7 +830,7 @@ def minimum( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "uint8", "uint16", "uint32", @@ -852,7 +852,7 @@ def reciprocal( return tf.math.reciprocal(x) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def deg2rad( x: Union[tf.Tensor, tf.Variable], /, @@ -881,7 +881,7 @@ def isreal( @with_unsupported_dtypes( - {"2.14.0 and below": ("uint8", "uint16", "uint32", "uint64", "complex", "bool")}, + {"2.15.0 and below": ("uint8", "uint16", "uint32", "uint64", "complex", "bool")}, backend_version, ) def fmod( @@ -898,7 +898,7 @@ def fmod( @with_unsupported_dtypes( - {"2.14.0 and below": ("uint8", "uint16", "uint32", "uint64")}, backend_version + {"2.15.0 and below": ("uint8", "uint16", "uint32", "uint64")}, backend_version ) def gcd( x1: Union[tf.Tensor, tf.Variable, int, list, tuple], @@ -916,7 +916,7 @@ def gcd( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "uint8", "uint16", "uint32", @@ -942,7 +942,7 @@ def angle( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "uint8", "uint16", "uint32", diff --git a/ivy/functional/backends/tensorflow/experimental/activations.py b/ivy/functional/backends/tensorflow/experimental/activations.py index 1da7e9e2e80a7..11c67e78af3b5 100644 --- a/ivy/functional/backends/tensorflow/experimental/activations.py +++ b/ivy/functional/backends/tensorflow/experimental/activations.py @@ -26,7 +26,7 @@ def logit( return tf.cast(tf.math.log(x / (1 - x)), x_dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("complex", "bool")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def thresholded_relu( x: Tensor, /, @@ -42,7 +42,7 @@ def relu6(x: Tensor, /, *, complex_mode="jax", out: Optional[Tensor] = None) -> return tf.nn.relu6(x) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def logsigmoid( input: Tensor, /, *, complex_mode="jax", out: Optional[Tensor] = None ) -> Tensor: @@ -51,7 +51,7 @@ def logsigmoid( return tf.math.log_sigmoid(input) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def selu(x: Tensor, /, *, out: Optional[Tensor] = None) -> Tensor: ret = tf.nn.selu(x) if ivy.exists(out): @@ -59,7 +59,7 @@ def selu(x: Tensor, /, *, out: Optional[Tensor] = None) -> Tensor: return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def silu( x: Tensor, /, @@ -72,7 +72,7 @@ def silu( return ivy.astype(ret, x.dtype) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def elu(x: Tensor, /, *, alpha: float = 1.0, out: Optional[Tensor] = None) -> Tensor: alpha = tf.cast(alpha, x.dtype) ret = tf.cast(tf.where(x > 0, x, tf.multiply(alpha, tf.math.expm1(x))), x.dtype) @@ -81,7 +81,7 @@ def elu(x: Tensor, /, *, alpha: float = 1.0, out: Optional[Tensor] = None) -> Te return ivy.astype(ret, x.dtype) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def hardtanh( x: Tensor, /, @@ -100,7 +100,7 @@ def hardtanh( return ivy.astype(ret, x.dtype) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def tanhshrink( x: Tensor, /, @@ -113,7 +113,7 @@ def tanhshrink( return ivy.astype(ret, x.dtype) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def threshold( x: Tensor, /, @@ -128,7 +128,7 @@ def threshold( return ivy.astype(ret, x.dtype) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def softshrink( x: Tensor, /, @@ -146,7 +146,7 @@ def softshrink( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def celu( x: Tensor, /, @@ -158,7 +158,7 @@ def celu( return tf.math.maximum(0, x) + alpha * tf.math.expm1(tf.math.minimum(0, x) / alpha) -@with_unsupported_dtypes({"2.14.0 and below": ("uint16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("uint16",)}, backend_version) def scaled_tanh( x: Tensor, /, @@ -170,7 +170,7 @@ def scaled_tanh( return alpha * tf.nn.tanh(beta * x) -@with_supported_dtypes({"2.14.0 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def hardshrink( x: Tensor, /, diff --git a/ivy/functional/backends/tensorflow/experimental/creation.py b/ivy/functional/backends/tensorflow/experimental/creation.py index e5c3884477515..9f648ce9ec018 100644 --- a/ivy/functional/backends/tensorflow/experimental/creation.py +++ b/ivy/functional/backends/tensorflow/experimental/creation.py @@ -13,7 +13,7 @@ @with_unsupported_device_and_dtypes( - {"2.14.0 and below": {"cpu": ("bfloat16",)}}, + {"2.15.0 and below": {"cpu": ("bfloat16",)}}, backend_version, ) def kaiser_window( @@ -130,7 +130,7 @@ def unsorted_segment_sum( return tf.math.unsorted_segment_sum(data, segment_ids, num_segments) -@with_unsupported_dtypes({"2.14.0 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool",)}, backend_version) def trilu( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/tensorflow/experimental/elementwise.py b/ivy/functional/backends/tensorflow/experimental/elementwise.py index f23d1aa615677..62467bf853aac 100644 --- a/ivy/functional/backends/tensorflow/experimental/elementwise.py +++ b/ivy/functional/backends/tensorflow/experimental/elementwise.py @@ -54,7 +54,7 @@ def amin( @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64")}, + {"2.15.0 and below": ("float16", "float32", "float64")}, backend_version, ) def lgamma( @@ -77,7 +77,7 @@ def sinc( @with_supported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "float32", "float64")}, backend_version + {"2.15.0 and below": ("bfloat16", "float16", "float32", "float64")}, backend_version ) def fmax( x1: Union[tf.Tensor, tf.Variable], @@ -93,7 +93,7 @@ def fmax( @with_unsupported_dtypes( - {"2.14.0 and below": ("uint8", "uint16", "uint32", "uint64")}, backend_version + {"2.15.0 and below": ("uint8", "uint16", "uint32", "uint64")}, backend_version ) def float_power( x1: Union[tf.Tensor, tf.Variable, float, list, tuple], @@ -145,7 +145,7 @@ def count_nonzero( ) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def nansum( x: Union[tf.Tensor, tf.Variable], /, @@ -208,7 +208,7 @@ def allclose( ) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def fix( x: Union[tf.Tensor, tf.Variable], /, @@ -218,7 +218,7 @@ def fix( return tf.cast(tf.where(x > 0, tf.math.floor(x), tf.math.ceil(x)), x.dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("bflaot16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bflaot16", "float16")}, backend_version) def nextafter( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -230,7 +230,7 @@ def nextafter( @with_unsupported_dtypes( - {"2.14.0 and below": ("uint8", "uint16", "uint32", "uint64")}, backend_version + {"2.15.0 and below": ("uint8", "uint16", "uint32", "uint64")}, backend_version ) def diff( x: Union[tf.Tensor, tf.Variable, list, tuple], @@ -253,7 +253,7 @@ def diff( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float32", "float64", ) @@ -469,7 +469,7 @@ def gradient( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "float32", "float64", @@ -499,7 +499,7 @@ def conj( return tf.math.conj(x) -@with_unsupported_dtypes({"2.14.0 and below": ("unsigned",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("unsigned",)}, backend_version) def ldexp( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable, int], @@ -520,7 +520,7 @@ def ldexp( return tf.cast(ret, out_dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("unsigned",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("unsigned",)}, backend_version) def frexp( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 5fe49de82d4df..715306a0b3125 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -173,7 +173,7 @@ def max_pool2d( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float64", "float16")}, backend_version + {"2.15.0 and below": ("bfloat16", "float64", "float16")}, backend_version ) def max_pool3d( x: Union[tf.Tensor, tf.Variable], @@ -279,7 +279,7 @@ def _handle_manual_pad_avg_pool(x, kernel, strides, padding, ceil_mode, dims): return padding, pad_specific, c -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "float64")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "float64")}, backend_version) def avg_pool1d( x: Union[tf.Tensor, tf.Variable], kernel: Union[int, Tuple[int]], @@ -351,7 +351,7 @@ def avg_pool1d( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float64", "float16")}, backend_version + {"2.15.0 and below": ("bfloat16", "float64", "float16")}, backend_version ) def avg_pool2d( x: Union[tf.Tensor, tf.Variable], @@ -443,7 +443,7 @@ def avg_pool2d( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float64", "float16")}, backend_version + {"2.15.0 and below": ("bfloat16", "float64", "float16")}, backend_version ) def avg_pool3d( x: Union[tf.Tensor, tf.Variable], @@ -548,7 +548,7 @@ def avg_pool3d( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float64", "float16")}, backend_version + {"2.15.0 and below": ("bfloat16", "float64", "float16")}, backend_version ) def pool( x: Union[tf.Tensor, tf.Variable], @@ -574,7 +574,7 @@ def pool( ) -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, backend_version) def dct( x: Union[tf.Tensor, tf.Variable], /, @@ -649,7 +649,7 @@ def _ifft_norm( @with_supported_dtypes( - {"2.14.0 and below": ("complex", "float32", "float64")}, backend_version + {"2.15.0 and below": ("complex", "float32", "float64")}, backend_version ) def fft( x: Union[tf.Tensor, tf.Variable], @@ -712,7 +712,7 @@ def fft( return ret -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def dropout( x: Union[tf.Tensor, tf.Variable], prob: float, @@ -854,7 +854,7 @@ def ifft( return ret -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def embedding( weights: Union[tf.Tensor, tf.Variable], indices: Union[tf.Tensor, tf.Variable], @@ -1052,7 +1052,7 @@ def _fft2_helper(x, shape, axes): return x -@with_supported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def fft2( x: Union[tf.Tensor, tf.Variable], *, @@ -1523,7 +1523,7 @@ def rfftn( # stft -@with_supported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def stft( signals: Union[tf.Tensor, tf.Variable], frame_length: int, diff --git a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py index 826360c73a34c..4d54923e2e850 100644 --- a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py @@ -12,7 +12,7 @@ @with_unsupported_dtypes( - {"2.14.0 and below": ("int", "float16", "bfloat16")}, backend_version + {"2.15.0 and below": ("int", "float16", "bfloat16")}, backend_version ) def eigh_tridiagonal( alpha: Union[tf.Tensor, tf.Variable], @@ -96,7 +96,7 @@ def matrix_exp( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "complex", "float32", "float64", @@ -115,7 +115,7 @@ def eig( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "complex", "float32", "float64", @@ -162,7 +162,7 @@ def solve_triangular( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bfloat16", "float16", "float32", @@ -241,7 +241,7 @@ def lu_factor( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bfloat16", "float16", "float32", diff --git a/ivy/functional/backends/tensorflow/experimental/losses.py b/ivy/functional/backends/tensorflow/experimental/losses.py index e9140d6ee382e..6b7f032cb2060 100644 --- a/ivy/functional/backends/tensorflow/experimental/losses.py +++ b/ivy/functional/backends/tensorflow/experimental/losses.py @@ -8,7 +8,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.14.0 and below": "bool"}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": "bool"}, backend_version) def huber_loss( input: tf.Tensor, target: tf.Tensor, @@ -30,7 +30,7 @@ def huber_loss( return loss -@with_unsupported_dtypes({"2.14.0 and below": "bool"}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": "bool"}, backend_version) def smooth_l1_loss( input: tf.Tensor, target: tf.Tensor, @@ -50,7 +50,7 @@ def smooth_l1_loss( return loss -@with_unsupported_dtypes({"2.14.0 and below": "bool"}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": "bool"}, backend_version) def soft_margin_loss( input: tf.Tensor, target: tf.Tensor, @@ -118,7 +118,7 @@ def _validate_poisson_nll_params( @with_supported_device_and_dtypes( { - "2.14.0 and below": { + "2.15.0 and below": { "cpu": ("float32", "float64"), "gpu": ("float32", "float64"), } diff --git a/ivy/functional/backends/tensorflow/experimental/manipulation.py b/ivy/functional/backends/tensorflow/experimental/manipulation.py index 67119d4cf2b8c..56ad09a9daab3 100644 --- a/ivy/functional/backends/tensorflow/experimental/manipulation.py +++ b/ivy/functional/backends/tensorflow/experimental/manipulation.py @@ -34,7 +34,7 @@ def moveaxis( return tf.experimental.numpy.moveaxis(a, source, destination) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def heaviside( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -85,7 +85,7 @@ def rot90( return tf.experimental.numpy.rot90(m, k, axes) -@with_unsupported_dtypes({"2.14.0 and below": ("unsigned", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("unsigned", "complex")}, backend_version) def top_k( x: tf.Tensor, k: int, @@ -127,7 +127,7 @@ def fliplr( return tf.experimental.numpy.fliplr(m) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def i0( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/tensorflow/experimental/norms.py b/ivy/functional/backends/tensorflow/experimental/norms.py index 91a6f46ad4259..3c9c878c8fa60 100644 --- a/ivy/functional/backends/tensorflow/experimental/norms.py +++ b/ivy/functional/backends/tensorflow/experimental/norms.py @@ -5,7 +5,7 @@ import math -@with_unsupported_dtypes({"2.14.0 and below": "uint8"}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": "uint8"}, backend_version) def l1_normalize( x: Union[tf.Tensor, tf.Variable], /, @@ -30,7 +30,7 @@ def l2_normalize( return tf.math.divide(x, denorm) -@with_supported_dtypes({"2.14.0 and below": ("float32", "float16")}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float32", "float16")}, backend_version) def local_response_norm( x: Union[tf.Tensor, tf.Variable], size, @@ -66,7 +66,7 @@ def local_response_norm( local_response_norm.partial_mixed_handler = lambda x, size, **kwargs: size % 2 != 0 -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def batch_norm( x: Union[tf.Tensor, tf.Variable], mean: Union[tf.Tensor, tf.Variable], diff --git a/ivy/functional/backends/tensorflow/experimental/random.py b/ivy/functional/backends/tensorflow/experimental/random.py index edb1a93721246..c2742785656e3 100644 --- a/ivy/functional/backends/tensorflow/experimental/random.py +++ b/ivy/functional/backends/tensorflow/experimental/random.py @@ -15,7 +15,7 @@ # dirichlet @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "blfoat16", "float16", ) @@ -65,7 +65,7 @@ def gamma( # TODO: Implement purely in tensorflow -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def poisson( lam: Union[float, tf.Tensor, tf.Variable], *, diff --git a/ivy/functional/backends/tensorflow/experimental/searching.py b/ivy/functional/backends/tensorflow/experimental/searching.py index 7fe85411390f1..9c979c1b386da 100644 --- a/ivy/functional/backends/tensorflow/experimental/searching.py +++ b/ivy/functional/backends/tensorflow/experimental/searching.py @@ -9,7 +9,7 @@ @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "int32", "int64", ) diff --git a/ivy/functional/backends/tensorflow/experimental/statistical.py b/ivy/functional/backends/tensorflow/experimental/statistical.py index 8bc2357b31b39..1febdbbf918a2 100644 --- a/ivy/functional/backends/tensorflow/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/experimental/statistical.py @@ -34,7 +34,7 @@ def histogram( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float", "complex", ) @@ -275,7 +275,7 @@ def nanmedian( @with_supported_device_and_dtypes( { - "2.14.0 and below": { + "2.15.0 and below": { "cpu": ( "int64", "int32", @@ -310,7 +310,7 @@ def bincount( @with_supported_device_and_dtypes( { - "2.14.0 and below": { + "2.15.0 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -323,7 +323,7 @@ def igamma( return tf.math.igamma(a, x) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def cov( x1: tf.Tensor, x2: tf.Tensor = None, @@ -426,7 +426,7 @@ def cov( @with_unsupported_dtypes( - {"2.14.0 and below": ("bool",)}, + {"2.15.0 and below": ("bool",)}, backend_version, ) def cummax( @@ -555,7 +555,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "complex")}, + {"2.15.0 and below": ("bfloat16", "complex")}, backend_version, ) def cummin( diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 3fa251d958b35..7a018f41c9197 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -345,7 +345,7 @@ def scatter_flat( scatter_flat.support_native_out = True -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def scatter_nd( indices: Union[tf.Tensor, tf.Variable], updates: Union[tf.Tensor, tf.Variable], @@ -505,7 +505,7 @@ def _vmap(*args, **kwargs): return _vmap -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def isin( elements: tf.Tensor, test_elements: tf.Tensor, diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 231de76d91c98..0e7dcfb2bee8d 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -92,7 +92,7 @@ def _transpose_out_pad( return out_shape, padding -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def conv1d( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], @@ -123,7 +123,7 @@ def conv1d( return res -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def conv1d_transpose( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], @@ -219,7 +219,7 @@ def conv2d( return res -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def conv2d_transpose( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], @@ -263,7 +263,7 @@ def conv2d_transpose( return res -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def depthwise_conv2d( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], @@ -292,7 +292,7 @@ def depthwise_conv2d( return res -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def conv3d( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], @@ -324,7 +324,7 @@ def conv3d( return res -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def conv3d_transpose( x: Tensor, filters: Tensor, @@ -363,7 +363,7 @@ def conv3d_transpose( return res -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def conv_general_dilated( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], @@ -474,7 +474,7 @@ def conv_general_dilated( return res -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "complex")}, backend_version) def conv_general_transpose( x: Union[tf.Tensor, tf.Variable], filters: Union[tf.Tensor, tf.Variable], diff --git a/ivy/functional/backends/tensorflow/linear_algebra.py b/ivy/functional/backends/tensorflow/linear_algebra.py index 10bf64c766fba..f6b412c9cb190 100644 --- a/ivy/functional/backends/tensorflow/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/linear_algebra.py @@ -17,7 +17,7 @@ # -------------------# -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def cholesky( x: Union[tf.Tensor, tf.Variable], /, @@ -35,7 +35,7 @@ def cholesky( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "complex", "float16", ) @@ -61,7 +61,7 @@ def cross( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bfloat16", ) @@ -77,7 +77,7 @@ def det( return tf.linalg.det(x) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def diagonal( x: Union[tf.Tensor, tf.Variable], /, @@ -90,7 +90,7 @@ def diagonal( return tf.experimental.numpy.diagonal(x, offset, axis1=axis1, axis2=axis2) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def eig( x: Union[tf.Tensor, tf.Variable], /, @@ -108,7 +108,7 @@ def eig( return result_tuple(eigenvalues, eigenvectors) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def eigh( x: Union[tf.Tensor, tf.Variable], /, @@ -135,7 +135,7 @@ def eigh( return result_tuple(eigenvalues, eigenvectors) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def eigvalsh( x: Union[tf.Tensor, tf.Variable], /, @@ -156,7 +156,7 @@ def eigvalsh( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "int8", "uint8", "int16", @@ -182,7 +182,7 @@ def inner( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bfloat16", ) @@ -200,7 +200,7 @@ def inv( @with_unsupported_dtypes( - {"2.14.0 and below": ("float16", "bfloat16", "bool")}, backend_version + {"2.15.0 and below": ("float16", "bfloat16", "bool")}, backend_version ) def matmul( x1: Union[tf.Tensor, tf.Variable], @@ -279,7 +279,7 @@ def matmul( @with_supported_dtypes( - {"2.14.0 and below": ("float32", "float64", "complex")}, backend_version + {"2.15.0 and below": ("float32", "float64", "complex")}, backend_version ) def matrix_norm( x: Union[tf.Tensor, tf.Variable], @@ -323,7 +323,7 @@ def matrix_norm( return ret -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def matrix_power( x: Union[tf.Tensor, tf.Variable], n: int, @@ -356,7 +356,7 @@ def matrix_power( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "complex")}, + {"2.15.0 and below": ("bfloat16", "float16", "complex")}, backend_version, ) # noinspection PyPep8Naming @@ -394,7 +394,7 @@ def matrix_rank( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "int8", "int16", @@ -421,7 +421,7 @@ def matrix_transpose( # noinspection PyUnusedLocal,PyShadowingBuiltins -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def outer( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -434,7 +434,7 @@ def outer( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "complex")}, + {"2.15.0 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def pinv( @@ -452,7 +452,7 @@ def pinv( return ret -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def qr( x: Union[tf.Tensor, tf.Variable], /, @@ -477,7 +477,7 @@ def qr( return ret -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def slogdet( x: Union[tf.Tensor, tf.Variable], /, @@ -488,7 +488,7 @@ def slogdet( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "complex")}, + {"2.15.0 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def solve( @@ -531,7 +531,7 @@ def solve( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "complex")}, + {"2.15.0 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svd( @@ -559,7 +559,7 @@ def svd( return results(D) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def svdvals( x: Union[tf.Tensor, tf.Variable], /, @@ -572,7 +572,7 @@ def svdvals( return ret -@with_supported_dtypes({"2.14.0 and below": ("float32",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float32",)}, backend_version) def tensordot( x1: Union[tf.Tensor, tf.Variable], x2: Union[tf.Tensor, tf.Variable], @@ -587,7 +587,7 @@ def tensordot( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "complex")}, + {"2.15.0 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def trace( @@ -606,7 +606,7 @@ def trace( @with_unsupported_dtypes( - {"2.14.0 and below": ("int16", "int8", "bool", "unsigned")}, backend_version + {"2.15.0 and below": ("int16", "int8", "bool", "unsigned")}, backend_version ) def vecdot( x1: Union[tf.Tensor, tf.Variable], @@ -622,7 +622,7 @@ def vecdot( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bfloat16", "integer", @@ -657,7 +657,7 @@ def vector_norm( # ----- # -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def diag( x: Union[tf.Tensor, tf.Variable], /, @@ -669,7 +669,7 @@ def diag( @with_unsupported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "complex", "unsigned")}, + {"2.15.0 and below": ("bfloat16", "float16", "complex", "unsigned")}, backend_version, ) def vander( @@ -685,7 +685,7 @@ def vander( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "int8", "int16", "int32", diff --git a/ivy/functional/backends/tensorflow/manipulation.py b/ivy/functional/backends/tensorflow/manipulation.py index c03e976a84cad..9ef86b5bc16bb 100644 --- a/ivy/functional/backends/tensorflow/manipulation.py +++ b/ivy/functional/backends/tensorflow/manipulation.py @@ -105,7 +105,7 @@ def permute_dims( return tf.transpose(x, perm=axes) -@with_unsupported_dtypes({"2.14.0 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool",)}, backend_version) def reshape( x: Union[tf.Tensor, tf.Variable], /, @@ -185,7 +185,7 @@ def squeeze( return ret -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def stack( arrays: Union[Tuple[tf.Tensor], List[tf.Tensor]], /, @@ -252,7 +252,7 @@ def repeat( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "uint8", "uint16", "uint32", @@ -323,7 +323,7 @@ def swapaxes( return tf.transpose(x, config) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def clip( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/tensorflow/random.py b/ivy/functional/backends/tensorflow/random.py index c9579e3ff19f5..8488efc1b1d9f 100644 --- a/ivy/functional/backends/tensorflow/random.py +++ b/ivy/functional/backends/tensorflow/random.py @@ -27,7 +27,7 @@ @with_supported_dtypes( - {"2.14.0 and below": ("float", "int32", "int64")}, backend_version + {"2.15.0 and below": ("float", "int32", "int64")}, backend_version ) def random_uniform( *, @@ -66,7 +66,7 @@ def random_normal( return tf.random.normal(shape, mean, std, dtype=dtype, seed=seed) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/tensorflow/searching.py b/ivy/functional/backends/tensorflow/searching.py index b9abffbee4076..660576fe75bb2 100644 --- a/ivy/functional/backends/tensorflow/searching.py +++ b/ivy/functional/backends/tensorflow/searching.py @@ -12,7 +12,7 @@ # ------------------ # -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def argmax( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/tensorflow/set.py b/ivy/functional/backends/tensorflow/set.py index eb901c8a76631..a4979773ddf4a 100644 --- a/ivy/functional/backends/tensorflow/set.py +++ b/ivy/functional/backends/tensorflow/set.py @@ -6,7 +6,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def unique_all( x: Union[tf.Tensor, tf.Variable], /, @@ -78,7 +78,7 @@ def unique_all( ) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def unique_counts( x: Union[tf.Tensor, tf.Variable], /, @@ -90,7 +90,7 @@ def unique_counts( return Results(v, c) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def unique_inverse( x: Union[tf.Tensor, tf.Variable], /, @@ -113,7 +113,7 @@ def unique_inverse( return Results(values, inverse_indices) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def unique_values( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/tensorflow/sorting.py b/ivy/functional/backends/tensorflow/sorting.py index efaf951cdc61c..ee2b1d3ca997d 100644 --- a/ivy/functional/backends/tensorflow/sorting.py +++ b/ivy/functional/backends/tensorflow/sorting.py @@ -8,7 +8,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.14.0 and below": ("complex", "bool")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def argsort( x: Union[tf.Tensor, tf.Variable], /, @@ -24,7 +24,7 @@ def argsort( return tf.cast(ret, dtype=tf.int64) -@with_unsupported_dtypes({"2.14.0 and below": ("complex", "bool")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def sort( x: Union[tf.Tensor, tf.Variable], /, @@ -43,7 +43,7 @@ def sort( # msort -@with_unsupported_dtypes({"2.14.0 and below": ("complex", "bool")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def msort( a: Union[tf.Tensor, tf.Variable, list, tuple], /, @@ -53,7 +53,7 @@ def msort( return tf.sort(a, axis=0) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def searchsorted( x: Union[tf.Tensor, tf.Variable], v: Union[tf.Tensor, tf.Variable], diff --git a/ivy/functional/backends/tensorflow/statistical.py b/ivy/functional/backends/tensorflow/statistical.py index 938f21c1834be..5fe0d43121805 100644 --- a/ivy/functional/backends/tensorflow/statistical.py +++ b/ivy/functional/backends/tensorflow/statistical.py @@ -12,7 +12,7 @@ # -------------------# -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def min( x: Union[tf.Tensor, tf.Variable], /, @@ -51,7 +51,7 @@ def max( return tf.math.reduce_max(x, axis=axis, keepdims=keepdims) -@with_unsupported_dtypes({"2.14.0 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bool",)}, backend_version) def mean( x: Union[tf.Tensor, tf.Variable], /, @@ -163,7 +163,7 @@ def var( # ------# -@with_unsupported_dtypes({"2.14.0 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": "bfloat16"}, backend_version) def cumprod( x: Union[tf.Tensor, tf.Variable], /, @@ -208,7 +208,7 @@ def cumsum( @with_unsupported_dtypes( - {"2.14.0 and below": ("unsigned", "int8", "int16")}, + {"2.15.0 and below": ("unsigned", "int8", "int16")}, backend_version, ) def einsum( diff --git a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py index 85b10db40b9ad..ef672977bb4d2 100644 --- a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py +++ b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py @@ -81,7 +81,7 @@ def bernoulli( # dirichlet @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "blfoat16", "float16", ) diff --git a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py index 4b73e332dc85b..50b592d5d9587 100644 --- a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py @@ -75,7 +75,7 @@ def histogram( @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float", "complex", ) diff --git a/ivy/functional/backends/torch/experimental/losses.py b/ivy/functional/backends/torch/experimental/losses.py index 2a0edce437b2d..e5b227a01f55d 100644 --- a/ivy/functional/backends/torch/experimental/losses.py +++ b/ivy/functional/backends/torch/experimental/losses.py @@ -124,7 +124,7 @@ def kl_div( @with_supported_device_and_dtypes( { - "2.14.0 and below": { + "2.15.0 and below": { "cpu": ( "float32", "float64", diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 9ac07666a8ed0..74b5c3b1c4b17 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -3,7 +3,7 @@ versions = { "torch": "2.1.1", - "tensorflow": "2.14.0", + "tensorflow": "2.15.0", "numpy": "1.25.2", "jax": "0.4.14", "scipy": "1.10.1", diff --git a/ivy/functional/frontends/jax/numpy/dtype.py b/ivy/functional/frontends/jax/numpy/dtype.py index 8a7a1d39e5f46..081a3c468e272 100644 --- a/ivy/functional/frontends/jax/numpy/dtype.py +++ b/ivy/functional/frontends/jax/numpy/dtype.py @@ -73,7 +73,7 @@ def can_cast(from_, to, casting="safe"): @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64")}, + {"2.15.0 and below": ("float16", "float32", "float64")}, "jax", ) @to_ivy_arrays_and_back @@ -82,7 +82,7 @@ def finfo(dtype): @with_supported_dtypes( - {"2.14.0 and below": ("integer",)}, + {"2.15.0 and below": ("integer",)}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/tensorflow/compat/v1/nn.py b/ivy/functional/frontends/tensorflow/compat/v1/nn.py index d1cfcd3c5d3d9..c3095a040d0fb 100644 --- a/ivy/functional/frontends/tensorflow/compat/v1/nn.py +++ b/ivy/functional/frontends/tensorflow/compat/v1/nn.py @@ -5,7 +5,7 @@ import ivy.functional.frontends.tensorflow.nn as tf_nn -@with_unsupported_dtypes({"2.14.0 and below": ("float16",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16",)}, "tensorflow") def depthwise_conv2d( input, filter, @@ -30,7 +30,7 @@ def depthwise_conv2d( # should have float16 as well but sqrt doesn't support it @to_ivy_arrays_and_back -@with_supported_dtypes({"2.14.0 and below": ("float32",)}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32",)}, "tensorflow") def fused_batch_norm( x, scale, @@ -105,7 +105,7 @@ def fused_batch_norm( @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.14.0 and below": ("float16",)}, + {"2.15.0 and below": ("float16",)}, "tensorflow", ) def max_pool(value, ksize, strides, padding, data_format="NHWC", name=None, input=None): @@ -124,7 +124,7 @@ def max_pool(value, ksize, strides, padding, data_format="NHWC", name=None, inpu @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/frontends/tensorflow/general_functions.py b/ivy/functional/frontends/tensorflow/general_functions.py index 6307a35369870..065a69852ed83 100644 --- a/ivy/functional/frontends/tensorflow/general_functions.py +++ b/ivy/functional/frontends/tensorflow/general_functions.py @@ -62,7 +62,7 @@ def boolean_mask(tensor, mask, axis=None, name=None): return ivy.get_item(tensor, mask) -@with_supported_dtypes({"2.14.0 and below": ("float32",)}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32",)}, "tensorflow") @to_ivy_arrays_and_back def clip_by_global_norm(t_list, clip_norm, use_norm=None): if use_norm is not None: @@ -76,7 +76,7 @@ def clip_by_global_norm(t_list, clip_norm, use_norm=None): ], global_norm -@with_supported_dtypes({"2.14.0 and below": ("float", "complex")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float", "complex")}, "tensorflow") @to_ivy_arrays_and_back def clip_by_norm(t, clip_norm, axes=None): t, clip_norm = check_tensorflow_casting(t, clip_norm) @@ -95,7 +95,7 @@ def clip_by_norm(t, clip_norm, axes=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.14.0 and below": ("float16",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16",)}, "tensorflow") def clip_by_value(t, clip_value_min, clip_value_max): ivy.utils.assertions.check_all_or_any_fn( clip_value_min, @@ -170,7 +170,7 @@ def expand_dims(input, axis, name=None): return ivy.expand_dims(input, axis=axis) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") @handle_tf_dtype @to_ivy_arrays_and_back def eye(num_rows, num_columns=None, batch_shape=None, dtype=ivy.float32, name=None): @@ -299,7 +299,7 @@ def no_op(name=None): return -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, "tensorflow") @to_ivy_arrays_and_back def norm(tensor, ord="euclidean", axis=None, keepdims=None, name=None): return tf_frontend.linalg.norm( @@ -321,7 +321,7 @@ def one_hot( return ivy.one_hot(indices, depth) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") @handle_tf_dtype @to_ivy_arrays_and_back def ones(shape, dtype=ivy.float32, name=None): @@ -340,7 +340,7 @@ def pad(tensor, paddings, mode="CONSTANT", constant_values=0, name=None): return ivy.pad(tensor, paddings, mode=mode.lower(), constant_values=constant_values) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") @handle_tf_dtype @to_ivy_arrays_and_back def range(start, limit=None, delta=1, dtype=None, name=None): @@ -352,7 +352,7 @@ def rank(input, **kwargs): return ivy.astype(ivy.array(input.ndim), ivy.int32) -@with_unsupported_dtypes({"2.14.0 and below": ("unsigned", "integer")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("unsigned", "integer")}, "tensorflow") @to_ivy_arrays_and_back def realdiv(x, y, name=None): x, y = check_tensorflow_casting(x, y) @@ -410,7 +410,7 @@ def searchsorted(sorted_sequence, values, side="left", out_type="int32"): @with_supported_dtypes( - {"2.14.0 and below": ("int8", "int16", "int32", "int64")}, "tensorflow" + {"2.15.0 and below": ("int8", "int16", "int32", "int64")}, "tensorflow" ) @to_ivy_arrays_and_back def sequence_mask(lengths, maxlen=None, dtype=ivy.bool, name=None): @@ -483,7 +483,7 @@ def sort(values, axis=-1, direction="ASCENDING", name=None): @with_unsupported_dtypes( - {"2.14.0 and below": ("uint8", "uint16", "uint32", "uint64", "int16")}, "tensorflow" + {"2.15.0 and below": ("uint8", "uint16", "uint32", "uint64", "int16")}, "tensorflow" ) @to_ivy_arrays_and_back def split(value, num_or_size_splits, axis=0, num=None, name=None): @@ -620,7 +620,7 @@ def tensor_scatter_nd_add(tensor, indices, updates, name=None): return ivy.add(tensor, scatter_tensor) -@with_unsupported_dtypes({"2.14.0 and below": ("uint16",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("uint16",)}, "tensorflow") @to_ivy_arrays_and_back def tile(input, multiples, name=None): return ivy.tile(input, multiples) @@ -636,14 +636,14 @@ def transpose(a, perm=None, conjugate=False, name="transpose"): return ivy.permute_dims(a, axes=perm) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") @to_ivy_arrays_and_back def truncatediv(x, y, name=None): return x.trunc_divide(y) @with_unsupported_dtypes( - {"2.14.0 and below": ("int16", "int8", "uint8", " uint16")}, "tensorflow" + {"2.15.0 and below": ("int16", "int8", "uint8", " uint16")}, "tensorflow" ) @to_ivy_arrays_and_back def truncatemod(x, y): @@ -704,7 +704,7 @@ def unravel_index(indices, dims, out=None, name=None): return ivy.unravel_index(indices, dims, out=out) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") @to_ivy_arrays_and_back def unstack(value: ivy.Array, axis=0, num=None, name=None): return ivy.unstack(value, axis=axis) @@ -739,7 +739,7 @@ def zeros(shape, dtype=ivy.float32, name=None): return ivy.zeros(shape=shape, dtype=dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") @to_ivy_arrays_and_back def zeros_initializer(shape, dtype=None, name=None): # todo internal: fix behaviour diff --git a/ivy/functional/frontends/tensorflow/image/cropping.py b/ivy/functional/frontends/tensorflow/image/cropping.py index f7d71422bfc45..daa01cf49d44f 100644 --- a/ivy/functional/frontends/tensorflow/image/cropping.py +++ b/ivy/functional/frontends/tensorflow/image/cropping.py @@ -7,7 +7,7 @@ from ivy.func_wrapper import with_supported_dtypes -@with_supported_dtypes({"2.14.0 and below": ("float",)}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float",)}, "tensorflow") @to_ivy_arrays_and_back def extract_patches(images, sizes, strides, rates, padding): depth = images.shape[-1] diff --git a/ivy/functional/frontends/tensorflow/keras/activations.py b/ivy/functional/frontends/tensorflow/keras/activations.py index 5ee4693e3977f..9abc0a84825ad 100644 --- a/ivy/functional/frontends/tensorflow/keras/activations.py +++ b/ivy/functional/frontends/tensorflow/keras/activations.py @@ -17,7 +17,7 @@ @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64")}, + {"2.15.0 and below": ("float16", "float32", "float64")}, "tensorflow", ) def deserialize(name, custom_objects=None): @@ -47,7 +47,7 @@ def deserialize(name, custom_objects=None): @with_supported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "float32", "float64")}, + {"2.15.0 and below": ("bfloat16", "float16", "float32", "float64")}, "tensorflow", ) @to_ivy_arrays_and_back @@ -103,7 +103,7 @@ def relu(x, alpha=0.0, max_value=None, threshold=0.0): @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64")}, + {"2.15.0 and below": ("float16", "float32", "float64")}, "tensorflow", ) @to_ivy_arrays_and_back @@ -112,7 +112,7 @@ def selu(x): @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64")}, + {"2.15.0 and below": ("float16", "float32", "float64")}, "tensorflow", ) def serialize(activation, use_legacy_format=False, custom_objects=None): diff --git a/ivy/functional/frontends/tensorflow/linalg.py b/ivy/functional/frontends/tensorflow/linalg.py index fdbe33455fb1c..b0e8bdfdc7c5f 100644 --- a/ivy/functional/frontends/tensorflow/linalg.py +++ b/ivy/functional/frontends/tensorflow/linalg.py @@ -38,7 +38,7 @@ def symmetrize(input): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") def cholesky_solve(chol, rhs, name=None): chol, rhs = check_tensorflow_casting(chol, rhs) y = ivy.solve(chol, rhs) @@ -107,7 +107,7 @@ def eigh(tensor, name=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.14.0 and below": ("float32", "float64", "complex64", "complex128")}, + {"2.15.0 and below": ("float32", "float64", "complex64", "complex128")}, "tensorflow", ) def eigvals(tensor, name=None): @@ -130,12 +130,12 @@ def expm(input, name=None): @handle_tf_dtype @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") def eye(num_rows, num_columns=None, batch_shape=None, dtype=ivy.float32, name=None): return ivy.eye(num_rows, num_columns, batch_shape=batch_shape, dtype=dtype) -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, "tensorflow") @to_ivy_arrays_and_back def global_norm(t_list, name=None): l2_norms = [ivy.sqrt(ivy.sum(ivy.square(t))) ** 2 for t in t_list if t is not None] @@ -145,7 +145,7 @@ def global_norm(t_list, name=None): @to_ivy_arrays_and_back @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float32", "float64", "complex64", @@ -159,7 +159,7 @@ def inv(input, adjoint=False, name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, "tensorflow") def l2_normalize(x, axis=None, epsilon=1e-12, name=None): square_sum = ivy.sum(ivy.square(x), axis=axis, keepdims=True) x_inv_norm = ivy.reciprocal(ivy.sqrt(ivy.maximum(square_sum, epsilon))) @@ -168,7 +168,7 @@ def l2_normalize(x, axis=None, epsilon=1e-12, name=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64", "complex64", "complex128")}, + {"2.15.0 and below": ("float16", "float32", "float64", "complex64", "complex128")}, "tensorflow", ) def logdet(matrix, name=None): @@ -185,7 +185,7 @@ def lu_matrix_inverse(lower_upper, perm, validate_args=False, name=None): @to_ivy_arrays_and_back @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "float32", "float64", @@ -244,7 +244,7 @@ def matrix_transpose(a, name="matrix_transpose", conjugate=False): return ivy.matrix_transpose(a) -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, "tensorflow") @to_ivy_arrays_and_back def norm(tensor, ord="euclidean", axis=None, keepdims=None, name=None): keepdims = keepdims or False @@ -257,7 +257,7 @@ def norm(tensor, ord="euclidean", axis=None, keepdims=None, name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, "tensorflow") def normalize(tensor, ord="euclidean", axis=None, name=None): tensor = tf_frontend.convert_to_tensor( tensor, dtype=ivy.dtype(tensor), dtype_hint="Any" @@ -280,7 +280,7 @@ def qr(input, /, *, full_matrices=False, name=None): @to_ivy_arrays_and_back @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bfloat16", "half", "float32", @@ -350,7 +350,7 @@ def slogdet(input, name=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") def solve(matrix, rhs, /, *, adjoint=False, name=None): matrix, rhs = check_tensorflow_casting(matrix, rhs) return ivy.solve(matrix, rhs, adjoint=adjoint) @@ -364,7 +364,7 @@ def svd(a, /, *, full_matrices=False, compute_uv=True, name=None): @to_ivy_arrays_and_back @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bfloat16", "half", "float32", @@ -388,7 +388,7 @@ def tensor_diag(diagonal, /, *, name=None): @to_ivy_arrays_and_back @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float32", "float64", "int32", @@ -424,7 +424,7 @@ def tensor_diag_part(input, name=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.14.0 and below": ("float32", "float64", "int32")}, "tensorflow" + {"2.15.0 and below": ("float32", "float64", "int32")}, "tensorflow" ) def tensordot(a, b, axes, name=None): a, b = check_tensorflow_casting(a, b) @@ -436,7 +436,7 @@ def tensordot(a, b, axes, name=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bfloat16", "int8", diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index 6519f0794502c..c3a56fa3ec55f 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -17,7 +17,7 @@ { "1.2.0": ("float16", "complex64", "complex128"), "1.8.0 and below": ("float16",), - "2.14.0 and below": ("int8", "int16", "uint8", "uint16", "uint32", "uint64"), + "2.15.0 and below": ("int8", "int16", "uint8", "uint16", "uint32", "uint64"), }, "tensorflow", ) @@ -105,7 +105,7 @@ def atanh(x, name="atanh"): @with_supported_dtypes( - {"2.14.0 and below": ("int32",)}, + {"2.15.0 and below": ("int32",)}, "tensorflow", ) @to_ivy_arrays_and_back @@ -297,7 +297,7 @@ def greater_equal(x, y, name=None): @with_supported_device_and_dtypes( { - "2.14.0 and below": { + "2.15.0 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -310,7 +310,7 @@ def igamma(a, x, name=None): @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64", "complex64", "complex128")}, + {"2.15.0 and below": ("float16", "float32", "float64", "complex64", "complex128")}, "tensorflow", ) @to_ivy_arrays_and_back @@ -326,7 +326,7 @@ def in_top_k(target, pred, k, name=None): @with_supported_dtypes( { - "2.14.0 and below": ("int32", "int64"), + "2.15.0 and below": ("int32", "int64"), }, "tensorflow", ) @@ -337,7 +337,7 @@ def invert_permutation(x, name=None): @with_supported_dtypes( { - "2.14.0 and below": ("bfloat16", "half", "float32", "float64"), + "2.15.0 and below": ("bfloat16", "half", "float32", "float64"), }, "tensorflow", ) @@ -375,7 +375,7 @@ def is_strictly_increasing(x, name="is_strictly_increasing"): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, "tensorflow") def l2_normalize(x, axis=None, epsilon=1e-12, name=None): square_sum = ivy.sum(ivy.square(x), axis=axis, keepdims=True) x_inv_norm = ivy.reciprocal(ivy.sqrt(ivy.maximum(square_sum, epsilon))) @@ -396,7 +396,7 @@ def less_equal(x, y, name="LessEqual"): # lgamma @to_ivy_arrays_and_back -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, "tensorflow") def lgamma(x, name=None): return ivy.lgamma(x) @@ -609,7 +609,7 @@ def reduce_variance(input_tensor, axis=None, keepdims=False, name="reduce_varian @with_supported_device_and_dtypes( { - "2.14.0 and below": { + "2.15.0 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -644,7 +644,7 @@ def sigmoid(x, name=None): @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bfloat16", "float16", "float32", @@ -676,7 +676,7 @@ def softplus(features, name=None): @with_supported_dtypes( - {"2.14.0 and below": ("bfloat32", "float32", "float64")}, "tensorflow" + {"2.15.0 and below": ("bfloat32", "float32", "float64")}, "tensorflow" ) @to_ivy_arrays_and_back def softsign(features, name=None): @@ -695,7 +695,7 @@ def square(x, name=None): @with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bfloat16", "float16", "float32", @@ -730,7 +730,7 @@ def tan(x, name=None): @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64", "complex64", "complex128")}, + {"2.15.0 and below": ("float16", "float32", "float64", "complex64", "complex128")}, "tensorflow", ) @to_ivy_arrays_and_back @@ -820,7 +820,7 @@ def unsorted_segment_sum(data, segment_ids, num_segments, name="unsorted_segment @with_supported_dtypes( - {"2.14.0 and below": ("float32", "float64", "complex64", "complex128")}, + {"2.15.0 and below": ("float32", "float64", "complex64", "complex128")}, "tensorflow", ) @to_ivy_arrays_and_back @@ -832,7 +832,7 @@ def xdivy(x, y, name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.14.0 and below": ("float32", "float64")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float64")}, "tensorflow") def xlog1py(x, y, name=None): x, y = check_tensorflow_casting(x, y) return x * ivy.log1p(y) @@ -855,7 +855,7 @@ def zero_fraction(value, name="zero_fraction"): @to_ivy_arrays_and_back @with_supported_dtypes( { - "2.14.0 and below": ("float32", "float64"), + "2.15.0 and below": ("float32", "float64"), }, "tensorflow", ) diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index f1c249217c7b2..4a226d7cdde67 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -221,7 +221,7 @@ def conv3d( ) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def conv3d_transpose( input, @@ -303,7 +303,7 @@ def ctc_unique_labels(labels, name=None): return unique_pad, ctc_labels[2] -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def depthwise_conv2d( input, @@ -347,13 +347,13 @@ def gelu(features, approximate=False, name=None): return ivy.gelu(features, approximate=approximate) -@with_unsupported_dtypes({"2.14.0 and below": "float16"}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": "float16"}, "tensorflow") @to_ivy_arrays_and_back def leaky_relu(features, alpha=0.2, name=None): return ivy.leaky_relu(features, alpha=alpha) -@with_supported_dtypes({"2.14.0 and below": ("float32", "float16")}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32", "float16")}, "tensorflow") @to_ivy_arrays_and_back def local_response_normalization( input, depth_radius=5, bias=1.0, alpha=1.0, beta=0.5, name=None @@ -378,7 +378,7 @@ def max_pool2d(input, ksize, strides, padding, data_format="NHWC", name=None): return ivy.max_pool2d(input, ksize, strides, padding, data_format=data_format) -@with_supported_dtypes({"2.14.0 and below": ("float32",)}, "tensorflow") +@with_supported_dtypes({"2.15.0 and below": ("float32",)}, "tensorflow") @to_ivy_arrays_and_back def max_pool3d(input, ksize, strides, padding, data_format="NDHWC", name=None): return ivy.max_pool3d(input, ksize, strides, padding, data_format=data_format) @@ -393,7 +393,7 @@ def moments(x, axes, shift=None, keepdims=False, name=None): @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "int8", "int16", "int32", @@ -442,19 +442,19 @@ def pool( ) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, "tensorflow") @to_ivy_arrays_and_back def relu(features, name=None): return ivy.relu(features) -@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, "tensorflow") @to_ivy_arrays_and_back def relu6(features, name=None): return ivy.relu6(features) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def separable_conv2d( input, @@ -481,7 +481,7 @@ def separable_conv2d( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "int8", "int16", "int32", @@ -508,7 +508,7 @@ def silu(features, beta: float = 1.0): return ivy.multiply(features, ivy.sigmoid(ivy.multiply(beta, features))) -@with_unsupported_dtypes({"2.14.0 and below": ("float16",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16",)}, "tensorflow") @to_ivy_arrays_and_back def softmax(logits, axis=None, name=None): return ivy.softmax(logits, axis=axis) @@ -517,7 +517,7 @@ def softmax(logits, axis=None, name=None): # Softsign @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "int8", "int16", "int32", @@ -568,7 +568,7 @@ def sufficient_statistics(x, axes, shift=None, keepdims=False, name=None): @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "int8", "int16", "int32", diff --git a/ivy/functional/frontends/tensorflow/random.py b/ivy/functional/frontends/tensorflow/random.py index 85b0dc873ec53..8ff688b630b8e 100644 --- a/ivy/functional/frontends/tensorflow/random.py +++ b/ivy/functional/frontends/tensorflow/random.py @@ -12,7 +12,7 @@ def gamma(shape, alpha, beta=None, dtype=ivy.float32, seed=None, name=None): @with_unsupported_dtypes( - {"2.14.0 and below": ("int8", "int16", "int32", "int64", "unsigned")}, "tensorflow" + {"2.15.0 and below": ("int8", "int16", "int32", "int64", "unsigned")}, "tensorflow" ) @to_ivy_arrays_and_back def normal(shape, mean=0.0, stddev=1.0, dtype=ivy.float32, seed=None, name=None): @@ -20,7 +20,7 @@ def normal(shape, mean=0.0, stddev=1.0, dtype=ivy.float32, seed=None, name=None) @with_unsupported_dtypes( - {"2.14.0 and below": ("int8", "int16", "unsigned")}, "tensorflow" + {"2.15.0 and below": ("int8", "int16", "unsigned")}, "tensorflow" ) @to_ivy_arrays_and_back @handle_tf_dtype @@ -34,7 +34,7 @@ def poisson(shape, lam, dtype=ivy.float32, seed=None, name=None): # implement random shuffle @with_unsupported_dtypes( - {"2.14.0 and below": ("int8", "int16", "in32", "int64", "unsigned")}, "tensorflow" + {"2.15.0 and below": ("int8", "int16", "in32", "int64", "unsigned")}, "tensorflow" ) @to_ivy_arrays_and_back def shuffle(value, seed=None, name=None): @@ -42,7 +42,7 @@ def shuffle(value, seed=None, name=None): @with_unsupported_dtypes( - {"2.14.0 and below": ("int8", "int16", "unsigned")}, "tensorflow" + {"2.15.0 and below": ("int8", "int16", "unsigned")}, "tensorflow" ) @to_ivy_arrays_and_back def stateless_normal( @@ -54,7 +54,7 @@ def stateless_normal( @with_unsupported_dtypes( - {"2.14.0 and below": ("int8", "int16", "unsigned")}, "tensorflow" + {"2.15.0 and below": ("int8", "int16", "unsigned")}, "tensorflow" ) @to_ivy_arrays_and_back def stateless_poisson(shape, seed, lam, dtype=ivy.int32, name=None): @@ -71,7 +71,7 @@ def stateless_uniform( @with_unsupported_dtypes( - {"2.14.0 and below": ("int8", "int16", "unsigned")}, "tensorflow" + {"2.15.0 and below": ("int8", "int16", "unsigned")}, "tensorflow" ) @to_ivy_arrays_and_back def uniform(shape, minval=0, maxval=None, dtype=ivy.float32, seed=None, name=None): diff --git a/ivy/functional/frontends/tensorflow/raw_ops.py b/ivy/functional/frontends/tensorflow/raw_ops.py index 311fafa4c203a..030e2be87b6fc 100644 --- a/ivy/functional/frontends/tensorflow/raw_ops.py +++ b/ivy/functional/frontends/tensorflow/raw_ops.py @@ -18,7 +18,7 @@ AddV2 = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.add)) ArgMax = to_ivy_arrays_and_back( with_unsupported_dtypes( - {"2.14.0 and below": ("complex",)}, + {"2.15.0 and below": ("complex",)}, "tensorflow", )( map_raw_ops_alias( @@ -28,7 +28,7 @@ ) ArgMin = to_ivy_arrays_and_back( with_unsupported_dtypes( - {"2.14.0 and below": ("complex",)}, + {"2.15.0 and below": ("complex",)}, "tensorflow", )( map_raw_ops_alias( @@ -40,7 +40,7 @@ Atan = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.atan)) Atan2 = to_ivy_arrays_and_back( with_unsupported_dtypes( - {"2.14.0 and below": "float16"}, + {"2.15.0 and below": "float16"}, "tensorflow", )(map_raw_ops_alias(tf_frontend.math.atan2)) ) @@ -69,7 +69,7 @@ Einsum = to_ivy_arrays_and_back( with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bfloat16", "complex128 ", "complex64", @@ -92,7 +92,7 @@ Igamma = to_ivy_arrays_and_back( with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float64", "float32", "half", @@ -104,7 +104,7 @@ LeakyRelu = to_ivy_arrays_and_back( with_supported_dtypes( { - "2.14.0 and below": ("bfloat16", "float16", "float32", "float64"), + "2.15.0 and below": ("bfloat16", "float16", "float32", "float64"), }, "tensorflow", )( @@ -116,7 +116,7 @@ LessEqual = to_ivy_arrays_and_back( with_unsupported_dtypes( { - "2.14.0 and below": ("complex",), + "2.15.0 and below": ("complex",), }, "tensorflow", )(map_raw_ops_alias(tf_frontend.math.less_equal)) @@ -125,7 +125,7 @@ LogSoftmax = to_ivy_arrays_and_back( with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "bfloat16", "float32", "float64", @@ -139,7 +139,7 @@ Max = to_ivy_arrays_and_back( with_unsupported_dtypes( { - "2.14.0 and below": ("complex",), + "2.15.0 and below": ("complex",), }, "tensorflow", )( @@ -155,7 +155,7 @@ MaxPool3D = to_ivy_arrays_and_back( with_supported_dtypes( { - "2.14.0 and below": ("float32",), + "2.15.0 and below": ("float32",), }, "tensorflow", )( @@ -167,7 +167,7 @@ Maximum = to_ivy_arrays_and_back( with_unsupported_dtypes( { - "2.14.0 and below": ("complex",), + "2.15.0 and below": ("complex",), }, "tensorflow", )(map_raw_ops_alias(tf_frontend.math.maximum)) @@ -184,7 +184,7 @@ Min = to_ivy_arrays_and_back( with_unsupported_dtypes( { - "2.14.0 and below": ("complex",), + "2.15.0 and below": ("complex",), }, "tensorflow", )( @@ -204,7 +204,7 @@ RealDiv = to_ivy_arrays_and_back( with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "complex", "bfloat16", "float16", @@ -219,7 +219,7 @@ Relu = to_ivy_arrays_and_back( with_unsupported_dtypes( { - "2.14.0 and below": ("complex", "float16"), + "2.15.0 and below": ("complex", "float16"), }, "tensorflow", )(map_raw_ops_alias(tf_frontend.nn.relu)) @@ -227,7 +227,7 @@ Relu6 = to_ivy_arrays_and_back( with_unsupported_dtypes( { - "2.14.0 and below": ("complex", "float16"), + "2.15.0 and below": ("complex", "float16"), }, "tensorflow", )( @@ -251,7 +251,7 @@ Softmax = to_ivy_arrays_and_back( with_unsupported_dtypes( { - "2.14.0 and below": ("float16",), + "2.15.0 and below": ("float16",), }, "tensorflow", )(map_raw_ops_alias(tf_frontend.nn.softmax)) @@ -264,7 +264,7 @@ SquaredDifference = to_ivy_arrays_and_back( with_supported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "complex", "bfloat16", "float16", @@ -287,7 +287,7 @@ Zeta = to_ivy_arrays_and_back( with_supported_dtypes( { - "2.14.0 and below": ("float32", "float64"), + "2.15.0 and below": ("float32", "float64"), }, "tensorflow", )(map_raw_ops_alias(tf_frontend.math.zeta)) @@ -342,7 +342,7 @@ def Angle( @with_unsupported_dtypes( { - "2.14.0 and below": ( + "2.15.0 and below": ( "float16", "bool", "bfloat16", @@ -526,7 +526,7 @@ def Diag(*, diagonal, name="Diag"): @with_supported_dtypes( - {"2.14.0 and below": ("bfloat16", "float16", "float32", "float64")}, + {"2.15.0 and below": ("bfloat16", "float16", "float32", "float64")}, "tensorflow", ) @to_ivy_arrays_and_back @@ -775,7 +775,7 @@ def Shape(*, input, output_type=ivy.int32, name="Shape"): @with_unsupported_dtypes( - {"2.14.0 and below": ("unsigned",)}, + {"2.15.0 and below": ("unsigned",)}, "tensorflow", ) @to_ivy_arrays_and_back @@ -820,7 +820,7 @@ def Sum(*, input, axis, keep_dims=False, name="Sum"): @with_supported_dtypes( - {"2.14.0 and below": ("float64", "float128", "halfcomplex64", "complex128")}, + {"2.15.0 and below": ("float64", "float128", "halfcomplex64", "complex128")}, "tensorflow", ) @to_ivy_arrays_and_back @@ -844,7 +844,7 @@ def TruncateDiv(*, x, y, name="TruncateDiv"): return ivy.astype(ivy.trunc_divide(x, y), x.dtype) -@with_unsupported_dtypes({"2.14.0 and below": ("float16", "bfloat16")}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, "tensorflow") @to_ivy_arrays_and_back def Unpack(*, value, num, axis=0, name="Unpack"): return ivy.unstack(value, axis=axis)[:num] @@ -857,7 +857,7 @@ def Xdivy(*, x, y, name="Xdivy"): return ivy.divide(x, y) -@with_unsupported_dtypes({"2.14.0 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def Xlog1py(*, x, y, name="Xlog1py"): if (x == 0).all(): diff --git a/ivy/functional/frontends/tensorflow/signal.py b/ivy/functional/frontends/tensorflow/signal.py index 0daf1db8a70c3..b0d3374327ad5 100644 --- a/ivy/functional/frontends/tensorflow/signal.py +++ b/ivy/functional/frontends/tensorflow/signal.py @@ -29,7 +29,7 @@ def kaiser_bessel_derived_window( @with_supported_dtypes( - {"2.14.0 and below": ("float32", "float64", "float16", "bfloat16")}, + {"2.15.0 and below": ("float32", "float64", "float16", "bfloat16")}, "tensorflow", ) @handle_tf_dtype @@ -62,7 +62,7 @@ def stft( @with_supported_dtypes( - {"2.14.0 and below": ("float16", "float32", "float64", "bfloat16")}, + {"2.15.0 and below": ("float16", "float32", "float64", "bfloat16")}, "tensorflow", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/tensorflow/tensor.py b/ivy/functional/frontends/tensorflow/tensor.py index 517d842fbe2f5..e70c78c13e1a5 100644 --- a/ivy/functional/frontends/tensorflow/tensor.py +++ b/ivy/functional/frontends/tensorflow/tensor.py @@ -108,7 +108,7 @@ def __floordiv__(self, y, name="floordiv"): return tf_frontend.raw_ops.FloorDiv(x=self, y=y, name=name) @with_unsupported_dtypes( - {"2.14.0 and below": ("complex",)}, + {"2.15.0 and below": ("complex",)}, "tensorflow", ) def __ge__(self, y, name="ge"): @@ -120,7 +120,7 @@ def __getitem__(self, slice_spec, var=None, name="getitem"): return EagerTensor(ret) @with_unsupported_dtypes( - {"2.14.0 and below": ("complex",)}, + {"2.15.0 and below": ("complex",)}, "tensorflow", ) def __gt__(self, y, name="gt"): @@ -130,14 +130,14 @@ def __invert__(self, name="invert"): return tf_frontend.raw_ops.Invert(x=self, name=name) @with_unsupported_dtypes( - {"2.14.0 and below": ("complex",)}, + {"2.15.0 and below": ("complex",)}, "tensorflow", ) def __le__(self, y, name="le"): return tf_frontend.raw_ops.LessEqual(x=self, y=y, name=name) @with_unsupported_dtypes( - {"2.14.0 and below": ("complex",)}, + {"2.15.0 and below": ("complex",)}, "tensorflow", ) def __lt__(self, y, name="lt"): @@ -150,7 +150,7 @@ def __mul__(self, y, name="mul"): return tf_frontend.math.multiply(self, y, name=name) @with_unsupported_dtypes( - {"2.14.0 and below": ("complex",)}, + {"2.15.0 and below": ("complex",)}, "tensorflow", ) def __mod__(self, y, name="mod"): From 79d36a11b32f5766e71d9ac1e1b0cd3c4f277cf8 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Fri, 17 Nov 2023 12:09:56 +0000 Subject: [PATCH 201/978] chore: Add test for torch.Tensor.uniform_ and remove unnecessary comments --- .../frontends/torch/nn/parameter.py | 1 - ivy/functional/frontends/torch/tensor.py | 14 +++++- .../test_frontends/test_torch/test_tensor.py | 49 +++++++++++++++++++ 3 files changed, 61 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/parameter.py b/ivy/functional/frontends/torch/nn/parameter.py index 11f93bdf6e6cb..1d8dc9eda80b8 100644 --- a/ivy/functional/frontends/torch/nn/parameter.py +++ b/ivy/functional/frontends/torch/nn/parameter.py @@ -20,7 +20,6 @@ def __init__(self, data=None, device=None, requires_grad=True): self.grad_fn = None def __deepcopy__(self, memo): - # TODO: Need to add test. Adding for KLA demo (priority) if id(self) in memo: return memo[id(self)] else: diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index ca8a0705cb3e6..b271cea307089 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -45,7 +45,6 @@ def __repr__(self): ) def __hash__(self): - # TODO: Need to add test. Adding for KLA demo (priority) return id(self) # Properties # @@ -1995,8 +1994,19 @@ def random_( ) return self.ivy_array + @with_unsupported_dtypes( + { + "2.1.1 and below": ( + "integer", + "unsigned", + "bfloat16", + "bool", + "complex", + ) + }, + "torch", + ) def uniform_(self, from_=0, to=1, *, generator=None): - # TODO: Need to add test. Adding for KLA demo (priority) ret = ivy.random_uniform( low=from_, high=to, shape=self.shape, dtype=self.dtype, seed=generator ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 1a824bf209d64..a4b88c6137f96 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -13500,6 +13500,55 @@ def test_torch_unfold( ) +# uniform_ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="uniform_", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_value=1, + max_value=5, + min_num_dims=1, + max_num_dims=5, + ), + from_=helpers.floats(min_value=-1000, max_value=0), + to=helpers.floats(min_value=1, max_value=1000), + test_inplace=st.just(True), +) +def test_torch_uniform_( + dtype_and_x, + from_, + to, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + method_flags.num_positional_args = 3 + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "from_": from_, + "to": to, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + test_values=False, + ) + + # unique @handle_frontend_method( class_tree=CLASS_TREE, From 14ce3cede2ab1b8945f7bb3517334d77dd03202f Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Sat, 18 Nov 2023 06:59:38 +0000 Subject: [PATCH 202/978] feat: Paddle Frontend: tensor __or__ (#27316) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 16 ++++++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index c251044038bcb..7e0a2e8504c57 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -68,6 +68,22 @@ def ivy_array(self, array): def __add__(self, y, /, name=None): return paddle_frontend.add(self, y) + @with_supported_dtypes( + { + "2.5.2 and below": ( + "bool", + "uint8", + "int8", + "int16", + "int32", + "int64", + ) + }, + "paddle", + ) + def __or__(self, y, /, name=None): + return paddle_frontend.logic.bitwise_or(self, y) + def __getitem__(self, item): ivy_args = ivy.nested_map(_to_ivy_array, [self, item]) ret = ivy.get_item(*ivy_args) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 9e9979de0d4e6..e66bd677ff2d3 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -307,6 +307,43 @@ def test_paddle___add__( ) +# __or__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__or__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("integer"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___or__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __setitem__ @handle_frontend_method( class_tree=CLASS_TREE, From be33b8067b5a9926bbb5d27ce8d298d7666c641a Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Sat, 18 Nov 2023 12:39:06 +0000 Subject: [PATCH 203/978] feat: Paddle Frontend: tensor __le__ (#27313) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 16 ++++++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 7e0a2e8504c57..ee880dda5fc76 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -68,6 +68,22 @@ def ivy_array(self, array): def __add__(self, y, /, name=None): return paddle_frontend.add(self, y) + @with_unsupported_dtypes( + { + "2.5.2 and below": ( + "bool", + "uint8", + "int8", + "int16", + "complex64", + "complex128", + ) + }, + "paddle", + ) + def __le__(self, y, /, name=None): + return paddle_frontend.logic.less_equal(self, y) + @with_supported_dtypes( { "2.5.2 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index e66bd677ff2d3..a61d2e9ae7591 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -307,6 +307,43 @@ def test_paddle___add__( ) +# __le__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__le__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___le__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __or__ @handle_frontend_method( class_tree=CLASS_TREE, From ec5a2d1fa68c93ef5a4084945f076813ac8f96de Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Sat, 18 Nov 2023 16:29:12 +0000 Subject: [PATCH 204/978] feat: Paddle Frontend: tensor __ge__ (#27311) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 16 ++++++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index ee880dda5fc76..b84072c2da544 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -68,6 +68,22 @@ def ivy_array(self, array): def __add__(self, y, /, name=None): return paddle_frontend.add(self, y) + @with_unsupported_dtypes( + { + "2.5.2 and below": ( + "bool", + "uint8", + "int8", + "int16", + "complex64", + "complex128", + ) + }, + "paddle", + ) + def __ge__(self, y, /, name=None): + return paddle_frontend.logic.greater_equal(self, y) + @with_unsupported_dtypes( { "2.5.2 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index a61d2e9ae7591..d087dabccfb90 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -307,6 +307,43 @@ def test_paddle___add__( ) +# __ge__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__ge__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___ge__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __le__ @handle_frontend_method( class_tree=CLASS_TREE, From bd2b356e88682c37ce37fd1a8256a4b0a75d7cd7 Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Sat, 18 Nov 2023 17:38:21 +0000 Subject: [PATCH 205/978] feat: Paddle Frontend: tensor __gt__ (#27309) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 16 ++++++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index b84072c2da544..d417c77f760f9 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -68,6 +68,22 @@ def ivy_array(self, array): def __add__(self, y, /, name=None): return paddle_frontend.add(self, y) + @with_unsupported_dtypes( + { + "2.5.2 and below": ( + "bool", + "uint8", + "int8", + "int16", + "complex64", + "complex128", + ) + }, + "paddle", + ) + def __gt__(self, y, /, name=None): + return paddle_frontend.logic.greater_than(self, y) + @with_unsupported_dtypes( { "2.5.2 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index d087dabccfb90..0d2f979cf4973 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -344,6 +344,43 @@ def test_paddle___ge__( ) +# __gt__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__gt__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___gt__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __le__ @handle_frontend_method( class_tree=CLASS_TREE, From 8404b11891538ef5524cd8e7f69afd7ac5ba6466 Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Sat, 18 Nov 2023 18:12:29 +0000 Subject: [PATCH 206/978] feat: Paddle Frontend: tensor __mul__ (#27307) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 7 ++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index d417c77f760f9..6cfce102f6370 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -68,6 +68,13 @@ def ivy_array(self, array): def __add__(self, y, /, name=None): return paddle_frontend.add(self, y) + @with_unsupported_dtypes( + {"2.5.2 and below": ("uint8", "int8", "int16", "float16", "bfloat16")}, + "paddle", + ) + def __mul__(self, y, /, name=None): + return paddle_frontend.multiply(self, y) + @with_unsupported_dtypes( { "2.5.2 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 0d2f979cf4973..bd89d02260649 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -418,6 +418,43 @@ def test_paddle___le__( ) +# __mul__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__mul__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___mul__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __or__ @handle_frontend_method( class_tree=CLASS_TREE, From 5920365d49401b3c19352d7f73422cc9efb3c945 Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Sat, 18 Nov 2023 18:39:46 +0000 Subject: [PATCH 207/978] feat: Paddle Frontend: tensor __sub__ (#27305) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 7 ++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 6cfce102f6370..4dda87cd07af2 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -68,6 +68,13 @@ def ivy_array(self, array): def __add__(self, y, /, name=None): return paddle_frontend.add(self, y) + @with_unsupported_dtypes( + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + "paddle", + ) + def __sub__(self, y, /, name=None): + return paddle_frontend.subtract(self, y) + @with_unsupported_dtypes( {"2.5.2 and below": ("uint8", "int8", "int16", "float16", "bfloat16")}, "paddle", diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index bd89d02260649..5e57df36a190c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -525,6 +525,43 @@ def test_paddle___setitem__( ) +# __sub__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__sub__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___sub__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __getitem__ @handle_frontend_method( class_tree=CLASS_TREE, From 72d6d2e83d994e776981f75be0f2d3c6acd768a6 Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Sat, 18 Nov 2023 18:48:28 +0000 Subject: [PATCH 208/978] feat: Paddle Frontend: tensor __radd__ (#27303) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 7 ++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 4dda87cd07af2..25fb162004233 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -68,6 +68,13 @@ def ivy_array(self, array): def __add__(self, y, /, name=None): return paddle_frontend.add(self, y) + @with_unsupported_dtypes( + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + "paddle", + ) + def __radd__(self, x, /, name=None): + return paddle_frontend.add(self, x) + @with_unsupported_dtypes( {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 5e57df36a190c..d6df04bd6e5d7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -492,6 +492,43 @@ def test_paddle___or__( ) +# __radd__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__radd__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___radd__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "x": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __setitem__ @handle_frontend_method( class_tree=CLASS_TREE, From ab3bd3e54cd92cf3c7fab5f0f400e396ebf7b23e Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 13:49:48 +0400 Subject: [PATCH 209/978] feat: Add __rsub__ method to PaddleTensor class (#27338) Co-authored-by: niixxaaa Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 7 ++++ .../test_paddle/test_tensor/test_tensor.py | 39 +++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 25fb162004233..b4d94d12eab3b 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -153,6 +153,13 @@ def __le__(self, y, /, name=None): def __or__(self, y, /, name=None): return paddle_frontend.logic.bitwise_or(self, y) + @with_unsupported_dtypes( + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + "paddle", + ) + def __rsub__(self, x, /, name=None): + return paddle_frontend.subtract(x, self) + def __getitem__(self, item): ivy_args = ivy.nested_map(_to_ivy_array, [self, item]) ret = ivy.get_item(*ivy_args) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index d6df04bd6e5d7..204530743f143 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -529,6 +529,45 @@ def test_paddle___radd__( ) +# __rsub__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__rsub__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + shared_dtype=True, + ), +) +def test_paddle__rsub__( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "x": x[1], + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # __setitem__ @handle_frontend_method( class_tree=CLASS_TREE, From 2519dec008a744ef679922bce1b446c3fec6c319 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 19 Nov 2023 09:51:21 +0000 Subject: [PATCH 210/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../test_paddle/test_tensor/test_tensor.py | 78 +++++++++---------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 204530743f143..1668fc9b80981 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -529,45 +529,6 @@ def test_paddle___radd__( ) -# __rsub__ -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="__rsub__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - num_arrays=2, - shared_dtype=True, - ), -) -def test_paddle__rsub__( - dtype_and_x, - frontend, - frontend_method_data, - init_flags, - method_flags, - backend_fw, - on_device, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "value": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "x": x[1], - }, - frontend=frontend, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - on_device=on_device, - ) - - # __setitem__ @handle_frontend_method( class_tree=CLASS_TREE, @@ -709,6 +670,45 @@ def test_paddle__reshape( ) +# __rsub__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__rsub__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + shared_dtype=True, + ), +) +def test_paddle__rsub__( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "x": x[1], + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # abs @handle_frontend_method( class_tree=CLASS_TREE, From 074eb856c4cc2d33a79742860428a1c7e2c9c4b0 Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 16:48:55 +0400 Subject: [PATCH 211/978] feat: Add floor division method to Paddle Tensor class (#27340) Co-authored-by: niixxaaa Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 4 ++ .../test_paddle/test_tensor/test_tensor.py | 42 +++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index b4d94d12eab3b..ef90fa15c5f80 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -170,6 +170,10 @@ def __setitem__(self, item, value): "ivy.functional.frontends.paddle.Tensor object doesn't support assignment" ) + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + def __floordiv__(self, y, /, name=None): + return paddle_frontend.floor_divide(self, y) + def __iter__(self): if self.ndim == 0: raise TypeError("iteration over a 0-d tensor not supported") diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 1668fc9b80981..1cc6b251a4427 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -599,6 +599,48 @@ def test_paddle___sub__( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__floordiv__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + num_arrays=2, + large_abs_safety_factor=2.5, + small_abs_safety_factor=2.5, + safety_factor_scale="log", + ), +) +def test_paddle__floordiv__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + assume(not np.any(np.isclose(x[1], 0))) + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "other": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + atol_=1, + ) + + # __getitem__ @handle_frontend_method( class_tree=CLASS_TREE, From 437de8e0a2446ee46d0eaa18ba3affb64f06f49f Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 17:19:04 +0400 Subject: [PATCH 212/978] feat: Add __ne__ method to Paddle Tensor class (#27341) Co-authored-by: niixxaaa Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 4 ++ .../test_paddle/test_tensor/test_tensor.py | 41 +++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index ef90fa15c5f80..7767f21381827 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -174,6 +174,10 @@ def __setitem__(self, item, value): def __floordiv__(self, y, /, name=None): return paddle_frontend.floor_divide(self, y) + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + def __ne__(self, y, /, name=None): + return paddle_frontend.not_equal(self, y) + def __iter__(self): if self.ndim == 0: raise TypeError("iteration over a 0-d tensor not supported") diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 1cc6b251a4427..2ed63a770fee8 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -675,6 +675,47 @@ def test_paddle__getitem__( ) +# __ne__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__ne__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + num_arrays=2, + min_value=-1e04, + max_value=1e04, + allow_inf=False, + ), +) +def test_paddle__ne__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "other": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # reshape @handle_frontend_method( class_tree=CLASS_TREE, From c0cb181a75e07e1bbc614525ef1c0713d00d7902 Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 19:37:00 +0400 Subject: [PATCH 213/978] feat: Add __rmul__ method to Paddle Tensor class (#27343) Co-authored-by: niixxaaa Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 7 ++++ .../test_paddle/test_tensor/test_tensor.py | 41 +++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 7767f21381827..42d40604532f0 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -184,6 +184,13 @@ def __iter__(self): for i in range(self.shape[0]): yield self[i] + @with_unsupported_dtypes( + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + "paddle", + ) + def __rmul__(self, y, /, name=None): + return paddle_frontend.multiply(self, y) + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 2ed63a770fee8..525de3a57a643 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -753,6 +753,47 @@ def test_paddle__reshape( ) +# __rmul__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__rmul__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + num_arrays=2, + min_value=-1e04, + max_value=1e04, + allow_inf=False, + ), +) +def test_paddle__rmul__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "other": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __rsub__ @handle_frontend_method( class_tree=CLASS_TREE, From c1eabd07c91376e4b2afea868f6e4a0df0ce62ed Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 19:45:45 +0400 Subject: [PATCH 214/978] feat: Add bitwise XOR operation to Paddle Tensor class (#27344) Co-authored-by: niixxaaa Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 3 ++ .../test_paddle/test_tensor/test_tensor.py | 39 +++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 42d40604532f0..8b9a505d20991 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -191,6 +191,9 @@ def __iter__(self): def __rmul__(self, y, /, name=None): return paddle_frontend.multiply(self, y) + def __xor__(self, y, /, name=None): + return paddle_frontend.logic.bitwise_xor(self, y) + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 525de3a57a643..21ef6eb8a529f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -833,6 +833,45 @@ def test_paddle__rsub__( ) +# __xor__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__xor__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("integer"), + num_arrays=2, + shared_dtype=True, + ), +) +def test_paddle__xor__( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # abs @handle_frontend_method( class_tree=CLASS_TREE, From 49cc1ec1ca925f552b4c690b9080afb4be6eb339 Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 19:55:57 +0400 Subject: [PATCH 215/978] feat: Add __float__ method to Paddle Tensor class (#27346) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 7 ++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 8b9a505d20991..3ffdf548e1547 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -190,6 +190,13 @@ def __iter__(self): ) def __rmul__(self, y, /, name=None): return paddle_frontend.multiply(self, y) + + @with_unsupported_dtypes( + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + "paddle", + ) + def __float__(self): + return float(self._ivy_array) def __xor__(self, y, /, name=None): return paddle_frontend.logic.bitwise_xor(self, y) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 21ef6eb8a529f..fe8e2286df332 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -907,6 +907,43 @@ def test_paddle_abs( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__float__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + max_num_dims=0, + ), +) +def test_paddle__float__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + frontend, + on_device, +): + input_dtypes, xs = dtype_and_x + # Numpy doesn't support complex to float conversion + assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) + helpers.test_frontend_method( + init_input_dtypes=input_dtypes, + backend_to_test=backend_fw, + method_input_dtypes=input_dtypes, + init_all_as_kwargs_np={ + "object": xs[0], + }, + method_all_as_kwargs_np={}, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # acosh @handle_frontend_method( class_tree=CLASS_TREE, From ce52f2fc5912452363d95bf77eb5942dc19bac08 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 19 Nov 2023 15:57:33 +0000 Subject: [PATCH 216/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../frontends/paddle/tensor/tensor.py | 2 +- .../test_paddle/test_tensor/test_tensor.py | 74 +++++++++---------- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 3ffdf548e1547..16f3069693d70 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -190,7 +190,7 @@ def __iter__(self): ) def __rmul__(self, y, /, name=None): return paddle_frontend.multiply(self, y) - + @with_unsupported_dtypes( {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index fe8e2286df332..cb744a46ef673 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -599,6 +599,43 @@ def test_paddle___sub__( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__float__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + max_num_dims=0, + ), +) +def test_paddle__float__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + frontend, + on_device, +): + input_dtypes, xs = dtype_and_x + # Numpy doesn't support complex to float conversion + assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) + helpers.test_frontend_method( + init_input_dtypes=input_dtypes, + backend_to_test=backend_fw, + method_input_dtypes=input_dtypes, + init_all_as_kwargs_np={ + "object": xs[0], + }, + method_all_as_kwargs_np={}, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", @@ -907,43 +944,6 @@ def test_paddle_abs( ) -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="__float__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - max_num_dims=0, - ), -) -def test_paddle__float__( - dtype_and_x, - frontend_method_data, - init_flags, - method_flags, - backend_fw, - frontend, - on_device, -): - input_dtypes, xs = dtype_and_x - # Numpy doesn't support complex to float conversion - assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) - helpers.test_frontend_method( - init_input_dtypes=input_dtypes, - backend_to_test=backend_fw, - method_input_dtypes=input_dtypes, - init_all_as_kwargs_np={ - "object": xs[0], - }, - method_all_as_kwargs_np={}, - frontend=frontend, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - on_device=on_device, - ) - - # acosh @handle_frontend_method( class_tree=CLASS_TREE, From 8c6b0123179a0cd79aba34bd72d20ec4cdc9023c Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 20:17:59 +0400 Subject: [PATCH 217/978] feat: Add __len__ method to PaddleTensor class (#27347) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 3 + .../test_paddle/test_tensor/test_tensor.py | 80 +++++++++++++++++++ 2 files changed, 83 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 16f3069693d70..00f05b1df97bd 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -201,6 +201,9 @@ def __float__(self): def __xor__(self, y, /, name=None): return paddle_frontend.logic.bitwise_xor(self, y) + def __len__(self): + return len(self._ivy_array) + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index cb744a46ef673..7c1812cc09048 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -62,6 +62,50 @@ def _get_as_complex_inputs_(draw): return x_dtype, x +@st.composite +def _array_and_shape( + draw, + *, + min_num_dims=1, + max_num_dims=3, + min_dim_size=1, + max_dim_size=10, +): + if isinstance(min_dim_size, st._internal.SearchStrategy): + min_dim_size = draw(min_dim_size) + if isinstance(max_dim_size, st._internal.SearchStrategy): + max_dim_size = draw(max_dim_size) + + available_dtypes = draw(helpers.get_dtypes("numeric")) + dtype = draw( + helpers.array_dtypes( + num_arrays=1, + available_dtypes=available_dtypes, + ) + ) + dtype.append("int32") + shape = draw( + st.shared( + helpers.get_shape( + min_num_dims=min_num_dims, + max_num_dims=max_num_dims, + min_dim_size=min_dim_size, + max_dim_size=max_dim_size, + ), + key="shape", + ) + ) + array = draw( + helpers.array_values( + dtype=dtype[0], + shape=shape, + ) + ) + to_shape = [(None if draw(st.booleans()) else _) for _ in shape] + + return dtype, [array, to_shape] + + # clip @st.composite def _get_clip_inputs(draw): @@ -944,6 +988,42 @@ def test_paddle_abs( ) +# __len__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__len__", + dtype_and_x=_array_and_shape( + min_num_dims=1, + max_num_dims=5, + ), +) +def test_paddle__len__( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # acosh @handle_frontend_method( class_tree=CLASS_TREE, From fba0502367a192d4b436fe816cd56ab9a0486bf8 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 19 Nov 2023 16:19:31 +0000 Subject: [PATCH 218/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../frontends/paddle/tensor/tensor.py | 2 +- .../test_paddle/test_tensor/test_tensor.py | 136 +++++++++--------- 2 files changed, 69 insertions(+), 69 deletions(-) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 00f05b1df97bd..27307ccb3823c 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -203,7 +203,7 @@ def __xor__(self, y, /, name=None): def __len__(self): return len(self._ivy_array) - + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 7c1812cc09048..0a9112bf63435 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -30,38 +30,6 @@ # --------------- # -def _filter_query(query): - return ( - query.ndim > 1 - if isinstance(query, np.ndarray) - else ( - not any(isinstance(i, np.ndarray) and i.ndim <= 1 for i in query) - if isinstance(query, tuple) - else True - ) - ) - - -# as_complex -@st.composite -def _get_as_complex_inputs_(draw): - shape = draw( - helpers.get_shape( - min_num_dims=2, max_num_dims=5, min_dim_size=2, max_dim_size=10 - ) - ) - - x_dtype, x = draw( - helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), - shape=(*shape, 2), - min_value=0, - max_value=50, - ) - ) - return x_dtype, x - - @st.composite def _array_and_shape( draw, @@ -106,6 +74,38 @@ def _array_and_shape( return dtype, [array, to_shape] +def _filter_query(query): + return ( + query.ndim > 1 + if isinstance(query, np.ndarray) + else ( + not any(isinstance(i, np.ndarray) and i.ndim <= 1 for i in query) + if isinstance(query, tuple) + else True + ) + ) + + +# as_complex +@st.composite +def _get_as_complex_inputs_(draw): + shape = draw( + helpers.get_shape( + min_num_dims=2, max_num_dims=5, min_dim_size=2, max_dim_size=10 + ) + ) + + x_dtype, x = draw( + helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + shape=(*shape, 2), + min_value=0, + max_value=50, + ) + ) + return x_dtype, x + + # clip @st.composite def _get_clip_inputs(draw): @@ -756,6 +756,42 @@ def test_paddle__getitem__( ) +# __len__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__len__", + dtype_and_x=_array_and_shape( + min_num_dims=1, + max_num_dims=5, + ), +) +def test_paddle__len__( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # __ne__ @handle_frontend_method( class_tree=CLASS_TREE, @@ -988,42 +1024,6 @@ def test_paddle_abs( ) -# __len__ -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="__len__", - dtype_and_x=_array_and_shape( - min_num_dims=1, - max_num_dims=5, - ), -) -def test_paddle__len__( - dtype_and_x, - frontend, - frontend_method_data, - init_flags, - method_flags, - backend_fw, - on_device, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "value": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={}, - frontend=frontend, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - on_device=on_device, - ) - - # acosh @handle_frontend_method( class_tree=CLASS_TREE, From a481e40d07398b8c85c67a9986b3c173d8613b54 Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 20:27:42 +0400 Subject: [PATCH 219/978] feat: Add __neg__ method to PaddleTensor class (#27348) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 3 ++ .../test_paddle/test_tensor/test_tensor.py | 38 +++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 27307ccb3823c..21fcd66d24668 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -204,6 +204,9 @@ def __xor__(self, y, /, name=None): def __len__(self): return len(self._ivy_array) + def __neg__(self): + return paddle_frontend.neg(self) + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 0a9112bf63435..3a1fd6447ea66 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -833,6 +833,44 @@ def test_paddle__ne__( ) +# __neg__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__neg__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + min_value=-1e04, + max_value=1e04, + allow_inf=False, + ), +) +def test_paddle__neg__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # reshape @handle_frontend_method( class_tree=CLASS_TREE, From 79de1aaeb45883e8a9a3119caa749dfac39d9b34 Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 20:47:43 +0400 Subject: [PATCH 220/978] feat: Add __rdiv__ method to PaddleTensor class (#27349) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 7 +++ .../test_paddle/test_tensor/test_tensor.py | 43 +++++++++++++++++++ 2 files changed, 50 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 21fcd66d24668..f64001d80b3aa 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -207,6 +207,13 @@ def __len__(self): def __neg__(self): return paddle_frontend.neg(self) + @with_unsupported_dtypes( + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + "paddle", + ) + def __rdiv__(self, y, /, name=None): + return paddle_frontend.divide(y, self) + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 3a1fd6447ea66..e130702bbde83 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -871,6 +871,49 @@ def test_paddle__neg__( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__rdiv__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + shared_dtype=True, + large_abs_safety_factor=10, + small_abs_safety_factor=10, + safety_factor_scale="log", + ), +) +def test_paddle__rdiv__( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + assume(not np.any(np.isclose(x[0], 0))) + assume(not np.any(np.isclose(x[1], 0))) + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # reshape @handle_frontend_method( class_tree=CLASS_TREE, From 8ed53462f7d813e447eb4cbe384b8b8e443e218d Mon Sep 17 00:00:00 2001 From: Arunima Santhosh Kumar <91986717+niixxaaa@users.noreply.github.com> Date: Sun, 19 Nov 2023 22:20:28 +0400 Subject: [PATCH 221/978] feat: Add __int__ method to PaddleTensor class (#27350) Co-authored-by: niixxaaa Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 7 ++++ .../test_paddle/test_tensor/test_tensor.py | 39 +++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index f64001d80b3aa..7df547bdb1a7e 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -214,6 +214,13 @@ def __neg__(self): def __rdiv__(self, y, /, name=None): return paddle_frontend.divide(y, self) + @with_unsupported_dtypes( + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + "paddle", + ) + def __int__(self): + return int(self._ivy_array) + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index e130702bbde83..3ab33f46e4b0f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -756,6 +756,45 @@ def test_paddle__getitem__( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__int__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("integer"), + max_num_dims=0, + min_value=-1e15, + max_value=1e15, + ), +) +def test_paddle__int__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + frontend, + on_device, +): + input_dtypes, xs = dtype_and_x + # Numpy doesn't support complex to int conversion + assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) + helpers.test_frontend_method( + init_input_dtypes=input_dtypes, + backend_to_test=backend_fw, + method_input_dtypes=input_dtypes, + init_all_as_kwargs_np={ + "object": xs[0], + }, + method_all_as_kwargs_np={}, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # __len__ @handle_frontend_method( class_tree=CLASS_TREE, From 821628dd68b1f473b85d33195f49dde2afed9a2b Mon Sep 17 00:00:00 2001 From: Nwaamaka Iduwe <110701338+Nwaamaka-Iduwe@users.noreply.github.com> Date: Sun, 19 Nov 2023 19:27:12 +0100 Subject: [PATCH 222/978] feat: implemented "trace" method for NumPy (#27268) Co-authored-by: NripeshN --- .../frontends/numpy/ndarray/ndarray.py | 28 +++++++++++ .../test_numpy/test_ndarray/test_ndarray.py | 47 +++++++++++++++++++ 2 files changed, 75 insertions(+) diff --git a/ivy/functional/frontends/numpy/ndarray/ndarray.py b/ivy/functional/frontends/numpy/ndarray/ndarray.py index c34a2d8b0d314..31ff643ec4888 100644 --- a/ivy/functional/frontends/numpy/ndarray/ndarray.py +++ b/ivy/functional/frontends/numpy/ndarray/ndarray.py @@ -6,6 +6,9 @@ import ivy import ivy.functional.frontends.numpy as np_frontend from ivy.functional.frontends.numpy.func_wrapper import _to_ivy_array +from ivy.func_wrapper import ( + with_supported_device_and_dtypes, +) # --- Classes ---# @@ -410,6 +413,31 @@ def tofile(self, fid, /, sep="", format_="%s"): def tolist(self) -> list: return self._ivy_array.to_list() + @with_supported_device_and_dtypes( + { + "1.26.2 and below": { + "cpu": ( + "int64", + "float32", + "float64", + "bfloat16", + "complex64", + "complex128", + "uint64", + ) + } + }, + "numpy", + ) + def trace(self, *, offset=0, axis1=0, axis2=1, out=None): + return np_frontend.trace( + self, + offset=offset, + axis1=axis1, + axis2=axis2, + out=out, + ) + def view(self): return np_frontend.reshape(self, tuple(self.shape)) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py index f19d5968df2aa..833da964cdfdd 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py @@ -3711,6 +3711,53 @@ def test_numpy_tolist( ) +# trace +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="numpy.array", + method_name="trace", + dtype_x_axis=helpers.dtype_values_axis( + available_dtypes=helpers.get_dtypes("numeric"), + min_num_dims=2, + min_axes_size=2, + max_axes_size=2, + valid_axis=True, + ), + offset=st.integers(min_value=-2, max_value=2), +) +def test_numpy_trace( + dtype_x_axis, + offset, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + frontend, + on_device, +): + input_dtypes, x, axis = dtype_x_axis + + helpers.test_frontend_method( + init_input_dtypes=input_dtypes, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "object": x[0], + }, + method_input_dtypes=input_dtypes, + method_all_as_kwargs_np={ + "axis1": axis[0], + "axis2": axis[1], + "offset": offset, + "out": None, + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + @handle_frontend_method( class_tree=CLASS_TREE, init_tree="numpy.array", From f5c75e99f3a414ced9b580ad0c3e815a002c1ce9 Mon Sep 17 00:00:00 2001 From: Mohamed Ibrahim Date: Sun, 19 Nov 2023 20:41:23 +0200 Subject: [PATCH 223/978] feat: Paddle frontend implementation for fft2 function (#27295) Co-authored-by: NripeshN --- ivy/functional/frontends/paddle/fft.py | 19 ++++++++ .../test_frontends/test_paddle/test_fft.py | 48 +++++++++++++++++++ 2 files changed, 67 insertions(+) diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 6687cadf7cd0d..75f3f089cdd58 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -16,6 +16,25 @@ def fft(x, n=None, axis=-1.0, norm="backward", name=None): return ivy.astype(ret, x.dtype) +@with_supported_dtypes( + { + "2.5.2 and below": ( + "int32", + "int64", + "float32", + "float64", + ) + }, + "paddle", +) +@to_ivy_arrays_and_back +def fft2(x, s=None, axes=(-2, -1), norm="backward", name=None): + if axes is None: + axes = (-2, -1) + ret = ivy.fft2(x, s=s, dim=axes, norm=norm) + return ret + + @with_supported_dtypes( { "2.5.2 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py index fcff4153a6409..5f9ef493350e7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py @@ -54,6 +54,54 @@ def test_paddle_fft( ) +@handle_frontend_test( + fn_tree="paddle.fft.fft2", + dtypes_x_axis=helpers.dtype_values_axis( + available_dtypes=helpers.get_dtypes("valid"), + min_value=-10, + max_value=10, + min_num_dims=2, + min_dim_size=2, + valid_axis=True, + force_int_axis=True, + ), + s=st.one_of( + st.none(), + st.lists(st.integers(min_value=2, max_value=10), min_size=2, max_size=2), + ), + axes=st.one_of( + st.none(), + st.tuples( + st.integers(min_value=-2, max_value=2), + st.integers(min_value=-1, max_value=2), + ), + ), + norm=st.sampled_from(["backward", "ortho", "forward"]), +) +def test_paddle_fft2( + dtypes_x_axis, + s, + axes, + norm, + frontend, + backend_fw, + test_flags, + fn_tree, +): + input_dtypes, x, _ = dtypes_x_axis + helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + x=x[0], + s=s, + axes=axes, + norm=norm, + ) + + @handle_frontend_test( fn_tree="paddle.fft.fftfreq", n=st.integers(min_value=1, max_value=1000), From f944f05613bdfdc643ae1c5183ba31c18d40cb7c Mon Sep 17 00:00:00 2001 From: Eddy Oyieko <67474838+mobley-trent@users.noreply.github.com> Date: Mon, 20 Nov 2023 18:07:25 +0300 Subject: [PATCH 224/978] refactor(jax-frontend): Refactored `fmin` and `fmax` to use native ivy functions (#27358) --- .../frontends/jax/numpy/mathematical_functions.py | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 021c2e74659a7..1dc1f43e42fa8 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -452,24 +452,13 @@ def floor_divide(x1, x2, /, out=None): @to_ivy_arrays_and_back def fmax(x1, x2): x1, x2 = promote_types_of_jax_inputs(x1, x2) - ret = ivy.where( - ivy.bitwise_or(ivy.greater(x1, x2), ivy.isnan(x2)), - x1, - x2, - ) - return ret + return ivy.fmax(x1, x2) @to_ivy_arrays_and_back def fmin(x1, x2): x1, x2 = promote_types_of_jax_inputs(x1, x2) - ret = ivy.where( - ivy.bitwise_or(ivy.less(x1, x2), ivy.isnan(x2)), - x1, - x2, - ) - print("jax-frontend", ret) - return ret + return ivy.fmin(x1, x2) @to_ivy_arrays_and_back From 9eaa54a103a10fb4e305dffd27e1a28983cb47d3 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 20 Nov 2023 20:46:35 +0530 Subject: [PATCH 225/978] fix: Fixed passing `key-word` arguments in 2 functions (#27300) --- ivy/functional/backends/torch/layers.py | 2 +- ivy/functional/frontends/jax/numpy/statistical.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index bf5a8eb70a17b..a90c6d81f8970 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -526,7 +526,7 @@ def depthwise_conv2d( dilations = [dilations] * 2 if isinstance(dilations, int) else dilations if data_format == "NHWC": x = x.permute(0, 3, 1, 2) - filters = ivy.squeeze(filters, 3).to_native() if filters.ndim == 4 else filters + filters = ivy.squeeze(filters, axis=3).to_native() if filters.ndim == 4 else filters filters = torch.unsqueeze(filters, -1) dims_in = filters.shape[-2] filters = filters.permute(2, 3, 0, 1) diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py index 514d077df004c..bb40e941322a4 100644 --- a/ivy/functional/frontends/jax/numpy/statistical.py +++ b/ivy/functional/frontends/jax/numpy/statistical.py @@ -495,7 +495,7 @@ def _nanquantile_unchecked( ): """Assumes that q is in [0, 1], and is an ndarray.""" if a.size == 0: - return ivy.nanmean(a, axis, out=out, keepdims=keepdims) + return ivy.nanmean(a, axis=axis, out=out, keepdims=keepdims) return _ureduce( a, func=_nanquantile_ureduce_func, From efa1b4adb74882783c2929849da99676c2c60c20 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 20 Nov 2023 20:46:55 +0530 Subject: [PATCH 226/978] fix: Fixed positional arguments for 2 `staticmethod` calls. (#27357) --- ivy/data_classes/container/creation.py | 1 - ivy/data_classes/container/experimental/creation.py | 1 - 2 files changed, 2 deletions(-) diff --git a/ivy/data_classes/container/creation.py b/ivy/data_classes/container/creation.py index ea238eb55c733..83ec6aafc6884 100644 --- a/ivy/data_classes/container/creation.py +++ b/ivy/data_classes/container/creation.py @@ -1654,7 +1654,6 @@ def triu_indices( out: Optional[Union[Tuple[ivy.Array], ivy.Container]] = None, ) -> ivy.Container: return self.static_triu_indices( - self, n_rows, n_cols, k, diff --git a/ivy/data_classes/container/experimental/creation.py b/ivy/data_classes/container/experimental/creation.py index b760f16ddde3f..03a0184d81eaf 100644 --- a/ivy/data_classes/container/experimental/creation.py +++ b/ivy/data_classes/container/experimental/creation.py @@ -599,7 +599,6 @@ def tril_indices( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: return self.static_tril_indices( - self, n_rows, n_cols, k, From 59d270c140a5a53c8211e9b4fde0d14cdc9b3313 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 21 Nov 2023 08:58:58 +0000 Subject: [PATCH 227/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 78234f4a95502..395004f114e81 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 78234f4a9550251550c0b296c4340c2bb04f9609 +Subproject commit 395004f114e816e4ed8cde7da7e19c75e9af7f7c From 502a803f3b49be7bd4559b98d33c7fb405e4d10f Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 21 Nov 2023 09:13:40 +0000 Subject: [PATCH 228/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 395004f114e81..98870b7b92546 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 395004f114e816e4ed8cde7da7e19c75e9af7f7c +Subproject commit 98870b7b92546a9e1dc9b45a0042771bd3c7b505 From cfd34066d5c71c795f9dd89b8b392a668f02638a Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 21 Nov 2023 09:42:54 +0000 Subject: [PATCH 229/978] fix: enable acess to tree in sklearn frontend namespace --- ivy/functional/frontends/sklearn/tree/__init__.py | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 ivy/functional/frontends/sklearn/tree/__init__.py diff --git a/ivy/functional/frontends/sklearn/tree/__init__.py b/ivy/functional/frontends/sklearn/tree/__init__.py new file mode 100644 index 0000000000000..d17f1a0841699 --- /dev/null +++ b/ivy/functional/frontends/sklearn/tree/__init__.py @@ -0,0 +1,2 @@ +from . import _classes +from ._classes import * From ccf379e76b60fd82554ab56465131a4866bee2f1 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 21 Nov 2023 09:45:16 +0000 Subject: [PATCH 230/978] refactor: remove irrelevant methods in BaseDecisionTree in sklearn front, at least for now --- .../frontends/sklearn/tree/_classes.py | 23 ------------------- 1 file changed, 23 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_classes.py b/ivy/functional/frontends/sklearn/tree/_classes.py index d2e8dc8b17c30..d7772084b4d60 100644 --- a/ivy/functional/frontends/sklearn/tree/_classes.py +++ b/ivy/functional/frontends/sklearn/tree/_classes.py @@ -43,12 +43,6 @@ def get_depth(self): def get_n_leaves(self): raise NotImplementedError - def _support_missing_values(self, X): - raise NotImplementedError - - def _compute_missing_values_in_feature_mask(self, X): - raise NotImplementedError - def _fit( self, X, @@ -59,9 +53,6 @@ def _fit( ): raise NotImplementedError - def _validate_X_predict(self, X, check_input): - raise NotImplementedError - def predict(self, X, check_input=True): raise NotImplementedError @@ -71,12 +62,6 @@ def apply(self, X, check_input=True): def decision_path(self, X, check_input=True): raise NotImplementedError - def _prune_tree(self): - raise NotImplementedError - - def cost_complexity_pruning_path(self, X, y, sample_weight=None): - raise NotImplementedError - @property def feature_importances_(self): raise NotImplementedError @@ -128,11 +113,3 @@ def predict_proba(self, X, check_input=True): def predict_log_proba(self, X): raise NotImplementedError - - def _more_tags(self): - allow_nan = self.splitter == "best" and self.criterion in { - "gini", - "log_loss", - "entropy", - } - return {"multilabel": True, "allow_nan": allow_nan} From ecacdf986455ba15ef862557afe00bbe7c7fbccb Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 21 Nov 2023 16:02:16 +0530 Subject: [PATCH 231/978] fix: Fixed passing `shape` argument in 2 functions. (#27363) Co-authored-by: @AnnaTz --- ivy/functional/frontends/paddle/tensor/tensor.py | 3 ++- ivy/functional/frontends/torch/tensor.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 7df547bdb1a7e..2d3e814391442 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -235,7 +235,8 @@ def reshape(self, *args, shape=None): return paddle_frontend.reshape(self, shape) else: return paddle_frontend.reshape(self, args) - return paddle_frontend.reshape(self) + else: + raise ValueError("reshape() got no values for argument 'shape'") def dim(self): return self.ivy_array.ndim diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index b271cea307089..9fe391b0cb731 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -142,7 +142,8 @@ def reshape(self, *args, shape=None): return torch_frontend.reshape(self, shape) else: return torch_frontend.reshape(self, args) - return torch_frontend.reshape(self) + else: + raise ValueError("reshape() got no values for argument 'shape'") @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") @with_unsupported_dtypes({"2.5.1 and below": ("float16",)}, "paddle") From 039f79399f6f8c8d2db8ac33577ea6dcd34fb08b Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 22 Nov 2023 12:24:56 +0530 Subject: [PATCH 232/978] fix: moved the rename wheels script inside the loop to rename each wheel separately in deploy_pypi.sh --- scripts/shell/deploy_pypi.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/shell/deploy_pypi.sh b/scripts/shell/deploy_pypi.sh index 720d60f39bfb4..c185f62dbb87d 100644 --- a/scripts/shell/deploy_pypi.sh +++ b/scripts/shell/deploy_pypi.sh @@ -1,6 +1,6 @@ jq -c '.compiler[]' available_configs.json | while read config; do export TAG=${config:1:${#config}-2} python -m build + python3 scripts/rename_wheels.py done -python3 scripts/rename_wheels.py python3 -m twine upload dist/* -u "__token__" -p "$PYPI_PASSWORD" --verbose From 91834942afcfcc90a718f288bc7c6ed220b12424 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 22 Nov 2023 17:44:00 +0530 Subject: [PATCH 233/978] fix: Fixed passing `prob` argument in 1 function. (#27373) --- ivy/functional/frontends/paddle/nn/functional/common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/paddle/nn/functional/common.py b/ivy/functional/frontends/paddle/nn/functional/common.py index d43f6a42a93bc..ef27e44b2fa41 100644 --- a/ivy/functional/frontends/paddle/nn/functional/common.py +++ b/ivy/functional/frontends/paddle/nn/functional/common.py @@ -55,7 +55,7 @@ def dropout(x, p=0.5, axis=None, training=True, mode="upscale_in_train", name=No @to_ivy_arrays_and_back @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def dropout2d(x, *, p=0.5, training=True, data_format="NCHW", name=None): - return ivy.dropout2d(x, p=p, training=training, data_format=data_format) + return ivy.dropout2d(x, p, training=training, data_format=data_format) @to_ivy_arrays_and_back From 36ad4ead4b54fe004e49657e4f7bfec3ec20d3a4 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 22 Nov 2023 16:00:32 +0000 Subject: [PATCH 234/978] refactor: Replaced the use of raw_ops in the tf backend of conv functions. Fixed a bug in the grouped convolution cases and refactored them to limit their node expansion more. --- ivy/functional/backends/tensorflow/layers.py | 252 +++++++++++-------- 1 file changed, 151 insertions(+), 101 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 0e7dcfb2bee8d..1fb3fe4b1613e 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -20,11 +20,11 @@ def _x_dil_before_conv(x, dims, x_dilations, data_format): # adding dilation in input x_dilations = [x_dilations] * dims if isinstance(x_dilations, int) else x_dilations x_dilations_idxs = [i for i, x_dil in enumerate(x_dilations) if x_dil > 1] - if data_format[-1] == "C" or data_format == "channel_last": - offset = 1 - else: - offset = 2 if x_dilations_idxs: + if data_format[-1] == "C": + offset = 1 + else: + offset = 2 for i in x_dilations_idxs: h = x.shape[offset + i] new_height = h + (h - 1) * (x_dilations[i] - 1) @@ -42,28 +42,29 @@ def _pad_before_conv(x, padding, dims, data_format): pad_list = [(padding, padding)] * dims else: pad_list = padding - if data_format[-1] == "C" or data_format == "channel_last": + if data_format[-1] == "C": pad_list = [(0, 0), *pad_list, (0, 0)] else: pad_list = [(0, 0), (0, 0), *pad_list] return tf.pad(x, pad_list, "CONSTANT"), "VALID" -def _to_explicit_padding(padding, dims): +def _extend_2d_padding(padding, data_format): if isinstance(padding, str): - return padding, [] + return padding if isinstance(padding, int): - explicit_pad = [padding] * dims * 2 + padding = [(padding, padding)] * 2 + if data_format[-1] == "C": + padding = [(0, 0)] + padding + [(0, 0)] else: - explicit_pad = [item for sublist in padding for item in sublist] - explicit_pad = [0, 0] + explicit_pad + [0, 0] - return "EXPLICIT", explicit_pad + padding = [(0, 0), (0, 0)] + padding + return padding def _transpose_out_pad( x_shape, filter_shape, strides, padding, dims, dilations, data_format ): - if data_format[-1] == "C" or data_format == "channel_last": + if data_format[-1] == "C": offset = 1 else: offset = 2 @@ -161,20 +162,20 @@ def conv1d_transpose( return res -def _extend_strides_dilations(strides, dilations, dims, data_format): - if data_format[-1] == "C" or data_format == "channel_last": - strides = [1, *([strides] * dims if isinstance(strides, int) else strides), 1] +def _extend_3d_strides_dilations(strides, dilations, data_format): + if data_format[-1] == "C": + strides = [1, *([strides] * 3 if isinstance(strides, int) else strides), 1] dilations = [ 1, - *([dilations] * dims if isinstance(dilations, int) else dilations), + *([dilations] * 3 if isinstance(dilations, int) else dilations), 1, ] else: - strides = [1, 1, *([strides] * dims if isinstance(strides, int) else strides)] + strides = [1, 1, *([strides] * 3 if isinstance(strides, int) else strides)] dilations = [ 1, 1, - *([dilations] * dims if isinstance(dilations, int) else dilations), + *([dilations] * 3 if isinstance(dilations, int) else dilations), ] return strides, dilations @@ -202,17 +203,8 @@ def conv2d( if filter_format == "channel_first": filters = tf.transpose(filters, (2, 3, 1, 0)) x = _x_dil_before_conv(x, 2, x_dilations, data_format) - padding, explicit_padding = _to_explicit_padding(padding, 2) - strides, dilations = _extend_strides_dilations(strides, dilations, 2, data_format) - res = tf.raw_ops.Conv2D( - input=x, - filter=filters, - strides=strides, - padding=padding, - explicit_paddings=explicit_padding, - data_format=data_format, - dilations=dilations, - ) + padding = _extend_2d_padding(padding, data_format) + res = tf.nn.conv2d(x, filters, strides, padding, data_format, dilations) res = tf.math.add(res, bias) if bias is not None else res if permuted_x: return tf.transpose(res, (0, 3, 1, 2)) @@ -284,7 +276,7 @@ def depthwise_conv2d( permuted_x = True if tf.rank(filters) == 3: filters = tf.expand_dims(filters, -1) - x, padding = _pad_before_conv(x, padding, 2, data_format) + padding = _extend_2d_padding(padding, data_format) strides = [1, strides[0], strides[1], 1] res = tf.nn.depthwise_conv2d(x, filters, strides, padding, data_format, dilations) if permuted_x: @@ -316,7 +308,7 @@ def conv3d( filters = tf.transpose(filters, (2, 3, 4, 1, 0)) x = _x_dil_before_conv(x, 3, x_dilations, data_format) x, padding = _pad_before_conv(x, padding, 3, data_format) - strides, dilations = _extend_strides_dilations(strides, dilations, 3, data_format) + strides, dilations = _extend_3d_strides_dilations(strides, dilations, data_format) res = tf.nn.conv3d(x, filters, strides, padding, data_format, dilations) res = tf.math.add(res, bias) if bias is not None else res if permuted_x: @@ -353,7 +345,7 @@ def conv3d_transpose( output_shape, padding = _transpose_out_pad( x.shape, filters.shape, strides, padding, 3, dilations, data_format ) - strides, dilations = _extend_strides_dilations(strides, dilations, 3, data_format) + strides, dilations = _extend_3d_strides_dilations(strides, dilations, data_format) res = tf.nn.conv3d_transpose( x, filters, output_shape, strides, padding, data_format, dilations ) @@ -380,81 +372,52 @@ def conv_general_dilated( bias: Optional[Union[tf.Tensor, tf.Variable]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - # permuting dims based on formats - if data_format == "channel_first": - x = tf.transpose(x, (0, *range(2, dims + 2), 1)) - if filter_format == "channel_first": filters = tf.transpose(filters, (*range(2, dims + 2), 1, 0)) - x = _x_dil_before_conv(x, dims, x_dilations, "channel_last") - - df = _get_x_data_format(dims, "channel_last") - - if filters.shape[-2] != (x.shape[-1] // feature_group_count): + num_channels = x.shape[1] if data_format == "channel_first" else x.shape[-1] + if filters.shape[-2] != (num_channels // feature_group_count): raise ivy.utils.exceptions.IvyError( f"given feature_group_count {feature_group_count} expected input channel of" - f" the filter to be {x.shape[-1] // feature_group_count} but got" + f" the filter to be {num_channels // feature_group_count} but got" f" {filters.shape[-2]}" ) - if x.shape[-1] % feature_group_count != 0: + if num_channels % feature_group_count != 0: raise ivy.utils.exceptions.IvyError( "input channel should be divisible by feature group count" - f" {feature_group_count} but got input channel {x.shape[-1]}" + f" {feature_group_count} but got input channel {num_channels}" ) - if dims == 1: - x, padding = _pad_before_conv(x, padding, dims, "channel_last") - res = tf.nn.conv1d( - x, - filters, - strides, - padding, - df, - dilations, - ) - elif dims == 2: - padding, explicit_padding = _to_explicit_padding(padding, 2) - strides, dilations = _extend_strides_dilations( - strides, dilations, 2, "channel_last" - ) - res = tf.raw_ops.Conv2D( - input=x, - filter=filters, - strides=strides, - padding=padding, - explicit_paddings=explicit_padding, - data_format="NHWC", - dilations=dilations, - ) - else: - x, padding = _pad_before_conv(x, padding, dims, "channel_last") - strides, dilations = _extend_strides_dilations( - strides, dilations, 3, "channel_last" - ) - # grouped conv3d is not supported on CPU - # ToDO: change the condition of GPU when automatic device shifting - # is implemented in ivy - if feature_group_count == 1 or tf.test.is_gpu_available(): - res = tf.nn.conv3d( + permuted_x = False + if data_format == "channel_first" and ivy.dev(x) == "cpu": + x = tf.transpose(x, (0, *range(2, dims + 2), 1)) + data_format = "channel_last" + permuted_x = True + + data_format = _get_x_data_format(dims, data_format) + + x = _x_dil_before_conv(x, dims, x_dilations, data_format) + + if dims == 2: + padding = _extend_2d_padding(padding, data_format) + if feature_group_count == 1: + res = tf.nn.conv2d( x, filters, strides, padding, - df, - dilations, + data_format=data_format, + dilations=dilations, ) else: res = tf.concat( [ - tf.nn.conv3d( - x[:, :, :, :, i : i + filters.shape[-2]], - filters[ - :, :, :, :, j : j + filters.shape[-1] // feature_group_count - ], + tf.nn.conv2d( + x[..., i : i + filters.shape[-2]], + filters[..., j : j + filters.shape[-1] // feature_group_count], strides, padding, - df, + data_format, dilations, ) for i, j in zip( @@ -468,9 +431,82 @@ def conv_general_dilated( ], axis=-1, ) + else: + x, padding = _pad_before_conv(x, padding, dims, data_format) + if dims == 1: + if feature_group_count == 1: + res = tf.nn.conv1d( + x, + filters, + strides, + padding, + data_format=data_format, + dilations=dilations, + ) + else: + res = tf.concat( + [ + tf.nn.conv2d( + x[..., i : i + filters.shape[-2]], + filters[ + ..., j : j + filters.shape[-1] // feature_group_count + ], + strides, + padding, + data_format, + dilations, + ) + for i, j in zip( + range(0, x.shape[-1], filters.shape[-2]), + range( + 0, + filters.shape[-1], + filters.shape[-1] // feature_group_count, + ), + ) + ], + axis=-1, + ) + else: + strides, dilations = _extend_3d_strides_dilations( + strides, dilations, data_format + ) + if feature_group_count == 1: + res = tf.nn.conv3d( + x, + filters, + strides, + padding, + data_format=data_format, + dilations=dilations, + ) + else: + res = tf.concat( + [ + tf.nn.conv3d( + x[..., i : i + filters.shape[-2]], + filters[ + ..., j : j + filters.shape[-1] // feature_group_count + ], + strides, + padding, + data_format, + dilations, + ) + for i, j in zip( + range(0, x.shape[-1], filters.shape[-2]), + range( + 0, + filters.shape[-1], + filters.shape[-1] // feature_group_count, + ), + ) + ], + axis=-1, + ) res = tf.math.add(res, bias) if bias is not None else res - if data_format == "channel_first": - res = tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) + if permuted_x: + return tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) return res @@ -492,7 +528,7 @@ def conv_general_transpose( ) -> Union[tf.Tensor, tf.Variable]: if feature_group_count == 1: if dims == 1: - res = conv1d_transpose( + return conv1d_transpose( x, filters, strides, @@ -503,7 +539,7 @@ def conv_general_transpose( bias=bias, ) elif dims == 2: - res = conv2d_transpose( + return conv2d_transpose( x, filters, strides, @@ -514,7 +550,7 @@ def conv_general_transpose( bias=bias, ) else: - res = conv3d_transpose( + return conv3d_transpose( x, filters, strides, @@ -525,12 +561,22 @@ def conv_general_transpose( bias=bias, ) else: - if data_format == "channel_first": + permuted_x = False + if data_format == "channel_first" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, *range(2, dims + 2), 1)) + data_format = "channel_last" + permuted_x = True + + data_format = _get_x_data_format(dims, data_format) + + output_shape, padding = _transpose_out_pad( + x.shape, filters.shape, strides, padding, dims, dilations, data_format + ) + if dims == 1: res = tf.concat( [ - conv1d_transpose( + tf.nn.conv1d_transpose( x[..., j : j + filters.shape[-2] // feature_group_count], filters[ ..., j : j + filters.shape[-2] // feature_group_count, : @@ -538,7 +584,7 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, - data_format="NWC", + data_format=data_format, dilations=dilations, ) for j in range( @@ -550,7 +596,7 @@ def conv_general_transpose( elif dims == 2: res = tf.concat( [ - conv2d_transpose( + tf.nn.conv2d_transpose( x[..., j : j + filters.shape[-2] // feature_group_count], filters[ ..., j : j + filters.shape[-2] // feature_group_count, : @@ -558,7 +604,7 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, - data_format="NHWC", + data_format=data_format, dilations=dilations, ) for j in range( @@ -568,9 +614,12 @@ def conv_general_transpose( axis=-1, ) else: + strides, dilations = _extend_3d_strides_dilations( + strides, dilations, data_format + ) res = tf.concat( [ - conv3d_transpose( + tf.nn.conv3d_transpose( x[..., j : j + filters.shape[-2] // feature_group_count], filters[ ..., j : j + filters.shape[-2] // feature_group_count, : @@ -578,7 +627,7 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, - data_format="NDHWC", + data_format=data_format, dilations=dilations, ) for j in range( @@ -587,10 +636,11 @@ def conv_general_transpose( ], axis=-1, ) + res = tf.math.add(res, bias) if bias is not None else res - if data_format == "channel_first": - res = tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) - return res + if permuted_x: + return tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) + return res def nms( From b1a553a881d9416985be3d0843cbacca5f35cfdc Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 23 Nov 2023 11:01:19 +0000 Subject: [PATCH 235/978] fix: Fixed training and scaling bugs in frontend and backend dropout functions and updated their tests to test the returned values when possible. Also removed some redundant operations. --- .../tensorflow/experimental/layers.py | 6 +- .../backends/torch/experimental/layers.py | 6 +- ivy/functional/frontends/tensorflow/nn.py | 2 +- .../torch/nn/functional/dropout_functions.py | 2 +- ivy/functional/ivy/layers.py | 2 +- .../test_frontends/test_tensorflow/test_nn.py | 49 +++++++++------ .../test_functional/test_dropout_functions.py | 46 ++++++++------ .../test_functional/test_nn/test_layers.py | 60 ++++++++++++------- 8 files changed, 109 insertions(+), 64 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 715306a0b3125..62a3a34b38d51 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -726,8 +726,10 @@ def dropout( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: x = ivy.astype(x, dtype) if dtype and x.dtype != dtype else x - res = tf.nn.dropout(x, prob, noise_shape=noise_shape, seed=seed) if training else x - res = res if scale else tf.multiply(res, (1.0 - prob)) + if prob == 0 or not training: + return x + res = tf.nn.dropout(x, prob, noise_shape=noise_shape, seed=seed) + res = tf.multiply(res, (1.0 - prob)) if not scale else res return res diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index ebf85483ded22..265663a68b16b 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -762,8 +762,10 @@ def dropout( out: Optional[torch.Tensor] = None, ) -> torch.Tensor: x = ivy.astype(x, dtype) if dtype and x.dtype != dtype else x - res = torch.nn.functional.dropout(x, prob, training=training) - res = res if scale else torch.multiply(res, (1.0 - prob)) + if prob == 0 or not training: + return x + res = torch.nn.functional.dropout(x, prob, training=True) + res = torch.multiply(res, (1.0 - prob)) if not scale else res return res diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index 4a226d7cdde67..bf143ebe8aca5 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -333,7 +333,7 @@ def depthwise_conv2d( @to_ivy_arrays_and_back def dropout(x, rate, noise_shape=None, seed=None, name=None): - return ivy.dropout(x, rate, noise_shape=noise_shape, seed=seed) + return ivy.dropout(x, rate, noise_shape=noise_shape, training=True, seed=seed) @with_unsupported_dtypes({"2.11.1 and below": ("complex",)}, "tensorflow") diff --git a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py index ac6fc71dbf4ab..3247afeb2cd66 100644 --- a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py @@ -30,7 +30,7 @@ def alpha_dropout(input, p=0.5, training=False, inplace=False): @to_ivy_arrays_and_back @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") def dropout(input, p=0.5, training=True, inplace=False): - return ivy.dropout(input, p, training=training) + return ivy.dropout(input, p, scale=True, training=training) @to_ivy_arrays_and_back diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 72a999a9809d7..43a18e56a73d7 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -396,7 +396,7 @@ def dropout( } """ if prob == 0 or not training: - if dtype is not None: + if dtype is not None and x.dtype != dtype: x = ivy.astype(x, dtype) return ivy.inplace_update(out, x) if ivy.exists(out) else x if noise_shape is None: diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py index 0ce5569b2f081..f4aae92c32b9e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py @@ -1186,24 +1186,37 @@ def test_tensorflow_dropout( on_device, ): (x_dtype, x), noise_shape, seed, rate = dtype_x_noiseshape - ret, frontend_ret = helpers.test_frontend_function( - input_dtypes=x_dtype, - backend_to_test=backend_fw, - frontend=frontend, - test_flags=test_flags, - fn_tree=fn_tree, - on_device=on_device, - test_values=False, - x=x[0], - rate=rate, - noise_shape=noise_shape, - seed=seed, - ) - ret = helpers.flatten_and_to_np(ret=ret) - frontend_ret = helpers.flatten_and_to_np(ret=frontend_ret) - for u, v, w in zip(ret, frontend_ret, x): - # cardinality test - assert u.shape == v.shape == w.shape + if rate == 0: + helpers.test_frontend_function( + input_dtypes=x_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x=x[0], + rate=rate, + noise_shape=noise_shape, + seed=seed, + ) + else: + ret = helpers.test_frontend_function( + input_dtypes=x_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + test_values=False, + x=x[0], + rate=rate, + noise_shape=noise_shape, + seed=seed, + ) + ret = helpers.flatten_and_to_np(ret=ret, backend=backend_fw) + for u in ret: + # cardinality test + assert u.shape == x[0].shape # embedding_lookup diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_dropout_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_dropout_functions.py index 16d6c9dc1a321..c7d6bac0556a1 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_dropout_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_dropout_functions.py @@ -80,23 +80,35 @@ def test_torch_dropout( backend_fw, ): input_dtype, x = dtype_and_x - ret = helpers.test_frontend_function( - input_dtypes=input_dtype, - backend_to_test=backend_fw, - frontend=frontend, - test_flags=test_flags, - fn_tree=fn_tree, - on_device=on_device, - input=x[0], - p=prob, - training=training, - test_values=False, - ) - ret = helpers.flatten_and_to_np(ret=ret, backend=backend_fw) - x = np.asarray(x[0], input_dtype[0]) - for u in ret: - # cardinality test - assert u.shape == x.shape + if not training or prob == 0: + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + input=x[0], + p=prob, + training=training, + ) + else: + ret = helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + input=x[0], + p=prob, + training=training, + test_values=False, + ) + ret = helpers.flatten_and_to_np(ret=ret, backend=backend_fw) + for u in ret: + # cardinality test + assert u.shape == x[0].shape @handle_frontend_test( diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index f33fbd155b80a..62aa3ed7b03fc 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -1326,28 +1326,44 @@ def test_dropout( on_device, ): (x_dtype, x), noise_shape, seed, dtype, prob, scale, training = data - ret, gt_ret = helpers.test_function( - input_dtypes=x_dtype, - test_flags=test_flags, - backend_to_test=backend_fw, - fn_name=fn_name, - on_device=on_device, - test_values=False, - x=x[0], - prob=prob, - scale=scale, - noise_shape=noise_shape, - dtype=dtype[0], - training=training, - seed=seed, - ) - ret = helpers.flatten_and_to_np(ret=ret, backend=backend_fw) - gt_ret = helpers.flatten_and_to_np( - ret=gt_ret, backend=test_flags.ground_truth_backend - ) - for u, v, w in zip(ret, gt_ret, x): - # cardinality test - assert u.shape == v.shape == w.shape + if not training or prob == 0: + helpers.test_function( + input_dtypes=x_dtype, + test_flags=test_flags, + backend_to_test=backend_fw, + fn_name=fn_name, + on_device=on_device, + x=x[0], + prob=prob, + scale=scale, + noise_shape=noise_shape, + dtype=dtype[0], + training=training, + seed=seed, + ) + else: + ret, gt_ret = helpers.test_function( + input_dtypes=x_dtype, + test_flags=test_flags, + backend_to_test=backend_fw, + fn_name=fn_name, + on_device=on_device, + test_values=False, + x=x[0], + prob=prob, + scale=scale, + noise_shape=noise_shape, + dtype=dtype[0], + training=training, + seed=seed, + ) + ret = helpers.flatten_and_to_np(ret=ret, backend=backend_fw) + gt_ret = helpers.flatten_and_to_np( + ret=gt_ret, backend=test_flags.ground_truth_backend + ) + for u, v, w in zip(ret, gt_ret, x): + # cardinality test + assert u.shape == v.shape == w.shape # linear From 5ccb4e3d41713627050572d2e5183c93f79074d5 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 23 Nov 2023 21:53:49 +0530 Subject: [PATCH 236/978] fix: Fixed passing `dims` argument in 1 function (#27376) Co-authored-by: @AnnaTz --- ivy/functional/frontends/torch/tensor.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 9fe391b0cb731..bf7ab631a2628 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -849,7 +849,8 @@ def permute(self, *args, dims=None): return torch_frontend.permute(self, dims) else: return torch_frontend.permute(self, args) - return torch_frontend.permute(self) + else: + raise ValueError("permute() got no values for argument 'dims'") @numpy_to_torch_style_args @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") From f55d00fbd507b57f7116c5018780ea83012ad92b Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 23 Nov 2023 17:52:51 +0000 Subject: [PATCH 237/978] feat: Added tensorflow backend for ivy.linear --- ivy/functional/backends/tensorflow/layers.py | 15 +++++++++++++++ .../test_functional/test_nn/test_layers.py | 3 ++- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 1fb3fe4b1613e..3f0ccffbcd06f 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -16,6 +16,21 @@ ) +@with_supported_dtypes( + {"2.15.0 and below": ("float", "int32", "int64", "complex")}, + backend_version, +) +def linear( + x: Union[tf.Tensor, tf.Variable], + weight: Union[tf.Tensor, tf.Variable], + /, + *, + bias: Optional[Union[tf.Tensor, tf.Variable]] = None, + out: Optional[Union[tf.Tensor, tf.Variable]] = None, +) -> Union[tf.Tensor, tf.Variable]: + return tf.einsum("...i,...ji->...j", x, weight) + bias + + def _x_dil_before_conv(x, dims, x_dilations, data_format): # adding dilation in input x_dilations = [x_dilations] * dims if isinstance(x_dilations, int) else x_dilations diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index 62aa3ed7b03fc..7da0237633a0e 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -689,7 +689,8 @@ def _x_and_linear(draw): mixed_fn_compos = draw(st.booleans()) is_torch_backend = ivy.current_backend_str() == "torch" dtype = draw( - helpers.get_dtypes("numeric", full=False, mixed_fn_compos=mixed_fn_compos) + # should sample from "valid" but with_supported_dtypes was not working + helpers.get_dtypes("float", full=False, mixed_fn_compos=mixed_fn_compos) ) in_features = draw( helpers.ints(min_value=1, max_value=2, mixed_fn_compos=mixed_fn_compos) From 8a20b613e4e2d34f0322c189c0e1545fee176d3f Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 23 Nov 2023 17:58:38 +0000 Subject: [PATCH 238/978] refactor: Refactored tf and torch backends of max pooling functions to limit the calls of pad and other extra operations --- .../tensorflow/experimental/layers.py | 119 ++++++++++-------- .../backends/torch/experimental/layers.py | 113 +++++++++-------- .../test_frontends/test_tensorflow/test_nn.py | 2 +- .../test_experimental/test_nn/test_layers.py | 18 +-- 4 files changed, 138 insertions(+), 114 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 62a3a34b38d51..72501f0416178 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -47,35 +47,42 @@ def max_pool1d( kernel, strides, padding, dilation, ceil_mode, dims, data_format ) - if data_format == "NCW": + permuted_x = False + if data_format == "NCW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 1)) kernel = [kernel[i] for i in [0, 2, 1]] if len(kernel) == (dims + 2) else kernel strides = ( [strides[i] for i in [0, 2, 1]] if len(strides) == (dims + 2) else strides ) - padding = ( - [padding[i] for i in [0, 2, 1]] - if isinstance(padding, list) and len(padding) == (dims + 2) - else padding - ) + data_format = "NWC" + permuted_x = True # determine depth pooling x, kernel, strides, depth_pooling = _determine_depth_max_pooling( - x, kernel, strides, dims, data_format="channel_last" + x, kernel, strides, dims, data_format=data_format ) if not depth_pooling: if ceil_mode: new_kernel = [kernel[0] + (kernel[0] - 1) * (dilation[0] - 1)] + if data_format == "NCW": + x_shape = x.shape[2:] + else: + x_shape = x.shape[1:-1] if isinstance(padding, str): - pad_w = _handle_padding(x.shape[1], strides[0], new_kernel[0], padding) + pad_w = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) padding = [(pad_w // 2, pad_w - pad_w // 2)] padding[0] = _padding_ceil_mode( - x.shape[1], new_kernel[0], padding[0], strides[0] + x_shape[0], new_kernel[0], padding[0], strides[0] ) - if ceil_mode or not isinstance(padding, str): - padding = [(0, 0)] + list(padding) + [(0, 0)] - x = tf.pad(x, padding, constant_values=-math.inf) + if isinstance(padding, list): + if any(item != 0 for sublist in padding for item in sublist): + if len(padding) < dims + 2: + if data_format == "NCW": + padding = [(0, 0), (0, 0), *padding] + else: + padding = [(0, 0), *padding, (0, 0)] + x = tf.pad(x, padding, constant_values=tf.math.reduce_min(x)) padding = "VALID" elif isinstance(padding, list): if any(item != 0 for sublist in padding for item in sublist): @@ -84,13 +91,13 @@ def max_pool1d( ) else: padding = "VALID" - res = tf.nn.pool(x, kernel, "MAX", strides, padding, dilations=dilation) + res = tf.nn.pool( + x, kernel, "MAX", strides, padding, dilations=dilation, data_format=data_format + ) if depth_pooling: res = tf.transpose(res, (0, 2, 1)) - # converting minimum value to -inf because tensorflow clips -inf to minimum value - res = tf.where(res <= ivy.finfo(res.dtype).min, -math.inf, res) - if data_format == "NCW": + if permuted_x: return tf.transpose(res, (0, 2, 1)) return res @@ -112,7 +119,8 @@ def max_pool2d( kernel, strides, padding, dilation, ceil_mode, dims, data_format ) - if data_format == "NCHW": + permuted_x = False + if data_format == "NCHW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 3, 1)) kernel = ( [kernel[i] for i in [0, 2, 3, 1]] if len(kernel) == (dims + 2) else kernel @@ -122,15 +130,12 @@ def max_pool2d( if len(strides) == (dims + 2) else strides ) - padding = ( - [padding[i] for i in [0, 2, 3, 1]] - if isinstance(padding, list) and len(padding) == (dims + 2) - else padding - ) + data_format = "NHWC" + permuted_x = True # determine depth pooling x, kernel, strides, depth_pooling = _determine_depth_max_pooling( - x, kernel, strides, dims, data_format="channel_last" + x, kernel, strides, dims, data_format=data_format ) if not depth_pooling: @@ -138,21 +143,29 @@ def max_pool2d( new_kernel = [ kernel[i] + (kernel[i] - 1) * (dilation[i] - 1) for i in range(dims) ] + if data_format == "NCHW": + x_shape = x.shape[2:] + else: + x_shape = x.shape[1:-1] if isinstance(padding, str): - pad_h = _handle_padding(x.shape[1], strides[0], new_kernel[0], padding) - pad_w = _handle_padding(x.shape[2], strides[1], new_kernel[1], padding) + pad_h = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) + pad_w = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) padding = [ (pad_h // 2, pad_h - pad_h // 2), (pad_w // 2, pad_w - pad_w // 2), ] - x_shape = x.shape[1:-1] for i in range(dims): padding[i] = _padding_ceil_mode( x_shape[i], new_kernel[i], padding[i], strides[i] ) - if ceil_mode or not isinstance(padding, str): - padding = [(0, 0)] + list(padding) + [(0, 0)] - x = tf.pad(x, padding, constant_values=-math.inf) + if isinstance(padding, list): + if any(item != 0 for sublist in padding for item in sublist): + if len(padding) < dims + 2: + if data_format == "NCHW": + padding = [(0, 0), (0, 0), *padding] + else: + padding = [(0, 0), *padding, (0, 0)] + x = tf.pad(x, padding, constant_values=tf.math.reduce_min(x)) padding = "VALID" elif isinstance(padding, list): if any(item != 0 for sublist in padding for item in sublist): @@ -161,13 +174,13 @@ def max_pool2d( ) else: padding = "VALID" - res = tf.nn.pool(x, kernel, "MAX", strides, padding, dilations=dilation) + res = tf.nn.pool( + x, kernel, "MAX", strides, padding, dilations=dilation, data_format=data_format + ) if depth_pooling: res = tf.transpose(res, (0, 2, 3, 1)) - # converting minimum value to -inf because tensorflow clips -inf to minimum value - res = tf.where(res <= ivy.finfo(res.dtype).min, -math.inf, res) - if data_format == "NCHW": + if permuted_x: return tf.transpose(res, (0, 3, 1, 2)) return res @@ -192,7 +205,8 @@ def max_pool3d( kernel, strides, padding, dilation, ceil_mode, dims, data_format ) - if data_format == "NCDHW": + permuted_x = False + if data_format == "NCDHW" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, 2, 3, 4, 1)) kernel = ( [kernel[i] for i in [0, 2, 3, 4, 1]] @@ -204,21 +218,23 @@ def max_pool3d( if len(strides) == (dims + 2) else strides ) - padding = ( - [padding[i] for i in [0, 2, 3, 4, 1]] - if isinstance(padding, list) and len(padding) == (dims + 2) - else padding - ) + data_format = "NDHWC" + permuted_x = True # determine depth pooling x, kernel, strides, depth_pooling = _determine_depth_max_pooling( - x, kernel, strides, dims, data_format="channel_last" + x, kernel, strides, dims, data_format=data_format ) if not depth_pooling: if ceil_mode: - new_kernel = [dilation[i] * (kernel[i] - 1) + 1 for i in range(dims)] - x_shape = x.shape[1:-1] + new_kernel = [ + kernel[i] + (kernel[i] - 1) * (dilation[i] - 1) for i in range(dims) + ] + if data_format == "NCDHW": + x_shape = x.shape[2:] + else: + x_shape = x.shape[1:-1] if isinstance(padding, str): pad_d = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) pad_h = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) @@ -232,9 +248,14 @@ def max_pool3d( padding[i] = _padding_ceil_mode( x_shape[i], new_kernel[i], padding[i], strides[i] ) - if ceil_mode or not isinstance(padding, str): - padding = [(0, 0)] + list(padding) + [(0, 0)] - x = tf.pad(x, padding, constant_values=-math.inf) + if isinstance(padding, list): + if any(item != 0 for sublist in padding for item in sublist): + if len(padding) < dims + 2: + if data_format == "NCDHW": + padding = [(0, 0), (0, 0), *padding] + else: + padding = [(0, 0), *padding, (0, 0)] + x = tf.pad(x, padding, constant_values=tf.math.reduce_min(x)) padding = "VALID" elif isinstance(padding, list): if any(item != 0 for sublist in padding for item in sublist): @@ -243,13 +264,13 @@ def max_pool3d( ) else: padding = "VALID" - res = tf.nn.pool(x, kernel, "MAX", strides, padding, dilations=dilation) + res = tf.nn.pool( + x, kernel, "MAX", strides, padding, dilations=dilation, data_format=data_format + ) if depth_pooling: res = tf.transpose(res, (0, 2, 3, 4, 1)) - # converting minimum value to -inf because tensorflow clips -inf to minimum value - res = tf.where(res <= ivy.finfo(res.dtype).min, -math.inf, res) - if data_format == "NCDHW": + if permuted_x: return tf.transpose(res, (0, 4, 1, 2, 3)) return res diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 265663a68b16b..09776b38d44aa 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -48,47 +48,47 @@ def max_pool1d( ) if data_format == "NWC": - x = x.permute((0, 2, 1)) + x = x.permute(0, 2, 1) kernel = [kernel[i] for i in [0, 2, 1]] if len(kernel) == (dims + 2) else kernel strides = ( [strides[i] for i in [0, 2, 1]] if len(strides) == (dims + 2) else strides ) - padding = ( - [padding[i] for i in [0, 2, 1]] - if isinstance(padding, list) and len(padding) == (dims + 2) - else padding - ) - # Determine deptwise pooling + # determine depth pooling x, kernel, strides, depth_pooling = _determine_depth_max_pooling( x, kernel, strides, dims, data_format="channel_first" ) if isinstance(padding, str): + x_shape = list(x.shape[2:]) new_kernel = [dilation[0] * (kernel[0] - 1) + 1] - pad_w = _handle_padding(x.shape[2], strides[0], new_kernel[0], padding) + pad_w = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) pad_list = [pad_w // 2, pad_w - pad_w // 2] else: - pad_list = [item for sublist in padding for item in sublist] - - if any(pad > 0 for pad in pad_list): - if not depth_pooling: - x = torch.nn.functional.pad( - x, - pad_list, - value=float("-inf"), - ) - else: + if any(item != 0 for sublist in padding for item in sublist) and depth_pooling: raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" ) + pad_list = [item for sublist in padding[::-1] for item in sublist] - res = torch.nn.functional.max_pool1d(x, kernel, strides, 0, dilation, ceil_mode) + if all(pad_list[i] == pad_list[i + 1] for i in range(0, 2 * dims, 2)) and all( + pad <= kernel_size / 2 for pad, kernel_size in zip(pad_list[::-2], kernel) + ): + res = torch.nn.functional.max_pool1d( + x, kernel, strides, pad_list[::-2], dilation, ceil_mode + ) + else: + x = torch.nn.functional.pad( + x, + pad_list, + value=float("-inf"), + ) + res = torch.nn.functional.max_pool1d(x, kernel, strides, 0, dilation, ceil_mode) if depth_pooling: res = torch.permute(res, (0, 2, 1)) if data_format == "NWC": - res = res.permute((0, 2, 1)) + return res.permute(0, 2, 1) return res @@ -128,11 +128,6 @@ def max_pool2d( if len(strides) == (dims + 2) else strides ) - padding = ( - [padding[i] for i in [0, 3, 1, 2]] - if isinstance(padding, list) and len(padding) == (dims + 2) - else padding - ) # determine depth pooling x, kernel, strides, depth_pooling = _determine_depth_max_pooling( @@ -146,21 +141,26 @@ def max_pool2d( pad_w = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) pad_list = [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2] else: - pad_list = [item for sublist in padding[::-1] for item in sublist] - - if any(pad > 0 for pad in pad_list): - if not depth_pooling: - x = torch.nn.functional.pad( - x, - pad_list, - value=float("-inf"), - ) - else: + if any(item != 0 for sublist in padding for item in sublist) and depth_pooling: raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" ) + pad_list = [item for sublist in padding[::-1] for item in sublist] + + if all(pad_list[i] == pad_list[i + 1] for i in range(0, 2 * dims, 2)) and all( + pad <= kernel_size / 2 for pad, kernel_size in zip(pad_list[::-2], kernel) + ): + res = torch.nn.functional.max_pool2d( + x, kernel, strides, pad_list[::-2], dilation, ceil_mode + ) + else: + x = torch.nn.functional.pad( + x, + pad_list, + value=float("-inf"), + ) + res = torch.nn.functional.max_pool2d(x, kernel, strides, 0, dilation, ceil_mode) - res = torch.nn.functional.max_pool2d(x, kernel, strides, 0, dilation, ceil_mode) if depth_pooling: res = torch.permute(res, (0, 2, 1, 3)) if data_format == "NHWC": @@ -206,20 +206,15 @@ def max_pool3d( if len(strides) == (dims + 2) else strides ) - padding = ( - [padding[i] for i in [0, 4, 1, 2, 3]] - if isinstance(padding, list) and len(padding) == (dims + 2) - else padding - ) - # Determine deptwise pooling + # determine depth pooling x, kernel, strides, depth_pooling = _determine_depth_max_pooling( x, kernel, strides, dims, data_format="channel_first" ) if isinstance(padding, str): - x_shape = x.shape[2:] - new_kernel = [dilation[i] * (kernel[i] - 1) + 1 for i in range(dims)] + x_shape = list(x.shape[2:]) + new_kernel = [kernel[i] + (kernel[i] - 1) * (dilation[i] - 1) for i in range(3)] pad_d = _handle_padding(x_shape[0], strides[0], new_kernel[0], padding) pad_h = _handle_padding(x_shape[1], strides[1], new_kernel[1], padding) pad_w = _handle_padding(x_shape[2], strides[2], new_kernel[2], padding) @@ -232,26 +227,30 @@ def max_pool3d( pad_d - pad_d // 2, ] else: - pad_list = [item for sublist in padding[::-1] for item in sublist] - - if any(pad > 0 for pad in pad_list): - if not depth_pooling: - x = torch.nn.functional.pad( - x, - pad_list, - value=float("-inf"), - ) - else: + if any(item != 0 for sublist in padding for item in sublist) and depth_pooling: raise NotImplementedError( "Nonzero explicit padding is not supported for depthwise max pooling" ) + pad_list = [item for sublist in padding[::-1] for item in sublist] - res = torch.nn.functional.max_pool3d(x, kernel, strides, 0, dilation, ceil_mode) + if all(pad_list[i] == pad_list[i + 1] for i in range(0, 2 * dims, 2)) and all( + pad <= kernel_size / 2 for pad, kernel_size in zip(pad_list[::-2], kernel) + ): + res = torch.nn.functional.max_pool3d( + x, kernel, strides, pad_list[::-2], dilation, ceil_mode + ) + else: + x = torch.nn.functional.pad( + x, + pad_list, + value=float("-inf"), + ) + res = torch.nn.functional.max_pool3d(x, kernel, strides, 0, dilation, ceil_mode) if depth_pooling: - res = res.permute(0, 2, 1, 3, 4) + res = torch.permute(res, (0, 2, 1, 3, 4)) if data_format == "NDHWC": - res = res.permute(0, 2, 3, 4, 1) + return res.permute(0, 2, 3, 4, 1) return res diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py index f4aae92c32b9e..a92976f53aecc 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py @@ -1483,7 +1483,7 @@ def test_tensorflow_max_pool2d( # max_pool3d @handle_frontend_test( fn_tree="tensorflow.nn.max_pool3d", - data_format=st.sampled_from(["NDHWC", "NCDHW"]), + data_format=st.just("NDHWC"), # Pooling3DOp only supports NDHWC on device type CPU x_k_s_p=helpers.arrays_for_pooling(min_dims=5, max_dims=5, min_side=1, max_side=4), test_with_out=st.just(False), ) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index caafbb8b4252c..ba074d564ba52 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -1165,12 +1165,9 @@ def test_max_pool2d( assume( not ( backend_fw == "tensorflow" - and ( - (stride[0] > kernel[0] or stride[0] > kernel[1]) - or ( - (stride[0] > 1 and dilation[0] > 1) - or (stride[0] > 1 and dilation[1] > 1) - ) + and all( + stride[i] > kernel[i] or (stride[i] > 1 and dilation[i] > 1) + for i in range(2) ) ) ) @@ -1223,7 +1220,14 @@ def test_max_pool3d( on_device, ): dtype, x, kernel, stride, pad, dilation, data_format = x_k_s_p - + assume( + not ( + backend_fw == "tensorflow" + and isinstance(pad, str) + and pad == "SAME" + and any(dil > 1 for dil in dilation) + ) + ) data_format = "NCDHW" if data_format == "channel_first" else "NDHWC" assume(not (isinstance(pad, str) and (pad.upper() == "VALID") and ceil_mode)) # TODO: Remove this once the paddle backend supports dilation From 344ee29f8e7f39c63e885ad25d0ceec972258d98 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 24 Nov 2023 10:48:25 +0530 Subject: [PATCH 239/978] fix: added installation of procps to the gpu dockerfile to fix the error installing tensorrt when installing tensorflow with cuda (#27380) --- docker/DockerfileGPU | 3 ++- docker/requirement_mappings_gpu.json | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/docker/DockerfileGPU b/docker/DockerfileGPU index 5eca7bab1a6cc..7cef64508c005 100644 --- a/docker/DockerfileGPU +++ b/docker/DockerfileGPU @@ -23,7 +23,8 @@ RUN grep security /etc/apt/sources.list | tee /etc/apt/security.sources.list && wget \ software-properties-common \ gcc \ - nano + nano \ + procps # install miniconda diff --git a/docker/requirement_mappings_gpu.json b/docker/requirement_mappings_gpu.json index 89586215a8504..a851f62b1ce3f 100644 --- a/docker/requirement_mappings_gpu.json +++ b/docker/requirement_mappings_gpu.json @@ -1,7 +1,7 @@ { - "tensorflow": ["tensorflow-probability"], "jax": ["dm-haiku", "flax"], "numpy": ["numpy"], "mxnet": ["mxnet"], - "torch": ["torch-scatter", "torchvision"] + "torch": ["torch-scatter", "torchvision"], + "tensorflow": ["tensorflow-probability"] } From ddf03d3106ed1a2547a8ddc27b491e46d6331791 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kacper=20Ko=C5=BCdo=C5=84?= <102428159+Kacper-W-Kozdon@users.noreply.github.com> Date: Fri, 24 Nov 2023 09:57:58 +0100 Subject: [PATCH 240/978] fix: fixes #26498 gather inplace update (#27377) Co-authored-by: @AnnaTz --- ivy/functional/backends/torch/general.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index beeab509335a7..8395caf0efd10 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -205,8 +205,9 @@ def gather( result.append(r) result = torch.stack(result) result = result.reshape([*params.shape[0:batch_dims], *result.shape[1:]]) - if out: - out[:] = result + if ivy.exists(out): + return ivy.inplace_update(out, result) + return result From e40024db710da67c3ee90311752f1eada33ecaac Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Fri, 24 Nov 2023 14:40:49 +0000 Subject: [PATCH 241/978] feat: Added filter_format argument to transpose convolution functions and fixed some pre-existing bugs. --- ivy/data_classes/array/layers.py | 25 +++++++-- ivy/data_classes/container/layers.py | 54 ++++++++++++++----- ivy/functional/backends/jax/layers.py | 16 ++++-- ivy/functional/backends/mxnet/layers.py | 4 ++ ivy/functional/backends/numpy/layers.py | 20 +++++++ ivy/functional/backends/paddle/layers.py | 19 ++++--- ivy/functional/backends/tensorflow/layers.py | 30 +++++++---- ivy/functional/backends/torch/layers.py | 16 ++++-- ivy/functional/frontends/tensorflow/nn.py | 3 -- .../nn/functional/convolution_functions.py | 4 +- ivy/functional/ivy/layers.py | 49 +++++++++++------ .../test_frontends/test_tensorflow/test_nn.py | 1 + .../test_convolution_functions.py | 21 ++++++++ .../test_functional/test_nn/test_layers.py | 37 ++++++------- 14 files changed, 218 insertions(+), 81 deletions(-) diff --git a/ivy/data_classes/array/layers.py b/ivy/data_classes/array/layers.py index fd1a9a22dc968..f4c42a5d6de6d 100644 --- a/ivy/data_classes/array/layers.py +++ b/ivy/data_classes/array/layers.py @@ -530,6 +530,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[int, Tuple[int]] = 1, bias: Optional[ivy.Array] = None, @@ -545,7 +546,7 @@ def conv1d_transpose( self Input image *[batch_size,w,d_in]* or *[batch_size,d_in,w]*. filters - Convolution filters *[fw,d_in,d_out]*. + Convolution filters *[fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -554,6 +555,9 @@ def conv1d_transpose( to apply before and after each spatial dimension. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IOW",input data formats, while "channel_last" corresponds to "WOI". data_format The ordering of the dimensions in the input, one of "NWC" or "NCW". "NWC" corresponds to input with shape (batch_size, width, channels), while "NCW" @@ -588,6 +592,7 @@ def conv1d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, bias=bias, @@ -739,6 +744,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[int, Tuple[int, int]] = 1, out: Optional[ivy.Array] = None, @@ -754,7 +760,7 @@ def conv2d_transpose( self Input image *[batch_size,h,w,d_in]* or *[batch_size,d_in,h,w]*. filters - Convolution filters *[fh,fw,d_in,d_out]*. + Convolution filters *[fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -762,6 +768,9 @@ def conv2d_transpose( per-dimension paddings. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IOHW",input data formats, while "channel_last" corresponds to "HWOI". data_format The ordering of the dimensions in the input, one of "NHWC" or "NCHW". "NHWC" corresponds to inputs with shape (batch_size, height, width, channels), @@ -783,7 +792,7 @@ def conv2d_transpose( Examples -------- >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 28, 28, 3]) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 6, 3]) >>> y = x.conv2d_transpose(filters,2,'SAME',) >>> print(y.shape) (1, 56, 56, 6) @@ -794,6 +803,7 @@ def conv2d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, out=out, @@ -880,6 +890,7 @@ def conv3d_transpose( /, *, output_shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None, + filter_format: str = "channel_last", data_format: str = "NDHWC", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, bias: Optional[ivy.Array] = None, @@ -895,7 +906,7 @@ def conv3d_transpose( self Input volume *[batch_size,d,h,w,d_in]* or *[batch_size,d_in,d,h,w]*. filters - Convolution filters *[fd,fh,fw,d_in,d_out]*. + Convolution filters *[fd,fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -903,6 +914,9 @@ def conv3d_transpose( the per-dimension paddings. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IODHW",input data formats, while "channel_last" corresponds to "DHWOI". data_format The ordering of the dimensions in the input, one of "NDHWC" or "NCDHW". "NDHWC" corresponds to inputs with shape (batch_size, @@ -925,7 +939,7 @@ def conv3d_transpose( Examples -------- >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 3, 28, 28, 3]) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6, 3]) >>> y = x.conv3d_transpose(filters, 2, 'SAME') >>> print(y.shape) (1, 6, 56, 56, 6) @@ -936,6 +950,7 @@ def conv3d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, bias=bias, diff --git a/ivy/data_classes/container/layers.py b/ivy/data_classes/container/layers.py index b2740bd33dbe2..aad198392b2e7 100644 --- a/ivy/data_classes/container/layers.py +++ b/ivy/data_classes/container/layers.py @@ -1568,6 +1568,7 @@ def _static_conv1d_transpose( /, *, output_shape: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[int, Tuple[int]] = 1, key_chains: Optional[Union[List[str], Dict[str, str]]] = None, @@ -1587,7 +1588,7 @@ def _static_conv1d_transpose( x Input image *[batch_size,w,d_in]* or *[batch_size,d_in,w]*. filters - Convolution filters *[fw,d_in,d_out]*. + Convolution filters *[fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -1596,6 +1597,9 @@ def _static_conv1d_transpose( to apply before and after each spatial dimension. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IOW",input data formats, while "channel_last" corresponds to "WOI". data_format The ordering of the dimensions in the input, one of "NWC" or "NCW". "NWC" corresponds to input with shape (batch_size, width, channels), while "NCW" @@ -1628,7 +1632,7 @@ def _static_conv1d_transpose( -------- >>> x = ivy.Container(a=ivy.random_normal(mean=0, std=1, shape=[1, 28, 3]), ... b=ivy.random_normal(mean=0, std=1, shape=[1, 56, 3])) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 6, 3]) >>> y = ivy.Container.static_conv1d_transpose(x, filters, 2, 'SAME') >>> print(y.shape) { @@ -1643,6 +1647,7 @@ def _static_conv1d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, key_chains=key_chains, @@ -1661,6 +1666,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: int = 1, key_chains: Optional[Union[List[str], Dict[str, str]]] = None, @@ -1680,7 +1686,7 @@ def conv1d_transpose( self Input image *[batch_size,w,d_in]* or *[batch_size,d_in,w]*. filters - Convolution filters *[fw,d_in,d_out]*. + Convolution filters *[fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -1689,6 +1695,9 @@ def conv1d_transpose( to apply before and after each spatial dimension. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IOW",input data formats, while "channel_last" corresponds to "WOI". data_format The ordering of the dimensions in the input, one of "NWC" or "NCW". "NWC" corresponds to input with shape (batch_size, width, channels), while "NCW" @@ -1721,7 +1730,7 @@ def conv1d_transpose( -------- >>> x = ivy.Container(a=ivy.random_normal(mean=0, std=1, shape=[1, 28, 3]), ... b=ivy.random_normal(mean=0, std=1, shape=[1, 56, 3])) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 6, 3]) >>> y = x.conv1d_transpose(filters, 2, 'SAME') >>> print(y.shape) { @@ -1735,6 +1744,7 @@ def conv1d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, key_chains=key_chains, @@ -1754,6 +1764,7 @@ def _static_conv2d_transpose( /, *, output_shape: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[int, Tuple[int, int]] = 1, key_chains: Optional[Union[List[str], Dict[str, str]]] = None, @@ -1773,7 +1784,7 @@ def _static_conv2d_transpose( x Input image *[batch_size,h,w,d_in]*. filters - Convolution filters *[fh,fw,d_in,d_out]*. + Convolution filters *[fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -1781,6 +1792,9 @@ def _static_conv2d_transpose( the per-dimension paddings. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IOHW",input data formats, while "channel_last" corresponds to "HWOI". data_format "NHWC" or "NCHW". Defaults to "NHWC". dilations @@ -1811,8 +1825,8 @@ def _static_conv2d_transpose( -------- >>> a = ivy.random_normal(mean=0, std=1, shape=[1, 14, 14, 3]) >>> b = ivy.random_normal(mean=0, std=1, shape=[1, 28, 28, 3]) - >>> c = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6]) - >>> d = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6]) + >>> c = ivy.random_normal(mean=0, std=1, shape=[3, 3, 6, 3]) + >>> d = ivy.random_normal(mean=0, std=1, shape=[3, 3, 6, 3]) >>> x = ivy.Container(a=a, b=b) >>> filters = ivy.Container(c=c, d=d) >>> y = ivy.Container.static_conv2d_transpose(x, filters, 2, 'SAME') @@ -1835,6 +1849,7 @@ def _static_conv2d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, key_chains=key_chains, @@ -1853,6 +1868,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[int, Tuple[int, int]] = 1, key_chains: Optional[Union[List[str], Dict[str, str]]] = None, @@ -1872,7 +1888,7 @@ def conv2d_transpose( self Input image *[batch_size,h,w,d_in]*. filters - Convolution filters *[fh,fw,d_in,d_out]*. + Convolution filters *[fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -1880,6 +1896,9 @@ def conv2d_transpose( the per-dimension paddings. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IOHW",input data formats, while "channel_last" corresponds to "HWOI". data_format "NHWC" or "NCHW". Defaults to "NHWC". dilations @@ -1941,6 +1960,7 @@ def conv2d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, key_chains=key_chains, @@ -2274,6 +2294,7 @@ def _static_conv3d_transpose( /, *, output_shape: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, + filter_format: str = "channel_last", data_format: str = "NDHWC", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, key_chains: Optional[Union[List[str], Dict[str, str]]] = None, @@ -2294,7 +2315,7 @@ def _static_conv3d_transpose( Input container with leaves of volume *[batch_size,d,h,w,d_in]* or *[batch_size,d_in,d,h,w]*. filters - Convolution filters *[fd,fh,fw,d_in,d_out]*. + Convolution filters *[fd,fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -2302,6 +2323,9 @@ def _static_conv3d_transpose( the per-dimension paddings. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IODHW",input data formats, while "channel_last" corresponds to "DHWOI". data_format The ordering of the dimensions in the input, one of "NDHWC" or "NCDHW". "NDHWC" corresponds to inputs with shape (batch_size, @@ -2323,8 +2347,8 @@ def _static_conv3d_transpose( >>> a = ivy.random_normal(mean=0, std=1, shape=[1, 3, 14, 14, 3]) >>> b = ivy.random_normal(mean=0, std=1, shape=[1, 3, 28, 28, 3])) - >>> c = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 3, 6]) - >>> d = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 3, 6])) + >>> c = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6, 3]) + >>> d = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6, 3])) >>> x = ivy.Container(a=a, b=b) >>> filters = ivy.Container(c=c, d=d) >>> y = ivy.Container.static_conv3d_transpose(x, filters, 2, 'SAME') @@ -2347,6 +2371,7 @@ def _static_conv3d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, key_chains=key_chains, @@ -2367,6 +2392,7 @@ def conv3d_transpose( /, *, output_shape: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, + filter_format: str = "channel_last", data_format: str = "NDHWC", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, key_chains: Optional[Union[List[str], Dict[str, str]]] = None, @@ -2387,7 +2413,7 @@ def conv3d_transpose( Input container with leaves of volume *[batch_size,d,h,w,d_in]* or *[batch_size,d_in,d,h,w]*. filters - Convolution filters *[fd,fh,fw,d_in,d_out]*. + Convolution filters *[fd,fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -2395,6 +2421,9 @@ def conv3d_transpose( the per-dimension paddings. output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IODHW",input data formats, while "channel_last" corresponds to "DHWOI". data_format The ordering of the dimensions in the input, one of "NDHWC" or "NCDHW". "NDHWC" corresponds to inputs with shape (batch_size, @@ -2437,6 +2466,7 @@ def conv3d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, key_chains=key_chains, diff --git a/ivy/functional/backends/jax/layers.py b/ivy/functional/backends/jax/layers.py index 001de4a03d0ff..37bd852c7c3a6 100644 --- a/ivy/functional/backends/jax/layers.py +++ b/ivy/functional/backends/jax/layers.py @@ -130,6 +130,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[int, Tuple[int]] = 1, bias: Optional[JaxArray] = None, @@ -141,7 +142,8 @@ def conv1d_transpose( x_shape = list(x.shape[1:2]) else: x_shape = list(x.shape[2:]) - filters = jnp.swapaxes(filters, -1, -2) + if filter_format == "channel_first": + filters = jnp.transpose(filters, (2, 1, 0)) padding = _get_tranpose_padding( x_shape, filters.shape, strides, padding, 1, dilations, output_shape ) @@ -198,6 +200,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[int, Tuple[int, int]] = 1, bias: Optional[JaxArray] = None, @@ -209,7 +212,8 @@ def conv2d_transpose( x_shape = list(x.shape[1:3]) else: x_shape = list(x.shape[2:]) - filters = jnp.swapaxes(filters, -1, -2) + if filter_format == "channel_first": + filters = jnp.transpose(filters, (2, 3, 1, 0)) padding = _get_tranpose_padding( x_shape, filters.shape, strides, padding, 2, dilations, output_shape ) @@ -299,13 +303,15 @@ def conv3d_transpose( *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, dilations: Union[int, Tuple[int, int, int]] = 1, + filter_format: str = "channel_last", data_format: str = "NDHWC", bias: Optional[JaxArray] = None, out: Optional[JaxArray] = None, ) -> JaxArray: strides = [strides] * 3 if isinstance(strides, int) else strides dilations = [dilations] * 3 if isinstance(dilations, int) else dilations - filters = jnp.swapaxes(filters, -1, -2) + if filter_format == "channel_first": + filters = jnp.transpose(filters, (2, 3, 4, 1, 0)) if data_format == "NDHWC": x_shape = list(x.shape[1:4]) else: @@ -417,6 +423,7 @@ def conv_general_transpose( *, dims: int = 2, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "channel_last", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, feature_group_count: Optional[int] = 1, @@ -425,7 +432,8 @@ def conv_general_transpose( ): strides = [strides] * dims if isinstance(strides, int) else strides dilations = [dilations] * dims if isinstance(dilations, int) else dilations - filters = jnp.swapaxes(filters, -1, -2) + if filter_format == "channel_first": + filters = jnp.transpose(filters, (*range(2, dims + 2), 1, 0)) df = _get_x_data_format(dims, "channel_last") filter_df = _get_filter_dataformat(dims) if data_format == "channel_first": diff --git a/ivy/functional/backends/mxnet/layers.py b/ivy/functional/backends/mxnet/layers.py index a30c494799fbd..5bb1ed3d5a26f 100644 --- a/ivy/functional/backends/mxnet/layers.py +++ b/ivy/functional/backends/mxnet/layers.py @@ -31,6 +31,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[(ivy.NativeShape, Sequence[int])]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[(int, Tuple[int])] = 1, out: Optional[Union[(None, mx.ndarray.NDArray)]] = None, @@ -60,6 +61,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[(ivy.NativeShape, Sequence[int])]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[(int, Tuple[(int, int)])] = 1, out: Optional[Union[(None, mx.ndarray.NDArray)]] = None, @@ -103,6 +105,7 @@ def conv3d_transpose( /, *, output_shape: Optional[Union[(ivy.NativeShape, Sequence[int])]] = None, + filter_format: str = "channel_last", data_format: str = "NDHWC", dilations: Union[(int, Tuple[(int, int, int)])] = 1, out: Optional[Union[(None, mx.ndarray.NDArray)]] = None, @@ -138,6 +141,7 @@ def conv_general_transpose( /, *, dims: int = 2, + filter_format: str = "channel_last", data_format: str = "channel_last", output_shape: Optional[Union[(ivy.NativeShape, Sequence[int])]] = None, dilations: Union[(int, Tuple[int], Tuple[(int, int)], Tuple[(int, int, int)])] = 1, diff --git a/ivy/functional/backends/numpy/layers.py b/ivy/functional/backends/numpy/layers.py index 52ad223304735..d6d4ebc27b20a 100644 --- a/ivy/functional/backends/numpy/layers.py +++ b/ivy/functional/backends/numpy/layers.py @@ -174,6 +174,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[int, Tuple[int]] = 1, bias: Optional[np.ndarray] = None, @@ -181,6 +182,10 @@ def conv1d_transpose( ) -> np.ndarray: if data_format == "NCW": x = np.transpose(x, (0, 2, 1)) + if filter_format == "channel_last": + filters = np.transpose(filters, (0, 2, 1)) + else: + filters = np.transpose(filters, (2, 0, 1)) x, filters = _dilate_pad_conv_tranpose( x, filters, strides, padding, 1, dilations, output_shape ) @@ -259,6 +264,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[int, Tuple[int, int]] = 1, bias: Optional[np.ndarray] = None, @@ -266,6 +272,10 @@ def conv2d_transpose( ): if data_format == "NCHW": x = np.transpose(x, (0, 2, 3, 1)) + if filter_format == "channel_last": + filters = np.transpose(filters, (0, 1, 3, 2)) + else: + filters = np.transpose(filters, (2, 3, 0, 1)) x, filters = _dilate_pad_conv_tranpose( x, filters, strides, padding, 2, dilations, output_shape ) @@ -403,6 +413,7 @@ def conv3d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NDHWC", dilations: Union[int, Tuple[int, int, int]] = 1, bias: Optional[np.ndarray] = None, @@ -410,6 +421,10 @@ def conv3d_transpose( ): if data_format == "NCDHW": x = np.transpose(x, (0, 2, 3, 4, 1)) + if filter_format == "channel_last": + filters = np.transpose(filters, (0, 1, 2, 4, 3)) + else: + filters = np.transpose(filters, (2, 3, 4, 0, 1)) x, filters = _dilate_pad_conv_tranpose( x, filters, strides, padding, 3, dilations, output_shape ) @@ -511,6 +526,7 @@ def conv_general_transpose( *, dims: int = 2, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "channel_last", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, feature_group_count: int = 1, @@ -519,6 +535,10 @@ def conv_general_transpose( ) -> np.ndarray: if data_format == "channel_first": x = np.transpose(x, (0, *range(2, dims + 2), 1)) + if filter_format == "channel_last": + filters = np.transpose(filters, (*range(dims), dims + 1, dims)) + else: + filters = np.transpose(filters, (*range(2, dims + 2), 0, 1)) x, filters = _dilate_pad_conv_tranpose( x, filters, strides, padding, dims, dilations, output_shape diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index 9a27ab9272cb1..4798e13e3f64f 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -168,6 +168,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[int, Tuple[int]] = 1, bias: Optional[paddle.Tensor] = None, @@ -177,7 +178,8 @@ def conv1d_transpose( x = x.transpose([0, 2, 1]) strides = [strides] if isinstance(strides, int) else strides dilations = [dilations] if isinstance(dilations, int) else dilations - filters = filters.transpose([1, 2, 0]) + if filter_format == "channel_last": + filters = filters.transpose([2, 1, 0]) not_valid_pad, padding_list, output_padding = _pad_before_conv_tranpose( x, filters, strides, padding, 1, dilations, output_shape, filters.shape[2:] ) @@ -216,7 +218,7 @@ def conv2d( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, + {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version, ) def conv2d_transpose( @@ -227,6 +229,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: Optional[str] = "NHWC", dilations: Optional[Union[int, Tuple[int, int]]] = 1, bias: Optional[paddle.Tensor] = None, @@ -236,7 +239,8 @@ def conv2d_transpose( x = x.transpose([0, 3, 1, 2]) strides = [strides] * 2 if isinstance(strides, int) else strides dilations = [dilations] * 2 if isinstance(dilations, int) else dilations - filters = filters.transpose([2, 3, 0, 1]) + if filter_format == "channel_last": + filters = filters.transpose([3, 2, 0, 1]) not_valid_pad, padding_list, output_padding = _pad_before_conv_tranpose( x, filters, strides, padding, 2, dilations, output_shape, filters.shape[2:] ) @@ -325,6 +329,7 @@ def conv3d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: Optional[str] = "NDHWC", dilations: Optional[Union[int, Tuple[int, int, int]]] = 1, bias: Optional[paddle.Tensor] = None, @@ -427,6 +432,7 @@ def conv_general_transpose( *, dims: Optional[int] = 2, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: Optional[str] = "NDHWC", dilations: Optional[ Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] @@ -436,10 +442,11 @@ def conv_general_transpose( out: Optional[paddle.Tensor] = None, ): if data_format == "channel_last": - x = x.transpose(x, (0, dims + 1, *range(1, dims + 1))) + x = x.transpose([0, dims + 1, *range(1, dims + 1)]) + if filter_format == "channel_last": + filters = filters.transpose([dims + 1, dims, *range(dims)]) strides = [strides] * dims if isinstance(strides, int) else strides dilations = [dilations] * dims if isinstance(dilations, int) else dilations - filters = filters.transpose(dims, dims + 1, *range(dims)) not_valid_pad, padding_list, output_padding = _pad_before_conv_tranpose( x, filters, strides, padding, dims, dilations, output_shape, filters.shape[2:] ) @@ -492,5 +499,5 @@ def conv_general_transpose( if not_valid_pad[2]: res = res[:, :, :, 0:-1] if data_format == "channel_last": - res = res.transpose(0, *range(2, dims + 2), 1) + res = res.transpose([0, *range(2, dims + 2), 1]) return res diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 3f0ccffbcd06f..979a51ec4fa14 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -148,6 +148,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[int, Tuple[int]] = 1, bias: Optional[Union[tf.Tensor, tf.Variable]] = None, @@ -164,7 +165,8 @@ def conv1d_transpose( x = tf.transpose(x, (0, 2, 1)) data_format = "NWC" permuted_x = True - filters = tf.transpose(filters, (0, 2, 1)) + if filter_format == "channel_first": + filters = tf.transpose(filters, (2, 1, 0)) output_shape, padding = _transpose_out_pad( x.shape, filters.shape, strides, padding, 1, dilations, data_format ) @@ -235,6 +237,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[int, Tuple[int, int]] = 1, bias: Optional[Union[tf.Tensor, tf.Variable]] = None, @@ -251,7 +254,8 @@ def conv2d_transpose( x = tf.transpose(x, (0, 2, 3, 1)) data_format = "NHWC" permuted_x = True - filters = tf.transpose(filters, (0, 1, 3, 2)) + if filter_format == "channel_first": + filters = tf.transpose(filters, (2, 3, 1, 0)) output_shape, padding = _transpose_out_pad( x.shape, filters.shape, @@ -340,6 +344,7 @@ def conv3d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NDHWC", dilations: Union[int, Tuple[int, int, int]] = 1, bias: Optional[Union[tf.Tensor, tf.Variable]] = None, @@ -356,7 +361,8 @@ def conv3d_transpose( x = tf.transpose(x, (0, 2, 3, 4, 1)) data_format = "NDHWC" permuted_x = True - filters = tf.transpose(filters, (0, 1, 2, 4, 3)) + if filter_format == "channel_first": + filters = tf.transpose(filters, (2, 3, 4, 1, 0)) output_shape, padding = _transpose_out_pad( x.shape, filters.shape, strides, padding, 3, dilations, data_format ) @@ -534,6 +540,7 @@ def conv_general_transpose( /, *, dims: int = 2, + filter_format: str = "channel_last", data_format: str = "channel_last", output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, @@ -549,6 +556,7 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format="NWC" if data_format == "channel_last" else "NCW", dilations=dilations, bias=bias, @@ -560,6 +568,7 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format="NHWC" if data_format == "channel_last" else "NCHW", dilations=dilations, bias=bias, @@ -571,11 +580,14 @@ def conv_general_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format="NDHWC" if data_format == "channel_last" else "NCDHW", dilations=dilations, bias=bias, ) else: + if filter_format == "channel_first": + filters = tf.transpose(filters, (*range(2, dims + 2), 1, 0)) permuted_x = False if data_format == "channel_first" and ivy.dev(x) == "cpu": x = tf.transpose(x, (0, *range(2, dims + 2), 1)) @@ -596,9 +608,9 @@ def conv_general_transpose( filters[ ..., j : j + filters.shape[-2] // feature_group_count, : ], + output_shape, strides, - padding, - output_shape=output_shape, + padding=padding, data_format=data_format, dilations=dilations, ) @@ -616,9 +628,9 @@ def conv_general_transpose( filters[ ..., j : j + filters.shape[-2] // feature_group_count, : ], + output_shape, strides, - padding, - output_shape=output_shape, + padding=padding, data_format=data_format, dilations=dilations, ) @@ -639,9 +651,9 @@ def conv_general_transpose( filters[ ..., j : j + filters.shape[-2] // feature_group_count, : ], + output_shape, strides, - padding, - output_shape=output_shape, + padding=padding, data_format=data_format, dilations=dilations, ) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index a90c6d81f8970..8b278ebada027 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -341,6 +341,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[int, Tuple[int]] = 1, bias: Optional[torch.Tensor] = None, @@ -348,7 +349,8 @@ def conv1d_transpose( ): if data_format == "NWC": x = x.permute(0, 2, 1) - filters = filters.permute(1, 2, 0) + if filter_format == "channel_last": + filters = filters.permute(2, 1, 0) not_valid_pad, symmetric_padding, output_padding = _tranpose_padding( x.shape[2:], filters.shape[2:], @@ -464,6 +466,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[int, Tuple[int, int]] = 1, bias: Optional[torch.Tensor] = None, @@ -471,7 +474,8 @@ def conv2d_transpose( ): if data_format == "NHWC": x = x.permute(0, 3, 1, 2) - filters = filters.permute(2, 3, 0, 1) + if filter_format == "channel_last": + filters = filters.permute(3, 2, 0, 1) not_valid_pad, symmetric_padding, output_padding = _tranpose_padding( x.shape[2:], filters.shape[2:], @@ -623,6 +627,7 @@ def conv3d_transpose( /, *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "NDHWC", dilations: Union[int, Tuple[int, int, int]] = 1, bias: Optional[torch.Tensor] = None, @@ -630,7 +635,8 @@ def conv3d_transpose( ) -> torch.Tensor: if data_format == "NDHWC": x = x.permute(0, 4, 1, 2, 3) - filters = filters.permute(3, 4, 0, 1, 2) + if filter_format == "channel_last": + filters = filters.permute(4, 3, 0, 1, 2) not_valid_pad, symmetric_padding, output_padding = _tranpose_padding( x.shape[2:], filters.shape[2:], @@ -777,6 +783,7 @@ def conv_general_transpose( *, dims: int = 2, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, + filter_format: str = "channel_last", data_format: str = "channel_first", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, feature_group_count: int = 1, @@ -785,7 +792,8 @@ def conv_general_transpose( ): if data_format == "channel_last": x = x.permute(0, dims + 1, *range(1, dims + 1)) - filters = filters.permute(dims, dims + 1, *range(dims)) + if filter_format == "channel_last": + filters = filters.permute(dims + 1, dims, *range(dims)) not_valid_pad, symmetric_padding, output_padding = _tranpose_padding( x.shape[2:], filters.shape[2:], diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index bf143ebe8aca5..398f88faa8c65 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -160,7 +160,6 @@ def conv1d_transpose( ): dilations = 1 if dilations is None else dilations strides, dilations = _reduce_strides_dilations(1, strides, dilations) - filters = filters.swapaxes(-2, -1) return ivy.conv1d_transpose( input, filters, @@ -198,7 +197,6 @@ def conv2d_transpose( dilations = 1 if dilations is None else dilations strides, dilations = _reduce_strides_dilations(2, strides, dilations) padding = _reduce_padding(padding, data_format) - filters = filters.swapaxes(-2, -1) return ivy.conv2d_transpose( input, filters, @@ -235,7 +233,6 @@ def conv3d_transpose( ): dilations = 1 if dilations is None else dilations strides, dilations = _reduce_strides_dilations(3, strides, dilations) - filters = filters.swapaxes(-2, -1) return ivy.conv3d_transpose( input, filters, diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index 782efc8e75f9b..66d385262a6b2 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -234,20 +234,20 @@ def conv_transpose2d( ): if ivy.current_backend_str() in ["torch", "tensorflow"]: # these two backends support explicit padding, no need for conv_general_dilated - weight = ivy.permute_dims(weight, axes=(2, 3, 0, 1)) return ivy.conv_general_transpose( input, weight, stride, _get_transpose_pad(padding, output_padding, 2), dims=2, + filter_format="channel_first", data_format="channel_first", dilations=dilation, feature_group_count=groups, bias=bias, ) else: - _conv_transpose( + return _conv_transpose( input, weight, bias=bias, diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 43a18e56a73d7..5db59cd1ee9e0 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -1128,6 +1128,7 @@ def conv1d_transpose( /, *, output_shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None, + filter_format: str = "channel_last", data_format: str = "NWC", dilations: Union[int, Tuple[int]] = 1, bias: Optional[ivy.Array] = None, @@ -1141,7 +1142,7 @@ def conv1d_transpose( x Input image *[batch_size,w,d_in]* or *[batch_size,d_in,w]*. filters - Convolution filters *[fw,d_in,d_out]*. + Convolution filters *[fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -1149,6 +1150,9 @@ def conv1d_transpose( input's), or ‘VALID’ (padding so that the output's shape is `output_shape`). output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IOW",input data formats, while "channel_last" corresponds to "WOI". data_format The ordering of the dimensions in the input, one of "NWC" or "NCW". "NWC" corresponds to input with shape (batch_size, width, channels), while "NCW" @@ -1175,7 +1179,7 @@ def conv1d_transpose( With :class:`ivy.Array` input: >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 28, 3]) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 6, 3]) >>> y = ivy.conv1d_transpose(x, filters, 2, 'SAME') >>> print(y.shape) ivy.Shape(1, 56, 6) @@ -1188,7 +1192,7 @@ def conv1d_transpose( >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 256, 64]) >>> y = ivy.zeros((1, 258, 32)) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 64, 32]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 32, 64]) >>> ivy.conv1d_transpose(x, filters, 1, 'VALID', out=y) >>> print(y.shape) ivy.Shape(1, 258, 32) @@ -1196,9 +1200,9 @@ def conv1d_transpose( With :class:`ivy.NativeArray` input: >>> x = ivy.native_array( - ... ivy.random_normal(mean=0, std=1, shape=[1,256,128])) + ... ivy.random_normal(mean=0, std=1, shape=[1, 256, 128])) >>> filters = ivy.native_array( - ... ivy.random_normal(mean=0, std=1, shape=[3, 128, 32])) + ... ivy.random_normal(mean=0, std=1, shape=[3, 32, 128])) >>> y = ivy.conv1d_transpose(x, filters, 2, 'SAME') >>> print(y.shape) ivy.Shape(1, 512, 32) @@ -1251,6 +1255,7 @@ def conv1d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, bias=bias, @@ -1414,6 +1419,7 @@ def conv2d_transpose( /, *, output_shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None, + filter_format: str = "channel_last", data_format: str = "NHWC", dilations: Union[int, Tuple[int, int]] = 1, bias: Optional[ivy.Array] = None, @@ -1427,7 +1433,7 @@ def conv2d_transpose( x Input image *[batch_size,h,w,d_in]* or *[batch_size,d_in,h,w]*. filters - Convolution filters *[fh,fw,d_in,d_out]*. + Convolution filters *[fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -1440,8 +1446,8 @@ def conv2d_transpose( corresponds to inputs with shape (batch_size, height, width, channels), while "NCHW" corresponds to input with shape (batch_size, channels, height, width). filter_format - Either "channel_first" or "channel_last". "channel_first" corresponds to - "OIDHW" input data formats, while "channel_last" corresponds to "DHWIO" . + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IOHW",input data formats, while "channel_last" corresponds to "HWOI". x_dilations The dilation factor for each dimension of input. (Default value = 1) dilations @@ -1465,7 +1471,7 @@ def conv2d_transpose( -------- With :class:`ivy.Array` input: >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 28, 28, 3]) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 6, 3]) >>> y = ivy.conv2d_transpose(x,filters,2,'SAME') >>> print(y.shape) ivy.Shape(1, 56, 56, 6) @@ -1478,7 +1484,7 @@ def conv2d_transpose( >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 256, 256, 64]) >>> y = ivy.zeros((1, 258, 258, 32)) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 64, 32]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 32, 64]) >>> ivy.conv2d_transpose(x,filters,[1, 1, 1],'VALID',out=y) >>> print(y.shape) ivy.Shape(1, 258, 258, 32) @@ -1529,6 +1535,7 @@ def conv2d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, bias=bias, @@ -1813,6 +1820,7 @@ def conv3d_transpose( /, *, output_shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None, + filter_format: str = "channel_last", data_format: str = "NDHWC", dilations: Union[int, Tuple[int, int, int]] = 1, bias: Optional[ivy.Array] = None, @@ -1826,7 +1834,7 @@ def conv3d_transpose( x Input volume *[batch_size,d,h,w,d_in]* or *[batch_size,d_in,d,h,w]*. filters - Convolution filters *[fd,fh,fw,d_in,d_out]*. + Convolution filters *[fd,fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -1834,6 +1842,9 @@ def conv3d_transpose( input's), or ‘VALID’ (padding so that the output's shape is `output_shape`). output_shape Shape of the output (Default value = None) + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IODHW",input data formats, while "channel_last" corresponds to "DHWOI". data_format The ordering of the dimensions in the input, one of "NDHWC" or "NCDHW". "NDHWC" corresponds to inputs with shape (batch_size, depth, height, width, channels), @@ -1857,13 +1868,13 @@ def conv3d_transpose( With :class:`ivy.Array` input: >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 3, 28, 28, 3]) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6, 3]) >>> y = ivy.conv3d_transpose(x, filters, [2, 2, 2], 'SAME') >>> print(y.shape) ivy.Shape(1, 6, 56, 56, 6) >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 3, 64, 64, 3]) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6, 3]) >>> y = ivy.conv3d_transpose(x, filters, [2, 2, 2], 'VALID', dilations=[1, 1, 1]) >>> print(y.shape) ivy.Shape(1, 7, 129, 129, 6) @@ -1927,6 +1938,7 @@ def conv3d_transpose( strides, padding, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, bias=bias, @@ -2036,6 +2048,7 @@ def conv_general_transpose( *, dims: int = 2, output_shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None, + filter_format: str = "channel_last", data_format: str = "channel_last", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, feature_group_count: int = 1, @@ -2051,7 +2064,7 @@ def conv_general_transpose( x Input image *[batch_size,d,h,w,d_in]* or *[batch_size,d_in,d,h,w]*. filters - Convolution filters *[fd,fh,fw,d_in,d_out]*. + Convolution filters *[fd,fh,fw,d_out,d_in]*. strides The stride of the sliding window for each dimension of input. padding @@ -2061,6 +2074,9 @@ def conv_general_transpose( Either 1, 2, or 3 corresponding to 1-D, 2-D, and 3-D convolution. output_shape Shape of the output. + filter_format + Either "channel_first" or "channel_last". "channel_first" corresponds + to "IODHW",input data formats, while "channel_last" corresponds to "DHWOI". data_format Either "channel_first" or "channel_last". "channel_first" corresponds to "NCW", "NCHW", "NCDHW" input data formatS for 1-D, 2-D, 3-D convolution respectively, @@ -2084,12 +2100,12 @@ def conv_general_transpose( -------- With :class:`ivy.Array` input: >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 3, 28, 28, 3]) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6, 3]) >>> y = ivy.conv3d_transpose(x, filters, [2, 2, 2], 'SAME') >>> print(y.shape) ivy.Shape(1, 6, 56, 56, 6) >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 3, 64, 64, 3]) - >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 3, 6]) + >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3, 6, 3]) >>> y = ivy.conv3d_transpose(x, filters, [2, 2, 2], 'VALID', dilations=[1, 1, 1]) >>> print(y.shape) ivy.Shape(1, 7, 129, 129, 6) @@ -2149,6 +2165,7 @@ def conv_general_transpose( padding, dims=dims, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, feature_group_count=feature_group_count, diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py index a92976f53aecc..9c26b4a068eb4 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py @@ -926,6 +926,7 @@ def test_tensorflow_conv2d_transpose( padding, output_shape, ) = x_f_d_df + assume(isinstance(padding, str) or backend_fw in ["torch", "tensorflow"]) _assume_tf_dilation_gt_1("tensorflow", on_device, dilation) helpers.test_frontend_function( input_dtypes=input_dtype, diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py index f8cd1dfcbae57..5c03cd7109fa7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py @@ -376,6 +376,13 @@ def test_torch_conv_tranpose1d( backend_fw, ): dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals + assume( + backend_fw in ["torch", "tensorflow"] + or all( + dil == 1 + for dil in ([dilations] if isinstance(dilations, int) else dilations) + ) + ) _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_frontend_function( input_dtypes=dtype, @@ -409,6 +416,13 @@ def test_torch_conv_tranpose2d( backend_fw, ): dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals + assume( + backend_fw in ["torch", "tensorflow"] + or all( + dil == 1 + for dil in ([dilations] if isinstance(dilations, int) else dilations) + ) + ) _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_frontend_function( input_dtypes=dtype, @@ -442,6 +456,13 @@ def test_torch_conv_tranpose3d( backend_fw, ): dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals + assume( + backend_fw in ["torch", "tensorflow"] + or all( + dil == 1 + for dil in ([dilations] if isinstance(dilations, int) else dilations) + ) + ) _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) helpers.test_frontend_function( input_dtypes=dtype, diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index 7da0237633a0e..c1895f1e5a912 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -465,7 +465,6 @@ def _x_and_filters( depthwise=False, general=False, bias=False, - filter_format=None, ): if not isinstance(dim, int): dim = draw(dim) @@ -483,7 +482,7 @@ def _x_and_filters( group_list = list(filter(lambda x: (input_channels % x == 0), group_list)) else: group_list = list(filter(lambda x: (output_channels % x == 0), group_list)) - fc = draw(st.sampled_from(group_list)) if general else 1 + fc = min(draw(st.sampled_from(group_list)), output_channels) if general else 1 strides = draw( st.one_of( st.integers(1, 3), st.lists(st.integers(1, 3), min_size=dim, max_size=dim) @@ -551,7 +550,7 @@ def _x_and_filters( filter_shape = filter_shape + (input_channels // fc, output_channels) else: input_channels = input_channels * fc - filter_shape = filter_shape + (input_channels, output_channels // fc) + filter_shape = filter_shape + (output_channels // fc, input_channels) else: filter_shape = filter_shape + (input_channels,) channel_first = True @@ -596,27 +595,25 @@ def _x_and_filters( ) ) dilations = (dilations, x_dilation) - if filter_format is not None: - filter_format = draw(filter_format) - if filter_format == "channel_first": - filters = np.transpose(filters, (-1, -2, *range(dim))) + filter_format = draw(st.sampled_from(["channel_first", "channel_last"])) + if filter_format == "channel_first": + filters = np.transpose(filters, (-1, -2, *range(dim))) ret = ( dtype, vals, filters, dilations, + filter_format, data_format, strides, padding, ) ret = ret + (output_shape, fc) if transpose else ret + (fc,) - ret = ret + (filter_format,) if filter_format is not None else ret if bias: return ret + (b,) return ret -# filter_format not in conv_general_transpose # output_shape not in conv_general_dilated @st.composite def _x_and_filters_and_transpose( @@ -624,28 +621,24 @@ def _x_and_filters_and_transpose( dim: int = 2, general=False, bias=False, - filter_format=None, ): transpose = draw(st.booleans()) - if not transpose: - filter_format = st.sampled_from(["channel_last", "channel_first"]) all_args = draw( _x_and_filters( dim=dim, general=general, bias=bias, - filter_format=filter_format, transpose=transpose, ) ) output_shape = None - filter_format = "channel_last" if transpose: ( dtype, x, filters, dilations, + filter_format, data_format, stride, pad, @@ -659,11 +652,11 @@ def _x_and_filters_and_transpose( x, filters, dilations, + filter_format, data_format, stride, pad, fc, - filter_format, bias, ) = all_args return ( @@ -925,7 +918,6 @@ def test_conv(*, dims, x_f_d_df_tr, test_flags, backend_fw, fn_name, on_device): x_f_d_df=_x_and_filters( dim=1, bias=True, - filter_format=st.sampled_from(["channel_last", "channel_first"]), ), ground_truth_backend="jax", ) @@ -981,6 +973,7 @@ def test_conv1d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic x, filters, dilations, + filter_format, data_format, stride, pad, @@ -1003,6 +996,7 @@ def test_conv1d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic strides=stride, padding=pad, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, bias=bias, @@ -1015,7 +1009,6 @@ def test_conv1d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic x_f_d_df=_x_and_filters( dim=2, bias=True, - filter_format=st.sampled_from(["channel_last", "channel_first"]), ), ground_truth_backend="jax", ) @@ -1070,6 +1063,7 @@ def test_conv2d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic x, filters, dilations, + filter_format, data_format, stride, pad, @@ -1092,6 +1086,7 @@ def test_conv2d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic strides=stride, padding=pad, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, bias=bias, @@ -1104,7 +1099,6 @@ def test_conv2d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic x_f_d_df=_x_and_filters( dim=3, bias=True, - filter_format=st.sampled_from(["channel_last", "channel_first"]), ), ground_truth_backend="jax", ) @@ -1159,6 +1153,7 @@ def test_conv3d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic x, filters, dilations, + filter_format, data_format, stride, pad, @@ -1180,6 +1175,7 @@ def test_conv3d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic strides=stride, padding=pad, output_shape=output_shape, + filter_format=filter_format, data_format=data_format, dilations=dilations, bias=bias, @@ -1194,7 +1190,6 @@ def test_conv3d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic dim=st.shared(st.integers(1, 3), key="dims"), general=True, bias=True, - filter_format=st.sampled_from(["channel_last", "channel_first"]), ), ground_truth_backend="jax", ) @@ -1249,6 +1244,7 @@ def test_conv_general_transpose( x, filters, dilations, + filter_format, data_format, stride, pad, @@ -1271,8 +1267,9 @@ def test_conv_general_transpose( strides=stride, padding=pad, dims=dims, - output_shape=output_shape, + filter_format=filter_format, data_format=data_format, + output_shape=output_shape, dilations=dilations, feature_group_count=fc, bias=bias, From 4f4d7b2988bcfb6291025473b860e442c013c2ef Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 24 Nov 2023 20:44:18 +0530 Subject: [PATCH 242/978] refactor: cleaning up the ivy.Module class (#27374) 1. Removed visualization methods and others that were unnecessary 2. Fixed the handling of v, buffers and modules with the getattr, setattr and delattr methods 3. Added a way to rebuild the module on updates to the sub-modules 4. Fixed the failing tests with test_sequential and test_sequential_layer 5. Fixed the dtype and device handling in the _create_variables of the stateful classes 6. Added the _extra_repr for all stateful classes which didn't have it --- .../frontends/torch/nn/modules/module.py | 2 +- ivy/stateful/activations.py | 42 + ivy/stateful/helpers.py | 782 +++++------- ivy/stateful/layers.py | 92 +- ivy/stateful/losses.py | 17 + ivy/stateful/module.py | 1059 ++++++----------- ivy/stateful/norms.py | 22 +- ivy/stateful/sequential.py | 6 + .../test_ivy/test_stateful/test_layers.py | 191 ++- .../test_ivy/test_stateful/test_modules.py | 597 +--------- .../test_ivy/test_stateful/test_sequential.py | 73 +- 11 files changed, 928 insertions(+), 1955 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 5458f50af041a..d8f0c7d9e7714 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -387,7 +387,7 @@ def requires_grad_(self, requires_grad: bool = True): def _get_name(self): return self.__class__.__name__ - def extra_repr(self) -> str: + def _extra_repr(self) -> str: return "" def register_full_backward_pre_hook( diff --git a/ivy/stateful/activations.py b/ivy/stateful/activations.py index 635aa7dc30161..ae3991c099122 100644 --- a/ivy/stateful/activations.py +++ b/ivy/stateful/activations.py @@ -48,6 +48,9 @@ def _forward(self, x): complex_mode=self._complex_mode, ) + def _extra_repr(self) -> str: + return f"approximate={self._approximate}, complex_mode={self._complex_mode}" + class GEGLU(Module): def __init__(self): @@ -104,6 +107,9 @@ def _forward(self, x): """ return ivy.relu(x, complex_mode=self._complex_mode) + def _extra_repr(self) -> str: + return f"complex_mode={self._complex_mode}" + class LeakyReLU(Module): def __init__( @@ -145,6 +151,9 @@ def _forward(self, x): complex_mode=self._complex_mode, ) + def _extra_repr(self) -> str: + return f"alpha={self._alpha}, complex_mode={self._complex_mode}" + class LogSoftmax(Module): def __init__( @@ -182,6 +191,9 @@ def _forward(self, x): """ return ivy.log_softmax(x, axis=self._axis, complex_mode=self._complex_mode) + def _extra_repr(self) -> str: + return f"axis={self._axis}, complex_mode={self._complex_mode}" + class Softmax(Module): def __init__( @@ -222,6 +234,9 @@ def _forward(self, x): """ return ivy.softmax(x, axis=self._axis, complex_mode=self._complex_mode) + def _extra_repr(self) -> str: + return f"axis={self._axis}, complex_mode={self._complex_mode}" + class Softplus(Module): def __init__(self, beta=1.0, threshold=None): @@ -251,6 +266,9 @@ def _forward(self, x): """ return ivy.softplus(x, beta=self._beta, threshold=self._threshold) + def _extra_repr(self) -> str: + return f"beta={self._beta}, threshold={self._threshold}" + class Mish(Module): def __init__(self): @@ -323,6 +341,9 @@ def _forward(self, x): """ return ivy.sigmoid(x, complex_mode=self._complex_mode) + def _extra_repr(self) -> str: + return f"complex_mode={self._complex_mode}" + class Tanh(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): @@ -353,6 +374,9 @@ def _forward(self, x): """ return ivy.tanh(x, complex_mode=self._complex_mode) + def _extra_repr(self) -> str: + return f"complex_mode={self._complex_mode}" + class ReLU6(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): @@ -383,6 +407,9 @@ def _forward(self, x): """ return ivy.relu6(x, complex_mode=self._complex_mode) + def _extra_repr(self) -> str: + return f"complex_mode={self._complex_mode}" + class Hardswish(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): @@ -413,6 +440,9 @@ def _forward(self, x): """ return ivy.hardswish(x, complex_mode=self._complex_mode) + def _extra_repr(self) -> str: + return f"complex_mode={self._complex_mode}" + class Logit(Module): def __init__( @@ -454,6 +484,9 @@ def _forward(self, x): complex_mode=self._complex_mode, ) + def _extra_repr(self) -> str: + return f"eps={self._eps}, complex_mode={self._complex_mode}" + class PReLU(Module): def __init__(self, slope): @@ -478,6 +511,9 @@ def _forward(self, x): """ return ivy.prelu(x, self._slope) + def _extra_repr(self) -> str: + return f"slope={self._slope}" + class SeLU(Module): def __init__(self): @@ -522,6 +558,9 @@ def _forward(self, x): """ return ivy.elu(x, alpha=self._alpha) + def _extra_repr(self) -> str: + return f"alpha={self._alpha}" + class LogSigmoid(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): @@ -551,3 +590,6 @@ def _forward(self, x): The outputs following the LogSigmoid activation *[batch_shape, d]* """ return ivy.logsigmoid(x, complex_mode=self._complex_mode) + + def _extra_repr(self) -> str: + return f"complex_mode={self._complex_mode}" diff --git a/ivy/stateful/helpers.py b/ivy/stateful/helpers.py index 7d94f5e0f229f..46eea4e6eda50 100644 --- a/ivy/stateful/helpers.py +++ b/ivy/stateful/helpers.py @@ -1,557 +1,351 @@ """Base class for helper module methods.""" # global -import abc -import numpy as np -import termcolor +import functools +import logging # local import ivy +from ivy.data_classes.container import Container +from ivy.func_wrapper import _get_first_array -class ModuleHelpers(abc.ABC): - # Private # - # --------# - def _top_v_fn(self, /, depth=None, flatten_key_chains=False): - """ - Return the variables at a specific depth, with depth 1 returning the variables - of the current layer. - - Parameters - ---------- - depth - depth of the variables to return. 1 for current layer, None for the - topmost layer. Default is ``None``. - flatten_key_chains - If set True, will return a flat container which all nested key-chains - flattened. Default is ``False``. - - Returns - ------- - ret - The variables of the submodule at the specified depth. - """ - if ivy.exists(self.top_v): - if ivy.exists(depth): - ret = self.top_v(depth - 1) if depth > 1 else self.v - else: - ret = self.top_v() - else: - ret = self.v - if flatten_key_chains: - return ret.cont_flatten_key_chains() - return ret - - def _top_mod_fn(self, /, depth=None): +class ModuleHelpers: + def _find_variables( + self, + /, + *, + obj=None, + without_initialisation=False, + _visited=None, + ): """ - Find the top (parent) module at specific depth, starting with depth 1 to return - the current submodule. + Find all internal variables in obj. Return empty Container if obj is None. Parameters ---------- - depth - The number of modules we want to trace back. 1 for the current module, None - for the topmost module. Default is ``None``. + obj + The submodule whose internal variables are to be returned. Default + is None. + without_initialization + Whether or not to initialize the variables, to avoid initialization when + the model variables are passed in the input directly. + _visited + Placeholder for tracking the visited nodes, do not set this parameter. Returns ------- ret - The module we want to track down. Return current module if no top - module exists. - """ - if ivy.exists(self.top_mod): - if ivy.exists(depth): - return self.top_mod(depth - 1) if depth > 1 else self - return self.top_mod() - return self - - # noinspection PyProtectedMember - def track_submod_rets(self): - """ - Return True if the current module should have its returns tracked as set by the - user during the call. - - Returns - ------- - ret - True if the returned values of the current module should be - tracked. - """ - if not ivy.exists(self.top_mod): - return False - top_mod = self.top_mod() - submods = top_mod._submods_to_track - if ivy.exists(submods) and self not in submods: - return False - depth = top_mod._submod_depth - if ivy.exists(depth): - return ( - self.top_mod(depth - 1)._track_submod_rets - if depth > 0 - else self._track_submod_rets - ) - return top_mod._track_submod_rets - - def check_submod_rets(self): - """ - Return True if there is an expected submodule return value set by the user - during the call. - - Returns - ------- - ret - True if the top module has expected_submod_rets. - """ - if not ivy.exists(self.top_mod): - return False - if ivy.exists(self.top_mod().expected_submod_rets): - return True - return False - - # noinspection PyProtectedMember - def track_submod_call_order(self): - """ - Tracks the order in which the submodules are called. + The internal variables of the submodule passed in the argument. + """ + _visited = ivy.default(_visited, {}) + vs = Container() + if id(obj) in _visited: + return vs + _visited[id(obj)] = True + # ToDo: add support for finding local variables, if/when JAX supports + # uniquely flagging variables + if isinstance(obj, ModuleHelpers) and obj is not self: + + if not obj.built and without_initialisation: + return lambda: obj._build_and_return_v( + *obj._args, dynamic_backend=self._dynamic_backend, **obj._kwargs + ) - Returns - ------- - ret - True if the current module allows call order tracking. - """ - if not ivy.exists(self.top_mod): - return False - top_mod = self.top_mod() - submods = top_mod._submods_to_track - if ivy.exists(submods) and self not in submods: - return False - depth = top_mod._submod_depth - if ivy.exists(depth): - return ( - self.top_mod(depth - 1)._track_submod_call_order - if depth > 0 - else self._track_submod_call_order + return obj._build_and_return_v( + *obj._args, dynamic_backend=obj._dynamic_backend, **obj._kwargs ) - return top_mod._track_submod_call_order + elif isinstance(obj, (list, tuple)): + for i, v in enumerate(obj): + ret = self._find_variables( + obj=v, + without_initialisation=without_initialisation, + _visited=_visited, + ) + if ret: + vs[f"v{str(i)}"] = ret + return vs + elif isinstance(obj, dict): + for k, v in obj.items(): + ret = self._find_variables( + obj=v, + without_initialisation=without_initialisation, + _visited=_visited, + ) + if ret: + vs[k[1:] if k[0] == "_" else k] = ret + return vs + elif not hasattr(obj, "__dict__"): + return vs + for k, v in obj.__dict__.items(): + if v is not None and k[0:2] != "__" and k != "_module_dict": + ret = self._find_variables( + obj=v, + without_initialisation=without_initialisation, + _visited=_visited, + ) + if ret: + vs[k[1:] if k[0] == "_" else k] = ret + return vs - def mod_depth(self): - """ - Return the depth of the current module. Return 0 for root module. + def _find_buffers(self): + for obj in self.__dict__.keys(): + if isinstance(getattr(self, obj), ivy.Module): + self._buffers.update({obj: getattr(self, obj).buffers}) - Returns - ------- - ret - The depth of the module in the network. - """ - depth = 0 - mod_above = self - while True: - if ivy.exists(mod_above.top_mod): - mod_above = mod_above.top_mod(1) - else: - break - depth += 1 - return depth - - def mod_height(self): - """ - Return the height of the network, with the current level being 0. + def _build_and_return_v(self, *args, **kwargs): + self.build(*args, **kwargs) + return self.v - Returns - ------- - ret - The height of the network. 0 if the are no submodules. + @staticmethod + def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): """ - return self.sub_mods().cont_max_depth - 1 - - # Public # - # ------# - - def _set_submod_flags( - self, - track_submod_rets, - submod_depth, - submods_to_track, - track_submod_call_order, - expected_submod_rets, - /, - ): - """ - Set flags of the submodule. + Extract the variables from the variables container v using the key + orig_key_chain and reinstantiate the duplicate variables that were removed by + _remove_duplicate_variables in their correct locations using keychain_mappings. Parameters ---------- - track_submod_rets - If True, will track the returns of submodules. - submod_depth - The depth of tracked submodules. - submods_to_track - If given, will only track submodules in `submods_to_track`. - track_submod_call_order - If True, will track the call order of submodules. - expected_submod_rets - If given, will raise exception if submodule returns are - different from expected returns. - """ - self._track_submod_rets = track_submod_rets - self._submod_depth = submod_depth - self._submods_to_track = submods_to_track - self._track_submod_call_order = track_submod_call_order - self.expected_submod_rets = ( - ivy.Container(expected_submod_rets).to_numpy(map_sequences=True) - if ivy.exists(expected_submod_rets) - else expected_submod_rets - ) + v + The variables container + keychain_mappings + The keychain mappings of duplicate vatriables + orig_key_chain + keychain of the variables to be extracted - def _unset_submod_flags(self): - """Unset flags of the submodule.""" - self._track_submod_rets = False - self._submod_depth = None - self._submods_to_track = None - self._track_submod_call_order = False - self.expected_submod_rets = None - - def get_mod_key(self, /, *, top_mod=None): - """ - Get the key of current module to be used when checking or tracking the return - values of a submodule. - - Parameters - ---------- - top_mod - Explicit indicate the top module. None for the top - module of current module. Default is ``None``. Returns ------- - A string of current module key. + ret_cont + container with the extracted variables. """ - if top_mod is None: - top_mod = self.top_mod() - submod_dict = top_mod.submod_dict - full_key = self.__repr__().split(".")[-1] - name_key = full_key.split(" ")[0] - if name_key not in submod_dict: - submod_dict[name_key] = {} - id_str = full_key.split(" ")[-1][:-1] - if id_str not in submod_dict[name_key]: - submod_dict[name_key][id_str] = str(len(submod_dict[name_key])) - idx_key = submod_dict[name_key][id_str] - return " " * self.mod_depth() + "_".join([name_key, idx_key]) - - def sub_mods(self, /, *, show_v=True, depth=None, flatten_key_chains=False): + if v.cont_has_key_chain(orig_key_chain): + ret_cont = v.cont_at_key_chain(orig_key_chain) + else: + ret_cont = Container() + for old_kc, new_kc in keychain_mappings.items(): + if orig_key_chain in old_kc: + ret_cont = ret_cont.cont_set_at_key_chain( + "/".join(new_kc.split("/")[1:]), v.cont_at_key_chain(new_kc) + ) + return ret_cont + + @staticmethod + def _remove_duplicate_variables(vs, created, /): """ - Return a container comoposed of all submodules. + Remove duplicate variables in `vs` referring to `created`. Parameters ---------- - show_v - If set True, will return values of all submodule variables. - Default is ``True``. - depth - How many layers we step in before beginning enumerating submodules. - None for current layer. Default is ``None``. - flatten_key_chains - If set True, will return a flat (depth-1) container, - in which all nested key-chains flattened. Default is ``False``. + vs + The container that needs to be pruned. + created + The container as the duplication reference. Returns ------- - ret - A container composed of all submodules. - """ - if self._sub_mods: - if ivy.exists(depth): - if depth == 0: - if show_v: - return self.v - return "" - next_depth = depth - 1 - else: - next_depth = None - ret = ivy.Container({ - ivy.Container.cont_flatten_key_chain( - sm.__repr__(), replacement="_" - ): sm.sub_mods(show_v=show_v, depth=next_depth) - for sm in self._sub_mods - }) - if flatten_key_chains: - return ret.cont_flatten_key_chains() - return ret - if show_v: - return self.v - return "" - - def show_v_in_top_v(self, /, *, depth=None): - """ - Show sub containers from the perspective of the top layer. Will give prompt if - either of `v` or `top_v` is not initialized. + vs + The container after removing duplicate variables. + keychain_mappings + Dict storing those keys and ids being removed. + """ + created_ids = created.cont_map(lambda x, kc: id(x)) + vs_ids = vs.cont_map(lambda x, kc: id(x)) + ids = {} + duplicate_keychains = [] + keychain_mappings = {} + + def unique_callback(x, kc): + ids[x] = kc + + def found_dup_callback(x, kc): + if ids[x] == kc: + return + duplicate_keychains.append(kc) + keychain_mappings[kc] = ids[x] - Parameters - ---------- - depth - The number of modules we want to step in. None for the value of - current module. Default is ``None``. - """ - if ivy.exists(self.top_v) and ivy.exists(self.v): - self.top_v(depth).cont_show_sub_container(self.v) - else: - print( - "both self.top_v and self.v must be initialized in order to show v in" - f" top_v, but found\n\ntop_v: {self.top_v}\n\nv: {self.v}." + created_ids.cont_map(lambda x, kc: unique_callback(x, kc)) + vs_ids.cont_map( + lambda x, kc: ( + unique_callback(x, kc) if x not in ids else found_dup_callback(x, kc) ) + ) + for dup_kc in duplicate_keychains: + vs = vs.cont_prune_key_chain(dup_kc) + return vs, keychain_mappings - def v_with_top_v_key_chains(self, /, *, depth=None, flatten_key_chains=False): + def _wrap_call_methods( + self, keychain_mappings, /, *, key="", obj=None, _visited=None + ): """ - Show the network's variables from the perspective of value of top layer. Will - give prompt if either of `v` and `top_v` is not initialized. + Wrap the call methods of the Module object by looping over all the items within + the module, wrapping the __call__ methods of all submodules using + _fn_with_var_arg. Parameters ---------- - depth - The number of modules we want to step in. None for the value of - current module. Default is ``None``. - flatten_key_chains - If set True, will return a flat container, - with all nested key-chains flattened. Default is ``False``. - """ - if ivy.exists(self.top_v) and ivy.exists(self.v): - kc = self.top_v(depth).cont_find_sub_container(self.v) - if kc: - ret = self.v.cont_restructure_key_chains({"": kc}, keep_orig=False) - else: - ret = self.v - if flatten_key_chains: - return ret.cont_flatten_key_chains() - return ret - else: - print( - "both self.top_v and self.v must be initialized in order to show v in" - f" top_v, but found\n\ntop_v: {self.top_v}\n\nv: {self.v}." - ) - - def mod_with_top_mod_key_chain(self, /, *, depth=None, flatten_key_chain=False): - """ - Return a list containing the modules of the network starting from the top - module, and ending with the current module. + keychain_mappings + The keychain mappings of the object + key + The keychain of the object obj, used for recursion. + obj + the object whose __call__ method is to be wrapped + _visited + Placeholder for tracking the visited nodes, do not set this parameter. - Parameters - ---------- - depth - If specified, will return a list of modules of length starting at - the current module and ending at the module at the specified depth. - 0 for the current module. 1 for the iimediate parent module. None for - the top module. Default is ``None``. - - flatten_key_chain - If set True, will return return a flat container, - with all nested key-chains flattened. Default is ``False``. - """ - if not ivy.exists(self.top_mod) or depth == 0: - return self.__repr__() - max_depth = depth - depth = 1 - top_mod = self - mods = [ - ivy.Container.cont_flatten_key_chain(top_mod.__repr__(), replacement="_") - ] - while ivy.exists(top_mod.top_mod): - top_mod = top_mod.top_mod(1) - mods.append( - ivy.Container.cont_flatten_key_chain( - top_mod.__repr__(), replacement="_" - ) - ) - if depth == max_depth: - break - depth += 1 - if flatten_key_chain: - return "__".join(reversed(mods)) - return [mod for mod in reversed(mods)] - - def show_mod_in_top_mod( - self, /, *, upper_depth=None, lower_depth=None, flatten_key_chains=False - ): + Returns + ------- + None """ - Show lower submodules in the top module. `upper_depth` and `lower_depth` are for - controlling the coverage of upper and lower modules. Will give prompt if no top - module found. + _visited = ivy.default(_visited, {}) + if id(obj) in _visited or not isinstance(key, str): + return + _visited[id(obj)] = True + if isinstance(obj, ModuleHelpers) and obj is not self: + orig_key_chain = key[1:] if key[0] == "_" else key - Parameters - ---------- - upper_depth - How many modules it tracks up as upper module. None for current module. - Default is ``None``. Will be truncated to mod_depth. - lower_depth - How many modules it tracks down. None for current module. - Default is ``None``. Will be truncated to mod_height. - flatten_key_chains - If set True, will return a flat (depth-1) container, - which all nested key-chains flattened. Default is ``False``. - """ - if ivy.exists(self.top_mod): - upper_depth = ivy.default(upper_depth, self.mod_depth()) - lower_depth = ivy.default(lower_depth, self.mod_height()) - mid_depth = upper_depth + lower_depth - upper_sub_mods = self.top_mod(upper_depth).sub_mods(depth=mid_depth) - lower_sub_mods = self.sub_mods(depth=lower_depth) - if flatten_key_chains: - upper_sub_mods = upper_sub_mods.cont_flatten_key_chains() - lower_sub_mods = lower_sub_mods.cont_flatten_key_chains() - upper_sub_mods.cont_show_sub_container(lower_sub_mods) - else: - print( - "self.top_mod must be initialized in order to show mod in top_mod,but" - f" found\n\ntop_mod: {self.top_mod}" + obj.__call__ = self._fn_with_var_arg( + obj.__call__, self._extract_v, keychain_mappings, orig_key_chain ) + return + elif isinstance(obj, (list, tuple)): + for i, val in enumerate(obj): + self._wrap_call_methods( + keychain_mappings, + key=f"{key}/v{str(i)}", + obj=val, + _visited=_visited, + ) + return + elif isinstance(obj, dict): + for k, val in obj.items(): + k = f"{key}/{k}" if key != "" and isinstance(k, str) else k + self._wrap_call_methods( + keychain_mappings, key=k, obj=val, _visited=_visited + ) + return + if not hasattr(obj, "__dict__"): + return + for k, val in obj.__dict__.items(): + if k[0:2] == "__": + continue + k = f"{key}/{k}" if key != "" else k + if val is not None: + self._wrap_call_methods( + keychain_mappings, key=k, obj=val, _visited=_visited + ) + return - def _add_submod_ret(self, ret, /): + def _call(self, *args, v=None, buffers=None, **kwargs): """ - Add returns to submod_rets variable of the top module. + Compute forward pass of the layer, treating layer instance as callable function. Parameters ---------- - ret - The return to be added. - """ - top_mod = self.top_mod() - sr = top_mod.submod_rets - ret = ivy.to_numpy(ret) - key = self.get_mod_key(top_mod=top_mod) - if key in sr: - sr[key].append(ret) - else: - sr[key] = [ret] - - def _check_submod_ret(self): - """ - Check the actual submodule returns with the expected submodule return values. - - Raise AssertError if returns are not close enough. - """ - top_mod = self.top_mod() - esr = top_mod.expected_submod_rets - key = self.get_mod_key(top_mod=top_mod) - esr_key = key - if key not in esr: - esr_key = key.replace(" ", "") - if esr_key not in esr: - return - sr = self.top_mod().submod_rets - rets = sr[key] - esr_ret = esr[esr_key] - if isinstance(esr_ret, dict): - expected_rets = esr_ret["val"] - atols = esr_ret["atol"] if "atol" in esr_ret else None - if not isinstance(atols, list): - atols = [atols] * len(expected_rets) - rtols = esr_ret["rtol"] if "rtol" in esr_ret else None - if not isinstance(rtols, list): - rtols = [rtols] * len(expected_rets) - else: - expected_rets = esr_ret - atols = [None] * len(expected_rets) - rtols = [None] * len(expected_rets) - for ret, expected_ret, atol, rtol in zip(rets, expected_rets, atols, rtols): - if expected_ret is None: - continue - kwargs = {} - if atol: - kwargs["atol"] = atol - if rtol: - kwargs["rtol"] = rtol - ivy.utils.assertions.check_true( - np.allclose(ret, expected_ret, **kwargs), - message=( - f"ret: {ret} and expected_ret: {expected_ret} were not close enough" - ), - ) - - # noinspection PyProtectedMember - def _is_submod_leaf(self): - """ - Check if the submodule is the leaf node of the network. + args + Positional arguments to the _build method. + v + Replace `v` of current layer when forwarding. Restore + after the forward finished. + buffers + Replace `v` of current layer when forwarding. Restore + after the forward finished. + kwargs + Keyword arguments to the _build method. Returns ------- ret - True if the submodule is the leaf node of the network. - """ - submod_depth = self.top_mod()._submod_depth - submods_to_track = self.top_mod()._submods_to_track - return ( - (ivy.exists(submod_depth) and self.mod_depth() == submod_depth) - or self.mod_height() == 0 - or (ivy.exists(submods_to_track) and self in submods_to_track) - ) - - def _add_submod_enter(self): - """Add key chains to submod_call_order variable of the top module.""" - sco = self.top_mod().submod_call_order - key_chain = self.mod_with_top_mod_key_chain() - for key in key_chain[:-1]: - kcs = sco.cont_key_chains_containing(key, include_empty=True) - if kcs: - max_key = sorted( - kcs, - key=lambda kc: int( - kc.split("/")[ - -2 if isinstance(sco[kc], np.ndarray) else -1 - ].split("_")[-1] - ), - )[-1].split("/")[0] - else: - max_key = f"{key}_0" - sco[max_key] = ivy.Container( - alphabetical_keys=False, ivyh=ivy.with_backend("numpy") - ) - sco = sco[max_key] - final_key = key_chain[-1] - kcs = sco.cont_key_chains_containing(final_key, include_empty=True) - if kcs: - sorted_kcs = sorted( - kcs, - key=lambda kc: int( - kc.split("/")[-2 if isinstance(sco[kc], np.ndarray) else -1].split( - "_" - )[-1] - ), + Result of the forward pass of the layer. + """ + if not self._built: + self.build( + *args, + **kwargs, + from_call=True, + dtype=_get_first_array(*args, **kwargs).dtype, ) - chosen_kc = sorted_kcs[-1] - max_key_idx = int( - chosen_kc.split("/")[ - -2 if isinstance(sco[chosen_kc], np.ndarray) else -1 - ].split("_")[-1] + if v is not None: + v_orig = self.v + buffers_orig = self.buffers + self._v = ( + Container(v, **v.cont_config) + if isinstance(v, Container) + else Container(v) ) - new_key = f"{final_key}_{max_key_idx + 1}" - else: - new_key = f"{final_key}_0" - if self._is_submod_leaf(): - sco[new_key] = self.v_with_top_v_key_chains( - flatten_key_chains=True - ).to_numpy() - else: - sco[new_key] = ivy.Container( - alphabetical_keys=False, ivyh=ivy.with_backend("numpy") + self._buffers = ( + Container(buffers, **buffers.cont_config) + if isinstance(buffers, Container) + else Container(buffers) ) + ret = self._forward(*args, **kwargs) + self._v = v_orig + self._buffers = buffers_orig + return ret - def show_structure(self): + elif hasattr(self.__call__, "wrapped"): + return self.__call__(*args, **kwargs) + return self._forward(*args, **kwargs) + + def _rebuild(self): + logging.warning( + "Building the module again as a trainable module was modified, " + 'please use the "explicit" or "on_call" build_modes instead ' + 'of "on_init" to avoid repetitive building after each addition' + ) + self._v = Container() + self._built = False + self.build(*self._args, **self._kwargs) + + def _compute_module_dict(self): + self._module_dict = Container() + for key, value in self.__dict__.items(): + if isinstance(value, ivy.Module): + if "stateful" in value.__module__: + self._module_dict[key] = value + else: + self._module_dict[key] = value._module_dict + + @staticmethod + def _addindent(s_, numSpaces): + s = s_.split("\n") + # don't do anything for single-line stuff + if len(s) == 1: + return s_ + first = s.pop(0) + s = [(numSpaces * " ") + line for line in s] + s = "\n".join(s) + s = first + "\n" + s + return s + + def _fn_with_var_arg_wrapper( + self, *a, fn, v_fn, keychain_mappings, orig_key_chain, **kw + ): + if "v" in kw: + del kw["v"] + v = v_fn(self.v, keychain_mappings, orig_key_chain) + return fn(*a, **kw, v=v) + + def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): """ - Print the structure of the layer network. + Extract variables from `v_fn` and use it as inputs for `fn`. - Returns - ------- - this_repr - String of the structure of the module. + Use `v_fn` to extract the variables and use the extracted + variables as inputs to the call function fn of the module. """ - this_repr = termcolor.colored(object.__repr__(self), "green") - sub_mod_repr = self.sub_mods(show_v=False).__repr__() - if sub_mod_repr == "''": - return this_repr - print("\n".join([this_repr, sub_mod_repr])) + _fn_with_var_arg_wrapper = functools.partial( + self._fn_with_var_arg_wrapper, + fn=fn, + v_fn=v_fn, + keychain_mappings=keychain_mappings, + orig_key_chain=orig_key_chain, + ) + _fn_with_var_arg_wrapper.wrapped = True + return _fn_with_var_arg_wrapper def _convert_tensors_to_numpy(self): """ - Recursively traverses the _sub_mods attribute of a Module object and converts + Recursively traverses the module_dict attribute of a Module object and converts every container containing tensors to numpy using the to_numpy() method. Returns @@ -559,14 +353,14 @@ def _convert_tensors_to_numpy(self): Module The converted Module object. """ - if len(self._sub_mods) > 0: - for sub_mod in self._sub_mods: - sub_mod._convert_tensors_to_numpy() + if self.module_dict: + for _, module in self.module_dict.items(): + module._convert_tensors_to_numpy() self.v = self.v.to_numpy() def _convert_numpy_to_tensors(self): """ - Recursively traverses the _sub_mods attribute of a Module object and converts + Recursively traverses the module_dict attribute of a Module object and converts every container containing tensors to numpy using the to_numpy() method. Returns @@ -574,9 +368,9 @@ def _convert_numpy_to_tensors(self): Module The converted Module object. """ - if len(self._sub_mods) > 0: - for sub_mod in self._sub_mods: - sub_mod._convert_numpy_to_tensors() + if self.module_dict: + for _, module in self.module_dict.items(): + module._convert_numpy_to_tensors() self.v = self.v.to_ivy() else: self.v = self.v.to_ivy() diff --git a/ivy/stateful/layers.py b/ivy/stateful/layers.py index 17db6118a9a4c..69420663206a2 100644 --- a/ivy/stateful/layers.py +++ b/ivy/stateful/layers.py @@ -65,7 +65,7 @@ def __init__( self._with_bias = with_bias Module.__init__(self, device=device, v=v, dtype=dtype) - def _create_variables(self, device, dtype=None): + def _create_variables(self, device=None, dtype=None): """ Create internal variables for the layer. @@ -78,6 +78,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._w_init.create_variables( self._w_shape, @@ -117,7 +119,7 @@ def _forward(self, x): """ return ivy.linear(x, self.v.w, bias=self.v.b if self._with_bias else None) - def extra_repr(self) -> str: + def _extra_repr(self) -> str: return ( f"in_features={self._input_channels}, out_features={self._output_channels}," f" with_bias={self._with_bias is True}" @@ -193,7 +195,7 @@ def _forward(self, inputs, dtype=None): inputs, self._prob, scale=self._scale, training=self.training, dtype=dtype ) - def extra_repr(self) -> str: + def _extra_repr(self) -> str: s = "prob={prob}" if not self._scale: s += ", scale={scale}" @@ -303,7 +305,7 @@ def __init__( training=training, ) - def _create_variables(self, device, dtype=None): + def _create_variables(self, device=None, dtype=None): """ Parameters ---------- @@ -314,6 +316,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = dict( out_proj_weights=GlorotUniform().create_variables( (self._embed_dim, self._inner_dim), @@ -448,6 +452,15 @@ def _forward( training=self.training, ) + def _extra_repr(self) -> str: + return ( + f"embed_dim={self._embed_dim}, key_dim={self._key_dim}, " + f"value_dim={self._value_dim}, num_heads={self.num_heads}, " + f"head_dim={self._head_dim}, dropout_rate={self.dropout_rate}, " + f"use_proj_bias={self._use_proj_bias}, " + f"attention_axes={self._attention_axes}, scale={self._scale}" + ) + # Convolutions # # -------------# @@ -524,7 +537,7 @@ def __init__( self._dilations = dilations Module.__init__(self, device=device, v=v, dtype=dtype) - def _create_variables(self, device, dtype=None): + def _create_variables(self, device=None, dtype=None): """ Create internal variables for the layer. @@ -537,6 +550,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._w_init.create_variables( self._w_shape, @@ -582,7 +597,7 @@ def _forward(self, inputs): dilations=self._dilations, ) + (self.v.b if self._with_bias else 0) - def extra_repr(self): + def _extra_repr(self): s = ( "{_input_channels}, {_output_channels}, filter_size={_filter_size}," " strides={_strides}, padding={_padding}" @@ -684,6 +699,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._w_init.create_variables( self._w_shape, @@ -730,7 +747,7 @@ def _forward(self, inputs): dilations=self._dilations, ) + (self.v.b if self._with_bias else 0) - def extra_repr(self): + def _extra_repr(self): s = ( "{_input_channels}, {_output_channels}, filter_size={_filter_size}," " strides={_strides}, padding={_padding}" @@ -832,6 +849,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._w_init.create_variables( self._w_shape, @@ -877,7 +896,7 @@ def _forward(self, inputs): dilations=self._dilations, ) + (self.v.b if self._with_bias else 0) - def extra_repr(self): + def _extra_repr(self): s = ( "{_input_channels}, {_output_channels}, filter_shape={_filter_shape}," " strides={_strides}, padding={_padding}" @@ -981,6 +1000,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._w_init.create_variables( self._w_shape, @@ -1027,7 +1048,7 @@ def _forward(self, inputs): dilations=self._dilations, ) + (self.v.b if self._with_bias else 0) - def extra_repr(self): + def _extra_repr(self): s = ( "{_input_channels}, {_output_channels}, filter_shape={_filter_shape}," " strides={_strides}, padding={_padding}" @@ -1125,6 +1146,8 @@ def _create_variables(self, device, dtype): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._w_init.create_variables( self._w_shape, @@ -1170,7 +1193,7 @@ def _forward(self, inputs): dilations=self._dilations, ) + (self.v.b if self._with_bias else 0) - def extra_repr(self): + def _extra_repr(self): s = ( "num_channels={_num_channels}, filter_shape={_filter_shape}," " strides={_strides}, padding={_padding}" @@ -1270,6 +1293,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._w_init.create_variables( self._w_shape, @@ -1316,7 +1341,7 @@ def _forward(self, inputs): dilations=self._dilations, ) + (self.v.b if self._with_bias else 0) - def extra_repr(self): + def _extra_repr(self): s = ( "{_input_channels}, {_output_channels}, filter_shape={_filter_shape}," " strides={_strides}, padding={_padding}" @@ -1421,6 +1446,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._w_init.create_variables( self._w_shape, @@ -1468,7 +1495,7 @@ def _forward(self, inputs): dilations=self._dilations, ) + (self.v.b if self._with_bias else 0) - def extra_repr(self): + def _extra_repr(self): s = ( "{_input_channels}, {_output_channels}, filter_shape={_filter_shape}," " strides={_strides}, padding={_padding}" @@ -1554,6 +1581,7 @@ def get_initial_state(self, batch_shape, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + dtype = ivy.default(dtype, self.dtype) batch_shape = list(batch_shape) return ( [ @@ -1568,7 +1596,7 @@ def get_initial_state(self, batch_shape, dtype=None): # Overridden - def _create_variables(self, device, dtype=None): + def _create_variables(self, device=None, dtype=None): """ Create internal variables for the layer. @@ -1581,6 +1609,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) input_weights = dict( zip( [f"layer_{str(i)}" for i in range(self._num_layers)], @@ -1668,7 +1698,7 @@ def _forward(self, inputs, initial_state=None): return h_t return h_t, (h_n_list, c_n_list) - def extra_repr(self): + def _extra_repr(self): s = "{_input_channels}, {_output_channels}" if self._num_layers != 1: s += ", num_layers={_num_layers}" @@ -1737,7 +1767,7 @@ def _forward(self, inputs): data_format=self._data_format, ) - def extra_repr(self): + def _extra_repr(self): s = "kernel_size={_kernel_size}, stride={_stride}, padding={_padding}" if self._data_format != "NHWC": s += ", data_format={_data_format}" @@ -1798,7 +1828,7 @@ def _forward(self, inputs): data_format=self._data_format, ) - def extra_repr(self): + def _extra_repr(self): s = "kernel_size={_kernel_size}, stride={_stride}, padding={_padding}" if self._data_format != "NHWC": s += ", data_format={_data_format}" @@ -1859,7 +1889,7 @@ def _forward(self, inputs): data_format=self._data_format, ) - def extra_repr(self): + def _extra_repr(self): s = "kernel_size={_kernel_size}, stride={_stride}, padding={_padding}" if self._data_format != "NHWC": s += ", data_format={_data_format}" @@ -1917,7 +1947,7 @@ def _forward(self, x): data_format=self._data_format, ) - def extra_repr(self): + def _extra_repr(self): s = "kernel_size={_kernel_size}, stride={_stride}, padding={_padding}" if self._data_format != "NDHWC": s += ", data_format={_data_format}" @@ -1991,7 +2021,7 @@ def _forward(self, x): divisor_override=self._divisor_override, ) - def extra_repr(self): + def _extra_repr(self): s = "kernel_size={_kernel_size}, stride={_stride}, padding={_padding}" if self._data_format != "NDHWC": s += ", data_format={_data_format}" @@ -2045,7 +2075,7 @@ def _forward(self, x): self._output_size, ) - def extra_repr(self): + def _extra_repr(self): return f"output_size={self._output_size}" @@ -2091,7 +2121,7 @@ def _forward(self, x): self._output_size, ) - def extra_repr(self): + def _extra_repr(self): return f"output_size={self._output_size}" @@ -2149,7 +2179,7 @@ def _forward(self, inputs): out=self._out, ) - def extra_repr(self): + def _extra_repr(self): s = "dim={_dim}" if self._norm != "backward": s += ", norm={_norm}" @@ -2209,7 +2239,7 @@ def _forward(self, inputs): data_format=self._data_format, ) - def extra_repr(self): + def _extra_repr(self): s = "kernel_size={_kernel_size}, stride={_stride}, padding={_padding}" if self._data_format != "NWC": s += ", data_format={_data_format}" @@ -2273,7 +2303,7 @@ def _forward(self, x): norm=self.norm, ) - def extra_repr(self): + def _extra_repr(self): s = "type={type}" if self.n is not None: s += ", n={n}" @@ -2335,7 +2365,7 @@ def __init__( self._weight_initializer = weight_initializer Module.__init__(self, device=device, v=v, dtype=dtype) - def _create_variables(self, device, dtype=None): + def _create_variables(self, device=None, dtype=None): """ Create internal variables for the layer. @@ -2348,6 +2378,8 @@ def _create_variables(self, device, dtype=None): the desired data type of the internal variables to be created if not provided. Default is ``None``. """ + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) v = { "w": self._weight_initializer.create_variables( (self._num_embeddings, self._embedding_dim), @@ -2382,7 +2414,7 @@ def _forward(self, indices): emb = self._pad_embd(indices, emb) return emb - def extra_repr(self): + def _extra_repr(self): s = "num_embeddings={_num_embeddings}, embedding_dim={_embedding_dim}" if self._padding_idx is not None: s += ", padding_idx={_padding_idx}" @@ -2479,3 +2511,11 @@ def _forward(self, inputs): n=self._n, out=self._out, ) + + def _extra_repr(self): + s = "dim={_dim}" + if self._norm != "backward": + s += ", norm={_norm}" + if self._n is not False: + s += ", n={_n}" + return s.format(**self.__dict__) diff --git a/ivy/stateful/losses.py b/ivy/stateful/losses.py index 5eb65bd03fd78..1970659dd3be1 100644 --- a/ivy/stateful/losses.py +++ b/ivy/stateful/losses.py @@ -53,6 +53,12 @@ def _forward( reduction=ivy.default(reduction, self._reduction), ) + def _extra_repr(self) -> str: + return ( + f"compute_full_loss={self._compute_full_loss}, axis={self._axis}, " + f"reduction={self._reduction}" + ) + class CrossEntropyLoss(Module): def __init__( @@ -99,6 +105,11 @@ def _forward(self, true, pred, *, axis=None, epsilon=None, reduction=None): reduction=ivy.default(reduction, self._reduction), ) + def _extra_repr(self) -> str: + return ( + f"axis={self._axis}, epsilon={self._epsilon}, reduction={self._reduction}" + ) + class BinaryCrossEntropyLoss(Module): def __init__( @@ -161,3 +172,9 @@ def _forward( pos_weight=pos_weight, axis=axis, ) + + def _extra_repr(self) -> str: + return ( + f"from_logits={self._from_logits}, epsilon={self._epsilon}, " + f"reduction={self._reduction}" + ) diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 6758859cef555..5f81fac5ac5c4 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -2,9 +2,7 @@ # global from collections import OrderedDict -import functools import os -import abc import copy import dill from typing import Optional, Tuple, Dict @@ -12,29 +10,11 @@ # local import ivy from ivy.data_classes.container import Container -from ivy.func_wrapper import _get_first_array from ivy.functional.ivy.gradients import _is_variable from ivy.stateful.helpers import ModuleHelpers from ivy.stateful.converters import ModuleConverters -# helpers -def _addindent(s_, numSpaces): - s = s_.split("\n") - # don't do anything for single-line stuff - if len(s) == 1: - return s_ - first = s.pop(0) - s = [(numSpaces * " ") + line for line in s] - s = "\n".join(s) - s = first + "\n" + s - return s - - -# Base # -# -----# - - class ModuleMeta: def __new__(cls, *args, **kwargs): # check the module of the class @@ -62,21 +42,15 @@ def __init__( self, /, *args, - device=None, v=None, buffers=None, build_mode="on_init", - trace_on_next_step=False, store_vars=True, - stateful=None, - arg_stateful_idxs=None, - kwarg_stateful_idxs=None, - fallback_to_non_traced=False, with_partial_v=False, - devices=None, - dtype=None, dynamic_backend=None, training=True, + dtype=None, + device=None, **kwargs, ): """ @@ -85,86 +59,56 @@ def __init__( Parameters ---------- - device - device on which to create the module's variables 'cuda:0', 'cuda:1', 'cpu' - etc. (Default value = None) + args + Positional arguments to the _build method. v Ivy container of trainable variables. Created internally by default. + buffers + Ivy container of buffers/non-trainable arrays in the state_dict. build_mode How the Module is built, either on initialization (now), explicitly by the user by calling build(), or the first time the __call__ method is run. Default is on initialization. - trace_on_next_step - Whether to trace the network in a graph on the next forward pass. - Default is ``False``. store_vars Whether or not to store the variables created. Default is ``True``. - stateful - The constant id stateful items to track as part of the forward pass. - Used when graph compiling, default is ``None``. - arg_stateful_idxs - The nested argument indices of stateful items to track as part of - the forward pass. - Used when graph compiling, default is ``None``. - kwarg_stateful_idxs - The nested keyword argument indices of stateful items to track as part of - the forward pass. Used when graph compiling, default is ``None``. - fallback_to_non_traced - Whether to fall back to non-traced forward call in the case that an error - is raised during the traced forward pass. Default is ``True``. with_partial_v Whether to allow partial specification of variables. Default is ``False``. + dynamic_backend + When the value is true, allow conversion of arrays from a different backend + to the current backend if v passed in the input contains arrays created with + different backend. training specifies whether the module is in training or evaluation mode. Default is ``True``. - devices - devices on which to distribute the module's variables - 'cuda:0', 'cuda:1', 'cpu' etc. (Default value = None) + dtype + Data type to be used for creating model variables. (Default value = None). + device + Device on which to create the module's variables 'cuda:0', 'cuda:1', 'cpu' + etc. (Default value = None). + kwargs + Keyword arguments to the _build method. """ valid_build_modes = ["on_init", "explicit", "on_call"] ivy.utils.assertions.check_elem_in_list(build_mode, valid_build_modes) - self._device = ivy.default( - device, - ivy.default( - lambda: devices[0], - default_val=ivy.default_device(), - catch_exceptions=True, - ), - ) - self._devices = ivy.default(devices, [self._device]) self._build_mode = build_mode - self._stateful = stateful - self._arg_stateful_idxs = arg_stateful_idxs - self._kwarg_stateful_idxs = kwarg_stateful_idxs - self._fallback_to_non_traced = fallback_to_non_traced self._with_partial_v = with_partial_v self._store_vars = store_vars self._built = False - self._traced = False - self._traced_fn = None - self._trace_on_next_step = trace_on_next_step - self._v_in = v if isinstance(v, Container) or v is None else Container(v) - self.v = v - self.top_v = None - self.top_mod = None - self._track_submod_rets = False - self._submod_depth = None - self._submods_to_track = None - self._track_submod_call_order = False - self.expected_submod_rets = None - self.submod_dict = {} - backend = ivy.with_backend("numpy") - self.submod_rets = ivy.Container(alphabetical_keys=False, ivyh=backend) - self.submod_call_order = ivy.Container(alphabetical_keys=False, ivyh=backend) - self._sub_mods = set() - self._dtype = dtype + self._v_from_constructor = ( + v if isinstance(v, Container) or v is None else Container(v) + ) + self._v = v + self._buffers = Container(ivy.default(buffers, {})) + self._module_dict = Container() self._args = args self._kwargs = kwargs self._module_graph = None self._target = None self._lazy_traced = False + self._training = training self._dynamic_backend = dynamic_backend - self.training = training + self._device = ivy.default(device, ivy.default_device()) + self._dtype = ivy.default(dtype, ivy.default_dtype()) if build_mode != "on_init": return if hasattr(Module, "_init_var"): @@ -177,12 +121,7 @@ def __init__( if v or with_partial_v: # build only if `v` or `with_partial_v` - self.build( - *args, - dynamic_backend=dynamic_backend, - buffers=buffers, - **kwargs, - ) + self.build(*args, dynamic_backend=dynamic_backend, **kwargs) # we don't want to delete the class variable now # since there could be other child modules return @@ -197,9 +136,7 @@ def __init__( # move on Module._init_var.pop() return - self.build( - *args, dynamic_backend=dynamic_backend, buffers=buffers, **kwargs - ) + self.build(*args, dynamic_backend=dynamic_backend, **kwargs) if Module._init_var[-1] == self.__class__.__name__: # you delete it, only if this is the class that caused it's creation Module._init_var.pop() @@ -209,485 +146,10 @@ def __init__( del Module._init_var return - self.build(*args, dynamic_backend=dynamic_backend, buffers=buffers, **kwargs) - - # Private # - # --------# - - def _fn_with_var_arg_wrapper( - self, *a, fn, v_fn, keychain_mappings, orig_key_chain, **kw - ): - if "v" in kw: - del kw["v"] - v = v_fn(self.v, keychain_mappings, orig_key_chain) - return fn(*a, **kw, v=v) - - def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): - """ - Extract variables from `v_fn` and use it as inputs for `fn`. - - Use `v_fn` to extract the variables and use the extracted - variables as inputs to the call function fn of the module. - """ - _fn_with_var_arg_wrapper = functools.partial( - self._fn_with_var_arg_wrapper, - fn=fn, - v_fn=v_fn, - keychain_mappings=keychain_mappings, - orig_key_chain=orig_key_chain, - ) - _fn_with_var_arg_wrapper.wrapped = True - return _fn_with_var_arg_wrapper - - def _find_variables( - self, /, *, obj=None, _visited=None, without_initialisation=False - ): - """ - Find all internal variables in obj. Return empty Container if obj is None. - - Parameters - ---------- - obj - The submodule whose internal variables are to be returned. Default - is None. - _visited - Placeholder for tracking the visited nodes, do not set this parameter. - - Returns - ------- - ret - The internal variables of the submodule passed in the argument. - """ - _visited = ivy.default(_visited, {}) - vs = Container() - if id(obj) in _visited: - return vs - _visited[id(obj)] = True - # ToDo: add support for finding local variables, if/when JAX supports - # uniquely flagging variables - if isinstance(obj, Module) and obj is not self: - obj.top_v = self._top_v_fn - obj.top_mod = self._top_mod_fn - self._sub_mods.add(obj) - - if not obj.built_ and without_initialisation: - return lambda: obj._build_and_return_v( - *obj._args, dynamic_backend=self._dynamic_backend, **obj._kwargs - ) - - return obj._build_and_return_v( - *obj._args, dynamic_backend=obj._dynamic_backend, **obj._kwargs - ) - elif isinstance(obj, (list, tuple)): - for i, v in enumerate(obj): - ret = self._find_variables( - obj=v, - _visited=_visited, - without_initialisation=without_initialisation, - ) - if ret: - vs[f"v{str(i)}"] = ret - return vs - elif isinstance(obj, dict): - for k, v in obj.items(): - ret = self._find_variables( - obj=v, - _visited=_visited, - without_initialisation=without_initialisation, - ) - if ret: - vs[k[1:] if k[0] == "_" else k] = ret - return vs - elif not hasattr(obj, "__dict__"): - return vs - for k, v in obj.__dict__.items(): - if v is not None and k[0:2] != "__": - ret = self._find_variables( - obj=v, - _visited=_visited, - without_initialisation=without_initialisation, - ) - if ret: - vs[k[1:] if k[0] == "_" else k] = ret - return vs - - def _build_and_return_v(self, *args, **kwargs): - self.build(*args, **kwargs) - return self.v - - def _find_child_objects(self, /, *, obj=None, _visited=None): - pass - - def _find_buffers(self): - for obj in self.__dict__.keys(): - if isinstance(getattr(self, obj), ivy.Module): - # simply fetch it's buffer - if hasattr(getattr(self, obj), "buffers"): - self.buffers.update({obj: getattr(self, obj).buffers}) - - @staticmethod - def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): - """ - Extract the variables from the variables container v using the key - orig_key_chain and reinstantiate the duplicate variables that were removed by - _remove_duplicate_variables in their correct locations using keychain_mappings. - - Parameters - ---------- - v - The variables container - keychain_mappings - The keychain mappings of duplicate vatriables - orig_key_chain - keychain of the variables to be extracted - - - Returns - ------- - ret_cont - container with the extracted variables. - """ - if v.cont_has_key_chain(orig_key_chain): - ret_cont = v.cont_at_key_chain(orig_key_chain) - else: - ret_cont = ivy.Container() - for old_kc, new_kc in keychain_mappings.items(): - if orig_key_chain in old_kc: - ret_cont = ret_cont.cont_set_at_key_chain( - "/".join(new_kc.split("/")[1:]), v.cont_at_key_chain(new_kc) - ) - return ret_cont - - def _wrap_call_methods( - self, keychain_mappings, /, *, key="", obj=None, _visited=None - ): - """ - Wrap the call methods of the Module object by looping over all the items within - the module, wrapping the __call__ methods of all submodules using - _fn_with_var_arg. - - Parameters - ---------- - keychain_mappings - The keychain mappings of the object - key - The keychain of the object obj, used for recursion. - obj - the object whose __call__ method is to be wrapped - _visited - Placeholder for tracking the visited nodes, do not set this parameter. - - Returns - ------- - None - """ - _visited = ivy.default(_visited, {}) - if id(obj) in _visited or not isinstance(key, str): - return - _visited[id(obj)] = True - if isinstance(obj, Module) and obj is not self: - orig_key_chain = key[1:] if key[0] == "_" else key - - obj.__call__ = self._fn_with_var_arg( - obj.__call__, self._extract_v, keychain_mappings, orig_key_chain - ) - return - elif isinstance(obj, (list, tuple)): - for i, val in enumerate(obj): - self._wrap_call_methods( - keychain_mappings, - key=f"{key}/v{str(i)}", - obj=val, - _visited=_visited, - ) - return - elif isinstance(obj, dict): - for k, val in obj.items(): - k = f"{key}/{k}" if key != "" and isinstance(k, str) else k - self._wrap_call_methods( - keychain_mappings, key=k, obj=val, _visited=_visited - ) - return - if not hasattr(obj, "__dict__"): - return - for k, val in obj.__dict__.items(): - if k[0:2] == "__": - continue - k = f"{key}/{k}" if key != "" else k - if val is not None: - self._wrap_call_methods( - keychain_mappings, key=k, obj=val, _visited=_visited - ) - return - - @staticmethod - def _remove_duplicate_variables(vs, created, /): - """ - Remove duplicate variables in `vs` referring to `created`. - - Parameters - ---------- - vs - The container that needs to be pruned. - created - The container as the duplication reference. - - Returns - ------- - vs - The container after removing duplicate variables. - keychain_mappings - Dict storing those keys and ids being removed. - """ - created_ids = created.cont_map(lambda x, kc: id(x)) - vs_ids = vs.cont_map(lambda x, kc: id(x)) - ids = {} - duplicate_keychains = [] - keychain_mappings = {} - - def unique_callback(x, kc): - ids[x] = kc - - def found_dup_callback(x, kc): - if ids[x] == kc: - return - duplicate_keychains.append(kc) - keychain_mappings[kc] = ids[x] - - created_ids.cont_map(lambda x, kc: unique_callback(x, kc)) - vs_ids.cont_map( - lambda x, kc: ( - unique_callback(x, kc) if x not in ids else found_dup_callback(x, kc) - ) - ) - for dup_kc in duplicate_keychains: - vs = vs.cont_prune_key_chain(dup_kc) - return vs, keychain_mappings - - def _set_buffers(self, buffers): - """ - Set the buffers of the given class instance, according to the buffers passed. - - Parameters - ---------- - buffers - a dictionary with variable names and corresponding values - - override - if true, sets the variable as an attribute even if it doesn't exist - """ - for buffer in buffers: - if hasattr(self, buffer): - # check if this value is another nested dictionary, if yes - # we recurse - if isinstance(buffers[buffer], dict): - getattr(self, buffer)._set_buffers(buffers=buffers[buffer]) - else: - setattr(self, buffer, buffers[buffer]) - else: - if hasattr(self, "buffers"): - self.buffers.update({buffer: buffers[buffer]}) - else: - setattr(self, "buffers", {buffer: buffers[buffer]}) - setattr(self, buffer, buffers[buffer]) - - # Overridable # - - # noinspection PyMethodMayBeStatic,PyUnusedLocal - def _create_variables(self, *, device=None, dtype=None): - """ - Create internal trainable variables, and return as arbitrary nested dict. - Overridable. - - Parameters - ---------- - device - The device string, specifying the device on which to create the variables. - - Returns - ------- - ret - An empty set. - """ - return {} - - def _build(self, *args, **kwargs) -> bool: - """ - Build the internal layers and variables for this module. Overridable. + self.build(*args, dynamic_backend=dynamic_backend, **kwargs) - Returns - ------- - ret - False or empty Container if the build only partially completed (i.e. some - child Modules have "on_call" build mode). Alternatively, return True or a - container of the built variables if the module is built. - """ - return True - - # Abstract # - - @abc.abstractmethod - def _forward(self, *args, **kwargs): - """ - Forward pass of the layer, called after handling the optional input variables. - - Raises - ------ - NotImplementedError - """ - raise ivy.utils.exceptions.IvyNotImplementedException - - def _forward_with_tracking(self, *args, **kwargs): - """ - Forward pass while optionally tracking submodule returns and call order. - - Returns - ------- - ret - Result of the forward pass of the layer. - """ - if self.track_submod_call_order(): - self._add_submod_enter() - ret = self._forward(*args, **kwargs) - track_submod_rets = self.track_submod_rets() - check_submod_rets = self.check_submod_rets() - if track_submod_rets or check_submod_rets: - self._add_submod_ret(ret) - if check_submod_rets: - self._check_submod_ret() - return ret - - def _call(self, *args, v=None, buffers=None, **kwargs): - """ - Compute forward pass of the layer, treating layer instance as callable function. - - Parameters - ---------- - v - Replace `v` of current layer when forwarding. Restore - after the forward finished. - - Returns - ------- - ret - Result of the forward pass of the layer. - """ - if not self._built: - self.build( - *args, - **kwargs, - from_call=True, - dtype=_get_first_array(*args, **kwargs).dtype, - ) - if buffers: - buffers_orig = self.buffers.copy() - self.buffers = {} - self._set_buffers(buffers) - if v is not None: - v_orig = self.v - self.v = ( - Container(v, **v.cont_config) - if isinstance(v, Container) - else Container(v) - ) - ret = self._forward_with_tracking(*args, **kwargs) - self.v = v_orig - if buffers: - self.buffers = {} - self._set_buffers(buffers_orig) - return ret - - elif hasattr(self.__call__, "wrapped"): - return self.__call__(*args, **kwargs) - return self._forward_with_tracking(*args, **kwargs) - - # Public # - # -------# - def __call__( - self, - *args, - v=None, - buffers=None, - stateful=None, - arg_stateful_idxs=None, - kwarg_stateful_idxs=None, - track_submod_rets=False, - submod_depth=None, - submods_to_track=None, - track_submod_call_order=False, - expected_submod_rets=None, - **kwargs, - ): - """ - Forward an input through current module. - - Parameters - ---------- - v - If given, use this container as internal variables temporarily. - Default is ``None``. - track_submod_rets - If True, will track the returns of submodules. - submod_depth - The depth of tracked submodules. - submods_to_track - If given, will only track submodules in `submods_to_track`. - track_submod_call_order - If True, will track the call order of submodules. - expected_submod_rets - If given, will raise exception if submodule returns are - different from expected returns. - - Returns - ------- - ret - """ - if self._lazy_traced: - # we are creating graph since we want to transpile module, - # so set the appropriate backend - if self._target: - ivy.set_backend(self._target) - self.trace_graph(args=args, kwargs=kwargs) - if self._target: - ivy.previous_backend() - - if self._module_graph: - # we need `v` in kwargs, since this is a traced call - v = v if v else self.v - return self._module_graph(*args, v=v, **kwargs) - - backend = ivy.with_backend("numpy") - self.submod_rets = ivy.Container(alphabetical_keys=False, ivyh=backend) - self.submod_call_order = ivy.Container(alphabetical_keys=False, ivyh=backend) - self._set_submod_flags( - track_submod_rets, - submod_depth, - submods_to_track, - track_submod_call_order, - expected_submod_rets, - ) - - # convert variables to native arrays so that they can be tracked - v = ivy.to_native(v) - ret = self._call(*args, v=v, buffers=buffers, **kwargs) - self._unset_submod_flags() - return ret - - def save_weights(self, weights_path, /): - """ - Save the weights on the Module. - - Parameters - ---------- - weights_path - The hdf5 file for saving the weights. - - Returns - ------- - None - """ - os.makedirs("/".join(weights_path.split("/")[:-1]), exist_ok=True) - self.v.cont_to_disk_as_hdf5(weights_path) + # Public Methods # + # ---------------# def build( self, @@ -696,7 +158,6 @@ def build( device=None, dtype=None, dynamic_backend=None, - buffers=None, **kwargs, ): """ @@ -704,6 +165,8 @@ def build( Parameters ---------- + args + Positional arguments to the _build method. from_call If True, denote that this build is triggered by calling. Otherwise, triggered by initializing the module. Default is ``False``. @@ -712,6 +175,11 @@ def build( Default is ``None``. dtype The data type for building the module. Default is ``None``. + dynamic_backend + Whether to use dynamic backend setting to deal if variables are passed as + input and created with a different backend to the current backend. + kwargs + Keyword arguments to the _build method. Returns ------- @@ -719,13 +187,11 @@ def build( True for successfully built a module. """ self._device = ivy.default(device, self._device) + self._dtype = ivy.default(dtype, self._dtype) + self._dynamic_backend = ivy.default(dynamic_backend, self._dynamic_backend) # return False if not from_call but build_mode is on_call if not from_call and self._build_mode == "on_call": return self.v - if dtype: - dtype = ivy.default_dtype(dtype=dtype, as_native=True) - else: - dtype = ivy.default_dtype(dtype=self._dtype, as_native=True) # why are we adding this kwarg in user-defined build ? # it results in the error while doing `from_haiku_module` if haiku's forward @@ -744,45 +210,45 @@ def build( ) # build variables based on locally built layers, if v not passed in constructor - v_from_constructor = self._v_in - created_n_found = Container( dict( **self._find_variables( obj=self, without_initialisation=( True - if v_from_constructor and not self._with_partial_v + if self._v_from_constructor and not self._with_partial_v else False ), ), **created, ), - dynamic_backend=dynamic_backend, + dynamic_backend=self._dynamic_backend, ) created_n_found.cont_config["build_callable"] = True - if ivy.exists(v_from_constructor): + if ivy.exists(self._v_from_constructor): if self._with_partial_v: - if v_from_constructor: + if self._v_from_constructor: created_n_found.cont_assert_contains_sub_structure( - v_from_constructor, partial=True + self._v_from_constructor, partial=True ) - self.v = created_n_found.cont_set_at_key_chains(v_from_constructor) + self._v = created_n_found.cont_set_at_key_chains( + self._v_from_constructor + ) else: created_n_found, _ = self._remove_duplicate_variables( created_n_found, created ) ivy.Container.cont_assert_identical_structure( - [created_n_found, v_from_constructor], + [created_n_found, self._v_from_constructor], assert_and_assign=True, ) - self.v = created_n_found + self._v = created_n_found else: - self.v = created_n_found + self._v = created_n_found # remove duplicates - self.v, keychain_mappings = self._remove_duplicate_variables(self.v, created) + self._v, keychain_mappings = self._remove_duplicate_variables(self.v, created) # build any child 'on_call' layers if not built and from_call: # update child modules to share the same device @@ -795,17 +261,17 @@ def build( # re-build variables based on additional child on-call layers, if v not # passed in constructor - if not ivy.exists(v_from_constructor): + if not ivy.exists(self._v_from_constructor): created_n_found = Container( dict( **self._find_variables(obj=self), **self._create_variables(device=self._device, dtype=dtype), ) ) - self.v = created_n_found + self._v = created_n_found # remove further duplicates with self.v - self.v, keychain_mappings = self._remove_duplicate_variables( + self._v, keychain_mappings = self._remove_duplicate_variables( self.v, created ) @@ -821,95 +287,104 @@ def build( v_ret = self.v if not self._store_vars: # ToDo: verify variables in self.v are released once this method exits - self.v = ivy.Container() + self._v = ivy.Container() # once all variables built, find and assign buffers - if buffers: - self._set_buffers(buffers=buffers) - self._find_buffers() + self._find_buffers() + + # compute the module dict + self._compute_module_dict() return v_ret if bool(v_ret) or isinstance(built, bool) else built - def register_buffer(self, var_name, value): - """Set the buffer at any place within the class.""" - self._set_buffers({var_name: value}) + def trace_graph( + self, + args: Optional[Tuple] = None, + kwargs: Optional[Dict] = None, + **trace_kwargs, + ): + """ + Trace the `ivy.Module`'s `_unified_ivy_graph` or `_call` method to the target + backend. - def eval(self): - # disables training mode for child modules - self.train(mode=False) + Parameters + ---------- + args: + arguments used to trace. Defaults to None. + kwargs: + keyword arguments used to trace. Defaults to None. + trace_kwargs: + keyword arguments passed to the trace function. + """ + # no arguments given to trace, so delay the compilation + if not (args or kwargs): + self._lazy_traced = True + return + + # we do not need convert the args to source + args = ivy.default(args, ()) + kwargs = ivy.default(kwargs, {}) + + # shallow copy the kwargs dict + kwargs = copy.copy(kwargs) + kwargs["v"] = self.v + + fn_to_trace = ivy.default(self._module_graph, self._call) + + self._module_graph = ivy.trace_graph( + fn_to_trace, **trace_kwargs, args=args, kwargs=kwargs + ) + + self._lazy_traced = False + + def register_buffer(self, name, value): + """ + Register a buffer. + + Parameters + ---------- + name + Name of the buffer + value + Value of the buffer + """ + self._buffers.update({name: value}) + + def register_parameter(self, name, value): + """ + Register a parameter. + + Parameters + ---------- + name + Name of the buffer + value + Value of the buffer + """ + self._v.update({name: value}) def train(self, mode: bool = True): - # enables/disables training mode - self.training = mode + """Enable or disable training mode.""" + self._training = mode for module in self.v: module = getattr(self, module, None) if isinstance(module, ivy.Module): module.train(mode=mode) + def eval(self): + """Disable training mode.""" + self.train(mode=False) + def to_device(self, device): - # moves the weights and buffers - # to the specified device + """Move the weights and buffers to the specified device.""" self._device = ivy.default(device, self._device) - # moving weights and buffers to new device - for key, obj in self.state_dict().items(): + for _, obj in self.state_dict.items(): if isinstance(obj, ivy.Module): obj.to_device(device) elif ivy.is_array(obj) or ivy.is_ivy_container(obj): ivy.to_device(obj, device, out=obj) return self - def __repr__(self): - extra_lines = [] - extra_repr = self.extra_repr() - if extra_repr: - extra_lines = extra_repr.split("\n") - child_lines = [] - for key, module in self.v.items(): - if isinstance(getattr(self, key, None), Module): - mod_str = repr(getattr(self, key)) - mod_str = _addindent(mod_str, 2) - child_lines.append(f"({key}): {mod_str}") - lines = extra_lines + child_lines - - main_str = f"{self._get_name()}(" - if lines: - # simple one-liner info, which most builtin Modules will use - if len(extra_lines) == 1 and not child_lines: - main_str += extra_lines[0] - else: - main_str += "\n " + "\n ".join(lines) + "\n" - - main_str += ")" - return main_str - - def extra_repr(self) -> str: - r""" - Set the extra representation of the module. - - To print customized extra information, you should re-implement - this method in your own modules. Both single-line and multi-line - strings are acceptable. - """ - return "" - - def _get_name(self): - return self.__class__.__name__ - - # Properties # - # -----------# - - @property - def build_mode(self): - return self._build_mode - - @property - def built_(self): - return self._built - - @property - def device(self): - return self._device - def show_graph( self, randomness_factor: float = 0.1, @@ -937,72 +412,21 @@ def show_graph( fname=fname, ) - def __getattribute__(self, name): - if name == "v": - if super().__getattribute__("v") is None and not self.built_: - self._build_and_return_v( - *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs - ) - if name != "buffers": - if hasattr(self, "buffers") and name in self.buffers: - return self.buffers[name] - return super().__getattribute__(name) - - def __setattr__(self, name, value): - if hasattr(self, "buffers") and name in self.buffers: - self.buffers[name] = value - return - return super().__setattr__(name, value) - - def __delattr__(self, name): - if hasattr(self, "buffers"): - if name in self.buffers: - del self.buffers[name] - else: - super().__delattr__(name) - - def state_dict(self): - return {**self.v, **getattr(self, "buffers", {})} - - def trace_graph( - self, - args: Optional[Tuple] = None, - kwargs: Optional[Dict] = None, - **trace_kwargs, - ): + def save_weights(self, weights_path, /): """ - Trace the `ivy.Module`'s `_unified_ivy_graph` or `_call` method to the target - backend. + Save the weights on the Module. Parameters ---------- - args: - arguments used to trace. Defaults to None. - kwargs: - keyword arguments used to trace. Defaults to None. - trace_kwargs: - keyword arguments passed to the trace function. - """ - # no arguments given to trace, so delay the compilation - if not (args or kwargs): - self._lazy_traced = True - return - - # we do not need convert the args to source - args = ivy.default(args, ()) - kwargs = ivy.default(kwargs, {}) - - # shallow copy the kwargs dict - kwargs = copy.copy(kwargs) - kwargs["v"] = self.v - - fn_to_trace = ivy.default(self._module_graph, self._call) - - self._module_graph = ivy.trace_graph( - fn_to_trace, **trace_kwargs, args=args, kwargs=kwargs - ) + weights_path + The hdf5 file for saving the weights. - self._lazy_traced = False + Returns + ------- + None + """ + os.makedirs("/".join(weights_path.split("/")[:-1]), exist_ok=True) + self.v.cont_to_disk_as_hdf5(weights_path) def save(self, filename): """ @@ -1041,6 +465,205 @@ def load(filename): loaded._convert_numpy_to_tensors() return loaded + # Dunder Methods # + # ---------------# + + def __call__( + self, + *args, + v=None, + buffers=None, + **kwargs, + ): + """ + Forward an input through current module. + + Parameters + ---------- + args + Positional args to the build method. + v + If given, use this container as internal variables temporarily. + Default is ``None``. + buffers + If given, use this container as internal buffers temporarily. + Default is ``None``. + kwargs + Keyword arguments to the build method. + + Returns + ------- + ret + """ + if self._lazy_traced: + # we are creating graph since we want to transpile module, + # so set the appropriate backend + if self._target: + ivy.set_backend(self._target) + self.trace_graph(args=args, kwargs=kwargs) + if self._target: + ivy.previous_backend() + + if self._module_graph: + # we need `v` in kwargs, since this is a traced call + v = v if v else self.v + return self._module_graph(*args, v=v, **kwargs) + + # convert variables to native arrays so that they can be tracked + v = ivy.to_native(v) + ret = self._call(*args, v=v, buffers=buffers, **kwargs) + return ret + + def __getattribute__(self, name): + if name == "v": + if super().__getattribute__("v") is None and not self.built: + self._build_and_return_v( + *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs + ) + return super().__getattribute__(name) + + def __setattr__(self, name, value): + if name in ["v", "buffers"]: + name = "_" + name + if isinstance(value, Module): + ret = super().__setattr__(name, value) + if ( + hasattr(self, "_build_mode") + and self.build_mode == "on_init" + and self.built + ): + self._rebuild() + return ret + return super().__setattr__(name, value) + + def __delattr__(self, name): + if hasattr(self, name): + if isinstance(getattr(self, name), Module): + super().__delattr__(name) + if self.build_mode == "on_init": + self._rebuild() + return + super().__delattr__(name) + + def __repr__(self): + extra_lines = [] + extra_repr = self._extra_repr() + if extra_repr: + extra_lines = extra_repr.split("\n") + child_lines = [] + for key, _ in self.v.items(): + if isinstance(getattr(self, key, None), Module): + mod_str = repr(getattr(self, key)) + mod_str = self._addindent(mod_str, 2) + child_lines.append(f"({key}): {mod_str}") + lines = extra_lines + child_lines + + main_str = f"{self.__class__.__name__}(" + if lines: + # simple one-liner info, which most builtin Modules will use + if len(extra_lines) == 1 and not child_lines: + main_str += extra_lines[0] + else: + main_str += "\n " + "\n ".join(lines) + "\n" + + main_str += ")" + return main_str + + # Methods to be Optionally Overriden # + # -----------------------------------# + + def _create_variables(self, *, device=None, dtype=None): + """ + Create internal trainable variables, and return as arbitrary nested dict. + Overridable. + + Parameters + ---------- + device + The device string, specifying the device on which to create the variables. + dtype + The dtype string, specifying the dtype on which to create the variables. + + Returns + ------- + ret + An empty set. + """ + return {} + + def _build(self, *args, **kwargs) -> bool: + """ + Build the internal layers and variables for this module. Overridable. + + Returns + ------- + ret + False or empty Container if the build only partially completed (i.e. some + child Modules have "on_call" build mode). Alternatively, return True or a + container of the built variables if the module is built. + """ + return True + + def _forward(self, *args, **kwargs): + """ + Forward pass of the layer, called after handling the optional input variables. + + Raises + ------ + NotImplementedError + """ + raise ivy.utils.exceptions.IvyNotImplementedException + + def _extra_repr(self) -> str: + """ + Set the extra representation of the module. + + To print customized extra information, you should re-implement + this method in your own modules. Both single-line and multi-line + strings are acceptable. + """ + return "" + + # Properties # + # -----------# + + @property + def device(self): + return self._device + + @property + def dtype(self): + return self._dtype + + @property + def build_mode(self): + return self._build_mode + + @property + def built(self): + return self._built + + @property + def training(self): + return self._training + + @property + def v(self): + return self._v + + @property + def buffers(self): + return self._buffers + + @property + def state_dict(self): + """Return the state_dict which is a collection of the variables and buffers.""" + return {**self.v, **self.buffers} + + @property + def module_dict(self): + return self._module_dict + class _HaikuIvyModule(Module): def __init__(self, *args, params_hk, native_module, device, devices, **kwargs): diff --git a/ivy/stateful/norms.py b/ivy/stateful/norms.py index 65560176ddedb..9e68fe433651e 100644 --- a/ivy/stateful/norms.py +++ b/ivy/stateful/norms.py @@ -52,8 +52,10 @@ def __init__( self._bias_init = Zeros() Module.__init__(self, device=device, v=v, dtype=dtype) - def _create_variables(self, device, dtype=None): + def _create_variables(self, device=None, dtype=None): """Create internal variables for the layer.""" + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) if self._elementwise_affine: return { "weight": self._weight_init.create_variables( @@ -88,6 +90,12 @@ def _forward(self, inputs): new_std=self._new_std, ) + def _extra_repr(self) -> str: + return ( + f"normalized_idxs={self._normalized_idxs}, epsilon={self._epsilon}, " + f"elementwise_affine={self._elementwise_affine}, new_std={self._new_std}" + ) + class BatchNorm2D(Module): def __init__( @@ -154,8 +162,10 @@ def __init__( self._running_var_init = Ones() Module.__init__(self, device=device, v=v, dtype=dtype, training=training) - def _create_variables(self, device, dtype=None): + def _create_variables(self, device=None, dtype=None): """Create internal variables for the layer.""" + device = ivy.default(device, self.device) + dtype = ivy.default(dtype, self.dtype) if self._affine: return { "b": self._bias_init.create_variables( @@ -203,3 +213,11 @@ def _forward(self, inputs): self.v.running_var = running_var return normalized + + def _extra_repr(self) -> str: + return ( + f"num_features={self._num_features}, affine={self._affine}, " + f"data_format={self._data_format}, epsilon={self._epsilon} " + f"momentum={self._momentum}, " + f"track_running_stats={self._track_running_stats}" + ) diff --git a/ivy/stateful/sequential.py b/ivy/stateful/sequential.py index a7ef0f6f969ec..3656b1f3b24af 100644 --- a/ivy/stateful/sequential.py +++ b/ivy/stateful/sequential.py @@ -75,3 +75,9 @@ def _forward(self, inputs): ) x = submod(x) return x + + def _extra_repr(self): + submods = [] + for i, submod in enumerate(self._submodules): + submods.append(f"v{i}={submod}") + return ", ".join(submods) diff --git a/ivy_tests/test_ivy/test_stateful/test_layers.py b/ivy_tests/test_ivy/test_stateful/test_layers.py index 1fae883a74d60..b421fbf483eab 100644 --- a/ivy_tests/test_ivy/test_stateful/test_layers.py +++ b/ivy_tests/test_ivy/test_stateful/test_layers.py @@ -1569,113 +1569,112 @@ def test_multi_head_attention_layer( ]), with_v=st.booleans(), seq_v=st.booleans(), - dtype=helpers.get_dtypes("float", full=False, none=True), + dtype=helpers.get_dtypes("float", full=False), ) def test_sequential_layer( - bs_c_target, - with_v, - seq_v, - dtype, - method_flags, - on_device, - trace_graph, - method_name, - class_name, + bs_c_target, with_v, seq_v, dtype, method_flags, on_device, backend_fw ): - dtype = dtype[0] - # smoke test - batch_shape, channels, target = bs_c_target - tolerance_dict = { - "bfloat16": 1e-2, - "float16": 1e-2, - "float32": 1e-5, - "float64": 1e-5, - None: 1e-5, - } - if method_flags.as_variable[0]: - x = _variable( - ivy.asarray( + with ivy.utils.backend.ContextManager(backend_fw): + dtype = dtype[0] + if backend_fw == "torch": + assume("float16" not in dtype) + if backend_fw == "paddle": + assume(dtype != "float16") + # smoke test + batch_shape, channels, target = bs_c_target + tolerance_dict = { + "bfloat16": 1e-1, + "float16": 1e-2, + "float32": 1e-2, + "float64": 1e-2, + } + if method_flags.as_variable[0]: + x = _variable( + ivy.asarray( + ivy.linspace( + ivy.zeros(batch_shape), ivy.ones(batch_shape), channels + ), + dtype=dtype, + ) + ) + else: + x = ivy.asarray( ivy.linspace(ivy.zeros(batch_shape), ivy.ones(batch_shape), channels), dtype=dtype, ) - ) - else: - x = ivy.asarray( - ivy.linspace(ivy.zeros(batch_shape), ivy.ones(batch_shape), channels), - dtype=dtype, - ) - if with_v: - np.random.seed(0) - wlim = (6 / (channels + channels)) ** 0.5 - v = Container({ - "submodules": { - "v0": { - "w": _variable( - ivy.array( - np.random.uniform(-wlim, wlim, (channels, channels)), - dtype=dtype, - device=on_device, - ) - ), - "b": _variable( - ivy.zeros([channels], device=on_device, dtype=dtype) - ), - }, - "v2": { - "w": _variable( - ivy.array( - np.random.uniform(-wlim, wlim, (channels, channels)), - dtype=dtype, - device=on_device, - ) - ), - "b": _variable( - ivy.zeros([channels], device=on_device, dtype=dtype) - ), - }, - } - }) - else: - v = None - if seq_v: - seq = ivy.Sequential( - ivy.Linear(channels, channels, device=on_device, dtype=dtype), - ivy.Dropout(0.0), - ivy.Linear(channels, channels, device=on_device, dtype=dtype), - device=on_device, - v=v if with_v else None, - dtype=dtype, - ) - else: - seq = ivy.Sequential( - ivy.Linear( - channels, - channels, + if with_v: + np.random.seed(0) + wlim = (6 / (channels + channels)) ** 0.5 + v = Container({ + "submodules": { + "v0": { + "w": _variable( + ivy.array( + np.random.uniform(-wlim, wlim, (channels, channels)), + dtype=dtype, + device=on_device, + ) + ), + "b": _variable( + ivy.zeros([channels], device=on_device, dtype=dtype) + ), + }, + "v2": { + "w": _variable( + ivy.array( + np.random.uniform(-wlim, wlim, (channels, channels)), + dtype=dtype, + device=on_device, + ) + ), + "b": _variable( + ivy.zeros([channels], device=on_device, dtype=dtype) + ), + }, + } + }) + else: + v = None + if seq_v: + seq = ivy.Sequential( + ivy.Linear(channels, channels, device=on_device, dtype=dtype), + ivy.Dropout(0.0, dtype=dtype), + ivy.Linear(channels, channels, device=on_device, dtype=dtype), device=on_device, - v=v["submodules"]["v0"] if with_v else None, + v=v if with_v else None, dtype=dtype, - ), - ivy.Dropout(0.0), - ivy.Linear( - channels, - channels, + ) + else: + seq = ivy.Sequential( + ivy.Linear( + channels, + channels, + device=on_device, + v=v["submodules"]["v0"] if with_v else None, + dtype=dtype, + ), + ivy.Dropout(0.0, dtype=dtype), + ivy.Linear( + channels, + channels, + device=on_device, + v=v["submodules"]["v2"] if with_v else None, + dtype=dtype, + ), device=on_device, - v=v["submodules"]["v2"] if with_v else None, dtype=dtype, - ), - device=on_device, + ) + ret = seq(x) + # type test + assert ivy.is_ivy_array(ret) + # cardinality test + assert ret.shape == ivy.Shape(batch_shape + [channels]) + # value test + if not with_v: + return + assert np.allclose( + ivy.to_numpy(seq(x)), np.array(target), rtol=tolerance_dict[dtype] ) - ret = seq(x) - # type test - assert ivy.is_ivy_array(ret) - # cardinality test - assert ret.shape == ivy.Shape(batch_shape + [channels]) - # value test - if not with_v: - return - assert np.allclose( - ivy.to_numpy(seq(x)), np.array(target), rtol=tolerance_dict[dtype] - ) all_initializers = ( diff --git a/ivy_tests/test_ivy/test_stateful/test_modules.py b/ivy_tests/test_ivy/test_stateful/test_modules.py index 2b61e72b22645..3a0c97444e38d 100644 --- a/ivy_tests/test_ivy/test_stateful/test_modules.py +++ b/ivy_tests/test_ivy/test_stateful/test_modules.py @@ -134,7 +134,7 @@ def _forward(self, x): class ModuleWithBuffer(ivy.Module): def __init__(self, *args, **kwargs): - pass + super().__init__() def _forward(self, *args, **kwargs): pass @@ -148,191 +148,19 @@ def _forward(): pass -@given( - buffer=st.just([ - { - "var1": [ - ivy.ones((1, 2)), - ] - } - ]) -) +@given(buffer=st.just({"var1": np.ones((1, 2))})) def test_get_buffers(buffer, backend_fw): with ivy.utils.backend.ContextManager(backend_fw): module = ModuleWithBuffer() - buffers = {} - for item in buffer: - buffers.update(item) - for key in item: - module.register_buffer(key, item[key]) + buffers = ivy.Container() + for name, value in buffer.items(): + value = ivy.array(value) + buffers[name] = value + module.register_buffer(name, value) assert module.buffers == buffers -# check submod returns -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_module_check_submod_rets( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - x = ivy.astype( - ivy.linspace(ivy.zeros(batch_shape), ivy.ones(batch_shape), input_channels), - "float32", - ) - module = WithNestedModules(input_channels, output_channels, device=on_device) - - # depth 1 - ret = module(x, track_submod_rets=True, submod_depth=1) - assert ret.shape == tuple(list(batch_shape) + [64]) - sm_rets = module.submod_rets - module(x, expected_submod_rets=sm_rets) - sm_rets.random_uniform(map_sequences=True) - try: - module(x, expected_submod_rets=sm_rets.random_uniform(map_sequences=True)) - raise Exception( - "forward pass succeeded despite passing random expected_submod_rets, " - "assertion error expected." - ) - except ivy.utils.exceptions.IvyException: - pass - - # depth 2 (full) - ret = module(x, track_submod_rets=True) - assert ret.shape == tuple(list(batch_shape) + [64]) - sm_rets = module.submod_rets - module(x, expected_submod_rets=sm_rets) - try: - module(x, expected_submod_rets=sm_rets.random_uniform(map_sequences=True)) - raise Exception( - "forward pass succeeded despite passing random expected_submod_rets, " - "assertion error expected." - ) - except ivy.utils.exceptions.IvyException: - pass - - # partial submodules - ret = module( - x, track_submod_rets=True, submods_to_track=[module._dl1, module._dl0._l0] - ) - assert ret.shape == tuple(list(batch_shape) + [64]) - sm_rets = module.submod_rets - module(x, expected_submod_rets=sm_rets) - try: - module(x, expected_submod_rets=sm_rets.random_uniform(map_sequences=True)) - raise Exception( - "forward pass succeeded despite passing random expected_submod_rets, " - "assertion error expected." - ) - except ivy.utils.exceptions.IvyException: - pass - - # with tolerances - ret = module(x, track_submod_rets=True) - assert ret.shape == tuple(list(batch_shape) + [64]) - sm_rets_orig = module.submod_rets - sm_rets = ivy.Container( - { - k: {"val": v, "atol": [1e-8] * len(v), "rtol": [1e-5] * len(v)} - for k, v in sm_rets_orig.items() - }, - **sm_rets_orig._config, - ) - module(x, expected_submod_rets=sm_rets) - sm_rets = ivy.Container( - { - k: {"val": v, "atol": 1e-8, "rtol": 1e-5} - for k, v in sm_rets_orig.items() - }, - **sm_rets_orig._config, - ) - module(x, expected_submod_rets=sm_rets) - try: - module(x, expected_submod_rets=sm_rets.random_uniform(map_sequences=True)) - raise Exception( - "forward pass succeeded despite passing random expected_submod_rets, " - "assertion error expected." - ) - except ivy.utils.exceptions.IvyException: - pass - - -# module depth -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_module_depth( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - module = WithNestedModules(input_channels, output_channels, device=on_device) - - # depth 0 - assert module.mod_depth() == 0 - - # depth 1 - assert module._dl0.mod_depth() == 1 - assert module._dl1.mod_depth() == 1 - - # depth 2 - assert module._dl0._l0.mod_depth() == 2 - assert module._dl0._l1.mod_depth() == 2 - assert module._dl1._l0.mod_depth() == 2 - assert module._dl1._l1.mod_depth() == 2 - - -# module height -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_module_height( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - module = WithNestedModules(input_channels, output_channels, device=on_device) - - # height 2 - assert module.mod_height() == 2 - - # height 1 - assert module._dl0.mod_height() == 1 - assert module._dl1.mod_height() == 1 - - # height 0 - assert module._dl0._l0.mod_height() == 0 - assert module._dl0._l1.mod_height() == 0 - assert module._dl1._l0.mod_height() == 0 - assert module._dl1._l1.mod_height() == 0 - - @given( batch_shape=helpers.get_shape( min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 @@ -417,231 +245,6 @@ def model_assert(mod, on_device): model_assert(model, on_device) -# track submod call order -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_module_track_submod_call_order( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - x = ivy.astype( - ivy.linspace(ivy.zeros(batch_shape), ivy.ones(batch_shape), input_channels), - "float32", - ) - module = WithNestedModules(input_channels, output_channels, device=on_device) - - root_key_0 = ivy.Container.cont_flatten_key_chain(module.__repr__(), "_") + "_0" - - dl0_key_0 = ( - ivy.Container.cont_flatten_key_chain(module._dl0.__repr__(), "_") + "_0" - ) - dl1_key_0 = ( - ivy.Container.cont_flatten_key_chain(module._dl1.__repr__(), "_") + "_0" - ) - dl1_key_1 = ( - ivy.Container.cont_flatten_key_chain(module._dl1.__repr__(), "_") + "_1" - ) - - dl0_l0_key_0 = ( - ivy.Container.cont_flatten_key_chain(module._dl0._l0.__repr__(), "_") + "_0" - ) - dl0_l1_key_0 = ( - ivy.Container.cont_flatten_key_chain(module._dl0._l1.__repr__(), "_") + "_0" - ) - dl1_l0_key_0 = ( - ivy.Container.cont_flatten_key_chain(module._dl1._l0.__repr__(), "_") + "_0" - ) - dl1_l1_key_0 = ( - ivy.Container.cont_flatten_key_chain(module._dl1._l1.__repr__(), "_") + "_0" - ) - - # depth 1 - ret = module(x, track_submod_call_order=True, submod_depth=1) - assert ret.shape == tuple(list(batch_shape) + [64]) - - sm_co = module.submod_call_order - - assert root_key_0 in sm_co - - assert dl0_key_0 in sm_co[root_key_0] - assert dl1_key_0 in sm_co[root_key_0] - assert dl1_key_1 in sm_co[root_key_0] - - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl0_key_0], - module._dl0.v.cont_flatten_key_chains().to_numpy(), - ]) - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl1_key_0], - module._dl1.v.cont_flatten_key_chains().to_numpy(), - ]) - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl1_key_1], - module._dl1.v.cont_flatten_key_chains().to_numpy(), - ]) - - # depth 2 (full) - ret = module(x, track_submod_call_order=True) - assert ret.shape == tuple(list(batch_shape) + [64]) - - sm_co = module.submod_call_order - - assert root_key_0 in sm_co - - assert dl0_key_0 in sm_co[root_key_0] - assert dl1_key_0 in sm_co[root_key_0] - assert dl1_key_1 in sm_co[root_key_0] - - assert dl0_l0_key_0 in sm_co[root_key_0][dl0_key_0] - assert dl0_l1_key_0 in sm_co[root_key_0][dl0_key_0] - assert dl1_l0_key_0 in sm_co[root_key_0][dl1_key_0] - assert dl1_l1_key_0 in sm_co[root_key_0][dl1_key_0] - assert dl1_l0_key_0 in sm_co[root_key_0][dl1_key_1] - assert dl1_l1_key_0 in sm_co[root_key_0][dl1_key_1] - - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl0_key_0][dl0_l0_key_0], - module._dl0._l0.v.cont_flatten_key_chains().to_numpy(), - ]) - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl0_key_0][dl0_l1_key_0], - module._dl0._l1.v.cont_flatten_key_chains().to_numpy(), - ]) - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl1_key_0][dl1_l0_key_0], - module._dl1._l0.v.cont_flatten_key_chains().to_numpy(), - ]) - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl1_key_0][dl1_l1_key_0], - module._dl1._l1.v.cont_flatten_key_chains().to_numpy(), - ]) - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl1_key_1][dl1_l0_key_0], - module._dl1._l0.v.cont_flatten_key_chains().to_numpy(), - ]) - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl1_key_1][dl1_l1_key_0], - module._dl1._l1.v.cont_flatten_key_chains().to_numpy(), - ]) - - # partial submodules - ret = module( - x, - track_submod_call_order=True, - submods_to_track=[module._dl1, module._dl0._l0], - ) - assert ret.shape == tuple(list(batch_shape) + [64]) - - sm_co = module.submod_call_order - - assert root_key_0 in sm_co - - assert dl0_key_0 in sm_co[root_key_0] - assert dl1_key_0 in sm_co[root_key_0] - assert dl1_key_1 in sm_co[root_key_0] - - assert dl0_l0_key_0 in sm_co[root_key_0][dl0_key_0] - assert dl0_l1_key_0 not in sm_co[root_key_0][dl0_key_0] - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl1_key_0], - module._dl1.v.cont_flatten_key_chains().to_numpy(), - ]) - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl1_key_1], - module._dl1.v.cont_flatten_key_chains().to_numpy(), - ]) - - assert ivy.Container.cont_identical([ - sm_co[root_key_0][dl0_key_0][dl0_l0_key_0], - module._dl0._l0.v.cont_flatten_key_chains().to_numpy(), - ]) - - -# track submod returns -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_module_track_submod_rets( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - x = ivy.astype( - ivy.linspace(ivy.zeros(batch_shape), ivy.ones(batch_shape), input_channels), - "float32", - ) - module = WithNestedModules(input_channels, output_channels, device=on_device) - - # depth 1 - ret = module(x, track_submod_rets=True, submod_depth=1) - assert ret.shape == tuple(list(batch_shape) + [64]) - sm_rets = module.submod_rets - for submod in [module._dl0, module._dl1]: - for ret in sm_rets[submod.get_mod_key()]: - assert isinstance(ret, np.ndarray) - assert ret.shape == tuple(list(batch_shape) + [64]) - for submod in [ - module._dl0._l0, - module._dl0._l1, - module._dl1._l0, - module._dl1._l1, - ]: - assert ( - ivy.Container.cont_flatten_key_chain(submod.__repr__(), "_") - not in sm_rets - ) - - # depth 2 (full) - ret = module(x, track_submod_rets=True) - assert ret.shape == tuple(list(batch_shape) + [64]) - sm_rets = module.submod_rets - for submod in [ - module._dl0, - module._dl1, - module._dl0._l0, - module._dl0._l1, - module._dl1._l0, - module._dl1._l1, - ]: - for ret in sm_rets[submod.get_mod_key()]: - assert isinstance(ret, np.ndarray) - assert ret.shape == tuple(list(batch_shape) + [64]) - - # partial submodules - ret = module( - x, track_submod_rets=True, submods_to_track=[module._dl1, module._dl0._l0] - ) - assert ret.shape == tuple(list(batch_shape) + [64]) - sm_rets = module.submod_rets - for submod in [module._dl1, module._dl0._l0]: - for ret in sm_rets[submod.get_mod_key()]: - assert isinstance(ret, np.ndarray) - assert ret.shape == tuple(list(batch_shape) + [64]) - for submod in [module._dl0, module._dl0._l1, module._dl1._l0, module._dl1._l1]: - assert ( - ivy.Container.cont_flatten_key_chain(submod.__repr__(), "_") - not in sm_rets - ) - - # module training @given( batch_shape=helpers.get_shape( @@ -960,125 +563,6 @@ def test_module_w_partial_v( module(x) -# sub modules -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_sub_modules( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - module = WithNestedModules(input_channels, output_channels, device=on_device) - - # depth 0 - sub_mods = module.sub_mods(depth=0) - assert module.v is sub_mods - - # depth 1 - sub_mods = module.sub_mods(depth=1) - for v in [module._dl0.v, module._dl1.v]: - assert v in sub_mods - - # depth 2 (full) - sub_mods = module.sub_mods() - for v in [ - module._dl0._l0.v, - module._dl0._l1.v, - module._dl1._l0.v, - module._dl1._l1.v, - ]: - assert v in sub_mods - - -# top module -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_top_module( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - module = WithNestedModules(input_channels, output_channels, device=on_device) - - # full depth - assert module._dl0.top_mod() is module - assert module._dl1.top_mod() is module - - assert module._dl0._l0.top_mod() is module - assert module._dl0._l1.top_mod() is module - assert module._dl1._l0.top_mod() is module - assert module._dl1._l1.top_mod() is module - - # depth 1 - assert module._dl0._l0.top_mod(1) is module._dl0 - assert module._dl0._l1.top_mod(1) is module._dl0 - assert module._dl1._l0.top_mod(1) is module._dl1 - assert module._dl1._l1.top_mod(1) is module._dl1 - - -# top variables -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_top_variables( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - module = WithNestedModules(input_channels, output_channels, device=on_device) - for key_chain in [ - "dl0", - "dl0/l0", - "dl0/l1", - "dl0/l0/b", - "dl0/l0/w", - "dl0/l1/b", - "dl0/l1/w", - "dl1", - "dl1/l0", - "dl1/l1", - "dl1/l0/b", - "dl1/l0/w", - "dl1/l1/b", - "dl1/l1/w", - ]: - # depth 1 - assert key_chain in module._dl0.top_v() - assert key_chain in module._dl1.top_v() - - # depth 2 - assert key_chain in module._dl0._l0.top_v() - assert key_chain in module._dl0._l1.top_v() - assert key_chain in module._dl1._l0.top_v() - assert key_chain in module._dl1._l1.top_v() - - @given(mode=st.booleans()) def test_train_eval(mode, backend_fw): with ivy.utils.backend.ContextManager(backend_fw): @@ -1089,73 +573,6 @@ def test_train_eval(mode, backend_fw): assert not cls.training -# v with top v key chains -@given( - batch_shape=helpers.get_shape( - min_num_dims=2, max_num_dims=2, min_dim_size=1, max_dim_size=2 - ), - input_channels=st.integers(min_value=2, max_value=5), - output_channels=st.integers(min_value=2, max_value=5), -) -def test_v_with_top_v_key_chains( - batch_shape, input_channels, output_channels, on_device, backend_fw -): - # smoke test - if backend_fw == "numpy": - # NumPy does not support gradients - return - - with ivy.utils.backend.ContextManager(backend_fw): - module = WithNestedModules(input_channels, output_channels, device=on_device) - - # full depth - v = module._dl0.v_with_top_v_key_chains() - assert "dl0" in v - assert v.dl0 is module._dl0.v - - v = module._dl1.v_with_top_v_key_chains() - assert "dl1" in v - assert v.dl1 is module._dl1.v - - v = module._dl0._l0.v_with_top_v_key_chains() - assert "dl0" in v - assert "l0" in v.dl0 - assert v.dl0.l0 is module._dl0._l0.v - - v = module._dl0._l1.v_with_top_v_key_chains() - assert "dl0" in v - assert "l1" in v.dl0 - assert v.dl0.l1 is module._dl0._l1.v - - v = module._dl1._l0.v_with_top_v_key_chains() - assert "dl1" in v - assert "l0" in v.dl1 - assert v.dl1.l0 is module._dl1._l0.v - - v = module._dl1._l1.v_with_top_v_key_chains() - assert "dl1" in v - assert "l1" in v.dl1 - assert v.dl1.l1 is module._dl1._l1.v - - # depth 1 - - v = module._dl0._l0.v_with_top_v_key_chains(depth=1) - assert "l0" in v - assert v.l0 is module._dl0._l0.v - - v = module._dl0._l1.v_with_top_v_key_chains(depth=1) - assert "l1" in v - assert v.l1 is module._dl0._l1.v - - v = module._dl1._l0.v_with_top_v_key_chains(depth=1) - assert "l0" in v - assert v.l0 is module._dl1._l0.v - - v = module._dl1._l1.v_with_top_v_key_chains(depth=1) - assert "l1" in v - assert v.l1 is module._dl1._l1.v - - # with custom var structure @given( batch_shape=helpers.get_shape( diff --git a/ivy_tests/test_ivy/test_stateful/test_sequential.py b/ivy_tests/test_ivy/test_stateful/test_sequential.py index 1a9223c309987..3273373477633 100644 --- a/ivy_tests/test_ivy/test_stateful/test_sequential.py +++ b/ivy_tests/test_ivy/test_stateful/test_sequential.py @@ -7,6 +7,7 @@ # local import ivy +from ivy_tests.test_ivy import helpers from ivy_tests.test_ivy.helpers.testing_helpers import handle_method @@ -59,7 +60,14 @@ def loss_fn(_v): @handle_method( method_tree="Sequential.__call__", input_array=st.lists( - st.floats(min_value=-1, max_value=1, allow_nan=False, allow_infinity=False), + helpers.floats( + min_value=-1, + max_value=1, + allow_nan=False, + allow_inf=False, + small_abs_safety_factor=1.5, + safety_factor_scale="log", + ), min_size=1, max_size=5, ), @@ -69,49 +77,58 @@ def loss_fn(_v): def test_sequential_construction_and_value( input_array, dims, use_activation, on_device, backend_fw ): - dims = [len(input_array)] + dims - layer_count = len(dims) - layers = [ - ivy.Linear(dims[i], dims[i + 1], device=on_device) - for i in range(layer_count - 1) - ] + with ivy.utils.backend.ContextManager(backend_fw): + dims = [len(input_array)] + dims + layer_count = len(dims) + layers = [ + ivy.Linear(dims[i], dims[i + 1], device=on_device) + for i in range(layer_count - 1) + ] - if use_activation: - activations = [ivy.GELU() for _ in range(layer_count - 1)] - layers = itertools.chain.from_iterable(zip(layers, activations)) + if use_activation: + activations = [ivy.GELU() for _ in range(layer_count - 1)] + layers = itertools.chain.from_iterable(zip(layers, activations)) - module = ivy.Sequential(*layers) + module = ivy.Sequential(*layers) - input_array = ivy.array(input_array, dtype="float32", device=on_device) + input_array = ivy.array(input_array, dtype="float32", device=on_device) - if "numpy" not in backend_fw.__name__: - _train(module, input_array) + if backend_fw != "numpy": + _train(module, input_array) @handle_method( method_tree="Sequential.__call__", input_array=st.lists( - st.floats(min_value=0, max_value=1, allow_nan=False, allow_infinity=False), + helpers.floats( + min_value=0, + max_value=1, + allow_nan=False, + allow_inf=False, + small_abs_safety_factor=1.5, + safety_factor_scale="log", + ), min_size=1, max_size=5, ), dims=st.lists(st.integers(1, 10), min_size=2, max_size=2), ) def test_sequential_same_as_class(input_array, dims, backend_fw): - dims = [len(input_array)] + dims - layer_count = len(dims) - layers = [ivy.Linear(dims[i], dims[i + 1]) for i in range(layer_count - 1)] + with ivy.utils.backend.ContextManager(backend_fw): + dims = [len(input_array)] + dims + layer_count = len(dims) + layers = [ivy.Linear(dims[i], dims[i + 1]) for i in range(layer_count - 1)] - m_sequential = ivy.Sequential(*layers) - m_class = TrainableModule(dims[0], dims[1], dims[2]) + m_sequential = ivy.Sequential(*layers) + m_class = TrainableModule(dims[0], dims[1], dims[2]) - # copy weights - _copy_weights(m_class.v.linear0, m_sequential.v.submodules.v0) - _copy_weights(m_class.v.linear1, m_sequential.v.submodules.v1) + # copy weights + _copy_weights(m_class.v.linear0, m_sequential.v.submodules.v0) + _copy_weights(m_class.v.linear1, m_sequential.v.submodules.v1) - input_array = ivy.array(input_array, dtype="float32") + input_array = ivy.array(input_array, dtype="float32") - if "numpy" not in backend_fw.__name__: - sequential_loss = _train(m_sequential, input_array) - class_loss = _train(m_class, input_array) - assert sequential_loss == class_loss + if backend_fw != "numpy": + sequential_loss = _train(m_sequential, input_array) + class_loss = _train(m_class, input_array) + assert sequential_loss == class_loss From 039ac591e8d1b40aa0b5f8e05e32bec02a5154a3 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sat, 25 Nov 2023 12:34:39 +0530 Subject: [PATCH 243/978] fix: Fixed passing of arguments in `ivy.layer_norm` function call. (#27385) --- ivy/functional/frontends/paddle/nn/functional/norm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/paddle/nn/functional/norm.py b/ivy/functional/frontends/paddle/nn/functional/norm.py index 17e2aca071c79..392abafeca45b 100644 --- a/ivy/functional/frontends/paddle/nn/functional/norm.py +++ b/ivy/functional/frontends/paddle/nn/functional/norm.py @@ -7,7 +7,7 @@ @to_ivy_arrays_and_back @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def layer_norm(x, normalized_shape, weight=None, bias=None, epsilon=1e-05, name=None): - return ivy.layer_norm(x, normalized_shape, weight, bias, epsilon) + return ivy.layer_norm(x, normalized_shape, scale=weight, offset=bias, eps=epsilon) @to_ivy_arrays_and_back From 1948300fad770695c3df18aea42751056871396a Mon Sep 17 00:00:00 2001 From: Alvin Vinod <63870684+alvin-98@users.noreply.github.com> Date: Sat, 25 Nov 2023 22:46:42 +0530 Subject: [PATCH 244/978] feat: add Numpy min frontend function and its test (#27391) Co-authored-by: NripeshN --- .../mathematical_functions/extrema_finding.py | 16 ++++++ .../test_extrema_finding.py | 49 +++++++++++++++++++ 2 files changed, 65 insertions(+) diff --git a/ivy/functional/frontends/numpy/mathematical_functions/extrema_finding.py b/ivy/functional/frontends/numpy/mathematical_functions/extrema_finding.py index 1f6ea86b47cc1..42a6a0de2330e 100644 --- a/ivy/functional/frontends/numpy/mathematical_functions/extrema_finding.py +++ b/ivy/functional/frontends/numpy/mathematical_functions/extrema_finding.py @@ -191,6 +191,22 @@ def amin( return ivy.astype(res, out_dtype, out=out, copy=False) +@handle_numpy_out +@to_ivy_arrays_and_back +@from_zero_dim_arrays_to_scalar +def min( + a, + /, + *, + axis=None, + out=None, + keepdims=False, + initial=None, + where=True, +): + return amin(a, axis=axis, out=out, keepdims=keepdims, initial=initial, where=where) + + @handle_numpy_out @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_extrema_finding.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_extrema_finding.py index 2d5f59ff7b45e..a645800d5ad5c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_extrema_finding.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_extrema_finding.py @@ -252,6 +252,55 @@ def test_numpy_maximum( ) +@handle_frontend_test( + fn_tree="numpy.min", + dtype_x_axis=helpers.dtype_values_axis( + available_dtypes=helpers.get_dtypes("float"), + min_num_dims=1, + valid_axis=True, + force_int_axis=True, + large_abs_safety_factor=2, + safety_factor_scale="log", + ), + initial=st.one_of(st.floats(min_value=-1000, max_value=1000), st.none()), + keepdims=st.booleans(), + where=np_frontend_helpers.where(), +) +def test_numpy_min( + dtype_x_axis, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, + where, + initial, + keepdims, +): + if initial is None and np.all(where) is not True: + assume(initial is inf) + + input_dtypes, x, axis = dtype_x_axis + where, input_dtypes, test_flags = np_frontend_helpers.handle_where_and_array_bools( + where=where, + input_dtype=input_dtypes, + test_flags=test_flags, + ) + np_frontend_helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + a=x[0], + axis=axis, + keepdims=keepdims, + initial=initial, + where=where, + ) + + # minimum @handle_frontend_test( fn_tree="numpy.minimum", From d4b2cd40bbdd5cf81a03d0e7678832f0dca11bec Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 26 Nov 2023 17:34:23 +0530 Subject: [PATCH 245/978] fix: Fixed passing of argument `seed` to class `Generator` (#27399) --- ivy/functional/frontends/numpy/random/Generator/Generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/numpy/random/Generator/Generator.py b/ivy/functional/frontends/numpy/random/Generator/Generator.py index 7f51a4dc7c0b2..55799d4cd191b 100644 --- a/ivy/functional/frontends/numpy/random/Generator/Generator.py +++ b/ivy/functional/frontends/numpy/random/Generator/Generator.py @@ -11,4 +11,4 @@ def multinomial(self, n, pvals, size=None): def default__rng(seed=None): - return Generator(seed=seed) + return Generator(bit_generator=seed) From ae2a2e0f886c7a292a8eaf792d231ccc50282001 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 27 Nov 2023 11:24:51 +0530 Subject: [PATCH 246/978] fix: hardcoded the version of ml_dtypes in requirements.txt to be 0.2.0 to avoid conflict between tensorflow and jax about the new additions and removals of dtypes in later versions of ml_dtypes (#27401) --- requirements/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 375a11f7bbeaa..f4aefa27b826e 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -12,7 +12,7 @@ requests pyvis dill astunparse -ml-dtypes # mod_name=ml_dtypes +ml-dtypes==0.2.0 # mod_name=ml_dtypes cloudpickle gast tqdm From 9920dfd70df32f4dc826957132c908b00acf6f51 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 27 Nov 2023 11:49:07 +0530 Subject: [PATCH 247/978] fix: resolved the issue with overwriting the mod_name in case of ml_dtypes or other libraries in the installation files where mod_name is specified --- scripts/test_dependencies.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/scripts/test_dependencies.py b/scripts/test_dependencies.py index 02bb80e9c2d0c..d6b4c65d75349 100644 --- a/scripts/test_dependencies.py +++ b/scripts/test_dependencies.py @@ -26,7 +26,9 @@ def parse(str_in): expected_version, expected_op = None, None for import_op in import_ops: if import_op in str_in: - mod_name, expected_version = str_in.split(import_op) + lib_name, expected_version = str_in.split(import_op) + if not "mod_name=" in str_in: + mod_name = lib_name expected_version = expected_version.split(" ")[0].split(",")[0] expected_op = import_op return mod_name, expected_version, expected_op From 9870908d0bf9cefdf8fdf6194c28858567b04a07 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 27 Nov 2023 12:01:15 +0530 Subject: [PATCH 248/978] feat: added back the last known key rule for the unsupported dtypes decorators to avoid breaking the tests after every release as the version update automation is now on hold (#27402) --- ivy/func_wrapper.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index cbd7c6c2a0702..bc94a450bfa5f 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -1269,8 +1269,8 @@ def _dtype_from_version(dic, version): if "to" in key and k1 <= version_tuple <= tuple(map(int, kl[2].split("."))): return dic[key] - # if no version is found, we return empty tuple - return () + # if no version is found, return the last version + return dic[list(dic.keys())[-1]] def _versioned_attribute_factory(attribute_function, base): From 6f408fc5efb588530375527bc15e50ca0a8241a7 Mon Sep 17 00:00:00 2001 From: Retzam Danladi Date: Mon, 27 Nov 2023 11:18:07 +0100 Subject: [PATCH 249/978] feat: Paddle frontend implementation for ihfftn function (#27336) --- ivy/functional/frontends/paddle/fft.py | 20 +++++++++ .../test_frontends/test_paddle/test_fft.py | 44 +++++++++++++++++++ 2 files changed, 64 insertions(+) diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 75f3f089cdd58..5ea418f5153e6 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -217,6 +217,26 @@ def ihfft2(x, s=None, axes=(-2, -1), norm="backward", name=None): return ivy.astype(ihfft2_result, ivy.complex128) +@to_ivy_arrays_and_back +def ihfftn(x, s=None, axes=None, norm="backward", name=None): + # cast the input to the same float64 type so that there are no backend issues + x_ = ivy.astype(x, ivy.float64) + + ihfftn_result = 0 + # Compute the complex conjugate of the 2-dimensional discrete Fourier Transform + if norm == "backward": + ihfftn_result = ivy.conj(ivy.rfftn(x_, s=s, axes=axes, norm="forward")) + if norm == "forward": + ihfftn_result = ivy.conj(ivy.rfftn(x_, s=s, axes=axes, norm="backward")) + if norm == "ortho": + ihfftn_result = ivy.conj(ivy.rfftn(x_, s=s, axes=axes, norm="ortho")) + + if x.dtype in [ivy.float32, ivy.int32, ivy.int64]: + return ivy.astype(ihfftn_result, ivy.complex64) + if x.dtype == ivy.float64: + return ivy.astype(ihfftn_result, ivy.complex128) + + @with_supported_dtypes( {"2.5.2 and below": ("complex64", "complex128")}, "paddle", diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py index 5f9ef493350e7..125e5d0857eb2 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_fft.py @@ -379,6 +379,50 @@ def test_paddle_ihfft2( ) +@handle_frontend_test( + fn_tree="paddle.fft.ihfftn", + dtype_x_axis=helpers.dtype_values_axis( + available_dtypes=["float64", "float32", "int64", "int32"], + min_value=-10, + max_value=10, + min_num_dims=2, + max_num_dims=2, + shape=st.tuples( + st.integers(min_value=2, max_value=10), + st.integers(min_value=2, max_value=10), + ), + ), + s=st.one_of( + st.lists(st.integers(min_value=2, max_value=10), min_size=2, max_size=2), + ), + axes=st.just([-2, -1]), + norm=st.sampled_from(["backward", "ortho", "forward"]), +) +def test_paddle_ihfftn( + dtype_x_axis, + s, + axes, + norm, + frontend, + backend_fw, + test_flags, + fn_tree, +): + input_dtypes, x, axis_ = dtype_x_axis + + helpers.test_frontend_function( + input_dtypes=input_dtypes, + frontend=frontend, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + x=x[0], + s=s, + axes=axes, + norm=norm, + ) + + @handle_frontend_test( fn_tree="paddle.fft.irfft", dtype_x_axis=helpers.dtype_values_axis( From 1699f3d1f1c32f21dbb2ba12c297a48b7477f16a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 27 Nov 2023 18:50:41 +0530 Subject: [PATCH 250/978] fix: Fixed passing of wrong argument in `ivy.matrix_transpose()` function call (#27405) --- ivy/functional/ivy/linear_algebra.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index 54f8f94378641..bd3c643f7e763 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -3182,7 +3182,7 @@ def tensorsolve( allaxes.remove(k) allaxes.insert(ndim1, k) - x1 = ivy.matrix_transpose(x1, allaxes) + x1 = ivy.matrix_transpose(x1) old_shape = x1.shape[-(ndim1 - ndim2) :] From 9e4919abafce5235883cb40bbffd5024e8965a74 Mon Sep 17 00:00:00 2001 From: Alvin Vinod <63870684+alvin-98@users.noreply.github.com> Date: Mon, 27 Nov 2023 22:55:46 +0530 Subject: [PATCH 251/978] feat: Implementation of Numpy max (#27397) Co-authored-by: NripeshN --- .../mathematical_functions/extrema_finding.py | 16 +++++++ .../test_extrema_finding.py | 48 +++++++++++++++++++ 2 files changed, 64 insertions(+) diff --git a/ivy/functional/frontends/numpy/mathematical_functions/extrema_finding.py b/ivy/functional/frontends/numpy/mathematical_functions/extrema_finding.py index 42a6a0de2330e..e4103ea582196 100644 --- a/ivy/functional/frontends/numpy/mathematical_functions/extrema_finding.py +++ b/ivy/functional/frontends/numpy/mathematical_functions/extrema_finding.py @@ -191,6 +191,22 @@ def amin( return ivy.astype(res, out_dtype, out=out, copy=False) +@handle_numpy_out +@to_ivy_arrays_and_back +@from_zero_dim_arrays_to_scalar +def max( + a, + /, + *, + axis=None, + out=None, + keepdims=False, + initial=None, + where=True, +): + return amax(a, axis=axis, out=out, keepdims=keepdims, initial=initial, where=where) + + @handle_numpy_out @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_extrema_finding.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_extrema_finding.py index a645800d5ad5c..3ae405d89f393 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_extrema_finding.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_extrema_finding.py @@ -202,6 +202,54 @@ def test_numpy_fmin( ) +@handle_frontend_test( + fn_tree="numpy.max", + dtype_x_axis=helpers.dtype_values_axis( + available_dtypes=helpers.get_dtypes("float"), + min_num_dims=1, + valid_axis=True, + force_int_axis=True, + large_abs_safety_factor=2, + safety_factor_scale="log", + ), + initial=st.one_of(st.floats(min_value=-1000, max_value=1000), st.none()), + keepdims=st.booleans(), + where=np_frontend_helpers.where(), +) +def test_numpy_max( + dtype_x_axis, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, + where, + initial, + keepdims, +): + if initial is None and np.all(where) is not True: + assume(initial is +inf) + input_dtypes, x, axis = dtype_x_axis + where, input_dtypes, test_flags = np_frontend_helpers.handle_where_and_array_bools( + where=where, + input_dtype=input_dtypes, + test_flags=test_flags, + ) + np_frontend_helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + a=x[0], + axis=axis, + keepdims=keepdims, + initial=initial, + where=where, + ) + + # maximum @handle_frontend_test( fn_tree="numpy.maximum", From e33c248e70ede72788abbe7be9032bfcd3df529a Mon Sep 17 00:00:00 2001 From: Vaatsalya <96314403+vaatsalya123@users.noreply.github.com> Date: Mon, 27 Nov 2023 22:42:26 +0400 Subject: [PATCH 252/978] Add a AST based kernel drop in place function. Todo : Add testing for it. --- ivy/__init__.py | 4 ++ ivy/compiler/replace_with.py | 78 ++++++++++++++++++++++++++++++++++++ 2 files changed, 82 insertions(+) create mode 100644 ivy/compiler/replace_with.py diff --git a/ivy/__init__.py b/ivy/__init__.py index 7f24a893c3d60..61281bad72d9a 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -796,6 +796,10 @@ class Node(str): from .compiler.compiler import transpile, trace_graph, unify except: # noqa: E722 pass # Added for the finally statement +try: + from .compiler.replace_with import replace_with, transform_function +except: + pass finally: # Skip framework imports done by Ivy compiler for now for backend_framework in _not_imported_backends.copy(): diff --git a/ivy/compiler/replace_with.py b/ivy/compiler/replace_with.py new file mode 100644 index 0000000000000..3bbab72988447 --- /dev/null +++ b/ivy/compiler/replace_with.py @@ -0,0 +1,78 @@ +import ast +import astunparse +import inspect + +replace_map = {} + + +def replace_with(new_func): + """ + Decorator to mark a function/method/attribute to be replaced by another. + + Args: + - new_func: The function that will replace the original. + """ + + def decorator(original_func): + if not callable(original_func) or not callable(new_func): + raise ValueError( + f"Both '{original_func.__name__}' and '{new_func.__name__}' should be" + " callable." + ) + + if inspect.getfullargspec(original_func) != inspect.getfullargspec(new_func): + raise ValueError( + f"Replacement function '{new_func.__name__}' arguments don't match" + f" '{original_func.__name__}' arguments." + ) + + new_func_name = f"{original_func.__name__}_replacement" + + if new_func_name in globals(): + raise NameError( + f"Name '{new_func_name}' already exists in global namespace." + ) + + globals()[new_func_name] = new_func + replace_map[original_func.__name__] = new_func_name + return original_func + + return decorator + + +class ReplaceFunction(ast.NodeTransformer): + """AST Node Transformer to replace function calls, methods, and attributes.""" + + def visit_Attribute(self, node): + if ( + isinstance(node.value, ast.Name) + and f"{node.value.id}.{node.attr}" in replace_map + ): + return ast.copy_location( + ast.Name(replace_map[f"{node.value.id}.{node.attr}"], node.ctx), node + ) + return node + + def visit_Call(self, node): + if ( + isinstance(node.func, ast.Attribute) + and f"{node.func.value.id}.{node.func.attr}" in replace_map + ): + node.func = ast.Name( + replace_map[f"{node.func.value.id}.{node.func.attr}"], node.func.ctx + ) + elif isinstance(node.func, ast.Name) and node.func.id in replace_map: + node.func.id = replace_map[node.func.id] + return node + + +def transform_function(func): + """Transforms the function by replacing its calls based on the replace_map.""" + source = inspect.getsource(func) + tree = ast.parse(source) + transformed_tree = ReplaceFunction().visit(tree) + transformed_code = astunparse.unparse(transformed_tree) + + namespace = {} + exec(transformed_code, globals(), namespace) + return namespace[func.__name__] From f2786a45b781e1e0544f6d20d0b0e409d96d3f3e Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 27 Nov 2023 21:37:20 +0000 Subject: [PATCH 253/978] feat: add base class for criteorion that measure the quality of a split in decision trees --- .../frontends/sklearn/tree/_criterion.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 ivy/functional/frontends/sklearn/tree/_criterion.py diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py new file mode 100644 index 0000000000000..e4aa990e07004 --- /dev/null +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -0,0 +1,15 @@ +from abc import ABC, abstractmethod + + +class Criterion(ABC): + @abstractmethod + def reset(self): + raise NotImplementedError + + @abstractmethod + def reverse_reset(self): + raise NotImplementedError + + @abstractmethod + def update(self, new_pos): + raise NotImplementedError From f6985dd7966795b2ab4343fdba4f5ed99ae7fe41 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 27 Nov 2023 21:54:28 +0000 Subject: [PATCH 254/978] feat: add basic layout for ClassificationCriterion with methods reset, reverse_reset and update. To-be-tested within the Gini classification criterion when implemented --- .../frontends/sklearn/tree/_criterion.py | 134 ++++++++++++++++++ 1 file changed, 134 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index e4aa990e07004..3dbd3eae1d7d9 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -1,4 +1,5 @@ from abc import ABC, abstractmethod +import ivy class Criterion(ABC): @@ -13,3 +14,136 @@ def reverse_reset(self): @abstractmethod def update(self, new_pos): raise NotImplementedError + + +class ClassificationCriterion(Criterion): + + def __init__(self, n_outputs: int, n_classes: ivy.Array): + self.start = 0 + self.pos = 0 + self.end = 0 + self.missing_go_to_left = 0 + self.n_outputs = n_outputs + self.n_samples = 0 + self.n_node_samples = 0 + self.weighted_n_node_samples = 0.0 + self.weighted_n_left = 0.0 + self.weighted_n_right = 0.0 + self.weighted_n_missing = 0.0 + self.n_classes = ivy.empty(n_outputs, dtype=ivy.int16) + max_n_classes = 0 + + for k in range(n_outputs): + self.n_classes[k] = n_classes[k] + + if n_classes[k] > max_n_classes: + max_n_classes = n_classes[k] + + self.max_n_classes = max_n_classes + + self.sum_total = ivy.zeros((n_outputs, max_n_classes), dtype=ivy.float64) + self.sum_left = ivy.zeros((n_outputs, max_n_classes), dtype=ivy.float64) + self.sum_right = ivy.zeros((n_outputs, max_n_classes), dtype=ivy.float64) + + def init( + self, + y, + sample_weight, + weighted_n_samples, + sample_indices, + start, + end, + ): + self.y = y + self.sample_weight = sample_weight + self.sample_indices = sample_indices + self.start = start + self.end = end + self.n_node_samples = end - start + self.weighted_n_samples = weighted_n_samples + self.weighted_n_node_samples = 0.0 + w = 1.0 + + for k in range(self.n_outputs): + n_cls = ivy.to_scalar(self.n_classes[k]) + self.sum_total[k, :n_cls] = 0 + + for p in range(start, end): + i = sample_indices[p] + if sample_weight is not None: + w = sample_weight[i] + for k in range(self.n_outputs): + c = int(self.y[i, k]) + self.sum_total[k, c] += w + + self.weighted_n_node_samples += w + + self.reset() + return 0 + + def reset(self): + self.pos = self.start + self.weighted_n_left, self.weighted_n_right, self.sum_left, self.sum_right = _move_sums_classification( + self, + self.sum_left, + self.sum_right, + self.weighted_n_left, + self.weighted_n_right + ) + return 0 + + def reverse_reset(self): + self.pos = self.end + self.weighted_n_right, self.weighted_n_left, self.sum_right, self.sum_left = _move_sums_classification( + self, + self.sum_right, + self.sum_left, + self.weighted_n_right, + self.weighted_n_left, + ) + return 0 + + def update(self, new_pos): + pos = self.pos + end_non_missing = self.end - self.n_missing + sample_indices = self.sample_indices + sample_weight = self.sample_weight + w = 1.0 + + if (new_pos - pos) <= (end_non_missing - new_pos): + for p in range(pos, new_pos): + i = sample_indices[p] + if sample_weight is not None: + w = sample_weight[i] + for k in range(self.n_outputs): + c = int(self.y[i, k]) + self.sum_left[k, c] += w + self.weighted_n_left += w + + else: + self.reverse_reset() + for p in range(end_non_missing - 1, new_pos - 1, -1): + i = sample_indices[p] + if sample_weight is not None: + w = sample_weight[i] + for k in range(self.n_outputs): + c = int(self.y[i, k]) + self.sum_left[k, c] -= w + self.weighted_n_left -= w + self.weighted_n_right = self.weighted_n_node_samples - self.weighted_n_left + for k in range(self.n_outputs): + for c in range(ivy.to_scalar(self.n_classes[k])): + self.sum_right[k, c] = self.sum_total[k, c] - self.sum_left[k, c] + self.pos = new_pos + return 0 + + +def _move_sums_classification(criterion, sum_1, sum_2, weighted_n_1, weighted_n_2): + for k in range(criterion.n_outputs): + for c in range(criterion.n_classes[k]): + sum_1[k][c] = 0.0 + sum_2[k][c] = criterion.sum_total[k][c] + + weighted_n_1[0] = 0.0 + weighted_n_2[0] = criterion.weighted_n_node_samples + return weighted_n_1, weighted_n_2, sum_1, sum_2 From 6297c303ca813cc31bcd7d36ab54f524b902b8e6 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 27 Nov 2023 21:57:02 +0000 Subject: [PATCH 255/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../frontends/sklearn/tree/_criterion.py | 33 +++++++++++-------- 1 file changed, 20 insertions(+), 13 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index 3dbd3eae1d7d9..b7731e1a51e9d 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -17,7 +17,6 @@ def update(self, new_pos): class ClassificationCriterion(Criterion): - def __init__(self, n_outputs: int, n_classes: ivy.Array): self.start = 0 self.pos = 0 @@ -83,23 +82,27 @@ def init( def reset(self): self.pos = self.start - self.weighted_n_left, self.weighted_n_right, self.sum_left, self.sum_right = _move_sums_classification( - self, - self.sum_left, - self.sum_right, - self.weighted_n_left, - self.weighted_n_right + self.weighted_n_left, self.weighted_n_right, self.sum_left, self.sum_right = ( + _move_sums_classification( + self, + self.sum_left, + self.sum_right, + self.weighted_n_left, + self.weighted_n_right, + ) ) return 0 def reverse_reset(self): self.pos = self.end - self.weighted_n_right, self.weighted_n_left, self.sum_right, self.sum_left = _move_sums_classification( - self, - self.sum_right, - self.sum_left, - self.weighted_n_right, - self.weighted_n_left, + self.weighted_n_right, self.weighted_n_left, self.sum_right, self.sum_left = ( + _move_sums_classification( + self, + self.sum_right, + self.sum_left, + self.weighted_n_right, + self.weighted_n_left, + ) ) return 0 @@ -138,6 +141,10 @@ def update(self, new_pos): return 0 +# --- Helpers --- # +# --------------- # + + def _move_sums_classification(criterion, sum_1, sum_2, weighted_n_1, weighted_n_2): for k in range(criterion.n_outputs): for c in range(criterion.n_classes[k]): From 660d9bb70a8a87636711274eeac45cc5ad7f017d Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 28 Nov 2023 20:15:29 +0530 Subject: [PATCH 256/978] docs: Updated helpful_resources page in docs (#27408) --- docs/overview/contributing/helpful_resources.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/overview/contributing/helpful_resources.rst b/docs/overview/contributing/helpful_resources.rst index c70e30f30795d..bacdfde8f99cb 100644 --- a/docs/overview/contributing/helpful_resources.rst +++ b/docs/overview/contributing/helpful_resources.rst @@ -20,11 +20,11 @@ Useful when working on almost any section in the Deep Dive. **Co-Pilot** GitHub Co-Pilot can be used to write any bit of code in Ivy. -They are often very useful when developing code and also helps gets things done faster. +They are often very useful when developing code and also help get things done faster. **GitHub - Reference** -Git docs is the first place you must head to when you are stuck which any issue related to git. +`Git docs `_ is the first place you must head to when you are stuck with any issue related to git. **IDE extension for spell checking** @@ -36,4 +36,4 @@ Though this may sound odd, a spell-checking extension is very useful to people c **Github Actions** -GitHub Actions can be the best place to understand Continuous Integration and how testing is done to keep our repo error free. +`GitHub Actions `_ can be the best place to understand Continuous Integration and how testing is done to keep our repo error free. From feb676a03b98b7fa65dbd26136849a9be765d4d9 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Tue, 28 Nov 2023 06:47:15 -0800 Subject: [PATCH 257/978] refactor(stateful): Refactor `torch.nn.Module` and `ivy.Module` classes (#27403) --- ivy/func_wrapper.py | 5 +- ivy/functional/frontends/torch/__init__.py | 1 - .../frontends/torch/nn/modules/module.py | 918 +++--------------- .../frontends/torch/utils/__init__.py | 1 - ivy/functional/frontends/torch/utils/hooks.py | 231 ----- ivy/stateful/converters.py | 2 + ivy/stateful/helpers.py | 45 +- ivy/stateful/module.py | 16 +- 8 files changed, 166 insertions(+), 1053 deletions(-) delete mode 100644 ivy/functional/frontends/torch/utils/__init__.py delete mode 100644 ivy/functional/frontends/torch/utils/hooks.py diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index bc94a450bfa5f..5bf89176fa58c 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -224,7 +224,10 @@ def try_array_function_override(func, overloaded_args, types, args, kwargs): def _get_first_array(*args, **kwargs): # ToDo: make this more efficient, with function ivy.nested_nth_index_where - array_fn = ivy.is_array if "array_fn" not in kwargs else kwargs["array_fn"] + array_fn = lambda x: ( + ivy.is_array(x) if not hasattr(x, "_ivy_array") else ivy.is_array(x.ivy_array) + ) + array_fn = array_fn if "array_fn" not in kwargs else kwargs["array_fn"] arr = None if args: arr_idxs = ivy.nested_argwhere(args, array_fn, stop_after_n_found=1) diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index 963e9894d24af..e871198f0a823 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -258,7 +258,6 @@ def promote_types_of_torch_inputs( return x1, x2 -from . import utils from . import nn from .nn.functional import softmax, relu, lstm from . import tensor diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index d8f0c7d9e7714..bba71b98e2a6e 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -1,131 +1,83 @@ -from collections import OrderedDict -import functools -from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Union -import warnings -import weakref +# global import ivy -from ivy.functional.frontends.torch.nn.parameter import Parameter +from collections import OrderedDict +from typing import Any, Dict, Iterator, List, Optional, Set, Tuple +# local +from ivy.functional.frontends.torch.nn.parameter import Parameter from ivy.functional.frontends.torch.tensor import Tensor -from ivy.functional.frontends.torch.utils import hooks - -_grad_t = Union[Tuple[Tensor, ...], Tensor] - - -class _WrappedHook: - def __init__(self, hook: Callable, module: Optional["Module"] = None): - self.hook: Callable = hook - functools.update_wrapper(self, hook) - - self.with_module: bool = False - - if module is not None: - self.module: weakref.ReferenceType[Module] = weakref.ref(module) - self.with_module = True - - def __call__(self, *args: Any, **kwargs: Any) -> Any: - if self.with_module: - module = self.module() - if module is None: - raise RuntimeError("You are trying to call the hook of a dead Module!") - return self.hook(module, *args, **kwargs) - return self.hook(*args, **kwargs) - - def __getstate__(self) -> Dict: - result = {"hook": self.hook, "with_module": self.with_module} - if self.with_module: - result["module"] = self.module() - - return result - - def __setstate__(self, state: Dict): - self.hook = state["hook"] - self.with_module = state["with_module"] - - if self.with_module: - if state["module"] is None: - raise RuntimeError( - "You are trying to revive the hook of a dead Module!" - ) - self.module = weakref.ref(state["module"]) class Module(ivy.Module): - dump_patches: bool = False _version: int = 1 training: bool _parameters: Dict[str, Optional[Parameter]] - _buffers: Dict[str, Optional[Tensor]] - _non_persistent_buffers_set: Set[str] - _backward_pre_hooks: Dict[int, Callable] - _backward_hooks: Dict[int, Callable] - _is_full_backward_hook: Optional[bool] - _forward_hooks: Dict[int, Callable] - _forward_hooks_with_kwargs: Dict[int, bool] - _forward_hooks_always_called: Dict[int, bool] - _forward_pre_hooks: Dict[int, Callable] - _forward_pre_hooks_with_kwargs: Dict[int, bool] - _state_dict_hooks: Dict[int, Callable] - _load_state_dict_pre_hooks: Dict[int, Callable] - _state_dict_pre_hooks: Dict[int, Callable] - _load_state_dict_post_hooks: Dict[int, Callable] _modules: Dict[str, Optional["Module"]] - call_super_init: bool = False - _compiled_call_impl: Optional[Callable] = None - - def __init__( - self, *args, device=None, devices=None, inplace_update=False, **kwargs - ) -> None: - self.__setattr__("_args", args) - self.__setattr__("_kwargs", kwargs) - self.__setattr__( - "_update_v", - self._inplace_update_v if inplace_update else self._replace_update_v, + + def __init__(self, *args, device=None, devices=None, **kwargs) -> None: + super().__init__( + self, + *args, + device=device, + devices=devices, + training=True, + build_mode="explicit", + dynamic_backend=True, + **kwargs, ) - self.__setattr__("training", True) - self.__setattr__("_parameters", OrderedDict()) - self.__setattr__("_buffers", OrderedDict()) - self.__setattr__("_non_persistent_buffers_set", set()) - self.__setattr__("_backward_pre_hooks", OrderedDict()) - self.__setattr__("_backward_hooks", OrderedDict()) - self.__setattr__("_is_full_backward_hook", None) - self.__setattr__("_forward_hooks", OrderedDict()) - self.__setattr__("_forward_hooks_with_kwargs", OrderedDict()) - self.__setattr__("_forward_hooks_always_called", OrderedDict()) - self.__setattr__("_forward_pre_hooks", OrderedDict()) - self.__setattr__("_forward_pre_hooks_with_kwargs", OrderedDict()) - self.__setattr__("_state_dict_hooks", OrderedDict()) - self.__setattr__("_state_dict_pre_hooks", OrderedDict()) - self.__setattr__("_load_state_dict_pre_hooks", OrderedDict()) - self.__setattr__("_load_state_dict_post_hooks", OrderedDict()) - self.__setattr__("_modules", OrderedDict()) - ivy.Module.__init__( - self, *args, device=device, devices=devices, build_mode="explicit", **kwargs + super().__setattr__("_frontend_module", True) + super().__setattr__("_nonetype_param_dict", dict()) + super().__setattr__("_nonetype_buffers_dict", dict()) + super().__setattr__( + "_attr_mapping", {"_parameters": "v", "_modules": "module_dict"} ) def _create_variables(self, device=None, dtype=None): - return self._native_params - - def _build(self, *args, **kwargs): - self._native_params = ivy.Container( + # Create variables stored in the `__dict__` that were set + # using direct `__setattr__` e.g. self.weight = ... + v = ivy.Container( OrderedDict( ([ (k.replace(".", "/"), v) - for k, v in dict(self.named_parameters()).items() + for k, v in self.__dict__.items() + if isinstance(v, Parameter) ]) ), - dynamic_backend=False, + dynamic_backend=self._dynamic_backend, ) - - @staticmethod - def _inplace_update(p, v): - p.data = v.data - - def _inplace_update_v(self, new_v): - ivy.Container.cont_multi_map( - lambda xs, kc: self._inplace_update(xs[0], xs[1]), - [self._native_params, new_v], + # Created variables that were added using `register_paramter`, + # since those would appear in `self._v` + v = ( + ivy.Container( + OrderedDict( + ( + dict( + ( + (_k.replace(".", "/"), _v) + for (_k, _v) in self._v.items() + if _k.replace(".", "/") not in v + and not isinstance(_v, ivy.Container) + ) + ) + ), + **v, + ) + ) + if self._v + else v ) + return v + + def _build(self, *args, **kwargs): + for _, module in self.__dict__.items(): + if isinstance(module, Module) and module is not self: + if not module.built: + module.build( + *module._args, + dynamic_backend=module._dynamic_backend, + **module._kwargs, + ) + return True def _replace_update_v(self, new_v, native=None): from ivy.functional.ivy.gradients import _is_variable @@ -134,7 +86,7 @@ def _replace_update_v(self, new_v, native=None): for k, v in new_v.items(): if isinstance(v, ivy.Container): # noinspection PyProtectedMember - native._modules[k] = self._replace_update_v(v, native._modules[k]) + native.module_dict[k] = self._replace_update_v(v, native.module_dict[k]) elif isinstance(v, Parameter): # noinspection PyProtectedMember native.__setattr__(k, v) @@ -150,94 +102,29 @@ def _replace_update_v(self, new_v, native=None): ) return native + _update_v = _replace_update_v + def forward(self, *input: Any) -> None: raise NotImplementedError( f'Module [{type(self).__name__}] is missing the required "forward" function' ) def _forward(self, *a, **kw): - ret = self._wrapped_call_impl(*a, **kw) + ret = self._call_impl(*a, **kw) return ret - def register_buffer( - self, name: str, tensor: Optional[Tensor], persistent: bool = True - ) -> None: - if "_buffers" not in self.__dict__: - raise AttributeError("cannot assign buffer before Module.__init__() call") - elif not isinstance(name, str): - raise TypeError(f"buffer name should be a string. Got {type(name)}") - elif "." in name: - raise KeyError('buffer name can\'t contain "."') - elif name == "": - raise KeyError('buffer name can\'t be empty string ""') - elif hasattr(self, name) and name not in self._buffers: - raise KeyError(f"attribute '{name}' already exists") - elif tensor is not None and not isinstance(tensor, Tensor): - raise TypeError( - f"cannot assign '{type(tensor)}' object to buffer '{name}' " - "(torch Tensor or None required)" - ) - else: - for hook in _global_buffer_registration_hooks.values(): - output = hook(self, name, tensor) - if output is not None: - tensor = output - self._buffers[name] = tensor - if persistent: - self._non_persistent_buffers_set.discard(name) - else: - self._non_persistent_buffers_set.add(name) + def add_module(self, name: str, module: Optional["Module"]) -> None: + super().__setattr__(name, module) - def register_parameter(self, name: str, param: Optional[Parameter]) -> None: - if "_parameters" not in self.__dict__: - raise AttributeError( - "cannot assign parameter before Module.__init__() call" - ) + def register_buffer(self, name: str, value: Optional["Tensor"]) -> None: + if value is None: + self._nonetype_buffers_dict[name] = value + super().register_buffer(name, value) - elif not isinstance(name, str): - raise TypeError(f"parameter name should be a string. Got {type(name)}") - elif "." in name: - raise KeyError('parameter name can\'t contain "."') - elif name == "": - raise KeyError('parameter name can\'t be empty string ""') - - if param is None: - self._parameters[name] = None - elif not isinstance(param, Parameter): - raise TypeError( - f"cannot assign '{type(param)}' object to parameter '{name}' " - "(torch.nn.Parameter or None required)" - ) - elif param.grad_fn: - raise ValueError( - f"Cannot assign non-leaf Tensor to parameter '{name}'. Model " - f"parameters must be created explicitly. To express '{name}' " - "as a function of another Tensor, compute the value in " - "the forward() method." - ) - else: - for hook in _global_parameter_registration_hooks.values(): - output = hook(self, name, param) - if output is not None: - param = output - self._parameters[name] = param - - def add_module(self, name: str, module: Optional["Module"]) -> None: - if not isinstance(module, Module) and module is not None: - raise TypeError(f"{type(module)} is not a Module subclass") - elif not isinstance(name, str): - raise TypeError(f"module name should be a string. Got {type(name)}") - elif hasattr(self, name) and name not in self._modules: - raise KeyError(f"attribute '{name}' already exists") - elif "." in name: - raise KeyError(f'module name can\'t contain ".", got: {name}') - elif name == "": - raise KeyError('module name can\'t be empty string ""') - for hook in _global_module_registration_hooks.values(): - output = hook(self, name, module) - if output is not None: - module = output - self._modules[name] = module + def register_parameter(self, name: str, value: Optional["Parameter"]) -> None: + if value is None: + self._nonetype_param_dict[name] = value + super().register_parameter(name, value) def register_module(self, name: str, module: Optional["Module"]) -> None: r"""Alias for :func:`add_module`.""" @@ -265,38 +152,8 @@ def get_submodule(self, target: str) -> "Module": return mod def get_parameter(self, target: str): - module_path, _, param_name = target.rpartition(".") - - mod: Module = self.get_submodule(module_path) - - if not hasattr(mod, param_name): - raise AttributeError( - mod._get_name() + " has no attribute `" + param_name + "`" - ) - - param: Parameter = getattr(mod, param_name) - - if not isinstance(param, Parameter): - raise AttributeError("`" + param_name + "` is not an nn.Parameter") - - return param - - def get_buffer(self, target: str): - module_path, _, buffer_name = target.rpartition(".") - - mod: Module = self.get_submodule(module_path) - - if not hasattr(mod, buffer_name): - raise AttributeError( - mod._get_name() + " has no attribute `" + buffer_name + "`" - ) - - buffer: Tensor = getattr(mod, buffer_name) - - if buffer_name not in mod._buffers: - raise AttributeError("`" + buffer_name + "` is not a buffer") - - return buffer + target = target.replace(".", "/") + return self.v[target] def _named_members( self, get_members_fn, prefix="", recurse=True, remove_duplicate: bool = True @@ -311,22 +168,26 @@ def _named_members( for module_prefix, module in modules: members = get_members_fn(module) for k, v in members: - if v is None or v in memo: + if v is None or id(v) in memo or not isinstance(v, Parameter): continue if remove_duplicate: - memo.add(v) + memo.add(id(v)) name = module_prefix + ("." if module_prefix else "") + k yield name, v def parameters(self, recurse: bool = True) -> Iterator[Parameter]: - for name, param in self.named_parameters(recurse=recurse): + for _, param in self.named_parameters(recurse=recurse): yield param def named_parameters( self, prefix: str = "", recurse: bool = True, remove_duplicate: bool = True ) -> Iterator[Tuple[str, Parameter]]: + if not self.built: + self.build( + *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs + ) gen = self._named_members( - lambda module: module._parameters.items(), + lambda module: module.v.items(), prefix=prefix, recurse=recurse, remove_duplicate=remove_duplicate, @@ -334,14 +195,14 @@ def named_parameters( yield from gen def children(self) -> Iterator["Module"]: - for name, module in self.named_children(): + for _, module in self.named_children(): yield module def named_children(self) -> Iterator[Tuple[str, "Module"]]: memo = set() - for name, module in self._modules.items(): - if module is not None and module not in memo: - memo.add(module) + for name, module in self._module_dict.items(): + if module is not None and id(module) not in memo: + memo.add(id(module)) yield name, module def modules(self) -> Iterator["Module"]: @@ -356,11 +217,11 @@ def named_modules( ): if memo is None: memo = set() - if self not in memo: + if id(self) not in memo: if remove_duplicate: - memo.add(self) + memo.add(id(self)) yield prefix, self - for name, module in self._modules.items(): + for name, module in self._module_dict.items(): if module is None: continue submodule_prefix = prefix + ("." if prefix else "") + name @@ -368,17 +229,6 @@ def named_modules( memo, submodule_prefix, remove_duplicate ) - def train(self, mode: bool = True): - if not isinstance(mode, bool): - raise ValueError("training mode is expected to be boolean") - self.training = mode - for module in self.children(): - module.train(mode) - return self - - def eval(self): - return self.train(False) - def requires_grad_(self, requires_grad: bool = True): for p in self.parameters(): p.requires_grad_(requires_grad) @@ -390,446 +240,52 @@ def _get_name(self): def _extra_repr(self) -> str: return "" - def register_full_backward_pre_hook( - self, - hook: Callable[["Module", _grad_t], Union[None, _grad_t]], - prepend: bool = False, - ) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle(self._backward_pre_hooks) - self._backward_pre_hooks[handle.id] = hook - if prepend: - self._backward_pre_hooks.move_to_end(handle.id, last=False) - return handle - - def register_backward_hook( - self, hook: Callable[["Module", _grad_t, _grad_t], Union[None, _grad_t]] - ) -> hooks.RemovableHandle: - if self._is_full_backward_hook is True: - raise RuntimeError( - "Cannot use both regular backward hooks and full backward hooks on a " - "single Module. Please use only one of them." - ) - - self._is_full_backward_hook = False - - handle = hooks.RemovableHandle(self._backward_hooks) - self._backward_hooks[handle.id] = hook - return handle - - def register_full_backward_hook( - self, - hook: Callable[["Module", _grad_t, _grad_t], Union[None, _grad_t]], - prepend: bool = False, - ) -> hooks.RemovableHandle: - if self._is_full_backward_hook is False: - raise RuntimeError( - "Cannot use both regular backward hooks and full backward hooks on a " - "single Module. Please use only one of them." - ) - - self._is_full_backward_hook = True - - handle = hooks.RemovableHandle(self._backward_hooks) - self._backward_hooks[handle.id] = hook - if prepend: - self._backward_hooks.move_to_end(handle.id, last=False) - return handle - - def _get_backward_hooks(self): - full_backward_hooks: List[Callable] = [] - if _global_is_full_backward_hook is True: - full_backward_hooks += _global_backward_hooks.values() - if self._is_full_backward_hook is True: - full_backward_hooks += self._backward_hooks.values() - - non_full_backward_hooks: List[Callable] = [] - if _global_is_full_backward_hook is False: - non_full_backward_hooks += _global_backward_hooks.values() - if self._is_full_backward_hook is False: - non_full_backward_hooks += self._backward_hooks.values() - - return full_backward_hooks, non_full_backward_hooks - - def _get_backward_pre_hooks(self): - backward_pre_hooks: List[Callable] = [] - backward_pre_hooks += _global_backward_pre_hooks.values() - backward_pre_hooks += self._backward_pre_hooks.values() - return backward_pre_hooks - - def _maybe_warn_non_full_backward_hook(self, inputs, result, grad_fn): - if not isinstance(result, Tensor): - if not ( - isinstance(result, tuple) and all(isinstance(r, Tensor) for r in result) - ): - warnings.warn( - "Using non-full backward hooks on a Module that does not return a" - " single Tensor or a tuple of Tensors is deprecated and will be" - " removed in future versions. This hook will be missing some of the" - " grad_output. Please use register_full_backward_hook to get the" - " documented behavior." - ) - return - else: - result = (result,) - - if not isinstance(inputs, Tensor): - if not ( - isinstance(inputs, tuple) and all(isinstance(i, Tensor) for i in inputs) - ): - warnings.warn( - "Using non-full backward hooks on a Module that does not take as" - " input a single Tensor or a tuple of Tensors is deprecated and" - " will be removed in future versions. This hook will be missing" - " some of the grad_input. Please use register_full_backward_hook to" - " get the documented behavior." - ) - return - else: - inputs = (inputs,) - - # At this point we are sure that inputs and result are tuple of Tensors - out_grad_fn = {r.grad_fn for r in result if r.grad_fn is not None} - if len(out_grad_fn) == 0 or ( - len(out_grad_fn) == 1 and grad_fn not in out_grad_fn - ): - warnings.warn( - "Using a non-full backward hook when outputs are nested in python data" - " structure is deprecated and will be removed in future versions. This" - " hook will be missing some grad_output." - ) - elif len(out_grad_fn) > 1: - warnings.warn( - "Using a non-full backward hook when outputs are generated by different" - " autograd Nodes is deprecated and will be removed in future versions." - " This hook will be missing some grad_output. Please use" - " register_full_backward_hook to get the documented behavior." - ) - else: - # At this point the grad_output part of the hook will most likely be correct - inputs_grad_fn = {i.grad_fn for i in inputs if i.grad_fn is not None} - - next_functions = {n[0] for n in grad_fn.next_functions} - - if inputs_grad_fn != next_functions: - warnings.warn( - "Using a non-full backward hook when the forward contains multiple" - " autograd Nodes is deprecated and will be removed in future" - " versions. This hook will be missing some grad_input. Please use" - " register_full_backward_hook to get the documented behavior." - ) - - def register_forward_pre_hook( - self, hook, *, prepend: bool = False, with_kwargs: bool = False - ) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle( - self._forward_pre_hooks, extra_dict=self._forward_pre_hooks_with_kwargs - ) - self._forward_pre_hooks[handle.id] = hook - if with_kwargs: - self._forward_pre_hooks_with_kwargs[handle.id] = True - - if prepend: - self._forward_pre_hooks.move_to_end(handle.id, last=False) - return handle - - def register_forward_hook( - self, - hook, - *, - prepend: bool = False, - with_kwargs: bool = False, - always_call: bool = False, - ) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle( - self._forward_hooks, - extra_dict=[ - self._forward_hooks_with_kwargs, - self._forward_hooks_always_called, - ], - ) - self._forward_hooks[handle.id] = hook - if with_kwargs: - self._forward_hooks_with_kwargs[handle.id] = True - if always_call: - self._forward_hooks_always_called[handle.id] = True - if prepend: - self._forward_hooks.move_to_end(handle.id, last=False) - return handle - - def _wrapped_call_impl(self, *args, **kwargs): - if self._compiled_call_impl is not None: - return self._compiled_call_impl(*args, **kwargs) - else: - return self._call_impl(*args, **kwargs) - def _call_impl(self, *args, **kwargs): - forward_call = self.forward - # If we don't have any hooks, we want to skip the rest of the logic in - # this function, and just call forward. - if not ( - self._backward_hooks - or self._backward_pre_hooks - or self._forward_hooks - or self._forward_pre_hooks - or _global_backward_pre_hooks - or _global_backward_hooks - or _global_forward_hooks - or _global_forward_pre_hooks - ): - return forward_call(*args, **kwargs) - - try: - result = None - called_always_called_hooks = set() - - full_backward_hooks, non_full_backward_hooks = [], [] - backward_pre_hooks = [] - if self._backward_pre_hooks or _global_backward_pre_hooks: - backward_pre_hooks = self._get_backward_pre_hooks() - - if self._backward_hooks or _global_backward_hooks: - full_backward_hooks, non_full_backward_hooks = ( - self._get_backward_hooks() - ) - - if _global_forward_pre_hooks or self._forward_pre_hooks: - for hook_id, hook in ( - *_global_forward_pre_hooks.items(), - *self._forward_pre_hooks.items(), - ): - if hook_id in self._forward_pre_hooks_with_kwargs: - args_kwargs_result = hook(self, args, kwargs) - if args_kwargs_result is not None: - if ( - isinstance(args_kwargs_result, tuple) - and len(args_kwargs_result) == 2 - ): - args, kwargs = args_kwargs_result - else: - raise RuntimeError( - "forward pre-hook must return None or a tuple of" - " (new_args, new_kwargs), but got" - f" {args_kwargs_result}." - ) - else: - args_result = hook(self, args) - if args_result is not None: - if not isinstance(args_result, tuple): - args_result = (args_result,) - args = args_result - - bw_hook = None - if full_backward_hooks or backward_pre_hooks: - bw_hook = hooks.BackwardHook( - self, full_backward_hooks, backward_pre_hooks - ) - args = bw_hook.setup_input_hook(args) - - result = forward_call(*args, **kwargs) - if _global_forward_hooks or self._forward_hooks: - for hook_id, hook in ( - *_global_forward_hooks.items(), - *self._forward_hooks.items(), - ): - # mark that always called hook is run - if ( - hook_id in self._forward_hooks_always_called - or hook_id in _global_forward_hooks_always_called - ): - called_always_called_hooks.add(hook_id) - - if hook_id in self._forward_hooks_with_kwargs: - hook_result = hook(self, args, kwargs, result) - else: - hook_result = hook(self, args, result) - - if hook_result is not None: - result = hook_result - - if bw_hook: - if not isinstance(result, (Tensor, tuple)): - warnings.warn( - "For backward hooks to be called," - " module output should be a Tensor or a tuple of Tensors" - f" but received {type(result)}" - ) - result = bw_hook.setup_output_hook(result) - - # Handle the non-full backward hooks - if non_full_backward_hooks: - var = result - while not isinstance(var, Tensor): - if isinstance(var, dict): - var = next(v for v in var.values() if isinstance(v, Tensor)) - else: - var = var[0] - grad_fn = var.grad_fn - if grad_fn is not None: - for hook in non_full_backward_hooks: - grad_fn.register_hook(_WrappedHook(hook, self)) - self._maybe_warn_non_full_backward_hook(args, result, grad_fn) - - return result - - except Exception: - # run always called hooks if they have not already been run - # For now only forward hooks have the always_call option but perhaps - # this functionality should be added to full backward hooks as well. - for hook_id, hook in _global_forward_hooks.items(): - if ( - hook_id in _global_forward_hooks_always_called - and hook_id not in called_always_called_hooks - ): - try: - hook_result = hook(self, args, result) - if hook_result is not None: - result = hook_result - except Exception as e: - warnings.warn( - "global module forward hook with ``always_call=True``" - " raised an exception that was silenced as another error" - f" was raised in forward: {str(e)}" - ) - continue - - for hook_id, hook in self._forward_hooks.items(): - if ( - hook_id in self._forward_hooks_always_called - and hook_id not in called_always_called_hooks - ): - try: - if hook_id in self._forward_hooks_with_kwargs: - hook_result = hook(self, args, kwargs, result) - else: - hook_result = hook(self, args, result) - if hook_result is not None: - result = hook_result - except Exception as e: - warnings.warn( - "module forward hook with ``always_call=True`` raised an" - " exception that was silenced as another error was raised" - f" in forward: {str(e)}" - ) - continue - # raise exception raised in try block - raise + return self.forward(*args, **kwargs) def __getattribute__(self, name: str) -> Any: - if name in ("__dict__", "v", "buffers"): - return super(Module, self).__getattribute__(name) - if "_parameters" in self.__dict__: - _parameters = self.__dict__["_parameters"] - if name in _parameters: - return _parameters[name] - if "_buffers" in self.__dict__: - _buffers = self.__dict__["_buffers"] - if name in _buffers: - return _buffers[name] - if "_modules" in self.__dict__: - modules = self.__dict__["_modules"] + if name == "__dict__": + return super().__getattribute__(name) + if "_module_dict" in self.__dict__: + modules = self.__dict__["_module_dict"] if name in modules: return modules[name] - return super(Module, self).__getattribute__(name) - - def __setattr__(self, name: str, value: Union[Tensor, "Module"]) -> None: - def remove_from(*dicts_or_sets): - for d in dicts_or_sets: - if name in d: - if isinstance(d, dict): - del d[name] - else: - d.discard(name) - - params = self.__dict__.get("_parameters") - if isinstance(value, Parameter): - if params is None: - raise AttributeError( - "cannot assign parameters before Module.__init__() call" - ) - remove_from( - self.__dict__, - self._buffers, - self._modules, - self._non_persistent_buffers_set, - ) - self.register_parameter(name, value) - else: - modules = self.__dict__.get("_modules") - if isinstance(value, Module): - if modules is None: - raise AttributeError( - "cannot assign module before Module.__init__() call" - ) - remove_from( - self.__dict__, - self._parameters, - self._buffers, - self._non_persistent_buffers_set, - ) - for hook in _global_module_registration_hooks.values(): - output = hook(self, name, value) - if output is not None: - value = output - modules[name] = value - elif modules is not None and name in modules: - if value is not None: - raise TypeError( - f"cannot assign '{type(value)}' as child module '{name}' " - "(torch.nn.Module or None expected)" - ) - for hook in _global_module_registration_hooks.values(): - output = hook(self, name, value) - if output is not None: - value = output - modules[name] = value - else: - buffers = self.__dict__.get("_buffers") - if buffers is not None and name in buffers: - if value is not None and not isinstance(value, Tensor): - raise TypeError( - f"cannot assign '{type(value)}' as buffer '{name}' " - "(torch.Tensor or None expected)" - ) - for hook in _global_buffer_registration_hooks.values(): - output = hook(self, name, value) - if output is not None: - value = output - buffers[name] = value - else: - super().__setattr__(name, value) - - def __delattr__(self, name): - if name in self._parameters: - del self._parameters[name] - elif name in self._buffers: - del self._buffers[name] - self._non_persistent_buffers_set.discard(name) - elif name in self._modules: - del self._modules[name] - else: - super().__delattr__(name) - - def _register_state_dict_hook(self, hook): - handle = hooks.RemovableHandle(self._state_dict_hooks) - self._state_dict_hooks[handle.id] = hook - return handle - - def register_state_dict_pre_hook(self, hook): - handle = hooks.RemovableHandle(self._state_dict_pre_hooks) - self._state_dict_pre_hooks[handle.id] = hook - return handle + if "_buffers" in self.__dict__: + buffers = self.__dict__["_buffers"] + if name in buffers: + return buffers[name] + if "_v" in self.__dict__: + v = self.__dict__["_v"] + if name in v: + return v[name] + if "_nonetype_param_dict" in self.__dict__: + nonetype_param_dict = self.__dict__["_nonetype_param_dict"] + if name in nonetype_param_dict: + return nonetype_param_dict[name] + if "_nonetype_buffers_dict" in self.__dict__: + nonetype_buffers_dict = self.__dict__["_nonetype_buffers_dict"] + if name in nonetype_buffers_dict: + return nonetype_buffers_dict[name] + # Adding this attribute mapping s.t if someone tries + # to retrieve self._modules/self._parameters, we + # can handle that here + if "_attr_mapping" in self.__dict__: + mapping = self.__dict__["_attr_mapping"] + if name in mapping: + return super().__getattribute__(mapping[name]) + return super().__getattribute__(name) def __repr__(self): # We treat the extra repr like the sub-module, one item per line extra_lines = [] - extra_repr = self.extra_repr() + extra_repr = self._extra_repr() # empty string will be split into list [''] if extra_repr: extra_lines = extra_repr.split("\n") child_lines = [] - for key, module in self._modules.items(): + for key, module in self._module_dict.items(): mod_str = repr(module) - mod_str = _addindent(mod_str, 2) + mod_str = self._addindent(mod_str, 2) child_lines.append("(" + key + "): " + mod_str) lines = extra_lines + child_lines @@ -847,8 +303,8 @@ def __repr__(self): def __dir__(self): module_attrs = dir(self.__class__) attrs = list(self.__dict__.keys()) - parameters = list(self._parameters.keys()) - modules = list(self._modules.keys()) + parameters = list(self._v.keys()) + modules = list(self._module_dict.keys()) buffers = list(self._buffers.keys()) keys = module_attrs + attrs + parameters + modules + buffers @@ -856,129 +312,3 @@ def __dir__(self): keys = [key for key in keys if not key[0].isdigit()] return sorted(keys) - - -# --- Helpers --- # -# --------------- # - - -def _addindent(s_, numSpaces): - s = s_.split("\n") - # don't do anything for single-line stuff - if len(s) == 1: - return s_ - first = s.pop(0) - s = [(numSpaces * " ") + line for line in s] - s = "\n".join(s) - s = first + "\n" + s - - return s - - -# --- Main --- # -# ------------ # - - -def register_module_backward_hook( - hook: Callable[["Module", _grad_t, _grad_t], Union[None, _grad_t]] -) -> hooks.RemovableHandle: - global _global_is_full_backward_hook - if _global_is_full_backward_hook is True: - raise RuntimeError( - "Cannot use both regular backward hooks and full backward hooks as a " - "global Module hook. Please use only one of them." - ) - - _global_is_full_backward_hook = False - - handle = hooks.RemovableHandle(_global_backward_hooks) - _global_backward_hooks[handle.id] = hook - return handle - - -def register_module_buffer_registration_hook( - hook: Callable[..., None] -) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle(_global_buffer_registration_hooks) - _global_buffer_registration_hooks[handle.id] = hook - return handle - - -def register_module_forward_hook( - hook: Callable[..., None], *, always_call: bool = False -) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle( - _global_forward_hooks, extra_dict=_global_forward_hooks_always_called - ) - _global_forward_hooks[handle.id] = hook - if always_call: - _global_forward_hooks_always_called[handle.id] = True - return handle - - -def register_module_forward_pre_hook( - hook: Callable[..., None] -) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle(_global_forward_pre_hooks) - _global_forward_pre_hooks[handle.id] = hook - return handle - - -def register_module_full_backward_hook( - hook: Callable[["Module", _grad_t, _grad_t], Union[None, _grad_t]] -) -> hooks.RemovableHandle: - global _global_is_full_backward_hook - if _global_is_full_backward_hook is False: - raise RuntimeError( - "Cannot use both regular backward hooks and full backward hooks as a " - "global Module hook. Please use only one of them." - ) - - _global_is_full_backward_hook = True - - handle = hooks.RemovableHandle(_global_backward_hooks) - _global_backward_hooks[handle.id] = hook - return handle - - -def register_module_full_backward_pre_hook( - hook: Callable[["Module", _grad_t], Union[None, _grad_t]] -) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle(_global_backward_pre_hooks) - _global_backward_pre_hooks[handle.id] = hook - return handle - - -def register_module_module_registration_hook( - hook: Callable[..., None] -) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle(_global_module_registration_hooks) - _global_module_registration_hooks[handle.id] = hook - return handle - - -def register_module_parameter_registration_hook( - hook: Callable[..., None] -) -> hooks.RemovableHandle: - handle = hooks.RemovableHandle(_global_parameter_registration_hooks) - _global_parameter_registration_hooks[handle.id] = hook - return handle - - -r"""This tracks hooks common to all modules that are executed immediately before -.registering the buffer/module/parameter""" -_global_buffer_registration_hooks: Dict[int, Callable] = OrderedDict() -_global_module_registration_hooks: Dict[int, Callable] = OrderedDict() -_global_parameter_registration_hooks: Dict[int, Callable] = OrderedDict() -r""" -This tracks hooks common to all modules that are executed before/after calling forward -and backward. - -This is global state used for debugging/profiling purposes -""" -_global_backward_pre_hooks: Dict[int, Callable] = OrderedDict() -_global_backward_hooks: Dict[int, Callable] = OrderedDict() -_global_is_full_backward_hook: Optional[bool] = None -_global_forward_pre_hooks: Dict[int, Callable] = OrderedDict() -_global_forward_hooks: Dict[int, Callable] = OrderedDict() -_global_forward_hooks_always_called: Dict[int, bool] = OrderedDict() diff --git a/ivy/functional/frontends/torch/utils/__init__.py b/ivy/functional/frontends/torch/utils/__init__.py deleted file mode 100644 index 88be3837977fe..0000000000000 --- a/ivy/functional/frontends/torch/utils/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from . import hooks diff --git a/ivy/functional/frontends/torch/utils/hooks.py b/ivy/functional/frontends/torch/utils/hooks.py deleted file mode 100644 index dccc79e3560ce..0000000000000 --- a/ivy/functional/frontends/torch/utils/hooks.py +++ /dev/null @@ -1,231 +0,0 @@ -import torch -from collections import OrderedDict -import weakref -from typing import Any, Tuple - - -class RemovableHandle: - id: int - next_id: int = 0 - - def __init__(self, hooks_dict: Any, *, extra_dict: Any = None) -> None: - self.hooks_dict_ref = weakref.ref(hooks_dict) - self.id = RemovableHandle.next_id - RemovableHandle.next_id += 1 - - self.extra_dict_ref: Tuple = () - if isinstance(extra_dict, dict): - self.extra_dict_ref = (weakref.ref(extra_dict),) - elif isinstance(extra_dict, list): - self.extra_dict_ref = tuple(weakref.ref(d) for d in extra_dict) - - def remove(self) -> None: - hooks_dict = self.hooks_dict_ref() - if hooks_dict is not None and self.id in hooks_dict: - del hooks_dict[self.id] - - for ref in self.extra_dict_ref: - extra_dict = ref() - if extra_dict is not None and self.id in extra_dict: - del extra_dict[self.id] - - def __getstate__(self): - if self.extra_dict_ref is None: - return (self.hooks_dict_ref(), self.id) - else: - return ( - self.hooks_dict_ref(), - self.id, - tuple(ref() for ref in self.extra_dict_ref), - ) - - def __setstate__(self, state) -> None: - if state[0] is None: - # create a dead reference - self.hooks_dict_ref = weakref.ref(OrderedDict()) - else: - self.hooks_dict_ref = weakref.ref(state[0]) - self.id = state[1] - RemovableHandle.next_id = max(RemovableHandle.next_id, self.id + 1) - - if len(state) < 3 or state[2] is None: - self.extra_dict_ref = () - else: - self.extra_dict_ref = tuple(weakref.ref(d) for d in state[2]) - - def __enter__(self) -> "RemovableHandle": - return self - - def __exit__(self, type: Any, value: Any, tb: Any) -> None: - self.remove() - - -class BackwardHook: - def __init__(self, module, user_hooks, user_pre_hooks): - self.user_hooks = user_hooks - self.user_pre_hooks = user_pre_hooks - self.module = module - - self.grad_outputs = None - self.n_outputs = -1 - self.output_tensors_index = None - self.n_inputs = -1 - self.input_tensors_index = None - - def _pack_with_none(self, indices, values, size): - res = [None] * size - for idx, val in zip(indices, values): - res[idx] = val - - return tuple(res) - - def _unpack_none(self, indices, values): - res = [] - for idx in indices: - res.append(values[idx]) - - return tuple(res) - - def _set_user_hook(self, grad_fn): - def hook(grad_input, _): - if self.grad_outputs is None: - # This happens because the gradient in your nn.Module flows to - # the Module's input without " passing through the Module's - # output, e.g. when you're doing double backward. - return - res = self._pack_with_none( - self.input_tensors_index, grad_input, self.n_inputs - ) - - for hook in self.user_hooks: - out = hook(self.module, res, self.grad_outputs) - - if out is None: - continue - - if len(out) != len(res): - raise RuntimeError( - "Backward hook returned an invalid number of grad_input, " - f"got {len(out)}, but expected {len(res)}" - ) - - res = out - - self.grad_outputs = None - - return self._unpack_none(self.input_tensors_index, res) - - grad_fn.register_hook(hook) - - def _apply_on_tensors(self, fn, args): - # Can be used to apply the given function to the tensors contained in the - # args. Will return updated args and the tensors indices - tensors_idx = [] - tensors = [] - - requires_grad = False - for i, arg in enumerate(args): - if isinstance(arg, torch.Tensor): - tensors_idx.append(i) - tensors.append(arg) - requires_grad |= arg.requires_grad - - if not (requires_grad and torch.is_grad_enabled()): - return args, None - - new_tensors = torch.nn.modules._functions.BackwardHookFunction.apply(*tensors) - if len(new_tensors) == 0: - raise RuntimeError( - "Cannot set Module backward hook for a Module with no input Tensors." - ) - - grad_fns = [ - t.grad_fn - for t in new_tensors - if t.grad_fn is not None - and t.grad_fn.name() == "BackwardHookFunctionBackward" - ] - if len(grad_fns) == 0: - raise RuntimeError( - "Error while setting up backward hooks. Please open " - "an issue with a code sample to reproduce this." - ) - - fn(grad_fns[0]) - - arg_list = list(args) - for idx, val in zip(tensors_idx, new_tensors): - arg_list[idx] = val - - return tuple(arg_list), tensors_idx - - def setup_input_hook(self, args): - def fn(grad_fn): - self._set_user_hook(grad_fn) - - res, input_idx = self._apply_on_tensors(fn, args) - self.n_inputs = len(args) - self.input_tensors_index = input_idx - return res - - def setup_output_hook(self, args): - def fn(grad_fn): - def hook(_, grad_output): - self.grad_outputs = self._pack_with_none( - self.output_tensors_index, grad_output, self.n_outputs - ) - - if self.user_pre_hooks: - expected_len = len(self.grad_outputs) - for user_pre_hook in self.user_pre_hooks: - hook_grad_outputs = user_pre_hook( - self.module, self.grad_outputs - ) - if hook_grad_outputs is None: - continue - - actual_len = len(hook_grad_outputs) - if actual_len != expected_len: - raise RuntimeError( - "Backward pre hook returned an invalid number of" - f" grad_output, got {actual_len}, but expected" - f" {expected_len}" - ) - self.grad_outputs = hook_grad_outputs - - # Special case if no input required gradients, - # this hook should call the user hook directly - if self.input_tensors_index is None: - grad_inputs = self._pack_with_none([], [], self.n_inputs) - for user_hook in self.user_hooks: - res = user_hook(self.module, grad_inputs, self.grad_outputs) - if res is not None and not ( - isinstance(res, tuple) and all(el is None for el in res) - ): - raise RuntimeError( - "Backward hook for Modules where no input requires" - " gradient should always return None or None for all" - " gradients." - ) - self.grad_outputs = None - - if self.grad_outputs is not None: - assert self.output_tensors_index is not None # mypy - return tuple( - self.grad_outputs[i] for i in self.output_tensors_index - ) - - grad_fn.register_hook(hook) - - is_tuple = True - if not isinstance(args, tuple): - args = (args,) - is_tuple = False - - res, output_idx = self._apply_on_tensors(fn, args) - self.n_outputs = len(args) - self.output_tensors_index = output_idx - - if not is_tuple: - res = res[0] - return res diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index 0636de01aa7b5..13b5e5cfde568 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -498,6 +498,8 @@ def _populate_params(self): def _propagate_params(self): def __update_param(ivy_module, x, kc): + if kc not in self._parameters: + return x # Update param in the underneath ivy module module = ivy_module keys = re.split("[/.]", kc) diff --git a/ivy/stateful/helpers.py b/ivy/stateful/helpers.py index 46eea4e6eda50..0cc4ad9b1b322 100644 --- a/ivy/stateful/helpers.py +++ b/ivy/stateful/helpers.py @@ -125,9 +125,13 @@ def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): ret_cont = Container() for old_kc, new_kc in keychain_mappings.items(): if orig_key_chain in old_kc: - ret_cont = ret_cont.cont_set_at_key_chain( - "/".join(new_kc.split("/")[1:]), v.cont_at_key_chain(new_kc) - ) + # Check if `v` contains `new_kc` before replacing in `ret_cont` + if v.cont_has_key_chain(new_kc): + ret_cont = ret_cont.cont_set_at_key_chain( + "/".join(new_kc.split("/")[1:]), v.cont_at_key_chain(new_kc) + ) + else: + continue return ret_cont @staticmethod @@ -259,30 +263,35 @@ def _call(self, *args, v=None, buffers=None, **kwargs): Result of the forward pass of the layer. """ if not self._built: + first_arr = _get_first_array(*args, **kwargs) self.build( *args, **kwargs, from_call=True, - dtype=_get_first_array(*args, **kwargs).dtype, + dtype=first_arr.dtype if ivy.exists(first_arr) else ivy.default_dtype(), ) + + # If `v` was provided, replace with the module's v + replace_v = False if v is not None: v_orig = self.v + self._v = v + replace_v = True + + # If `buffers` were provided, replace with the module's buffers + replace_buffers = False + if buffers is not None: buffers_orig = self.buffers - self._v = ( - Container(v, **v.cont_config) - if isinstance(v, Container) - else Container(v) - ) - self._buffers = ( - Container(buffers, **buffers.cont_config) - if isinstance(buffers, Container) - else Container(buffers) - ) + self._buffers = buffers + replace_buffers = True + + if replace_v or replace_buffers: + # Call the forward pass ret = self._forward(*args, **kwargs) - self._v = v_orig - self._buffers = buffers_orig + # Replace v, buffers if needed + self._v = v_orig if replace_v else self._v + self._buffers = buffers_orig if replace_buffers else self._buffers return ret - elif hasattr(self.__call__, "wrapped"): return self.__call__(*args, **kwargs) return self._forward(*args, **kwargs) @@ -301,7 +310,7 @@ def _compute_module_dict(self): self._module_dict = Container() for key, value in self.__dict__.items(): if isinstance(value, ivy.Module): - if "stateful" in value.__module__: + if "stateful" in value.__module__ or hasattr(value, "_frontend_module"): self._module_dict[key] = value else: self._module_dict[key] = value._module_dict diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 5f81fac5ac5c4..41d5be1525d7b 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -97,7 +97,7 @@ def __init__( self._v_from_constructor = ( v if isinstance(v, Container) or v is None else Container(v) ) - self._v = v + self._v = v if v is not None else Container() self._buffers = Container(ivy.default(buffers, {})) self._module_dict = Container() self._args = args @@ -206,7 +206,7 @@ def build( # this creates weights for this Module only created = Container( self._create_variables(device=self._device, dtype=dtype), - dynamic_backend=False, + dynamic_backend=self._dynamic_backend, ) # build variables based on locally built layers, if v not passed in constructor @@ -248,7 +248,7 @@ def build( else: self._v = created_n_found # remove duplicates - self._v, keychain_mappings = self._remove_duplicate_variables(self.v, created) + self._v, keychain_mappings = self._remove_duplicate_variables(self._v, created) # build any child 'on_call' layers if not built and from_call: # update child modules to share the same device @@ -266,13 +266,14 @@ def build( dict( **self._find_variables(obj=self), **self._create_variables(device=self._device, dtype=dtype), - ) + ), + dynamic_backend=self._dynamic_backend, ) self._v = created_n_found # remove further duplicates with self.v self._v, keychain_mappings = self._remove_duplicate_variables( - self.v, created + self._v, created ) # set built flag @@ -370,10 +371,11 @@ def train(self, mode: bool = True): module = getattr(self, module, None) if isinstance(module, ivy.Module): module.train(mode=mode) + return self def eval(self): """Disable training mode.""" - self.train(mode=False) + return self.train(mode=False) def to_device(self, device): """Move the weights and buffers to the specified device.""" @@ -516,7 +518,7 @@ def __call__( def __getattribute__(self, name): if name == "v": - if super().__getattribute__("v") is None and not self.built: + if not super().__getattribute__("_v") and not self.built: self._build_and_return_v( *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs ) From 4d9ef3bbd7e0f7c0f46371da4f2f0af0d352b778 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 29 Nov 2023 02:28:56 +0300 Subject: [PATCH 258/978] fix: Fixed typo in test names --- .../test_nn/test_functional/test_convolution_functions.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py index 5c03cd7109fa7..62bfa189bdc44 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py @@ -366,7 +366,7 @@ def test_torch_conv3d( fn_tree="torch.nn.functional.conv_transpose1d", dtype_vals=_x_and_filters(dim=1, transpose=True, max_dilation=1), ) -def test_torch_conv_tranpose1d( +def test_torch_conv_transpose1d( *, dtype_vals, on_device, @@ -406,7 +406,7 @@ def test_torch_conv_tranpose1d( fn_tree="torch.nn.functional.conv_transpose2d", dtype_vals=_x_and_filters(dim=2, transpose=True), ) -def test_torch_conv_tranpose2d( +def test_torch_conv_transpose2d( *, dtype_vals, on_device, @@ -446,7 +446,7 @@ def test_torch_conv_tranpose2d( fn_tree="torch.nn.functional.conv_transpose3d", dtype_vals=_x_and_filters(dim=3, transpose=True, max_dilation=1), ) -def test_torch_conv_tranpose3d( +def test_torch_conv_transpose3d( *, dtype_vals, on_device, From 517ab4c4510b7b53afb9aef46cb340a4642ea8c9 Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 29 Nov 2023 02:29:23 +0300 Subject: [PATCH 259/978] fix: Fixed bugs that came up when running the tensorflow backend convolution functions on gpu. --- ivy/functional/backends/tensorflow/layers.py | 56 +++++++++++++++----- 1 file changed, 43 insertions(+), 13 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 979a51ec4fa14..14f8cfa492b6b 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -44,9 +44,9 @@ def _x_dil_before_conv(x, dims, x_dilations, data_format): h = x.shape[offset + i] new_height = h + (h - 1) * (x_dilations[i] - 1) h = tf.eye(new_height, dtype=x.dtype)[:: x_dilations[i]] - x = tf.experimental.numpy.swapaxes(x, offset + i, -offset) + x = tf.experimental.numpy.swapaxes(x, offset + i, -1) x = tf.matmul(x, h) - x = tf.experimental.numpy.swapaxes(x, -offset, offset + i) + x = tf.experimental.numpy.swapaxes(x, -1, offset + i) return x @@ -103,8 +103,14 @@ def _transpose_out_pad( + 1 for i in range(dims) ] - padding = [[0, 0], *padding, [0, 0]] - out_shape = [x_shape[0], *out_shape, filter_shape[-2]] + if data_format[-1] == "C": + padding = [[0, 0], *padding, [0, 0]] + else: + padding = [[0, 0], [0, 0], *padding] + if data_format[-1] == "C": + out_shape = [x_shape[0], *out_shape, filter_shape[-2]] + else: + out_shape = [x_shape[0], filter_shape[-2], *out_shape] return out_shape, padding @@ -133,7 +139,10 @@ def conv1d( x = _x_dil_before_conv(x, 1, x_dilations, data_format) x, padding = _pad_before_conv(x, padding, 1, data_format) res = tf.nn.conv1d(x, filters, strides, padding, data_format, dilations) - res = tf.math.add(res, bias) if bias is not None else res + if bias is not None: + if data_format[1] == "C": + bias = bias[tf.newaxis, ..., tf.newaxis] + res = tf.math.add(res, bias) if permuted_x: res = tf.transpose(res, (0, 2, 1)) return res @@ -173,7 +182,10 @@ def conv1d_transpose( res = tf.nn.conv1d_transpose( x, filters, output_shape, strides, padding, data_format, dilations ) - res = tf.math.add(res, bias) if bias is not None else res + if bias is not None: + if data_format[1] == "C": + bias = bias[tf.newaxis, ..., tf.newaxis] + res = tf.math.add(res, bias) if permuted_x: res = tf.transpose(res, (0, 2, 1)) return res @@ -222,7 +234,10 @@ def conv2d( x = _x_dil_before_conv(x, 2, x_dilations, data_format) padding = _extend_2d_padding(padding, data_format) res = tf.nn.conv2d(x, filters, strides, padding, data_format, dilations) - res = tf.math.add(res, bias) if bias is not None else res + if bias is not None: + if data_format[1] == "C": + bias = bias[tf.newaxis, ..., tf.newaxis, tf.newaxis] + res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, 3, 1, 2)) return res @@ -268,7 +283,10 @@ def conv2d_transpose( res = tf.nn.conv2d_transpose( x, filters, output_shape, strides, padding, data_format, dilations ) - res = tf.math.add(res, bias) if bias is not None else res + if bias is not None: + if data_format[1] == "C": + bias = bias[tf.newaxis, ..., tf.newaxis, tf.newaxis] + res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, 3, 1, 2)) return res @@ -329,7 +347,10 @@ def conv3d( x, padding = _pad_before_conv(x, padding, 3, data_format) strides, dilations = _extend_3d_strides_dilations(strides, dilations, data_format) res = tf.nn.conv3d(x, filters, strides, padding, data_format, dilations) - res = tf.math.add(res, bias) if bias is not None else res + if bias is not None: + if data_format[1] == "C": + bias = bias[tf.newaxis, ..., tf.newaxis, tf.newaxis, tf.newaxis] + res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, 4, 1, 2, 3)) return res @@ -370,7 +391,10 @@ def conv3d_transpose( res = tf.nn.conv3d_transpose( x, filters, output_shape, strides, padding, data_format, dilations ) - res = tf.math.add(res, bias) if bias is not None else res + if bias is not None: + if data_format[1] == "C": + bias = bias[tf.newaxis, ..., tf.newaxis, tf.newaxis, tf.newaxis] + res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, 4, 1, 2, 3)) return res @@ -410,7 +434,9 @@ def conv_general_dilated( ) permuted_x = False - if data_format == "channel_first" and ivy.dev(x) == "cpu": + if data_format == "channel_first" and ( + ivy.dev(x) == "cpu" or feature_group_count != 1 + ): x = tf.transpose(x, (0, *range(2, dims + 2), 1)) data_format = "channel_last" permuted_x = True @@ -467,7 +493,7 @@ def conv_general_dilated( else: res = tf.concat( [ - tf.nn.conv2d( + tf.nn.conv1d( x[..., i : i + filters.shape[-2]], filters[ ..., j : j + filters.shape[-1] // feature_group_count @@ -525,7 +551,11 @@ def conv_general_dilated( ], axis=-1, ) - res = tf.math.add(res, bias) if bias is not None else res + if bias is not None: + if data_format[1] == "C": + new_dims = [tf.newaxis, Ellipsis] + [tf.newaxis] * dims + bias = bias[new_dims] + res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) return res From 8a0fb3bd857e7868f5271abd7421bd73f8f678ea Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 29 Nov 2023 03:40:09 +0300 Subject: [PATCH 260/978] fix: Fixed bugs in the convolution function testing. Corrected the order of the strategy arguments and the feature_group_count filtering. --- .../test_functional/test_nn/test_layers.py | 32 +++++++++++-------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index c1895f1e5a912..73fe88ff2e848 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -479,10 +479,14 @@ def _x_and_filters( output_channels = draw(st.integers(1, 3)) group_list = [*range(1, 6)] if not transpose: - group_list = list(filter(lambda x: (input_channels % x == 0), group_list)) + group_list = list( + filter( + lambda x: (input_channels % x == 0 and x <= output_channels), group_list + ) + ) else: group_list = list(filter(lambda x: (output_channels % x == 0), group_list)) - fc = min(draw(st.sampled_from(group_list)), output_channels) if general else 1 + fc = draw(st.sampled_from(group_list)) strides = draw( st.one_of( st.integers(1, 3), st.lists(st.integers(1, 3), min_size=dim, max_size=dim) @@ -595,20 +599,22 @@ def _x_and_filters( ) ) dilations = (dilations, x_dilation) - filter_format = draw(st.sampled_from(["channel_first", "channel_last"])) - if filter_format == "channel_first": - filters = np.transpose(filters, (-1, -2, *range(dim))) + if not depthwise: + filter_format = draw(st.sampled_from(["channel_first", "channel_last"])) + if filter_format == "channel_first": + filters = np.transpose(filters, (-1, -2, *range(dim))) ret = ( dtype, vals, filters, dilations, - filter_format, data_format, strides, padding, ) ret = ret + (output_shape, fc) if transpose else ret + (fc,) + if not depthwise: + ret = ret + (filter_format,) if bias: return ret + (b,) return ret @@ -638,12 +644,12 @@ def _x_and_filters_and_transpose( x, filters, dilations, - filter_format, data_format, stride, pad, output_shape, fc, + filter_format, bias, ) = all_args else: @@ -652,11 +658,11 @@ def _x_and_filters_and_transpose( x, filters, dilations, - filter_format, data_format, stride, pad, fc, + filter_format, bias, ) = all_args return ( @@ -973,12 +979,12 @@ def test_conv1d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic x, filters, dilations, - filter_format, data_format, stride, pad, output_shape, fc, + filter_format, bias, ) = x_f_d_df # tensorflow does not work with dilations > 1 on cpu @@ -1063,12 +1069,12 @@ def test_conv2d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic x, filters, dilations, - filter_format, data_format, stride, pad, output_shape, fc, + filter_format, bias, ) = x_f_d_df assume(isinstance(pad, str) or backend_fw in ["torch", "tensorflow"]) @@ -1153,12 +1159,12 @@ def test_conv3d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic x, filters, dilations, - filter_format, data_format, stride, pad, output_shape, fc, + filter_format, bias, ) = x_f_d_df _assume_tf_dilation_gt_1(backend_fw, on_device, dilations) @@ -1191,7 +1197,7 @@ def test_conv3d_transpose(*, x_f_d_df, test_flags, backend_fw, fn_name, on_devic general=True, bias=True, ), - ground_truth_backend="jax", + ground_truth_backend="torch", ) def test_conv_general_dilated( *, dims, x_f_d_df, test_flags, backend_fw, fn_name, on_device @@ -1244,12 +1250,12 @@ def test_conv_general_transpose( x, filters, dilations, - filter_format, data_format, stride, pad, output_shape, fc, + filter_format, bias, ) = dim_x_f_d_df assume(isinstance(pad, str) or backend_fw in ["torch", "tensorflow"]) From 2d1679b9bcd8534c70d5382ddfef15b06596d4e6 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 29 Nov 2023 13:59:54 +0530 Subject: [PATCH 261/978] fix: Updated the handle_device func wrapper and the jnp.array frontend (#27412) For both to work with both ivy and native arrays --- ivy/func_wrapper.py | 2 +- ivy/functional/frontends/jax/numpy/creation.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index 5bf89176fa58c..2f93de927a7f4 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -805,7 +805,7 @@ def _handle_device(*args, **kwargs): with ivy.DefaultDevice(ivy.default_device(dev)): return ivy.handle_soft_device_variable(*args, fn=fn, **kwargs) inputs = args + tuple(kwargs.values()) - devices = tuple(ivy.dev(x) for x in inputs if ivy.is_native_array(x)) + devices = tuple(ivy.dev(x) for x in inputs if ivy.is_array(x)) unique_devices = set(devices) # check if arrays are on the same device if len(unique_devices) <= 1: diff --git a/ivy/functional/frontends/jax/numpy/creation.py b/ivy/functional/frontends/jax/numpy/creation.py index d426cf6939c7b..93a8cba0eca7b 100644 --- a/ivy/functional/frontends/jax/numpy/creation.py +++ b/ivy/functional/frontends/jax/numpy/creation.py @@ -45,13 +45,13 @@ def array(object, dtype=None, copy=True, order="K", ndmin=0): raise ivy.utils.exceptions.IvyNotImplementedException( "Only implemented for order='K'" ) - ret = ivy.array(object, dtype=dtype) + device = ivy.default_device() + if ivy.is_array(object): + device = ivy.dev(object) + ret = ivy.array(object, dtype=dtype, device=device) if ivy.get_num_dims(ret) < ndmin: ret = ivy.expand_dims(ret, axis=list(range(ndmin - ivy.get_num_dims(ret)))) - default_device = ivy.default_device() - ret = ivy.to_device(ret, default_device) - if ret.shape == () and dtype is None: return Array(ret, weak_type=True) return Array(ret) From 394b25e5c4723402df7bee83373a71c94fbb0ca6 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 29 Nov 2023 10:06:58 +0000 Subject: [PATCH 262/978] feat: add Gini classification Criterion for decision tree classifiers in sklearn frontend --- .../frontends/sklearn/tree/_criterion.py | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index b7731e1a51e9d..f145007f01a8c 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -141,6 +141,44 @@ def update(self, new_pos): return 0 +class Gini(ClassificationCriterion): + def node_impurity(self): + gini = 0.0 + for k in range(self.n_outputs): + sq_count = 0.0 + for c in range(int(self.n_classes[k])): + count_k = self.sum_total[k, c] + sq_count += count_k * count_k + gini += 1.0 - sq_count / ( + self.weighted_n_node_samples * self.weighted_n_node_samples + ) + return gini / self.n_outputs + + def children_impurity( + self, + impurity_left: float, + impurity_right: float, + ): + gini_left, gini_right = 0.0, 0.0 + for k in range(self.n_outputs): + sq_count_left, sq_count_right = 0.0, 0.0 + for c in range(int(self.n_classes[k])): + count_k = self.sum_left[k, c] + sq_count_left += count_k * count_k + count_k = self.sum_right[k, c] + sq_count_right += count_k * count_k + + gini_left += 1.0 - sq_count_left / ( + self.weighted_n_left * self.weighted_n_left + ) + gini_right += 1.0 - sq_count_right / ( + self.weighted_n_right * self.weighted_n_right + ) + impurity_left = gini_left / self.n_outputs + impurity_right = gini_right / self.n_outputs + return impurity_left, impurity_right + + # --- Helpers --- # # --------------- # From 248f4d760b0adc86aee1f86a7085776252827ded Mon Sep 17 00:00:00 2001 From: Abdullah Sabry Date: Wed, 29 Nov 2023 06:08:09 -0800 Subject: [PATCH 263/978] feat: Implemented `numpy.isin` in `numpy` frontend (#27410) Co-authored-by: NripeshN --- .../frontends/numpy/logic/array_contents.py | 9 ++++ .../test_logic/test_array_contents.py | 51 +++++++++++++++++++ 2 files changed, 60 insertions(+) diff --git a/ivy/functional/frontends/numpy/logic/array_contents.py b/ivy/functional/frontends/numpy/logic/array_contents.py index 87bab7479f744..2d0c40ef64ce7 100644 --- a/ivy/functional/frontends/numpy/logic/array_contents.py +++ b/ivy/functional/frontends/numpy/logic/array_contents.py @@ -7,6 +7,7 @@ handle_numpy_out, ) from ivy.functional.frontends.numpy import promote_types_of_numpy_inputs +from ivy.func_wrapper import with_supported_dtypes @inputs_to_ivy_arrays @@ -23,6 +24,14 @@ def isclose(a, b, /, *, rtol=1e-05, atol=1e-08, equal_nan=False): return ivy.isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan) +@with_supported_dtypes( + {"2.5.2 and below": ("int64", "float64", "float32", "int32", "bfloat16")}, "paddle" +) +@to_ivy_arrays_and_back +def isin(element, test_elements, assume_unique=False, invert=False): + return ivy.isin(element, test_elements, assume_unique=assume_unique, invert=invert) + + @handle_numpy_out @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_logic/test_array_contents.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_logic/test_array_contents.py index 56447b9024f47..99a41881c4b3d 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_logic/test_array_contents.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_logic/test_array_contents.py @@ -7,6 +7,25 @@ from ivy_tests.test_ivy.helpers import handle_frontend_test +# --- Helpers --- # +# --------------- # + + +# isin +@st.composite +def _isin_data_generation_helper(draw): + dtype_and_x = helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=2, + shared_dtype=True, + ) + return draw(dtype_and_x) + + +# --- Main --- # +# ------------ # + + @handle_frontend_test( fn_tree="numpy.allclose", dtype_and_x=helpers.dtype_and_values( @@ -75,6 +94,38 @@ def test_numpy_isclose( ) +# isin +@handle_frontend_test( + fn_tree="numpy.isin", + assume_unique_and_dtype_and_x=_isin_data_generation_helper(), + invert=st.booleans(), +) +def test_numpy_isin( + *, + assume_unique_and_dtype_and_x, + invert, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + x_and_dtype = assume_unique_and_dtype_and_x + dtypes, values = x_and_dtype + elements, test_elements = values + helpers.test_frontend_function( + input_dtypes=dtypes, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + element=elements, + test_elements=test_elements, + invert=invert, + backend_to_test=backend_fw, + ) + + @handle_frontend_test( fn_tree="numpy.isneginf", dtype_and_x=helpers.dtype_and_values( From d3c562dcc91cd839e3e1a05bee0deb2fbda7c02e Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Wed, 29 Nov 2023 14:51:54 +0000 Subject: [PATCH 264/978] refactor: Changes to improve unet's latency on tensorflow. --- .../backends/tensorflow/experimental/layers.py | 15 ++++++++++++--- .../tensorflow/experimental/manipulation.py | 8 +++----- .../backends/tensorflow/experimental/norms.py | 11 ++++++++++- ivy/functional/backends/tensorflow/layers.py | 15 +++++++-------- .../frontends/torch/nn/functional/norms.py | 5 +++-- ivy/functional/frontends/torch/tensor.py | 2 +- 6 files changed, 36 insertions(+), 20 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 72501f0416178..9cff4a5eb70ba 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -174,9 +174,18 @@ def max_pool2d( ) else: padding = "VALID" - res = tf.nn.pool( - x, kernel, "MAX", strides, padding, dilations=dilation, data_format=data_format - ) + if any(d > 1 for d in dilation): + res = tf.nn.pool( + x, + kernel, + "MAX", + strides, + padding, + dilations=dilation, + data_format=data_format, + ) + else: # faster + res = tf.nn.max_pool2d(x, kernel, strides, padding, data_format=data_format) if depth_pooling: res = tf.transpose(res, (0, 2, 3, 1)) diff --git a/ivy/functional/backends/tensorflow/experimental/manipulation.py b/ivy/functional/backends/tensorflow/experimental/manipulation.py index 56ad09a9daab3..43e286e1eb0a8 100644 --- a/ivy/functional/backends/tensorflow/experimental/manipulation.py +++ b/ivy/functional/backends/tensorflow/experimental/manipulation.py @@ -294,11 +294,9 @@ def pad( **kwargs: Optional[Any], ) -> Union[tf.Tensor, tf.Variable]: pad_width = _to_tf_padding(pad_width, len(input.shape)) - if not isinstance(pad_width, (tf.Variable, tf.Tensor)): - pad_width = tf.constant(pad_width) - constant_values = tf.constant(constant_values) - if constant_values.dtype != input.dtype: - constant_values = tf.cast(constant_values, input.dtype) + if isinstance(constant_values, (tf.Variable, tf.Tensor)): + if constant_values.dtype != input.dtype: + constant_values = tf.cast(constant_values, input.dtype) return tf.pad( input, pad_width, diff --git a/ivy/functional/backends/tensorflow/experimental/norms.py b/ivy/functional/backends/tensorflow/experimental/norms.py index 3c9c878c8fa60..0e62c92a4a75c 100644 --- a/ivy/functional/backends/tensorflow/experimental/norms.py +++ b/ivy/functional/backends/tensorflow/experimental/norms.py @@ -107,7 +107,16 @@ def batch_norm( runningvariance = (1 - momentum) * runningvariance + momentum * variance * n / ( n - 1 ) - xnormalized = tf.nn.batch_normalization(x, mean, variance, offset, scale, eps) + + inv = 1.0 / tf.math.sqrt(variance + eps) + offset = 0 if offset is None else offset + if scale is not None and any(s != 1 for s in scale): + inv = tf.math.multiply(inv, scale) + xnormalized = tf.math.multiply(x, inv) + if any(s != 0 for s in offset): + xnormalized = tf.math.add(xnormalized, offset) + xnormalized = tf.math.subtract(xnormalized, tf.math.multiply(mean, inv)) + # the above approach is faster than tf.nn.batch_normalization if data_format == "NCS": xnormalized = tf.transpose( diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 14f8cfa492b6b..a443e1c1706a3 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -141,7 +141,7 @@ def conv1d( res = tf.nn.conv1d(x, filters, strides, padding, data_format, dilations) if bias is not None: if data_format[1] == "C": - bias = bias[tf.newaxis, ..., tf.newaxis] + bias = tf.reshape(bias, [1, -1, 1]) res = tf.math.add(res, bias) if permuted_x: res = tf.transpose(res, (0, 2, 1)) @@ -184,7 +184,7 @@ def conv1d_transpose( ) if bias is not None: if data_format[1] == "C": - bias = bias[tf.newaxis, ..., tf.newaxis] + bias = tf.reshape(bias, [1, -1, 1]) res = tf.math.add(res, bias) if permuted_x: res = tf.transpose(res, (0, 2, 1)) @@ -236,7 +236,7 @@ def conv2d( res = tf.nn.conv2d(x, filters, strides, padding, data_format, dilations) if bias is not None: if data_format[1] == "C": - bias = bias[tf.newaxis, ..., tf.newaxis, tf.newaxis] + bias = tf.reshape(bias, [1, -1, 1, 1]) res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, 3, 1, 2)) @@ -285,7 +285,7 @@ def conv2d_transpose( ) if bias is not None: if data_format[1] == "C": - bias = bias[tf.newaxis, ..., tf.newaxis, tf.newaxis] + bias = tf.reshape(bias, [1, -1, 1, 1]) res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, 3, 1, 2)) @@ -349,7 +349,7 @@ def conv3d( res = tf.nn.conv3d(x, filters, strides, padding, data_format, dilations) if bias is not None: if data_format[1] == "C": - bias = bias[tf.newaxis, ..., tf.newaxis, tf.newaxis, tf.newaxis] + bias = tf.reshape(bias, [1, -1, 1, 1, 1]) res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, 4, 1, 2, 3)) @@ -393,7 +393,7 @@ def conv3d_transpose( ) if bias is not None: if data_format[1] == "C": - bias = bias[tf.newaxis, ..., tf.newaxis, tf.newaxis, tf.newaxis] + bias = tf.reshape(bias, [1, -1, 1, 1, 1]) res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, 4, 1, 2, 3)) @@ -553,8 +553,7 @@ def conv_general_dilated( ) if bias is not None: if data_format[1] == "C": - new_dims = [tf.newaxis, Ellipsis] + [tf.newaxis] * dims - bias = bias[new_dims] + bias = tf.reshape(bias, [1, -1, *([1] * dims)]) res = tf.math.add(res, bias) if permuted_x: return tf.transpose(res, (0, dims + 1, *range(1, dims + 1))) diff --git a/ivy/functional/frontends/torch/nn/functional/norms.py b/ivy/functional/frontends/torch/nn/functional/norms.py index bc4bbfabf1083..c489dbee9f5d0 100644 --- a/ivy/functional/frontends/torch/nn/functional/norms.py +++ b/ivy/functional/frontends/torch/nn/functional/norms.py @@ -34,8 +34,9 @@ def batch_norm( momentum=momentum, data_format="NCS", ) - ivy.inplace_update(running_mean, mean) - ivy.inplace_update(running_var, var) + if training: + ivy.inplace_update(running_mean, mean) + ivy.inplace_update(running_var, var) return normalized diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index bf7ab631a2628..c6bf10cd8df2b 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -793,7 +793,7 @@ def pow_(self, exponent): return self def size(self, dim=None): - shape = self.shape + shape = self.ivy_array.shape if dim is None: return shape try: From 9e538b137aaf498d5d3c0ecb8a95c4737b64c31e Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 29 Nov 2023 21:21:58 +0530 Subject: [PATCH 265/978] fix: Fixed missing parentheses after `super` calls. (#26363) --- ivy/data_classes/container/base.py | 4 ++-- ivy_tests/test_ivy/helpers/globals.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index b2bc127c40863..7addfcff8c52c 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -3980,7 +3980,7 @@ def _add_newline(str_in): return new_dict def __dir__(self): - return list(super.__dir__(self)) + list(self.keys()) + return list(super().__dir__()) + list(self.keys()) # noinspection PyProtectedMember def __getattr__(self, item, *args, **kwargs): @@ -4007,7 +4007,7 @@ def __setattr__(self, name, value): if name[0] != "_": self[name] = value else: - super.__setattr__(self, name, value) + super().__setattr__(name, value) def _get_queue_item(self, query): if isinstance(query, int): diff --git a/ivy_tests/test_ivy/helpers/globals.py b/ivy_tests/test_ivy/helpers/globals.py index 8d1d7f2f191d2..b97865b637e38 100644 --- a/ivy_tests/test_ivy/helpers/globals.py +++ b/ivy_tests/test_ivy/helpers/globals.py @@ -62,7 +62,7 @@ class InterruptedTest(BaseException): """Indicate that a test tried to write global attributes while a test is running.""" def __init__(self, test_interrupted): - super.__init__(f"{test_interrupted} was interrupted during execution.") + super().__init__(f"{test_interrupted} was interrupted during execution.") # Setup From 33e2be4490cd403c69b9e4cca3c62c5c13b68ced Mon Sep 17 00:00:00 2001 From: Abdullah Sabry Date: Wed, 29 Nov 2023 09:47:32 -0800 Subject: [PATCH 266/978] fix: Fixed import error in `test_tensor.py` in torch frontend (#27413) Co-authored-by: NripeshN --- .../test_indexing_slicing_joining_mutating_ops.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py index f08400ec8e6c3..591d477f57ecf 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py @@ -11,8 +11,8 @@ import ivy_tests.test_ivy.helpers.globals as test_globals from ivy_tests.test_ivy.helpers import handle_frontend_test from ivy_tests.test_ivy.test_functional.test_core.test_manipulation import _get_splits -from ivy_tests.array_api_testing.test_array_api.array_api_tests import ( - hypothesis_helpers as hh, +from ivy_tests.test_ivy.helpers.hypothesis_helpers.general_helpers import ( + two_broadcastable_shapes, ) @@ -337,7 +337,7 @@ def _dtypes_input_mask(draw): @st.composite def _where_helper(draw): - shape_1, shape_2 = draw(hh.two_broadcastable_shapes()) + shape_1, shape_2 = draw(two_broadcastable_shapes()) dtype_x1, x1 = draw( helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("valid"), From 99f184d52b050780890059d14ccc89dccf6074be Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 30 Nov 2023 11:16:26 +0530 Subject: [PATCH 267/978] refactor: Extract `Duplicate Code` into Helper Function in `ivy\func_wrapper.py` (#26572) Co-authored-by: vedpatwardhan --- ivy/func_wrapper.py | 92 +++++++++++---------------------------------- 1 file changed, 21 insertions(+), 71 deletions(-) diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index 2f93de927a7f4..3083fb7978c08 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -91,91 +91,41 @@ def caster(dtype, intersect): return ret_dtype +def cast_helper(arg, dtype, intersect, is_upcast=True): + step = 1 if is_upcast else -1 + index = casting_modes_dict[arg]().index(dtype) + step + result = "" + while 0 <= index < len(casting_modes_dict[arg]()): + if casting_modes_dict[arg]()[index] not in intersect: + result = casting_modes_dict[arg]()[index] + break + index += step + + return result + + def upcaster(dtype, intersect): # upcasting is enabled, we upcast to the highest if "uint" in str(dtype): - index = casting_modes_dict["uint"]().index(dtype) + 1 - result = "" - while index < len(casting_modes_dict["uint"]()): - if casting_modes_dict["uint"]()[index] not in intersect: - result = casting_modes_dict["uint"]()[index] - break - index += 1 - return result - + return cast_helper("uint", dtype, intersect, is_upcast=True) if "int" in dtype: - index = casting_modes_dict["int"]().index(dtype) + 1 - result = "" - while index < len(casting_modes_dict["int"]()): - if casting_modes_dict["int"]()[index] not in intersect: - result = casting_modes_dict["int"]()[index] - break - index += 1 - return result - + return cast_helper("int", dtype, intersect, is_upcast=True) if "float" in dtype: - index = casting_modes_dict["float"]().index(dtype) + 1 - result = "" - while index < len(casting_modes_dict["float"]()): - if casting_modes_dict["float"]()[index] not in intersect: - result = casting_modes_dict["float"]()[index] - break - index += 1 - return result - + return cast_helper("float", dtype, intersect, is_upcast=True) if "complex" in dtype: - index = casting_modes_dict["complex"]().index(dtype) + 1 - result = "" - while index < len(casting_modes_dict["complex"]()): - if casting_modes_dict["complex"]()[index] not in intersect: - result = casting_modes_dict["complex"]()[index] - break - index += 1 - return result + return cast_helper("complex", dtype, intersect, is_upcast=True) def downcaster(dtype, intersect): # downcasting is enabled, we upcast to the highest if "uint" in str(dtype): - index = casting_modes_dict["uint"]().index(dtype) - 1 - result = "" - while index >= 0: - if casting_modes_dict["int"]()[index] not in intersect: - result = casting_modes_dict["uint"]()[index] - break - index -= 1 - return result - + return cast_helper("uint", dtype, intersect, is_upcast=False) if "int" in dtype: - index = casting_modes_dict["int"]().index(dtype) - 1 - result = "" - while index >= 0: - if casting_modes_dict["int"]()[index] not in intersect: - result = casting_modes_dict["int"]()[index] - break - index -= 1 - return result - + return cast_helper("int", dtype, intersect, is_upcast=False) if "float" in dtype: - index = casting_modes_dict["float"]().index(dtype) - 1 - - result = "" - while index >= 0: - if casting_modes_dict["float"]()[index] not in intersect: - result = casting_modes_dict["float"]()[index] - break - index -= 1 - return result - + return cast_helper("float", dtype, intersect, is_upcast=False) if "complex" in dtype: - index = casting_modes_dict["complex"]().index(dtype) - 1 - result = "" - while index >= 0: - if casting_modes_dict["complex"]()[index] not in intersect: - result = casting_modes_dict["complex"]()[index] - break - index -= 1 - return result + return cast_helper("complex", dtype, intersect, is_upcast=False) def cross_caster(intersect): From 423ebedfa8358074ec4097f93eada8fdc7760b35 Mon Sep 17 00:00:00 2001 From: Vismay Suramwar <83938053+Vismay-dev@users.noreply.github.com> Date: Thu, 30 Nov 2023 04:15:08 -0600 Subject: [PATCH 268/978] fix: added support for dilation in torch.nn.functional.conv_transpose2d (#27411) Co-authored-by: @AnnaTz --- .../nn/functional/convolution_functions.py | 95 ++++++++++++++----- .../test_convolution_functions.py | 7 +- 2 files changed, 71 insertions(+), 31 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index 66d385262a6b2..f0adcfb744056 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -38,8 +38,6 @@ def _conv(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return ret -# ToDo: add support for dilation > 1 -# ToDo: add support for output_padding > padding def _conv_transpose( input, weight, @@ -54,10 +52,20 @@ def _conv_transpose( weight = ivy.permute_dims(weight, axes=(*range(2, dims + 2), 0, 1)) for i in range(dims): weight = ivy.flip(weight, axis=i) - padding, output_padding = map( - lambda x: [x] * dims if isinstance(x, int) else x, [padding, output_padding] + padding, output_padding, stride, dilation = map( + lambda x: [x] * dims if isinstance(x, int) else x, + [padding, output_padding, stride, dilation], ) - pad_widths = [(weight.shape[i] - 1,) * 2 for i in range(dims)] + + pad_widths = [ + ( + (weight.shape[i] - 1) * dilation[i] + + max([output_padding[i] - padding[i], 0]), + ) + * 2 + for i in range(dims) + ] + ret = ivy.conv_general_dilated( input, weight, @@ -67,12 +75,17 @@ def _conv_transpose( data_format="channel_first", feature_group_count=groups, x_dilations=stride, + dilations=dilation, bias=bias, ) unpad_slice = (slice(None),) * 2 for i in range(dims): unpad_slice += ( - slice(padding[i], ret.shape[2 + i] - padding[i] + output_padding[i], 1), + slice( + max([padding[i] - (dilation[i] // 2), padding[i], output_padding[i]]), + ret.shape[2 + i] - padding[i] + output_padding[i] + (dilation[i] // 2), + 1, + ), ) ret = ret[unpad_slice] return ret @@ -208,16 +221,31 @@ def conv_transpose1d( groups=1, dilation=1, ): - return _conv_transpose( - input, - weight, - bias=bias, - stride=stride, - padding=padding, - output_padding=output_padding, - groups=groups, - dilation=dilation, - ) + if ivy.current_backend_str() in ["torch"]: + # this backend supports explicit padding, no need for conv_general_dilated + return ivy.conv_general_transpose( + input, + weight, + stride, + _get_transpose_pad(padding, output_padding, 1), + dims=1, + filter_format="channel_first", + data_format="channel_first", + dilations=dilation, + feature_group_count=groups, + bias=bias, + ) + else: + return _conv_transpose( + input, + weight, + bias=bias, + stride=stride, + padding=padding, + output_padding=output_padding, + groups=groups, + dilation=dilation, + ) @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @@ -271,16 +299,31 @@ def conv_transpose3d( groups=1, dilation=1, ): - return _conv_transpose( - input, - weight, - bias=bias, - stride=stride, - padding=padding, - output_padding=output_padding, - groups=groups, - dilation=dilation, - ) + if ivy.current_backend_str() in ["torch"]: + # this backend supports explicit padding, no need for conv_general_dilated + return ivy.conv_general_transpose( + input, + weight, + stride, + _get_transpose_pad(padding, output_padding, 3), + dims=3, + filter_format="channel_first", + data_format="channel_first", + dilations=dilation, + feature_group_count=groups, + bias=bias, + ) + else: + return _conv_transpose( + input, + weight, + bias=bias, + stride=stride, + padding=padding, + output_padding=output_padding, + groups=groups, + dilation=dilation, + ) @to_ivy_arrays_and_back diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py index 62bfa189bdc44..de8d285f5d7d3 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_convolution_functions.py @@ -227,9 +227,6 @@ def _x_and_filters(draw, dim: int = 2, transpose: bool = False, max_dilation=3): ) padding = [padding] * dim if isinstance(padding, int) else padding for i in range(len(output_padding)): - # ToDo: remove this when support for output_padding > padding is added - if dim != 2: - output_padding[i] = min(padding[i], output_padding[i]) m = min(fstrides[i], fdilations[i]) output_padding[i] = min(output_padding[i], m - 1) if draw(st.booleans()): @@ -364,7 +361,7 @@ def test_torch_conv3d( @handle_frontend_test( fn_tree="torch.nn.functional.conv_transpose1d", - dtype_vals=_x_and_filters(dim=1, transpose=True, max_dilation=1), + dtype_vals=_x_and_filters(dim=1, transpose=True), ) def test_torch_conv_transpose1d( *, @@ -444,7 +441,7 @@ def test_torch_conv_transpose2d( @handle_frontend_test( fn_tree="torch.nn.functional.conv_transpose3d", - dtype_vals=_x_and_filters(dim=3, transpose=True, max_dilation=1), + dtype_vals=_x_and_filters(dim=3, transpose=True), ) def test_torch_conv_transpose3d( *, From a385c0bb631d3ae36291802771d79db2589eeaea Mon Sep 17 00:00:00 2001 From: AnnaTz <111577222+AnnaTz@users.noreply.github.com> Date: Thu, 30 Nov 2023 17:26:49 +0000 Subject: [PATCH 269/978] refactor: Avoid changing the backend in KerasModule's __call__ if it's already tensorflow. --- ivy/stateful/converters.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index 13b5e5cfde568..599b5532d0a24 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -527,10 +527,12 @@ def call(self, *args, training=None, **kwargs): return ret def __call__(self, *args, **kwargs): - ivy.set_backend("tensorflow") - args, kwargs = ivy.args_to_new_backend(*args, native=True, **kwargs) - ivy.previous_backend() - + if ivy.backend != "tensorflow": + ivy.set_backend("tensorflow") + args, kwargs = ivy.args_to_new_backend(*args, native=True, **kwargs) + ivy.previous_backend() + else: + args, kwargs = ivy.args_to_new_backend(*args, native=True, **kwargs) return super(KerasModel, self).__call__(*args, **kwargs) def to_device(self, device): From c66ee77624e5a2f0120669eb7c93c4e8786d121e Mon Sep 17 00:00:00 2001 From: Abdullah Sabry Date: Fri, 1 Dec 2023 04:51:55 -0800 Subject: [PATCH 270/978] feat: Added `tridiagonal_solve` in tensorflow frontend (#23279) Co-authored-by: NripeshN --- ivy/functional/frontends/tensorflow/linalg.py | 49 ++++++++ .../test_tensorflow/test_linalg.py | 106 ++++++++++++++++++ 2 files changed, 155 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/linalg.py b/ivy/functional/frontends/tensorflow/linalg.py index b0e8bdfdc7c5f..c0dcad4dd5906 100644 --- a/ivy/functional/frontends/tensorflow/linalg.py +++ b/ivy/functional/frontends/tensorflow/linalg.py @@ -458,3 +458,52 @@ def tensorsolve(a, b, axes): @to_ivy_arrays_and_back def trace(x, name=None): return ivy.trace(x, axis1=-2, axis2=-1) + + +@to_ivy_arrays_and_back +@with_supported_dtypes( + { + "2.13.0 and below": ( + "float32", + "float64", + "complex64", + "complex128", + ) + }, + "tensorflow", +) +def tridiagonal_solve( + diagonals, + rhs, + diagonals_format="compact", + transpose_rhs=False, + conjugate_rhs=False, + name=None, + partial_pivoting=True, + perturb_singular=False, +): + if transpose_rhs is True: + rhs_copy = ivy.matrix_transpose(rhs) + if conjugate_rhs is True: + rhs_copy = ivy.conj(rhs) + if not transpose_rhs and not conjugate_rhs: + rhs_copy = ivy.array(rhs) + + if diagonals_format == "matrix": + return ivy.solve(diagonals, rhs_copy) + elif diagonals_format in ["sequence", "compact"]: + diagonals = ivy.array(diagonals) + dim = diagonals[0].shape[0] + diagonals[[0, -1], [-1, 0]] = 0 + dummy_idx = [0, 0] + indices = ivy.array([ + [(i, i + 1) for i in range(dim - 1)] + [dummy_idx], + [(i, i) for i in range(dim)], + [dummy_idx] + [(i + 1, i) for i in range(dim - 1)], + ]) + constructed_matrix = ivy.scatter_nd( + indices, diagonals, shape=ivy.array([dim, dim]) + ) + return ivy.solve(constructed_matrix, rhs_copy) + else: + raise "Unexpected diagonals_format" diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py index fdc93ffc80933..e3d22b6f3f4ad 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py @@ -153,6 +153,41 @@ def _get_second_matrix(draw): ) +@st.composite +def _get_tridiagonal_dtype_matrix_format(draw): + input_dtype_strategy = st.shared( + st.sampled_from(draw(helpers.get_dtypes("float_and_complex"))), + key="shared_dtype", + ) + input_dtype = draw(input_dtype_strategy) + shared_size = draw( + st.shared(helpers.ints(min_value=2, max_value=4), key="shared_size") + ) + diagonals_format = draw(st.sampled_from(["compact", "sequence", "matrix"])) + if diagonals_format == "matrix": + matrix = draw( + helpers.array_values( + dtype=input_dtype, + shape=tuple([shared_size, shared_size]), + min_value=2, + max_value=5, + ).filter(tridiagonal_matrix_filter) + ) + elif diagonals_format in ["compact", "sequence"]: + matrix = draw( + helpers.array_values( + dtype=input_dtype, + shape=tuple([3, shared_size]), + min_value=2, + max_value=5, + ).filter(tridiagonal_compact_filter) + ) + if diagonals_format == "sequence": + matrix = list(matrix) + + return input_dtype, matrix, diagonals_format + + # --- Main --- # # ------------ # @@ -1207,3 +1242,74 @@ def test_tensorflow_trace( fn_tree=fn_tree, x=x[0], ) + + +# tridiagonal_solve +@handle_frontend_test( + fn_tree="tensorflow.linalg.tridiagonal_solve", + x=_get_tridiagonal_dtype_matrix_format(), + y=_get_second_matrix(), + transpose_rhs=st.just(False), + conjugate_rhs=st.booleans(), +) +def test_tensorflow_tridiagonal_solve( + *, + x, + y, + transpose_rhs, + conjugate_rhs, + frontend, + backend_fw, + test_flags, + fn_tree, + on_device, +): + input_dtype1, x1, diagonals_format = x + input_dtype2, x2 = y + helpers.test_frontend_function( + input_dtypes=[input_dtype1, input_dtype2], + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + rtol=1e-3, + atol=1e-3, + diagonals=x1, + rhs=x2, + diagonals_format=diagonals_format, + transpose_rhs=transpose_rhs, + conjugate_rhs=conjugate_rhs, + ) + + +def tridiagonal_compact_filter(x): + diagonals = ivy.array(x) + dim = diagonals[0].shape[0] + diagonals[[0, -1], [-1, 0]] = 0 + dummy_idx = [0, 0] + indices = ivy.array([ + [(i, i + 1) for i in range(dim - 1)] + [dummy_idx], + [(i, i) for i in range(dim)], + [dummy_idx] + [(i + 1, i) for i in range(dim - 1)], + ]) + matrix = ivy.scatter_nd( + indices, diagonals, ivy.array([dim, dim]), reduction="replace" + ) + return tridiagonal_matrix_filter(matrix) + + +def tridiagonal_matrix_filter(x): + dim = x.shape[0] + if ivy.abs(ivy.det(x)) < 1e-3: + return False + for i in range(dim): + for j in range(dim): + cell = x[i][j] + if i == j or i == j - 1 or i == j + 1: + if cell == 0: + return False + else: + if cell != 0: + return False + return True From bfbb01bed923c1cfa6888400867861d345269ee5 Mon Sep 17 00:00:00 2001 From: Abdullah Sabry Date: Fri, 1 Dec 2023 04:54:01 -0800 Subject: [PATCH 271/978] feat: added `floor_mod` in paddle frontend (#26064) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 6 ++++ .../test_paddle/test_tensor/test_tensor.py | 36 +++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 2d3e814391442..530b36b1087f4 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -781,6 +781,12 @@ def floor_divide(self, y, name=None): def mod(self, y, name=None): return paddle_frontend.Tensor(ivy.fmod(self._ivy_array, _to_ivy_array(y))) + @with_supported_dtypes( + {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + ) + def floor_mod(self, y, name=None): + return paddle_frontend.remainder(self, y) + # cond @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def cond(self, p=None, name=None): diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 3ab33f46e4b0f..345fe4cbc04a5 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -5392,6 +5392,42 @@ def test_paddle_tensor_expand( ) +# floor_mod +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="floor_mod", + dtypes_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=2, + min_value=2, + shared_dtype=True, + ), +) +def test_paddle_tensor_floor_mod( + dtypes_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtypes_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={"data": x[0]}, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={"y": x[1]}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", From 4b399fc82313b0efaf6f562ab70a7b627e2adc68 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 1 Dec 2023 16:57:46 +0000 Subject: [PATCH 272/978] feat: add base Splitter class for decision trees in sklearn front --- .../frontends/sklearn/tree/_splitter.py | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 ivy/functional/frontends/sklearn/tree/_splitter.py diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py new file mode 100644 index 0000000000000..e199271527150 --- /dev/null +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -0,0 +1,80 @@ +import ivy + + +class Splitter: + def __init__( + self, + criterion, + max_features: int, + min_samples_leaf: int, + min_weight_leaf: float, + random_state, + *args, + ): + self.criterion = criterion + self.n_samples = 0 + self.n_features = 0 + self.max_features = max_features + self.min_samples_leaf = min_samples_leaf + self.min_weight_leaf = min_weight_leaf + self.random_state = random_state + + def init( + self, + X, + y, + sample_weight, + missing_values_in_feature_mask, + *args, + ): + + n_samples = X.shape[0] + self.samples = ivy.empty(n_samples, dtype=ivy.int32) + samples = self.samples + j = 0 + weighted_n_samples = 0.0 + + for i in range(n_samples): + if sample_weight is None or sample_weight[i] != 0.0: + samples[j] = i + j += 1 + if sample_weight is not None: + weighted_n_samples += sample_weight[i] + else: + weighted_n_samples += 1.0 + + self.n_samples = j + self.weighted_n_samples = weighted_n_samples + n_features = X.shape[1] + self.features = ivy.arange(n_features, dtype=ivy.int32) + self.n_features = n_features + self.feature_values = ivy.empty(n_samples, dtype=ivy.float32) + self.constant_features = ivy.empty(n_features, dtype=ivy.int32) + self.y = y + self.sample_weight = sample_weight + if missing_values_in_feature_mask is not None: + self.criterion.init_sum_missing() + return 0 + + def node_reset(self, start, end, weighted_n_node_samples): + self.start = start + self.end = end + self.criterion.init( + self.y, + self.sample_weight, + self.weighted_n_samples, + self.samples, + start, + end, + ) + weighted_n_node_samples = self.criterion.weighted_n_node_samples + return 0, weighted_n_node_samples + + def node_split(self, impurity, split, n_constant_features): + pass + + def node_value(self, dest, node_id): + return self.criterion.node_value(dest, node_id) + + def node_impurity(self): + return self.criterion.node_impurity() From eb53e58dd39b488c778fa58643257e1298f7aacd Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 1 Dec 2023 17:00:21 +0000 Subject: [PATCH 273/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/frontends/sklearn/tree/_splitter.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index e199271527150..ecf72db430ef6 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -27,7 +27,6 @@ def init( missing_values_in_feature_mask, *args, ): - n_samples = X.shape[0] self.samples = ivy.empty(n_samples, dtype=ivy.int32) samples = self.samples From 8ead3ae8a9f91ff0f9b234316af0d0b49fb485e4 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 1 Dec 2023 17:12:59 +0000 Subject: [PATCH 274/978] feat: add base structure for BestSplitter method which overrides init and node_split from Splitter --- .../frontends/sklearn/tree/_splitter.py | 40 +++++++++++++++++-- 1 file changed, 37 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index ecf72db430ef6..33f4da240449c 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -5,9 +5,9 @@ class Splitter: def __init__( self, criterion, - max_features: int, - min_samples_leaf: int, - min_weight_leaf: float, + max_features, + min_samples_leaf, + min_weight_leaf, random_state, *args, ): @@ -77,3 +77,37 @@ def node_value(self, dest, node_id): def node_impurity(self): return self.criterion.node_impurity() + + +class BestSplitter(Splitter): + def init( + self, + X, + y, + sample_weight, + missing_values_in_feature_mask, + *args, + ): + Splitter.init(self, X, y, sample_weight, missing_values_in_feature_mask, *args) + self.partitioner = None + + def node_split(self, impurity, split, n_constant_features): + return node_split_best( + self, + self.partitioner, + self.criterion, + impurity, + split, + n_constant_features, + ) + + +def node_split_best( + splitter: Splitter, + partitioner, + criterion, + impurity, + split, + n_constant_features +): + pass From 604fb8490a4088cb9ef4add4766ef2fcf6fd7b5b Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 1 Dec 2023 17:14:38 +0000 Subject: [PATCH 275/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/frontends/sklearn/tree/_splitter.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 33f4da240449c..6ecd472d2b971 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -103,11 +103,6 @@ def node_split(self, impurity, split, n_constant_features): def node_split_best( - splitter: Splitter, - partitioner, - criterion, - impurity, - split, - n_constant_features + splitter: Splitter, partitioner, criterion, impurity, split, n_constant_features ): pass From 319c2836a5549546e25c0387a8d4046c089295a4 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 1 Dec 2023 18:10:59 +0000 Subject: [PATCH 276/978] feat: add DensePartitioner required for both the best splitter and random splitter for decision trees. check https://github.com/scikit-learn/scikit-learn/blob/a6603bcd8953e6bcc94081fa5c5d5741eb408927/sklearn/tree/_splitter.pyx#L860 --- .../frontends/sklearn/tree/_splitter.py | 169 ++++++++++++++++++ 1 file changed, 169 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 6ecd472d2b971..c222d7361d41f 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -1,5 +1,7 @@ import ivy +FEATURE_THRESHOLD = 1e-7 + class Splitter: def __init__( @@ -79,6 +81,169 @@ def node_impurity(self): return self.criterion.node_impurity() +class DensePartitioner: + X = [] + samples = [] + feature_values = [] + start = 0 + end = 0 + n_missing = 0 + missing_values_in_feature_mask = [] + + def __init__( + self, + X, + samples, + feature_values, + missing_values_in_feature_mask, + ): + self.X = X + self.samples = samples + self.feature_values = feature_values + self.missing_values_in_feature_mask = missing_values_in_feature_mask + + def init_node_split(self, start, end): + self.start = start + self.end = end + self.n_missing = 0 + + def sort_samples_and_feature_values(self, current_feature): + feature_values = self.feature_values + X = self.X + samples = self.samples + n_missing = 0 + missing_values_in_feature_mask = self.missing_values_in_feature_mask + if ( + missing_values_in_feature_mask is not None + and missing_values_in_feature_mask[current_feature] + ): + i, current_end = self.start, self.end - 1 + while i <= current_end: + if ivy.isnan(X[samples[current_end], current_feature]): + n_missing += 1 + current_end -= 1 + continue + if ivy.isnan(X[samples[i], current_feature]): + samples[i], samples[current_end] = samples[current_end], samples[i] + n_missing += 1 + current_end -= 1 + feature_values[i] = X[samples[i], current_feature] + i += 1 + else: + for i in range(self.start, self.end): + feature_values[i] = X[int(samples[i]), int(current_feature)] + ( + self.feature_values[self.start : self.end], + self.samples[self.start : self.end], + ) = sort( + feature_values[self.start : self.end], + samples[self.start : self.end], + self.end - self.start - n_missing, + ) + self.n_missing = n_missing + + def find_min_max( + self, + current_feature: int, + min_feature_value_out: float, + max_feature_value_out: float, + ): + current_feature = 0 + X = self.X + samples = self.samples + min_feature_value = X[samples[self.start], current_feature] + max_feature_value = min_feature_value + feature_values = self.feature_values + feature_values[self.start] = min_feature_value + for p in range(self.start + 1, self.end): + current_feature_value = X[samples[p], current_feature] + feature_values[p] = current_feature_value + + if current_feature_value < min_feature_value: + min_feature_value = current_feature_value + elif current_feature_value > max_feature_value: + max_feature_value = current_feature_value + return min_feature_value, max_feature_value + + def next_p(self, p_prev: int, p: int): + feature_values = self.feature_values + end_non_missing = self.end - self.n_missing + + while ( + p + 1 < end_non_missing + and feature_values[p + 1] <= feature_values[p] + FEATURE_THRESHOLD + ): + p += 1 + p_prev = p + p += 1 + return p_prev, p + + def partition_samples(self, current_thershold: float): + p = self.start + partition_end = self.end + samples = self.samples + feature_values = self.feature_values + while p < partition_end: + if feature_values[p] <= current_thershold: + p += 1 + else: + partition_end -= 1 + + feature_values[p], feature_values[partition_end] = ( + feature_values[partition_end], + feature_values[p], + ) + samples[p], samples[partition_end] = ( + samples[partition_end], + samples[p], + ) + return partition_end + + def partition_samples_final( + self, + best_pos, + best_threshold, + best_feature, + best_n_missing, + ): + start = self.start + p = start + end = self.end - 1 + partition_end = end - best_n_missing + samples = self.samples + X = self.X + + if best_n_missing != 0: + while p < partition_end: + if ivy.isnan(X[samples[end], best_feature]): + end -= 1 + continue + current_value = X[samples[p], best_feature] + if ivy.isnan(current_value): + samples[p], samples[end] = samples[end], samples[p] + end -= 1 + current_value = X[samples[p], best_feature] + if current_value <= best_threshold: + p += 1 + else: + samples[p], samples[partition_end] = ( + samples[partition_end], + samples[p], + ) + partition_end -= 1 + else: + while p < partition_end: + if X[samples[p], best_feature] <= best_threshold: + p += 1 + else: + samples[p], samples[partition_end] = ( + samples[partition_end], + samples[p], + ) + partition_end -= 1 + self.samples = samples + + class BestSplitter(Splitter): def init( self, @@ -106,3 +271,7 @@ def node_split_best( splitter: Splitter, partitioner, criterion, impurity, split, n_constant_features ): pass + + +def sort(feature_values, samples, n): + return 0, 0 From 91fb2824f5cdcc899811b8a26e01c4d994d8d954 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 1 Dec 2023 18:20:56 +0000 Subject: [PATCH 277/978] feat: add custom sort function for DensePartitions's sort_samples_and_feature_values --- ivy/functional/frontends/sklearn/tree/_splitter.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index c222d7361d41f..037233038533f 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -274,4 +274,7 @@ def node_split_best( def sort(feature_values, samples, n): - return 0, 0 + if n == 0: + return + idx = ivy.argsort(feature_values) + return feature_values[idx], samples[idx] From 12b30834e5629a10d24e945427dc19bf46bc0152 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sat, 2 Dec 2023 01:52:57 +0400 Subject: [PATCH 278/978] test commit (#27421) From 4577f47d9a410968cbd16931636a1327e7b61040 Mon Sep 17 00:00:00 2001 From: Abdullah Sabry Date: Fri, 1 Dec 2023 13:55:39 -0800 Subject: [PATCH 279/978] feat: Added `torchTensor.frac` to torch frontend (#27417) Co-authored-by: NripeshN --- ivy/functional/frontends/torch/tensor.py | 4 ++ .../test_frontends/test_torch/test_tensor.py | 38 +++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index c6bf10cd8df2b..66193ab80f063 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2017,6 +2017,10 @@ def uniform_(self, from_=0, to=1, *, generator=None): ) return self + @with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") + def frac(self, name=None): + return torch_frontend.frac(self._ivy_array) + @with_unsupported_dtypes( { "2.1.1 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index a4b88c6137f96..8ab5c29226aee 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -7088,6 +7088,44 @@ def test_torch_fmod_( ) +# frac +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="frac", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes(kind="valid"), + num_arrays=1, + max_value=1e6, + min_value=-1e6, + ), +) +def test_torch_frac( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + @handle_frontend_method( class_tree=CLASS_TREE, init_tree="torch.tensor", From 0984dae7599deb043d491e339eb7d908cb16a774 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Sat, 2 Dec 2023 07:29:16 +0000 Subject: [PATCH 280/978] Add __getstate__ and __setstate__ methods to frontend torch.nn.Module --- ivy/functional/frontends/torch/nn/modules/module.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index bba71b98e2a6e..319a9989ac9d9 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -312,3 +312,11 @@ def __dir__(self): keys = [key for key in keys if not key[0].isdigit()] return sorted(keys) + + def __getstate__(self): + state = self.__dict__.copy() + state.pop("_compiled_call_impl", None) + return state + + def __setstate__(self, state): + self.__dict__.update(state) From 2e1dab48170e7ce9d5f01099f3e973630ec6e538 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 3 Dec 2023 19:17:33 +0530 Subject: [PATCH 281/978] fix: Fixed typos (used `codespell` pre-commit hook) (#27426) Co-authored-by: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> --- ivy/data_classes/array/experimental/creation.py | 2 +- ivy/data_classes/container/base.py | 8 ++++---- ivy/data_classes/container/experimental/creation.py | 4 ++-- ivy/engines/XLA/rust_api/xla_rs/xla_rs.cc | 2 +- ivy/functional/ivy/experimental/activations.py | 2 +- ivy/functional/ivy/experimental/creation.py | 2 +- ivy/functional/ivy/general.py | 2 +- ivy/stateful/module.py | 2 +- .../helpers/hypothesis_helpers/general_helpers.py | 2 +- scripts/backend_generation/generate.py | 6 +++--- 10 files changed, 16 insertions(+), 16 deletions(-) diff --git a/ivy/data_classes/array/experimental/creation.py b/ivy/data_classes/array/experimental/creation.py index fdca1bcffabf3..6d814ee70f85b 100644 --- a/ivy/data_classes/array/experimental/creation.py +++ b/ivy/data_classes/array/experimental/creation.py @@ -335,7 +335,7 @@ def polyval( Returns ------- ret - Simplified result of substituing x in the coefficients - final value of + Simplified result of substituting x in the coefficients - final value of polynomial. Examples diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index 7addfcff8c52c..b7b35452b3cde 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -1602,7 +1602,7 @@ def _cont_prune_key_chains_input_as_dict(self, key_chains, return_cont=None): # ---------------# def cont_duplicate_array_keychains(self): - duplciates = () + duplicates = () key_chains = self.cont_all_key_chains() skips = set() for i in range(len(key_chains)): @@ -1618,9 +1618,9 @@ def cont_duplicate_array_keychains(self): if key_chains[j] not in temp_duplicates: temp_duplicates += (key_chains[j],) if len(temp_duplicates) > 0: - duplciates += (temp_duplicates,) - skips = chain.from_iterable(duplciates) - return duplciates + duplicates += (temp_duplicates,) + skips = chain.from_iterable(duplicates) + return duplicates def cont_update_config(self, **config): new_config = {} diff --git a/ivy/data_classes/container/experimental/creation.py b/ivy/data_classes/container/experimental/creation.py index 03a0184d81eaf..540162d93e6fe 100644 --- a/ivy/data_classes/container/experimental/creation.py +++ b/ivy/data_classes/container/experimental/creation.py @@ -1290,7 +1290,7 @@ def static_polyval( Returns ------- ret - Output container containing simplified result of substituing x in the + Output container containing simplified result of substituting x in the coefficients - final value of polynomial. """ return ContainerBase.cont_multi_map_in_function( @@ -1385,7 +1385,7 @@ def polyval( Returns ------- ret - Output container containing simplified result of substituing x in the + Output container containing simplified result of substituting x in the coefficients - final value of polynomial. """ return self.static_polyval(self, coeffs, x) diff --git a/ivy/engines/XLA/rust_api/xla_rs/xla_rs.cc b/ivy/engines/XLA/rust_api/xla_rs/xla_rs.cc index 6fa315da050fe..e4f19d746b0e6 100644 --- a/ivy/engines/XLA/rust_api/xla_rs/xla_rs.cc +++ b/ivy/engines/XLA/rust_api/xla_rs/xla_rs.cc @@ -1188,7 +1188,7 @@ status execute(const pjrt_loaded_executable exe, const literal *inputs, ASSIGN_OR_RETURN_STATUS(buffer, client->BufferFromHostLiteral(*inputs[i], device)); // Wait for the transfer to have completed to avoid the literal potentially - // getting out of scope before it has been transfered. + // getting out of scope before it has been transferred. MAYBE_RETURN_STATUS(buffer->GetReadyFuture().Await()); input_buffer_ptrs.push_back(buffer.release()); } diff --git a/ivy/functional/ivy/experimental/activations.py b/ivy/functional/ivy/experimental/activations.py index fe15ccc31721f..1b1fda6b32a08 100644 --- a/ivy/functional/ivy/experimental/activations.py +++ b/ivy/functional/ivy/experimental/activations.py @@ -799,7 +799,7 @@ def celu( out: Optional[ivy.Array] = None, ) -> ivy.Array: """ - Apply the Continously Differentiable Exponential Linear Unit (CELU) activation + Apply the Continuously Differentiable Exponential Linear Unit (CELU) activation function to each element of the input. Parameters diff --git a/ivy/functional/ivy/experimental/creation.py b/ivy/functional/ivy/experimental/creation.py index bbda425e2ccbe..ff9ed655f1592 100644 --- a/ivy/functional/ivy/experimental/creation.py +++ b/ivy/functional/ivy/experimental/creation.py @@ -1197,7 +1197,7 @@ def polyval( Returns ------- ret - Simplified result of substituing x in the coefficients - final value + Simplified result of substituting x in the coefficients - final value of polynomial. Examples diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index f0e7ad7af4f76..5406a86e8367f 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -2841,7 +2841,7 @@ def get_item( if query.ndim == 0: if query is False: return ivy.zeros(shape=(0,) + x.shape, dtype=x.dtype) - return x[None] # eqivalent to ivy.expand_dims(x, axis=0) + return x[None] # equivalent to ivy.expand_dims(x, axis=0) query = ivy.nonzero(query, as_tuple=False) ret = ivy.gather_nd(x, query) else: diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 41d5be1525d7b..b6f21663635b3 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -571,7 +571,7 @@ def __repr__(self): main_str += ")" return main_str - # Methods to be Optionally Overriden # + # Methods to be Optionally Overridden # # -----------------------------------# def _create_variables(self, *, device=None, dtype=None): diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 971a19bdee0b2..7662f4d2753f5 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -165,7 +165,7 @@ def general_helpers_dtype_info_helper(backend, kind_dtype, dtype): # from array-api repo class BroadcastError(ValueError): - """Shapes do not broadcast with eachother.""" + """Shapes do not broadcast with each other.""" # from array-api repo diff --git a/scripts/backend_generation/generate.py b/scripts/backend_generation/generate.py index ef2a7af9789f9..f10355a0148c2 100644 --- a/scripts/backend_generation/generate.py +++ b/scripts/backend_generation/generate.py @@ -268,9 +268,9 @@ def _update_valid_config_value(key): ret = ret.strip("") if ret == "": return True - indicies = ret.split(" ") - indicies = [int(item.strip(" ")) for item in indicies] - for i in sorted(indicies, reverse=True): + indices = ret.split(" ") + indices = [int(item.strip(" ")) for item in indices] + for i in sorted(indices, reverse=True): del config_valids[key][i] return True From 298c136eb1e2caaa61331bfe2a2bf9a4b2bdb3b2 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 3 Dec 2023 20:32:26 +0530 Subject: [PATCH 282/978] fix: Fixed passing of arguments in `get_referrers_recursive()` function call (#27428) Co-authored-by: NripeshN --- ivy/functional/ivy/general.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index 5406a86e8367f..879b3919c52d1 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -254,7 +254,11 @@ def get_referrers_recursive( def get_referrers_recursive_inner(): return get_referrers_recursive( - ref, depth + 1, max_depth, seen_set, local_set + ref, + depth=depth + 1, + max_depth=max_depth, + seen_set=seen_set, + local_set=local_set, ) this_repr = "tracked" if seen else str(ref).replace(" ", "") From 0cac502006b8474fbe3a04548e22b12786b49887 Mon Sep 17 00:00:00 2001 From: G544 <55620913+G544@users.noreply.github.com> Date: Mon, 4 Dec 2023 12:08:31 +0300 Subject: [PATCH 283/978] feat: add erfc_ to torch frontend (#27291) Co-authored-by: NripeshN --- ivy/functional/frontends/torch/tensor.py | 8 ++++ .../test_frontends/test_torch/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 66193ab80f063..01b9dd26665fe 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -11,6 +11,7 @@ ) from ivy.func_wrapper import with_unsupported_dtypes from ivy.func_wrapper import with_supported_dtypes +from ivy.func_wrapper import with_supported_device_and_dtypes from ivy.functional.frontends.torch.func_wrapper import ( _to_ivy_array, numpy_to_torch_style_args, @@ -518,6 +519,13 @@ def erf_(self, *, out=None): self.ivy_array = self.erf(out=out).ivy_array return self + @with_supported_device_and_dtypes( + {"2.1.0 and below": {"cpu": ("float32", "float64")}}, + "torch", + ) + def erfc_(self, *, out=None): + return torch_frontend.erfc(self, out=out) + def new_zeros( self, *args, diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 8ab5c29226aee..ec5010e2f2b4c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -12791,6 +12791,43 @@ def test_torch_tensor_corrcoef( ) +# erfc_ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="erfc_", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + ), +) +def test_torch_tensor_erfc_( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + rtol_=1e-2, + atol_=1e-2, + ) + + # positive @handle_frontend_method( class_tree=CLASS_TREE, From 454dd26756503bbdc0d3e8edca1723f11a03a3cb Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 4 Dec 2023 09:27:22 +0000 Subject: [PATCH 284/978] feat: add node_split_best function in sklearn frontend splitter submodule derived from https://github.com/scikit-learn/scikit-learn/blob/c6654f919601ec54436f7a24a94e0874a763a8a1/sklearn/tree/_splitter.pyx#L289C20-L289C20 --- .../frontends/sklearn/tree/_splitter.py | 210 +++++++++++++++++- 1 file changed, 208 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 037233038533f..4ece5b2c180a5 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -1,6 +1,7 @@ import ivy FEATURE_THRESHOLD = 1e-7 +INFINITY = ivy.inf class Splitter: @@ -244,6 +245,9 @@ def partition_samples_final( self.samples = samples +class SplitRecord: ... + + class BestSplitter(Splitter): def init( self, @@ -267,10 +271,212 @@ def node_split(self, impurity, split, n_constant_features): ) +# --- Helpers --- # +# --------------- # + + +def _init_split(split_record, start_pos): + return + + +# --- Main --- # +# ------------ # + + def node_split_best( - splitter: Splitter, partitioner, criterion, impurity, split, n_constant_features + splitter, partitioner, criterion, impurity, split, n_constant_features ): - pass + start = splitter.start + end = splitter.end + splitter.samples + features = splitter.features + constant_features = splitter.constant_features + n_features = splitter.n_features + + feature_values = splitter.feature_values + max_features = splitter.max_features + min_samples_leaf = splitter.min_samples_leaf + min_weight_leaf = splitter.min_weight_leaf + + best_split = SplitRecord() + current_split = SplitRecord() + current_proxy_improvement = -INFINITY + best_proxy_improvement = -INFINITY + + f_i = n_features + f_j = 0 + p = 0 + p_prev = 0 + + n_visited_features = 0 + # Number of features discovered to be constant during the split search + n_found_constants = 0 + # Number of features known to be constant and drawn without replacement + n_drawn_constants = 0 + n_known_constants = n_constant_features + # n_total_constants = n_known_constants + n_found_constants + n_total_constants = n_known_constants + best_split = _init_split(best_split, end) + partitioner.init_node_split(start, end) + while f_i > n_total_constants and ( + n_visited_features < max_features + or n_visited_features <= n_found_constants + n_drawn_constants + ): + n_visited_features += 1 + f_j = ivy.randint(n_drawn_constants, f_i - n_found_constants) + + if f_j < n_known_constants: + features[n_drawn_constants], features[f_j] = ( + features[f_j], + features[n_drawn_constants], + ) + + n_drawn_constants += 1 + continue + + # f_j in the interval [n_known_constants, f_i - n_found_constants[ + f_j += n_found_constants + # f_j in the interval [n_total_constants, f_i[ + current_split.feature = features[f_j] + partitioner.sort_samples_and_feature_values(current_split.feature) + n_missing = partitioner.n_missing + end_non_missing = end - n_missing + + if ( + end_non_missing == start + or feature_values[end_non_missing - 1] + <= feature_values[start] + FEATURE_THRESHOLD + ): + features[f_j], features[n_total_constants] = ( + features[n_total_constants], + features[f_j], + ) + + n_found_constants += 1 + n_total_constants += 1 + continue + + f_i -= 1 + features[f_i], features[f_j] = features[f_j], features[f_i] + has_missing = n_missing != 0 + criterion.init_missing(n_missing) + + n_searches = 2 if has_missing else 1 + + for i in range(n_searches): + missing_go_to_left = i == 1 + criterion.missing_go_to_left = missing_go_to_left + criterion.reset() + p = start + + while p < end_non_missing: + p_prev, p = partitioner.next_p(p_prev, p) + + if p >= end_non_missing: + continue + + if missing_go_to_left: + n_left = p - start + n_missing + n_right = end_non_missing - p + else: + n_left = p - start + n_right = end_non_missing - p + n_missing + + if n_left < min_samples_leaf or n_right < min_samples_leaf: + continue + + current_split.pos = p + criterion.update(current_split.pos) + + if ( + criterion.weighted_n_left < min_weight_leaf + or criterion.weighted_n_right < min_weight_leaf + ): + continue + + current_proxy_improvement = criterion.proxy_impurity_improvement() + + if current_proxy_improvement > best_proxy_improvement: + best_proxy_improvement = current_proxy_improvement + current_split.threshold = ( + feature_values[p_prev] / 2.0 + feature_values[p] / 2.0 + ) + + if ( + current_split.threshold == feature_values[p] + or current_split.threshold == INFINITY + or current_split.threshold == -INFINITY + ): + current_split.threshold = feature_values[p_prev] + + current_split.n_missing = n_missing + if n_missing == 0: + current_split.missing_go_to_left = n_left > n_right + else: + current_split.missing_go_to_left = missing_go_to_left + + best_split = SplitRecord(**current_split.__dict__) + + if has_missing: + n_left, n_right = end - start - n_missing, n_missing + p = end - n_missing + missing_go_to_left = 0 + + if not ((n_left < min_samples_leaf) or (n_right < min_samples_leaf)): + criterion.missing_go_to_left = missing_go_to_left + criterion.update(p) + + if not ( + criterion.weighted_n_left < min_weight_leaf + or criterion.weighted_n_right < min_weight_leaf + ): + current_proxy_improvement = criterion.proxy_impurity_improvement() + + if current_proxy_improvement > best_proxy_improvement: + best_proxy_improvement = current_proxy_improvement + current_split.threshold = INFINITY + current_split.missing_go_to_left = missing_go_to_left + current_split.n_missing = n_missing + current_split.pos = p + best_split = current_split + + # Reorganize into samples[start:best_split.pos] + samples[best_split.pos:end] + if best_split.pos < end: + partitioner.partition_samples_final( + best_split.pos, + best_split.threshold, + best_split.feature, + best_split.n_missing, + ) + + if best_split.n_missing != 0: + criterion.init_missing(best_split.n_missing) + + criterion.missing_go_to_left = best_split.missing_go_to_left + criterion.reset() + criterion.update(best_split.pos) + + ( + best_split.impurity_left, + best_split.impurity_right, + ) = criterion.children_impurity( + best_split.impurity_left, best_split.impurity_right + ) + + best_split.improvement = criterion.impurity_improvement( + impurity, best_split.impurity_left, best_split.impurity_right + ) + + # best_split, samples = shift_missing_values_to_left_if_required(best_split, samples, end) + # todo : implement shift_missing_values_to_left_if_required + features[0:n_known_constants] = constant_features[0:n_known_constants] + constant_features[n_known_constants:n_found_constants] = features[ + n_known_constants:n_found_constants + ] + + split = best_split + n_constant_features = n_total_constants + return 0, n_constant_features, split def sort(feature_values, samples, n): From c8d4b5ecf15a095a12cfee5c404d47d3810b54f6 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 4 Dec 2023 09:40:08 +0000 Subject: [PATCH 285/978] feat: define _init_split helper function used in node_split_best derived from https://github.com/scikit-learn/scikit-learn/blob/c6654f919601ec54436f7a24a94e0874a763a8a1/sklearn/tree/_splitter.pyx#L43 --- ivy/functional/frontends/sklearn/tree/_splitter.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 4ece5b2c180a5..5a7e5e324cc90 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -276,7 +276,15 @@ def node_split(self, impurity, split, n_constant_features): def _init_split(split_record, start_pos): - return + split_record.impurity_left = INFINITY + split_record.impurity_right = INFINITY + split_record.pos = start_pos + split_record.feature = 0 + split_record.threshold = 0.0 + split_record.improvement = -INFINITY + split_record.missing_go_to_left = False + split_record.n_missing = 0 + return split_record # --- Main --- # From ba399353f4d1268ccc35c8a714fcd2d10701167b Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 4 Dec 2023 09:47:07 +0000 Subject: [PATCH 286/978] feat: define SplitRecord class used for split structure in node best splitter function --- .../frontends/sklearn/tree/_splitter.py | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 5a7e5e324cc90..0960eeef81009 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -245,7 +245,26 @@ def partition_samples_final( self.samples = samples -class SplitRecord: ... +class SplitRecord: + def __init__( + self, + feature=0, + pos=0, + threshold=0.0, + improvement=-INFINITY, + impurity_left=0.0, + impurity_right=0.0, + missing_go_to_left=False, + n_missing=0, + ): + self.feature = feature + self.pos = pos + self.threshold = threshold + self.improvement = improvement + self.impurity_left = impurity_left + self.impurity_right = impurity_right + self.missing_go_to_left = missing_go_to_left + self.n_missing = n_missing class BestSplitter(Splitter): From 22e5820807ebafc529d5fd5bb06ede750181b3b6 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 4 Dec 2023 09:51:07 +0000 Subject: [PATCH 287/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/frontends/sklearn/tree/_splitter.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 0960eeef81009..a2c333d1ee675 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -1,7 +1,6 @@ import ivy FEATURE_THRESHOLD = 1e-7 -INFINITY = ivy.inf class Splitter: @@ -511,3 +510,4 @@ def sort(feature_values, samples, n): return idx = ivy.argsort(feature_values) return feature_values[idx], samples[idx] +INFINITY = ivy.inf From 9864b2914e4fa55a2272856af22e60651514a84c Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 4 Dec 2023 09:52:44 +0000 Subject: [PATCH 288/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/frontends/sklearn/tree/_splitter.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index a2c333d1ee675..6ea7e810e4022 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -510,4 +510,6 @@ def sort(feature_values, samples, n): return idx = ivy.argsort(feature_values) return feature_values[idx], samples[idx] + + INFINITY = ivy.inf From b016d25d3324d1b6cb15da388e34f54c4fba884b Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 4 Dec 2023 10:29:24 +0000 Subject: [PATCH 289/978] fix: use ivy.inf temporarily cutting out INFINITY constant to avoid undefined behaviour caused by the lintbot --- .../frontends/sklearn/tree/_splitter.py | 21 ++++++++----------- 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 6ea7e810e4022..af172e77e3646 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -250,7 +250,7 @@ def __init__( feature=0, pos=0, threshold=0.0, - improvement=-INFINITY, + improvement=-ivy.inf, impurity_left=0.0, impurity_right=0.0, missing_go_to_left=False, @@ -294,12 +294,12 @@ def node_split(self, impurity, split, n_constant_features): def _init_split(split_record, start_pos): - split_record.impurity_left = INFINITY - split_record.impurity_right = INFINITY + split_record.impurity_left = ivy.inf + split_record.impurity_right = ivy.inf split_record.pos = start_pos split_record.feature = 0 split_record.threshold = 0.0 - split_record.improvement = -INFINITY + split_record.improvement = -ivy.inf split_record.missing_go_to_left = False split_record.n_missing = 0 return split_record @@ -326,8 +326,8 @@ def node_split_best( best_split = SplitRecord() current_split = SplitRecord() - current_proxy_improvement = -INFINITY - best_proxy_improvement = -INFINITY + current_proxy_improvement = -ivy.inf + best_proxy_improvement = -ivy.inf f_i = n_features f_j = 0 @@ -430,8 +430,8 @@ def node_split_best( if ( current_split.threshold == feature_values[p] - or current_split.threshold == INFINITY - or current_split.threshold == -INFINITY + or current_split.threshold == ivy.inf + or current_split.threshold == -ivy.inf ): current_split.threshold = feature_values[p_prev] @@ -460,7 +460,7 @@ def node_split_best( if current_proxy_improvement > best_proxy_improvement: best_proxy_improvement = current_proxy_improvement - current_split.threshold = INFINITY + current_split.threshold = ivy.inf current_split.missing_go_to_left = missing_go_to_left current_split.n_missing = n_missing current_split.pos = p @@ -510,6 +510,3 @@ def sort(feature_values, samples, n): return idx = ivy.argsort(feature_values) return feature_values[idx], samples[idx] - - -INFINITY = ivy.inf From 6a7517784ea9c062b3735def4bb81c10d8989078 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 4 Dec 2023 11:14:31 +0000 Subject: [PATCH 290/978] refactor: remove unwanted variables in node_split_best in sklearn frontend splitter moduel --- ivy/functional/frontends/sklearn/tree/_splitter.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index af172e77e3646..0461682204e72 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -314,7 +314,6 @@ def node_split_best( ): start = splitter.start end = splitter.end - splitter.samples features = splitter.features constant_features = splitter.constant_features n_features = splitter.n_features @@ -326,12 +325,9 @@ def node_split_best( best_split = SplitRecord() current_split = SplitRecord() - current_proxy_improvement = -ivy.inf best_proxy_improvement = -ivy.inf f_i = n_features - f_j = 0 - p = 0 p_prev = 0 n_visited_features = 0 From d7aedb56a6bd51c5d751be70de463671dc61ea78 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 4 Dec 2023 21:34:01 +0530 Subject: [PATCH 291/978] fix: Fixed order of functions and added missing `staticmethod` decorator (#27436) --- .../container/experimental/creation.py | 105 +++++++++--------- 1 file changed, 53 insertions(+), 52 deletions(-) diff --git a/ivy/data_classes/container/experimental/creation.py b/ivy/data_classes/container/experimental/creation.py index 540162d93e6fe..fc861420bc843 100644 --- a/ivy/data_classes/container/experimental/creation.py +++ b/ivy/data_classes/container/experimental/creation.py @@ -1252,57 +1252,6 @@ def static_unsorted_segment_mean( map_sequences=map_sequences, ) - def static_polyval( - coeffs: ivy.Container, - x: Union[ivy.Container, int, float], - *, - key_chains: Optional[Union[List[str], Dict[str, str]]] = None, - to_apply: bool = True, - prune_unapplied: bool = False, - map_sequences: bool = False, - ) -> ivy.Container: - r""" - ivy.Container static method variant of ivy.polyval. This method simply wraps the - function, and so the docstring for ivy.polyval also applies to this method with - minimal changes. - - Evaluate and return a polynomial at specific given values. - - Parameters - ---------- - coeffs - Polynomial coefficients (including zero) from highest degree - to constant term. - x - The value of the indeterminate variable at which to evaluate the polynomial. - key_chains - The key-chains to apply or not apply the method to. Default is ``None``. - to_apply - If True, the method will be applied to key_chains, otherwise key_chains - will be skipped. Default is ``True``. - prune_unapplied - Whether to prune key_chains for which the function was not applied. - Default is ``False``. - map_sequences - Whether to also map method to sequences (lists, tuples). - Default is ``False``. - - Returns - ------- - ret - Output container containing simplified result of substituting x in the - coefficients - final value of polynomial. - """ - return ContainerBase.cont_multi_map_in_function( - "polyval", - coeffs, - x, - key_chains=key_chains, - to_apply=to_apply, - prune_unapplied=prune_unapplied, - map_sequences=map_sequences, - ) - def unsorted_segment_mean( self: ivy.Container, segment_ids: Union[ivy.Array, ivy.Container], @@ -1359,6 +1308,58 @@ def unsorted_segment_mean( num_segments, ) + @staticmethod + def static_polyval( + coeffs: ivy.Container, + x: Union[ivy.Container, int, float], + *, + key_chains: Optional[Union[List[str], Dict[str, str]]] = None, + to_apply: bool = True, + prune_unapplied: bool = False, + map_sequences: bool = False, + ) -> ivy.Container: + r""" + ivy.Container static method variant of ivy.polyval. This method simply wraps the + function, and so the docstring for ivy.polyval also applies to this method with + minimal changes. + + Evaluate and return a polynomial at specific given values. + + Parameters + ---------- + coeffs + Polynomial coefficients (including zero) from highest degree + to constant term. + x + The value of the indeterminate variable at which to evaluate the polynomial. + key_chains + The key-chains to apply or not apply the method to. Default is ``None``. + to_apply + If True, the method will be applied to key_chains, otherwise key_chains + will be skipped. Default is ``True``. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + + Returns + ------- + ret + Output container containing simplified result of substituting x in the + coefficients - final value of polynomial. + """ + return ContainerBase.cont_multi_map_in_function( + "polyval", + coeffs, + x, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + def polyval( self: ivy.Container, coeffs: ivy.Container, @@ -1388,4 +1389,4 @@ def polyval( Output container containing simplified result of substituting x in the coefficients - final value of polynomial. """ - return self.static_polyval(self, coeffs, x) + return self.static_polyval(coeffs, x) From 08bd6dcba63375addb28539bd8ad591878330305 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 4 Dec 2023 21:34:40 +0530 Subject: [PATCH 292/978] fix: Fixed raising `TypeError` exception instead or `ValueError` exception for invalid type (#27439) --- ivy/compiler/replace_with.py | 2 +- ivy/functional/frontends/jax/numpy/fft.py | 2 +- ivy/functional/frontends/jax/numpy/indexing.py | 2 +- .../frontends/numpy/fft/discrete_fourier_transform.py | 4 ++-- ivy/functional/frontends/paddle/nn/functional/vision.py | 4 ++-- ivy/functional/frontends/torch/nn/modules/module.py | 2 +- ivy/utils/assertions.py | 2 +- 7 files changed, 9 insertions(+), 9 deletions(-) diff --git a/ivy/compiler/replace_with.py b/ivy/compiler/replace_with.py index 3bbab72988447..b19d8b84dc03c 100644 --- a/ivy/compiler/replace_with.py +++ b/ivy/compiler/replace_with.py @@ -15,7 +15,7 @@ def replace_with(new_func): def decorator(original_func): if not callable(original_func) or not callable(new_func): - raise ValueError( + raise TypeError( f"Both '{original_func.__name__}' and '{new_func.__name__}' should be" " callable." ) diff --git a/ivy/functional/frontends/jax/numpy/fft.py b/ivy/functional/frontends/jax/numpy/fft.py index 69b9415b6176b..5732511ac8838 100644 --- a/ivy/functional/frontends/jax/numpy/fft.py +++ b/ivy/functional/frontends/jax/numpy/fft.py @@ -24,7 +24,7 @@ def fftfreq(n, d=1.0, *, dtype=None): if not isinstance( n, (int, type(ivy.int8), type(ivy.int16), type(ivy.int32), type(ivy.int64)) ): - raise ValueError("n should be an integer") + raise TypeError("n should be an integer") dtype = ivy.float64 if dtype is None else ivy.as_ivy_dtype(dtype) diff --git a/ivy/functional/frontends/jax/numpy/indexing.py b/ivy/functional/frontends/jax/numpy/indexing.py index 54e7ee79028ae..1e0b778bd9aa6 100644 --- a/ivy/functional/frontends/jax/numpy/indexing.py +++ b/ivy/functional/frontends/jax/numpy/indexing.py @@ -52,7 +52,7 @@ def __getitem__(self, key): newobj = _make_1d_grid_from_slice(item) item_ndim = 0 elif isinstance(item, str): - raise ValueError("string directive must be placed at the beginning") + raise TypeError("string directive must be placed at the beginning") else: newobj = array(item, copy=False) item_ndim = newobj.ndim diff --git a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py index 609d4e303072b..d98660c654e4b 100644 --- a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py +++ b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py @@ -31,7 +31,7 @@ def fftfreq(n, d=1.0): if not isinstance( n, (int, type(ivy.int8), type(ivy.int16), type(ivy.int32), type(ivy.int64)) ): - raise ValueError("n should be an integer") + raise TypeError("n should be an integer") N = (n - 1) // 2 + 1 val = 1.0 / (n * d) @@ -135,7 +135,7 @@ def rfftfreq(n, d=1.0): if not isinstance( n, (int, type(ivy.int8), type(ivy.int16), type(ivy.int32), type(ivy.int64)) ): - raise ValueError("n should be an integer") + raise TypeError("n should be an integer") val = 1.0 / (n * d) N = n // 2 + 1 diff --git a/ivy/functional/frontends/paddle/nn/functional/vision.py b/ivy/functional/frontends/paddle/nn/functional/vision.py index 5f25344dd0a34..935ce239a7dbb 100644 --- a/ivy/functional/frontends/paddle/nn/functional/vision.py +++ b/ivy/functional/frontends/paddle/nn/functional/vision.py @@ -118,7 +118,7 @@ def pixel_shuffle(x, upscale_factor, data_format="NCHW"): ) if not isinstance(upscale_factor, int): - raise ValueError("upscale factor must be int type") + raise TypeError("upscale factor must be int type") if data_format not in ["NCHW", "NHWC"]: raise ValueError( @@ -172,7 +172,7 @@ def pixel_unshuffle(x, downscale_factor, data_format="NCHW"): ) if not isinstance(downscale_factor, int): - raise ValueError("Downscale factor must be int type") + raise TypeError("Downscale factor must be int type") if downscale_factor <= 0: raise ValueError("Downscale factor must be positive") diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 319a9989ac9d9..31f30e4ad0b1e 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -147,7 +147,7 @@ def get_submodule(self, target: str) -> "Module": mod = getattr(mod, item) if not isinstance(mod, Module): - raise AttributeError("`" + item + "` is not an nn.Module") + raise TypeError("`" + item + "` is not an nn.Module") return mod diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index 3ce9cb927f8be..77f4cce892390 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -184,7 +184,7 @@ def check_same_dtype(x1, x2, message=""): def check_unsorted_segment_valid_params(data, segment_ids, num_segments): if not isinstance(num_segments, int): - raise ValueError("num_segments must be of integer type") + raise TypeError("num_segments must be of integer type") valid_dtypes = [ ivy.int32, From 541a68cccc12fdb449bbcd34332e5ae1b6a2a1fc Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Mon, 4 Dec 2023 16:08:13 +0000 Subject: [PATCH 293/978] fix: Add a check in the converters to filter any NoneType model parameters when doing a to_keras_module on an ivy.Module instance --- ivy/stateful/converters.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index 599b5532d0a24..b3d78f296f6cf 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -476,13 +476,19 @@ def _assign_variables(self): ), ) self._ivy_module.v.cont_map( - lambda x, kc: self.add_weight( - name=kc, shape=x.shape, dtype=x.dtype, trainable=True + lambda x, kc: ( + self.add_weight( + name=kc, shape=x.shape, dtype=x.dtype, trainable=True + ) + if x is not None + else x ) ) model_weights = [] self._ivy_module.v.cont_map( - lambda x, kc: model_weights.append(ivy.to_numpy(x)) + lambda x, kc: ( + model_weights.append(ivy.to_numpy(x)) if x is not None else x + ) ) self.set_weights(model_weights) From e0c5d0992ca2ad689a9adceeafed5030c5cbdcd3 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 5 Dec 2023 20:56:42 +0530 Subject: [PATCH 294/978] refactor: Refactored to make the code more readable and better. (#27424) --- ivy/data_classes/array/conversions.py | 2 +- ivy/data_classes/container/container.py | 8 ++--- .../backends/jax/experimental/losses.py | 4 +-- .../backends/numpy/experimental/losses.py | 8 ++--- .../backends/paddle/experimental/losses.py | 8 ++--- ivy/functional/backends/tensorflow/device.py | 2 +- .../tensorflow/experimental/losses.py | 8 ++--- ivy/functional/backends/torch/sorting.py | 4 +-- ivy/functional/frontends/jax/numpy/fft.py | 2 +- ivy/functional/frontends/jax/numpy/linalg.py | 2 +- .../jax/numpy/mathematical_functions.py | 4 +-- .../frontends/numpy/broadcast/methods.py | 2 +- .../numpy/fft/discrete_fourier_transform.py | 2 +- ...olving_equations_and_inverting_matrices.py | 2 +- .../frontends/tensorflow/general_functions.py | 7 ++-- ivy/functional/frontends/torch/linalg.py | 2 +- .../frontends/torch/nn/modules/module.py | 32 ++++++++----------- ivy/stateful/converters.py | 4 +-- ivy/utils/einsum_path_helpers.py | 2 +- .../hypothesis_helpers/array_helpers.py | 6 ++-- .../test_jax/test_lax/test_linalg.py | 6 ++-- .../test_jax/test_numpy/test_linalg.py | 18 +++++------ .../test_frontends/test_jax/test_random.py | 4 +-- .../test_linalg/test_decompositions.py | 4 +-- .../test_matrix_and_vector_products.py | 2 +- .../test_linalg/test_matrix_eigenvalues.py | 6 ++-- ...olving_equations_and_inverting_matrices.py | 2 +- .../test_frontends/test_paddle/test_linalg.py | 4 +-- .../test_frontends/test_paddle/test_math.py | 2 +- .../test_scipy/test_linalg/test_linalg.py | 6 ++-- .../test_keras/test_activations.py | 6 ++-- .../test_tensorflow/test_linalg.py | 20 ++++++------ .../test_tensorflow/test_math.py | 12 +++---- .../test_tensorflow/test_raw_ops.py | 8 ++--- .../test_torch/test_blas_and_lapack_ops.py | 2 +- .../test_frontends/test_torch/test_tensor.py | 2 +- .../test_functional/test_core/test_linalg.py | 12 +++---- .../test_core/test_manipulation.py | 2 +- .../test_backend_handler.py | 2 +- scripts/test_dependencies.py | 2 +- 40 files changed, 111 insertions(+), 122 deletions(-) diff --git a/ivy/data_classes/array/conversions.py b/ivy/data_classes/array/conversions.py index 2020b1f2306c4..988286408e763 100644 --- a/ivy/data_classes/array/conversions.py +++ b/ivy/data_classes/array/conversions.py @@ -342,7 +342,7 @@ def args_to_new_backend( *args: Iterable[Any], native: bool = True, shallow: bool = True, - include_derived: Dict[str, bool] = None, + include_derived: Optional[Dict[str, bool]] = None, cont_inplace: bool = False, to_ignore: Optional[Union[type, Tuple[type]]] = None, **kwargs: Dict[str, Any], diff --git a/ivy/data_classes/container/container.py b/ivy/data_classes/container/container.py index b41def052fd73..cc7d4fcf1b6dc 100644 --- a/ivy/data_classes/container/container.py +++ b/ivy/data_classes/container/container.py @@ -435,18 +435,14 @@ def __imod__(self, other): def __divmod__(self, other): return ivy.Container.cont_multi_map( - lambda xs, _: tuple([ - operator.truediv(xs[0], xs[1]), operator.mod(xs[0], xs[1]) - ]), + lambda xs, _: (operator.truediv(xs[0], xs[1]), operator.mod(xs[0], xs[1])), [self, other], map_nests=True, ) def __rdivmod__(self, other): return ivy.Container.cont_multi_map( - lambda xs, _: tuple([ - operator.truediv(xs[0], xs[1]), operator.mod(xs[0], xs[1]) - ]), + lambda xs, _: (operator.truediv(xs[0], xs[1]), operator.mod(xs[0], xs[1])), [other, self], map_nests=True, ) diff --git a/ivy/functional/backends/jax/experimental/losses.py b/ivy/functional/backends/jax/experimental/losses.py index bb7e3e3020d50..5b39d166bc5ff 100644 --- a/ivy/functional/backends/jax/experimental/losses.py +++ b/ivy/functional/backends/jax/experimental/losses.py @@ -105,8 +105,8 @@ def _validate_poisson_nll_params( # Validate shape if input.shape != label.shape: raise ValueError( - "The shape of 'input' (%s) must be the same as the shape of 'label' (%s)." - % (input.shape, label.shape) + f"The shape of 'input' ({input.shape}) must be the same as the shape of" + f" 'label' ({label.shape})." ) return True diff --git a/ivy/functional/backends/numpy/experimental/losses.py b/ivy/functional/backends/numpy/experimental/losses.py index 9da5beb3a95f8..bf34147ac80ec 100644 --- a/ivy/functional/backends/numpy/experimental/losses.py +++ b/ivy/functional/backends/numpy/experimental/losses.py @@ -98,8 +98,8 @@ def _validate_poisson_nll_params( for parameter, name in zip([input, label], ["input", "label"]): if parameter.dtype not in allowed_dtypes: raise ValueError( - "The dtype of '%s' in poisson_nll_loss should be one of %s, but" - " received %s." % (name, allowed_dtypes, parameter.dtype) + f"The dtype of '{name}' in poisson_nll_loss should be one of" + f" {allowed_dtypes}, but received {parameter.dtype}." ) # Validate epsilon @@ -119,8 +119,8 @@ def _validate_poisson_nll_params( # Validate shape if input.shape != label.shape: raise ValueError( - "The shape of 'input' (%s) must be the same as the shape of 'label' (%s)." - % (input.shape, label.shape) + f"The shape of 'input' ({input.shape}) must be the same as the shape of" + f" 'label' ({label.shape})." ) return True diff --git a/ivy/functional/backends/paddle/experimental/losses.py b/ivy/functional/backends/paddle/experimental/losses.py index a6a4b4973bf89..665720fbe0df7 100644 --- a/ivy/functional/backends/paddle/experimental/losses.py +++ b/ivy/functional/backends/paddle/experimental/losses.py @@ -165,8 +165,8 @@ def _validate_poisson_nll_params( for parameter, name in zip([input, label], ["input", "label"]): if parameter.dtype not in allowed_dtypes: raise ValueError( - "The dtype of '%s' in poisson_nll_loss should be one of %s, but" - " received %s." % (name, allowed_dtypes, parameter.dtype) + f"The dtype of '{name}' in poisson_nll_loss should be one of" + f" {allowed_dtypes}, but received {parameter.dtype}." ) # Validate epsilon @@ -186,8 +186,8 @@ def _validate_poisson_nll_params( # Validate shape if input.shape != label.shape: raise ValueError( - "The shape of 'input' (%s) must be the same as the shape of 'label' (%s)." - % (input.shape, label.shape) + f"The shape of 'input' ({input.shape}) must be the same as the shape of" + f" 'label' ({label.shape})." ) return True diff --git a/ivy/functional/backends/tensorflow/device.py b/ivy/functional/backends/tensorflow/device.py index cff1e2e23c627..bec64860d54a4 100644 --- a/ivy/functional/backends/tensorflow/device.py +++ b/ivy/functional/backends/tensorflow/device.py @@ -66,7 +66,7 @@ def as_ivy_dev(device: str, /): dev_type = dev_type.lower() if dev_type == "cpu": return ivy.Device(dev_type) - return ivy.Device(":".join([dev_type, dev_idx])) + return ivy.Device(f"{dev_type}:{dev_idx}") def as_native_dev(device: str, /): diff --git a/ivy/functional/backends/tensorflow/experimental/losses.py b/ivy/functional/backends/tensorflow/experimental/losses.py index 6b7f032cb2060..cffbd02cee440 100644 --- a/ivy/functional/backends/tensorflow/experimental/losses.py +++ b/ivy/functional/backends/tensorflow/experimental/losses.py @@ -88,8 +88,8 @@ def _validate_poisson_nll_params( for parameter, name in zip([input, label], ["input", "label"]): if parameter.dtype not in allowed_dtypes: raise ValueError( - "The dtype of '%s' in poisson_nll_loss should be one of %s, but" - " received %s." % (name, allowed_dtypes, parameter.dtype) + f"The dtype of '{name}' in poisson_nll_loss should be one of" + f" {allowed_dtypes}, but received {parameter.dtype}." ) # Validate epsilon @@ -109,8 +109,8 @@ def _validate_poisson_nll_params( # Validate shape if input.shape != label.shape: raise ValueError( - "The shape of 'input' (%s) must be the same as the shape of 'label' (%s)." - % (input.shape, label.shape) + f"The shape of 'input' ({input.shape}) must be the same as the shape of" + f" 'label' ({label.shape})." ) return True diff --git a/ivy/functional/backends/torch/sorting.py b/ivy/functional/backends/torch/sorting.py index 9e474c01d1816..7d5f34341267c 100644 --- a/ivy/functional/backends/torch/sorting.py +++ b/ivy/functional/backends/torch/sorting.py @@ -19,7 +19,7 @@ def argsort( out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if out is not None: - out = tuple([torch.zeros(x.shape, dtype=x.dtype), out.long()]) + out = (torch.zeros(x.shape, dtype=x.dtype), out.long()) _, sorted_indices = torch.sort( x, dim=axis, descending=descending, stable=stable, out=out ) @@ -40,7 +40,7 @@ def sort( out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if out is not None: - out = tuple([out, torch.zeros(out.shape, dtype=torch.long)]) + out = (out, torch.zeros(out.shape, dtype=torch.long)) sorted_tensor, _ = torch.sort( x, dim=axis, descending=descending, stable=stable, out=out ) diff --git a/ivy/functional/frontends/jax/numpy/fft.py b/ivy/functional/frontends/jax/numpy/fft.py index 5732511ac8838..e8c18e016caf8 100644 --- a/ivy/functional/frontends/jax/numpy/fft.py +++ b/ivy/functional/frontends/jax/numpy/fft.py @@ -31,7 +31,7 @@ def fftfreq(n, d=1.0, *, dtype=None): N = (n - 1) // 2 + 1 val = 1.0 / (n * d) - results = ivy.zeros(tuple([n]), dtype=dtype) + results = ivy.zeros((n,), dtype=dtype) results[:N] = ivy.arange(0, N, dtype=dtype) results[N:] = ivy.arange(-(n // 2), 0, dtype=dtype) diff --git a/ivy/functional/frontends/jax/numpy/linalg.py b/ivy/functional/frontends/jax/numpy/linalg.py index 90a1a7449e765..1a34220713653 100644 --- a/ivy/functional/frontends/jax/numpy/linalg.py +++ b/ivy/functional/frontends/jax/numpy/linalg.py @@ -139,7 +139,7 @@ def tensorinv(a, ind=2): raise ValueError("Invalid ind argument.") a = ivy.reshape(a, shape=(prod, -1)) ia = ivy.inv(a) - new_shape = tuple([*invshape]) + new_shape = (*invshape,) return Array(ivy.reshape(ia, shape=new_shape)) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 1dc1f43e42fa8..c8a607f689ced 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -181,7 +181,7 @@ def divide(x1, x2, /): @to_ivy_arrays_and_back def divmod(x1, x2, /): x1, x2 = promote_types_of_jax_inputs(x1, x2) - return tuple([ivy.floor_divide(x1, x2), ivy.remainder(x1, x2)]) + return (ivy.floor_divide(x1, x2), ivy.remainder(x1, x2)) @to_ivy_arrays_and_back @@ -237,7 +237,7 @@ def einsum_path(subscripts, *operands, optimize="greedy"): path_type = path_type[0] else: - raise TypeError("Did not understand the path: %s" % str(path_type)) + raise TypeError(f"Did not understand the path: {str(path_type)}") # Python side parsing if subscripts: diff --git a/ivy/functional/frontends/numpy/broadcast/methods.py b/ivy/functional/frontends/numpy/broadcast/methods.py index c029d51abdf3f..eeaf072c66f78 100644 --- a/ivy/functional/frontends/numpy/broadcast/methods.py +++ b/ivy/functional/frontends/numpy/broadcast/methods.py @@ -12,7 +12,7 @@ def __init__(self, *args): self._index = 0 self._numiter = len(data) self._size = data[0].size - self._data = tuple((*zip(*(ivy.flatten(i) for i in data)),)) + self._data = (*zip(*(ivy.flatten(i) for i in data)),) self._iters = tuple(iter(ivy.flatten(i)) for i in data) @property diff --git a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py index d98660c654e4b..796f1521b0aa0 100644 --- a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py +++ b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py @@ -35,7 +35,7 @@ def fftfreq(n, d=1.0): N = (n - 1) // 2 + 1 val = 1.0 / (n * d) - results = ivy.empty(tuple([n]), dtype=int) + results = ivy.empty((n,), dtype=int) p1 = ivy.arange(0, N, dtype=int) results[:N] = p1 diff --git a/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py b/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py index 5aff9e9fa56f3..e6c504d83f360 100644 --- a/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py +++ b/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py @@ -59,5 +59,5 @@ def tensorinv(a, ind=2): raise ValueError("Invalid ind argument.") a = ivy.reshape(a, shape=(prod, -1)) ia = ivy.inv(a) - new_shape = tuple([*invshape]) + new_shape = (*invshape,) return ivy.reshape(ia, shape=new_shape) diff --git a/ivy/functional/frontends/tensorflow/general_functions.py b/ivy/functional/frontends/tensorflow/general_functions.py index 065a69852ed83..d96945f4e82f9 100644 --- a/ivy/functional/frontends/tensorflow/general_functions.py +++ b/ivy/functional/frontends/tensorflow/general_functions.py @@ -86,10 +86,9 @@ def clip_by_norm(t, clip_norm, axes=None): l2sum_safe = ivy.where(pred, l2sum, ivy.ones_like(l2sum)) l2norm = ivy.where(pred, ivy.sqrt(l2sum_safe), l2sum) intermediate = t * clip_norm - assert t.shape == intermediate.shape, "Dimensions %s and %s are not compatible" % ( - t.shape, - intermediate.shape, - ) + assert ( + t.shape == intermediate.shape + ), f"Dimensions {t.shape} and {intermediate.shape} are not compatible" t_clip = intermediate / ivy.maximum(l2norm, clip_norm) return t_clip diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index 7f5e9d87b4de6..b3a5e36743d34 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -341,7 +341,7 @@ def tensorinv(input, ind=2, *, out=None): assert prod_ind_end == prod_ind_start, f"{prod_cond}." inverse_shape = shape_ind_start + shape_ind_end input = ivy.reshape(input, shape=(prod_ind_end, -1)) - inverse_shape_tuple = tuple([*inverse_shape]) + inverse_shape_tuple = (*inverse_shape,) assert inv_ex(input, check_errors=True), f"{not_invertible}." inverse_tensor = ivy.inv(input) return ivy.reshape(inverse_tensor, shape=inverse_shape_tuple, out=out) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 31f30e4ad0b1e..c59e52b5eb97c 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -26,8 +26,8 @@ def __init__(self, *args, device=None, devices=None, **kwargs) -> None: **kwargs, ) super().__setattr__("_frontend_module", True) - super().__setattr__("_nonetype_param_dict", dict()) - super().__setattr__("_nonetype_buffers_dict", dict()) + super().__setattr__("_nonetype_param_dict", {}) + super().__setattr__("_nonetype_buffers_dict", {}) super().__setattr__( "_attr_mapping", {"_parameters": "v", "_modules": "module_dict"} ) @@ -36,13 +36,11 @@ def _create_variables(self, device=None, dtype=None): # Create variables stored in the `__dict__` that were set # using direct `__setattr__` e.g. self.weight = ... v = ivy.Container( - OrderedDict( - ([ - (k.replace(".", "/"), v) - for k, v in self.__dict__.items() - if isinstance(v, Parameter) - ]) - ), + OrderedDict([ + (k.replace(".", "/"), v) + for k, v in self.__dict__.items() + if isinstance(v, Parameter) + ]), dynamic_backend=self._dynamic_backend, ) # Created variables that were added using `register_paramter`, @@ -50,16 +48,12 @@ def _create_variables(self, device=None, dtype=None): v = ( ivy.Container( OrderedDict( - ( - dict( - ( - (_k.replace(".", "/"), _v) - for (_k, _v) in self._v.items() - if _k.replace(".", "/") not in v - and not isinstance(_v, ivy.Container) - ) - ) - ), + ({ + _k.replace(".", "/"): _v + for (_k, _v) in self._v.items() + if _k.replace(".", "/") not in v + and not isinstance(_v, ivy.Container) + }), **v, ) ) diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index b3d78f296f6cf..1f91646840b5f 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -458,7 +458,7 @@ def to_keras_module(self): class KerasModel(tf.keras.Model): def __init__(self, ivy_module): - super(KerasModel, self).__init__() + super().__init__() self._ivy_module = ivy_module self._parameters = {} self._assign_variables() @@ -539,7 +539,7 @@ def __call__(self, *args, **kwargs): ivy.previous_backend() else: args, kwargs = ivy.args_to_new_backend(*args, native=True, **kwargs) - return super(KerasModel, self).__call__(*args, **kwargs) + return super().__call__(*args, **kwargs) def to_device(self, device): self._ivy_module._module_graph.to_device(device) diff --git a/ivy/utils/einsum_path_helpers.py b/ivy/utils/einsum_path_helpers.py index c627bc0894962..4dfe63aef2dca 100644 --- a/ivy/utils/einsum_path_helpers.py +++ b/ivy/utils/einsum_path_helpers.py @@ -633,7 +633,7 @@ def parse_einsum_input(operands, subscripts=None): # Make sure output subscripts are in the input for char in output_subscript: if char not in input_subscripts: - raise ValueError("Output character %s did not appear in the input" % char) + raise ValueError(f"Output character {char} did not appear in the input") # Make sure number operands is equivalent to the number of terms if len(input_subscripts.split(",")) != len(operands): diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py index fe9eb99c44bdb..0de8cfe26b10c 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py @@ -2022,7 +2022,7 @@ def create_nested_input(draw, dimensions, leaf_values): def cond_data_gen_helper(draw): dtype_x = helpers.dtype_and_values( available_dtypes=["float32", "float64"], - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), max_value=10, min_value=-10, allow_nan=False, @@ -2056,7 +2056,7 @@ def get_first_solve_matrix(draw, adjoint=True): matrix = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([shared_size, shared_size]), + shape=(shared_size, shared_size), min_value=2, max_value=5, ).filter(lambda x: np.linalg.cond(x) < 1 / sys.float_info.epsilon) @@ -2086,7 +2086,7 @@ def get_second_solve_matrix(draw): ) return input_dtype, draw( helpers.array_values( - dtype=input_dtype, shape=tuple([shared_size, 1]), min_value=2, max_value=5 + dtype=input_dtype, shape=(shared_size, 1), min_value=2, max_value=5 ) ) diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_linalg.py index bc5ec8da88181..789512cb08421 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_linalg.py @@ -16,7 +16,7 @@ available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -64,7 +64,7 @@ def test_jax_cholesky( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -165,7 +165,7 @@ def test_jax_qr( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py index 721dd7e1fcf70..0924ab4d14c21 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py @@ -148,7 +148,7 @@ def norm_helper(draw): available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -248,7 +248,7 @@ def test_jax_det( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -306,7 +306,7 @@ def test_jax_eig( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -368,7 +368,7 @@ def test_jax_eigh( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -423,7 +423,7 @@ def test_jax_eigvals( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -468,7 +468,7 @@ def test_jax_eigvalsh( available_dtypes=helpers.get_dtypes("float"), min_value=-100, max_value=100, - shape=helpers.ints(min_value=1, max_value=10).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=1, max_value=10).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -541,7 +541,7 @@ def test_jax_lstsq( available_dtypes=helpers.get_dtypes("float"), min_value=-100, max_value=100, - shape=helpers.ints(min_value=1, max_value=10).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=1, max_value=10).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -612,7 +612,7 @@ def test_jax_matrix_rank( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), num_arrays=2, shared_dtype=True, ).filter( @@ -857,7 +857,7 @@ def test_jax_solve( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_random.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_random.py index ab55689f7c711..ed6724403e7cd 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_random.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_random.py @@ -80,7 +80,7 @@ def get_mean_cov_vector(draw): dtype_mean = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([shared_size]), + shape=(shared_size,), min_value=2, max_value=5, ) @@ -90,7 +90,7 @@ def get_mean_cov_vector(draw): dtype_cov = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([shared_size, shared_size]), + shape=(shared_size, shared_size), min_value=2, max_value=5, ).filter(lambda x: np.linalg.cond(x.tolist()) < 1 / sys.float_info.epsilon) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_decompositions.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_decompositions.py index fee1e0e77c29e..f740b7278dacb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_decompositions.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_decompositions.py @@ -18,7 +18,7 @@ available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: np.linalg.cond(x[1][0]) < 1 / sys.float_info.epsilon and np.linalg.det(x[1][0]) != 0 @@ -87,7 +87,7 @@ def test_numpy_qr( available_dtypes=helpers.get_dtypes("float"), min_value=0.1, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), full_matrices=st.booleans(), compute_uv=st.booleans(), diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py index a3dd357e34cfe..db40d797d4039 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py @@ -322,7 +322,7 @@ def test_numpy_matmul( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=50, - shape=helpers.ints(min_value=2, max_value=8).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=8).map(lambda x: (x, x)), ), n=helpers.ints(min_value=1, max_value=8), test_with_out=st.just(False), diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py index b76655cf0897d..d4015efc19a21 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py @@ -22,7 +22,7 @@ available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -79,7 +79,7 @@ def test_numpy_eig( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -136,7 +136,7 @@ def test_numpy_eigh( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=4).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=4).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py index 07e9a06bfbcd2..1af6216ee5d01 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py @@ -67,7 +67,7 @@ def _get_inv_square_matrices(draw): available_dtypes=helpers.get_dtypes("float"), small_abs_safety_factor=2, safety_factor_scale="log", - shape=helpers.ints(min_value=2, max_value=20).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=20).map(lambda x: (x, x)), ).filter(lambda x: np.linalg.cond(x[1][0].tolist()) < 1 / sys.float_info.epsilon), test_with_out=st.just(False), ) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py index cc3923059d942..26547bb45a8f6 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py @@ -333,7 +333,7 @@ def test_paddle_bmm( available_dtypes=helpers.get_dtypes("valid"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), upper=st.booleans(), ) @@ -827,7 +827,7 @@ def test_paddle_matmul( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=50, - shape=helpers.ints(min_value=2, max_value=8).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=8).map(lambda x: (x, x)), ), n=helpers.ints(min_value=1, max_value=8), test_with_out=st.just(False), diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py index c4b40e6a715d9..3aa1a088b7e79 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py @@ -1331,7 +1331,7 @@ def test_paddle_inner( available_dtypes=helpers.get_dtypes("float"), min_value=-100.0, max_value=100.0, - shape=helpers.ints(min_value=2, max_value=10).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=10).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] diff --git a/ivy_tests/test_ivy/test_frontends/test_scipy/test_linalg/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_scipy/test_linalg/test_linalg.py index a8e405bcbe01b..4b6f51e059d64 100644 --- a/ivy_tests/test_ivy/test_frontends/test_scipy/test_linalg/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_scipy/test_linalg/test_linalg.py @@ -154,7 +154,7 @@ def test_scipy_eigh_tridiagonal( available_dtypes=helpers.get_dtypes("float"), small_abs_safety_factor=2, safety_factor_scale="log", - shape=helpers.ints(min_value=2, max_value=20).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=20).map(lambda x: (x, x)), ).filter(lambda x: np.linalg.cond(x[1][0].tolist()) < 1 / sys.float_info.epsilon), test_with_out=st.just(False), ) @@ -312,7 +312,7 @@ def test_scipy_pinv( available_dtypes=helpers.get_dtypes("float"), min_value=0.1, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), full_matrices=st.booleans(), compute_uv=st.booleans(), @@ -366,7 +366,7 @@ def test_scipy_svd( available_dtypes=helpers.get_dtypes("float"), min_value=0.1, max_value=50, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), check_finite=st.booleans(), test_with_out=st.just(False), diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_activations.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_activations.py index 7d3fca6e829d7..ed861effd7787 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_activations.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_activations.py @@ -91,7 +91,7 @@ def simple_test_two_function( available_dtypes=helpers.get_dtypes("valid"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), ) def test_tensorflow_deserialize( @@ -206,7 +206,7 @@ def test_tensorflow_gelu( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), ) def test_tensorflow_get(fn_name, dtype_and_data): @@ -363,7 +363,7 @@ def test_tensorflow_selu( available_dtypes=helpers.get_dtypes("valid"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), ) def test_tensorflow_serialize( diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py index e3d22b6f3f4ad..1a021be263a75 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py @@ -36,7 +36,7 @@ def _get_cholesky_matrix(draw): gen = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([shared_size, shared_size]), + shape=(shared_size, shared_size), min_value=2, max_value=5, ).filter(lambda x: np.linalg.cond(x.tolist()) < 1 / sys.float_info.epsilon) @@ -125,7 +125,7 @@ def _get_hermitian_pos_def_matrix(draw): gen = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([shared_size, shared_size]), + shape=(shared_size, shared_size), min_value=2, max_value=5, ).filter(lambda x: np.linalg.cond(x.tolist()) < 1 / sys.float_info.epsilon) @@ -148,7 +148,7 @@ def _get_second_matrix(draw): ) return input_dtype, draw( helpers.array_values( - dtype=input_dtype, shape=tuple([shared_size, 1]), min_value=2, max_value=5 + dtype=input_dtype, shape=(shared_size, 1), min_value=2, max_value=5 ) ) @@ -168,7 +168,7 @@ def _get_tridiagonal_dtype_matrix_format(draw): matrix = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([shared_size, shared_size]), + shape=(shared_size, shared_size), min_value=2, max_value=5, ).filter(tridiagonal_matrix_filter) @@ -177,7 +177,7 @@ def _get_tridiagonal_dtype_matrix_format(draw): matrix = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([3, shared_size]), + shape=(3, shared_size), min_value=2, max_value=5, ).filter(tridiagonal_compact_filter) @@ -451,7 +451,7 @@ def test_tensorflow_eigvalsh( num_arrays=1, min_value=1, max_value=10, - shape=helpers.ints(min_value=3, max_value=3).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=3, max_value=3).map(lambda x: (x, x)), ).filter(lambda x: "float16" not in x[0]), test_with_out=st.just(False), ) @@ -511,7 +511,7 @@ def test_tensorflow_global_norm( available_dtypes=helpers.get_dtypes("valid"), min_value=-100, max_value=100, - shape=helpers.ints(min_value=1, max_value=20).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=1, max_value=20).map(lambda x: (x, x)), ).filter( lambda x: "bfloat16" not in x[0] and np.linalg.cond(x[1][0]) < 1 / sys.float_info.epsilon @@ -587,7 +587,7 @@ def test_tensorflow_l2_normalize( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: "float16" not in x[0] and "bfloat16" not in x[0] @@ -933,7 +933,7 @@ def test_tensorflow_pinv( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), ) def test_tensorflow_qr( @@ -1074,7 +1074,7 @@ def test_tensorflow_solve( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), full_matrices=st.booleans(), compute_uv=st.just(True), diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py index 21fbc1c7a8000..90e44c3a4c1e2 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py @@ -54,7 +54,7 @@ def test_tensorflow_abs( @handle_frontend_test( fn_tree="tensorflow.math.accumulate_n", dtype_and_x=helpers.dtype_and_values( - available_dtypes=tuple([ivy.int64]), + available_dtypes=(ivy.int64,), num_arrays=helpers.ints(min_value=2, max_value=5), shared_dtype=True, ), @@ -1633,7 +1633,7 @@ def test_tensorflow_log_softmax( @handle_frontend_test( fn_tree="tensorflow.math.logical_and", dtype_and_x=helpers.dtype_and_values( - available_dtypes=tuple([ivy.bool]), + available_dtypes=(ivy.bool,), num_arrays=2, shared_dtype=True, ), @@ -1665,7 +1665,7 @@ def test_tensorflow_logical_and( @handle_frontend_test( fn_tree="tensorflow.math.logical_not", dtype_and_x=helpers.dtype_and_values( - available_dtypes=tuple([ivy.bool]), + available_dtypes=(ivy.bool,), num_arrays=2, shared_dtype=True, ), @@ -1728,7 +1728,7 @@ def test_tensorflow_logical_or( @handle_frontend_test( fn_tree="tensorflow.math.logical_xor", dtype_and_x=helpers.dtype_and_values( - available_dtypes=tuple([ivy.bool]), + available_dtypes=(ivy.bool,), num_arrays=2, shared_dtype=True, ), @@ -2184,7 +2184,7 @@ def test_tensorflow_reciprocal_no_nan( @handle_frontend_test( fn_tree="tensorflow.math.reduce_all", dtype_and_x=helpers.dtype_and_values( - available_dtypes=tuple([ivy.bool]), + available_dtypes=(ivy.bool,), ), test_with_out=st.just(False), ) @@ -2213,7 +2213,7 @@ def test_tensorflow_reduce_all( @handle_frontend_test( fn_tree="tensorflow.math.reduce_any", dtype_and_x=helpers.dtype_and_values( - available_dtypes=tuple([ivy.bool]), + available_dtypes=(ivy.bool,), ), test_with_out=st.just(False), ) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index b3fe2d66ab1ba..ba95184397d4f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -1079,7 +1079,7 @@ def test_tensorflow_Ceil( # NOQA available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), test_with_out=st.just(False), ) @@ -2744,7 +2744,7 @@ def test_tensorflow_MatMul( # NOQA fn_tree="tensorflow.raw_ops.MatrixDeterminant", dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("float"), - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), min_value=-5, max_value=5, ), @@ -2775,7 +2775,7 @@ def test_tensorflow_MatrixDeterminant( # NOQA fn_tree="tensorflow.raw_ops.MatrixInverse", dtype_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("float"), - shape=helpers.ints(min_value=2, max_value=10).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=10).map(lambda x: (x, x)), ).filter(lambda x: np.linalg.cond(x[1][0].tolist()) < 1 / sys.float_info.epsilon), adjoint=st.booleans(), test_with_out=st.just(False), @@ -4200,7 +4200,7 @@ def test_tensorflow_Sum( # NOQA available_dtypes=helpers.get_dtypes("valid"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), full_matrices=st.booleans(), compute_uv=st.just(True), diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_blas_and_lapack_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_blas_and_lapack_ops.py index 217a2b2edaf8a..a9eb41dd76b55 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_blas_and_lapack_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_blas_and_lapack_ops.py @@ -524,7 +524,7 @@ def test_torch_chain_matmul( available_dtypes=helpers.get_dtypes("float", index=1), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ).filter( lambda x: np.linalg.cond(x[1]) < 1 / sys.float_info.epsilon and np.linalg.det(np.asarray(x[1])) != 0 diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index ec5010e2f2b4c..47026b53f7dd1 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -12467,7 +12467,7 @@ def test_torch_sum( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), some=st.booleans(), compute_uv=st.booleans(), diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_core/test_linalg.py index 7eeec236b6a68..9c081e53af64f 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_linalg.py @@ -19,7 +19,7 @@ @st.composite def _det_helper(draw): - square = draw(helpers.ints(min_value=2, max_value=8).map(lambda x: tuple([x, x]))) + square = draw(helpers.ints(min_value=2, max_value=8).map(lambda x: (x, x))) shape_prefix = draw(helpers.get_shape()) dtype_x = draw( helpers.dtype_and_values( @@ -185,7 +185,7 @@ def _get_first_matrix_and_dtype(draw, *, transpose=False, conjugate=False): matrix = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([random_size, shared_size]), + shape=(random_size, shared_size), min_value=2, max_value=5, ) @@ -224,7 +224,7 @@ def _get_second_matrix_and_dtype(draw, *, transpose=False): matrix = draw( helpers.array_values( dtype=input_dtype, - shape=tuple([random_size, shared_size]), + shape=(random_size, shared_size), min_value=2, max_value=5, ) @@ -355,7 +355,7 @@ def dtype_value1_value2_axis( available_dtypes=helpers.get_dtypes("float"), min_value=0, max_value=10, - shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)), ), upper=st.booleans(), ) @@ -593,7 +593,7 @@ def test_inner(*, dtype_xy, test_flags, backend_fw, fn_name, on_device): small_abs_safety_factor=24, large_abs_safety_factor=24, safety_factor_scale="log", - shape=helpers.ints(min_value=2, max_value=20).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=20).map(lambda x: (x, x)), ).filter(lambda x: np.linalg.cond(x[1][0].tolist()) < 1 / sys.float_info.epsilon), adjoint=st.booleans(), ) @@ -681,7 +681,7 @@ def test_matrix_norm( available_dtypes=helpers.get_dtypes("float"), min_value=1e-3, max_value=20, - shape=helpers.ints(min_value=2, max_value=8).map(lambda x: tuple([x, x])), + shape=helpers.ints(min_value=2, max_value=8).map(lambda x: (x, x)), ), n=helpers.ints(min_value=-6, max_value=6), ) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py index 1fe495ad058aa..0c0bb83992e84 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py @@ -47,7 +47,7 @@ def _associative_scan_helper(draw): shared_size = draw( st.shared(helpers.ints(min_value=1, max_value=5), key="shared_size") ) - shape = tuple([random_size, shared_size, shared_size]) + shape = (random_size, shared_size, shared_size) matrix = draw( helpers.array_values( dtype=input_dtype, diff --git a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py index ac26cf7ba3906..db75505b51629 100644 --- a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py +++ b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py @@ -88,7 +88,7 @@ def test_current_backend(backend, array_type): @pytest.mark.parametrize( - ["middle_backend", "end_backend"], + ("middle_backend", "end_backend"), [(a, b) for a in backends for b in backends if (a != b and "mxnet" not in [a, b])], ) def test_dynamic_backend_all_combos(middle_backend, end_backend): diff --git a/scripts/test_dependencies.py b/scripts/test_dependencies.py index d6b4c65d75349..2e4469ff1e414 100644 --- a/scripts/test_dependencies.py +++ b/scripts/test_dependencies.py @@ -27,7 +27,7 @@ def parse(str_in): for import_op in import_ops: if import_op in str_in: lib_name, expected_version = str_in.split(import_op) - if not "mod_name=" in str_in: + if "mod_name=" not in str_in: mod_name = lib_name expected_version = expected_version.split(" ")[0].split(",")[0] expected_op = import_op From a4f8a48101318d6b4a347b391ccdd797c3fccaab Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 15:48:25 +0000 Subject: [PATCH 295/978] feat: add base TreeBuilder class for sklearn frontend --- ivy/functional/frontends/sklearn/tree/__init__.py | 6 ++++++ ivy/functional/frontends/sklearn/tree/_tree.py | 10 ++++++++++ 2 files changed, 16 insertions(+) create mode 100644 ivy/functional/frontends/sklearn/tree/_tree.py diff --git a/ivy/functional/frontends/sklearn/tree/__init__.py b/ivy/functional/frontends/sklearn/tree/__init__.py index d17f1a0841699..b726da4f4a4c2 100644 --- a/ivy/functional/frontends/sklearn/tree/__init__.py +++ b/ivy/functional/frontends/sklearn/tree/__init__.py @@ -1,2 +1,8 @@ from . import _classes from ._classes import * +from . import _criterion +from ._criterion import * +from . import _splitter +from ._splitter import * +from . import _tree +from ._tree import * diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py new file mode 100644 index 0000000000000..5bdf331b0260d --- /dev/null +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -0,0 +1,10 @@ +class TreeBuilder: + def build( + self, + tree, + X, + y, + sample_weight=None, + missing_values_in_feature_mask=None, + ): + pass From 6cb31c2456944891480b8902cc5d9e8be2fc4835 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 15:52:34 +0000 Subject: [PATCH 296/978] feat: add DepthFirstTreeBuilder class for sklearn frontend with the corresponding build method for reference check https://github.com/scikit-learn/scikit-learn/blob/bd162e5548e04264589221af2dcc6162fee40863/sklearn/tree/_tree.pyx#L153 --- .../frontends/sklearn/tree/_tree.py | 148 ++++++++++++++++++ 1 file changed, 148 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index 5bdf331b0260d..b46d6907ce3a7 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -1,3 +1,13 @@ +import ivy +from ._splitter import SplitRecord + +EPSILON = ivy.finfo(ivy.double).eps +INFINITY = ivy.inf + + +class StackRecord: ... + + class TreeBuilder: def build( self, @@ -8,3 +18,141 @@ def build( missing_values_in_feature_mask=None, ): pass + + +class DepthFirstTreeBuilder(TreeBuilder): + def __init__( + self, + splitter, + min_samples_split, + min_samples_leaf, + min_weight_leaf, + max_depth, + min_impurity_decrease, + ): + self.splitter = splitter + self.min_samples_split = min_samples_split + self.min_samples_leaf = min_samples_leaf + self.min_weight_leaf = min_weight_leaf + self.max_depth = max_depth + self.min_impurity_decrease = min_impurity_decrease + + def build( + self, tree, X, y, sample_weight=None, missing_values_in_feature_mask=None + ): + + if tree.max_depth <= 10: + init_capacity = int(2 ** (tree.max_depth + 1)) - 1 + else: + init_capacity = 2047 + tree._resize(init_capacity) + + splitter = self.splitter + max_depth = self.max_depth + min_samples_leaf = self.min_samples_leaf + min_weight_leaf = self.min_weight_leaf + min_samples_split = self.min_samples_split + min_impurity_decrease = self.min_impurity_decrease + + splitter.init(X, y, sample_weight, missing_values_in_feature_mask) + weighted_n_node_samples = 0.0 + split = SplitRecord() + first = 1 + max_depth_seen = -1 + builder_stack = [] + + # Push root node onto stack + builder_stack.append( + StackRecord( + start=0, + end=splitter.n_samples, + depth=0, + parent=-2, + is_left=False, + impurity=INFINITY, + n_constant_features=0, + ) + ) + + while len(builder_stack) > 0: + stack_record = builder_stack.pop() + + start = stack_record.start + end = stack_record.end + depth = stack_record.depth + parent = stack_record.parent + is_left = stack_record.is_left + impurity = stack_record.impurity + n_constant_features = stack_record.n_constant_features + + n_node_samples = end - start + _, weighted_n_node_samples = splitter.node_reset( + start, end, weighted_n_node_samples + ) + + is_leaf = ( + depth >= max_depth + or n_node_samples < min_samples_split + or n_node_samples < 2 * min_samples_leaf + or weighted_n_node_samples < 2 * min_weight_leaf + ) + + if first: + impurity = splitter.node_impurity() + first = 0 + is_leaf = is_leaf or impurity <= EPSILON + + if not is_leaf: + _, n_constant_features, split = splitter.node_split( + impurity, split, n_constant_features + ) + + is_leaf = ( + is_leaf + or split.pos >= end + or (split.improvement + EPSILON < min_impurity_decrease) + ) + + node_id = tree._add_node( + parent, + is_left, + is_leaf, + split.feature, + split.threshold, + impurity, + n_node_samples, + weighted_n_node_samples, + split.missing_go_to_left, + ) + tree.value = splitter.node_value(tree.value, node_id) + + if not is_leaf: + # Push right child on stack + builder_stack.append( + StackRecord( + start=split.pos, + end=end, + depth=depth + 1, + parent=node_id, + is_left=False, + impurity=split.impurity_right, + n_constant_features=n_constant_features, + ) + ) + + # Push left child on stack + builder_stack.append( + StackRecord( + start=start, + end=split.pos, + depth=depth + 1, + parent=node_id, + is_left=True, + impurity=split.impurity_left, + n_constant_features=n_constant_features, + ) + ) + + if depth > max_depth_seen: + max_depth_seen = depth + tree.max_depth = max_depth_seen From 3b449c63256153a401961bd2ee0c31a897531123 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 16:00:28 +0000 Subject: [PATCH 297/978] feat: define StackRecord for depth first tree growing check https://github.com/scikit-learn/scikit-learn/blob/bd162e5548e04264589221af2dcc6162fee40863/sklearn/tree/_tree.pyx#L142 --- .../frontends/sklearn/tree/_tree.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index b46d6907ce3a7..e49e262fd8506 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -5,7 +5,24 @@ INFINITY = ivy.inf -class StackRecord: ... +class StackRecord: + def __init__( + self, + start: int, + end: int, + depth: int, + parent: int, + is_left: int, + impurity: float, + n_constant_features: int, + ): + self.start = start + self.end = end + self.depth = depth + self.parent = parent + self.is_left = is_left + self.impurity = impurity + self.n_constant_features = n_constant_features class TreeBuilder: From 36ec24a98f8a77ed39dc181fc2c21b2ffbe4449f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 16:47:55 +0000 Subject: [PATCH 298/978] feat: add basic structure for Tree in sklearn frontend derived from https://github.com/scikit-learn/scikit-learn/blob/bd162e5548e04264589221af2dcc6162fee40863/sklearn/tree/_tree.pyx#L687 --- .../frontends/sklearn/tree/_tree.py | 39 +++++++++++++++---- 1 file changed, 32 insertions(+), 7 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index e49e262fd8506..2f9c695276290 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -5,16 +5,41 @@ INFINITY = ivy.inf +class Tree: + def __init__(self, n_features, n_classes, n_outputs): + self.max_depth = 0 + self.node_count = 0 + self.capacity = 0 + self.nodes = [] + self.value = None + + self.n_features = n_features + self.n_outputs = n_outputs + self.n_classes = ivy.zeros(n_outputs, dtype=ivy.int32) + + self.max_n_classes = ivy.max(n_classes) + self.value_stride = n_outputs * self.max_n_classes + + for k in range(n_outputs): + self.n_classes[k] = n_classes[k] + + def predict(self, X): + pass + + def apply(self, X): + pass + + class StackRecord: def __init__( self, - start: int, - end: int, - depth: int, - parent: int, - is_left: int, - impurity: float, - n_constant_features: int, + start, + end, + depth, + parent, + is_left, + impurity, + n_constant_features, ): self.start = start self.end = end From 3b5343aa82bb4286352a7c22e6547fb0c9a6a69f Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 6 Dec 2023 01:56:17 +0530 Subject: [PATCH 299/978] fix: Improved error handling by raising `ValueError` (#27445) --- ivy/functional/frontends/tensorflow/linalg.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/tensorflow/linalg.py b/ivy/functional/frontends/tensorflow/linalg.py index c0dcad4dd5906..90c896909a925 100644 --- a/ivy/functional/frontends/tensorflow/linalg.py +++ b/ivy/functional/frontends/tensorflow/linalg.py @@ -506,4 +506,4 @@ def tridiagonal_solve( ) return ivy.solve(constructed_matrix, rhs_copy) else: - raise "Unexpected diagonals_format" + raise ValueError("Unexpected diagonals_format") From 56b19bc756ffba7b1277ed9c8dd767f68f05c97e Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 20:38:21 +0000 Subject: [PATCH 300/978] feat: add placeholders for resize and node adding methods for Tree for use in depth first tree builder in sklearn frontend --- ivy/functional/frontends/sklearn/tree/_tree.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index 2f9c695276290..fc8c91587e5dd 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -3,6 +3,7 @@ EPSILON = ivy.finfo(ivy.double).eps INFINITY = ivy.inf +INTPTR_MAX = ivy.iinfo(ivy.int32).max class Tree: @@ -23,6 +24,15 @@ def __init__(self, n_features, n_classes, n_outputs): for k in range(n_outputs): self.n_classes[k] = n_classes[k] + def _resize(self, capacity): + self._resize_c(capacity) + + def _resize_c(self, capacity=INTPTR_MAX): + pass + + def _add_node(self): + pass + def predict(self, X): pass From 04531f6c2e6a652ed83b3bbbd618b11e603448d5 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 20:42:07 +0000 Subject: [PATCH 301/978] feat: define resize method for inner Tree arrays derived from https://github.com/scikit-learn/scikit-learn/blob/bd162e5548e04264589221af2dcc6162fee40863/sklearn/tree/_tree.pyx#L893 --- .../frontends/sklearn/tree/_tree.py | 29 ++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index fc8c91587e5dd..a276dbda99c51 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -28,7 +28,34 @@ def _resize(self, capacity): self._resize_c(capacity) def _resize_c(self, capacity=INTPTR_MAX): - pass + if capacity == self.capacity and len(self.nodes) != 0: + return 0 + if capacity == INTPTR_MAX: + if self.capacity == 0: + capacity = 3 + else: + capacity = 2 * self.capacity + if self.value is None: + self.value = ivy.zeros( + (capacity, int(self.n_outputs), int(self.max_n_classes)), + dtype=ivy.float32, + ) + else: + self.value = ivy.concat([ + self.value, + ivy.zeros( + ( + int(capacity - self.capacity), + int(self.n_outputs), + int(self.max_n_classes), + ), + dtype=ivy.float32, + ), + ]) + if capacity < self.node_count: + self.node_count = capacity + self.capacity = capacity + return 0 def _add_node(self): pass From 4154f672f4015fcef8c7221e17b822c6a919a094 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 20:52:27 +0000 Subject: [PATCH 302/978] feat: defined node adding method for Tree class and the related constants in sklearn frontend _add_node derived from https://github.com/scikit-learn/scikit-learn/blob/bd162e5548e04264589221af2dcc6162fee40863/sklearn/tree/_tree.pyx#L926 constant defined at https://github.com/scikit-learn/scikit-learn/blob/bd162e5548e04264589221af2dcc6162fee40863/sklearn/tree/_tree.pyx#L71 --- .../frontends/sklearn/tree/_tree.py | 50 ++++++++++++++++++- 1 file changed, 48 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index a276dbda99c51..c5918cf334745 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -4,6 +4,13 @@ EPSILON = ivy.finfo(ivy.double).eps INFINITY = ivy.inf INTPTR_MAX = ivy.iinfo(ivy.int32).max +TREE_UNDEFINED = -2 +_TREE_UNDEFINED = TREE_UNDEFINED +TREE_LEAF = -1 +_TREE_LEAF = TREE_LEAF + + +class Node: ... class Tree: @@ -57,8 +64,47 @@ def _resize_c(self, capacity=INTPTR_MAX): self.capacity = capacity return 0 - def _add_node(self): - pass + def _add_node( + self, + parent, + is_left, + is_leaf, + feature, + threshold, + impurity, + n_node_samples, + weighted_n_node_samples, + missing_go_to_left, + ): + node_id = self.node_count + if node_id >= self.capacity: + self._resize_c() + + node = Node() + node.impurity = impurity + node.n_node_samples = n_node_samples + node.weighted_n_node_samples = weighted_n_node_samples + + if parent != _TREE_UNDEFINED: + if is_left: + self.nodes[parent].left_child = node_id + else: + self.nodes[parent].right_child = node_id + + if is_leaf: + node.left_child = _TREE_LEAF + node.right_child = _TREE_LEAF + node.feature = _TREE_UNDEFINED + node.threshold = _TREE_UNDEFINED + else: + node.feature = feature + node.threshold = threshold + node.missing_go_to_left = missing_go_to_left + + self.nodes.append(node) + self.node_count += 1 + + return node_id def predict(self, X): pass From b4bb35041e2d733937146dfe3cfacec1d504d0d7 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 20:58:29 +0000 Subject: [PATCH 303/978] chore: disable ivy-lint check to avoid the rare case where it leads to undefined behaviour by pushing defined variable to the end of file --- .pre-commit-config.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 470cad8c679d6..c4b505a64e319 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -32,7 +32,7 @@ repos: - id: pydocstyle # Exclude everything in frontends except __init__.py, and func_wrapper.py exclude: 'ivy/functional/(frontends|backends)/(?!.*/func_wrapper\.py$).*(?!__init__\.py$)' - - repo: https://github.com/unifyai/lint-hook - rev: 2ea80bc854c7f74b09620151028579083ff92ec2 - hooks: - - id: ivy-lint +# - repo: https://github.com/unifyai/lint-hook +# rev: 2ea80bc854c7f74b09620151028579083ff92ec2 +# hooks: +# - id: ivy-lint From 71b684745d403d290db4b5c5798cc5204ce9a22f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 5 Dec 2023 21:05:20 +0000 Subject: [PATCH 304/978] feat: define Node class for use in Tree building in sklearn class derived from https://github.com/scikit-learn/scikit-learn/blob/bd162e5548e04264589221af2dcc6162fee40863/sklearn/tree/_tree.pxd#L21 --- ivy/functional/frontends/sklearn/tree/_tree.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index c5918cf334745..5d178f798dd01 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -10,7 +10,16 @@ _TREE_LEAF = TREE_LEAF -class Node: ... +class Node: + def __init__(self): + self.left_child = None + self.right_child = None + self.feature = None + self.threshold = None + self.impurity = None + self.n_node_samples = None + self.weighted_n_node_samples = None + self.missing_go_to_left = None class Tree: From 69c80aa4fcbf81d0f8f0844f844465eaac1a1a0a Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 6 Dec 2023 09:16:13 +0000 Subject: [PATCH 305/978] feat: define apply and _apply_dense tree methods in sklearn frontend derived from https://github.com/scikit-learn/scikit-learn/blob/e883b4b8c0b2ca858e6d7ddff52f6fa76981411f/sklearn/tree/_tree.pyx#L985 etc. --- .../frontends/sklearn/tree/_tree.py | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index 5d178f798dd01..3bdaa1db04cb4 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -119,7 +119,27 @@ def predict(self, X): pass def apply(self, X): - pass + return self._apply_dense(X) + + def _apply_dense(self, X): + X_tensor = X + n_samples = X.shape[0] + out = ivy.zeros(n_samples, dtype="int32") + for i in range(n_samples): + node = self.nodes[0] # root node + while node.left_child != _TREE_LEAF: + X_i_node_feature = X_tensor[i, node.feature] + if ivy.isnan(X_i_node_feature): + if node.missing_go_to_left: + node = self.nodes[node.left_child] + else: + node = self.nodes[node.right_child] + elif X_i_node_feature <= node.threshold: + node = self.nodes[node.left_child] + else: + node = self.nodes[node.right_child] + out[i] = self.nodes.index(node) # terminal node index + return out class StackRecord: From 018f7bcae99a2419191d2a25d758e7ea8f2cbf0d Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 6 Dec 2023 09:48:54 +0000 Subject: [PATCH 306/978] feat: define predict method for Tree in sklearn frontend derived from https://github.com/scikit-learn/scikit-learn/blob/36f6734789fc7e4940792c1cfb6a6e90dfcae484/sklearn/tree/_tree.pyx#L970 --- ivy/functional/frontends/sklearn/tree/_splitter.py | 3 ++- ivy/functional/frontends/sklearn/tree/_tree.py | 7 ++++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 0461682204e72..ef26ba4258414 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -489,7 +489,8 @@ def node_split_best( impurity, best_split.impurity_left, best_split.impurity_right ) - # best_split, samples = shift_missing_values_to_left_if_required(best_split, samples, end) + # best_split, samples = shift_missing_values_to_left_if_required( + # best_split, samples, end) # todo : implement shift_missing_values_to_left_if_required features[0:n_known_constants] = constant_features[0:n_known_constants] constant_features[n_known_constants:n_found_constants] = features[ diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index 3bdaa1db04cb4..4e8bf6622c75e 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -116,7 +116,12 @@ def _add_node( return node_id def predict(self, X): - pass + X_applied = self.apply(X) + X_threshold = ivy.where(X_applied > X.shape[0], X.shape[0] - 1, X_applied) + out = ivy.gather(self.value, X_threshold, axis=0) + if self.n_outputs == 1: + out = out.reshape((X.shape[0], self.max_n_classes)) + return out def apply(self, X): return self._apply_dense(X) From 2e382f564c41345f4275937fcae9ef203495738f Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 6 Dec 2023 16:06:37 +0530 Subject: [PATCH 307/978] fix: Added missing `staticmethod` decorator (#27448) --- ivy/data_classes/factorized_tensor/parafac2_tensor.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/data_classes/factorized_tensor/parafac2_tensor.py b/ivy/data_classes/factorized_tensor/parafac2_tensor.py index c2a211ee5924f..64b23361119cb 100644 --- a/ivy/data_classes/factorized_tensor/parafac2_tensor.py +++ b/ivy/data_classes/factorized_tensor/parafac2_tensor.py @@ -430,6 +430,7 @@ def parafac2_to_slices(parafac2_tensor, validate=True): for i in range(I) ] + @staticmethod def parafac2_to_tensor(parafac2_tensor): """ Construct a full tensor from a PARAFAC2 decomposition. @@ -491,6 +492,7 @@ def parafac2_to_tensor(parafac2_tensor): tensor[i, :length] = slice_ return tensor + @staticmethod def parafac2_to_unfolded(parafac2_tensor, mode): """ Construct an unfolded tensor from a PARAFAC2 decomposition. Uneven slices are @@ -543,6 +545,7 @@ def parafac2_to_unfolded(parafac2_tensor, mode): """ return ivy.unfold(ivy.Parafac2Tensor.parafac2_to_tensor(parafac2_tensor), mode) + @staticmethod def parafac2_to_vec(parafac2_tensor): """ Construct a vectorized tensor from a PARAFAC2 decomposition. Uneven slices are From cc2e0cc19e6edc017e0ed5ab4dcab5d762740e0f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 6 Dec 2023 12:50:49 +0000 Subject: [PATCH 308/978] fix: docstring related fixes for pydocstyle checks --- ivy/compiler/replace_with.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/ivy/compiler/replace_with.py b/ivy/compiler/replace_with.py index b19d8b84dc03c..51af07f192249 100644 --- a/ivy/compiler/replace_with.py +++ b/ivy/compiler/replace_with.py @@ -7,10 +7,12 @@ def replace_with(new_func): """ - Decorator to mark a function/method/attribute to be replaced by another. + Decorate a function/method/attribute to be replaced by another. - Args: - - new_func: The function that will replace the original. + Parameters + ---------- + new_func + The function that will replace the original. """ def decorator(original_func): @@ -67,7 +69,7 @@ def visit_Call(self, node): def transform_function(func): - """Transforms the function by replacing its calls based on the replace_map.""" + """Transform the function by replacing its calls based on the replace_map.""" source = inspect.getsource(func) tree = ast.parse(source) transformed_tree = ReplaceFunction().visit(tree) From 5c364f1f0e1b4f09d1119d2cf83508528b1a00d0 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 6 Dec 2023 16:47:30 +0000 Subject: [PATCH 309/978] feat: define the fit method for Decision tree classifiers in sklearn frontend derived from https://github.com/scikit-learn/scikit-learn/blob/9ef1b9d4e618a245221cbef380f24c369c64500e/sklearn/tree/_classes.py#L231 --- .../frontends/sklearn/tree/_classes.py | 85 ++++++++++++++++++- 1 file changed, 84 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_classes.py b/ivy/functional/frontends/sklearn/tree/_classes.py index d7772084b4d60..48ed37d1f622a 100644 --- a/ivy/functional/frontends/sklearn/tree/_classes.py +++ b/ivy/functional/frontends/sklearn/tree/_classes.py @@ -4,6 +4,12 @@ ClassifierMixin, MultiOutputMixin, ) +import copy +from ._criterion import Gini, Criterion +from ._splitter import BestSplitter, Splitter +from ._tree import DepthFirstTreeBuilder, Tree +import ivy +import numbers class BaseDecisionTree(MultiOutputMixin, BaseEstimator, metaclass=ABCMeta): @@ -51,7 +57,84 @@ def _fit( check_input=True, missing_values_in_feature_mask=None, ): - raise NotImplementedError + n_samples, self.n_features_in_ = X.shape + y = ivy.atleast_1d(y) + if y.ndim == 1: + y = ivy.reshape(y, (-1, 1)) + self.n_outputs_ = y.shape[1] + y = ivy.copy.copy(y) + self.classes_ = [] + self.n_classes_ = [] + if self.class_weight is not None: + ivy.copy.copy(y) + y_encoded = ivy.zeros(y.shape, dtype=ivy.int32) + + for k in range(self.n_outputs_): + classes_k, y_encoded[:, k] = ivy.unique_inverse(y[:, k]) + self.classes_.append(classes_k) + self.n_classes_.append(classes_k.shape[0]) + y = y_encoded + + self.n_classes_ = ivy.array(self.n_classes_, dtype="np.int64") + + y = ivy.array(y, dtype="float32") + max_depth = ( + ivy.iinfo(ivy.int32).max if self.max_depth is None else self.max_depth + ) + + if isinstance(self.min_samples_leaf, numbers.Integral): + min_samples_leaf = self.min_samples_leaf + else: + min_samples_leaf = int(ivy.ceil(self.min_samples_leaf * n_samples)) + + if isinstance(self.min_samples_split, numbers.Integral): + min_samples_split = self.min_samples_split + else: + min_samples_split = int(ivy.ceil(self.min_samples_split * n_samples)) + min_samples_split = max(2, min_samples_split) + min_samples_split = max(min_samples_split, 2 * min_samples_leaf) + if self.max_features is None: # todo: other cases + max_features = self.n_features_in_ + self.max_features_ = max_features + assert len(y) == n_samples, "Number of labels does not match number of samples" + + if sample_weight is None: + min_weight_leaf = self.min_weight_fraction_leaf * n_samples + else: + min_weight_leaf = self.min_weight_fraction_leaf * ivy.sum(sample_weight) + + self.n_classes_ = ivy.array(self.n_classes_, dtype=ivy.int64) + + criterion = self.criterion + if not isinstance(criterion, Criterion): + criterion = Gini(self.n_outputs_, n_samples) + else: + criterion = copy.deepcopy(criterion) + splitter = self.splitter + monotonic_cst = None + + if not isinstance(self.splitter, Splitter): + splitter = BestSplitter( + criterion, + self.max_features_, + min_samples_leaf, + min_weight_leaf, + self.random_state, + monotonic_cst, + ) + self.tree_ = Tree(self.n_features_in_, self.n_classes_, self.n_outputs_) + builder = DepthFirstTreeBuilder( + splitter, + min_samples_split, + min_samples_leaf, + min_weight_leaf, + max_depth, + self.min_impurity_decrease, + ) + builder.build(self.tree_, X, y, sample_weight, missing_values_in_feature_mask) + self.n_classes_ = self.n_classes_[0] + self.classes_ = self.classes_[0] + return self def predict(self, X, check_input=True): raise NotImplementedError From e9d8f038544bdb32d82364c3ffbd721be333768e Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 7 Dec 2023 10:36:18 +0530 Subject: [PATCH 310/978] fix: Fixed default value of `os.getenv` (#27450) --- ivy_tests/conftest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/conftest.py b/ivy_tests/conftest.py index e573de819178c..96533c7bc5784 100644 --- a/ivy_tests/conftest.py +++ b/ivy_tests/conftest.py @@ -109,7 +109,7 @@ def pytest_configure(config): max_examples = getopt("--num-examples") deadline = getopt("--deadline") if ( - os.getenv("REDIS_URL", default=False) + os.getenv("REDIS_URL", default=None) and os.environ["REDIS_URL"] and is_db_available( master=True, From 54ea8b125dc0f9b5a7eaf894ed1f54382952f072 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 10:52:36 +0000 Subject: [PATCH 311/978] fix: pass the number of classes corretly for Gini criterion, fix dtype passed to ivy array, bring tree to ivy sklearn frontend namespace --- ivy/functional/frontends/sklearn/__init__.py | 1 + ivy/functional/frontends/sklearn/tree/_classes.py | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/sklearn/__init__.py b/ivy/functional/frontends/sklearn/__init__.py index 278ccd9274970..96d60d7f67f9d 100644 --- a/ivy/functional/frontends/sklearn/__init__.py +++ b/ivy/functional/frontends/sklearn/__init__.py @@ -1,3 +1,4 @@ +from . import tree import ivy from ivy.functional.frontends.numpy import array diff --git a/ivy/functional/frontends/sklearn/tree/_classes.py b/ivy/functional/frontends/sklearn/tree/_classes.py index 48ed37d1f622a..4fcef96e18f8a 100644 --- a/ivy/functional/frontends/sklearn/tree/_classes.py +++ b/ivy/functional/frontends/sklearn/tree/_classes.py @@ -75,7 +75,7 @@ def _fit( self.n_classes_.append(classes_k.shape[0]) y = y_encoded - self.n_classes_ = ivy.array(self.n_classes_, dtype="np.int64") + self.n_classes_ = ivy.array(self.n_classes_, dtype="int64") y = ivy.array(y, dtype="float32") max_depth = ( @@ -107,7 +107,7 @@ def _fit( criterion = self.criterion if not isinstance(criterion, Criterion): - criterion = Gini(self.n_outputs_, n_samples) + criterion = Gini(self.n_outputs_, self.n_classes_) else: criterion = copy.deepcopy(criterion) splitter = self.splitter From 83df970a9b167077c0ded6a28dbd0beadcbac7da Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 11:05:08 +0000 Subject: [PATCH 312/978] fix: remove the axis arg as np.reshape doesn't take axis argument --- ivy/functional/backends/numpy/set.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/numpy/set.py b/ivy/functional/backends/numpy/set.py index 18911bebd6402..097fa25b24060 100644 --- a/ivy/functional/backends/numpy/set.py +++ b/ivy/functional/backends/numpy/set.py @@ -85,7 +85,7 @@ def unique_inverse( values = np.append(values, np.full(nan_count - 1, np.nan), axis=axis).astype( x.dtype ) - inverse_indices = np.reshape(inverse_indices, x.shape, axis=0) + inverse_indices = np.reshape(inverse_indices, x.shape) return Results(values, inverse_indices) From eacbef19d1f066b779a0084c16f097eacfb60d36 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 11:15:05 +0000 Subject: [PATCH 313/978] fix: ensure max_n_classes is scalar before inserted into shape arg for ivy.zeros ahead --- ivy/functional/frontends/sklearn/tree/_criterion.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index f145007f01a8c..5c3de7e6c1599 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -34,10 +34,10 @@ def __init__(self, n_outputs: int, n_classes: ivy.Array): for k in range(n_outputs): self.n_classes[k] = n_classes[k] - if n_classes[k] > max_n_classes: max_n_classes = n_classes[k] - + if isinstance(max_n_classes, ivy.Array): + max_n_classes = ivy.to_scalar(max_n_classes) self.max_n_classes = max_n_classes self.sum_total = ivy.zeros((n_outputs, max_n_classes), dtype=ivy.float64) From 5679227b7e06a5c44aaf1278a089f7497476b865 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guilherme=20Louren=C3=A7o=20de=20Toledo?= <67521354+guitld@users.noreply.github.com> Date: Thu, 7 Dec 2023 12:28:39 -0300 Subject: [PATCH 314/978] Added logical_xor to torch frontend (#27453) --- ivy/functional/frontends/torch/tensor.py | 4 ++ .../test_frontends/test_torch/test_tensor.py | 38 +++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 01b9dd26665fe..209a91152c8a7 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -425,6 +425,10 @@ def logical_not_(self): def logical_or(self, other): return torch_frontend.logical_or(self, other) + @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + def logical_xor(self, other): + return torch_frontend.logical_xor(self, other) + def bitwise_not(self): return torch_frontend.bitwise_not(self) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 47026b53f7dd1..ad382206bb170 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -8832,6 +8832,44 @@ def test_torch_logical_or( ) +# logical_xor +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="logical_xor", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=2, + ), +) +def test_torch_logical_xor( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "other": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # logit @handle_frontend_method( class_tree=CLASS_TREE, From 9c2ce195fdc638a0dfec40091be38dd1445ae470 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 15:50:49 +0000 Subject: [PATCH 315/978] fix: use the DensePartitioner in BestSplitter to enable node splitting in node_spit_best function --- ivy/functional/frontends/sklearn/tree/_splitter.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index ef26ba4258414..b248625db2873 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -276,7 +276,9 @@ def init( *args, ): Splitter.init(self, X, y, sample_weight, missing_values_in_feature_mask, *args) - self.partitioner = None + self.partitioner = DensePartitioner( + X, self.samples, self.feature_values, missing_values_in_feature_mask + ) def node_split(self, impurity, split, n_constant_features): return node_split_best( From 1e032c4d0e913588bb7e0b7dc7d3ff37322a55fa Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 16:58:43 +0000 Subject: [PATCH 316/978] fix: remove handling of missing values in splitter --- ivy/functional/frontends/sklearn/tree/_splitter.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index b248625db2873..0d170f8ed7949 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -383,10 +383,7 @@ def node_split_best( f_i -= 1 features[f_i], features[f_j] = features[f_j], features[f_i] has_missing = n_missing != 0 - criterion.init_missing(n_missing) - n_searches = 2 if has_missing else 1 - for i in range(n_searches): missing_go_to_left = i == 1 criterion.missing_go_to_left = missing_go_to_left From f60314183b70b65072b394e686bd775eaadfeb51 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 17:02:54 +0000 Subject: [PATCH 317/978] fix: update _move_sums_classification helper to avoid indexing a float in sklearn frontend --- ivy/functional/frontends/sklearn/tree/_criterion.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index 5c3de7e6c1599..9945016010915 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -30,6 +30,7 @@ def __init__(self, n_outputs: int, n_classes: ivy.Array): self.weighted_n_right = 0.0 self.weighted_n_missing = 0.0 self.n_classes = ivy.empty(n_outputs, dtype=ivy.int16) + self.n_missing = 0 # todo: remove this assumption max_n_classes = 0 for k in range(n_outputs): @@ -185,10 +186,11 @@ def children_impurity( def _move_sums_classification(criterion, sum_1, sum_2, weighted_n_1, weighted_n_2): for k in range(criterion.n_outputs): - for c in range(criterion.n_classes[k]): - sum_1[k][c] = 0.0 - sum_2[k][c] = criterion.sum_total[k][c] + n = int(criterion.n_classes[k]) + sum_1[k, :n] = 0 + sum_2[k, :n] = criterion.sum_total[k, :n] + + weighted_n_1 = 0.0 + weighted_n_2 = criterion.weighted_n_node_samples - weighted_n_1[0] = 0.0 - weighted_n_2[0] = criterion.weighted_n_node_samples return weighted_n_1, weighted_n_2, sum_1, sum_2 From 7ba843e92e6e200f6c8a41609c1b3a558023bb27 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 17:42:14 +0000 Subject: [PATCH 318/978] feat: add impurity_improvement method for the Criterion class in sklearn frontend to compute impurity improvement during split derived from https://github.com/scikit-learn/scikit-learn/blob/c9138537790cc0fa352968eed927433fe17ee17c/sklearn/tree/_criterion.pyx#L188 --- ivy/functional/frontends/sklearn/tree/_criterion.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index 9945016010915..bdc0412ba005c 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -15,6 +15,18 @@ def reverse_reset(self): def update(self, new_pos): raise NotImplementedError + def impurity_improvement( + self, impurity_parent: float, impurity_left: float, impurity_right: float + ): + return (self.weighted_n_node_samples / self.weighted_n_samples) * ( + impurity_parent + - (self.weighted_n_right / self.weighted_n_node_samples * impurity_right) + - (self.weighted_n_left / self.weighted_n_node_samples * impurity_left) + ) + + def node_value(self, dest, node_id): + return dest + class ClassificationCriterion(Criterion): def __init__(self, n_outputs: int, n_classes: ivy.Array): From a08481c2ecaac73758d0d449accd28657e52483f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 20:09:21 +0000 Subject: [PATCH 319/978] feat: add proxy_impurity_improvement method for Criterion class in sklearn frontend to speed up the search in best split based on https://github.com/scikit-learn/scikit-learn/blob/c9138537790cc0fa352968eed927433fe17ee17c/sklearn/tree/_criterion.pyx#L170 --- ivy/functional/frontends/sklearn/tree/_criterion.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index bdc0412ba005c..2213df22946cf 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -15,6 +15,18 @@ def reverse_reset(self): def update(self, new_pos): raise NotImplementedError + def proxy_impurity_improvement(self): + impurity_left = 0.0 + impurity_right = 0.0 + impurity_left, impurity_right = self.children_impurity( + impurity_left, impurity_right + ) + + return ( + -self.weighted_n_right * impurity_right + - self.weighted_n_left * impurity_left + ) + def impurity_improvement( self, impurity_parent: float, impurity_left: float, impurity_right: float ): From bd8435cd46f13b1a5b922052521e6bb25ba5f9a6 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 7 Dec 2023 20:12:41 +0000 Subject: [PATCH 320/978] feat: define predict method for BaseDecisionTree in sklearn frontend based on https://github.com/scikit-learn/scikit-learn/blob/main/sklearn/tree/_classes.py#L505 --- ivy/functional/frontends/sklearn/base.py | 3 --- .../frontends/sklearn/tree/_classes.py | 18 +++++++++++++++++- 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/ivy/functional/frontends/sklearn/base.py b/ivy/functional/frontends/sklearn/base.py index 8fa319eb2b587..e8dad2105936a 100644 --- a/ivy/functional/frontends/sklearn/base.py +++ b/ivy/functional/frontends/sklearn/base.py @@ -13,9 +13,6 @@ def score(self, X, y, sample_weight=None): def fit(self, X, y, **kwargs): raise NotImplementedError - def predict(self, X): - raise NotImplementedError - class TransformerMixin: def fit_transform(self, X, y=None, **fit_params): diff --git a/ivy/functional/frontends/sklearn/tree/_classes.py b/ivy/functional/frontends/sklearn/tree/_classes.py index 4fcef96e18f8a..109887524d374 100644 --- a/ivy/functional/frontends/sklearn/tree/_classes.py +++ b/ivy/functional/frontends/sklearn/tree/_classes.py @@ -137,7 +137,23 @@ def _fit( return self def predict(self, X, check_input=True): - raise NotImplementedError + proba = self.tree_.predict(X) + n_samples = X.shape[0] + + # Classification + + if self.n_outputs_ == 1: + return ivy.gather(self.classes_, ivy.argmax(proba, axis=1), axis=0) + + else: + class_type = self.classes_[0].dtype + predictions = ivy.zeros((n_samples, self.n_outputs_), dtype=class_type) + for k in range(self.n_outputs_): + predictions[:, k] = ivy.gather( + self.classes_[k], ivy.argmax(proba[:, k], axis=1), axis=0 + ) + + return predictions def apply(self, X, check_input=True): raise NotImplementedError From 67566f739fabc56299ba738d4f7449d521c0fc6c Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 8 Dec 2023 01:47:22 +0530 Subject: [PATCH 321/978] feat: Updated `jax` version to 0.4.21 (#27442) --- ivy/functional/backends/jax/__init__.py | 24 ++++---- ivy/functional/backends/jax/elementwise.py | 28 +++++----- .../backends/jax/experimental/elementwise.py | 2 +- .../backends/jax/experimental/layers.py | 6 +- .../backends/jax/experimental/random.py | 2 +- .../backends/jax/experimental/sorting.py | 2 +- .../backends/jax/experimental/statistical.py | 6 +- ivy/functional/backends/jax/general.py | 4 +- ivy/functional/backends/jax/linear_algebra.py | 56 +++++++++---------- ivy/functional/backends/jax/manipulation.py | 2 +- ivy/functional/backends/jax/random.py | 2 +- ivy/functional/backends/jax/searching.py | 4 +- ivy/functional/backends/jax/sorting.py | 2 +- ivy/functional/backends/jax/statistical.py | 4 +- ivy/functional/frontends/__init__.py | 2 +- ivy/functional/frontends/jax/lax/operators.py | 8 +-- .../jax/nn/non_linear_activations.py | 2 +- .../frontends/jax/numpy/creation.py | 6 +- ivy/functional/frontends/jax/numpy/linalg.py | 4 +- ivy/functional/frontends/jax/numpy/logic.py | 4 +- .../jax/numpy/mathematical_functions.py | 12 ++-- .../frontends/jax/numpy/searching_sorting.py | 4 +- .../frontends/jax/numpy/statistical.py | 6 +- ivy/functional/frontends/jax/random.py | 32 +++++------ 24 files changed, 112 insertions(+), 112 deletions(-) diff --git a/ivy/functional/backends/jax/__init__.py b/ivy/functional/backends/jax/__init__.py index ca2e47c668e58..171ffe5a794d4 100644 --- a/ivy/functional/backends/jax/__init__.py +++ b/ivy/functional/backends/jax/__init__.py @@ -101,7 +101,7 @@ def _array_unflatten(aux_data, children): # update these to add new dtypes valid_dtypes = { - "0.4.20 and below": ( + "0.4.21 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -120,7 +120,7 @@ def _array_unflatten(aux_data, children): ) } valid_numeric_dtypes = { - "0.4.20 and below": ( + "0.4.21 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -139,7 +139,7 @@ def _array_unflatten(aux_data, children): } valid_int_dtypes = { - "0.4.20 and below": ( + "0.4.21 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -152,12 +152,12 @@ def _array_unflatten(aux_data, children): } valid_uint_dtypes = { - "0.4.20 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) + "0.4.21 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) } valid_float_dtypes = { - "0.4.20 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) + "0.4.21 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) } -valid_complex_dtypes = {"0.4.20 and below": (ivy.complex64, ivy.complex128)} +valid_complex_dtypes = {"0.4.21 and below": (ivy.complex64, ivy.complex128)} # leave these untouched @@ -172,12 +172,12 @@ def _array_unflatten(aux_data, children): # invalid data types # update these to add new dtypes -invalid_dtypes = {"0.4.20 and below": ()} -invalid_numeric_dtypes = {"0.4.20 and below": ()} -invalid_int_dtypes = {"0.4.20 and below": ()} -invalid_float_dtypes = {"0.4.20 and below": ()} -invalid_uint_dtypes = {"0.4.20 and below": ()} -invalid_complex_dtypes = {"0.4.20 and below": ()} +invalid_dtypes = {"0.4.21 and below": ()} +invalid_numeric_dtypes = {"0.4.21 and below": ()} +invalid_int_dtypes = {"0.4.21 and below": ()} +invalid_float_dtypes = {"0.4.21 and below": ()} +invalid_uint_dtypes = {"0.4.21 and below": ()} +invalid_complex_dtypes = {"0.4.21 and below": ()} # leave these untouched invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index 23e3211ccffb5..909da651c29e6 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -72,7 +72,7 @@ def atanh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arctanh(x) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def bitwise_and( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -84,14 +84,14 @@ def bitwise_and( return jnp.bitwise_and(x1, x2) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def bitwise_invert( x: Union[int, JaxArray], /, *, out: Optional[JaxArray] = None ) -> JaxArray: return jnp.bitwise_not(x) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def bitwise_left_shift( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -103,7 +103,7 @@ def bitwise_left_shift( return jnp.left_shift(x1, x2) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def bitwise_or( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -115,7 +115,7 @@ def bitwise_or( return jnp.bitwise_or(x1, x2) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def bitwise_right_shift( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -127,7 +127,7 @@ def bitwise_right_shift( return jnp.right_shift(x1, x2) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def bitwise_xor( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -139,7 +139,7 @@ def bitwise_xor( return jnp.bitwise_xor(x1, x2) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def ceil(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -151,7 +151,7 @@ def cos(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.cos(x) -@with_unsupported_dtypes({"0.4.20 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("float16",)}, backend_version) def cosh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.cosh(x) @@ -191,7 +191,7 @@ def expm1(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.expm1(x) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def floor(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -199,7 +199,7 @@ def floor(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.floor(x) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def floor_divide( x1: Union[float, JaxArray], x2: Union[float, JaxArray], @@ -427,7 +427,7 @@ def pow( return jnp.power(x1, x2) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def remainder( x1: Union[float, JaxArray], x2: Union[float, JaxArray], @@ -524,7 +524,7 @@ def tanh( return jnp.tanh(x) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def trunc(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -564,7 +564,7 @@ def angle( # ------# -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def erf(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jax.scipy.special.erf(x) @@ -615,7 +615,7 @@ def isreal(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.isreal(x) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def fmod( x1: JaxArray, x2: JaxArray, diff --git a/ivy/functional/backends/jax/experimental/elementwise.py b/ivy/functional/backends/jax/experimental/elementwise.py index 4a005bd28c203..1ebf9d8c99ff8 100644 --- a/ivy/functional/backends/jax/experimental/elementwise.py +++ b/ivy/functional/backends/jax/experimental/elementwise.py @@ -50,7 +50,7 @@ def sinc(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: @with_supported_dtypes( - {"0.4.20 and below": ("float16", "float32", "float64")}, backend_version + {"0.4.21 and below": ("float16", "float32", "float64")}, backend_version ) def lgamma(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jlax.lgamma(x) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 95fbb1277a19c..475749cadcc31 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -440,7 +440,7 @@ def avg_pool3d( return res -@with_supported_dtypes({"0.4.20 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"0.4.21 and below": ("float32", "float64")}, backend_version) def dct( x: JaxArray, /, @@ -822,7 +822,7 @@ def ifftn( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, backend_version + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version ) def embedding( weights: JaxArray, @@ -870,7 +870,7 @@ def rfft( return ret -@with_unsupported_dtypes({"0.4.20 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("float16", "complex")}, backend_version) def rfftn( x: JaxArray, s: Optional[Sequence[int]] = None, diff --git a/ivy/functional/backends/jax/experimental/random.py b/ivy/functional/backends/jax/experimental/random.py index 0afa2f35dc9a1..4675cf0d8293d 100644 --- a/ivy/functional/backends/jax/experimental/random.py +++ b/ivy/functional/backends/jax/experimental/random.py @@ -56,7 +56,7 @@ def beta( return jax.random.beta(rng_input, a, b, shape, dtype) -@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, backend_version) def gamma( alpha: Union[float, JaxArray], beta: Union[float, JaxArray], diff --git a/ivy/functional/backends/jax/experimental/sorting.py b/ivy/functional/backends/jax/experimental/sorting.py index 232bf3d4be6e2..9dcc596eae53c 100644 --- a/ivy/functional/backends/jax/experimental/sorting.py +++ b/ivy/functional/backends/jax/experimental/sorting.py @@ -23,7 +23,7 @@ def invert_permutation( # lexsort -@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, backend_version) def lexsort( keys: JaxArray, /, diff --git a/ivy/functional/backends/jax/experimental/statistical.py b/ivy/functional/backends/jax/experimental/statistical.py index 65beaf0363722..f83e98bee4c88 100644 --- a/ivy/functional/backends/jax/experimental/statistical.py +++ b/ivy/functional/backends/jax/experimental/statistical.py @@ -10,7 +10,7 @@ @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16",)}, + {"0.4.21 and below": ("bfloat16",)}, backend_version, ) def histogram( @@ -121,7 +121,7 @@ def histogram( @with_unsupported_dtypes( - {"0.4.20 and below": ("complex64", "complex128")}, backend_version + {"0.4.21 and below": ("complex64", "complex128")}, backend_version ) def median( input: JaxArray, @@ -406,7 +406,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "bfloat16", "bool", ) diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index c2f643afcd9cc..cb9c1edceab73 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -101,7 +101,7 @@ def array_equal(x0: JaxArray, x1: JaxArray, /) -> bool: return bool(jnp.array_equal(x0, x1)) -@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, backend_version) def to_numpy(x: JaxArray, /, *, copy: bool = True) -> np.ndarray: if copy: return np.array(_to_array(x)) @@ -420,7 +420,7 @@ def vmap( ) -@with_unsupported_dtypes({"0.4.20 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("float16", "bfloat16")}, backend_version) def isin( elements: JaxArray, test_elements: JaxArray, diff --git a/ivy/functional/backends/jax/linear_algebra.py b/ivy/functional/backends/jax/linear_algebra.py index 0e622f58b8bed..c5243e5c404de 100644 --- a/ivy/functional/backends/jax/linear_algebra.py +++ b/ivy/functional/backends/jax/linear_algebra.py @@ -20,7 +20,7 @@ @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def cholesky( @@ -34,7 +34,7 @@ def cholesky( return ret -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def cross( x1: JaxArray, x2: JaxArray, @@ -51,14 +51,14 @@ def cross( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def det(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.linalg.det(x) -@with_unsupported_dtypes({"0.4.20 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("float16", "bfloat16")}, backend_version) def eig(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> Tuple[JaxArray]: result_tuple = NamedTuple( "eig", [("eigenvalues", JaxArray), ("eigenvectors", JaxArray)] @@ -67,7 +67,7 @@ def eig(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> Tuple[JaxArray]: return result_tuple(eigenvalues, eigenvectors) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def diagonal( x: JaxArray, /, @@ -104,7 +104,7 @@ def tensorsolve( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def eigh( @@ -118,7 +118,7 @@ def eigh( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def eigvalsh( @@ -127,14 +127,14 @@ def eigvalsh( return jnp.linalg.eigvalsh(x, UPLO=UPLO) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def inner(x1: JaxArray, x2: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: x1, x2 = ivy.promote_types_of_inputs(x1, x2) return jnp.inner(x1, x2) @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def inv( @@ -155,7 +155,7 @@ def inv( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matmul( @@ -181,7 +181,7 @@ def matmul( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matrix_norm( @@ -202,13 +202,13 @@ def matrix_norm( return jnp.linalg.norm(x, ord=ord, axis=axis, keepdims=keepdims) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def matrix_power(x: JaxArray, n: int, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.linalg.matrix_power(x, n) @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matrix_rank( @@ -239,7 +239,7 @@ def matrix_rank( @with_unsupported_dtypes( - {"0.4.20 and below": ("int", "float16", "complex")}, + {"0.4.21 and below": ("int", "float16", "complex")}, backend_version, ) def matrix_transpose( @@ -251,7 +251,7 @@ def matrix_transpose( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def outer( @@ -266,7 +266,7 @@ def outer( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def pinv( @@ -284,7 +284,7 @@ def pinv( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def qr( @@ -296,7 +296,7 @@ def qr( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def slogdet( @@ -309,7 +309,7 @@ def slogdet( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def solve( @@ -351,7 +351,7 @@ def solve( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svd( @@ -368,7 +368,7 @@ def svd( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svdvals( @@ -378,7 +378,7 @@ def svdvals( return jnp.linalg.svd(x, compute_uv=False) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def tensordot( x1: JaxArray, x2: JaxArray, @@ -392,7 +392,7 @@ def tensordot( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def trace( @@ -407,7 +407,7 @@ def trace( return jnp.trace(x, offset=offset, axis1=axis1, axis2=axis2, out=out) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def vecdot( x1: JaxArray, x2: JaxArray, /, *, axis: int = -1, out: Optional[JaxArray] = None ) -> JaxArray: @@ -415,7 +415,7 @@ def vecdot( return jnp.tensordot(x1, x2, axes=(axis, axis)) -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def vector_norm( x: JaxArray, /, @@ -445,7 +445,7 @@ def vector_norm( # ------# -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def diag( x: JaxArray, /, @@ -457,7 +457,7 @@ def diag( @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "complex")}, + {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def vander( @@ -473,7 +473,7 @@ def vander( @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/jax/manipulation.py b/ivy/functional/backends/jax/manipulation.py index 161ba13f9f082..c7bc18b42c636 100644 --- a/ivy/functional/backends/jax/manipulation.py +++ b/ivy/functional/backends/jax/manipulation.py @@ -226,7 +226,7 @@ def clip( return x -@with_unsupported_dtypes({"0.4.20 and below": ("uint64",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("uint64",)}, backend_version) def constant_pad( x: JaxArray, /, diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index 506eb095fae5c..f277860762f4c 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -82,7 +82,7 @@ def random_normal( return jax.random.normal(rng_input, shape, dtype=dtype) * std + mean -@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/jax/searching.py b/ivy/functional/backends/jax/searching.py index 679c02981e49e..a2a6a7381ec2d 100644 --- a/ivy/functional/backends/jax/searching.py +++ b/ivy/functional/backends/jax/searching.py @@ -12,7 +12,7 @@ # ------------------ # -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def argmax( x: JaxArray, /, @@ -38,7 +38,7 @@ def argmax( return ret -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def argmin( x: JaxArray, /, diff --git a/ivy/functional/backends/jax/sorting.py b/ivy/functional/backends/jax/sorting.py index 1dc7eecb5b2c4..a633b8044004a 100644 --- a/ivy/functional/backends/jax/sorting.py +++ b/ivy/functional/backends/jax/sorting.py @@ -80,7 +80,7 @@ def searchsorted( # msort -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) def msort( a: Union[JaxArray, list, tuple], /, diff --git a/ivy/functional/backends/jax/statistical.py b/ivy/functional/backends/jax/statistical.py index 9e0cef560e067..3524c4ff88d36 100644 --- a/ivy/functional/backends/jax/statistical.py +++ b/ivy/functional/backends/jax/statistical.py @@ -38,7 +38,7 @@ def max( @with_unsupported_dtypes( - {"0.4.20 and below": "bfloat16"}, + {"0.4.21 and below": "bfloat16"}, backend_version, ) def mean( @@ -143,7 +143,7 @@ def var( # ------# -@with_unsupported_dtypes({"0.4.20 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes({"0.4.21 and below": "bfloat16"}, backend_version) def cumprod( x: JaxArray, /, diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 74b5c3b1c4b17..712f483d3df7e 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -5,7 +5,7 @@ "torch": "2.1.1", "tensorflow": "2.15.0", "numpy": "1.25.2", - "jax": "0.4.14", + "jax": "0.4.21", "scipy": "1.10.1", "paddle": "2.5.2", "sklearn": "1.3.0", diff --git a/ivy/functional/frontends/jax/lax/operators.py b/ivy/functional/frontends/jax/lax/operators.py index b2ce5a8631c81..935911d628424 100644 --- a/ivy/functional/frontends/jax/lax/operators.py +++ b/ivy/functional/frontends/jax/lax/operators.py @@ -157,7 +157,7 @@ def broadcast(operand, sizes): @with_supported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "float32", "float64", @@ -309,7 +309,7 @@ def cosh(x): @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16", "float16", "bool", "complex64", "complex128")}, + {"0.4.21 and below": ("bfloat16", "float16", "bool", "complex64", "complex128")}, "jax", ) @to_ivy_arrays_and_back @@ -400,7 +400,7 @@ def erf(x): @with_supported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "float32", "float64", @@ -465,7 +465,7 @@ def imag(x): @with_unsupported_dtypes( - {"0.4.20 and below": ("bool", "bfloat16")}, + {"0.4.21 and below": ("bool", "bfloat16")}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/nn/non_linear_activations.py b/ivy/functional/frontends/jax/nn/non_linear_activations.py index 0cc778cf320cb..726114cbac3e1 100644 --- a/ivy/functional/frontends/jax/nn/non_linear_activations.py +++ b/ivy/functional/frontends/jax/nn/non_linear_activations.py @@ -289,7 +289,7 @@ def sigmoid(x): @with_supported_dtypes( - {"0.4.20 and below": ("complex", "float")}, + {"0.4.21 and below": ("complex", "float")}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/numpy/creation.py b/ivy/functional/frontends/jax/numpy/creation.py index 93a8cba0eca7b..b83c1ff83d27e 100644 --- a/ivy/functional/frontends/jax/numpy/creation.py +++ b/ivy/functional/frontends/jax/numpy/creation.py @@ -17,7 +17,7 @@ @with_unsupported_device_and_dtypes( { - "0.4.20 and below": { + "0.4.21 and below": { "cpu": ( "float16", "bflooat16", @@ -196,7 +196,7 @@ def iterable(y): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -217,7 +217,7 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/frontends/jax/numpy/linalg.py b/ivy/functional/frontends/jax/numpy/linalg.py index 1a34220713653..04c18eec1313f 100644 --- a/ivy/functional/frontends/jax/numpy/linalg.py +++ b/ivy/functional/frontends/jax/numpy/linalg.py @@ -88,7 +88,7 @@ def multi_dot(arrays, *, precision=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"0.4.20 and below": ("float32", "float64")}, + {"0.4.21 and below": ("float32", "float64")}, "jax", ) def norm(x, ord=None, axis=None, keepdims=False): @@ -127,7 +127,7 @@ def svd(a, /, *, full_matrices=True, compute_uv=True, hermitian=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.20 and below": ("float16", "bfloat16")}, "jax") +@with_unsupported_dtypes({"0.4.21 and below": ("float16", "bfloat16")}, "jax") def tensorinv(a, ind=2): old_shape = ivy.shape(a) prod = 1 diff --git a/ivy/functional/frontends/jax/numpy/logic.py b/ivy/functional/frontends/jax/numpy/logic.py index c6d79f193d91d..d5a28d2803509 100644 --- a/ivy/functional/frontends/jax/numpy/logic.py +++ b/ivy/functional/frontends/jax/numpy/logic.py @@ -101,7 +101,7 @@ def equal(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, "jax") +@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, "jax") def fromfunction(function, shape, *, dtype=float, **kwargs): def canonicalize_shape(shape, context="shape argument"): if isinstance(shape, int): @@ -285,7 +285,7 @@ def right_shift(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16", "bool")}, "jax") +@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16", "bool")}, "jax") def setxor1d(ar1, ar2, assume_unique=False): common_dtype = ivy.promote_types(ivy.dtype(ar1), ivy.dtype(ar2)) ar1 = ivy.asarray(ar1, dtype=common_dtype) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index c8a607f689ced..9e661cad4746e 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -76,7 +76,7 @@ def around(a, decimals=0, out=None): @with_unsupported_dtypes( - {"0.4.20 and below": ("bfloat16",)}, + {"0.4.21 and below": ("bfloat16",)}, "jax", ) @to_ivy_arrays_and_back @@ -420,7 +420,7 @@ def expm1( @with_unsupported_dtypes( - {"0.4.20 and below": ("uint16",)}, + {"0.4.21 and below": ("uint16",)}, "jax", ) @to_ivy_arrays_and_back @@ -584,7 +584,7 @@ def minimum(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.20 and below": ("complex",)}, "jax") +@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, "jax") def mod(x1, x2, /): x1, x2 = promote_types_of_jax_inputs(x1, x2) return ivy.remainder(x1, x2) @@ -626,7 +626,7 @@ def negative( @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "bfloat16", "float16", ) @@ -671,7 +671,7 @@ def polyadd(a1, a2): @with_unsupported_dtypes( - {"0.4.20 and below": ("float16",)}, + {"0.4.21 and below": ("float16",)}, "jax", ) @to_ivy_arrays_and_back @@ -713,7 +713,7 @@ def polydiv(u, v, *, trim_leading_zeros=False): @with_unsupported_dtypes( - {"0.4.20 and below": ("float16",)}, + {"0.4.21 and below": ("float16",)}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/numpy/searching_sorting.py b/ivy/functional/frontends/jax/numpy/searching_sorting.py index 3ad8b7b6d835f..bd692378a6749 100644 --- a/ivy/functional/frontends/jax/numpy/searching_sorting.py +++ b/ivy/functional/frontends/jax/numpy/searching_sorting.py @@ -15,7 +15,7 @@ @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -58,7 +58,7 @@ def argwhere(a, /, *, size=None, fill_value=None): @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "uint8", "int8", "bool", diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py index bb40e941322a4..43ed0fe0499b7 100644 --- a/ivy/functional/frontends/jax/numpy/statistical.py +++ b/ivy/functional/frontends/jax/numpy/statistical.py @@ -103,7 +103,7 @@ def corrcoef(x, y=None, rowvar=True): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.20 and below": ("float16", "bfloat16")}, "jax") +@with_unsupported_dtypes({"0.4.21 and below": ("float16", "bfloat16")}, "jax") def correlate(a, v, mode="valid", precision=None): if ivy.get_num_dims(a) != 1 or ivy.get_num_dims(v) != 1: raise ValueError("correlate() only support 1-dimensional inputs.") @@ -572,7 +572,7 @@ def ptp(a, axis=None, out=None, keepdims=False): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.20 and below": ("complex64", "complex128", "bfloat16", "bool", "float16")}, + {"0.4.21 and below": ("complex64", "complex128", "bfloat16", "bool", "float16")}, "jax", ) def quantile( @@ -597,7 +597,7 @@ def quantile( @handle_jax_dtype -@with_unsupported_dtypes({"0.4.20 and below": ("bfloat16",)}, "jax") +@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, "jax") @to_ivy_arrays_and_back def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=None): axis = tuple(axis) if isinstance(axis, list) else axis diff --git a/ivy/functional/frontends/jax/random.py b/ivy/functional/frontends/jax/random.py index f8adcc6778a04..898b45aa05a5a 100644 --- a/ivy/functional/frontends/jax/random.py +++ b/ivy/functional/frontends/jax/random.py @@ -38,7 +38,7 @@ def PRNGKey(seed): @to_ivy_arrays_and_back @with_supported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float32", "float64", ) @@ -70,7 +70,7 @@ def bernoulli(key, p=0.5, shape=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -85,7 +85,7 @@ def beta(key, a, b, shape=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -133,7 +133,7 @@ def cauchy(key, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -149,7 +149,7 @@ def dirichlet(key, alpha, shape=None, dtype="float32"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.20 and below": "uint32"}, + {"0.4.21 and below": "uint32"}, "jax", ) def double_sided_maxwell(key, loc, scale, shape=(), dtype="float64"): @@ -168,7 +168,7 @@ def double_sided_maxwell(key, loc, scale, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -196,7 +196,7 @@ def fold_in(key, data): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -212,7 +212,7 @@ def gamma(key, a, shape=None, dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -231,7 +231,7 @@ def generalized_normal(key, p, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -255,7 +255,7 @@ def gumbel(key, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -270,7 +270,7 @@ def loggamma(key, a, shape=None, dtype="float64"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.20 and below": ("float16", "bfloat16")}, + {"0.4.21 and below": ("float16", "bfloat16")}, "jax", ) def logistic(key, shape=(), dtype="float64"): @@ -301,7 +301,7 @@ def maxwell(key, shape, dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -358,7 +358,7 @@ def orthogonal(key, n, shape=(), dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.20 and below": ( + "0.4.21 and below": ( "float16", "bfloat16", ) @@ -393,7 +393,7 @@ def permutation(key, x, axis=0, independent=False): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.20 and below": ("unsigned", "int8", "int16")}, + {"0.4.21 and below": ("unsigned", "int8", "int16")}, "jax", ) def poisson(key, lam, shape=None, dtype=None): @@ -404,7 +404,7 @@ def poisson(key, lam, shape=None, dtype=None): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.20 and below": ("unsigned", "int8", "int16")}, + {"0.4.21 and below": ("unsigned", "int8", "int16")}, "jax", ) def rademacher(key, shape, dtype="int64"): @@ -418,7 +418,7 @@ def rademacher(key, shape, dtype="int64"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.20 and below": ("unsigned", "int8", "int16")}, + {"0.4.21 and below": ("unsigned", "int8", "int16")}, "jax", ) def randint(key, shape, minval, maxval, dtype="int64"): From dec9ce63fa5d73a5b5c7b85718cb6a119009076c Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 8 Dec 2023 01:47:33 +0530 Subject: [PATCH 322/978] fix: Fixed using `callable` to check if x is callable instead of `hasattr` (#27447) --- .../test_ivy/test_functional/test_core/test_general.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index edf425cb782c1..0ce3c2eb561c7 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -627,13 +627,13 @@ def test_default(x, default_val, test_flags, backend_fw): with BackendHandler.update_backend(backend_fw) as ivy_backend: with_callable = False if x is not None: - if hasattr(x, "__call__"): + if callable(x): with_callable = True else: x_dtype, x = x x = x[0].tolist() if isinstance(x, list) else x else: - if hasattr(default_val, "__call__"): + if callable(default_val): with_callable = True else: dv_dtype, default_val = default_val @@ -845,7 +845,7 @@ def test_einops_repeat( ) def test_exists(x): if x is not None: - if not hasattr(x, "__call__"): + if not callable(x): dtype, x = x ret = ivy.exists(x) assert isinstance(ret, bool) From f4627106bcc6a07c3746cf6949948b34c76dbb3a Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 8 Dec 2023 21:20:55 +0000 Subject: [PATCH 323/978] fix: use the correct parameter name in torch.unique call as in https://pytorch.org/docs/2.1/generated/torch.unique.html#torch-unique --- ivy/functional/backends/torch/set.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/torch/set.py b/ivy/functional/backends/torch/set.py index 6f232ee2864a3..397f81ea59745 100644 --- a/ivy/functional/backends/torch/set.py +++ b/ivy/functional/backends/torch/set.py @@ -114,7 +114,7 @@ def unique_inverse( x = torch.flatten(x) axis = 0 - values, inverse_indices = torch.unique(x, return_inverse=True, axis=axis) + values, inverse_indices = torch.unique(x, return_inverse=True, dim=axis) nan_idx = torch.isnan(x) if nan_idx.any(): inverse_indices[nan_idx] = torch.where(torch.isnan(values))[0][0] From 3c7917f671e99d2dd4492f7fc5846aebbf8de73a Mon Sep 17 00:00:00 2001 From: Arsalan ali Date: Sat, 9 Dec 2023 15:28:46 +0500 Subject: [PATCH 324/978] feat: implement add (#25940) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 4 +++ .../test_paddle/test_tensor/test_tensor.py | 35 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 530b36b1087f4..b7c451fbb0c33 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -420,6 +420,10 @@ def clip_(self, min=None, max=None, name=None): def tanh(self, name=None): return paddle_frontend.tanh(self) + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + def add(self, y, name=None): + return paddle_frontend.Tensor(ivy.add(self._ivy_array, _to_ivy_array(y))) + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def add_(self, y, name=None): self.ivy_array = paddle_frontend.add(self, y).ivy_array diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 345fe4cbc04a5..72799ea0cf13c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -1179,6 +1179,41 @@ def test_paddle_acosh( ) +# add +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="add", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle_tensor_add( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={"y": x[1]}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # add_ @handle_frontend_method( class_tree=CLASS_TREE, From cb060cb6ae594442b86cde40fd2ee0708c0368d1 Mon Sep 17 00:00:00 2001 From: Adeola Abiola <42617783+Adeola23@users.noreply.github.com> Date: Sat, 9 Dec 2023 10:31:43 +0000 Subject: [PATCH 325/978] feat(frontends): Implemented acos for Paddle.tensor.tensor.Tensor (#26013) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 4 +++ .../test_paddle/test_tensor/test_tensor.py | 34 +++++++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index b7c451fbb0c33..e18f35a224a08 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -957,6 +957,10 @@ def nonzero(self): def inner(self, y, name=None): return paddle_frontend.inner(self, y, name) + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + def acos(self, name=None): + return paddle_frontend.Tensor(ivy.acos(self._ivy_array)) + @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def mean(self, axis=None, keepdim=False, name=None): return paddle_frontend.mean(self, axis=axis, keepdim=keepdim) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 72799ea0cf13c..0921b094e50bb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -1144,6 +1144,40 @@ def test_paddle_abs( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="acos", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + ), +) +def test_paddle_tensor_acos( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # acosh @handle_frontend_method( class_tree=CLASS_TREE, From a2b6d2eb671c649d85d8a6b281db123d576205c8 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sat, 9 Dec 2023 16:40:16 +0400 Subject: [PATCH 326/978] fix: Replace project.toml to pyproject.toml (#27441) --- .github/workflows/intelligent-tests-pr.yml | 2 +- project.toml => pyproject.toml | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename project.toml => pyproject.toml (100%) diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index 66c3af4eb79c9..ece59285375a0 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -81,7 +81,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/project.toml b/pyproject.toml similarity index 100% rename from project.toml rename to pyproject.toml From 1f94af4db0f203125067a921daecbdef8f79e87a Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 9 Dec 2023 12:41:49 +0000 Subject: [PATCH 327/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/__init__.py | 24 +- ivy/compiler/compiler.py | 10 +- ivy/compiler/replace_with.py | 9 +- ivy/data_classes/array/activations.py | 55 +- ivy/data_classes/array/array.py | 126 +- ivy/data_classes/array/conversions.py | 44 +- ivy/data_classes/array/creation.py | 91 +- ivy/data_classes/array/data_type.py | 54 +- ivy/data_classes/array/device.py | 14 +- ivy/data_classes/array/elementwise.py | 520 ++++----- .../array/experimental/activations.py | 93 +- .../array/experimental/creation.py | 55 +- .../array/experimental/elementwise.py | 197 ++-- .../array/experimental/general.py | 7 +- ivy/data_classes/array/experimental/layers.py | 113 +- .../array/experimental/linear_algebra.py | 166 ++- ivy/data_classes/array/experimental/losses.py | 45 +- .../array/experimental/manipulation.py | 218 ++-- ivy/data_classes/array/experimental/norms.py | 30 +- ivy/data_classes/array/experimental/random.py | 21 +- .../array/experimental/searching.py | 7 +- .../array/experimental/sorting.py | 7 +- .../array/experimental/statistical.py | 91 +- .../array/experimental/utility.py | 9 +- ivy/data_classes/array/general.py | 227 ++-- ivy/data_classes/array/gradients.py | 50 +- ivy/data_classes/array/layers.py | 102 +- ivy/data_classes/array/linear_algebra.py | 116 +- ivy/data_classes/array/losses.py | 23 +- ivy/data_classes/array/manipulation.py | 112 +- ivy/data_classes/array/norms.py | 7 +- ivy/data_classes/array/random.py | 35 +- ivy/data_classes/array/searching.py | 35 +- ivy/data_classes/array/set.py | 21 +- ivy/data_classes/array/sorting.py | 24 +- ivy/data_classes/array/statistical.py | 59 +- ivy/data_classes/array/utility.py | 14 +- ivy/data_classes/array/wrapping.py | 13 +- ivy/data_classes/container/activations.py | 126 +- ivy/data_classes/container/base.py | 356 +++--- ivy/data_classes/container/container.py | 95 +- ivy/data_classes/container/conversions.py | 15 +- ivy/data_classes/container/creation.py | 91 +- ivy/data_classes/container/data_type.py | 117 +- ivy/data_classes/container/device.py | 28 +- ivy/data_classes/container/elementwise.py | 1040 +++++++---------- .../container/experimental/activations.py | 184 ++- .../container/experimental/creation.py | 171 ++- .../container/experimental/elementwise.py | 373 +++--- .../container/experimental/general.py | 14 +- .../container/experimental/layers.py | 234 ++-- .../container/experimental/linear_algebra.py | 299 +++-- .../container/experimental/losses.py | 98 +- .../container/experimental/manipulation.py | 407 +++---- .../container/experimental/norms.py | 84 +- .../container/experimental/random.py | 56 +- .../container/experimental/searching.py | 14 +- .../container/experimental/sorting.py | 20 +- .../container/experimental/statistical.py | 182 ++- .../container/experimental/utility.py | 16 +- ivy/data_classes/container/general.py | 430 +++---- ivy/data_classes/container/gradients.py | 52 +- ivy/data_classes/container/layers.py | 200 ++-- ivy/data_classes/container/linear_algebra.py | 261 ++--- ivy/data_classes/container/losses.py | 46 +- ivy/data_classes/container/manipulation.py | 216 ++-- ivy/data_classes/container/norms.py | 7 +- ivy/data_classes/container/random.py | 70 +- ivy/data_classes/container/searching.py | 70 +- ivy/data_classes/container/set.py | 47 +- ivy/data_classes/container/sorting.py | 48 +- ivy/data_classes/container/statistical.py | 84 +- ivy/data_classes/container/utility.py | 28 +- ivy/data_classes/container/wrapping.py | 8 +- .../factorized_tensor/cp_tensor.py | 54 +- .../factorized_tensor/parafac2_tensor.py | 34 +- .../factorized_tensor/tt_tensor.py | 25 +- ivy/func_wrapper.py | 116 +- ivy/functional/backends/jax/activations.py | 3 +- ivy/functional/backends/jax/device.py | 3 +- ivy/functional/backends/jax/general.py | 3 +- ivy/functional/backends/jax/gradients.py | 3 +- ivy/functional/backends/jax/layers.py | 3 +- ivy/functional/backends/jax/random.py | 3 +- ivy/functional/backends/mxnet/activations.py | 3 +- ivy/functional/backends/mxnet/device.py | 3 +- ivy/functional/backends/mxnet/gradients.py | 3 +- ivy/functional/backends/mxnet/layers.py | 3 +- ivy/functional/backends/mxnet/random.py | 3 +- ivy/functional/backends/numpy/activations.py | 3 +- ivy/functional/backends/numpy/device.py | 3 +- ivy/functional/backends/numpy/general.py | 3 +- ivy/functional/backends/numpy/gradients.py | 3 +- ivy/functional/backends/numpy/helpers.py | 3 +- ivy/functional/backends/numpy/layers.py | 3 +- ivy/functional/backends/numpy/random.py | 3 +- ivy/functional/backends/paddle/activations.py | 3 +- ivy/functional/backends/paddle/device.py | 3 +- .../paddle/experimental/elementwise.py | 3 +- ivy/functional/backends/paddle/general.py | 3 +- ivy/functional/backends/paddle/gradients.py | 3 +- ivy/functional/backends/paddle/layers.py | 3 +- ivy/functional/backends/paddle/random.py | 3 +- .../backends/tensorflow/activations.py | 3 +- ivy/functional/backends/tensorflow/device.py | 3 +- ivy/functional/backends/tensorflow/general.py | 3 +- .../backends/tensorflow/gradients.py | 3 +- ivy/functional/backends/tensorflow/layers.py | 3 +- ivy/functional/backends/tensorflow/random.py | 3 +- .../experimental/statistical.py | 5 +- ivy/functional/backends/torch/activations.py | 3 +- ivy/functional/backends/torch/device.py | 3 +- ivy/functional/backends/torch/general.py | 3 +- ivy/functional/backends/torch/gradients.py | 3 +- ivy/functional/backends/torch/layers.py | 3 +- ivy/functional/backends/torch/random.py | 3 +- .../frontends/jax/numpy/__init__.py | 9 +- .../mindspore/ops/function/nn_func.py | 4 +- .../frontends/mxnet/func_wrapper.py | 9 +- .../frontends/mxnet/numpy/__init__.py | 9 +- ivy/functional/frontends/numpy/__init__.py | 5 +- .../frontends/numpy/func_wrapper.py | 28 +- .../numpy/statistics/order_statistics.py | 3 +- ivy/functional/frontends/onnx/__init__.py | 9 +- ivy/functional/frontends/onnx/func_wrapper.py | 9 +- ivy/functional/frontends/paddle/__init__.py | 9 +- ivy/functional/frontends/paddle/fft.py | 4 +- .../frontends/paddle/func_wrapper.py | 9 +- .../frontends/tensorflow/__init__.py | 7 +- .../frontends/tensorflow/func_wrapper.py | 23 +- .../frontends/tensorflow/variable.py | 6 +- ivy/functional/frontends/torch/__init__.py | 9 +- .../frontends/torch/func_wrapper.py | 12 +- ivy/functional/frontends/torch/tensor.py | 3 +- ivy/functional/frontends/xgboost/core.py | 14 +- .../xgboost/linear/updater_coordinate.py | 18 +- ivy/functional/frontends/xgboost/sklearn.py | 8 +- ivy/functional/frontends/xgboost/training.py | 3 +- ivy/functional/ivy/activations.py | 30 +- ivy/functional/ivy/control_flow_ops.py | 18 +- ivy/functional/ivy/creation.py | 133 +-- ivy/functional/ivy/data_type.py | 136 +-- ivy/functional/ivy/device.py | 136 +-- ivy/functional/ivy/elementwise.py | 435 +++---- .../ivy/experimental/activations.py | 47 +- ivy/functional/ivy/experimental/creation.py | 107 +- .../ivy/experimental/elementwise.py | 116 +- ivy/functional/ivy/experimental/general.py | 4 +- ivy/functional/ivy/experimental/gradients.py | 9 +- ivy/functional/ivy/experimental/layers.py | 116 +- .../ivy/experimental/linear_algebra.py | 108 +- ivy/functional/ivy/experimental/losses.py | 31 +- .../ivy/experimental/manipulation.py | 162 ++- ivy/functional/ivy/experimental/norms.py | 14 +- ivy/functional/ivy/experimental/random.py | 25 +- ivy/functional/ivy/experimental/searching.py | 4 +- ivy/functional/ivy/experimental/sorting.py | 13 +- .../ivy/experimental/statistical.py | 45 +- ivy/functional/ivy/experimental/utility.py | 9 +- ivy/functional/ivy/general.py | 288 ++--- ivy/functional/ivy/gradients.py | 74 +- ivy/functional/ivy/layers.py | 86 +- ivy/functional/ivy/linear_algebra.py | 120 +- ivy/functional/ivy/losses.py | 9 +- ivy/functional/ivy/manipulation.py | 57 +- ivy/functional/ivy/meta.py | 12 +- ivy/functional/ivy/nest.py | 79 +- ivy/functional/ivy/norms.py | 3 +- ivy/functional/ivy/random.py | 31 +- ivy/functional/ivy/searching.py | 23 +- ivy/functional/ivy/set.py | 21 +- ivy/functional/ivy/sorting.py | 12 +- ivy/functional/ivy/statistical.py | 32 +- ivy/functional/ivy/utility.py | 8 +- ivy/stateful/activations.py | 39 +- ivy/stateful/converters.py | 24 +- ivy/stateful/helpers.py | 41 +- ivy/stateful/initializers.py | 41 +- ivy/stateful/layers.py | 200 ++-- ivy/stateful/losses.py | 6 +- ivy/stateful/module.py | 50 +- ivy/stateful/norms.py | 12 +- ivy/stateful/optimizers.py | 72 +- ivy/stateful/sequential.py | 8 +- ivy/utils/_importlib.py | 3 +- ivy/utils/backend/ast_helpers.py | 3 +- ivy/utils/backend/handler.py | 40 +- ivy/utils/einsum_parser.py | 33 +- ivy/utils/einsum_path_helpers.py | 47 +- ivy/utils/exceptions.py | 12 +- ivy/utils/inspection.py | 5 +- ivy/utils/logging.py | 6 +- ivy/utils/profiler.py | 3 +- ivy_tests/test_docstrings.py | 3 +- ivy_tests/test_ivy/helpers/assertions.py | 28 +- .../test_ivy/helpers/function_testing.py | 37 +- ivy_tests/test_ivy/helpers/globals.py | 8 +- .../hypothesis_helpers/array_helpers.py | 62 +- .../hypothesis_helpers/dtype_helpers.py | 14 +- .../hypothesis_helpers/general_helpers.py | 39 +- .../hypothesis_helpers/number_helpers.py | 11 +- ivy_tests/test_ivy/helpers/testing_helpers.py | 31 +- ivy_tests/test_ivy/test_frontends/__init__.py | 7 +- .../test_jax/test_numpy/test_linalg.py | 4 +- .../test_frontends/test_numpy/__init__.py | 3 +- .../test_frontends/test_numpy/helpers.py | 9 +- .../test_linalg/test_matrix_eigenvalues.py | 4 +- .../test_frontends/test_paddle/__init__.py | 3 +- .../test_frontends/test_scipy/__init__.py | 3 +- .../test_tensorflow/__init__.py | 3 +- .../test_tensorflow/test_raw_ops.py | 5 +- .../test_frontends/test_torch/__init__.py | 3 +- .../test_frontends/test_torch/test_linalg.py | 3 +- .../test_core/test_manipulation.py | 5 +- ivy_tests/test_ivy/test_misc/test_array.py | 3 +- scripts/eager_mode_benchmark/benchmark.py | 8 +- 216 files changed, 5268 insertions(+), 7212 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 61281bad72d9a..a816d0b255fd5 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -1012,8 +1012,7 @@ def vec_sig_fig(x, sig_fig=3): def set_array_significant_figures(sig_figs): - """ - Summary. + """Summary. Parameters ---------- @@ -1053,8 +1052,7 @@ def _assert_array_decimal_values_formatting(dec_vals): def set_array_decimal_values(dec_vals): - """ - Summary. + """Summary. Parameters ---------- @@ -1080,8 +1078,7 @@ def unset_array_decimal_values(): def set_warning_level(warn_level): - """ - Summary. + """Summary. Parameters ---------- @@ -1113,8 +1110,7 @@ def warn(warning_message, stacklevel=0): def set_nan_policy(warn_level): - """ - Summary. + """Summary. Parameters ---------- @@ -1147,7 +1143,8 @@ def unset_nan_policy(): def set_dynamic_backend(flag): - """Set the global dynamic backend setting to the provided flag (True or False)""" + """Set the global dynamic backend setting to the provided flag (True or + False)""" global dynamic_backend_stack if flag not in [True, False]: raise ValueError("dynamic_backend must be a boolean value (True or False)") @@ -1156,8 +1153,7 @@ def set_dynamic_backend(flag): def unset_dynamic_backend(): - """ - Remove the current dynamic backend setting. + """Remove the current dynamic backend setting. Also restore the previous setting (if any) """ @@ -1466,8 +1462,7 @@ def __init__(self): self.logging_mode_stack.append(logging.WARNING) def set_logging_mode(self, mode): - """ - Set the current logging mode for Ivy. + """Set the current logging mode for Ivy. Possible modes are 'DEBUG', 'INFO', 'WARNING', 'ERROR'. """ @@ -1480,7 +1475,8 @@ def set_logging_mode(self, mode): self.logging_mode_stack.append(mode) def unset_logging_mode(self): - """Remove the most recently set logging mode, returning to the previous one.""" + """Remove the most recently set logging mode, returning to the previous + one.""" if len(self.logging_mode_stack) > 1: # Remove the current mode self.logging_mode_stack.pop() diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 97f8ada162541..ba5f858ee07d7 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -20,8 +20,8 @@ def trace_graph( params_v=None, v=None ): - """ - Take `fn` and traces it into a more efficient composition of backend operations. + """Take `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -131,9 +131,9 @@ def transpile( params_v=None, v=None ): - """ - Transpiles Callable objects passed as arguments. If args and kwargs are specified, - transpilation is performed eagerly, otherwise, transpilation will happen lazily. + """Transpiles Callable objects passed as arguments. If args and kwargs are + specified, transpilation is performed eagerly, otherwise, transpilation + will happen lazily. Parameters ---------- diff --git a/ivy/compiler/replace_with.py b/ivy/compiler/replace_with.py index 51af07f192249..2bfdd8140b7b5 100644 --- a/ivy/compiler/replace_with.py +++ b/ivy/compiler/replace_with.py @@ -6,8 +6,7 @@ def replace_with(new_func): - """ - Decorate a function/method/attribute to be replaced by another. + """Decorate a function/method/attribute to be replaced by another. Parameters ---------- @@ -43,7 +42,8 @@ def decorator(original_func): class ReplaceFunction(ast.NodeTransformer): - """AST Node Transformer to replace function calls, methods, and attributes.""" + """AST Node Transformer to replace function calls, methods, and + attributes.""" def visit_Attribute(self, node): if ( @@ -69,7 +69,8 @@ def visit_Call(self, node): def transform_function(func): - """Transform the function by replacing its calls based on the replace_map.""" + """Transform the function by replacing its calls based on the + replace_map.""" source = inspect.getsource(func) tree = ast.parse(source) transformed_tree = ReplaceFunction().visit(tree) diff --git a/ivy/data_classes/array/activations.py b/ivy/data_classes/array/activations.py index 950dd0512b6f7..6fcdafe056a19 100644 --- a/ivy/data_classes/array/activations.py +++ b/ivy/data_classes/array/activations.py @@ -17,10 +17,9 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.relu. This method simply wraps the - function, and so the docstring for ivy.relu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.relu. This method simply + wraps the function, and so the docstring for ivy.relu also applies to + this method with minimal changes. Parameters ---------- @@ -55,10 +54,9 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.leaky_relu. This method simply wraps - the function, and so the docstring for ivy.leaky_relu also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.leaky_relu. This method + simply wraps the function, and so the docstring for ivy.leaky_relu also + applies to this method with minimal changes. Parameters ---------- @@ -97,10 +95,9 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gelu. This method simply wraps the - function, and so the docstring for ivy.gelu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.gelu. This method simply + wraps the function, and so the docstring for ivy.gelu also applies to + this method with minimal changes. Parameters ---------- @@ -138,8 +135,7 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sigmoid. + """ivy.Array instance method variant of ivy.sigmoid. This method simply wraps the function, and so the docstring for ivy.sigmoid also applies to this method with minimal changes. @@ -178,10 +174,9 @@ def softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.softmax. This method simply wraps the - function, and so the docstring for ivy.softmax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.softmax. This method simply + wraps the function, and so the docstring for ivy.softmax also applies + to this method with minimal changes. Parameters ---------- @@ -219,10 +214,9 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.softplus. This method simply wraps the - function, and so the docstring for ivy.softplus also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.softplus. This method + simply wraps the function, and so the docstring for ivy.softplus also + applies to this method with minimal changes. Parameters ---------- @@ -276,10 +270,9 @@ def log_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log_softmax. This method simply wraps - the function, and so the docstring for ivy.log_softmax also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.log_softmax. This method + simply wraps the function, and so the docstring for ivy.log_softmax + also applies to this method with minimal changes. Parameters ---------- @@ -324,10 +317,9 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.mish. This method simply wraps the - function, and so the docstring for ivy.mish also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.mish. This method simply + wraps the function, and so the docstring for ivy.mish also applies to + this method with minimal changes. Parameters ---------- @@ -356,8 +348,7 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the hardswish activation function element-wise. + """Apply the hardswish activation function element-wise. Parameters ---------- diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 06b5cb4d4615a..358efed6ddd7b 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -232,8 +232,7 @@ def device(self) -> ivy.Device: @property def mT(self) -> ivy.Array: - """ - Transpose of a matrix (or a stack of matrices). + """Transpose of a matrix (or a stack of matrices). Returns ------- @@ -290,8 +289,7 @@ def strides(self) -> Optional[int]: @property def T(self) -> ivy.Array: - """ - Transpose of the array. + """Transpose of the array. Returns ------- @@ -309,8 +307,7 @@ def base(self) -> ivy.Array: @property def real(self) -> ivy.Array: - """ - Real part of the array. + """Real part of the array. Returns ------- @@ -323,8 +320,7 @@ def real(self) -> ivy.Array: @property def imag(self) -> ivy.Array: - """ - Imaginary part of the array. + """Imaginary part of the array. Returns ------- @@ -479,10 +475,9 @@ def __neg__(self): return ivy.negative(self._data) def __pow__(self, power): - """ - ivy.Array special method variant of ivy.pow. This method simply wraps the - function, and so the docstring for ivy.pow also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.pow. This method simply + wraps the function, and so the docstring for ivy.pow also applies to + this method with minimal changes. Parameters ---------- @@ -521,10 +516,9 @@ def __ipow__(self, power): return ivy.pow(self._data, power) def __add__(self, other): - """ - ivy.Array special method variant of ivy.add. This method simply wraps the - function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.add. This method simply + wraps the function, and so the docstring for ivy.add also applies to + this method with minimal changes. Parameters ---------- @@ -551,10 +545,9 @@ def __add__(self, other): return ivy.add(self._data, other) def __radd__(self, other): - """ - ivy.Array reverse special method variant of ivy.add. This method simply wraps - the function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Array reverse special method variant of ivy.add. This method + simply wraps the function, and so the docstring for ivy.add also + applies to this method with minimal changes. Parameters ---------- @@ -584,10 +577,9 @@ def __iadd__(self, other): return ivy.add(self._data, other) def __sub__(self, other): - """ - ivy.Array special method variant of ivy.subtract. This method simply wraps the - function, and so the docstring for ivy.subtract also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.subtract. This method simply + wraps the function, and so the docstring for ivy.subtract also applies + to this method with minimal changes. Parameters ---------- @@ -616,10 +608,9 @@ def __sub__(self, other): return ivy.subtract(self._data, other) def __rsub__(self, other): - """ - ivy.Array reverse special method variant of ivy.subtract. This method simply - wraps the function, and so the docstring for ivy.subtract also applies to this - method with minimal changes. + """ivy.Array reverse special method variant of ivy.subtract. This + method simply wraps the function, and so the docstring for ivy.subtract + also applies to this method with minimal changes. Parameters ---------- @@ -673,10 +664,9 @@ def __rdivmod__(self, other): return ivy.divide(other, self._data), ivy.remainder(other, self._data) def __truediv__(self, other): - """ - ivy.Array reverse special method variant of ivy.divide. This method simply wraps - the function, and so the docstring for ivy.divide also applies to this method - with minimal changes. + """ivy.Array reverse special method variant of ivy.divide. This method + simply wraps the function, and so the docstring for ivy.divide also + applies to this method with minimal changes. Parameters ---------- @@ -727,10 +717,9 @@ def __imatmul__(self, other): return ivy.matmul(self._data, other) def __abs__(self): - """ - ivy.Array special method variant of ivy.abs. This method simply wraps the - function, and so the docstring for ivy.abs also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.abs. This method simply + wraps the function, and so the docstring for ivy.abs also applies to + this method with minimal changes. Parameters ---------- @@ -803,10 +792,9 @@ def __dlpack_device__(self): return self._data.__dlpack_device__() def __lt__(self, other): - """ - ivy.Array special method variant of ivy.less. This method simply wraps the - function, and so the docstring for ivy.less also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.less. This method simply + wraps the function, and so the docstring for ivy.less also applies to + this method with minimal changes. Parameters ---------- @@ -833,10 +821,9 @@ def __lt__(self, other): return ivy.less(self._data, other) def __le__(self, other): - """ - ivy.Array special method variant of ivy.less_equal. This method simply wraps the - function, and so the docstring for ivy.less_equal also applies to this method - with minimal changes. + """ivy.Array special method variant of ivy.less_equal. This method + simply wraps the function, and so the docstring for ivy.less_equal also + applies to this method with minimal changes. Parameters ---------- @@ -863,10 +850,9 @@ def __le__(self, other): return ivy.less_equal(self._data, other) def __eq__(self, other): - """ - ivy.Array special method variant of ivy.equal. This method simply wraps the - function, and so the docstring for ivy.equal also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.equal. This method simply + wraps the function, and so the docstring for ivy.equal also applies to + this method with minimal changes. Parameters ---------- @@ -901,10 +887,9 @@ def __eq__(self, other): return ivy.equal(self._data, other) def __ne__(self, other): - """ - ivy.Array special method variant of ivy.not_equal. This method simply wraps the - function, and so the docstring for ivy.not_equal also applies to this method - with minimal changes. + """ivy.Array special method variant of ivy.not_equal. This method + simply wraps the function, and so the docstring for ivy.not_equal also + applies to this method with minimal changes. Parameters ---------- @@ -939,10 +924,9 @@ def __ne__(self, other): return ivy.not_equal(self._data, other) def __gt__(self, other): - """ - ivy.Array special method variant of ivy.greater. This method simply wraps the - function, and so the docstring for ivy.greater also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.greater. This method simply + wraps the function, and so the docstring for ivy.greater also applies + to this method with minimal changes. Parameters ---------- @@ -986,10 +970,9 @@ def __gt__(self, other): return ivy.greater(self._data, other) def __ge__(self, other): - """ - ivy.Array special method variant of ivy.greater_equal. This method simply wraps - the function, and so the docstring for ivy.bitwise_xor also applies to this - method with minimal changes. + """ivy.Array special method variant of ivy.greater_equal. This method + simply wraps the function, and so the docstring for ivy.bitwise_xor + also applies to this method with minimal changes. Parameters ---------- @@ -1054,10 +1037,9 @@ def __invert__(self): return ivy.bitwise_invert(self._data) def __xor__(self, other): - """ - ivy.Array special method variant of ivy.bitwise_xor. This method simply wraps - the function, and so the docstring for ivy.bitwise_xor also applies to this - method with minimal changes. + """ivy.Array special method variant of ivy.bitwise_xor. This method + simply wraps the function, and so the docstring for ivy.bitwise_xor + also applies to this method with minimal changes. Parameters ---------- @@ -1112,10 +1094,10 @@ def __ilshift__(self, other): return ivy.bitwise_left_shift(self._data, other) def __rshift__(self, other): - """ - ivy.Array special method variant of ivy.bitwise_right_shift. This method simply - wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Array special method variant of ivy.bitwise_right_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- @@ -1145,10 +1127,10 @@ def __rshift__(self, other): return ivy.bitwise_right_shift(self._data, other) def __rrshift__(self, other): - """ - ivy.Array reverse special method variant of ivy.bitwise_right_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Array reverse special method variant of ivy.bitwise_right_shift. + This method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/array/conversions.py b/ivy/data_classes/array/conversions.py index 988286408e763..67898f34951cd 100644 --- a/ivy/data_classes/array/conversions.py +++ b/ivy/data_classes/array/conversions.py @@ -1,5 +1,4 @@ -""" -Ivy wrapping functions for conversions. +"""Ivy wrapping functions for conversions. Collection of Ivy functions for wrapping functions to accept and return ivy.Array instances. @@ -141,10 +140,10 @@ def to_ivy( nested: bool = False, include_derived: Optional[Dict[str, bool]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """ - Return the input array converted to an ivy.Array instance if it is a native array - type, otherwise the input is returned unchanged. If nested is set, the check is - applied to all nested leafs of tuples, lists and dicts contained within x. + """Return the input array converted to an ivy.Array instance if it is a + native array type, otherwise the input is returned unchanged. If nested is + set, the check is applied to all nested leafs of tuples, lists and dicts + contained within x. Parameters ---------- @@ -173,9 +172,8 @@ def args_to_ivy( include_derived: Optional[Dict[str, bool]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """ - Return args and keyword args in their ivy.Array or form for all nested instances, - otherwise the arguments are returned unchanged. + """Return args and keyword args in their ivy.Array or form for all nested + instances, otherwise the arguments are returned unchanged. Parameters ---------- @@ -205,10 +203,10 @@ def to_native( cont_inplace: bool = False, to_ignore: Optional[Union[type, Tuple[type]]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """ - Return the input item in its native backend framework form if it is an ivy.Array - instance, otherwise the input is returned unchanged. If nested is set, the check is - applied to all nested leaves of tuples, lists and dicts contained within ``x``. + """Return the input item in its native backend framework form if it is an + ivy.Array instance, otherwise the input is returned unchanged. If nested is + set, the check is applied to all nested leaves of tuples, lists and dicts + contained within ``x``. Parameters ---------- @@ -248,9 +246,9 @@ def args_to_native( to_ignore: Optional[Union[type, Tuple[type]]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """ - Return args and keyword args in their native backend framework form for all nested - ivy.Array instances, otherwise the arguments are returned unchanged. + """Return args and keyword args in their native backend framework form for + all nested ivy.Array instances, otherwise the arguments are returned + unchanged. Parameters ---------- @@ -296,11 +294,10 @@ def to_new_backend( cont_inplace: bool = False, to_ignore: Optional[Union[type, Tuple[type]]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """ - Return the input array converted to new backend framework form if it is an - `ivy.Array`, `ivy.NativeArray` or NativeVariable instance. If nested is set, the - check is applied to all nested leaves of tuples, lists and dicts contained within - ``x``. + """Return the input array converted to new backend framework form if it is + an `ivy.Array`, `ivy.NativeArray` or NativeVariable instance. If nested is + set, the check is applied to all nested leaves of tuples, lists and dicts + contained within ``x``. Parameters ---------- @@ -347,9 +344,8 @@ def args_to_new_backend( to_ignore: Optional[Union[type, Tuple[type]]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """ - Return args and keyword args in the new current backend framework for all nested - ivy.Array, ivy.NativeArray or NativeVariable instances. + """Return args and keyword args in the new current backend framework for + all nested ivy.Array, ivy.NativeArray or NativeVariable instances. Parameters ---------- diff --git a/ivy/data_classes/array/creation.py b/ivy/data_classes/array/creation.py index 94e2ab7a096d3..6486096f38b13 100644 --- a/ivy/data_classes/array/creation.py +++ b/ivy/data_classes/array/creation.py @@ -21,10 +21,9 @@ def asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.asarray. This method simply wraps the - function, and so the docstring for ivy.asarray also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.asarray. This method simply + wraps the function, and so the docstring for ivy.asarray also applies + to this method with minimal changes. Parameters ---------- @@ -87,10 +86,9 @@ def full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.full_like. This method simply wraps the - function, and so the docstring for ivy.full_like also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.full_like. This method + simply wraps the function, and so the docstring for ivy.full_like also + applies to this method with minimal changes. Parameters ---------- @@ -151,10 +149,9 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ones_like. This method simply wraps the - function, and so the docstring for ivy.ones_like also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.ones_like. This method + simply wraps the function, and so the docstring for ivy.ones_like also + applies to this method with minimal changes. Parameters ---------- @@ -185,10 +182,9 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.zeros_like. This method simply wraps - the function, and so the docstring for ivy.zeros_like also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.zeros_like. This method + simply wraps the function, and so the docstring for ivy.zeros_like also + applies to this method with minimal changes. Parameters ---------- @@ -214,10 +210,9 @@ def zeros_like( def tril( self: ivy.Array, /, *, k: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tril. This method simply wraps the - function, and so the docstring for ivy.tril also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tril. This method simply + wraps the function, and so the docstring for ivy.tril also applies to + this method with minimal changes. Parameters ---------- @@ -245,10 +240,9 @@ def tril( def triu( self: ivy.Array, /, *, k: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.triu. This method simply wraps the - function, and so the docstring for ivy.triu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.triu. This method simply + wraps the function, and so the docstring for ivy.triu also applies to + this method with minimal changes. Parameters ---------- @@ -281,10 +275,9 @@ def empty_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.empty_like. This method simply wraps - the function, and so the docstring for ivy.empty_like also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.empty_like. This method + simply wraps the function, and so the docstring for ivy.empty_like also + applies to this method with minimal changes. Parameters ---------- @@ -315,10 +308,9 @@ def meshgrid( sparse: bool = False, indexing: str = "xy", ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.meshgrid. This method simply wraps the - function, and so the docstring for ivy.meshgrid also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.meshgrid. This method + simply wraps the function, and so the docstring for ivy.meshgrid also + applies to this method with minimal changes. Parameters ---------- @@ -351,10 +343,9 @@ def from_dlpack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.from_dlpack. This method simply wraps - the function, and so the docstring for ivy.from_dlpack also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.from_dlpack. This method + simply wraps the function, and so the docstring for ivy.from_dlpack + also applies to this method with minimal changes. Parameters ---------- @@ -381,10 +372,9 @@ def copy_array( to_ivy_array: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.copy_array. This method simply wraps - the function, and so the docstring for ivy.copy_array also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.copy_array. This method + simply wraps the function, and so the docstring for ivy.copy_array also + applies to this method with minimal changes. Parameters ---------- @@ -412,10 +402,9 @@ def native_array( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.NativeArray: - """ - ivy.Array instance method variant of ivy.native_array. This method simply wraps - the function, and so the docstring for ivy.native_array also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.native_array. This method + simply wraps the function, and so the docstring for ivy.native_array + also applies to this method with minimal changes. Parameters ---------- @@ -445,10 +434,9 @@ def one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.one_hot. This method simply wraps the - function, and so the docstring for ivy.one_hot also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.one_hot. This method simply + wraps the function, and so the docstring for ivy.one_hot also applies + to this method with minimal changes. Parameters ---------- @@ -549,10 +537,9 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logspace. This method simply wraps the - function, and so the docstring for ivy.logspace also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.logspace. This method + simply wraps the function, and so the docstring for ivy.logspace also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/data_type.py b/ivy/data_classes/array/data_type.py index 01cdedea04c58..afaaade47303c 100644 --- a/ivy/data_classes/array/data_type.py +++ b/ivy/data_classes/array/data_type.py @@ -18,9 +18,8 @@ def astype( copy: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Copy an array to a specified data type irrespective of :ref:`type- promotion` - rules. + """Copy an array to a specified data type irrespective of :ref:`type- + promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -69,10 +68,10 @@ def astype( def broadcast_arrays( self: ivy.Array, *arrays: Union[ivy.Array, ivy.NativeArray] ) -> List[ivy.Array]: - """ - `ivy.Array` instance method variant of `ivy.broadcast_arrays`. This method - simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also - applies to this method with minimal changes. + """`ivy.Array` instance method variant of `ivy.broadcast_arrays`. This + method simply wraps the function, and so the docstring for + `ivy.broadcast_arrays` also applies to this method with minimal + changes. Parameters ---------- @@ -113,10 +112,9 @@ def broadcast_arrays( def broadcast_to( self: ivy.Array, /, shape: Tuple[int, ...], *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - `ivy.Array` instance method variant of `ivy.broadcast_to`. This method simply - wraps the function, and so the docstring for `ivy.broadcast_to` also applies to - this method with minimal changes. + """`ivy.Array` instance method variant of `ivy.broadcast_to`. This + method simply wraps the function, and so the docstring for + `ivy.broadcast_to` also applies to this method with minimal changes. Parameters ---------- @@ -146,10 +144,9 @@ def broadcast_to( return ivy.broadcast_to(self._data, shape=shape, out=out) def can_cast(self: ivy.Array, to: ivy.Dtype) -> bool: - """ - `ivy.Array` instance method variant of `ivy.can_cast`. This method simply wraps - the function, and so the docstring for `ivy.can_cast` also applies to this - method with minimal changes. + """`ivy.Array` instance method variant of `ivy.can_cast`. This method + simply wraps the function, and so the docstring for `ivy.can_cast` also + applies to this method with minimal changes. Parameters ---------- @@ -179,9 +176,8 @@ def can_cast(self: ivy.Array, to: ivy.Dtype) -> bool: def dtype( self: ivy.Array, as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """ - `ivy.Array` instance method variant of `ivy.dtype`. This method helps to get the - data type of the array. + """`ivy.Array` instance method variant of `ivy.dtype`. This method + helps to get the data type of the array. Parameters ---------- @@ -212,8 +208,7 @@ def dtype( return ivy.dtype(self._data, as_native=as_native) def finfo(self: ivy.Array, /) -> Finfo: - """ - Array instance method variant of `ivy.finfo`. + """Array instance method variant of `ivy.finfo`. Parameters ---------- @@ -235,10 +230,9 @@ def finfo(self: ivy.Array, /) -> Finfo: return ivy.finfo(self._data) def iinfo(self: ivy.Array, /) -> Iinfo: - """ - `ivy.Array` instance method variant of `ivy.iinfo`. This method simply wraps the - function, and so the docstring for `ivy.iinfo` also applies to this method with - minimal changes. + """`ivy.Array` instance method variant of `ivy.iinfo`. This method + simply wraps the function, and so the docstring for `ivy.iinfo` also + applies to this method with minimal changes. Parameters ---------- @@ -267,9 +261,8 @@ def is_bool_dtype(self: ivy.Array) -> bool: return ivy.is_bool_dtype(self._data) def is_float_dtype(self: ivy.Array) -> bool: - """ - `ivy.Array` instance method variant of `ivy.is_float_dtype`. This method simply - checks to see if the array is of type `float`. + """`ivy.Array` instance method variant of `ivy.is_float_dtype`. This + method simply checks to see if the array is of type `float`. Parameters ---------- @@ -303,10 +296,9 @@ def result_type( self: ivy.Array, *arrays_and_dtypes: Union[ivy.Array, ivy.NativeArray, ivy.Dtype], ) -> ivy.Dtype: - """ - `ivy.Array` instance method variant of `ivy.result_type`. This method simply - wraps the function, and so the docstring for `ivy.result_type` also applies to - this method with minimal changes. + """`ivy.Array` instance method variant of `ivy.result_type`. This + method simply wraps the function, and so the docstring for + `ivy.result_type` also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/device.py b/ivy/data_classes/array/device.py index f0eb01d3b048f..18ac9887abd27 100644 --- a/ivy/data_classes/array/device.py +++ b/ivy/data_classes/array/device.py @@ -12,10 +12,9 @@ class _ArrayWithDevice(abc.ABC): def dev( self: ivy.Array, *, as_native: bool = False ) -> Union[ivy.Device, ivy.NativeDevice]: - """ - ivy.Array instance method variant of ivy.dev. This method simply wraps the - function, and so the docstring for ivy.dev also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dev. This method simply + wraps the function, and so the docstring for ivy.dev also applies to + this method with minimal changes. Parameters ---------- @@ -40,10 +39,9 @@ def to_device( stream: Optional[Union[int, Any]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.to_device. This method simply wraps the - function, and so the docstring for ivy.to_device also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.to_device. This method + simply wraps the function, and so the docstring for ivy.to_device also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/elementwise.py b/ivy/data_classes/array/elementwise.py index f33601eac27da..b8de2d75e91ad 100644 --- a/ivy/data_classes/array/elementwise.py +++ b/ivy/data_classes/array/elementwise.py @@ -14,10 +14,9 @@ def abs( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: # noqa - """ - ivy.Array instance method variant of ivy.abs. This method simply wraps the - function, and so the docstring for ivy.abs also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.abs. This method simply + wraps the function, and so the docstring for ivy.abs also applies to + this method with minimal changes. Parameters ---------- @@ -43,10 +42,9 @@ def abs( return ivy.abs(self, out=out) def acosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.acosh. This method simply wraps the - function, and so the docstring for ivy.acosh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.acosh. This method simply + wraps the function, and so the docstring for ivy.acosh also applies to + this method with minimal changes. Parameters ---------- @@ -74,10 +72,9 @@ def acosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.acosh(self._data, out=out) def acos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.acos. This method simply wraps the - function, and so the docstring for ivy.acos also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.acos. This method simply + wraps the function, and so the docstring for ivy.acos also applies to + this method with minimal changes. Parameters ---------- @@ -110,10 +107,9 @@ def add( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.add. This method simply wraps the - function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.add. This method simply + wraps the function, and so the docstring for ivy.add also applies to + this method with minimal changes. Parameters ---------- @@ -151,10 +147,9 @@ def add( return ivy.add(self._data, x2, alpha=alpha, out=out) def asin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.asin. This method simply wraps the - function, and so the docstring for ivy.asin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.asin. This method simply + wraps the function, and so the docstring for ivy.asin also applies to + this method with minimal changes. Parameters ---------- @@ -188,10 +183,9 @@ def asin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.asin(self._data, out=out) def asinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.asinh. This method simply wraps the - function, and so the docstring for ivy.asinh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.asinh. This method simply + wraps the function, and so the docstring for ivy.asinh also applies to + this method with minimal changes. Parameters ---------- @@ -219,10 +213,9 @@ def asinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.asinh(self._data, out=out) def atan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.atan. This method simply wraps the - function, and so the docstring for ivy.atan also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.atan. This method simply + wraps the function, and so the docstring for ivy.atan also applies to + this method with minimal changes. Parameters ---------- @@ -254,10 +247,9 @@ def atan2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.atan2. This method simply wraps the - function, and so the docstring for ivy.atan2 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.atan2. This method simply + wraps the function, and so the docstring for ivy.atan2 also applies to + this method with minimal changes. Parameters ---------- @@ -329,10 +321,9 @@ def atan2( return ivy.atan2(self._data, x2, out=out) def atanh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.atanh. This method simply wraps the - function, and so the docstring for ivy.atanh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.atanh. This method simply + wraps the function, and so the docstring for ivy.atanh also applies to + this method with minimal changes. Parameters ---------- @@ -366,10 +357,9 @@ def bitwise_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_and. This method simply wraps - the function, and so the docstring for ivy.bitwise_and also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_and. This method + simply wraps the function, and so the docstring for ivy.bitwise_and + also applies to this method with minimal changes. Parameters ---------- @@ -412,10 +402,10 @@ def bitwise_left_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_left_shift. This method simply - wraps the function, and so the docstring for ivy.bitwise_left_shift also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_left_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_left_shift also applies to this method with minimal + changes. Parameters ---------- @@ -441,10 +431,9 @@ def bitwise_left_shift( def bitwise_invert( self: ivy.Array, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_invert. This method simply - wraps the function, and so the docstring for ivy.bitiwse_invert also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_invert. This method + simply wraps the function, and so the docstring for ivy.bitiwse_invert + also applies to this method with minimal changes. Parameters ---------- @@ -482,10 +471,9 @@ def bitwise_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_or. This method simply wraps - the function, and so the docstring for ivy.bitwise_or also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_or. This method + simply wraps the function, and so the docstring for ivy.bitwise_or also + applies to this method with minimal changes. Parameters ---------- @@ -521,10 +509,10 @@ def bitwise_right_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_right_shift. This method simply - wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_right_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- @@ -562,10 +550,9 @@ def bitwise_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_xor. This method simply wraps - the function, and so the docstring for ivy.bitwise_xor also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_xor. This method + simply wraps the function, and so the docstring for ivy.bitwise_xor + also applies to this method with minimal changes. Parameters ---------- @@ -597,10 +584,9 @@ def bitwise_xor( return ivy.bitwise_xor(self._data, x2, out=out) def ceil(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ceil. This method simply wraps the - function, and so the docstring for ivy.ceil also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.ceil. This method simply + wraps the function, and so the docstring for ivy.ceil also applies to + this method with minimal changes. Parameters ---------- @@ -626,10 +612,9 @@ def ceil(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.ceil(self._data, out=out) def cos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cos. This method simply wraps the - function, and so the docstring for ivy.cos also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cos. This method simply + wraps the function, and so the docstring for ivy.cos also applies to + this method with minimal changes. Parameters ---------- @@ -670,10 +655,9 @@ def cos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.cos(self._data, out=out) def cosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cosh. This method simply wraps the - function, and so the docstring for ivy.cosh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cosh. This method simply + wraps the function, and so the docstring for ivy.cosh also applies to + this method with minimal changes. Parameters ---------- @@ -711,10 +695,9 @@ def divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.divide. This method simply wraps the - function, and so the docstring for ivy.divide also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.divide. This method simply + wraps the function, and so the docstring for ivy.divide also applies to + this method with minimal changes. Parameters ---------- @@ -762,10 +745,9 @@ def equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.equal. This method simply wraps the - function, and so the docstring for ivy.equal also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.equal. This method simply + wraps the function, and so the docstring for ivy.equal also applies to + this method with minimal changes. Parameters ---------- @@ -825,10 +807,9 @@ def equal( return ivy.equal(self._data, x2, out=out) def exp(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.exp. This method simply wraps the - function, and so the docstring for ivy.exp also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.exp. This method simply + wraps the function, and so the docstring for ivy.exp also applies to + this method with minimal changes. Parameters ---------- @@ -854,10 +835,9 @@ def exp(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.exp(self._data, out=out) def expm1(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.expm1. This method simply wraps the - function, and so the docstring for ivy.expm1 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.expm1. This method simply + wraps the function, and so the docstring for ivy.expm1 also applies to + this method with minimal changes. Parameters ---------- @@ -890,10 +870,9 @@ def expm1(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.expm1(self._data, out=out) def floor(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.floor. This method simply wraps the - function, and so the docstring for ivy.floor also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.floor. This method simply + wraps the function, and so the docstring for ivy.floor also applies to + this method with minimal changes. Parameters ---------- @@ -925,10 +904,9 @@ def floor_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.floor_divide. This method simply wraps - the function, and so the docstring for ivy.floor_divide also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.floor_divide. This method + simply wraps the function, and so the docstring for ivy.floor_divide + also applies to this method with minimal changes. Parameters ---------- @@ -976,10 +954,9 @@ def fmin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fmin. This method simply wraps the - function, and so the docstring for ivy.fmin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fmin. This method simply + wraps the function, and so the docstring for ivy.fmin also applies to + this method with minimal changes. Parameters ---------- @@ -1016,10 +993,9 @@ def greater( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.greater. This method simply wraps the - function, and so the docstring for ivy.greater also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.greater. This method simply + wraps the function, and so the docstring for ivy.greater also applies + to this method with minimal changes. Parameters ---------- @@ -1056,10 +1032,9 @@ def greater_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.greater_equal. This method simply wraps - the function, and so the docstring for ivy.greater_equal also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.greater_equal. This method + simply wraps the function, and so the docstring for ivy.greater_equal + also applies to this method with minimal changes. Parameters ---------- @@ -1090,10 +1065,9 @@ def greater_equal( return ivy.greater_equal(self._data, x2, out=out) def isfinite(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isfinite. This method simply wraps the - function, and so the docstring for ivy.isfinite also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isfinite. This method + simply wraps the function, and so the docstring for ivy.isfinite also + applies to this method with minimal changes. Parameters ---------- @@ -1126,10 +1100,9 @@ def isinf( detect_negative: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isinf. This method simply wraps the - function, and so the docstring for ivy.isinf also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isinf. This method simply + wraps the function, and so the docstring for ivy.isinf also applies to + this method with minimal changes. Parameters ---------- @@ -1184,10 +1157,9 @@ def isinf( ) def isnan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isnan. This method simply wraps the - function, and so the docstring for ivy.isnan also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isnan. This method simply + wraps the function, and so the docstring for ivy.isnan also applies to + this method with minimal changes. Parameters ---------- @@ -1245,10 +1217,9 @@ def less( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.less. This method simply wraps the - function, and so the docstring for ivy.less also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.less. This method simply + wraps the function, and so the docstring for ivy.less also applies to + this method with minimal changes. Parameters ---------- @@ -1285,10 +1256,9 @@ def less_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.less_equal. This method simply wraps - the function, and so the docstring for ivy.less_equal also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.less_equal. This method + simply wraps the function, and so the docstring for ivy.less_equal also + applies to this method with minimal changes. Parameters ---------- @@ -1340,10 +1310,9 @@ def less_equal( return ivy.less_equal(self._data, x2, out=out) def log(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log. This method simply wraps the - function, and so the docstring for ivy.log also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.log. This method simply + wraps the function, and so the docstring for ivy.log also applies to + this method with minimal changes. Parameters ---------- @@ -1384,10 +1353,9 @@ def log(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log(self._data, out=out) def log1p(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log1p. This method simply wraps the - function, and so the docstring for ivy.log1p also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.log1p. This method simply + wraps the function, and so the docstring for ivy.log1p also applies to + this method with minimal changes. Parameters ---------- @@ -1419,10 +1387,9 @@ def log1p(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log1p(self._data, out=out) def log2(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log2. This method simply wraps the - function, and so the docstring for ivy.log2 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.log2. This method simply + wraps the function, and so the docstring for ivy.log2 also applies to + this method with minimal changes. Parameters ---------- @@ -1463,10 +1430,9 @@ def log2(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log2(self._data, out=out) def log10(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log10. This method simply wraps the - function, and so the docstring for ivy.log10 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.log10. This method simply + wraps the function, and so the docstring for ivy.log10 also applies to + this method with minimal changes. Parameters ---------- @@ -1513,10 +1479,9 @@ def logaddexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logaddexp. This method simply wraps the - function, and so the docstring for ivy.logaddexp also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.logaddexp. This method + simply wraps the function, and so the docstring for ivy.logaddexp also + applies to this method with minimal changes. Parameters ---------- @@ -1554,10 +1519,9 @@ def logaddexp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logaddexp2. This method simply wraps - the function, and so the docstring for ivy.logaddexp2 also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logaddexp2. This method + simply wraps the function, and so the docstring for ivy.logaddexp2 also + applies to this method with minimal changes. Parameters ---------- @@ -1588,10 +1552,9 @@ def logical_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logical_and. This method simply wraps - the function, and so the docstring for ivy.logical_and also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logical_and. This method + simply wraps the function, and so the docstring for ivy.logical_and + also applies to this method with minimal changes. Parameters ---------- @@ -1624,10 +1587,9 @@ def logical_and( return ivy.logical_and(self._data, x2, out=out) def logical_not(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logical_not. This method simply wraps - the function, and so the docstring for ivy.logical_not also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logical_not. This method + simply wraps the function, and so the docstring for ivy.logical_not + also applies to this method with minimal changes. Parameters ---------- @@ -1664,10 +1626,9 @@ def logical_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logical_or. This method simply wraps - the function, and so the docstring for ivy.logical_or also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logical_or. This method + simply wraps the function, and so the docstring for ivy.logical_or also + applies to this method with minimal changes. Parameters ---------- @@ -1716,10 +1677,9 @@ def logical_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logical_xor. This method simply wraps - the function, and so the docstring for ivy.logical_xor also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logical_xor. This method + simply wraps the function, and so the docstring for ivy.logical_xor + also applies to this method with minimal changes. Parameters ---------- @@ -1756,10 +1716,9 @@ def multiply( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.multiply. This method simply wraps the - function, and so the docstring for ivy.multiply also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.multiply. This method + simply wraps the function, and so the docstring for ivy.multiply also + applies to this method with minimal changes. Parameters ---------- @@ -1808,10 +1767,9 @@ def maximum( use_where: bool = True, out: Optional[ivy.Array] = None, ): - """ - ivy.Array instance method variant of ivy.maximum. This method simply wraps the - function, and so the docstring for ivy.maximum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.maximum. This method simply + wraps the function, and so the docstring for ivy.maximum also applies + to this method with minimal changes. Parameters ---------- @@ -1867,10 +1825,9 @@ def minimum( use_where: bool = True, out: Optional[ivy.Array] = None, ): - """ - ivy.Array instance method variant of ivy.minimum. This method simply wraps the - function, and so the docstring for ivy.minimum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.minimum. This method simply + wraps the function, and so the docstring for ivy.minimum also applies + to this method with minimal changes. Parameters ---------- @@ -1919,10 +1876,9 @@ def minimum( return ivy.minimum(self, x2, use_where=use_where, out=out) def negative(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.negative. This method simply wraps the - function, and so the docstring for ivy.negative also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.negative. This method + simply wraps the function, and so the docstring for ivy.negative also + applies to this method with minimal changes. Parameters ---------- @@ -1969,10 +1925,9 @@ def not_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.not_equal. This method simply wraps the - function, and so the docstring for ivy.not_equal also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.not_equal. This method + simply wraps the function, and so the docstring for ivy.not_equal also + applies to this method with minimal changes. Parameters ---------- @@ -2031,10 +1986,9 @@ def not_equal( return ivy.not_equal(self._data, x2, out=out) def positive(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.positive. This method simply wraps the - function, and so the docstring for ivy.positive also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.positive. This method + simply wraps the function, and so the docstring for ivy.positive also + applies to this method with minimal changes. Parameters ---------- @@ -2081,10 +2035,9 @@ def pow( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.pow. This method simply wraps the - function, and so the docstring for ivy.pow also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.pow. This method simply + wraps the function, and so the docstring for ivy.pow also applies to + this method with minimal changes. Parameters ---------- @@ -2124,10 +2077,9 @@ def pow( return ivy.pow(self._data, x2, out=out) def real(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.real. This method simply wraps the - function, and so the docstring for ivy.real also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.real. This method simply + wraps the function, and so the docstring for ivy.real also applies to + this method with minimal changes. Parameters ---------- @@ -2160,10 +2112,9 @@ def remainder( modulus: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.remainder. This method simply wraps the - function, and so the docstring for ivy.remainder also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.remainder. This method + simply wraps the function, and so the docstring for ivy.remainder also + applies to this method with minimal changes. Parameters ---------- @@ -2211,10 +2162,9 @@ def remainder( def round( self: ivy.Array, *, decimals: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.round. This method simply wraps the - function, and so the docstring for ivy.round also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.round. This method simply + wraps the function, and so the docstring for ivy.round also applies to + this method with minimal changes. Parameters ---------- @@ -2266,10 +2216,9 @@ def sign( np_variant: Optional[bool] = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sign. This method simply wraps the - function, and so the docstring for ivy.sign also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sign. This method simply + wraps the function, and so the docstring for ivy.sign also applies to + this method with minimal changes. Parameters ---------- @@ -2306,10 +2255,9 @@ def sign( return ivy.sign(self._data, np_variant=np_variant, out=out) def sin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sin. This method simply wraps the - function, and so the docstring for ivy.sin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sin. This method simply + wraps the function, and so the docstring for ivy.sin also applies to + this method with minimal changes. Parameters ---------- @@ -2337,10 +2285,9 @@ def sin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.sin(self._data, out=out) def sinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sinh. This method simply wraps the - function, and so the docstring for ivy.sinh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sinh. This method simply + wraps the function, and so the docstring for ivy.sinh also applies to + this method with minimal changes. Parameters ---------- @@ -2372,10 +2319,9 @@ def sinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.sinh(self._data, out=out) def square(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.square. This method simply wraps the - function, and so the docstring for ivy.square also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.square. This method simply + wraps the function, and so the docstring for ivy.square also applies to + this method with minimal changes. Parameters ---------- @@ -2409,10 +2355,9 @@ def square(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.square(self._data, out=out) def sqrt(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sqrt. This method simply wraps the - function, and so the docstring for ivy.sqrt also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sqrt. This method simply + wraps the function, and so the docstring for ivy.sqrt also applies to + this method with minimal changes. Parameters ---------- @@ -2449,10 +2394,9 @@ def subtract( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.subtract. This method simply wraps the - function, and so the docstring for ivy.subtract also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.subtract. This method + simply wraps the function, and so the docstring for ivy.subtract also + applies to this method with minimal changes. Parameters ---------- @@ -2499,10 +2443,9 @@ def trapz( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trapz. This method simply wraps the - function, and so the docstring for ivy.trapz also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.trapz. This method simply + wraps the function, and so the docstring for ivy.trapz also applies to + this method with minimal changes. Parameters ---------- @@ -2543,10 +2486,9 @@ def trapz( return ivy.trapz(self._data, x=x, dx=dx, axis=axis, out=out) def tan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tan. This method simply wraps the - function, and so the docstring for ivy.tan also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tan. This method simply + wraps the function, and so the docstring for ivy.tan also applies to + this method with minimal changes. Parameters ---------- @@ -2579,10 +2521,9 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tanh. This method simply wraps the - function, and so the docstring for ivy.tanh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tanh. This method simply + wraps the function, and so the docstring for ivy.tanh also applies to + this method with minimal changes. Parameters ---------- @@ -2613,10 +2554,9 @@ def tanh( return ivy.tanh(self._data, complex_mode=complex_mode, out=out) def trunc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trunc. This method simply wraps the - function, and so the docstring for ivy.trunc also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.trunc. This method simply + wraps the function, and so the docstring for ivy.trunc also applies to + this method with minimal changes. Parameters ---------- @@ -2642,10 +2582,9 @@ def trunc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.trunc(self._data, out=out) def erf(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.erf. This method simply wraps the - function, and so the docstring for ivy.erf also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.erf. This method simply + wraps the function, and so the docstring for ivy.erf also applies to + this method with minimal changes. Parameters ---------- @@ -2674,10 +2613,9 @@ def exp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.exp2. This method simply wraps the - function, and so the docstring for ivy.exp2 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.exp2. This method simply + wraps the function, and so the docstring for ivy.exp2 also applies to + this method with minimal changes. Parameters ---------- @@ -2709,10 +2647,9 @@ def gcd( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gcd. This method simply wraps the - function, and so the docstring for ivy.gcd also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.gcd. This method simply + wraps the function, and so the docstring for ivy.gcd also applies to + this method with minimal changes. Parameters ---------- @@ -2750,10 +2687,9 @@ def nan_to_num( neginf: Optional[Union[float, int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nan_to_num. This method simply wraps - the function, and so the docstring for ivy.nan_to_num also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.nan_to_num. This method + simply wraps the function, and so the docstring for ivy.nan_to_num also + applies to this method with minimal changes. Parameters ---------- @@ -2801,10 +2737,9 @@ def imag( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.imag. This method simply wraps the - function, and so the docstring for ivy.imag also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.imag. This method simply + wraps the function, and so the docstring for ivy.imag also applies to + this method with minimal changes. Parameters ---------- @@ -2837,10 +2772,9 @@ def angle( deg: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.angle. This method simply wraps the - function, and so the docstring for ivy.angle also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.angle. This method simply + wraps the function, and so the docstring for ivy.angle also applies to + this method with minimal changes. Parameters ---------- @@ -2878,10 +2812,9 @@ def reciprocal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.reciprocal.This method simply wraps the - function, and so the docstring for ivy.reciprocal also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.reciprocal.This method + simply wraps the function, and so the docstring for ivy.reciprocal also + applies to this method with minimal changes. Parameters ---------- @@ -2906,10 +2839,9 @@ def reciprocal( return ivy.reciprocal(self._data, out=out) def deg2rad(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.deg2rad. This method simply wraps the - function, and so the docstring for ivy.deg2rad also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.deg2rad. This method simply + wraps the function, and so the docstring for ivy.deg2rad also applies + to this method with minimal changes. Parameters ---------- @@ -2936,10 +2868,9 @@ def deg2rad(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.deg2rad(self._data, out=out) def rad2deg(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.rad2deg. This method simply wraps the - function, and so the docstring for ivy.rad2deg also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.rad2deg. This method simply + wraps the function, and so the docstring for ivy.rad2deg also applies + to this method with minimal changes. Parameters ---------- @@ -2972,10 +2903,9 @@ def trunc_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trunc_divide. This method simply wraps - the function, and so the docstring for ivy.trunc_divide also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.trunc_divide. This method + simply wraps the function, and so the docstring for ivy.trunc_divide + also applies to this method with minimal changes. Parameters ---------- @@ -3009,10 +2939,9 @@ def trunc_divide( return ivy.trunc_divide(self._data, x2, out=out) def isreal(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isreal. This method simply wraps the - function, and so the docstring for ivy.isreal also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isreal. This method simply + wraps the function, and so the docstring for ivy.isreal also applies to + this method with minimal changes. Parameters ---------- @@ -3040,10 +2969,9 @@ def isreal(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: def lcm( self: ivy.Array, x2: ivy.Array, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lcm. This method simply wraps the - function, and so the docstring for ivy.lcm also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.lcm. This method simply + wraps the function, and so the docstring for ivy.lcm also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/activations.py b/ivy/data_classes/array/experimental/activations.py index 24e38a9dc52ff..6e44b4240c190 100644 --- a/ivy/data_classes/array/experimental/activations.py +++ b/ivy/data_classes/array/experimental/activations.py @@ -15,10 +15,9 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logit. This method simply wraps the - function, and so the docstring for ivy.logit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.logit. This method simply + wraps the function, and so the docstring for ivy.logit also applies to + this method with minimal changes. Parameters ---------- @@ -60,10 +59,9 @@ def thresholded_relu( threshold: Union[int, float] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.thresholded_relu. This method simply - wraps the function, and so the docstring for ivy.thresholded_relu also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.thresholded_relu. This + method simply wraps the function, and so the docstring for + ivy.thresholded_relu also applies to this method with minimal changes. Parameters ---------- @@ -97,8 +95,7 @@ def prelu( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Prelu takes input data (Array) and slope array as input, + """Prelu takes input data (Array) and slope array as input, and produces one output data (array) where the function f(x) = slope * x for x < 0, f(x) = x for x >= 0., is applied @@ -130,8 +127,7 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the rectified linear unit 6 function element-wise. + """Apply the rectified linear unit 6 function element-wise. Parameters ---------- @@ -171,10 +167,9 @@ def logsigmoid( self: ivy.Array, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logsigmoid. This method simply wraps - the function, and so the docstring for ivy.logsigmoid also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logsigmoid. This method + simply wraps the function, and so the docstring for ivy.logsigmoid also + applies to this method with minimal changes. Parameters ---------- @@ -203,8 +198,7 @@ def logsigmoid( return ivy.logsigmoid(self._data, complex_mode=complex_mode) def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - Apply the scaled exponential linear unit function element-wise. + """Apply the scaled exponential linear unit function element-wise. Parameters ---------- @@ -240,10 +234,9 @@ def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.selu(self._data, out=out) def silu(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.silu. This method simply wraps the - function, and so the docstring for ivy.silu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.silu. This method simply + wraps the function, and so the docstring for ivy.silu also applies to + this method with minimal changes. Parameters ---------- @@ -269,10 +262,9 @@ def elu( alpha: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Ivy.Array instance method variant of ivy.elu. This method simply wraps the - function, and so the docstring for ivy.elu also applies to this method with - minimal. + """Ivy.Array instance method variant of ivy.elu. This method simply + wraps the function, and so the docstring for ivy.elu also applies to + this method with minimal. Parameters ---------- @@ -306,10 +298,9 @@ def hardtanh( min_val: float = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.hardtanh. This method simply wraps the - function, and so the docstring for ivy.hardtanh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.hardtanh. This method + simply wraps the function, and so the docstring for ivy.hardtanh also + applies to this method with minimal changes. Parameters ---------- @@ -339,10 +330,9 @@ def hardtanh( return ivy.hardtanh(self._data, min_val=min_val, max_val=max_val, out=out) def tanhshrink(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tanhshrink. This method simply wraps - the function, and so the docstring for ivy.tanhshrink also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.tanhshrink. This method + simply wraps the function, and so the docstring for ivy.tanhshrink also + applies to this method with minimal changes. Parameters ---------- @@ -369,10 +359,9 @@ def threshold( value: Union[int, float], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.threshold. This method simply wraps the - function, and so the docstring for ivy.threshold also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.threshold. This method + simply wraps the function, and so the docstring for ivy.threshold also + applies to this method with minimal changes. Parameters ---------- @@ -407,10 +396,9 @@ def softshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.softshrink. This method simply wraps - the function, and so the docstring for ivy.softshrink also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.softshrink. This method + simply wraps the function, and so the docstring for ivy.softshrink also + applies to this method with minimal changes. Parameters ---------- @@ -448,10 +436,9 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.celu. This method simply wraps the - function, and so the docstring for ivy.celu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.celu. This method simply + wraps the function, and so the docstring for ivy.celu also applies to + this method with minimal changes. Parameters ---------- @@ -488,10 +475,9 @@ def scaled_tanh( beta: float = 0.67, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.scaled_tanh. This method simply wraps - the function, and so the docstring for ivy.scaled_tanh also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.scaled_tanh. This method + simply wraps the function, and so the docstring for ivy.scaled_tanh + also applies to this method with minimal changes. Parameters ---------- @@ -537,10 +523,9 @@ def hardshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.hardshrink. This method simply wraps - the function, and so the docstring for ivy.hardshrink also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.hardshrink. This method + simply wraps the function, and so the docstring for ivy.hardshrink also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/creation.py b/ivy/data_classes/array/experimental/creation.py index 6d814ee70f85b..62ab0e9f1744d 100644 --- a/ivy/data_classes/array/experimental/creation.py +++ b/ivy/data_classes/array/experimental/creation.py @@ -16,10 +16,9 @@ def eye_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.eye_like. This method simply wraps the - function, and so the docstring for ivy.eye_like also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.eye_like. This method + simply wraps the function, and so the docstring for ivy.eye_like also + applies to this method with minimal changes. Parameters ---------- @@ -60,10 +59,10 @@ def unsorted_segment_min( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - r""" - ivy.Array instance method variant of ivy.unsorted_segment_min. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_min - also applies to this method with minimal changes. + r"""ivy.Array instance method variant of ivy.unsorted_segment_min. This + method simply wraps the function, and so the docstring for + ivy.unsorted_segment_min also applies to this method with minimal + changes. Note ---- @@ -97,10 +96,10 @@ def unsorted_segment_sum( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - r""" - ivy.Array instance method variant of ivy.unsorted_segment_sum. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_sum - also applies to this method with minimal changes. + r"""ivy.Array instance method variant of ivy.unsorted_segment_sum. This + method simply wraps the function, and so the docstring for + ivy.unsorted_segment_sum also applies to this method with minimal + changes. Parameters ---------- @@ -133,10 +132,9 @@ def blackman_window( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.blackman_window. This method simply - wraps the function, and so the docstring for ivy.blackman_window also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.blackman_window. This + method simply wraps the function, and so the docstring for + ivy.blackman_window also applies to this method with minimal changes. Parameters ---------- @@ -181,10 +179,9 @@ def trilu( upper: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trilu. This method simply wraps the - function, and so the docstring for ivy.trilu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.trilu. This method simply + wraps the function, and so the docstring for ivy.trilu also applies to + this method with minimal changes. Parameters ---------- @@ -220,10 +217,10 @@ def mel_weight_matrix( lower_edge_hertz: Optional[Union[float, ivy.Array]] = 0.0, upper_edge_hertz: Optional[Union[float, ivy.Array]] = 3000.0, ): - """ - Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a - linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins - frequency information based on the [lower_edge_hertz, upper_edge_hertz] + """Generate a MelWeightMatrix that can be used to re-weight a Tensor + containing a linearly sampled frequency spectra (from DFT or STFT) into + num_mel_bins frequency information based on the [lower_edge_hertz, + upper_edge_hertz] range on the mel scale. This function defines the mel scale in terms of a frequency in hertz according to the following @@ -270,8 +267,8 @@ def unsorted_segment_mean( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - """ - Compute the mean of values in the array 'self' based on segment identifiers. + """Compute the mean of values in the array 'self' based on segment + identifiers. Parameters ---------- @@ -318,9 +315,9 @@ def polyval( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.Array: - """ - ivy.Array instance method of polyval. This method simply wraps the function, and so - the docstring for ivy.polyval also applies to this method with minimal changes. + """ivy.Array instance method of polyval. This method simply wraps the + function, and so the docstring for ivy.polyval also applies to this method + with minimal changes. Evaluate and return a polynomial at specific given values. diff --git a/ivy/data_classes/array/experimental/elementwise.py b/ivy/data_classes/array/experimental/elementwise.py index 31e4245b01f15..f48d1b303fc55 100644 --- a/ivy/data_classes/array/experimental/elementwise.py +++ b/ivy/data_classes/array/experimental/elementwise.py @@ -16,10 +16,9 @@ def amax( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.amax. This method simply wraps the - function, and so the docstring for ivy.amax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.amax. This method simply + wraps the function, and so the docstring for ivy.amax also applies to + this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def amin( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.amin. This method simply wraps the - function, and so the docstring for ivy.amin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.amin. This method simply + wraps the function, and so the docstring for ivy.amin also applies to + this method with minimal changes. Parameters ---------- @@ -133,10 +131,9 @@ def amin( return ivy.amin(self._data, axis=axis, keepdims=keepdims, out=out) def lgamma(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lgamma. This method simply wraps the - function, and so the docstring for ivy.lgamma also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.lgamma. This method simply + wraps the function, and so the docstring for ivy.lgamma also applies to + this method with minimal changes. Parameters ---------- @@ -168,10 +165,9 @@ def lgamma(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.lgamma(self._data, out=out) def sinc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sinc. This method simply wraps the - function, and so the docstring for ivy.sinc also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sinc. This method simply + wraps the function, and so the docstring for ivy.sinc also applies to + this method with minimal changes. Parameters ---------- @@ -205,10 +201,9 @@ def fmod( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fmod. This method simply wraps the - function, and so the docstring for ivy.fmod also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fmod. This method simply + wraps the function, and so the docstring for ivy.fmod also applies to + this method with minimal changes. Parameters ---------- @@ -245,10 +240,9 @@ def fmax( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fmax. This method simply wraps the - function, and so the docstring for ivy.fmax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fmax. This method simply + wraps the function, and so the docstring for ivy.fmax also applies to + this method with minimal changes. Parameters ---------- @@ -285,10 +279,9 @@ def float_power( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.float_power. This method simply wraps - the function, and so the docstring for ivy.float_power also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.float_power. This method + simply wraps the function, and so the docstring for ivy.float_power + also applies to this method with minimal changes. Parameters ---------- @@ -326,10 +319,9 @@ def copysign( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.copysign. This method simply wraps the - function, and so the docstring for ivy.copysign also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.copysign. This method + simply wraps the function, and so the docstring for ivy.copysign also + applies to this method with minimal changes. Parameters ---------- @@ -367,10 +359,9 @@ def count_nonzero( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.count_nonzero. This method simply wraps - the function, and so the docstring for ivy.count_nonzero also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.count_nonzero. This method + simply wraps the function, and so the docstring for ivy.count_nonzero + also applies to this method with minimal changes. Parameters ---------- @@ -421,10 +412,9 @@ def nansum( keepdims: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nansum. This method simply wraps the - function, and so the docstring for ivy.nansum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nansum. This method simply + wraps the function, and so the docstring for ivy.nansum also applies to + this method with minimal changes. Parameters ---------- @@ -473,10 +463,9 @@ def isclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isclose. This method simply wraps the - function, and so the docstring for ivy.isclose also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isclose. This method simply + wraps the function, and so the docstring for ivy.isclose also applies + to this method with minimal changes. Parameters ---------- @@ -528,10 +517,9 @@ def signbit( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.signbit. This method simply wraps the - function, and so the docstring for ivy.signbit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.signbit. This method simply + wraps the function, and so the docstring for ivy.signbit also applies + to this method with minimal changes. Parameters ---------- @@ -560,10 +548,9 @@ def hypot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.hypot. This method simply wraps the - function, and so the docstring for ivy.hypot also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.hypot. This method simply + wraps the function, and so the docstring for ivy.hypot also applies to + this method with minimal changes. Parameters ---------- @@ -600,10 +587,9 @@ def allclose( equal_nan: bool = False, out: Optional[ivy.Container] = None, ) -> bool: - """ - ivy.Array instance method variant of ivy.allclose. This method simply wraps the - function, and so the docstring for ivy.allclose also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.allclose. This method + simply wraps the function, and so the docstring for ivy.allclose also + applies to this method with minimal changes. Parameters ---------- @@ -662,10 +648,9 @@ def diff( append: Optional[Union[ivy.Array, ivy.NativeArray, int, list, tuple]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.diff. This method simply wraps the - function, and so the docstring for ivy.diff also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.diff. This method simply + wraps the function, and so the docstring for ivy.diff also applies to + this method with minimal changes. Parameters ---------- @@ -705,10 +690,9 @@ def fix( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fix. This method simply wraps the - function, and so the docstring for ivy.fix also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fix. This method simply + wraps the function, and so the docstring for ivy.fix also applies to + this method with minimal changes. Parameters ---------- @@ -738,10 +722,9 @@ def nextafter( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nextafter. This method simply wraps the - function, and so the docstring for ivy.nextafter also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.nextafter. This method + simply wraps the function, and so the docstring for ivy.nextafter also + applies to this method with minimal changes. Parameters ---------- @@ -774,10 +757,9 @@ def zeta( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.zeta. This method simply wraps the - function, and so the docstring for ivy.zeta also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.zeta. This method simply + wraps the function, and so the docstring for ivy.zeta also applies to + this method with minimal changes. Parameters ---------- @@ -812,8 +794,7 @@ def gradient( edge_order: int = 1, axis: Optional[Union[int, list, tuple]] = None, ) -> Union[ivy.Array, List[ivy.Array]]: - """ - Calculate gradient of x with respect to (w.r.t.) spacing. + """Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -885,10 +866,9 @@ def xlogy( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.xlogy. This method simply wraps the - function, and so the docstring for ivy.xlogy also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.xlogy. This method simply + wraps the function, and so the docstring for ivy.xlogy also applies to + this method with minimal changes. Parameters ---------- @@ -922,9 +902,8 @@ def xlogy( def binarizer( self: ivy.Array, /, *, threshold: float = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Map the values of the input tensor to either 0 or 1, element-wise, based on the - outcome of a comparison against a threshold value. + """Map the values of the input tensor to either 0 or 1, element-wise, + based on the outcome of a comparison against a threshold value. Parameters ---------- @@ -945,10 +924,9 @@ def binarizer( return ivy.binarizer(self._data, threshold=threshold, out=out) def conj(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.conj. This method simply wraps the - function, and so the docstring for ivy.conj also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.conj. This method simply + wraps the function, and so the docstring for ivy.conj also applies to + this method with minimal changes. Parameters ---------- @@ -980,10 +958,9 @@ def lerp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lerp. This method simply wraps the - function, and so the docstring for ivy.lerp also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.lerp. This method simply + wraps the function, and so the docstring for ivy.lerp also applies to + this method with minimal changes. Parameters ---------- @@ -1021,10 +998,9 @@ def ldexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ldexp. This method simply wraps the - function, and so the docstring for ivy.ldexp also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.ldexp. This method simply + wraps the function, and so the docstring for ivy.ldexp also applies to + this method with minimal changes. Parameters ---------- @@ -1053,10 +1029,9 @@ def ldexp( def frexp( self: ivy.Array, /, *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.frexp. This method simply wraps the - function, and so the docstring for ivy.frexp also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.frexp. This method simply + wraps the function, and so the docstring for ivy.frexp also applies to + this method with minimal changes. Parameters ---------- @@ -1082,10 +1057,9 @@ def frexp( def modf( self: ivy.Array, /, *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.modf. This method simply wraps the - function, and so the docstring for ivy.modf also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.modf. This method simply + wraps the function, and so the docstring for ivy.modf also applies to + this method with minimal changes. Parameters ---------- @@ -1114,10 +1088,9 @@ def digamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.digamma. This method simply wraps the - function, and so the docstring for ivy.digamma also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.digamma. This method simply + wraps the function, and so the docstring for ivy.digamma also applies + to this method with minimal changes. Note ---- @@ -1152,10 +1125,9 @@ def sparsify_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array class method variant of ivy.sparsify_tensor. This method simply wraps - the function, and so the docstring for ivy.sparsify_tensor also applies to this - method with minimal changes. + """ivy.Array class method variant of ivy.sparsify_tensor. This method + simply wraps the function, and so the docstring for ivy.sparsify_tensor + also applies to this method with minimal changes. Parameters ---------- @@ -1195,10 +1167,9 @@ def erfc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.erfc. This method simply wraps the - function, and so the docstring for ivy.erfc also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.erfc. This method simply + wraps the function, and so the docstring for ivy.erfc also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/general.py b/ivy/data_classes/array/experimental/general.py index d07f50f94981c..c51957e6b51bb 100644 --- a/ivy/data_classes/array/experimental/general.py +++ b/ivy/data_classes/array/experimental/general.py @@ -16,10 +16,9 @@ def reduce( axes: Union[int, Sequence[int]] = 0, keepdims: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.reduce. This method simply wraps the - function, and so the docstring for ivy.reduce also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.reduce. This method simply + wraps the function, and so the docstring for ivy.reduce also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/layers.py b/ivy/data_classes/array/experimental/layers.py index 2e1bb60a33d05..5ca1f26c26d36 100644 --- a/ivy/data_classes/array/experimental/layers.py +++ b/ivy/data_classes/array/experimental/layers.py @@ -19,10 +19,9 @@ def max_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.max_pool1d`. This method simply wraps - the function, and so the docstring for `ivy.max_pool1d` also applies to this - method with minimal changes. + """ivy.Array instance method variant of `ivy.max_pool1d`. This method + simply wraps the function, and so the docstring for `ivy.max_pool1d` + also applies to this method with minimal changes. Parameters ---------- @@ -87,10 +86,9 @@ def max_pool2d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.max_pool2d`. This method simply wraps - the function, and so the docstring for `ivy.max_pool2d` also applies to this - method with minimal changes. + """ivy.Array instance method variant of `ivy.max_pool2d`. This method + simply wraps the function, and so the docstring for `ivy.max_pool2d` + also applies to this method with minimal changes. Parameters ---------- @@ -166,8 +164,7 @@ def max_pool3d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D max pool given 5-D input x. + """Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -231,10 +228,9 @@ def avg_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.avg_pool1d`. This method simply wraps - the function, and so the docstring for `ivy.avg_pool1d` also applies to this - method with minimal changes. + """ivy.Array instance method variant of `ivy.avg_pool1d`. This method + simply wraps the function, and so the docstring for `ivy.avg_pool1d` + also applies to this method with minimal changes. Parameters ---------- @@ -300,10 +296,9 @@ def avg_pool2d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.avg_pool2d`. This method simply wraps - the function, and so the docstring for `ivy.avg_pool2d` also applies to this - method with minimal changes. + """ivy.Array instance method variant of `ivy.avg_pool2d`. This method + simply wraps the function, and so the docstring for `ivy.avg_pool2d` + also applies to this method with minimal changes. Parameters ---------- @@ -377,8 +372,7 @@ def avg_pool3d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D max pool given 5-D input x. + """Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -443,10 +437,9 @@ def dct( norm: Optional[Literal["ortho"]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dct. This method simply wraps the - function, and so the docstring for ivy.dct also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dct. This method simply + wraps the function, and so the docstring for ivy.dct also applies to + this method with minimal changes. Parameters ---------- @@ -492,10 +485,9 @@ def idct( norm: Optional[Literal["ortho"]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.idct. This method simply wraps the - function, and so the docstring for ivy.idct also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.idct. This method simply + wraps the function, and so the docstring for ivy.idct also applies to + this method with minimal changes. Parameters ---------- @@ -541,10 +533,9 @@ def fft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ifft. This method simply wraps the - function, and so the docstring for ivy.ifft also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.ifft. This method simply + wraps the function, and so the docstring for ivy.ifft also applies to + this method with minimal changes. Parameters ---------- @@ -597,10 +588,9 @@ def ifft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ifft. This method simply wraps the - function, and so the docstring for ivy.ifft also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.ifft. This method simply + wraps the function, and so the docstring for ivy.ifft also applies to + this method with minimal changes. Parameters ---------- @@ -666,8 +656,7 @@ def dft( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the discrete Fourier transform of input. + """Compute the discrete Fourier transform of input. Parameters ---------- @@ -751,8 +740,7 @@ def interpolate( antialias: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Down/up samples the input to the given size. The algorithm used for + """Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -811,9 +799,8 @@ def adaptive_avg_pool1d( self: ivy.Array, output_size: int, ) -> ivy.Array: - """ - Apply a 1D adaptive average pooling over an input signal composed of several - input planes. + """Apply a 1D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -838,9 +825,8 @@ def adaptive_avg_pool2d( self: ivy.Array, output_size: Union[Sequence[int], int], ) -> ivy.Array: - """ - Apply a 2D adaptive average pooling over an input signal composed of several - input planes. + """Apply a 2D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -865,9 +851,8 @@ def adaptive_max_pool2d( self: ivy.Array, output_size: Union[Sequence[int], int], ) -> ivy.Array: - """ - Apply a 2D adaptive maximum pooling over an input signal composed of several - input planes. + """Apply a 2D adaptive maximum pooling over an input signal composed of + several input planes. Parameters ---------- @@ -900,8 +885,8 @@ def reduce_window( base_dilation: Union[int, Sequence[int]] = 1, window_dilation: Union[int, Sequence[int]] = 1, ) -> ivy.Array: - """ - Apply a reduction function to all elements in each window of an array. + """Apply a reduction function to all elements in each window of an + array. Parameters ---------- @@ -957,8 +942,7 @@ def fft2( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the 2-dimensional discrete Fourier Transform. + """Compute the 2-dimensional discrete Fourier Transform. Parameters ---------- @@ -1022,8 +1006,7 @@ def ifftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the N-dimensional inverse discrete Fourier Transform. + """Compute the N-dimensional inverse discrete Fourier Transform. Parameters ---------- @@ -1095,10 +1078,9 @@ def rfft( norm: Literal["backward", "ortho", "forward"] = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.rfft. This method simply wraps the - function, and so the docstring for ivy.rfft also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.rfft. This method simply + wraps the function, and so the docstring for ivy.rfft also applies to + this method with minimal changes. Parameters ---------- @@ -1150,8 +1132,7 @@ def rfftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the n-dimensional discrete Fourier Transform. + """Compute the n-dimensional discrete Fourier Transform. Parameters ---------- @@ -1186,8 +1167,7 @@ def stft( name: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Short-time Fourier Transform of signals. + """Compute the Short-time Fourier Transform of signals. Parameters ---------- @@ -1239,8 +1219,7 @@ def sliding_window( dilation: Union[int, Tuple[int, int]] = 1, padding: Union[str, int, Sequence[Tuple[int, int]]] = "VALID", ) -> ivy.Array: - """ - Slide a window of specified dimension over all elements of an array. + """Slide a window of specified dimension over all elements of an array. Parameters ---------- @@ -1295,8 +1274,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Array: - """ - Compute a 1-D max unpooling given the 1-D pooled input x and its indices. + """Compute a 1-D max unpooling given the 1-D pooled input x and its + indices. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/linear_algebra.py b/ivy/data_classes/array/experimental/linear_algebra.py index 0fe58b0dc3513..6156d43f33ee0 100644 --- a/ivy/data_classes/array/experimental/linear_algebra.py +++ b/ivy/data_classes/array/experimental/linear_algebra.py @@ -19,10 +19,9 @@ def eigh_tridiagonal( ] = None, tol: Optional[float] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array]]: - """ - ivy.Array instance method variant of ivy.eigh_tridiagonal. This method simply - wraps the function, and so the docstring for ivy.eigh_tridiagonal also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.eigh_tridiagonal. This + method simply wraps the function, and so the docstring for + ivy.eigh_tridiagonal also applies to this method with minimal changes. Parameters ---------- @@ -89,10 +88,9 @@ def diagflat( num_cols: int = -1, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.diagflat. This method simply wraps the - function, and so the docstring for ivy.diagflat also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.diagflat. This method + simply wraps the function, and so the docstring for ivy.diagflat also + applies to this method with minimal changes. Examples -------- @@ -119,10 +117,9 @@ def kron( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.kron. This method simply wraps the - function, and so the docstring for ivy.kron also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.kron. This method simply + wraps the function, and so the docstring for ivy.kron also applies to + this method with minimal changes. Examples -------- @@ -134,10 +131,9 @@ def kron( return ivy.kron(self._data, b, out=out) def matrix_exp(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.kron. This method simply wraps the - function, and so the docstring for ivy.matrix_exp also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.kron. This method simply + wraps the function, and so the docstring for ivy.matrix_exp also + applies to this method with minimal changes. Examples -------- @@ -157,10 +153,9 @@ def eig( self: ivy.Array, /, ) -> Tuple[ivy.Array, ...]: - """ - ivy.Array instance method variant of ivy.eig. This method simply wraps the - function, and so the docstring for ivy.eig also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.eig. This method simply + wraps the function, and so the docstring for ivy.eig also applies to + this method with minimal changes. Examples -------- @@ -178,10 +173,9 @@ def eigvals( self: ivy.Array, /, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.eigvals. This method simply wraps the - function, and so the docstring for ivy.eigvals also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.eigvals. This method simply + wraps the function, and so the docstring for ivy.eigvals also applies + to this method with minimal changes. Examples -------- @@ -197,10 +191,9 @@ def adjoint( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.adjoint. This method simply wraps the - function, and so the docstring for ivy.adjoint also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.adjoint. This method simply + wraps the function, and so the docstring for ivy.adjoint also applies + to this method with minimal changes. Examples -------- @@ -223,10 +216,9 @@ def multi_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.multi_dot. This method simply wraps the - function, and so the docstring for ivy.multi_dot also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.multi_dot. This method + simply wraps the function, and so the docstring for ivy.multi_dot also + applies to this method with minimal changes. Examples -------- @@ -242,10 +234,9 @@ def multi_dot( def cond( self: ivy.Array, /, *, p: Optional[Union[int, float, str]] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cond. This method simply wraps the - function, and so the docstring for ivy.cond also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cond. This method simply + wraps the function, and so the docstring for ivy.cond also applies to + this method with minimal changes. Examples -------- @@ -268,10 +259,9 @@ def mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.mode_dot. This method simply wraps the - function, and so the docstring for ivy.mode_dot also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.mode_dot. This method + simply wraps the function, and so the docstring for ivy.mode_dot also + applies to this method with minimal changes. Parameters ---------- @@ -310,10 +300,9 @@ def multi_mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - ivy.Array instance method variant of ivy.multi_mode_dot. This method simply - wraps the function, and so the docstring for ivy.multi_mode_dot also applies to - this method with minimal changes. + r"""ivy.Array instance method variant of ivy.multi_mode_dot. This method + simply wraps the function, and so the docstring for ivy.multi_mode_dot + also applies to this method with minimal changes. Parameters ---------- @@ -357,10 +346,9 @@ def svd_flip( /, u_based_decision: Optional[bool] = True, ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.svd_flip. This method simply wraps the - function, and so the docstring for ivy.svd_flip also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.svd_flip. This method + simply wraps the function, and so the docstring for ivy.svd_flip also + applies to this method with minimal changes. Parameters ---------- @@ -388,10 +376,10 @@ def make_svd_non_negative( *, nntype: Optional[Literal["nndsvd", "nndsvda"]] = "nndsvd", ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.make_svd_non_negative. This method - simply wraps the function, and so the docstring for ivy.make_svd_non_negative - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.make_svd_non_negative. This + method simply wraps the function, and so the docstring for + ivy.make_svd_non_negative also applies to this method with minimal + changes. Parameters ---------- @@ -418,10 +406,9 @@ def tensor_train( svd: Optional[Literal["truncated_svd"]] = "truncated_svd", verbose: Optional[bool] = False, ) -> ivy.TTTensor: - """ - ivy.Array instance method variant of ivy.tensor_train. This method simply wraps - the function, and so the docstring for ivy.tensor_train also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.tensor_train. This method + simply wraps the function, and so the docstring for ivy.tensor_train + also applies to this method with minimal changes. Parameters ---------- @@ -448,10 +435,10 @@ def truncated_svd( compute_uv: bool = True, n_eigenvecs: Optional[int] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array, ivy.Array]]: - """ - ivy.Array instance method variant of ivy.make_svd_non_negative. This method - simply wraps the function, and so the docstring for ivy.make_svd_non_negative - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.make_svd_non_negative. This + method simply wraps the function, and so the docstring for + ivy.make_svd_non_negative also applies to this method with minimal + changes. Parameters ---------- @@ -487,10 +474,9 @@ def initialize_tucker( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, svd_mask_repeats: Optional[int] = 5, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ - ivy.Array instance method variant of ivy.initialize_tucker. This method simply - wraps the function, and so the docstring for ivy.initialize_tucker also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.initialize_tucker. This + method simply wraps the function, and so the docstring for + ivy.initialize_tucker also applies to this method with minimal changes. Parameters ---------- @@ -553,10 +539,9 @@ def partial_tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ - ivy.Array instance method variant of ivy.partial_tucker. This method simply - wraps the function, and so the docstring for ivy.partial_tucker also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.partial_tucker. This method + simply wraps the function, and so the docstring for ivy.partial_tucker + also applies to this method with minimal changes. Parameters ---------- @@ -635,10 +620,9 @@ def tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ): - """ - ivy.Array instance method variant of ivy.tucker. This method simply wraps the - function, and so the docstring for ivy.tucker also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tucker. This method simply + wraps the function, and so the docstring for ivy.tucker also applies to + this method with minimal changes. Parameters ---------- @@ -713,10 +697,10 @@ def tt_matrix_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Ivy.Array instance method variant of ivy.tt_matrix_to_tensor. This method simply - wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also - applies to this method with minimal changes. + """Ivy.Array instance method variant of ivy.tt_matrix_to_tensor. This + method simply wraps the function, and so the docstring for + ivy.tt_matrix_to_tensor also applies to this method with minimal + changes. Parameters ---------- @@ -766,10 +750,9 @@ def dot( *, out: Optional[ivy.Array] = None, ): - """ - Compute the dot product between two arrays `a` and `b` using the current - backend's implementation. The dot product is defined as the sum of the element- - wise product of the input arrays. + """Compute the dot product between two arrays `a` and `b` using the + current backend's implementation. The dot product is defined as the sum + of the element- wise product of the input arrays. Parameters ---------- @@ -820,10 +803,10 @@ def general_inner_product( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.general_inner_product. This method - simply wraps the function, and so the docstring for ivy.general_inner_product - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.general_inner_product. This + method simply wraps the function, and so the docstring for + ivy.general_inner_product also applies to this method with minimal + changes. Parameters ---------- @@ -875,10 +858,10 @@ def higher_order_moment( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.higher_order_moment. This method simply - wraps the function, and so the docstring for ivy.higher_order_moment also - applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.higher_order_moment. This + method simply wraps the function, and so the docstring for + ivy.higher_order_moment also applies to this method with minimal + changes. Parameters ---------- @@ -916,10 +899,9 @@ def batched_outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Ivy Array instance method variant of ivy.batched_outer. This method simply wraps - the function, and so the docstring for ivy.batched_outer also applies to this - method with minimal changes. + """Ivy Array instance method variant of ivy.batched_outer. This method + simply wraps the function, and so the docstring for ivy.batched_outer + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/losses.py b/ivy/data_classes/array/experimental/losses.py index daedf43d09d7e..f676338c11c89 100644 --- a/ivy/data_classes/array/experimental/losses.py +++ b/ivy/data_classes/array/experimental/losses.py @@ -15,10 +15,9 @@ def l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.l1_loss. This method simply wraps the - function, and so the docstring for ivy.l1_loss also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.l1_loss. This method simply + wraps the function, and so the docstring for ivy.l1_loss also applies + to this method with minimal changes. Parameters ---------- @@ -59,10 +58,9 @@ def log_poisson_loss( reduction: str = "none", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log_poisson_loss. This method simply - wraps the function, and so the docstring for ivy.l1_loss also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.log_poisson_loss. This + method simply wraps the function, and so the docstring for ivy.l1_loss + also applies to this method with minimal changes. Parameters ---------- @@ -122,10 +120,9 @@ def huber_loss( delta: Optional[float] = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of huber_loss. This method simply wraps the - function, and so the docstring for huber_loss also applies to this method with - minimal changes. + """ivy.Array instance method variant of huber_loss. This method simply + wraps the function, and so the docstring for huber_loss also applies to + this method with minimal changes. Parameters ---------- @@ -170,10 +167,9 @@ def smooth_l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy. smooth_l1_loss. This method simply - wraps the function, and so the docstring for ivy.smooth_l1_loss also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy. smooth_l1_loss. This + method simply wraps the function, and so the docstring for + ivy.smooth_l1_loss also applies to this method with minimal changes. Parameters ---------- @@ -218,10 +214,9 @@ def soft_margin_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.soft_margin_loss. This method simply - wraps the function, and so the docstring for ivy.soft_margin_loss also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.soft_margin_loss. This + method simply wraps the function, and so the docstring for + ivy.soft_margin_loss also applies to this method with minimal changes. Parameters ---------- @@ -261,10 +256,9 @@ def kl_div( log_target=False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.kl_div. This method simply wraps the - function, and so the docstring for ivy.kl_div also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.kl_div. This method simply + wraps the function, and so the docstring for ivy.kl_div also applies to + this method with minimal changes. Parameters ---------- @@ -308,8 +302,7 @@ def poisson_nll_loss( eps: float = 1e-8, reduction: str = "mean", ) -> ivy.Array: - r""" - Compute the Poisson Negative Log Likelihood Loss. + r"""Compute the Poisson Negative Log Likelihood Loss. This function calculates the negative log likelihood loss between the `input` and `target`under the assumption that diff --git a/ivy/data_classes/array/experimental/manipulation.py b/ivy/data_classes/array/experimental/manipulation.py index f7027eafa78ab..013af82658b0a 100644 --- a/ivy/data_classes/array/experimental/manipulation.py +++ b/ivy/data_classes/array/experimental/manipulation.py @@ -29,10 +29,9 @@ def moveaxis( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.moveaxis. This method simply wraps the - function, and so the docstring for ivy.unstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.moveaxis. This method + simply wraps the function, and so the docstring for ivy.unstack also + applies to this method with minimal changes. Parameters ---------- @@ -74,10 +73,9 @@ def heaviside( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.heaviside. This method simply wraps the - function, and so the docstring for ivy.heaviside also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.heaviside. This method + simply wraps the function, and so the docstring for ivy.heaviside also + applies to this method with minimal changes. Parameters ---------- @@ -116,10 +114,9 @@ def flipud( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.flipud. This method simply wraps the - function, and so the docstring for ivy.flipud also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.flipud. This method simply + wraps the function, and so the docstring for ivy.flipud also applies to + this method with minimal changes. Parameters ---------- @@ -160,10 +157,9 @@ def vstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.vstack. This method simply wraps the - function, and so the docstring for ivy.vstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.vstack. This method simply + wraps the function, and so the docstring for ivy.vstack also applies to + this method with minimal changes. Examples -------- @@ -192,10 +188,9 @@ def hstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.hstack. This method simply wraps the - function, and so the docstring for ivy.hstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.hstack. This method simply + wraps the function, and so the docstring for ivy.hstack also applies to + this method with minimal changes. Examples -------- @@ -222,10 +217,9 @@ def rot90( axes: Tuple[int, int] = (0, 1), out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.rot90. This method simply wraps the - function, and so the docstring for ivy.rot90 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.rot90. This method simply + wraps the function, and so the docstring for ivy.rot90 also applies to + this method with minimal changes. Parameters ---------- @@ -284,10 +278,9 @@ def top_k( sorted: bool = True, out: Optional[tuple] = None, ) -> Tuple[ivy.Array, ivy.NativeArray]: - """ - ivy.Array instance method variant of ivy.top_k. This method simply wraps the - function, and so the docstring for ivy.top_k also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.top_k. This method simply + wraps the function, and so the docstring for ivy.top_k also applies to + this method with minimal changes. Parameters ---------- @@ -329,10 +322,9 @@ def fliplr( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fliplr. This method simply wraps the - function, and so the docstring for ivy.fliplr also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fliplr. This method simply + wraps the function, and so the docstring for ivy.fliplr also applies to + this method with minimal changes. Parameters ---------- @@ -369,10 +361,9 @@ def i0( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.i0. This method simply wraps the - function, and so the docstring for ivy.i0 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.i0. This method simply + wraps the function, and so the docstring for ivy.i0 also applies to + this method with minimal changes. Parameters ---------- @@ -404,10 +395,9 @@ def flatten( order: str = "C", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.flatten. This method simply wraps the - function, and so the docstring for ivy.flatten also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.flatten. This method simply + wraps the function, and so the docstring for ivy.flatten also applies + to this method with minimal changes. Parameters ---------- @@ -540,8 +530,7 @@ def pad( out: Optional[ivy.Array] = None, **kwargs: Optional[Any], ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.pad. + """ivy.Array instance method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -566,10 +555,9 @@ def vsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.vsplit. This method simply wraps the - function, and so the docstring for ivy.vsplit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.vsplit. This method simply + wraps the function, and so the docstring for ivy.vsplit also applies to + this method with minimal changes. Parameters ---------- @@ -613,10 +601,9 @@ def dsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.dsplit. This method simply wraps the - function, and so the docstring for ivy.dsplit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dsplit. This method simply + wraps the function, and so the docstring for ivy.dsplit also applies to + this method with minimal changes. Parameters ---------- @@ -659,10 +646,9 @@ def atleast_1d( *arys: Union[ivy.Array, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.atleast_1d. This method simply wraps - the function, and so the docstring for ivy.atleast_1d also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.atleast_1d. This method + simply wraps the function, and so the docstring for ivy.atleast_1d also + applies to this method with minimal changes. Parameters ---------- @@ -702,10 +688,9 @@ def dstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dstack. This method simply wraps the - function, and so the docstring for ivy.dstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dstack. This method simply + wraps the function, and so the docstring for ivy.dstack also applies to + this method with minimal changes. Examples -------- @@ -730,10 +715,9 @@ def atleast_2d( *arys: ivy.Array, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.atleast_2d. This method simply wraps - the function, and so the docstring for ivy.atleast_2d also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.atleast_2d. This method + simply wraps the function, and so the docstring for ivy.atleast_2d also + applies to this method with minimal changes. Parameters ---------- @@ -769,10 +753,9 @@ def atleast_3d( *arys: Union[ivy.Array, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.atleast_3d. This method simply wraps - the function, and so the docstring for ivy.atleast_3d also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.atleast_3d. This method + simply wraps the function, and so the docstring for ivy.atleast_3d also + applies to this method with minimal changes. Parameters ---------- @@ -816,10 +799,9 @@ def take_along_axis( mode: str = "fill", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.take_along_axis. This method simply - wraps the function, and so the docstring for ivy.take_along_axis also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.take_along_axis. This + method simply wraps the function, and so the docstring for + ivy.take_along_axis also applies to this method with minimal changes. Parameters ---------- @@ -858,10 +840,9 @@ def hsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.hsplit. This method simply wraps the - function, and so the docstring for ivy.hsplit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.hsplit. This method simply + wraps the function, and so the docstring for ivy.hsplit also applies to + this method with minimal changes. Parameters ---------- @@ -913,8 +894,8 @@ def expand( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Broadcast the input Array following the given shape and the broadcast rule. + """Broadcast the input Array following the given shape and the + broadcast rule. Parameters ---------- @@ -945,8 +926,7 @@ def as_strided( strides: Sequence[int], /, ) -> ivy.Array: - """ - Create a copy of the input array with the given shape and strides. + """Create a copy of the input array with the given shape and strides. Parameters ---------- @@ -977,8 +957,7 @@ def concat_from_sequence( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Concatenate a sequence of arrays along a new or an existing axis. + """Concatenate a sequence of arrays along a new or an existing axis. Parameters ---------- @@ -1025,8 +1004,7 @@ def associative_scan( reverse: bool = False, axis: int = 0, ) -> ivy.Array: - """ - Perform an associative scan over the given array. + """Perform an associative scan over the given array. Parameters ---------- @@ -1052,8 +1030,7 @@ def unique_consecutive( *, axis: Optional[int] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.unique_consecutive. + """ivy.Array instance method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -1068,8 +1045,7 @@ def fill_diagonal( *, wrap: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fill_diag. + """ivy.Array instance method variant of ivy.fill_diag. This method simply wraps the function, and so the docstring for ivy.fill_diag also applies to this method with minimal changes. @@ -1086,8 +1062,7 @@ def take( fill_value: Optional[Number] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.take. + """ivy.Array instance method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -1165,8 +1140,7 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trim_zeros. + """ivy.Array instance method variant of ivy.trim_zeros. This method simply wraps the function, and so the docstring for ivy.trim_zeros also applies to this method with minimal changes. @@ -1206,10 +1180,9 @@ def unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.unfold. This method simply wraps the - function, and so the docstring for ivy.unfold also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.unfold. This method simply + wraps the function, and so the docstring for ivy.unfold also applies to + this method with minimal changes. Parameters ---------- @@ -1235,10 +1208,9 @@ def fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fold. This method simply wraps the - function, and so the docstring for ivy.fold also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fold. This method simply + wraps the function, and so the docstring for ivy.fold also applies to + this method with minimal changes. Parameters ---------- @@ -1268,10 +1240,9 @@ def partial_unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.partial_unfold. This method simply - wraps the function, and so the docstring for ivy.partial_unfold also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.partial_unfold. This method + simply wraps the function, and so the docstring for ivy.partial_unfold + also applies to this method with minimal changes. Parameters ---------- @@ -1311,10 +1282,9 @@ def partial_fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.partial_fold. This method simply wraps - the function, and so the docstring for ivy.partial_fold also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.partial_fold. This method + simply wraps the function, and so the docstring for ivy.partial_fold + also applies to this method with minimal changes. Parameters ---------- @@ -1343,10 +1313,10 @@ def partial_tensor_to_vec( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.partial_tensor_to_vec. This method - simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.partial_tensor_to_vec. This + method simply wraps the function, and so the docstring for + ivy.partial_tensor_to_vec also applies to this method with minimal + changes. Parameters ---------- @@ -1374,10 +1344,10 @@ def partial_vec_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.partial_vec_to_tensor. This method - simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.partial_vec_to_tensor. This + method simply wraps the function, and so the docstring for + ivy.partial_vec_to_tensor also applies to this method with minimal + changes. Parameters ---------- @@ -1405,10 +1375,9 @@ def matricize( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.matricize. This method simply wraps the - function, and so the docstring for ivy.matricize also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.matricize. This method + simply wraps the function, and so the docstring for ivy.matricize also + applies to this method with minimal changes. Parameters ---------- @@ -1435,10 +1404,9 @@ def soft_thresholding( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.soft_thresholding. This method simply - wraps the function, and so the docstring for ivy.soft_thresholding also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.soft_thresholding. This + method simply wraps the function, and so the docstring for + ivy.soft_thresholding also applies to this method with minimal changes. Parameters ---------- @@ -1465,8 +1433,7 @@ def column_stack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.column_stack. + """ivy.Array instance method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -1504,8 +1471,7 @@ def put_along_axis( mode: Literal["sum", "min", "max", "mul", "mean", "replace"] = "replace", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.put_along_axis. + """ivy.Array instance method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal diff --git a/ivy/data_classes/array/experimental/norms.py b/ivy/data_classes/array/experimental/norms.py index 916c63a32a521..6d8be11765f95 100644 --- a/ivy/data_classes/array/experimental/norms.py +++ b/ivy/data_classes/array/experimental/norms.py @@ -12,8 +12,7 @@ def l1_normalize( axis: Optional[Union[int, Tuple[int, ...]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Normalize the array to have unit L1 norm. + """Normalize the array to have unit L1 norm. Parameters ---------- @@ -46,8 +45,7 @@ def l2_normalize( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Normalize the array to have unit L2 norm. + """Normalize the array to have unit L2 norm. Parameters ---------- @@ -89,10 +87,9 @@ def batch_norm( data_format: str = "NSC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.batch_norm. This method simply wraps - the function, and so the docstring for ivy.batch_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.batch_norm. This method + simply wraps the function, and so the docstring for ivy.batch_norm also + applies to this method with minimal changes. Parameters ---------- @@ -160,10 +157,9 @@ def instance_norm( data_format: str = "NSC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.instance_norm. This method simply wraps - the function, and so the docstring for ivy.instance_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.instance_norm. This method + simply wraps the function, and so the docstring for ivy.instance_norm + also applies to this method with minimal changes. Parameters ---------- @@ -226,10 +222,9 @@ def group_norm( data_format: Optional[str] = "NSC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.group_norm. This method simply wraps - the function, and so the docstring for ivy.group_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.group_norm. This method + simply wraps the function, and so the docstring for ivy.group_norm also + applies to this method with minimal changes. Parameters ---------- @@ -277,8 +272,7 @@ def lp_normalize( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Normalize the array to have Lp norm. + """Normalize the array to have Lp norm. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/random.py b/ivy/data_classes/array/experimental/random.py index cd067cd304ba2..8c5f407e350e0 100644 --- a/ivy/data_classes/array/experimental/random.py +++ b/ivy/data_classes/array/experimental/random.py @@ -16,10 +16,9 @@ def dirichlet( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dirichlet. This method simply wraps the - function, and so the docstring for ivy.shuffle also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dirichlet. This method + simply wraps the function, and so the docstring for ivy.shuffle also + applies to this method with minimal changes. Parameters ---------- @@ -71,10 +70,9 @@ def beta( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.beta. This method simply wraps the - function, and so the docstring for ivy.beta also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.beta. This method simply + wraps the function, and so the docstring for ivy.beta also applies to + this method with minimal changes. Parameters ---------- @@ -122,10 +120,9 @@ def gamma( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gamma. This method simply wraps the - function, and so the docstring for ivy.gamma also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.gamma. This method simply + wraps the function, and so the docstring for ivy.gamma also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/searching.py b/ivy/data_classes/array/experimental/searching.py index 6dc82e7b1716a..99b5925179417 100644 --- a/ivy/data_classes/array/experimental/searching.py +++ b/ivy/data_classes/array/experimental/searching.py @@ -14,10 +14,9 @@ def unravel_index( *, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array]: - """ - ivy.Array instance method variant of ivy.unravel_index. This method simply wraps - the function, and so the docstring for ivy.unravel_index also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.unravel_index. This method + simply wraps the function, and so the docstring for ivy.unravel_index + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/sorting.py b/ivy/data_classes/array/experimental/sorting.py index e3aa93f401e0b..a073f02fd812e 100644 --- a/ivy/data_classes/array/experimental/sorting.py +++ b/ivy/data_classes/array/experimental/sorting.py @@ -15,10 +15,9 @@ def lexsort( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lexsort. This method simply wraps the - function, and so the docstring for ivy.lexsort also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.lexsort. This method simply + wraps the function, and so the docstring for ivy.lexsort also applies + to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/statistical.py b/ivy/data_classes/array/experimental/statistical.py index d206ff796fae0..8b8570f8d885d 100644 --- a/ivy/data_classes/array/experimental/statistical.py +++ b/ivy/data_classes/array/experimental/statistical.py @@ -21,10 +21,9 @@ def histogram( density: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.histogram. This method simply wraps the - function, and so the docstring for ivy.histogram also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.histogram. This method + simply wraps the function, and so the docstring for ivy.histogram also + applies to this method with minimal changes. Parameters ---------- @@ -97,10 +96,9 @@ def median( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.median. This method simply wraps the - function, and so the docstring for ivy.median also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.median. This method simply + wraps the function, and so the docstring for ivy.median also applies to + this method with minimal changes. Parameters ---------- @@ -139,10 +137,9 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanmean. This method simply wraps the - function, and so the docstring for ivy.nanmean also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nanmean. This method simply + wraps the function, and so the docstring for ivy.nanmean also applies + to this method with minimal changes. Parameters ---------- @@ -190,10 +187,9 @@ def nanmin( where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanmin. This method simply wraps the - function, and so the docstring for ivy.min also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nanmin. This method simply + wraps the function, and so the docstring for ivy.min also applies to + this method with minimal changes. Parameters ---------- @@ -246,10 +242,9 @@ def nanprod( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanprod. This method simply wraps the - function, and so the docstring for ivy.prod also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nanprod. This method simply + wraps the function, and so the docstring for ivy.prod also applies to + this method with minimal changes. Parameters ---------- @@ -305,10 +300,9 @@ def quantile( interpolation: str = "linear", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.quantile. This method simply wraps the - function, and so the docstring for ivy.quantile also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.quantile. This method + simply wraps the function, and so the docstring for ivy.quantile also + applies to this method with minimal changes. Parameters ---------- @@ -389,10 +383,9 @@ def corrcoef( rowvar: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.corrcoef. This method simply wraps the - function, and so the docstring for ivy.corrcoef also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.corrcoef. This method + simply wraps the function, and so the docstring for ivy.corrcoef also + applies to this method with minimal changes. Parameters ---------- @@ -433,10 +426,9 @@ def nanmedian( overwrite_input: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanmedian. This method simply wraps the - function, and so the docstring for ivy.nanmedian also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.nanmedian. This method + simply wraps the function, and so the docstring for ivy.nanmedian also + applies to this method with minimal changes. Parameters ---------- @@ -496,10 +488,9 @@ def bincount( minlength: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bincount. This method simply wraps the - function, and so the docstring for ivy.bincount also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.bincount. This method + simply wraps the function, and so the docstring for ivy.bincount also + applies to this method with minimal changes. Parameters ---------- @@ -542,10 +533,9 @@ def igamma( x: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.igamma. This method simply wraps the - function, and so the docstring for ivy.igamma also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.igamma. This method simply + wraps the function, and so the docstring for ivy.igamma also applies to + this method with minimal changes. Parameters ---------- @@ -587,10 +577,9 @@ def cov( aweights: Optional[ivy.Array] = None, dtype: Optional[type] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cov. This method simply wraps the - function, and so the docstring for ivy.cov also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cov. This method simply + wraps the function, and so the docstring for ivy.cov also applies to + this method with minimal changes. Parameters ---------- @@ -672,10 +661,9 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cummax. This method simply wraps the - function, and so the docstring for ivy.cummax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cummax. This method simply + wraps the function, and so the docstring for ivy.cummax also applies to + this method with minimal changes. Parameters ---------- @@ -742,10 +730,9 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cummin. This method simply wraps the - function, and so the docstring for ivy.cummin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cummin. This method simply + wraps the function, and so the docstring for ivy.cummin also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/utility.py b/ivy/data_classes/array/experimental/utility.py index 46aaccd3510ad..d8f8c8e8554c1 100644 --- a/ivy/data_classes/array/experimental/utility.py +++ b/ivy/data_classes/array/experimental/utility.py @@ -13,11 +13,10 @@ def optional_get_element( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - If the input is a tensor or sequence type, it returns the input. If the input is - an optional type, it outputs the element in the input. It is an error if the - input is an empty optional-type (i.e. does not have an element) and the behavior - is undefined in this case. + """If the input is a tensor or sequence type, it returns the input. If + the input is an optional type, it outputs the element in the input. It + is an error if the input is an empty optional-type (i.e. does not have + an element) and the behavior is undefined in this case. Parameters ---------- diff --git a/ivy/data_classes/array/general.py b/ivy/data_classes/array/general.py index 87d5bae046c94..8aa3194c8caf2 100644 --- a/ivy/data_classes/array/general.py +++ b/ivy/data_classes/array/general.py @@ -17,10 +17,9 @@ def is_native_array( *, exclusive: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.is_native_array. This method simply - wraps the function, and so the docstring for ivy.is_native_array also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.is_native_array. This + method simply wraps the function, and so the docstring for + ivy.is_native_array also applies to this method with minimal changes. Parameters ---------- @@ -45,10 +44,9 @@ def is_native_array( return ivy.is_native_array(self, exclusive=exclusive) def is_ivy_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: - """ - ivy.Array instance method variant of ivy.is_ivy_array. This method simply wraps - the function, and so the docstring for ivy.is_ivy_array also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.is_ivy_array. This method + simply wraps the function, and so the docstring for ivy.is_ivy_array + also applies to this method with minimal changes. Parameters ---------- @@ -73,10 +71,9 @@ def is_ivy_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: return ivy.is_ivy_array(self, exclusive=exclusive) def is_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: - """ - ivy.Array instance method variant of ivy.is_array. This method simply wraps the - function, and so the docstring for ivy.is_array also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.is_array. This method + simply wraps the function, and so the docstring for ivy.is_array also + applies to this method with minimal changes. Parameters ---------- @@ -100,10 +97,9 @@ def is_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: return ivy.is_array(self, exclusive=exclusive) def is_ivy_container(self: ivy.Array) -> bool: - """ - ivy.Array instance method variant of ivy.is_ivy_container. This method simply - wraps the function, and so the docstring for ivy.is_ivy_container also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.is_ivy_container. This + method simply wraps the function, and so the docstring for + ivy.is_ivy_container also applies to this method with minimal changes. Parameters ---------- @@ -126,10 +122,9 @@ def is_ivy_container(self: ivy.Array) -> bool: def all_equal( self: ivy.Array, *x2: Iterable[Any], equality_matrix: bool = False ) -> Union[bool, ivy.Array, ivy.NativeArray]: - """ - ivy.Array instance method variant of ivy.all_equal. This method simply wraps the - function, and so the docstring for ivy.all_equal also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.all_equal. This method + simply wraps the function, and so the docstring for ivy.all_equal also + applies to this method with minimal changes. Parameters ---------- @@ -168,10 +163,9 @@ def all_equal( return ivy.all_equal(*arrays, equality_matrix=equality_matrix) def has_nans(self: ivy.Array, /, *, include_infs: bool = True): - """ - ivy.Array instance method variant of ivy.has_nans. This method simply wraps the - function, and so the docstring for ivy.has_nans also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.has_nans. This method + simply wraps the function, and so the docstring for ivy.has_nans also + applies to this method with minimal changes. Parameters ---------- @@ -204,10 +198,9 @@ def gather( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gather. This method simply wraps the - function, and so the docstring for ivy.gather also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.gather. This method simply + wraps the function, and so the docstring for ivy.gather also applies to + this method with minimal changes. Parameters ---------- @@ -277,8 +270,7 @@ def scatter_nd( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Scatter updates into an array according to indices. + """Scatter updates into an array according to indices. Parameters ---------- @@ -331,10 +323,9 @@ def gather_nd( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gather_nd. This method simply wraps the - function, and so the docstring for ivy.gather_nd also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.gather_nd. This method + simply wraps the function, and so the docstring for ivy.gather_nd also + applies to this method with minimal changes. Parameters ---------- @@ -371,10 +362,9 @@ def einops_rearrange( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.einops_rearrange. This method simply - wraps the function, and so the docstring for ivy.einops_rearrange also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.einops_rearrange. This + method simply wraps the function, and so the docstring for + ivy.einops_rearrange also applies to this method with minimal changes. Parameters ---------- @@ -433,10 +423,9 @@ def einops_reduce( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.einops_reduce. This method simply wraps - the function, and so the docstring for ivy.einops_reduce also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.einops_reduce. This method + simply wraps the function, and so the docstring for ivy.einops_reduce + also applies to this method with minimal changes. Parameters ---------- @@ -495,10 +484,9 @@ def einops_repeat( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.einops_repeat. This method simply wraps - the function, and so the docstring for ivy.einops_repeat also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.einops_repeat. This method + simply wraps the function, and so the docstring for ivy.einops_repeat + also applies to this method with minimal changes. Parameters ---------- @@ -540,10 +528,9 @@ def einops_repeat( return ivy.einops_repeat(self._data, pattern, out=out, **axes_lengths) def to_numpy(self: ivy.Array, /, *, copy: bool = True) -> np.ndarray: - """ - ivy.Array instance method variant of ivy.to_numpy. This method simply wraps the - function, and so the docstring for ivy.to_numpy also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.to_numpy. This method + simply wraps the function, and so the docstring for ivy.to_numpy also + applies to this method with minimal changes. Parameters ---------- @@ -576,10 +563,9 @@ def to_numpy(self: ivy.Array, /, *, copy: bool = True) -> np.ndarray: return ivy.to_numpy(self, copy=copy) def to_list(self: ivy.Array, /) -> List: - """ - ivy.Array instance method variant of ivy.to_list. This method simply wraps the - function, and so the docstring for ivy.to_list also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.to_list. This method simply + wraps the function, and so the docstring for ivy.to_list also applies + to this method with minimal changes. Parameters ---------- @@ -605,9 +591,8 @@ def to_list(self: ivy.Array, /) -> List: def to_file( self: ivy.Array, fid: Union[str, bytes, int], sep: str = "", format_: str = "%s" ) -> None: - """ - ivy.Array instance method variant of to_file. Write array to a file as text or - binary. The data is always written in 'C' order. + """ivy.Array instance method variant of to_file. Write array to a file + as text or binary. The data is always written in 'C' order. Parameters ---------- @@ -640,10 +625,10 @@ def to_file( return ivy.to_file(self, fid, sep, format_) def supports_inplace_updates(self: ivy.Array, /) -> bool: - """ - ivy.Array instance method variant of ivy.supports_inplace_updates. This method - simply wraps the function, and so the docstring for ivy.supports_inplace_updates - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.supports_inplace_updates. + This method simply wraps the function, and so the docstring for + ivy.supports_inplace_updates also applies to this method with minimal + changes. Parameters ---------- @@ -677,10 +662,9 @@ def supports_inplace_updates(self: ivy.Array, /) -> bool: def inplace_decrement( self: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray] ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.inplace_decrement. This method simply - wraps the function, and so the docstring for ivy.inplace_decrement also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.inplace_decrement. This + method simply wraps the function, and so the docstring for + ivy.inplace_decrement also applies to this method with minimal changes. Parameters ---------- @@ -719,10 +703,9 @@ def stable_divide( Union[Number, ivy.Array, ivy.NativeArray, ivy.Container] ] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.stable_divide. This method simply wraps - the function, and so the docstring for ivy.stable_divide also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.stable_divide. This method + simply wraps the function, and so the docstring for ivy.stable_divide + also applies to this method with minimal changes. Parameters ---------- @@ -770,10 +753,9 @@ def clip_vector_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.clip_vector_norm. This method simply - wraps the function, and so the docstring for ivy.clip_vector_norm also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.clip_vector_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_vector_norm also applies to this method with minimal changes. Parameters ---------- @@ -805,10 +787,9 @@ def clip_vector_norm( return ivy.clip_vector_norm(self, max_norm, p=p, out=out) def array_equal(self: ivy.Array, x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """ - ivy.Array instance method variant of ivy.array_equal. This method simply wraps - the function, and so the docstring for ivy.array_equal also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.array_equal. This method + simply wraps the function, and so the docstring for ivy.array_equal + also applies to this method with minimal changes. Parameters ---------- @@ -845,10 +826,10 @@ def array_equal(self: ivy.Array, x: Union[ivy.Array, ivy.NativeArray], /) -> boo return ivy.array_equal(self, x) def assert_supports_inplace(self: ivy.Array, /) -> bool: - """ - ivy.Array instance method variant of ivy.assert_supports_inplace. This method - simply wraps the function, and so the docstring for ivy.assert_supports_inplace - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.assert_supports_inplace. + This method simply wraps the function, and so the docstring for + ivy.assert_supports_inplace also applies to this method with minimal + changes. Parameters ---------- @@ -879,10 +860,9 @@ def assert_supports_inplace(self: ivy.Array, /) -> bool: return ivy.assert_supports_inplace(self) def to_scalar(self: ivy.Array) -> Number: - """ - ivy.Array instance method variant of ivy.to_scalar. This method simply wraps the - function, and so the docstring for ivy.to_scalar also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.to_scalar. This method + simply wraps the function, and so the docstring for ivy.to_scalar also + applies to this method with minimal changes. Parameters ---------- @@ -915,10 +895,9 @@ def fourier_encode( concat: bool = True, flatten: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Tuple]: - """ - ivy.Array instance method variant of ivy.fourier_encode. This method simply - wraps the function, and so the docstring for ivy.fourier_encode also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.fourier_encode. This method + simply wraps the function, and so the docstring for ivy.fourier_encode + also applies to this method with minimal changes. Parameters ---------- @@ -979,10 +958,9 @@ def fourier_encode( ) def value_is_nan(self: ivy.Array, /, *, include_infs: bool = True) -> bool: - """ - ivy.Array instance method variant of ivy.value_is_nan. This method simply wraps - the function, and so the docstring for ivy.value_is_nan also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.value_is_nan. This method + simply wraps the function, and so the docstring for ivy.value_is_nan + also applies to this method with minimal changes. Parameters ---------- @@ -1023,10 +1001,9 @@ def value_is_nan(self: ivy.Array, /, *, include_infs: bool = True) -> bool: return ivy.value_is_nan(self, include_infs=include_infs) def exists(self: ivy.Array, /) -> bool: - """ - ivy.Array instance method variant of ivy.exists. This method simply wraps the - function, and so the docstring for ivy.exists also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.exists. This method simply + wraps the function, and so the docstring for ivy.exists also applies to + this method with minimal changes. Parameters ---------- @@ -1061,10 +1038,9 @@ def default( rev: bool = False, with_callable: bool = False, ) -> Any: - """ - ivy.Array instance method variant of ivy.default. This method simply wraps the - function, and so the docstring for ivy.default also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.default. This method simply + wraps the function, and so the docstring for ivy.default also applies + to this method with minimal changes. Parameters ---------- @@ -1107,10 +1083,9 @@ def stable_pow( *, min_base: Optional[float] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.stable_pow. This method simply wraps - the function, and so the docstring for ivy.stable_pow also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.stable_pow. This method + simply wraps the function, and so the docstring for ivy.stable_pow also + applies to this method with minimal changes. Parameters ---------- @@ -1152,10 +1127,9 @@ def inplace_update( ensure_in_backend: bool = False, keep_input_dtype: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.inplace_update. This method simply - wraps the function, and so the docstring for ivy.inplace_update also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.inplace_update. This method + simply wraps the function, and so the docstring for ivy.inplace_update + also applies to this method with minimal changes. Parameters ---------- @@ -1220,10 +1194,9 @@ def inplace_update( def inplace_increment( self: ivy.Array, val: Union[ivy.Array, ivy.NativeArray] ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.inplace_increment. This method wraps - the function, and so the docstring for ivy.inplace_increment also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.inplace_increment. This + method wraps the function, and so the docstring for + ivy.inplace_increment also applies to this method with minimal changes. Parameters ---------- @@ -1261,10 +1234,9 @@ def clip_matrix_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.clip_matrix_norm. This method simply - wraps the function, and so the docstring for ivy.clip_matrix_norm also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.clip_matrix_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_matrix_norm also applies to this method with minimal changes. Parameters ---------- @@ -1303,10 +1275,9 @@ def scatter_flat( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.scatter_flat. This method simply wraps - the function, and so the docstring for ivy.scatter_flat also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.scatter_flat. This method + simply wraps the function, and so the docstring for ivy.scatter_flat + also applies to this method with minimal changes. Parameters ---------- @@ -1351,10 +1322,9 @@ def scatter_flat( return ivy.scatter_flat(self, updates, size=size, reduction=reduction, out=out) def get_num_dims(self: ivy.Array, /, *, as_array: bool = False) -> int: - """ - ivy.Array instance method variant of ivy.shape. This method simply wraps the - function, and so the docstring for ivy.shape also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.shape. This method simply + wraps the function, and so the docstring for ivy.shape also applies to + this method with minimal changes. Parameters ---------- @@ -1396,10 +1366,9 @@ def isin( assume_unique: bool = False, invert: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isin. This method simply wraps the - function, and so the docstring for ivy.isin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isin. This method simply + wraps the function, and so the docstring for ivy.isin also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/gradients.py b/ivy/data_classes/array/gradients.py index 3f0cb0fda507f..bb0b7164d95d4 100644 --- a/ivy/data_classes/array/gradients.py +++ b/ivy/data_classes/array/gradients.py @@ -16,10 +16,9 @@ def stop_gradient( preserve_type: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.stop_gradient. This method simply wraps - the function, and so the docstring for ivy.stop_gradient also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.stop_gradient. This method + simply wraps the function, and so the docstring for ivy.stop_gradient + also applies to this method with minimal changes. Parameters ---------- @@ -58,10 +57,9 @@ def adam_step( epsilon: float = 1e-7, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.adam_step. This method simply wraps the - function, and so the docstring for ivy.adam_step also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.adam_step. This method + simply wraps the function, and so the docstring for ivy.adam_step also + applies to this method with minimal changes. Parameters ---------- @@ -116,10 +114,9 @@ def optimizer_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.optimizer_update. This method simply - wraps the function, and so the docstring for ivy.optimizer_update also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.optimizer_update. This + method simply wraps the function, and so the docstring for + ivy.optimizer_update also applies to this method with minimal changes. Parameters ---------- @@ -165,10 +162,10 @@ def gradient_descent_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gradient_descent_update. This method - simply wraps the function, and so the docstring for ivy.gradient_descent_update - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.gradient_descent_update. + This method simply wraps the function, and so the docstring for + ivy.gradient_descent_update also applies to this method with minimal + changes. Parameters ---------- @@ -222,10 +219,9 @@ def lars_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lars_update. This method simply wraps - the function, and so the docstring for ivy.lars_update also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.lars_update. This method + simply wraps the function, and so the docstring for ivy.lars_update + also applies to this method with minimal changes. Parameters ---------- @@ -288,10 +284,9 @@ def adam_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.adam_update. This method simply wraps - the function, and so the docstring for ivy.adam_update also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.adam_update. This method + simply wraps the function, and so the docstring for ivy.adam_update + also applies to this method with minimal changes. Parameters ---------- @@ -376,10 +371,9 @@ def lamb_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lamb_update. This method simply wraps - the function, and so the docstring for ivy.lamb_update also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.lamb_update. This method + simply wraps the function, and so the docstring for ivy.lamb_update + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/layers.py b/ivy/data_classes/array/layers.py index f4c42a5d6de6d..3ecec50f7bc0e 100644 --- a/ivy/data_classes/array/layers.py +++ b/ivy/data_classes/array/layers.py @@ -20,10 +20,9 @@ def linear( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.linear. This method simply wraps the - function, and so the docstring for ivy.linear also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.linear. This method simply + wraps the function, and so the docstring for ivy.linear also applies to + this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def dropout( noise_shape: Optional[Sequence[int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dropout. This method simply wraps the - function, and so the docstring for ivy.dropout also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dropout. This method simply + wraps the function, and so the docstring for ivy.dropout also applies + to this method with minimal changes. Parameters ---------- @@ -157,10 +155,9 @@ def dropout1d( data_format: str = "NWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dropout1d. This method simply wraps the - function, and so the docstring for ivy.droput1d also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dropout1d. This method + simply wraps the function, and so the docstring for ivy.droput1d also + applies to this method with minimal changes. Parameters ---------- @@ -205,10 +202,9 @@ def dropout2d( data_format: str = "NHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dropout2d. This method simply wraps the - function, and so the docstring for ivy.droput1d also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dropout2d. This method + simply wraps the function, and so the docstring for ivy.droput1d also + applies to this method with minimal changes. Parameters ---------- @@ -254,10 +250,9 @@ def dropout3d( data_format: str = "NDHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dropout3d. This method simply wraps the - function, and so the docstring for ivy.droput3d also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dropout3d. This method + simply wraps the function, and so the docstring for ivy.droput3d also + applies to this method with minimal changes. Parameters ---------- @@ -299,11 +294,10 @@ def scaled_dot_product_attention( training: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.scaled_dot_product_attention. This - method simply wraps the function, and so the docstring for - ivy.scaled_dot_product_attention also applies to this method with minimal - changes. + """ivy.Array instance method variant of + ivy.scaled_dot_product_attention. This method simply wraps the + function, and so the docstring for ivy.scaled_dot_product_attention + also applies to this method with minimal changes. Parameters ---------- @@ -463,10 +457,9 @@ def conv1d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.conv1d. This method simply wraps the - function, and so the docstring for ivy.conv1d also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.conv1d. This method simply + wraps the function, and so the docstring for ivy.conv1d also applies to + this method with minimal changes. Parameters ---------- @@ -536,10 +529,9 @@ def conv1d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.conv1d_transpose. This method simply - wraps the function, and so the docstring for ivy.conv1d_transpose also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.conv1d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv1d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -610,10 +602,9 @@ def depthwise_conv2d( dilations: Union[int, Tuple[int], Tuple[int, int]] = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.depthwise_conv2d. This method simply - wraps the function, and so the docstring for ivy.depthwise_conv2d also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.depthwise_conv2d. This + method simply wraps the function, and so the docstring for + ivy.depthwise_conv2d also applies to this method with minimal changes. Parameters ---------- @@ -671,10 +662,9 @@ def conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.conv2d`. This method simply wraps the - function, and so the docstring for `ivy.conv2d` also applies to this method with - minimal changes. + """ivy.Array instance method variant of `ivy.conv2d`. This method + simply wraps the function, and so the docstring for `ivy.conv2d` also + applies to this method with minimal changes. Parameters ---------- @@ -750,10 +740,10 @@ def conv2d_transpose( out: Optional[ivy.Array] = None, bias: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.conv2d_transpose`. This method simply - wraps the function, and so the docstring for `ivy.conv2d_transpose` also applies - to this method with minimal changes. + """ivy.Array instance method variant of `ivy.conv2d_transpose`. This + method simply wraps the function, and so the docstring for + `ivy.conv2d_transpose` also applies to this method with minimal + changes. Parameters ---------- @@ -824,10 +814,9 @@ def conv3d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.conv3d`. This method simply wraps the - function, and so the docstring for `ivy.conv3d` also applies to this method with - minimal changes. + """ivy.Array instance method variant of `ivy.conv3d`. This method + simply wraps the function, and so the docstring for `ivy.conv3d` also + applies to this method with minimal changes. Parameters ---------- @@ -896,10 +885,10 @@ def conv3d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.conv3d_transpose`. This method simply - wraps the function, and so the docstring for `ivy.conv3d_transpose` also applies - to this method with minimal changes. + """ivy.Array instance method variant of `ivy.conv3d_transpose`. This + method simply wraps the function, and so the docstring for + `ivy.conv3d_transpose` also applies to this method with minimal + changes. Parameters ---------- @@ -968,10 +957,9 @@ def lstm_update( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, recurrent_bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.lstm_update. This method simply wraps - the function, and so the docstring for ivy.lstm_update also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.lstm_update. This method + simply wraps the function, and so the docstring for ivy.lstm_update + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/linear_algebra.py b/ivy/data_classes/array/linear_algebra.py index a25df9d4cabb7..025932fa11f0c 100644 --- a/ivy/data_classes/array/linear_algebra.py +++ b/ivy/data_classes/array/linear_algebra.py @@ -21,10 +21,9 @@ def matmul( adjoint_b: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.matmul. This method simply wraps the - function, and so the docstring for ivy.matmul also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.matmul. This method simply + wraps the function, and so the docstring for ivy.matmul also applies to + this method with minimal changes. Parameters ---------- @@ -82,10 +81,9 @@ def cholesky( upper: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cholesky. This method simply wraps the - function, and so the docstring for ivy.cholesky also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cholesky. This method + simply wraps the function, and so the docstring for ivy.cholesky also + applies to this method with minimal changes. Parameters ---------- @@ -135,10 +133,9 @@ def cross( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cross. This method simply wraps the - function, and so the docstring for ivy.cross also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cross. This method simply + wraps the function, and so the docstring for ivy.cross also applies to + this method with minimal changes. Parameters ---------- @@ -194,10 +191,9 @@ def diagonal( axis2: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.diagonal. This method simply wraps the - function, and so the docstring for ivy.diagonal also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.diagonal. This method + simply wraps the function, and so the docstring for ivy.diagonal also + applies to this method with minimal changes. Parameters ---------- @@ -274,10 +270,9 @@ def diag( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.diag. This method simply wraps the - function, and so the docstring for ivy.diag also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.diag. This method simply + wraps the function, and so the docstring for ivy.diag also applies to + this method with minimal changes. Examples -------- @@ -313,10 +308,9 @@ def eigvalsh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.eigvalsh. This method simply wraps the - function, and so the docstring for ivy.eigvalsh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.eigvalsh. This method + simply wraps the function, and so the docstring for ivy.eigvalsh also + applies to this method with minimal changes. Parameters ---------- @@ -362,8 +356,7 @@ def inner( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the inner product of two vectors ``self`` and ``x2``. + """Return the inner product of two vectors ``self`` and ``x2``. Parameters ---------- @@ -421,10 +414,9 @@ def inner( def inv( self: ivy.Array, /, *, adjoint: bool = False, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.inv. This method simply wraps the - function, and so the docstring for ivy.inv also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.inv. This method simply + wraps the function, and so the docstring for ivy.inv also applies to + this method with minimal changes. Parameters ---------- @@ -463,10 +455,9 @@ def matrix_norm( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.matrix_norm. This method simply wraps - the function, and so the docstring for ivy.matrix_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.matrix_norm. This method + simply wraps the function, and so the docstring for ivy.matrix_norm + also applies to this method with minimal changes. Parameters ---------- @@ -525,10 +516,9 @@ def matrix_rank( hermitian: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.matrix_rank. This method returns the - rank (i.e., number of non-zero singular values) of a matrix (or a stack of - matrices). + """ivy.Array instance method variant of ivy.matrix_rank. This method + returns the rank (i.e., number of non-zero singular values) of a matrix + (or a stack of matrices). Parameters ---------- @@ -599,8 +589,7 @@ def matrix_rank( def matrix_transpose( self: ivy.Array, /, *, conjugate: bool = False, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Transpose a matrix (or a stack of matrices) ``x``. + """Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -637,8 +626,7 @@ def outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the outer product between two arrays. + """Compute the outer product between two arrays. Parameters ---------- @@ -674,10 +662,9 @@ def pinv( rtol: Optional[Union[float, Tuple[float]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.pinv. This method simply wraps the - function, and so the docstring for ivy.pinv also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.pinv. This method simply + wraps the function, and so the docstring for ivy.pinv also applies to + this method with minimal changes. Parameters ---------- @@ -719,10 +706,9 @@ def qr( mode: str = "reduced", out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.qr. This method simply wraps the - function, and so the docstring for ivy.qr also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.qr. This method simply + wraps the function, and so the docstring for ivy.qr also applies to + this method with minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -779,10 +765,9 @@ def qr( def slogdet( self: ivy.Array, ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.slogdet. This method simply wraps the - function, and so the docstring for ivy.slogdet also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.slogdet. This method simply + wraps the function, and so the docstring for ivy.slogdet also applies + to this method with minimal changes. Parameters ---------- @@ -836,10 +821,9 @@ def svd( compute_uv: bool = True, full_matrices: bool = True, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """ - ivy.Array instance method variant of ivy.svf. This method simply wraps the - function, and so the docstring for ivy.svd also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.svf. This method simply + wraps the function, and so the docstring for ivy.svd also applies to + this method with minimal changes. Parameters ---------- @@ -924,9 +908,9 @@ def trace( axis2: int = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trace. This method Returns the sum - along the specified diagonals of a matrix (or a stack of matrices). + """ivy.Array instance method variant of ivy.trace. This method Returns + the sum along the specified diagonals of a matrix (or a stack of + matrices). Parameters ---------- @@ -996,9 +980,8 @@ def vector_norm( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.vector_norm. This method computes the - vector norm of a vector (or batch of vectors). + """ivy.Array instance method variant of ivy.vector_norm. This method + computes the vector norm of a vector (or batch of vectors). Parameters ---------- @@ -1089,9 +1072,8 @@ def vander( increasing: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.vander. This method Returns the - Vandermonde matrix of the input array. + """ivy.Array instance method variant of ivy.vander. This method Returns + the Vandermonde matrix of the input array. Parameters ---------- diff --git a/ivy/data_classes/array/losses.py b/ivy/data_classes/array/losses.py index 214c05ac5a189..b11f9d9399e3b 100644 --- a/ivy/data_classes/array/losses.py +++ b/ivy/data_classes/array/losses.py @@ -17,10 +17,9 @@ def cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cross_entropy. This method simply wraps - the function, and so the docstring for ivy.cross_entropy also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.cross_entropy. This method + simply wraps the function, and so the docstring for ivy.cross_entropy + also applies to this method with minimal changes. Parameters ---------- @@ -69,10 +68,10 @@ def binary_cross_entropy( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.binary_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.binary_cross_entropy - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.binary_cross_entropy. This + method simply wraps the function, and so the docstring for + ivy.binary_cross_entropy also applies to this method with minimal + changes. Parameters ---------- @@ -134,10 +133,10 @@ def sparse_cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sparse_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.sparse_cross_entropy - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.sparse_cross_entropy. This + method simply wraps the function, and so the docstring for + ivy.sparse_cross_entropy also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/array/manipulation.py b/ivy/data_classes/array/manipulation.py index f9055f928ff2f..a090309c39673 100644 --- a/ivy/data_classes/array/manipulation.py +++ b/ivy/data_classes/array/manipulation.py @@ -32,10 +32,9 @@ def concat( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.concat. This method simply wraps the - function, and so the docstring for ivy.concat also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.concat. This method simply + wraps the function, and so the docstring for ivy.concat also applies to + this method with minimal changes. Parameters ---------- @@ -69,10 +68,9 @@ def expand_dims( axis: Union[int, Sequence[int]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.expand_dims. This method simply wraps - the function, and so the docstring for ivy.expand_dims also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.expand_dims. This method + simply wraps the function, and so the docstring for ivy.expand_dims + also applies to this method with minimal changes. Parameters ---------- @@ -116,10 +114,9 @@ def flip( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.flip. This method simply wraps the - function, and so the docstring for ivy.flip also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.flip. This method simply + wraps the function, and so the docstring for ivy.flip also applies to + this method with minimal changes. Parameters ---------- @@ -170,10 +167,9 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.permute_dims. This method simply wraps - the function, and so the docstring for ivy.permute_dims also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.permute_dims. This method + simply wraps the function, and so the docstring for ivy.permute_dims + also applies to this method with minimal changes. Parameters ---------- @@ -229,10 +225,9 @@ def reshape( allowzero: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.reshape. This method simply wraps the - function, and so the docstring for ivy.reshape also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.reshape. This method simply + wraps the function, and so the docstring for ivy.reshape also applies + to this method with minimal changes. Parameters ---------- @@ -297,10 +292,9 @@ def roll( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.roll. This method simply wraps the - function, and so the docstring for ivy.roll also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.roll. This method simply + wraps the function, and so the docstring for ivy.roll also applies to + this method with minimal changes. Parameters ---------- @@ -354,10 +348,9 @@ def squeeze( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.squeeze. This method simply wraps the - function, and so the docstring for ivy.squeeze also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.squeeze. This method simply + wraps the function, and so the docstring for ivy.squeeze also applies + to this method with minimal changes. Parameters ---------- @@ -403,10 +396,9 @@ def stack( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.stack also applies to + this method with minimal changes. Parameters ---------- @@ -454,10 +446,9 @@ def clip( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.clip. This method simply wraps the - function, and so the docstring for ivy.clip also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.clip. This method simply + wraps the function, and so the docstring for ivy.clip also applies to + this method with minimal changes. Parameters ---------- @@ -494,10 +485,9 @@ def constant_pad( value: Number = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.constant_pad. This method simply wraps - the function, and so the docstring for ivy.constant_pad also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.constant_pad. This method + simply wraps the function, and so the docstring for ivy.constant_pad + also applies to this method with minimal changes. Parameters ---------- @@ -536,10 +526,9 @@ def repeat( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.repeat. This method simply wraps the - function, and so the docstring for ivy.repeat also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.repeat. This method simply + wraps the function, and so the docstring for ivy.repeat also applies to + this method with minimal changes. Parameters ---------- @@ -581,10 +570,9 @@ def split( axis: int = 0, with_remainder: bool = False, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.split. This method simply wraps the - function, and so the docstring for ivy.split also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.split. This method simply + wraps the function, and so the docstring for ivy.split also applies to + this method with minimal changes. Parameters ---------- @@ -636,10 +624,9 @@ def swapaxes( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.swap_axes. This method simply wraps the - function, and so the docstring for ivy.split also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.swap_axes. This method + simply wraps the function, and so the docstring for ivy.split also + applies to this method with minimal changes. Parameters ---------- @@ -692,10 +679,9 @@ def tile( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tile. This method simply wraps the - function, and so the docstring for ivy.tile also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tile. This method simply + wraps the function, and so the docstring for ivy.tile also applies to + this method with minimal changes. Parameters ---------- @@ -738,10 +724,9 @@ def unstack( axis: int = 0, keepdims: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.unstack. This method simply wraps the - function, and so the docstring for ivy.unstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.unstack. This method simply + wraps the function, and so the docstring for ivy.unstack also applies + to this method with minimal changes. Parameters ---------- @@ -786,10 +771,9 @@ def zero_pad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.zero_pad. This method simply wraps the - function, and so the docstring for ivy.zero_pad also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.zero_pad. This method + simply wraps the function, and so the docstring for ivy.zero_pad also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/norms.py b/ivy/data_classes/array/norms.py index 3c66c85517c20..d3116b4d0cf43 100644 --- a/ivy/data_classes/array/norms.py +++ b/ivy/data_classes/array/norms.py @@ -20,10 +20,9 @@ def layer_norm( new_std: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.layer_norm. This method simply wraps - the function, and so the docstring for ivy.layer_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.layer_norm. This method + simply wraps the function, and so the docstring for ivy.layer_norm also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/random.py b/ivy/data_classes/array/random.py index 047386ee6779f..2835b7690c798 100644 --- a/ivy/data_classes/array/random.py +++ b/ivy/data_classes/array/random.py @@ -18,10 +18,9 @@ def random_uniform( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.random_uniform. This method simply - wraps the function, and so the docstring for ivy.random_uniform also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.random_uniform. This method + simply wraps the function, and so the docstring for ivy.random_uniform + also applies to this method with minimal changes. Parameters ---------- @@ -117,10 +116,9 @@ def random_normal( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.random_normal. This method simply wraps - the function, and so the docstring for ivy.random_normal also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.random_normal. This method + simply wraps the function, and so the docstring for ivy.random_normal + also applies to this method with minimal changes. Parameters ---------- @@ -215,10 +213,9 @@ def multinomial( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.multinomial. This method simply wraps - the function, and so the docstring for ivy.multinomial also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.multinomial. This method + simply wraps the function, and so the docstring for ivy.multinomial + also applies to this method with minimal changes. Parameters ---------- @@ -269,10 +266,9 @@ def randint( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.randint. This method simply wraps the - function, and so the docstring for ivy.randint also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.randint. This method simply + wraps the function, and so the docstring for ivy.randint also applies + to this method with minimal changes. Parameters ---------- @@ -363,10 +359,9 @@ def shuffle( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.shuffle. This method simply wraps the - function, and so the docstring for ivy.shuffle also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.shuffle. This method simply + wraps the function, and so the docstring for ivy.shuffle also applies + to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/searching.py b/ivy/data_classes/array/searching.py index 15537fa4b2005..527132b4248fa 100644 --- a/ivy/data_classes/array/searching.py +++ b/ivy/data_classes/array/searching.py @@ -18,10 +18,9 @@ def argmax( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, int]: - """ - ivy.Array instance method variant of ivy.argmax. This method simply wraps the - function, and so the docstring for ivy.argmax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.argmax. This method simply + wraps the function, and so the docstring for ivy.argmax also applies to + this method with minimal changes. Parameters ---------- @@ -94,10 +93,9 @@ def argmin( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, int]: - """ - ivy.Array instance method variant of ivy.argmin. This method simply wraps the - function, and so the docstring for ivy.argmin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.argmin. This method simply + wraps the function, and so the docstring for ivy.argmin also applies to + this method with minimal changes. Parameters ---------- @@ -162,10 +160,9 @@ def nonzero( size: Optional[int] = None, fill_value: Number = 0, ) -> Union[Tuple[ivy.Array], ivy.Array]: - """ - ivy.Array instance method variant of ivy.nonzero. This method simply wraps the - function, and so the docstring for ivy.nonzero also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nonzero. This method simply + wraps the function, and so the docstring for ivy.nonzero also applies + to this method with minimal changes. Parameters ---------- @@ -202,10 +199,9 @@ def where( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.where. This method simply wraps the - function, and so the docstring for ivy.where also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.where. This method simply + wraps the function, and so the docstring for ivy.where also applies to + this method with minimal changes. Parameters ---------- @@ -238,10 +234,9 @@ def where( return ivy.where(self._data, x1._data, x2._data, out=out) def argwhere(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.argwhere. This method simply wraps the - function, and so the docstring for ivy.argwhere also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.argwhere. This method + simply wraps the function, and so the docstring for ivy.argwhere also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/set.py b/ivy/data_classes/array/set.py index cde03cfce2555..83e2aefdfbc67 100644 --- a/ivy/data_classes/array/set.py +++ b/ivy/data_classes/array/set.py @@ -8,10 +8,9 @@ class _ArrayWithSet(abc.ABC): def unique_counts(self: ivy.Array) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.unique_counts. This method simply wraps - the function, and so the docstring for ivy.unique_counts also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.unique_counts. This method + simply wraps the function, and so the docstring for ivy.unique_counts + also applies to this method with minimal changes. Parameters ---------- @@ -108,10 +107,9 @@ def unique_all( axis: Optional[int] = None, by_value: bool = True, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.unique_all. This method simply wraps - the function, and so the docstring for ivy.unique_all also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.unique_all. This method + simply wraps the function, and so the docstring for ivy.unique_all also + applies to this method with minimal changes. Parameters ---------- @@ -146,10 +144,9 @@ def unique_all( return ivy.unique_all(self._data, axis=axis, by_value=by_value) def unique_inverse(self: ivy.Array) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.unique_inverse. This method simply - wraps the function, and so the docstring for ivy.unique_inverse also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.unique_inverse. This method + simply wraps the function, and so the docstring for ivy.unique_inverse + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/sorting.py b/ivy/data_classes/array/sorting.py index ceb6cfddd0566..b32929c132296 100644 --- a/ivy/data_classes/array/sorting.py +++ b/ivy/data_classes/array/sorting.py @@ -17,10 +17,9 @@ def argsort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.argsort. This method simply wraps the - function, and so the docstring for ivy.argsort also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.argsort. This method simply + wraps the function, and so the docstring for ivy.argsort also applies + to this method with minimal changes. Parameters ---------- @@ -76,10 +75,9 @@ def sort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sort. This method simply wraps the - function, and so the docstring for ivy.sort also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sort. This method simply + wraps the function, and so the docstring for ivy.sort also applies to + this method with minimal changes. Examples -------- @@ -103,10 +101,9 @@ def msort( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.msort. This method simply wraps the - function, and so the docstring for ivy.msort also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.msort. This method simply + wraps the function, and so the docstring for ivy.msort also applies to + this method with minimal changes. Parameters ---------- @@ -141,8 +138,7 @@ def searchsorted( ret_dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.searchsorted. + """ivy.Array instance method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal diff --git a/ivy/data_classes/array/statistical.py b/ivy/data_classes/array/statistical.py index e6cf071dd2319..53b309c0a78e6 100644 --- a/ivy/data_classes/array/statistical.py +++ b/ivy/data_classes/array/statistical.py @@ -17,8 +17,7 @@ def min( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the minimum value of the input array ``x``. + """Calculate the minimum value of the input array ``x``. Parameters ---------- @@ -79,10 +78,9 @@ def max( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.max. This method simply wraps the - function, and so the docstring for ivy.max also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.max. This method simply + wraps the function, and so the docstring for ivy.max also applies to + this method with minimal changes. Parameters ---------- @@ -142,10 +140,9 @@ def mean( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.mean. This method simply wraps the - function, and so the docstring for ivy.mean also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.mean. This method simply + wraps the function, and so the docstring for ivy.mean also applies to + this method with minimal changes. **Special Cases** @@ -230,10 +227,9 @@ def var( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.var. This method simply wraps the - function, and so the docstring for ivy.var also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.var. This method simply + wraps the function, and so the docstring for ivy.var also applies to + this method with minimal changes. **Special Cases** @@ -316,10 +312,9 @@ def prod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.array instance method variant of ivy.prod. This method simply wraps the - function, and so the docstring for ivy.prod also applies to this method with - minimal changes. + """ivy.array instance method variant of ivy.prod. This method simply + wraps the function, and so the docstring for ivy.prod also applies to + this method with minimal changes. Parameters ---------- @@ -402,10 +397,9 @@ def std( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.array instance method variant of ivy.std. This method simply wraps the - function, and so the docstring for ivy.std also applies to this method with - minimal changes. + """ivy.array instance method variant of ivy.std. This method simply + wraps the function, and so the docstring for ivy.std also applies to + this method with minimal changes. Parameters ---------- @@ -497,10 +491,9 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cumsum. This method simply wraps the - function, and so the docstring for ivy.cumsum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cumsum. This method simply + wraps the function, and so the docstring for ivy.cumsum also applies to + this method with minimal changes. Parameters ---------- @@ -572,10 +565,9 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cumprod. This method simply wraps the - function, and so the docstring for ivy.cumprod also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cumprod. This method simply + wraps the function, and so the docstring for ivy.cumprod also applies + to this method with minimal changes. Parameters ---------- @@ -643,10 +635,9 @@ def einsum( *operands: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.einsum. This method simply wraps the - function, and so the docstring for ivy.einsum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.einsum. This method simply + wraps the function, and so the docstring for ivy.einsum also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/utility.py b/ivy/data_classes/array/utility.py index 089b99918be1b..a711dfd46f1f8 100644 --- a/ivy/data_classes/array/utility.py +++ b/ivy/data_classes/array/utility.py @@ -15,10 +15,9 @@ def all( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.all. This method simply wraps the - function, and so the docstring for ivy.all also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.all. This method simply + wraps the function, and so the docstring for ivy.all also applies to + this method with minimal changes. Parameters ---------- @@ -76,10 +75,9 @@ def any( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.any. This method simply wraps the - function, and so the docstring for ivy.any also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.any. This method simply + wraps the function, and so the docstring for ivy.any also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/wrapping.py b/ivy/data_classes/array/wrapping.py index 74105ef566edc..f79ad5a07191a 100644 --- a/ivy/data_classes/array/wrapping.py +++ b/ivy/data_classes/array/wrapping.py @@ -9,8 +9,7 @@ def _wrap_function(function_name: str) -> Callable: - """ - Wrap the function called `function_name`. + """Wrap the function called `function_name`. Parameters ---------- @@ -33,9 +32,8 @@ def _wrap_function(function_name: str) -> Callable: """ def new_function(self, *args, **kwargs): - """ - Add the data of the current array from which the instance function is invoked as - the first arg parameter or kwarg parameter. + """Add the data of the current array from which the instance function + is invoked as the first arg parameter or kwarg parameter. Return the new function with the name function_name and the new args variable or kwargs as the new inputs. @@ -63,9 +61,8 @@ def new_function(self, *args, **kwargs): def add_ivy_array_instance_methods( cls: Type[ivy.Array], modules: List[ModuleType], to_ignore: Iterable = () ): - """ - Loop over all ivy modules such as activations, general, etc. and add the module - functions to ivy arrays as instance methods using _wrap_function. + """Loop over all ivy modules such as activations, general, etc. and add the + module functions to ivy arrays as instance methods using _wrap_function. Parameters ---------- diff --git a/ivy/data_classes/container/activations.py b/ivy/data_classes/container/activations.py index 9d5883bd1d213..c8499ef9d6f91 100644 --- a/ivy/data_classes/container/activations.py +++ b/ivy/data_classes/container/activations.py @@ -21,10 +21,9 @@ def _static_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.relu. This method simply wraps the - function, and so the docstring for ivy.relu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.relu. This method simply + wraps the function, and so the docstring for ivy.relu also applies to + this method with minimal changes. Parameters ---------- @@ -86,10 +85,9 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.relu. This method simply wraps the - function, and so the docstring for ivy.relu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.relu. This method + simply wraps the function, and so the docstring for ivy.relu also + applies to this method with minimal changes. Parameters ---------- @@ -152,10 +150,9 @@ def _static_leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.leaky_relu. This method simply wraps - the function, and so the docstring for ivy.leaky_relu also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.leaky_relu. This method + simply wraps the function, and so the docstring for ivy.leaky_relu also + applies to this method with minimal changes. Parameters ---------- @@ -220,10 +217,9 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.leaky_relu. This method simply - wraps the function, and so the docstring for ivy.leaky_relu also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.leaky_relu. This method + simply wraps the function, and so the docstring for ivy.leaky_relu also + applies to this method with minimal changes. Parameters ---------- @@ -288,10 +284,9 @@ def _static_gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.gelu. This method simply wraps the - function, and so the docstring for ivy.gelu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.gelu. This method simply + wraps the function, and so the docstring for ivy.gelu also applies to + this method with minimal changes. Parameters ---------- @@ -355,10 +350,9 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gelu. This method simply wraps the - function, and so the docstring for ivy.gelu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.gelu. This method + simply wraps the function, and so the docstring for ivy.gelu also + applies to this method with minimal changes. Parameters ---------- @@ -422,10 +416,9 @@ def _static_sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sigmoid. This method simply wraps the - function, and so the docstring for ivy.sigmoid also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sigmoid. This method + simply wraps the function, and so the docstring for ivy.sigmoid also + applies to this method with minimal changes. Parameters ---------- @@ -486,10 +479,9 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sigmoid. This method simply wraps - the function, and so the docstring for ivy.sigmoid also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.sigmoid. This method + simply wraps the function, and so the docstring for ivy.sigmoid also + applies to this method with minimal changes. Parameters ---------- @@ -551,10 +543,9 @@ def _static_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.softmax. This method simply wraps the - function, and so the docstring for ivy.softmax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.softmax. This method + simply wraps the function, and so the docstring for ivy.softmax also + applies to this method with minimal changes. Parameters ---------- @@ -619,10 +610,9 @@ def softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.softmax. This method simply wraps - the function, and so the docstring for ivy.softmax also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.softmax. This method + simply wraps the function, and so the docstring for ivy.softmax also + applies to this method with minimal changes. Parameters ---------- @@ -688,10 +678,9 @@ def _static_softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.softplus. This method simply wraps - the function, and so the docstring for ivy.softplus also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.softplus. This method + simply wraps the function, and so the docstring for ivy.softplus also + applies to this method with minimal changes. Parameters ---------- @@ -767,10 +756,9 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.softplus. This method simply wraps - the function, and so the docstring for ivy.softplus also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.softplus. This method + simply wraps the function, and so the docstring for ivy.softplus also + applies to this method with minimal changes. Parameters ---------- @@ -844,10 +832,9 @@ def _static_log_softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log_softmax. This method simply wraps - the function, and so the docstring for ivy.log_softmax also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.log_softmax. This method + simply wraps the function, and so the docstring for ivy.log_softmax + also applies to this method with minimal changes. Parameters ---------- @@ -919,10 +906,9 @@ def log_softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container instance method variant of ivy.log_softmax. This method simply - wraps the function, and so the docstring for ivy.log_softmax also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.log_softmax. This + method simply wraps the function, and so the docstring for + ivy.log_softmax also applies to this method with minimal changes. Parameters ---------- @@ -993,10 +979,9 @@ def _static_mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.mish. This method simply wraps the - function, and so the docstring for ivy.mish also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.mish. This method simply + wraps the function, and so the docstring for ivy.mish also applies to + this method with minimal changes. Parameters ---------- @@ -1058,10 +1043,9 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.mish. This method simply wraps the - function, and so the docstring for ivy.mish also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.mish. This method + simply wraps the function, and so the docstring for ivy.mish also + applies to this method with minimal changes. Parameters ---------- @@ -1123,10 +1107,9 @@ def _static_hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hardswish. This method simply wraps - the function, and so the docstring for ivy.hardswish also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.hardswish. This method + simply wraps the function, and so the docstring for ivy.hardswish also + applies to this method with minimal changes. Parameters ---------- @@ -1188,10 +1171,9 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hardswish. This method simply wraps - the function, and so the docstring for ivy.hardswish also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.hardswish. This method + simply wraps the function, and so the docstring for ivy.hardswish also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index b7b35452b3cde..ea24b676a9154 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -72,8 +72,7 @@ def __init__( build_callable=False, **kwargs, ): - """ - Initialize container object from input dict representation. + """Initialize container object from input dict representation. Parameters ---------- @@ -272,9 +271,8 @@ def map_fn(vals, _): @staticmethod def cont_handle_inplace(ret, out): - """ - Return an inplace update of out, provided it is not None, by updating with the - values in ret. + """Return an inplace update of out, provided it is not None, by + updating with the values in ret. Parameters ---------- @@ -295,8 +293,7 @@ def cont_handle_inplace(ret, out): @staticmethod def cont_list_join(containers, config=None): - """ - Join containers of lists together along the specified dimension. + """Join containers of lists together along the specified dimension. Parameters ---------- @@ -328,8 +325,7 @@ def cont_list_join(containers, config=None): @staticmethod def cont_list_stack(containers, dim, config=None): - """ - List stack containers together along the specified dimension. + """List stack containers together along the specified dimension. Parameters ---------- @@ -379,9 +375,8 @@ def _cont_mean_unify(containers, device, _=None, _1=None): @staticmethod def cont_unify(containers, device, mode, axis=0): - """ - Unify a list of containers, on arbitrary devices, to a single container on the - specified device. + """Unify a list of containers, on arbitrary devices, to a single + container on the specified device. Parameters ---------- @@ -407,9 +402,8 @@ def cont_unify(containers, device, mode, axis=0): @staticmethod def cont_combine(*containers, config=None): - """ - Combine keys and values in a sequence of containers, with priority given to the - right-most container in the case of duplicates. + """Combine keys and values in a sequence of containers, with priority + given to the right-most container in the case of duplicates. Parameters ---------- @@ -466,10 +460,9 @@ def cont_diff( detect_shape_diffs=True, config=None, ): - """ - Compare keys and values in a sequence of containers, returning the single shared - values where they are the same, and new nested sub-dicts with all values where - they are different. + """Compare keys and values in a sequence of containers, returning the + single shared values where they are the same, and new nested sub-dicts + with all values where they are different. Parameters ---------- @@ -613,10 +606,9 @@ def cont_structural_diff( detect_shape_diffs=True, config=None, ): - """ - Compare keys and shapes in a sequence of containers, returning the single shared - values where they are the same, and new nested sub-dicts with all values where - they are different. + """Compare keys and shapes in a sequence of containers, returning the + single shared values where they are the same, and new nested sub-dicts + with all values where they are different. Parameters ---------- @@ -666,8 +658,7 @@ def cont_multi_map( map_nests=False, assert_identical=False, ): - """ - Apply function to all array values from a collection of containers. + """Apply function to all array values from a collection of containers. Parameters ---------- @@ -786,8 +777,7 @@ def _found_in_key_chains(this_key_chain, key_chains): @staticmethod def cont_common_key_chains(containers): - """ - Return the key-chains common across all containers. + """Return the key-chains common across all containers. Parameters ---------- @@ -816,9 +806,8 @@ def cont_identical( key_chain="", assert_and_assign=False, ): - """ - Return a single boolean as to whether the input containers have identical key- - chains and data types. + """Return a single boolean as to whether the input containers have + identical key- chains and data types. Parameters ---------- @@ -930,9 +919,8 @@ def cont_assert_identical( to_apply=True, partial=False, ): - """ - Assert whether the input containers are identical. Otherwise, the diff is shown - in an exception. + """Assert whether the input containers are identical. Otherwise, the + diff is shown in an exception. Parameters ---------- @@ -983,9 +971,8 @@ def cont_identical_structure( key_chain="", assert_and_assign=False, ): - """ - Return a single boolean as to whether the input containers have identical - structure. + """Return a single boolean as to whether the input containers have + identical structure. Parameters ---------- @@ -1038,9 +1025,8 @@ def cont_assert_identical_structure( partial=False, assert_and_assign=False, ): - """ - Assert whether the input containers have identical structure. Otherwise, the - diff is shown in an exception. + """Assert whether the input containers have identical structure. + Otherwise, the diff is shown in an exception. Parameters ---------- @@ -1080,9 +1066,8 @@ def cont_assert_identical_structure( @staticmethod def cont_identical_configs(containers): - """ - Return a single boolean as to whether the input containers all have identical - configs. + """Return a single boolean as to whether the input containers all have + identical configs. Parameters ---------- @@ -1098,9 +1083,9 @@ def cont_identical_configs(containers): @staticmethod def cont_identical_array_shapes(containers, exclusive=False): - """ - Determine whether all of the containers have identical number of arrays and - identical array shapes, regardless of their key-chain structures. + """Determine whether all of the containers have identical number of + arrays and identical array shapes, regardless of their key-chain + structures. Parameters ---------- @@ -1142,9 +1127,8 @@ def cont_load(filepath, format="h5py"): def cont_from_disk_as_hdf5( h5_obj_or_filepath, slice_obj=slice(None), alphabetical_keys=True, ivyh=None ): - """ - Load container object from disk, as an h5py file, at the specified hdf5 - filepath. + """Load container object from disk, as an h5py file, at the specified + hdf5 filepath. Parameters ---------- @@ -1193,8 +1177,7 @@ def cont_from_disk_as_hdf5( @staticmethod def cont_from_disk_as_pickled(pickle_filepath, ivyh=None): - """ - Load container object from disk at the specified pickle filepath. + """Load container object from disk at the specified pickle filepath. Parameters ---------- @@ -1216,9 +1199,9 @@ def cont_from_disk_as_pickled(pickle_filepath, ivyh=None): @staticmethod def cont_from_disk_as_json(json_filepath, ivyh=None): - """ - Load container object from disk at the specified json filepath. If some objects - were not json-able during saving, then they will be loaded as strings. + """Load container object from disk at the specified json filepath. If + some objects were not json-able during saving, then they will be loaded + as strings. Parameters ---------- @@ -1237,8 +1220,7 @@ def cont_from_disk_as_json(json_filepath, ivyh=None): @staticmethod def h5_file_size(h5_obj_or_filepath): - """ - Get file size of h5 file contents. + """Get file size of h5 file contents. Parameters ---------- @@ -1279,9 +1261,8 @@ def h5_file_size(h5_obj_or_filepath): @staticmethod def shuffle_h5_file(h5_obj_or_filepath, seed_value=0): - """ - Shuffle entries in all datasets of h5 file, such that they are still aligned - along axis 0. + """Shuffle entries in all datasets of h5 file, such that they are still + aligned along axis 0. Parameters ---------- @@ -1320,8 +1301,7 @@ def shuffle_h5_file(h5_obj_or_filepath, seed_value=0): @staticmethod def cont_reduce(containers, reduction, config=None): - """ - Reduce containers. + """Reduce containers. Parameters ---------- @@ -1363,8 +1343,7 @@ def cont_reduce(containers, reduction, config=None): def cont_flatten_key_chain( key_chain, replacement="__", above_height=None, below_depth=None ): - """ - Summary. + """Summary. Parameters ---------- @@ -1400,8 +1379,7 @@ def cont_flatten_key_chain( @staticmethod def cont_trim_key(key, max_length): - """ - Summary. Returns a trimmed key with a maximum length of max_length. + """Summary. Returns a trimmed key with a maximum length of max_length. Parameters ---------- @@ -1641,9 +1619,8 @@ def cont_update_config(self, **config): def cont_inplace_update( self, dict_in: Union[ivy.Container, dict], **config ) -> ivy.Container: - """ - Update the contents of this container inplace, using either a new dict or - container. + """Update the contents of this container inplace, using either a new + dict or container. Parameters ---------- @@ -1695,8 +1672,8 @@ def cont_all_true( prune_unapplied=False, map_sequences=False, ): - """ - Determine whether all the entries in the container boolean evaluate to True. + """Determine whether all the entries in the container boolean evaluate + to True. Parameters ---------- @@ -1740,8 +1717,8 @@ def cont_all_false( prune_unapplied=False, map_sequences=False, ): - """ - Determine whether all the entries in the container boolean evaluate to False. + """Determine whether all the entries in the container boolean evaluate + to False. Parameters ---------- @@ -1778,8 +1755,7 @@ def cont_all_false( ) def cont_slice_via_key(self, slice_key): - """ - Get slice of container, based on key. + """Get slice of container, based on key. Parameters ---------- @@ -1808,8 +1784,7 @@ def cont_as_bools( prune_unapplied=False, map_sequences=False, ): - """ - Return boolean evaluation for all nested items in the container. + """Return boolean evaluation for all nested items in the container. Parameters ---------- @@ -1848,8 +1823,7 @@ def _ret_bool(x): ) def cont_unstack_conts(self, axis, keepdims=False, dim_size=None): - """ - Unstack containers along specified dimension. + """Unstack containers along specified dimension. Parameters ---------- @@ -1896,8 +1870,7 @@ def split_conts( prune_unapplied=False, map_sequences=False, ): - """ - Split a container into multiple sub-containers. + """Split a container into multiple sub-containers. The function does that by splitting their constituent arrays. @@ -1952,9 +1925,8 @@ def split_conts( ).cont_unstack_conts(0, dim_size=dim_size) def cont_num_arrays(self, exclusive=False): - """ - Compute the number of arrays present at the leaf nodes, including variables by - default. + """Compute the number of arrays present at the leaf nodes, including + variables by default. Parameters ---------- @@ -1969,9 +1941,8 @@ def cont_num_arrays(self, exclusive=False): ) def cont_size_ordered_arrays(self, exclusive=False): - """ - Return a container with keychains mapped to flat keys, and arrays given in order - of smallest to largest. + """Return a container with keychains mapped to flat keys, and arrays + given in order of smallest to largest. Parameters ---------- @@ -2006,8 +1977,8 @@ def cont_save(self, filepath, format="h5py"): def cont_to_disk_as_hdf5( self, h5_obj_or_filepath, starting_index=0, mode="a", max_batch_size=None ): - """ - Save container object to disk, as an h5py file, at the specified filepath. + """Save container object to disk, as an h5py file, at the specified + filepath. Parameters ---------- @@ -2066,8 +2037,8 @@ def cont_to_disk_as_hdf5( ) def cont_to_disk_as_pickled(self, pickle_filepath): - """ - Save container object to disk, as an pickled file, at the specified filepath. + """Save container object to disk, as an pickled file, at the specified + filepath. Parameters ---------- @@ -2096,8 +2067,8 @@ def cont_to_jsonable(self, return_dict=None): return return_dict def cont_to_disk_as_json(self, json_filepath): - """ - Save container object to disk, as an json file, at the specified filepath. + """Save container object to disk, as an json file, at the specified + filepath. Parameters ---------- @@ -2117,8 +2088,7 @@ def cont_to_nested_list(self): return return_list def cont_to_raw(self): - """ - Convert container to its original form. + """Convert container to its original form. Returns ------- @@ -2140,8 +2110,7 @@ def cont_to_raw(self): return return_item def cont_to_dict(self): - """ - Summary. + """Summary. Returns ------- @@ -2235,8 +2204,7 @@ def cont_to_iterator_keys( yield kc def cont_to_flat_list(self): - """ - Summary. + """Summary. Returns ------- @@ -2246,9 +2214,8 @@ def cont_to_flat_list(self): return [item for key, item in self.cont_to_iterator()] def cont_from_flat_list(self, flat_list): - """ - Return new container object with the same hierarchy, but with values replaced - from flat list. + """Return new container object with the same hierarchy, but with values + replaced from flat list. Parameters ---------- @@ -2269,9 +2236,8 @@ def cont_from_flat_list(self, flat_list): return ivy.Container(new_dict, **self._config) def cont_has_key(self, query_key): - """ - Determine whether container object has specified key somewhere in the nested - structure. + """Determine whether container object has specified key somewhere in + the nested structure. Parameters ---------- @@ -2304,8 +2270,7 @@ def map_fn(x, kc): return has_key def cont_has_key_chain(self, key_chain): - """ - Determine whether container object has specified key-chain. + """Determine whether container object has specified key-chain. Parameters ---------- @@ -2327,8 +2292,7 @@ def cont_has_key_chain(self, key_chain): return True def cont_find_sub_container(self, sub_cont_to_find, partial=False): - """ - Find the sub-container in the current container if it exists. + """Find the sub-container in the current container if it exists. Parameters ---------- @@ -2359,9 +2323,8 @@ def _check_sub_cont(sub_cont, kc): return key_chain_found def cont_contains_sub_container(self, sub_cont, partial=False): - """ - Determine whether the current container contains the sub-container, with - matching structure and array values. + """Determine whether the current container contains the sub-container, + with matching structure and array values. Parameters ---------- @@ -2378,9 +2341,8 @@ def cont_contains_sub_container(self, sub_cont, partial=False): return isinstance(self.cont_find_sub_container(sub_cont, partial), str) def cont_assert_contains_sub_container(self, sub_cont, partial=False): - """ - Assert that the current container contains the sub-container, otherwise - exception raised with the diff printed to screen. + """Assert that the current container contains the sub-container, + otherwise exception raised with the diff printed to screen. Parameters ---------- @@ -2409,8 +2371,8 @@ def cont_assert_contains_sub_container(self, sub_cont, partial=False): def cont_find_sub_structure( self, sub_struc_to_find, check_shapes=True, partial=False ): - """ - Find the sub-container structure in the current container if it exists. + """Find the sub-container structure in the current container if it + exists. Parameters ---------- @@ -2454,8 +2416,8 @@ def _check_sub_cont(sub_cont, kc): return key_chain_found def cont_contains_sub_structure(self, sub_cont, check_shapes=True, partial=False): - """ - Determine whether the current container contains the sub-container structure. + """Determine whether the current container contains the sub-container + structure. Parameters ---------- @@ -2474,9 +2436,8 @@ def cont_contains_sub_structure(self, sub_cont, check_shapes=True, partial=False def cont_assert_contains_sub_structure( self, sub_cont, check_shapes=True, partial=False ): - """ - Assert that the current container contains the sub-container structure, - otherwise exception raised with the diff printed to screen. + """Assert that the current container contains the sub-container + structure, otherwise exception raised with the diff printed to screen. Parameters ---------- @@ -2514,8 +2475,8 @@ def cont_assert_contains_sub_structure( def cont_at_keys( self, queries, ignore_none=True, containing=False, ignore_key_errors=False ): - """ - Query container object at specified keys, either as list or nested dict. + """Query container object at specified keys, either as list or nested + dict. Parameters ---------- @@ -2558,8 +2519,7 @@ def map_fn(x, kc): ) def cont_at_key_chain(self, key_chain, ignore_key_errors=False): - """ - Query container object at a specified key-chain. + """Query container object at a specified key-chain. Parameters ---------- @@ -2585,8 +2545,8 @@ def cont_at_key_chain(self, key_chain, ignore_key_errors=False): return ret def cont_at_key_chains(self, key_chains, ignore_none=True, ignore_key_errors=False): - """ - Query container object at specified key-chains, either as list or nested dict. + """Query container object at specified key-chains, either as list or + nested dict. Parameters ---------- @@ -2651,8 +2611,7 @@ def cont_key_chains_containing(self, sub_str, include_empty=False): ] def cont_set_at_keys(self, target_dict): - """ - Set values of container object at specified keys. + """Set values of container object at specified keys. Parameters ---------- @@ -2675,8 +2634,7 @@ def cont_set_at_keys(self, target_dict): return ivy.Container(return_dict, **self._config) def cont_set_at_key_chain(self, key_chain, val, inplace=False): - """ - Set value of container object at a specified key-chain. + """Set value of container object at a specified key-chain. Parameters ---------- @@ -2706,8 +2664,7 @@ def cont_set_at_key_chain(self, key_chain, val, inplace=False): return cont def cont_overwrite_at_key_chain(self, key_chain, val, inplace=False): - """ - Overwrite value of container object at a specified key-chain. + """Overwrite value of container object at a specified key-chain. Parameters ---------- @@ -2751,8 +2708,7 @@ def cont_overwrite_at_key_chain(self, key_chain, val, inplace=False): return cont def cont_set_at_key_chains(self, target_dict, return_dict=None, inplace=False): - """ - Set values of container object at specified key-chains. + """Set values of container object at specified key-chains. Parameters ---------- @@ -2783,8 +2739,7 @@ def cont_set_at_key_chains(self, target_dict, return_dict=None, inplace=False): def cont_overwrite_at_key_chains( self, target_dict, return_dict=None, inplace=False ): - """ - Overwrite values of container object at specified key-chains. + """Overwrite values of container object at specified key-chains. Parameters ---------- @@ -2824,8 +2779,7 @@ def cont_overwrite_at_key_chains( return return_dict def cont_prune_keys(self, query_keys, ignore_none=True): - """ - Recursively prune set of keys. + """Recursively prune set of keys. Parameters ---------- @@ -2865,8 +2819,7 @@ def map_fn(x, kc): return self.cont_prune_key_chains(key_chains_to_prune) def cont_prune_key_chain(self, key_chain): - """ - Recursively prune chain of keys, specified as 'key1/key2/key3/...'. + """Recursively prune chain of keys, specified as 'key1/key2/key3/...'. Parameters ---------- @@ -2900,8 +2853,7 @@ def cont_prune_key_chain(self, key_chain): return ivy.Container(out_dict, **self._config) def cont_prune_key_chains(self, key_chains, ignore_none=True): - """ - Recursively prune set of key chains. + """Recursively prune set of key chains. Parameters ---------- @@ -2930,8 +2882,7 @@ def cont_prune_key_chains(self, key_chains, ignore_none=True): ) def cont_format_key_chains(self, format_fn): - """ - Format all key-chains, using the formatting function. + """Format all key-chains, using the formatting function. Parameters ---------- @@ -2956,9 +2907,8 @@ def cont_sort_by_key(self): return ivy.Container(new_dict, **self._config) def cont_prune_empty(self, keep_nones=False, base=True): - """ - Recursively prunes empty keys from the container dict structure. Returns None if - the entire container is empty. + """Recursively prunes empty keys from the container dict structure. + Returns None if the entire container is empty. Parameters ---------- @@ -2987,9 +2937,8 @@ def cont_prune_empty(self, keep_nones=False, base=True): return def cont_prune_key_from_key_chains(self, absolute=None, containing=None): - """ - Recursively prune absolute key or key containing a certain substring from all - key chains. + """Recursively prune absolute key or key containing a certain substring + from all key chains. Parameters ---------- @@ -3029,9 +2978,8 @@ def cont_prune_key_from_key_chains(self, absolute=None, containing=None): return out_cont def cont_prune_keys_from_key_chains(self, absolute=None, containing=None): - """ - Recursively prune absolute keys or keys containing certain substrings from all - key chains. + """Recursively prune absolute keys or keys containing certain + substrings from all key chains. Parameters ---------- @@ -3077,9 +3025,9 @@ def cont_prune_keys_from_key_chains(self, absolute=None, containing=None): def cont_restructure_key_chains( self, keychain_mapping, keep_orig=True, replace=True ): - """ - Create a new container with the same contents, but a new key-chain structure. - Given by the mapping with keys as old key-chains and values as new key-chains. + """Create a new container with the same contents, but a new key-chain + structure. Given by the mapping with keys as old key-chains and values + as new key-chains. Parameters ---------- @@ -3101,10 +3049,9 @@ def cont_restructure_key_chains( return new_cont def cont_restructure(self, mapping, keep_orig=True, replace=True): - """ - Create a new container with the same contents, but a new key-chain structure, - and transposes and/or reshaped arrays. Given by the mapping with keys as old - key-chains and values as new key-chains. + """Create a new container with the same contents, but a new key-chain + structure, and transposes and/or reshaped arrays. Given by the mapping + with keys as old key-chains and values as new key-chains. Parameters ---------- @@ -3140,8 +3087,7 @@ def cont_restructure(self, mapping, keep_orig=True, replace=True): def cont_flatten_key_chains( self, include_empty=False, above_height=None, below_depth=None ): - """ - Summary. + """Summary. Parameters ---------- @@ -3163,8 +3109,7 @@ def cont_flatten_key_chains( ) def cont_copy(self): - """ - Create a copy of this container. + """Create a copy of this container. Returns ------- @@ -3173,8 +3118,7 @@ def cont_copy(self): return ivy.Container(self.cont_to_dict(), **self._config) def cont_deep_copy(self): - """ - Create a deep copy (copying all internal tensors) of this container. + """Create a deep copy (copying all internal tensors) of this container. return: A deep copy of the container """ @@ -3197,8 +3141,7 @@ def cont_map( inplace=False, key_chain="", ): - """ - Apply function to all array values of container. + """Apply function to all array values of container. Parameters ---------- @@ -3273,8 +3216,7 @@ def cont_map_sub_conts( key_chain="", include_self=True, ): - """ - Apply function to all sub-contains in the container. + """Apply function to all sub-contains in the container. Parameters ---------- @@ -3336,9 +3278,8 @@ def to_list(x, _=""): return self.cont_map(to_list) def cont_reshape_like(self, target_dict, leading_shape=None, return_cont=None): - """ - Set shapes of container entries to shapes specified by new container with the - same key structure. + """Set shapes of container entries to shapes specified by new container + with the same key structure. Parameters ---------- @@ -3369,9 +3310,8 @@ def cont_reshape_like(self, target_dict, leading_shape=None, return_cont=None): return ivy.Container(return_cont, **self._config) def cont_create_if_absent(self, key, value, inplace=True): - """ - Add a key to the container with corresponding value, if it is not already - present. otherwise, do nothing. + """Add a key to the container with corresponding value, if it is not + already present. otherwise, do nothing. Parameters ---------- @@ -3386,8 +3326,8 @@ def cont_create_if_absent(self, key, value, inplace=True): self.cont_set_at_key_chain(key, value, inplace) def cont_if_exists(self, key): - """ - Return the sub-container at the following key if it exists, otherwise None. + """Return the sub-container at the following key if it exists, + otherwise None. Parameters ---------- @@ -3399,8 +3339,7 @@ def cont_if_exists(self, key): return def cont_try_kc(self, key): - """ - Try the following key or key chain, returning self if not present. + """Try the following key or key chain, returning self if not present. Parameters ---------- @@ -3412,8 +3351,7 @@ def cont_try_kc(self, key): return self def cont_cutoff_at_depth(self, depth_cutoff, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3438,8 +3376,7 @@ def _maybe_cutoff(cont, kc): return ret def cont_cutoff_at_height(self, height_cutoff, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3478,8 +3415,7 @@ def _cont_slice_keys(self, key_slice): return ret.cont_at_key_chains(desired_keys) def cont_slice_keys(self, key_slice, all_depths=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3510,8 +3446,7 @@ def _fn(cont, kc): return self._cont_slice_keys(key_slice) def cont_with_print_limit(self, print_limit, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3532,8 +3467,7 @@ def _update_print_limit(cont, _): # noinspection PyTypeChecker def cont_remove_print_limit(self, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3543,8 +3477,7 @@ def cont_remove_print_limit(self, inplace=False): return self.cont_with_print_limit(None, inplace) def cont_with_key_length_limit(self, key_length_limit, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3564,8 +3497,7 @@ def _update_key_length_limit(cont, _): return ret def cont_remove_key_length_limit(self, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3575,8 +3507,7 @@ def cont_remove_key_length_limit(self, inplace=False): return self.cont_with_key_length_limit(None, inplace) def cont_with_print_indent(self, print_indent, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3596,8 +3527,7 @@ def _update_print_indent(cont, _): return ret def cont_with_print_line_spacing(self, print_line_spacing, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3617,8 +3547,7 @@ def _update_print_line_spacing(cont, _): return ret def cont_with_default_key_color(self, default_key_color, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3638,8 +3567,7 @@ def _update_default_key_color(cont, _): return ret def cont_with_ivy_backend(self, ivy_backend: str, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3662,8 +3590,7 @@ def cont_show(self): # noinspection PyUnresolvedReferences def cont_show_sub_container(self, sub_cont_or_keychain): - """ - Summary. + """Summary. Parameters ---------- @@ -4053,8 +3980,7 @@ def _get_queue_item(self, query): return combined_cont[shifted_query] def __getitem__(self, query): - """ - Get slice, key or key chain of container object. + """Get slice, key or key chain of container object. Parameters ---------- @@ -4095,8 +4021,7 @@ def __getitem__(self, query): return ret def __setitem__(self, query, val): - """ - Set key or key chain of container object. + """Set key or key chain of container object. Parameters ---------- @@ -4205,8 +4130,7 @@ def _cont_ivy(self, local_ivy): @property def cont_shape(self): - """ - The shape of the arrays in the container. + """The shape of the arrays in the container. None is placed in indices which are not consistent across arrays. @@ -4215,8 +4139,7 @@ def cont_shape(self): @property def cont_dtype(self): - """ - The dtype of the arrays in the container. + """The dtype of the arrays in the container. None is returned if the dtypes are not consistent. """ @@ -4224,8 +4147,7 @@ def cont_dtype(self): @property def cont_shapes(self): - """ - The shapes of each array in the container. + """The shapes of each array in the container. None is placed in leaf entries without a shape attribute. """ @@ -4233,8 +4155,7 @@ def cont_shapes(self): @property def cont_dev(self): - """ - The device to which the arrays in the container belong. + """The device to which the arrays in the container belong. None returned if the devices are not consistent. """ @@ -4242,8 +4163,7 @@ def cont_dev(self): @property def cont_dev_str(self): - """ - The device to which the arrays in the container belong. + """The device to which the arrays in the container belong. None returned if the devices are not consistent. """ diff --git a/ivy/data_classes/container/container.py b/ivy/data_classes/container/container.py index cc7d4fcf1b6dc..2c430ec1d3426 100644 --- a/ivy/data_classes/container/container.py +++ b/ivy/data_classes/container/container.py @@ -141,9 +141,9 @@ def __neg__(self): return self.cont_map(lambda x, kc: -x, map_sequences=True) def __pow__(self, power): - """ - ivy.Container special method for the power operator, calling - :code:`operator.pow` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the power operator, calling + :code:`operator.pow` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -196,9 +196,9 @@ def __ipow__(self, power): return self.cont_map(lambda x, _: operator.ipow(x, power), map_sequences=True) def __add__(self, other): - """ - ivy.Container special method for the add operator, calling :code:`operator.add` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the add operator, calling + :code:`operator.add` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -261,9 +261,9 @@ def __add__(self, other): ) def __radd__(self, other): - """ - ivy.Container reverse special method for the add operator, calling - :code:`operator.add` for each of the corresponding leaves of the two containers. + """ivy.Container reverse special method for the add operator, calling + :code:`operator.add` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -300,9 +300,9 @@ def __iadd__(self, other): ) def __sub__(self, other): - """ - ivy.Container special method for the subtract operator, calling - :code:`operator.sub` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the subtract operator, calling + :code:`operator.sub` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -370,9 +370,9 @@ def __isub__(self, other): ) def __rsub__(self, other): - """ - ivy.Container reverse special method for the subtract operator, calling - :code:`operator.sub` for each of the corresponding leaves of the two containers. + """ivy.Container reverse special method for the subtract operator, + calling :code:`operator.sub` for each of the corresponding leaves of + the two containers. Parameters ---------- @@ -448,10 +448,9 @@ def __rdivmod__(self, other): ) def __truediv__(self, other): - """ - ivy.Container special method for the divide operator, calling - :code:`operator.truediv` for each of the corresponding leaves of the two - containers. + """ivy.Container special method for the divide operator, calling + :code:`operator.truediv` for each of the corresponding leaves of the + two containers. Parameters ---------- @@ -564,9 +563,9 @@ def __imatmul__(self, other): ) def __abs__(self): - """ - ivy.Container special method for the abs operator, calling :code:`operator.abs` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the abs operator, calling + :code:`operator.abs` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -594,9 +593,9 @@ def __abs__(self): return self.cont_map(lambda x, kc: operator.abs(x), map_sequences=True) def __lt__(self, other): - """ - ivy.Container special method for the less operator, calling :code:`operator.lt` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the less operator, calling + :code:`operator.lt` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -632,9 +631,9 @@ def __lt__(self, other): return self.cont_map(lambda x, kc: x < other, map_sequences=True) def __le__(self, other): - """ - ivy.Container special method for the less_equal operator, calling - :code:`operator.le` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the less_equal operator, calling + :code:`operator.le` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -670,9 +669,9 @@ def __le__(self, other): return self.cont_map(lambda x, kc: x <= other, map_sequences=True) def __eq__(self, other): - """ - ivy.Container special method for the equal operator, calling :code:`operator.eq` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the equal operator, calling + :code:`operator.eq` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -732,9 +731,9 @@ def __eq__(self, other): return self.cont_map(lambda x, kc: x == other, map_sequences=True) def __ne__(self, other): - """ - ivy.Container special method for the not_equal operator, calling - :code:`operator.ne` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the not_equal operator, calling + :code:`operator.ne` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -794,9 +793,9 @@ def __ne__(self, other): return self.cont_map(lambda x, kc: x != other, map_sequences=True) def __gt__(self, other): - """ - ivy.Container special method for the greater operator, calling - :code:`operator.gt` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the greater operator, calling + :code:`operator.gt` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -832,9 +831,9 @@ def __gt__(self, other): return self.cont_map(lambda x, kc: x > other, map_sequences=True) def __ge__(self, other): - """ - ivy.Container special method for the greater_equal operator, calling - :code:`operator.ge` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the greater_equal operator, calling + :code:`operator.ge` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -905,9 +904,9 @@ def __invert__(self): return self.cont_map(lambda x, kc: operator.not_(x), map_sequences=True) def __xor__(self, other): - """ - ivy.Container special method for the ge operator, calling :code:`operator.ge` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the ge operator, calling + :code:`operator.ge` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -980,8 +979,7 @@ def __ilshift__(self, other): ) def __rshift__(self, other): - """ - ivy.Container special method for the right shift operator, calling + """ivy.Container special method for the right shift operator, calling :code:`operator.rshift` for each of the corresponding leaves of the two containers. @@ -1049,10 +1047,9 @@ def __rshift__(self, other): ) def __rrshift__(self, other): - """ - ivy.Container reverse special method for the right shift operator, calling - :code:`operator.rshift` for each of the corresponding leaves of the two - containers. + """ivy.Container reverse special method for the right shift operator, + calling :code:`operator.rshift` for each of the corresponding leaves of + the two containers. Parameters ---------- diff --git a/ivy/data_classes/container/conversions.py b/ivy/data_classes/container/conversions.py index 00cdf6cdcfef8..f57bc6b58b2c8 100644 --- a/ivy/data_classes/container/conversions.py +++ b/ivy/data_classes/container/conversions.py @@ -1,5 +1,4 @@ -""" -Ivy wrapping functions for conversions. +"""Ivy wrapping functions for conversions. Collection of Ivy functions for wrapping functions to accept and return ivy.Array instances. @@ -26,8 +25,7 @@ def _static_to_native( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_native. + """ivy.Container static method variant of ivy.to_native. This method simply wraps the function, and so the docstring for ivy.to_native also applies to this method with minimal changes. @@ -86,8 +84,7 @@ def to_native( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_native. + """ivy.Container instance method variant of ivy.to_native. This method simply wraps the function, and so the docstring for ivy.to_native also applies to this method with minimal changes. @@ -146,8 +143,7 @@ def _static_to_ivy( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_ivy. + """ivy.Container static method variant of ivy.to_ivy. This method simply wraps the function, and so the docstring for ivy.to_ivy also applies to this method with minimal changes. @@ -207,8 +203,7 @@ def to_ivy( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_ivy. + """ivy.Container instance method variant of ivy.to_ivy. This method simply wraps the function, and so the docstring for ivy.to_ivy also applies to this method with minimal changes. diff --git a/ivy/data_classes/container/creation.py b/ivy/data_classes/container/creation.py index 83ec6aafc6884..f66a19fc9d2b0 100644 --- a/ivy/data_classes/container/creation.py +++ b/ivy/data_classes/container/creation.py @@ -59,10 +59,9 @@ def _static_asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.asarray. This method simply wraps the - function, and so the docstring for ivy.asarray also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.asarray. This method + simply wraps the function, and so the docstring for ivy.asarray also + applies to this method with minimal changes. Parameters ---------- @@ -257,10 +256,9 @@ def _static_full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.full_like. This method simply wraps - the function, and so the docstring for ivy.full_like also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.full_like. This method + simply wraps the function, and so the docstring for ivy.full_like also + applies to this method with minimal changes. Parameters ---------- @@ -343,10 +341,9 @@ def full_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.full_like. This method simply wraps - the function, and so the docstring for ivy.full_like also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.full_like. This method + simply wraps the function, and so the docstring for ivy.full_like also + applies to this method with minimal changes. Parameters ---------- @@ -428,10 +425,9 @@ def _static_ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.ones_like. This method simply wraps - the function, and so the docstring for ivy.ones_like also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.ones_like. This method + simply wraps the function, and so the docstring for ivy.ones_like also + applies to this method with minimal changes. Parameters ---------- @@ -487,10 +483,9 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.ones_like. This method simply wraps - the function, and so the docstring for ivy.ones_like also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.ones_like. This method + simply wraps the function, and so the docstring for ivy.ones_like also + applies to this method with minimal changes. Parameters ---------- @@ -546,10 +541,9 @@ def _static_zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.zeros_like. This method simply wraps - the function, and so the docstring for ivy.zeros_like also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.zeros_like. This method + simply wraps the function, and so the docstring for ivy.zeros_like also + applies to this method with minimal changes. Parameters ---------- @@ -605,10 +599,9 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.zeros_like. This method simply - wraps the function, and so the docstring for ivy.zeros_like also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.zeros_like. This method + simply wraps the function, and so the docstring for ivy.zeros_like also + applies to this method with minimal changes. Parameters ---------- @@ -1081,10 +1074,9 @@ def _static_logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logspace. This method simply wraps - the function, and so the docstring for ivy.logspace also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.logspace. This method + simply wraps the function, and so the docstring for ivy.logspace also + applies to this method with minimal changes. Parameters ---------- @@ -1164,10 +1156,9 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logspace. This method simply wraps - the function, and so the docstring for ivy.logspace also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.logspace. This method + simply wraps the function, and so the docstring for ivy.logspace also + applies to this method with minimal changes. Parameters ---------- @@ -1266,10 +1257,9 @@ def _static_one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.one_hot. This method simply wraps the - function, and so the docstring for ivy.one_hot also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.one_hot. This method + simply wraps the function, and so the docstring for ivy.one_hot also + applies to this method with minimal changes. Parameters ---------- @@ -1366,10 +1356,9 @@ def one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.one_hot. This method simply wraps - the function, and so the docstring for ivy.one_hot also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.one_hot. This method + simply wraps the function, and so the docstring for ivy.one_hot also + applies to this method with minimal changes. Parameters ---------- @@ -1463,10 +1452,9 @@ def static_frombuffer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container static method variant of ivy.frombuffer. This method simply wraps - the function, and so the docstring for ivy.frombuffer also applies to this - method with minimal changes. + r"""ivy.Container static method variant of ivy.frombuffer. This method + simply wraps the function, and so the docstring for ivy.frombuffer also + applies to this method with minimal changes. Parameters ---------- @@ -1543,10 +1531,9 @@ def frombuffer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.frombuffer. This method simply - wraps the function, and so the docstring for ivy.frombuffer also applies to this - method with minimal changes. + r"""ivy.Container instance method variant of ivy.frombuffer. This method + simply wraps the function, and so the docstring for ivy.frombuffer also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/data_type.py b/ivy/data_classes/container/data_type.py index c8d7533d64006..7e45fe10c6b7d 100644 --- a/ivy/data_classes/container/data_type.py +++ b/ivy/data_classes/container/data_type.py @@ -22,9 +22,8 @@ def _static_astype( copy: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Copy an array to a specified data type irrespective of :ref:`type- promotion` - rules. + """Copy an array to a specified data type irrespective of :ref:`type- + promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -93,9 +92,8 @@ def astype( copy: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Copy an array to a specified data type irrespective of :ref:`type- promotion` - rules. + """Copy an array to a specified data type irrespective of :ref:`type- + promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -162,10 +160,10 @@ def _static_broadcast_arrays( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.broadcast_arrays`. This method - simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also - applies to this method with minimal changes. + """`ivy.Container` static method variant of `ivy.broadcast_arrays`. + This method simply wraps the function, and so the docstring for + `ivy.broadcast_arrays` also applies to this method with minimal + changes. Parameters ---------- @@ -238,10 +236,10 @@ def broadcast_arrays( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.broadcast_arrays`. This method - simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also - applies to this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.broadcast_arrays`. + This method simply wraps the function, and so the docstring for + `ivy.broadcast_arrays` also applies to this method with minimal + changes. Parameters ---------- @@ -315,10 +313,9 @@ def _static_broadcast_to( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.broadcast_to`. This method simply - wraps the function, and so the docstring for `ivy.broadcast_to` also applies to - this method with minimal changes. + """`ivy.Container` static method variant of `ivy.broadcast_to`. This + method simply wraps the function, and so the docstring for + `ivy.broadcast_to` also applies to this method with minimal changes. Parameters ---------- @@ -373,10 +370,9 @@ def broadcast_to( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.broadcast_to`. This method - simply wraps the function, and so the docstring for `ivy.broadcast_to` also - applies to this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.broadcast_to`. This + method simply wraps the function, and so the docstring for + `ivy.broadcast_to` also applies to this method with minimal changes. Parameters ---------- @@ -428,10 +424,9 @@ def _static_can_cast( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.can_cast`. This method simply - wraps the function, and so the docstring for `ivy.can_cast` also applies to this - method with minimal changes. + """`ivy.Container` static method variant of `ivy.can_cast`. This method + simply wraps the function, and so the docstring for `ivy.can_cast` also + applies to this method with minimal changes. Parameters ---------- @@ -488,10 +483,9 @@ def can_cast( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.can_cast`. This method simply - wraps the function, and so the docstring for `ivy.can_cast` also applies to this - method with minimal changes. + """`ivy.Container` instance method variant of `ivy.can_cast`. This + method simply wraps the function, and so the docstring for + `ivy.can_cast` also applies to this method with minimal changes. Parameters ---------- @@ -679,8 +673,7 @@ def _static_finfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.finfo`. + """`ivy.Container` static method variant of `ivy.finfo`. Parameters ---------- @@ -725,8 +718,7 @@ def finfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.finfo`. + """`ivy.Container` instance method variant of `ivy.finfo`. Parameters ---------- @@ -770,10 +762,9 @@ def _static_iinfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.iinfo`. This method simply wraps - the function, and so the docstring for `ivy.iinfo` also applies to this method - with minimal changes. + """`ivy.Container` static method variant of `ivy.iinfo`. This method + simply wraps the function, and so the docstring for `ivy.iinfo` also + applies to this method with minimal changes. Parameters ---------- @@ -830,10 +821,9 @@ def iinfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.iinfo`. This method simply wraps - the function, and so the docstring for `ivy.iinfo` also applies to this method - with minimal changes. + """`ivy.Container` instance method variant of `ivy.iinfo`. This method + simply wraps the function, and so the docstring for `ivy.iinfo` also + applies to this method with minimal changes. Parameters ---------- @@ -932,10 +922,9 @@ def _static_is_float_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `is_float_dtype`. This method simply - wraps this function, so the docstring of `is_float_dtype` roughly applies to - this method. + """`ivy.Container` static method variant of `is_float_dtype`. This + method simply wraps this function, so the docstring of `is_float_dtype` + roughly applies to this method. Parameters ---------- @@ -1003,10 +992,9 @@ def is_float_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.is_float_dtype`. This method - simply wraps the function, and so the docstring for `ivy.is_float_dtype` also - applies to this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.is_float_dtype`. + This method simply wraps the function, and so the docstring for + `ivy.is_float_dtype` also applies to this method with minimal changes. Parameters ---------- @@ -1143,10 +1131,9 @@ def _static_is_complex_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `is_complex_dtype`. This method simply - wraps this function, so the docstring of `is_complex_dtype` roughly applies to - this method. + """`ivy.Container` static method variant of `is_complex_dtype`. This + method simply wraps this function, so the docstring of + `is_complex_dtype` roughly applies to this method. Parameters ---------- @@ -1202,10 +1189,10 @@ def is_complex_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.is_complex_dtype`. This method - simply wraps the function, and so the docstring for `ivy.is_complex_dtype` also - applies to this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.is_complex_dtype`. + This method simply wraps the function, and so the docstring for + `ivy.is_complex_dtype` also applies to this method with minimal + changes. Parameters ---------- @@ -1263,10 +1250,9 @@ def _static_result_type( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.result_type`. This method simply - wraps the function, and so the docstring for `ivy.result_type` also applies to - this method with minimal changes. + """`ivy.Container` static method variant of `ivy.result_type`. This + method simply wraps the function, and so the docstring for + `ivy.result_type` also applies to this method with minimal changes. Parameters ---------- @@ -1319,10 +1305,9 @@ def result_type( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.result_type`. This method simply - wraps the function, and so the docstring for `ivy.result_type` also applies to - this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.result_type`. This + method simply wraps the function, and so the docstring for + `ivy.result_type` also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/device.py b/ivy/data_classes/container/device.py index 3960c59d83f1f..9012fd4f4e989 100644 --- a/ivy/data_classes/container/device.py +++ b/ivy/data_classes/container/device.py @@ -13,10 +13,9 @@ class _ContainerWithDevice(ContainerBase): def _static_dev( x: ivy.Container, /, *, as_native: Union[bool, ivy.Container] = False ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dev. This method simply wraps the - function, and so the docstring for ivy.dev also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.dev. This method simply + wraps the function, and so the docstring for ivy.dev also applies to + this method with minimal changes. Examples -------- @@ -35,10 +34,9 @@ def _static_dev( def dev( self: ivy.Container, as_native: Union[bool, ivy.Container] = False ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dev. This method simply wraps the - function, and so the docstring for ivy.dev also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.dev. This method simply + wraps the function, and so the docstring for ivy.dev also applies to + this method with minimal changes. Parameters ---------- @@ -74,10 +72,9 @@ def _static_to_device( stream: Optional[Union[int, Any, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_device. This method simply wraps - the function, and so the docstring for ivy.to_device also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_device. This method + simply wraps the function, and so the docstring for ivy.to_device also + applies to this method with minimal changes. Parameters ---------- @@ -141,10 +138,9 @@ def to_device( stream: Optional[Union[int, Any, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_device. This method simply wraps - the function, and so the docstring for ivy.to_device also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_device. This method + simply wraps the function, and so the docstring for ivy.to_device also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/elementwise.py b/ivy/data_classes/container/elementwise.py index c52a3f42ba646..8932ae067e331 100644 --- a/ivy/data_classes/container/elementwise.py +++ b/ivy/data_classes/container/elementwise.py @@ -18,10 +18,9 @@ def _static_abs( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: # noqa - """ - ivy.Container static method variant of ivy.abs. This method simply wraps the - function, and so the docstring for ivy.abs also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.abs. This method simply + wraps the function, and so the docstring for ivy.abs also applies to + this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def abs( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.abs. This method simply wraps the - function, and so the docstring for ivy.abs also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.abs. This method simply + wraps the function, and so the docstring for ivy.abs also applies to + this method with minimal changes. Parameters ---------- @@ -140,10 +138,9 @@ def _static_acosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cosh. This method simply wraps the - function, and so the docstring for ivy.cosh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cosh. This method simply + wraps the function, and so the docstring for ivy.cosh also applies to + this method with minimal changes. Parameters ---------- @@ -202,10 +199,9 @@ def acosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.acosh. This method simply wraps the - function, and so the docstring for ivy.acosh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.acosh. This method + simply wraps the function, and so the docstring for ivy.acosh also + applies to this method with minimal changes. Parameters ---------- @@ -265,10 +261,9 @@ def _static_acos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.acos. This method simply wraps the - function, and so the docstring for ivy.acos also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.acos. This method simply + wraps the function, and so the docstring for ivy.acos also applies to + this method with minimal changes. Parameters ---------- @@ -329,10 +324,9 @@ def _static_add( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.add. This method simply wraps the - function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.add. This method simply + wraps the function, and so the docstring for ivy.add also applies to + this method with minimal changes. Parameters ---------- @@ -428,10 +422,9 @@ def acos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.acos. This method simply wraps the - function, and so the docstring for ivy.acos also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.acos. This method + simply wraps the function, and so the docstring for ivy.acos also + applies to this method with minimal changes. Parameters ---------- @@ -490,10 +483,9 @@ def add( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.add. This method simply wraps the - function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.add. This method simply + wraps the function, and so the docstring for ivy.add also applies to + this method with minimal changes. Parameters ---------- @@ -569,10 +561,9 @@ def _static_asin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.asin. This method simply wraps the - function, and so the docstring for ivy.asin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.asin. This method simply + wraps the function, and so the docstring for ivy.asin also applies to + this method with minimal changes. Parameters ---------- @@ -640,10 +631,9 @@ def asin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.asin. This method simply wraps the - function, and so the docstring for ivy.asin also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.asin. This method + simply wraps the function, and so the docstring for ivy.asin also + applies to this method with minimal changes. Parameters ---------- @@ -712,10 +702,9 @@ def _static_asinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.asinh. This method simply wraps the - function, and so the docstring for ivy.asinh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.asinh. This method simply + wraps the function, and so the docstring for ivy.asinh also applies to + this method with minimal changes. Parameters ---------- @@ -774,10 +763,9 @@ def asinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.asinh. This method simply wraps the - function, and so the docstring for ivy.asinh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.asinh. This method + simply wraps the function, and so the docstring for ivy.asinh also + applies to this method with minimal changes. Parameters ---------- @@ -837,10 +825,9 @@ def _static_atan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.atan. This method simply wraps the - function, and so the docstring for ivy.atan also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.atan. This method simply + wraps the function, and so the docstring for ivy.atan also applies to + this method with minimal changes. Parameters ---------- @@ -897,10 +884,9 @@ def atan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.atan. This method simply wraps the - function, and so the docstring for ivy.atan also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.atan. This method + simply wraps the function, and so the docstring for ivy.atan also + applies to this method with minimal changes. Parameters ---------- @@ -959,10 +945,9 @@ def _static_atan2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.atan2. This method simply wraps the - function, and so the docstring for ivy.atan2 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.atan2. This method simply + wraps the function, and so the docstring for ivy.atan2 also applies to + this method with minimal changes. Parameters ---------- @@ -1040,10 +1025,9 @@ def atan2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.atan2. This method simply wraps the - function, and so the docstring for ivy.atan2 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.atan2. This method + simply wraps the function, and so the docstring for ivy.atan2 also + applies to this method with minimal changes. Parameters ---------- @@ -1119,10 +1103,9 @@ def _static_atanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.atanh. This method simply wraps the - function, and so the docstring for ivy.atanh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.atanh. This method simply + wraps the function, and so the docstring for ivy.atanh also applies to + this method with minimal changes. Parameters ---------- @@ -1180,10 +1163,9 @@ def atanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.atanh. This method simply wraps the - function, and so the docstring for ivy.atanh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.atanh. This method + simply wraps the function, and so the docstring for ivy.atanh also + applies to this method with minimal changes. Parameters ---------- @@ -1243,10 +1225,9 @@ def _static_bitwise_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_and. This method simply wraps - the function, and so the docstring for ivy.bitwise_and also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_and. This method + simply wraps the function, and so the docstring for ivy.bitwise_and + also applies to this method with minimal changes. Parameters ---------- @@ -1328,10 +1309,9 @@ def bitwise_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_and. This method simply - wraps the function, and so the docstring for ivy.bitwise_and also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_and. This + method simply wraps the function, and so the docstring for + ivy.bitwise_and also applies to this method with minimal changes. Parameters ---------- @@ -1397,10 +1377,10 @@ def _static_bitwise_left_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_left_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_left_shift also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_left_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_left_shift also applies to this method with minimal + changes. Parameters ---------- @@ -1455,10 +1435,10 @@ def bitwise_left_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_left_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_left_shift also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_left_shift. + This method simply wraps the function, and so the docstring for + ivy.bitwise_left_shift also applies to this method with minimal + changes. Parameters ---------- @@ -1511,10 +1491,9 @@ def _static_bitwise_invert( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_invert. This method simply - wraps the function, and so the docstring for ivy.bitwise_invert also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_invert. This + method simply wraps the function, and so the docstring for + ivy.bitwise_invert also applies to this method with minimal changes. Parameters ---------- @@ -1578,10 +1557,9 @@ def bitwise_invert( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_invert. This method simply - wraps the function, and so the docstring for ivy.bitwise_invert also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_invert. This + method simply wraps the function, and so the docstring for + ivy.bitwise_invert also applies to this method with minimal changes. Parameters ---------- @@ -1648,10 +1626,9 @@ def _static_cos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cos. This method simply wraps the - function, and so the docstring for ivy.cos also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cos. This method simply + wraps the function, and so the docstring for ivy.cos also applies to + this method with minimal changes. Parameters ---------- @@ -1711,10 +1688,9 @@ def cos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cos. This method simply wraps the - function, and so the docstring for ivy.cos also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cos. This method simply + wraps the function, and so the docstring for ivy.cos also applies to + this method with minimal changes. Parameters ---------- @@ -1776,10 +1752,9 @@ def _static_bitwise_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_or. This method simply wraps - the function, and so the docstring for ivy.bitwise_or also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_or. This method + simply wraps the function, and so the docstring for ivy.bitwise_or also + applies to this method with minimal changes. Parameters ---------- @@ -1853,10 +1828,9 @@ def bitwise_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_or. This method simply - wraps the function, and so the docstring for ivy.bitwise_or also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_or. This method + simply wraps the function, and so the docstring for ivy.bitwise_or also + applies to this method with minimal changes. Parameters ---------- @@ -1920,10 +1894,10 @@ def _static_bitwise_right_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_right_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_right_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- @@ -2001,10 +1975,10 @@ def bitwise_right_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_right_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_right_shift. + This method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- @@ -2068,10 +2042,9 @@ def _static_bitwise_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_xor. This method simply wraps - the function, and so the docstring for ivy.bitwise_xor also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_xor. This method + simply wraps the function, and so the docstring for ivy.bitwise_xor + also applies to this method with minimal changes. Parameters ---------- @@ -2137,10 +2110,9 @@ def bitwise_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_xor. This method simply - wraps the function, and so the docstring for ivy.bitwise_xor also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_xor. This + method simply wraps the function, and so the docstring for + ivy.bitwise_xor also applies to this method with minimal changes. Parameters ---------- @@ -2205,10 +2177,9 @@ def _static_ceil( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.ceil. This method simply wraps the - function, and so the docstring for ivy.ceil also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.ceil. This method simply + wraps the function, and so the docstring for ivy.ceil also applies to + this method with minimal changes. Parameters ---------- @@ -2265,10 +2236,9 @@ def ceil( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.ceil. This method simply wraps the - function, and so the docstring for ivy.ceil also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.ceil. This method + simply wraps the function, and so the docstring for ivy.ceil also + applies to this method with minimal changes. Parameters ---------- @@ -2326,10 +2296,9 @@ def _static_cosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cosh. This method simply wraps the - function, and so the docstring for ivy.cosh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cosh. This method simply + wraps the function, and so the docstring for ivy.cosh also applies to + this method with minimal changes. Parameters ---------- @@ -2399,10 +2368,9 @@ def cosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cosh. This method simply wraps the - function, and so the docstring for ivy.cosh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cosh. This method + simply wraps the function, and so the docstring for ivy.cosh also + applies to this method with minimal changes. Parameters ---------- @@ -2474,10 +2442,9 @@ def _static_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.divide. This method simply wraps the - function, and so the docstring for ivy.divide also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.divide. This method + simply wraps the function, and so the docstring for ivy.divide also + applies to this method with minimal changes. Parameters ---------- @@ -2544,10 +2511,9 @@ def divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.divide. This method simply wraps - the function, and so the docstring for ivy.divide also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.divide. This method + simply wraps the function, and so the docstring for ivy.divide also + applies to this method with minimal changes. Parameters ---------- @@ -2626,10 +2592,9 @@ def _static_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.equal. This method simply wraps the - function, and so the docstring for ivy.equal also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.equal. This method simply + wraps the function, and so the docstring for ivy.equal also applies to + this method with minimal changes. Parameters ---------- @@ -2695,10 +2660,9 @@ def equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.equal. This method simply wraps the - function, and so the docstring for ivy.equal also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.equal. This method + simply wraps the function, and so the docstring for ivy.equal also + applies to this method with minimal changes. Parameters ---------- @@ -2776,10 +2740,9 @@ def static_nan_to_num( neginf: Optional[Union[float, int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nan_to_num. This method simply wraps - the function, and so the docstring for ivy.nan_to_num also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.nan_to_num. This method + simply wraps the function, and so the docstring for ivy.nan_to_num also + applies to this method with minimal changes. Parameters ---------- @@ -2841,10 +2804,9 @@ def nan_to_num( neginf: Optional[Union[float, int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nan_to_num. This method simply - wraps the function, and so the docstring for ivy.nan_to_num also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.nan_to_num. This method + simply wraps the function, and so the docstring for ivy.nan_to_num also + applies to this method with minimal changes. Parameters ---------- @@ -2899,10 +2861,9 @@ def static_imag( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.imag. This method simply wraps the - function, and so the docstring for ivy.imag also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.imag. This method simply + wraps the function, and so the docstring for ivy.imag also applies to + this method with minimal changes. Parameters ---------- @@ -2948,10 +2909,9 @@ def imag( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.imag. This method simply wraps the - function, and so the docstring for ivy.imag also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.imag. This method + simply wraps the function, and so the docstring for ivy.imag also + applies to this method with minimal changes. Parameters ---------- @@ -2995,10 +2955,9 @@ def static_angle( deg: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.angle. This method simply wraps the - function, and so the docstring for ivy.angle also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.angle. This method simply + wraps the function, and so the docstring for ivy.angle also applies to + this method with minimal changes. Parameters ---------- @@ -3056,10 +3015,9 @@ def angle( deg: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.angle. This method simply wraps the - function, and so the docstring for ivy.angle also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.angle. This method + simply wraps the function, and so the docstring for ivy.angle also + applies to this method with minimal changes. Parameters ---------- @@ -3113,10 +3071,9 @@ def static_gcd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.gcd. This method simply wraps the - function, and so the docstring for ivy.gcd also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.gcd. This method simply + wraps the function, and so the docstring for ivy.gcd also applies to + this method with minimal changes. Parameters ---------- @@ -3162,10 +3119,9 @@ def gcd( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gcd. This method simply wraps the - function, and so the docstring for ivy.gcd also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.gcd. This method simply + wraps the function, and so the docstring for ivy.gcd also applies to + this method with minimal changes. Parameters ---------- @@ -3206,10 +3162,9 @@ def static_exp2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.exp2. This method simply wraps the - function, and so the docstring for ivy.exp2 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.exp2. This method simply + wraps the function, and so the docstring for ivy.exp2 also applies to + this method with minimal changes. Parameters ---------- @@ -3250,10 +3205,9 @@ def exp2( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.exp2. This method simply wraps the - function, and so the docstring for ivy.exp2 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.exp2. This method + simply wraps the function, and so the docstring for ivy.exp2 also + applies to this method with minimal changes. Parameters ---------- @@ -3291,10 +3245,9 @@ def _static_exp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.exp. This method simply wraps the - function, and so the docstring for ivy.exp also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.exp. This method simply + wraps the function, and so the docstring for ivy.exp also applies to + this method with minimal changes. Parameters ---------- @@ -3351,10 +3304,9 @@ def exp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.exp. This method simply wraps the - function, and so the docstring for ivy.exp also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.exp. This method simply + wraps the function, and so the docstring for ivy.exp also applies to + this method with minimal changes. Parameters ---------- @@ -3412,10 +3364,9 @@ def _static_expm1( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.expm1. This method simply wraps - thefunction, and so the docstring for ivy.expm1 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.expm1. This method simply + wraps thefunction, and so the docstring for ivy.expm1 also applies to + this method with minimal changes. Parameters ---------- @@ -3473,10 +3424,9 @@ def expm1( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.expm1. This method simply wraps the - function, and so the docstring for ivy.expm1 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.expm1. This method + simply wraps the function, and so the docstring for ivy.expm1 also + applies to this method with minimal changes. Parameters ---------- @@ -3543,10 +3493,9 @@ def _static_floor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.floor. This method simply wraps - thefunction, and so the docstring for ivy.floor also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.floor. This method simply + wraps thefunction, and so the docstring for ivy.floor also applies to + this method with minimal changes. Parameters ---------- @@ -3603,10 +3552,9 @@ def floor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.floor. This method simply wraps the - function, and so the docstring for ivy.floor also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.floor. This method + simply wraps the function, and so the docstring for ivy.floor also + applies to this method with minimal changes. Parameters ---------- @@ -3665,10 +3613,9 @@ def _static_floor_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.floor_divide. This method simply - wraps the function, and so the docstring for ivy.floor_divide also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.floor_divide. This method + simply wraps the function, and so the docstring for ivy.floor_divide + also applies to this method with minimal changes. Parameters ---------- @@ -3746,10 +3693,9 @@ def floor_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.floor_divide. This method simply - wraps the function, and so the docstring for ivy.floor_divide also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.floor_divide. This + method simply wraps the function, and so the docstring for + ivy.floor_divide also applies to this method with minimal changes. Parameters ---------- @@ -3828,10 +3774,9 @@ def static_fmin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fmin. This method simply wraps the - function, and so the docstring for ivy.fmin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fmin. This method simply + wraps the function, and so the docstring for ivy.fmin also applies to + this method with minimal changes. Parameters ---------- @@ -3877,10 +3822,9 @@ def fmin( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fmin. This method simply wraps the - function, and so the docstring for ivy.fmin also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fmin. This method + simply wraps the function, and so the docstring for ivy.fmin also + applies to this method with minimal changes. Parameters ---------- @@ -3922,10 +3866,9 @@ def _static_greater( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.greater. This method simply wraps the - function, and so the docstring for ivy.greater also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.greater. This method + simply wraps the function, and so the docstring for ivy.greater also + applies to this method with minimal changes. Parameters ---------- @@ -3991,10 +3934,9 @@ def greater( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.greater. This method simply wraps - the function, and so the docstring for ivy.greater also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.greater. This method + simply wraps the function, and so the docstring for ivy.greater also + applies to this method with minimal changes. Parameters ---------- @@ -4060,10 +4002,9 @@ def _static_greater_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.greater_equal. This method simply - wraps the function, and so the docstring for ivy.greater_equal also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.greater_equal. This + method simply wraps the function, and so the docstring for + ivy.greater_equal also applies to this method with minimal changes. Parameters ---------- @@ -4129,10 +4070,9 @@ def greater_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.greater_equal. This method simply - wraps the function, and so the docstring for ivy.greater_equal also applies to - this metho with minimal changes. + """ivy.Container instance method variant of ivy.greater_equal. This + method simply wraps the function, and so the docstring for + ivy.greater_equal also applies to this metho with minimal changes. Parameters ---------- @@ -4197,10 +4137,9 @@ def _static_isfinite( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isfinite. This method simply wraps - the function, and so the docstring for ivy.isfinite also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.isfinite. This method + simply wraps the function, and so the docstring for ivy.isfinite also + applies to this method with minimal changes. Parameters ---------- @@ -4258,10 +4197,9 @@ def isfinite( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isfinite. This method simply wraps - the function, and so the docstring for ivy.isfinite also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.isfinite. This method + simply wraps the function, and so the docstring for ivy.isfinite also + applies to this method with minimal changes. Parameters ---------- @@ -4322,10 +4260,9 @@ def _static_isinf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isinf. This method simply wraps the - function, and so the docstring for ivy.isinf also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.isinf. This method simply + wraps the function, and so the docstring for ivy.isinf also applies to + this method with minimal changes. Parameters ---------- @@ -4393,10 +4330,9 @@ def isinf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isinf. This method simply wraps the - function, and so the docstring for ivy.isinf also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.isinf. This method + simply wraps the function, and so the docstring for ivy.isinf also + applies to this method with minimal changes. Parameters ---------- @@ -4463,10 +4399,9 @@ def _static_isnan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isnan. This method simply wraps the - function, and so the docstring for ivy.isnan also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.isnan. This method simply + wraps the function, and so the docstring for ivy.isnan also applies to + this method with minimal changes. Parameters ---------- @@ -4526,10 +4461,9 @@ def isnan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isnan. This method simply wraps the - function, and so the docstring for ivy.isnan also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.isnan. This method + simply wraps the function, and so the docstring for ivy.isnan also + applies to this method with minimal changes. Parameters ---------- @@ -4589,10 +4523,9 @@ def _static_less( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.less. This method simply wraps the - function, and so the docstring for ivy.less also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.less. This method simply + wraps the function, and so the docstring for ivy.less also applies to + this method with minimal changes. Parameters ---------- @@ -4658,10 +4591,9 @@ def less( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.less. This method simply wraps the - function, and so the docstring for ivy.less also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.less. This method + simply wraps the function, and so the docstring for ivy.less also + applies to this method with minimal changes. Parameters ---------- @@ -4727,10 +4659,9 @@ def _static_less_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.less_equal. This method simply wraps - the function, and so the docstring for ivy.less_equal also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.less_equal. This method + simply wraps the function, and so the docstring for ivy.less_equal also + applies to this method with minimal changes. Parameters ---------- @@ -4796,10 +4727,9 @@ def less_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.less_equal. This method simply - wraps the function, and so the docstring for ivy.less_equal also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.less_equal. This method + simply wraps the function, and so the docstring for ivy.less_equal also + applies to this method with minimal changes. Parameters ---------- @@ -4875,10 +4805,9 @@ def _static_log( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log. This method simply wraps the - function, and so the docstring for ivy.log also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.log. This method simply + wraps the function, and so the docstring for ivy.log also applies to + this method with minimal changes. Parameters ---------- @@ -4940,10 +4869,9 @@ def log( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log. This method simply wraps the - function, and so the docstring for ivy.log also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.log. This method simply + wraps the function, and so the docstring for ivy.log also applies to + this method with minimal changes. Parameters ---------- @@ -5006,10 +4934,9 @@ def _static_log1p( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log1p. This method simply wraps the - function, and so the docstring for ivy.log1p also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.log1p. This method simply + wraps the function, and so the docstring for ivy.log1p also applies to + this method with minimal changes. Parameters ---------- @@ -5074,10 +5001,9 @@ def log1p( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log1p. This method simply wraps the - function, and so the docstring for ivy.log1p also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.log1p. This method + simply wraps the function, and so the docstring for ivy.log1p also + applies to this method with minimal changes. Parameters ---------- @@ -5136,10 +5062,9 @@ def _static_log2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log2. This method simply wraps the - function, and so the docstring for ivy.log2 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.log2. This method simply + wraps the function, and so the docstring for ivy.log2 also applies to + this method with minimal changes. Parameters ---------- @@ -5201,10 +5126,9 @@ def log2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log2. This method simply wraps the - function, and so the docstring for ivy.log2 also applies to this metho with - minimal changes. + """ivy.Container instance method variant of ivy.log2. This method + simply wraps the function, and so the docstring for ivy.log2 also + applies to this metho with minimal changes. Parameters ---------- @@ -5267,10 +5191,9 @@ def _static_log10( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log10. This method simply wraps the - function, and so the docstring for ivy.log10 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.log10. This method simply + wraps the function, and so the docstring for ivy.log10 also applies to + this method with minimal changes. Parameters ---------- @@ -5332,10 +5255,9 @@ def log10( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log10. This method simply wraps the - function, and so the docstring for ivy.log10 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.log10. This method + simply wraps the function, and so the docstring for ivy.log10 also + applies to this method with minimal changes. Parameters ---------- @@ -5399,10 +5321,9 @@ def _static_logaddexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.greater_equal. This method simply - wraps the function, and so the docstring for ivy.greater_equal also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.greater_equal. This + method simply wraps the function, and so the docstring for + ivy.greater_equal also applies to this method with minimal changes. Parameters ---------- @@ -5471,10 +5392,9 @@ def logaddexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.greater_equal. This method simply - wraps the function, and so the docstring for ivy.greater_equal also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.greater_equal. This + method simply wraps the function, and so the docstring for + ivy.greater_equal also applies to this method with minimal changes. Parameters ---------- @@ -5543,10 +5463,9 @@ def static_logaddexp2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logaddexp2. This method simply wraps - the function, and so the docstring for ivy.logaddexp2 also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logaddexp2. This method + simply wraps the function, and so the docstring for ivy.logaddexp2 also + applies to this method with minimal changes. Parameters ---------- @@ -5592,10 +5511,9 @@ def logaddexp2( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logaddexp2. This method simply - wraps the function, and so the docstring for ivy.logaddexp2 also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.logaddexp2. This method + simply wraps the function, and so the docstring for ivy.logaddexp2 also + applies to this method with minimal changes. Parameters ---------- @@ -5637,10 +5555,9 @@ def _static_logical_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logical_and. This method simply wraps - the function, and so the docstring for ivy.logical_and also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logical_and. This method + simply wraps the function, and so the docstring for ivy.logical_and + also applies to this method with minimal changes. Parameters ---------- @@ -5725,10 +5642,9 @@ def logical_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logical_and. This method simply - wraps the function, and so the docstring for ivy.logical_and also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.logical_and. This + method simply wraps the function, and so the docstring for + ivy.logical_and also applies to this method with minimal changes. Parameters ---------- @@ -5811,10 +5727,9 @@ def _static_logical_not( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logical_not. This method simply wraps - the function, and so the docstring for ivy.logical_not also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logical_not. This method + simply wraps the function, and so the docstring for ivy.logical_not + also applies to this method with minimal changes. Parameters ---------- @@ -5871,10 +5786,9 @@ def logical_not( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logical_not. This method simply - wraps the function, and so the docstring for ivy.logical_not also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.logical_not. This + method simply wraps the function, and so the docstring for + ivy.logical_not also applies to this method with minimal changes. Parameters ---------- @@ -5942,10 +5856,9 @@ def _static_logical_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logical_or. This method simply wraps - the function, and so the docstring for ivy.logical_or also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logical_or. This method + simply wraps the function, and so the docstring for ivy.logical_or also + applies to this method with minimal changes. Parameters ---------- @@ -6011,10 +5924,9 @@ def logical_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logical_or. This method simply - wraps the function, and so the docstring for ivy.logical_or also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.logical_or. This method + simply wraps the function, and so the docstring for ivy.logical_or also + applies to this method with minimal changes. Parameters ---------- @@ -6091,10 +6003,9 @@ def _static_logical_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logical_xor. This method simply wraps - the function, and so the docstring for ivy.logical_xor also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logical_xor. This method + simply wraps the function, and so the docstring for ivy.logical_xor + also applies to this method with minimal changes. Parameters ---------- @@ -6171,10 +6082,9 @@ def logical_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logical_xor. This method simply - wraps the function, and so the docstring for ivy.logical_xor also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.logical_xor. This + method simply wraps the function, and so the docstring for + ivy.logical_xor also applies to this method with minimal changes. Parameters ---------- @@ -6238,10 +6148,9 @@ def _static_multiply( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.multiply. This method simply wraps - the function, and so the docstring for ivy.multiply also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.multiply. This method + simply wraps the function, and so the docstring for ivy.multiply also + applies to this method with minimal changes. Parameters ---------- @@ -6310,10 +6219,9 @@ def multiply( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.multiply. This method simply wraps - the function, and so the docstring for ivy.multiply also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.multiply. This method + simply wraps the function, and so the docstring for ivy.multiply also + applies to this method with minimal changes. Parameters ---------- @@ -6393,10 +6301,9 @@ def _static_negative( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.negative. This method simply wraps - the function, and so the docstring for ivy.negative also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.negative. This method + simply wraps the function, and so the docstring for ivy.negative also + applies to this method with minimal changes. Parameters ---------- @@ -6455,10 +6362,9 @@ def negative( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.negative. This method simply wraps - the function, and so the docstring for ivy.negative also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.negative. This method + simply wraps the function, and so the docstring for ivy.negative also + applies to this method with minimal changes. Parameters ---------- @@ -6519,10 +6425,9 @@ def _static_not_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.not_equal. This method simply wraps - the function, and so the docstring for ivy.not_equal also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.not_equal. This method + simply wraps the function, and so the docstring for ivy.not_equal also + applies to this method with minimal changes. Parameters ---------- @@ -6588,10 +6493,9 @@ def not_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.not_equal. This method simply wraps - the function, and so the docstring for ivy.not_equal also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.not_equal. This method + simply wraps the function, and so the docstring for ivy.not_equal also + applies to this method with minimal changes. Parameters ---------- @@ -6667,10 +6571,9 @@ def _static_positive( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.positive. This method simply wraps - the function, and so the docstring for ivy.positive also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.positive. This method + simply wraps the function, and so the docstring for ivy.positive also + applies to this method with minimal changes. Parameters ---------- @@ -6729,10 +6632,9 @@ def positive( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.positive. This method simply wraps - the function, and so the docstring for ivy.positive also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.positive. This method + simply wraps the function, and so the docstring for ivy.positive also + applies to this method with minimal changes. Parameters ---------- @@ -6793,10 +6695,9 @@ def _static_pow( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.pow. This method simply wraps the - function, and so the docstring for ivy.pow also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.pow. This method simply + wraps the function, and so the docstring for ivy.pow also applies to + this method with minimal changes. Parameters ---------- @@ -6861,10 +6762,9 @@ def pow( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.pow. This method simply wraps the - function, and so the docstring for ivy.pow also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.pow. This method simply + wraps the function, and so the docstring for ivy.pow also applies to + this method with minimal changes. Parameters ---------- @@ -6928,10 +6828,9 @@ def static_real( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.real. This method simply wraps the - function, and so the docstring for ivy.real also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.real. This method simply + wraps the function, and so the docstring for ivy.real also applies to + this method with minimal changes. Parameters ---------- @@ -6990,10 +6889,9 @@ def real( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.real. This method simply wraps the - function, and so the docstring for ivy.real also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.real. This method + simply wraps the function, and so the docstring for ivy.real also + applies to this method with minimal changes. Parameters ---------- @@ -7055,10 +6953,9 @@ def _static_remainder( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.remainder. This method simply wraps - the function, and so the docstring for ivy.remainder also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.remainder. This method + simply wraps the function, and so the docstring for ivy.remainder also + applies to this method with minimal changes. Parameters ---------- @@ -7151,10 +7048,9 @@ def remainder( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.remainder. This method simply wraps - the function, and so the docstring for ivy.remainder also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.remainder. This method + simply wraps the function, and so the docstring for ivy.remainder also + applies to this method with minimal changes. Parameters ---------- @@ -7246,10 +7142,9 @@ def _static_round( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.round. This method simply wraps - thevfunction, and so the docstring for ivy.round also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.round. This method simply + wraps thevfunction, and so the docstring for ivy.round also applies to + this method with minimal changes. Parameters ---------- @@ -7312,10 +7207,9 @@ def round( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.round. This method simply wraps the - function, and so the docstring for ivy.round also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.round. This method + simply wraps the function, and so the docstring for ivy.round also + applies to this method with minimal changes. Parameters ---------- @@ -7379,10 +7273,9 @@ def _static_sign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sign. This method simply wraps the - function, and so the docstring for ivy.sign also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sign. This method simply + wraps the function, and so the docstring for ivy.sign also applies to + this method with minimal changes. Parameters ---------- @@ -7441,10 +7334,9 @@ def sign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sign. This method simply wraps the - function, and so the docstring for ivy.sign also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sign. This method + simply wraps the function, and so the docstring for ivy.sign also + applies to this method with minimal changes. Parameters ---------- @@ -7505,10 +7397,9 @@ def _static_sin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sin. This method simply wraps the - function, and so the docstring for ivy.sin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sin. This method simply + wraps the function, and so the docstring for ivy.sin also applies to + this method with minimal changes. Parameters ---------- @@ -7567,10 +7458,9 @@ def sin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sin. This method simply wraps the - function, and so the docstring for ivy.sin also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sin. This method simply + wraps the function, and so the docstring for ivy.sin also applies to + this method with minimal changes. Parameters ---------- @@ -7630,10 +7520,9 @@ def _static_sinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sinh. This method simply wraps the - function, and so the docstring for ivy.sinh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sinh. This method simply + wraps the function, and so the docstring for ivy.sinh also applies to + this method with minimal changes. Parameters ---------- @@ -7701,10 +7590,9 @@ def sinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sinh. This method simply wraps the - function, and so the docstring for ivy.sinh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sinh. This method + simply wraps the function, and so the docstring for ivy.sinh also + applies to this method with minimal changes. Parameters ---------- @@ -7773,10 +7661,9 @@ def _static_square( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.square. This method simply wraps the - function, and so the docstring for ivy.square also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.square. This method + simply wraps the function, and so the docstring for ivy.square also + applies to this method with minimal changes. Parameters ---------- @@ -7833,10 +7720,9 @@ def square( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.square. This method simply wraps - the function, and so the docstring for ivy.square also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.square. This method + simply wraps the function, and so the docstring for ivy.square also + applies to this method with minimal changes. Parameters ---------- @@ -7894,10 +7780,9 @@ def _static_sqrt( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sqrt. This method simply wraps the - function, and so the docstring for ivy.sqrt also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sqrt. This method simply + wraps the function, and so the docstring for ivy.sqrt also applies to + this method with minimal changes. Parameters ---------- @@ -7957,10 +7842,9 @@ def sqrt( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sqrt. This method simply wraps the - function, and so the docstring for ivy.sqrt also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sqrt. This method + simply wraps the function, and so the docstring for ivy.sqrt also + applies to this method with minimal changes. Parameters ---------- @@ -8023,10 +7907,9 @@ def _static_subtract( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.subtract. This method simply wraps - the function, and so the docstring for ivy.subtract also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.subtract. This method + simply wraps the function, and so the docstring for ivy.subtract also + applies to this method with minimal changes. Parameters ---------- @@ -8103,10 +7986,9 @@ def subtract( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.subtract. This method simply wraps - the function, and so the docstring for ivy.subtract also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.subtract. This method + simply wraps the function, and so the docstring for ivy.subtract also + applies to this method with minimal changes. Parameters ---------- @@ -8181,10 +8063,9 @@ def _static_tan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tan. This method simply wraps the - function, and so the docstring for ivy.tan also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tan. This method simply + wraps the function, and so the docstring for ivy.tan also applies to + this method with minimal changes. Parameters ---------- @@ -8242,10 +8123,9 @@ def tan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tan. This method simply wraps the - function, and so the docstring for ivy.tan also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.tan. This method simply + wraps the function, and so the docstring for ivy.tan also applies to + this method with minimal changes. Parameters ---------- @@ -8305,10 +8185,9 @@ def _static_tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tanh. This method simply wraps the - function, and so the docstring for ivy.tanh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tanh. This method simply + wraps the function, and so the docstring for ivy.tanh also applies to + this method with minimal changes. Parameters ---------- @@ -8371,10 +8250,9 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tanh. This method simply wraps the - function, and so the docstring for ivy.tanh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.tanh. This method + simply wraps the function, and so the docstring for ivy.tanh also + applies to this method with minimal changes. Parameters ---------- @@ -8438,10 +8316,9 @@ def _static_trunc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trunc. This method simply wraps the - function, and so the docstring for ivy.trunc also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.trunc. This method simply + wraps the function, and so the docstring for ivy.trunc also applies to + this method with minimal changes. Parameters ---------- @@ -8500,10 +8377,9 @@ def trunc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.trunc. This method simply wraps the - function, and so the docstring for ivy.trunc also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.trunc. This method + simply wraps the function, and so the docstring for ivy.trunc also + applies to this method with minimal changes. Parameters ---------- @@ -8561,10 +8437,9 @@ def _static_erf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.erf. This method simply wraps the - function, and so the docstring for ivy.erf also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.erf. This method simply + wraps the function, and so the docstring for ivy.erf also applies to + this method with minimal changes. Parameters ---------- @@ -8620,10 +8495,9 @@ def erf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.erf. This method simply wraps - thefunction, and so the docstring for ivy.erf also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.erf. This method simply + wraps thefunction, and so the docstring for ivy.erf also applies to + this method with minimal changes. Parameters ---------- @@ -8682,10 +8556,9 @@ def _static_minimum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.minimum. This method simply wraps the - function, and so the docstring for ivy.minimum also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.minimum. This method + simply wraps the function, and so the docstring for ivy.minimum also + applies to this method with minimal changes. Parameters ---------- @@ -8755,10 +8628,9 @@ def minimum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.minimum. This method simply wraps - the function, and so the docstring for ivy.minimum also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.minimum. This method + simply wraps the function, and so the docstring for ivy.minimum also + applies to this method with minimal changes. Parameters ---------- @@ -8828,10 +8700,9 @@ def _static_maximum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.maximum. This method simply wraps the - function, and so the docstring for ivy.maximum also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.maximum. This method + simply wraps the function, and so the docstring for ivy.maximum also + applies to this method with minimal changes. Parameters ---------- @@ -8906,10 +8777,9 @@ def maximum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.maximum. This method simply wraps - the function, and so the docstring for ivy.maximum also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.maximum. This method + simply wraps the function, and so the docstring for ivy.maximum also + applies to this method with minimal changes. Parameters ---------- @@ -8982,10 +8852,9 @@ def _static_reciprocal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.reciprocal. This method simply wraps - the function, and so the docstring for ivy.reciprocal also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.reciprocal. This method + simply wraps the function, and so the docstring for ivy.reciprocal also + applies to this method with minimal changes. Parameters ---------- @@ -9040,10 +8909,9 @@ def reciprocal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.reciprocal. This method simply - wraps the function, and so the docstring for ivy.reciprocal also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.reciprocal. This method + simply wraps the function, and so the docstring for ivy.reciprocal also + applies to this method with minimal changes. Parameters ---------- @@ -9099,10 +8967,9 @@ def _static_deg2rad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.deg2rad. This method simply wraps the - function, and so the docstring for ivy.deg2rad also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.deg2rad. This method + simply wraps the function, and so the docstring for ivy.deg2rad also + applies to this method with minimal changes. Parameters ---------- @@ -9158,10 +9025,9 @@ def deg2rad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.deg2rad. This method simply wraps - the function, and so the docstring for ivy.deg2rad also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.deg2rad. This method + simply wraps the function, and so the docstring for ivy.deg2rad also + applies to this method with minimal changes. Parameters ---------- @@ -9220,10 +9086,9 @@ def _static_rad2deg( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rad2deg. This method simply wraps the - function, and so the docstring for ivy.rad2deg also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.rad2deg. This method + simply wraps the function, and so the docstring for ivy.rad2deg also + applies to this method with minimal changes. Parameters ---------- @@ -9279,10 +9144,9 @@ def rad2deg( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.rad2deg. This method simply wraps - the function, and so the docstring for ivy.rad2deg also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.rad2deg. This method + simply wraps the function, and so the docstring for ivy.rad2deg also + applies to this method with minimal changes. Parameters ---------- @@ -9342,10 +9206,9 @@ def _static_trunc_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trunc_divide. This method simply - wraps the function, and so the docstring for ivy.trunc_divide also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.trunc_divide. This method + simply wraps the function, and so the docstring for ivy.trunc_divide + also applies to this method with minimal changes. Parameters ---------- @@ -9412,10 +9275,9 @@ def trunc_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.trunc_divide. This method simply - wraps the function, and so the docstring for ivy.trunc_divide also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.trunc_divide. This + method simply wraps the function, and so the docstring for + ivy.trunc_divide also applies to this method with minimal changes. Parameters ---------- @@ -9482,10 +9344,9 @@ def _static_isreal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isreal. This method simply wraps the - function, and so the docstring for ivy.isreal also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.isreal. This method + simply wraps the function, and so the docstring for ivy.isreal also + applies to this method with minimal changes. Parameters ---------- @@ -9543,10 +9404,9 @@ def isreal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isreal. This method simply wraps - the function, and so the docstring for ivy.isreal also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.isreal. This method + simply wraps the function, and so the docstring for ivy.isreal also + applies to this method with minimal changes. Parameters ---------- @@ -9608,10 +9468,9 @@ def _static_trapz( axis: Union[int, ivy.Container] = -1, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trapz. This method simply wraps the - function, and so the docstring for ivy.trapz also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.trapz. This method simply + wraps the function, and so the docstring for ivy.trapz also applies to + this method with minimal changes. Parameters ---------- @@ -9666,10 +9525,9 @@ def trapz( axis: Union[int, ivy.Container] = -1, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.trapz. This method simply wraps the - function, and so the docstring for ivy.trapz also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.trapz. This method + simply wraps the function, and so the docstring for ivy.trapz also + applies to this method with minimal changes. Parameters ---------- @@ -9716,10 +9574,9 @@ def _static_lcm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.lcm. This method simply wraps the - function, and so the docstring for ivy.lcm also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.lcm. This method simply + wraps the function, and so the docstring for ivy.lcm also applies to + this method with minimal changes. Parameters ---------- @@ -9769,10 +9626,9 @@ def lcm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.lcm. This method simply wraps the - function, and so the docstring for ivy.lcm also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.lcm. This method simply + wraps the function, and so the docstring for ivy.lcm also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/activations.py b/ivy/data_classes/container/experimental/activations.py index 1d1cb87018641..e42c7d270d00c 100644 --- a/ivy/data_classes/container/experimental/activations.py +++ b/ivy/data_classes/container/experimental/activations.py @@ -16,10 +16,9 @@ def static_logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logit. This method simply wraps the - function, and so the docstring for ivy.logit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.logit. This method simply + wraps the function, and so the docstring for ivy.logit also applies to + this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logit. This method simply wraps the - function, and so the docstring for ivy.logit also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.logit. This method + simply wraps the function, and so the docstring for ivy.logit also + applies to this method with minimal changes. Parameters ---------- @@ -138,10 +136,9 @@ def static_thresholded_relu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.thresholded_relu. This method simply - wraps the function, and so the docstring for ivy.thresholded_relu also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.thresholded_relu. This + method simply wraps the function, and so the docstring for + ivy.thresholded_relu also applies to this method with minimal changes. Parameters ---------- @@ -202,10 +199,9 @@ def thresholded_relu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.thresholded_relu. This method - simply wraps the function, and so the docstring for ivy.thresholded_relu also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.thresholded_relu. This + method simply wraps the function, and so the docstring for + ivy.thresholded_relu also applies to this method with minimal changes. Parameters ---------- @@ -332,10 +328,9 @@ def static_relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.relu6. This method simply wraps the - function, and so the docstring for ivy.relu6 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.relu6. This method simply + wraps the function, and so the docstring for ivy.relu6 also applies to + this method with minimal changes. Parameters ---------- @@ -398,10 +393,9 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.relu6. This method simply wraps the - function, and so the docstring for ivy.relu6 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.relu6. This method + simply wraps the function, and so the docstring for ivy.relu6 also + applies to this method with minimal changes. Parameters ---------- @@ -463,10 +457,9 @@ def static_logsigmoid( map_sequences: Union[bool, ivy.Container] = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logsigmoid. This method simply wraps - the function, and so the docstring for ivy.logsigmoid also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logsigmoid. This method + simply wraps the function, and so the docstring for ivy.logsigmoid also + applies to this method with minimal changes. Parameters ---------- @@ -533,8 +526,7 @@ def logsigmoid( map_sequences: Union[bool, ivy.Container] = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Container: - """ - Apply element-wise Log-sigmoid of x i.e. log(1 / (1 + exp(-x)). + """Apply element-wise Log-sigmoid of x i.e. log(1 / (1 + exp(-x)). Parameters ---------- @@ -579,10 +571,9 @@ def static_selu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.selu. This method simply wraps the - function, and so the docstring for ivy.selu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.selu. This method simply + wraps the function, and so the docstring for ivy.selu also applies to + this method with minimal changes. Parameters ---------- @@ -639,10 +630,9 @@ def selu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.selu. This method simply wraps the - function, and so the docstring for ivy.selu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.selu. This method + simply wraps the function, and so the docstring for ivy.selu also + applies to this method with minimal changes. Parameters ---------- @@ -699,10 +689,9 @@ def _static_silu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.silu. This method simply wraps the - function, and so the docstring for ivy.silu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.silu. This method simply + wraps the function, and so the docstring for ivy.silu also applies to + this method with minimal changes. Parameters ---------- @@ -759,10 +748,9 @@ def silu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.silu. This method simply wraps the - function, and so the docstring for ivy.silu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.silu. This method + simply wraps the function, and so the docstring for ivy.silu also + applies to this method with minimal changes. Parameters ---------- @@ -820,10 +808,9 @@ def _static_elu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.elu. This method simply wraps the - function, and so the docstring for ivy.elu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.elu. This method simply + wraps the function, and so the docstring for ivy.elu also applies to + this method with minimal changes. Parameters ---------- @@ -883,10 +870,9 @@ def elu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.elu. This method simply wraps the - function, and so the docstring for ivy.elu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.elu. This method simply + wraps the function, and so the docstring for ivy.elu also applies to + this method with minimal changes. Parameters ---------- @@ -947,10 +933,9 @@ def _static_hardtanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hardtanh.This method simply wrap the - function,the docstring for ivy.hardtanh also applies to this method with minimal - changes. + """ivy.Container static method variant of ivy.hardtanh.This method + simply wrap the function,the docstring for ivy.hardtanh also applies to + this method with minimal changes. Parameters ---------- @@ -1014,10 +999,9 @@ def hardtanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hardtanh.This method simply wraps - the function, so the docstring for ivy.elu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.hardtanh.This method + simply wraps the function, so the docstring for ivy.elu also applies to + this method with minimal changes. Parameters ---------- @@ -1079,10 +1063,9 @@ def _static_tanhshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tanhshrink. This method simply wraps - the function, and so the docstring for ivy.tanhshrink also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.tanhshrink. This method + simply wraps the function, and so the docstring for ivy.tanhshrink also + applies to this method with minimal changes. Parameters ---------- @@ -1139,10 +1122,9 @@ def tanhshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tanhshrink. This method simply - wraps the function, and so the docstring for ivy.tanhshrink also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.tanhshrink. This method + simply wraps the function, and so the docstring for ivy.tanhshrink also + applies to this method with minimal changes. Parameters ---------- @@ -1201,10 +1183,9 @@ def _static_threshold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.threshold. This method simply wraps - the function, and so the docstring for ivy.threshold also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.threshold. This method + simply wraps the function, and so the docstring for ivy.threshold also + applies to this method with minimal changes. Parameters ---------- @@ -1267,10 +1248,9 @@ def threshold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.threshold. This method simply wraps - the function, and so the docstring for ivy.threshold also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.threshold. This method + simply wraps the function, and so the docstring for ivy.threshold also + applies to this method with minimal changes. Parameters ---------- @@ -1332,10 +1312,9 @@ def _static_softshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.softshrink. This method simply wraps - the function, and so the docstring for ivy.softshrink also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.softshrink. This method + simply wraps the function, and so the docstring for ivy.softshrink also + applies to this method with minimal changes. Parameters ---------- @@ -1393,8 +1372,7 @@ def softshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Apply the soft shrinkage function element-wise. + """Apply the soft shrinkage function element-wise. Parameters ---------- @@ -1454,10 +1432,9 @@ def _static_celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.celu. This method simply wraps the - function, and so the docstring for ivy.celu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.celu. This method simply + wraps the function, and so the docstring for ivy.celu also applies to + this method with minimal changes. Parameters ---------- @@ -1522,10 +1499,9 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.leaky_relu. This method simply - wraps the function, and so the docstring for ivy.leaky_relu also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.leaky_relu. This method + simply wraps the function, and so the docstring for ivy.leaky_relu also + applies to this method with minimal changes. Parameters ---------- @@ -1591,10 +1567,9 @@ def _static_scaled_tanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.scaled_tanh. This method simply wraps - the function, and so the docstring for ivy.scaled_tanh also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.scaled_tanh. This method + simply wraps the function, and so the docstring for ivy.scaled_tanh + also applies to this method with minimal changes. Parameters ---------- @@ -1678,10 +1653,9 @@ def scaled_tanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.scaled_tanh. This method - simplywraps the function, and so the docstring for ivy.scaled_tanh also applies - to this method with minimal changes. + """ivy.Container instance method variant of ivy.scaled_tanh. This + method simplywraps the function, and so the docstring for + ivy.scaled_tanh also applies to this method with minimal changes. Parameters ---------- @@ -1761,10 +1735,9 @@ def _static_hardshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hardshrink. This method simply wraps - the function, and so the docstring for ivy.hardshrink also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.hardshrink. This method + simply wraps the function, and so the docstring for ivy.hardshrink also + applies to this method with minimal changes. Parameters ---------- @@ -1819,8 +1792,7 @@ def hardshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Apply the hard shrinkage function element-wise. + """Apply the hard shrinkage function element-wise. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/creation.py b/ivy/data_classes/container/experimental/creation.py index fc861420bc843..e563d358474c2 100644 --- a/ivy/data_classes/container/experimental/creation.py +++ b/ivy/data_classes/container/experimental/creation.py @@ -19,10 +19,9 @@ def static_hann_window( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hann_window. This method simply wraps - the function, and so the docstring for ivy.hann_window also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.hann_window. This method + simply wraps the function, and so the docstring for ivy.hann_window + also applies to this method with minimal changes. Parameters ---------- @@ -71,10 +70,9 @@ def hann_window( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hann_window. This method simply - wraps the function, and so the docstring for ivy.hann_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.hann_window. This + method simply wraps the function, and so the docstring for + ivy.hann_window also applies to this method with minimal changes. Parameters ---------- @@ -119,10 +117,9 @@ def static_kaiser_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.kaiser_window. This method simply - wraps the function, and so the docstring for ivy.kaiser_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.kaiser_window. This + method simply wraps the function, and so the docstring for + ivy.kaiser_window also applies to this method with minimal changes. Parameters ---------- @@ -177,10 +174,9 @@ def kaiser_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.kaiser_window. This method simply - wraps the function, and so the docstring for ivy.kaiser_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.kaiser_window. This + method simply wraps the function, and so the docstring for + ivy.kaiser_window also applies to this method with minimal changes. Parameters ---------- @@ -235,11 +231,10 @@ def static_kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.kaiser_bessel_derived_window. This - method simply wraps the function, and so the docstring for - ivy.kaiser_bessel_derived_window also applies to this method with minimal - changes. + """ivy.Container static method variant of + ivy.kaiser_bessel_derived_window. This method simply wraps the + function, and so the docstring for ivy.kaiser_bessel_derived_window + also applies to this method with minimal changes. Parameters ---------- @@ -294,11 +289,10 @@ def kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.kaiser_bessel_derived_window. This - method simply wraps the function, and so the docstring for - ivy.kaiser_bessel_derived_window also applies to this method with minimal - changes. + """ivy.Container instance method variant of + ivy.kaiser_bessel_derived_window. This method simply wraps the + function, and so the docstring for ivy.kaiser_bessel_derived_window + also applies to this method with minimal changes. Parameters ---------- @@ -355,10 +349,9 @@ def static_hamming_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hamming_window. This method simply - wraps the function, and so the docstring for ivy.hamming_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.hamming_window. This + method simply wraps the function, and so the docstring for + ivy.hamming_window also applies to this method with minimal changes. Parameters ---------- @@ -417,10 +410,9 @@ def hamming_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hamming_window. This method simply - wraps the function, and so the docstring for ivy.hamming_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.hamming_window. This + method simply wraps the function, and so the docstring for + ivy.hamming_window also applies to this method with minimal changes. Parameters ---------- @@ -468,10 +460,9 @@ def static_vorbis_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.vorbis_window. This method simply - wraps the function, and so the docstring for ivy.vorbis_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.vorbis_window. This + method simply wraps the function, and so the docstring for + ivy.vorbis_window also applies to this method with minimal changes. Parameters ---------- @@ -520,10 +511,9 @@ def vorbis_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.vorbis_window. This method simply - wraps the function, and so the docstring for ivy.vorbis_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.vorbis_window. This + method simply wraps the function, and so the docstring for + ivy.vorbis_window also applies to this method with minimal changes. Parameters ---------- @@ -623,10 +613,9 @@ def static_eye_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.eye_like. This method simply wraps - the function, and so the docstring for ivy.eye_like also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.eye_like. This method + simply wraps the function, and so the docstring for ivy.eye_like also + applies to this method with minimal changes. Parameters ---------- @@ -700,10 +689,9 @@ def eye_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eye_like. This method simply wraps - the function, and so the docstring for ivy.eye_like also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.eye_like. This method + simply wraps the function, and so the docstring for ivy.eye_like also + applies to this method with minimal changes. Parameters ---------- @@ -775,10 +763,10 @@ def static_unsorted_segment_min( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.unsorted_segment_min. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_min - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.unsorted_segment_min. + This method simply wraps the function, and so the docstring for + ivy.unsorted_segment_min also applies to this method with minimal + changes. Note ---- @@ -830,10 +818,10 @@ def unsorted_segment_min( segment_ids: ivy.Container, num_segments: Union[int, ivy.Container], ): - r""" - ivy.Container instance method variant of ivy.unsorted_segment_min. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_min - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.unsorted_segment_min. + This method simply wraps the function, and so the docstring for + ivy.unsorted_segment_min also applies to this method with minimal + changes. Note ---- @@ -875,10 +863,10 @@ def static_unsorted_segment_sum( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.unsorted_segment_sum. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_sum - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.unsorted_segment_sum. + This method simply wraps the function, and so the docstring for + ivy.unsorted_segment_sum also applies to this method with minimal + changes. Parameters ---------- @@ -925,10 +913,10 @@ def unsorted_segment_sum( segment_ids: ivy.Container, num_segments: Union[int, ivy.Container], ): - r""" - ivy.Container instance method variant of ivy.unsorted_segment_sum. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_sum - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.unsorted_segment_sum. + This method simply wraps the function, and so the docstring for + ivy.unsorted_segment_sum also applies to this method with minimal + changes. Parameters ---------- @@ -966,10 +954,9 @@ def static_blackman_window( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.blackman_window. This method simply - wraps the function, and so the docstring for ivy.blackman_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.blackman_window. This + method simply wraps the function, and so the docstring for + ivy.blackman_window also applies to this method with minimal changes. Parameters ---------- @@ -1018,10 +1005,9 @@ def blackman_window( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.blackman_window. This method simply - wraps the function, and so the docstring for ivy.blackman_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.blackman_window. This + method simply wraps the function, and so the docstring for + ivy.blackman_window also applies to this method with minimal changes. Parameters ---------- @@ -1114,10 +1100,9 @@ def static_mel_weight_matrix( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.mel_weight_matrix. This method - simply wraps the function, and so the docstring for ivy.mel_weight_matrix also - applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.mel_weight_matrix. This + method simply wraps the function, and so the docstring for + ivy.mel_weight_matrix also applies to this method with minimal changes. Parameters ---------- @@ -1169,10 +1154,9 @@ def mel_weight_matrix( lower_edge_hertz: Optional[float] = 0.0, upper_edge_hertz: Optional[float] = 3000.0, ): - r""" - ivy.Container instance method variant of ivy.mel_weight_matrix. This method - simply wraps the function, and so the docstring for ivy.mel_weight_matrix also - applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.mel_weight_matrix. This + method simply wraps the function, and so the docstring for + ivy.mel_weight_matrix also applies to this method with minimal changes. Parameters ---------- @@ -1211,8 +1195,8 @@ def static_unsorted_segment_mean( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Compute the mean of values in the input data based on segment identifiers. + """Compute the mean of values in the input data based on segment + identifiers. Parameters ---------- @@ -1257,9 +1241,8 @@ def unsorted_segment_mean( segment_ids: Union[ivy.Array, ivy.Container], num_segments: Union[int, ivy.Container], ) -> ivy.Container: - """ - Compute the mean of values in the input array or container based on segment - identifiers. + """Compute the mean of values in the input array or container based on + segment identifiers. Parameters ---------- @@ -1318,10 +1301,9 @@ def static_polyval( prune_unapplied: bool = False, map_sequences: bool = False, ) -> ivy.Container: - r""" - ivy.Container static method variant of ivy.polyval. This method simply wraps the - function, and so the docstring for ivy.polyval also applies to this method with - minimal changes. + r"""ivy.Container static method variant of ivy.polyval. This method + simply wraps the function, and so the docstring for ivy.polyval also + applies to this method with minimal changes. Evaluate and return a polynomial at specific given values. @@ -1365,10 +1347,9 @@ def polyval( coeffs: ivy.Container, x: ivy.Container, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.polyval. This method simply wraps - the function, and so the docstring for ivy.polyval also applies to this method - with minimal changes. + r"""ivy.Container instance method variant of ivy.polyval. This method + simply wraps the function, and so the docstring for ivy.polyval also + applies to this method with minimal changes. Evaluate and return a polynomial at specific given values. diff --git a/ivy/data_classes/container/experimental/elementwise.py b/ivy/data_classes/container/experimental/elementwise.py index 45cf7674adbb0..939c32874fc50 100644 --- a/ivy/data_classes/container/experimental/elementwise.py +++ b/ivy/data_classes/container/experimental/elementwise.py @@ -21,10 +21,9 @@ def static_amax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.amax. This method simply wraps the - function, and so the docstring for ivy.amax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.amax. This method simply + wraps the function, and so the docstring for ivy.amax also applies to + this method with minimal changes. Parameters ---------- @@ -117,10 +116,9 @@ def amax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.amax. This method simply wraps the - function, and so the docstring for ivy.amax also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.amax. This method + simply wraps the function, and so the docstring for ivy.amax also + applies to this method with minimal changes. Parameters ---------- @@ -213,10 +211,9 @@ def static_amin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.amin. This method simply wraps the - function, and so the docstring for ivy.amin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.amin. This method simply + wraps the function, and so the docstring for ivy.amin also applies to + this method with minimal changes. Parameters ---------- @@ -308,10 +305,9 @@ def amin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.amin. This method simply wraps the - function, and so the docstring for ivy.amin also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.amin. This method + simply wraps the function, and so the docstring for ivy.amin also + applies to this method with minimal changes. Parameters ---------- @@ -401,10 +397,9 @@ def static_sinc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sinc. This method simply wraps the - function, and so the docstring for ivy.sinc also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sinc. This method simply + wraps the function, and so the docstring for ivy.sinc also applies to + this method with minimal changes. Parameters ---------- @@ -463,10 +458,9 @@ def sinc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sinc. This method simply wraps the - function, and so the docstring for ivy.sinc also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sinc. This method + simply wraps the function, and so the docstring for ivy.sinc also + applies to this method with minimal changes. Parameters ---------- @@ -527,10 +521,9 @@ def static_fmod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fmod. This method simply wraps the - function, and so the docstring for ivy.fmod also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fmod. This method simply + wraps the function, and so the docstring for ivy.fmod also applies to + this method with minimal changes. Parameters ---------- @@ -576,10 +569,9 @@ def fmod( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fmod. This method simply wraps the - function, and so the docstring for ivy.fmod also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fmod. This method + simply wraps the function, and so the docstring for ivy.fmod also + applies to this method with minimal changes. Parameters ---------- @@ -621,10 +613,9 @@ def static_fmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fmax. This method simply wraps the - function, and so the docstring for ivy.fmax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fmax. This method simply + wraps the function, and so the docstring for ivy.fmax also applies to + this method with minimal changes. Parameters ---------- @@ -670,10 +661,9 @@ def fmax( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fmax. This method simply wraps the - function, and so the docstring for ivy.fmax also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fmax. This method + simply wraps the function, and so the docstring for ivy.fmax also + applies to this method with minimal changes. Parameters ---------- @@ -715,10 +705,9 @@ def static_float_power( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.float_power. This method simply wraps - the function, and so the docstring for ivy.float_power also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.float_power. This method + simply wraps the function, and so the docstring for ivy.float_power + also applies to this method with minimal changes. Parameters ---------- @@ -764,10 +753,9 @@ def float_power( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.float_power. This method simply - wraps the function, and so the docstring for ivy.float_power also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.float_power. This + method simply wraps the function, and so the docstring for + ivy.float_power also applies to this method with minimal changes. Parameters ---------- @@ -809,10 +797,9 @@ def static_copysign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.copysign. This method simply wraps - the function, and so the docstring for ivy.copysign also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.copysign. This method + simply wraps the function, and so the docstring for ivy.copysign also + applies to this method with minimal changes. Parameters ---------- @@ -863,10 +850,9 @@ def copysign( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.copysign. This method simply wraps - the function, and so the docstring for ivy.copysign also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.copysign. This method + simply wraps the function, and so the docstring for ivy.copysign also + applies to this method with minimal changes. Parameters ---------- @@ -915,10 +901,9 @@ def static_count_nonzero( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.count_nonzero. This method simply - wraps the function, and so the docstring for ivy.count_nonzero also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.count_nonzero. This + method simply wraps the function, and so the docstring for + ivy.count_nonzero also applies to this method with minimal changes. Parameters ---------- @@ -1005,10 +990,9 @@ def count_nonzero( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.count_nonzero. This method simply - wraps the function, and so the docstring for ivy.count_nonzero also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.count_nonzero. This + method simply wraps the function, and so the docstring for + ivy.count_nonzero also applies to this method with minimal changes. Parameters ---------- @@ -1096,10 +1080,9 @@ def static_nansum( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nansum. This method simply wraps the - function, and so the docstring for ivy.nansum also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nansum. This method + simply wraps the function, and so the docstring for ivy.nansum also + applies to this method with minimal changes. Parameters ---------- @@ -1167,10 +1150,9 @@ def nansum( keepdims: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nansum. This method simply wraps - the function, and so the docstring for ivy.nansum also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nansum. This method + simply wraps the function, and so the docstring for ivy.nansum also + applies to this method with minimal changes. Parameters ---------- @@ -1230,10 +1212,9 @@ def static_isclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isclose. This method simply wraps the - function, and so the docstring for ivy.isclose also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.isclose. This method + simply wraps the function, and so the docstring for ivy.isclose also + applies to this method with minimal changes. Parameters ---------- @@ -1329,10 +1310,9 @@ def isclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isclose. This method simply wraps - the function, and so the docstring for ivy.isclose also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.isclose. This method + simply wraps the function, and so the docstring for ivy.isclose also + applies to this method with minimal changes. Parameters ---------- @@ -1424,10 +1404,9 @@ def static_signbit( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.signbit. This method simply wraps the - function, and so the docstring for ivy.signbit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.signbit. This method + simply wraps the function, and so the docstring for ivy.signbit also + applies to this method with minimal changes. Parameters ---------- @@ -1467,10 +1446,9 @@ def signbit( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.signbit. This method simply wraps - the function, and so the docstring for ivy.signbit also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.signbit. This method + simply wraps the function, and so the docstring for ivy.signbit also + applies to this method with minimal changes. Parameters ---------- @@ -1508,10 +1486,9 @@ def static_hypot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hypot. This method simply wraps the - function, and so the docstring for ivy.hypot also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.hypot. This method simply + wraps the function, and so the docstring for ivy.hypot also applies to + this method with minimal changes. Parameters ---------- @@ -1573,10 +1550,9 @@ def hypot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hypot. This method simply wraps the - function, and so the docstring for ivy.hypot also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.hypot. This method + simply wraps the function, and so the docstring for ivy.hypot also + applies to this method with minimal changes. Parameters ---------- @@ -1641,10 +1617,9 @@ def static_allclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.allclose. This method simply wraps - the function, and so the docstring for ivy.allclose also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.allclose. This method + simply wraps the function, and so the docstring for ivy.allclose also + applies to this method with minimal changes. Parameters ---------- @@ -1732,10 +1707,9 @@ def allclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.allclose. This method simply wraps - the function, and so the docstring for ivy.allclose also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.allclose. This method + simply wraps the function, and so the docstring for ivy.allclose also + applies to this method with minimal changes. Parameters ---------- @@ -1825,10 +1799,9 @@ def static_diff( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.diff. This method simply wraps the - function, and so the docstring for ivy.diff also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.diff. This method simply + wraps the function, and so the docstring for ivy.diff also applies to + this method with minimal changes. Parameters ---------- @@ -1902,10 +1875,9 @@ def diff( ] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diff. This method simply wraps the - function, and so the docstring for ivy.diff also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.diff. This method + simply wraps the function, and so the docstring for ivy.diff also + applies to this method with minimal changes. Parameters ---------- @@ -1955,10 +1927,9 @@ def static_fix( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fix. This method simply wraps the - function, and so the docstring for ivy.fix also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fix. This method simply + wraps the function, and so the docstring for ivy.fix also applies to + this method with minimal changes. Parameters ---------- @@ -1999,10 +1970,9 @@ def fix( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fix. This method simply wraps the - function, and so the docstring for ivy.fix also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fix. This method simply + wraps the function, and so the docstring for ivy.fix also applies to + this method with minimal changes. Parameters ---------- @@ -2041,10 +2011,9 @@ def static_nextafter( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nextafter. This method simply wraps - the function, and so the docstring for ivy.nextafter also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.nextafter. This method + simply wraps the function, and so the docstring for ivy.nextafter also + applies to this method with minimal changes. Parameters ---------- @@ -2107,10 +2076,9 @@ def nextafter( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nextafter. This method simply wraps - the function, and so the docstring for ivy.nextafter also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nextafter. This method + simply wraps the function, and so the docstring for ivy.nextafter also + applies to this method with minimal changes. Parameters ---------- @@ -2173,10 +2141,9 @@ def static_zeta( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.zeta. This method simply wraps the - function, and so the docstring for ivy.zeta also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.zeta. This method simply + wraps the function, and so the docstring for ivy.zeta also applies to + this method with minimal changes. Parameters ---------- @@ -2238,10 +2205,9 @@ def zeta( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.zeta. This method simply wraps the - function, and so the docstring for ivy.zeta also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.zeta. This method + simply wraps the function, and so the docstring for ivy.zeta also + applies to this method with minimal changes. Parameters ---------- @@ -2324,8 +2290,7 @@ def gradient( edge_order: Union[int, ivy.Container] = 1, axis: Optional[Union[int, list, tuple, ivy.Container]] = None, ) -> ivy.Container: - """ - Calculate gradient of x with respect to (w.r.t.) spacing. + """Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -2465,10 +2430,9 @@ def static_xlogy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.xlogy. This method simply wraps the - function, and so the docstring for ivy.xlogy also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.xlogy. This method simply + wraps the function, and so the docstring for ivy.xlogy also applies to + this method with minimal changes. Parameters ---------- @@ -2531,10 +2495,9 @@ def xlogy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.xlogy. This method simply wraps the - function, and so the docstring for ivy.xlogy also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.xlogy. This method + simply wraps the function, and so the docstring for ivy.xlogy also + applies to this method with minimal changes. Parameters ---------- @@ -2597,9 +2560,8 @@ def static_binarizer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Map the values of the input tensor to either 0 or 1, element-wise, based on the - outcome of a comparison against a threshold value. + """Map the values of the input tensor to either 0 or 1, element-wise, + based on the outcome of a comparison against a threshold value. Parameters ---------- @@ -2649,9 +2611,8 @@ def binarizer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Map the values of the input tensor to either 0 or 1, element-wise, based on the - outcome of a comparison against a threshold value. + """Map the values of the input tensor to either 0 or 1, element-wise, + based on the outcome of a comparison against a threshold value. Parameters ---------- @@ -2699,10 +2660,9 @@ def static_conj( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conj. This method simply wraps the - function, and so the docstring for ivy.conj also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.conj. This method simply + wraps the function, and so the docstring for ivy.conj also applies to + this method with minimal changes. Parameters ---------- @@ -2762,10 +2722,9 @@ def conj( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conj. This method simply wraps the - function, and so the docstring for ivy.conj also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.conj. This method + simply wraps the function, and so the docstring for ivy.conj also + applies to this method with minimal changes. Parameters ---------- @@ -2826,10 +2785,9 @@ def static_ldexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.ldexp. This method simply wraps the - function, and so the docstring for ivy.ldexp also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.ldexp. This method simply + wraps the function, and so the docstring for ivy.ldexp also applies to + this method with minimal changes. Parameters ---------- @@ -2886,10 +2844,9 @@ def ldexp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.ldexp. This method simply wraps the - function, and so the docstring for ivy.ldexp also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.ldexp. This method + simply wraps the function, and so the docstring for ivy.ldexp also + applies to this method with minimal changes. Parameters ---------- @@ -2931,10 +2888,9 @@ def static_lerp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.lerp. This method simply wraps the - function, and so the docstring for ivy.lerp also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.lerp. This method simply + wraps the function, and so the docstring for ivy.lerp also applies to + this method with minimal changes. Parameters ---------- @@ -3007,10 +2963,9 @@ def lerp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.lerp. This method simply wraps the - function, and so the docstring for ivy.lerp also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.lerp. This method + simply wraps the function, and so the docstring for ivy.lerp also + applies to this method with minimal changes. Parameters ---------- @@ -3053,10 +3008,9 @@ def static_frexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.frexp. This method simply wraps the - function, and so the docstring for ivy.frexp also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.frexp. This method simply + wraps the function, and so the docstring for ivy.frexp also applies to + this method with minimal changes. Parameters ---------- @@ -3107,10 +3061,9 @@ def frexp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.frexp. This method simply wraps the - function, and so the docstring for ivy.frexp also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.frexp. This method + simply wraps the function, and so the docstring for ivy.frexp also + applies to this method with minimal changes. Parameters ---------- @@ -3148,10 +3101,9 @@ def static_modf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.modf. This method simply wraps the - function, and so the docstring for ivy.modf also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.modf. This method simply + wraps the function, and so the docstring for ivy.modf also applies to + this method with minimal changes. Parameters ---------- @@ -3204,10 +3156,9 @@ def modf( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.modf. This method simply wraps the - function, and so the docstring for ivy.modf also applies to this method with - minimal changes. + r"""ivy.Container instance method variant of ivy.modf. This method + simply wraps the function, and so the docstring for ivy.modf also + applies to this method with minimal changes. Parameters ---------- @@ -3246,10 +3197,9 @@ def static_digamma( map_sequences: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.digamma. This method simply wraps the - function, and so the docstring for ivy.digamma also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.digamma. This method + simply wraps the function, and so the docstring for ivy.digamma also + applies to this method with minimal changes. Note ---- @@ -3309,10 +3259,9 @@ def digamma( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.digamma. This method simply wraps - the function, and so the docstring for ivy.digamma also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.digamma. This method + simply wraps the function, and so the docstring for ivy.digamma also + applies to this method with minimal changes. Note ---- @@ -3372,10 +3321,9 @@ def static_sparsify_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sparsify_tensor. This method simply - wraps the function, and so the docstring for ivy.sparsify_tensor also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.sparsify_tensor. This + method simply wraps the function, and so the docstring for + ivy.sparsify_tensor also applies to this method with minimal changes. Parameters ---------- @@ -3437,8 +3385,7 @@ def sparsify_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sparsify_tensor. + """ivy.Container instance method variant of ivy.sparsify_tensor. This method simply wraps the function, and so the docstring for ivy.sparsify_tensor also applies to this method with minimal @@ -3465,10 +3412,9 @@ def static_erfc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.erfc. This method simply wraps the - function, and so the docstring for ivy.erfc also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.erfc. This method simply + wraps the function, and so the docstring for ivy.erfc also applies to + this method with minimal changes. Parameters ---------- @@ -3518,10 +3464,9 @@ def erfc( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.erfc. This method simply wraps the - function, and so the docstring for ivy.erfc also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.erfc. This method + simply wraps the function, and so the docstring for ivy.erfc also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/general.py b/ivy/data_classes/container/experimental/general.py index af380102a50ce..e44bc1fc8e506 100644 --- a/ivy/data_classes/container/experimental/general.py +++ b/ivy/data_classes/container/experimental/general.py @@ -21,10 +21,9 @@ def _static_reduce( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.reduce. This method simply wraps the - function, and so the docstring for ivy.reduce also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.reduce. This method + simply wraps the function, and so the docstring for ivy.reduce also + applies to this method with minimal changes. Parameters ---------- @@ -95,10 +94,9 @@ def reduce( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.reduce. This method simply wraps - the function, and so the docstring for ivy.reduce also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.reduce. This method + simply wraps the function, and so the docstring for ivy.reduce also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/layers.py b/ivy/data_classes/container/experimental/layers.py index ce2f0c1ffc3cf..023cf2554bfd6 100644 --- a/ivy/data_classes/container/experimental/layers.py +++ b/ivy/data_classes/container/experimental/layers.py @@ -24,10 +24,9 @@ def static_max_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_pool1d. This method simply wraps - the function, and so the docstring for ivy.max_pool1d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.max_pool1d. This method + simply wraps the function, and so the docstring for ivy.max_pool1d also + applies to this method with minimal changes. Parameters ---------- @@ -101,10 +100,9 @@ def max_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.max_pool1d`. This method simply - wraps the function, and so the docstring for `ivy.max_pool1d` also applies to - this method with minimal changes. + """ivy.Container instance method variant of `ivy.max_pool1d`. This + method simply wraps the function, and so the docstring for + `ivy.max_pool1d` also applies to this method with minimal changes. Parameters ---------- @@ -178,10 +176,9 @@ def static_max_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_pool2dd. This method simply wraps - the function, and so the docstring for ivy.max_pool2d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.max_pool2dd. This method + simply wraps the function, and so the docstring for ivy.max_pool2d also + applies to this method with minimal changes. Parameters ---------- @@ -253,10 +250,9 @@ def max_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.max_pool2d`. This method simply - wraps the function, and so the docstring for `ivy.max_pool2d` also applies to - this method with minimal changes. + """ivy.Container instance method variant of `ivy.max_pool2d`. This + method simply wraps the function, and so the docstring for + `ivy.max_pool2d` also applies to this method with minimal changes. Parameters ---------- @@ -332,10 +328,9 @@ def static_max_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_pool3d. This method simply wraps - the function, and so the docstring for ivy.max_pool3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.max_pool3d. This method + simply wraps the function, and so the docstring for ivy.max_pool3d also + applies to this method with minimal changes. Parameters ---------- @@ -410,10 +405,9 @@ def max_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_pool3d. This method simply wraps - the function, and so the docstring for ivy.max_pool3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.max_pool3d. This method + simply wraps the function, and so the docstring for ivy.max_pool3d also + applies to this method with minimal changes. Parameters ---------- @@ -485,10 +479,9 @@ def static_avg_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.avg_pool1d. This method simply wraps - the function, and so the docstring for ivy.avg_pool1d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.avg_pool1d. This method + simply wraps the function, and so the docstring for ivy.avg_pool1d also + applies to this method with minimal changes. Parameters ---------- @@ -561,10 +554,9 @@ def avg_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.avg_pool1d`. This method simply - wraps the function, and so the docstring for `ivy.avg_pool1d` also applies to - this method with minimal changes. + """ivy.Container instance method variant of `ivy.avg_pool1d`. This + method simply wraps the function, and so the docstring for + `ivy.avg_pool1d` also applies to this method with minimal changes. Parameters ---------- @@ -638,10 +630,9 @@ def static_avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.avg_pool2d. This method simply wraps - the function, and so the docstring for ivy.avg_pool2d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.avg_pool2d. This method + simply wraps the function, and so the docstring for ivy.avg_pool2d also + applies to this method with minimal changes. Parameters ---------- @@ -718,10 +709,9 @@ def avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.avg_pool2d`. This method simply - wraps the function, and so the docstring for `ivy.avg_pool2d` also applies to - this method with minimal changes. + """ivy.Container instance method variant of `ivy.avg_pool2d`. This + method simply wraps the function, and so the docstring for + `ivy.avg_pool2d` also applies to this method with minimal changes. Parameters ---------- @@ -798,10 +788,9 @@ def static_avg_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.avg_pool3d. This method simply wraps - the function, and so the docstring for ivy.avg_pool3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.avg_pool3d. This method + simply wraps the function, and so the docstring for ivy.avg_pool3d also + applies to this method with minimal changes. Parameters ---------- @@ -879,10 +868,9 @@ def avg_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.avg_pool3d. This method simply wraps - the function, and so the docstring for ivy.avg_pool3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.avg_pool3d. This method + simply wraps the function, and so the docstring for ivy.avg_pool3d also + applies to this method with minimal changes. Parameters ---------- @@ -959,10 +947,9 @@ def static_dct( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dct. This method simply wraps the - function, and so the docstring for ivy.dct also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.dct. This method simply + wraps the function, and so the docstring for ivy.dct also applies to + this method with minimal changes. Parameters ---------- @@ -1035,10 +1022,9 @@ def dct( norm: Optional[Union[Literal["ortho"], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dct. This method simply wraps the - function, and so the docstring for ivy.dct also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.dct. This method simply + wraps the function, and so the docstring for ivy.dct also applies to + this method with minimal changes. Parameters ---------- @@ -1095,10 +1081,9 @@ def static_idct( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.idct. This method simply wraps the - function, and so the docstring for ivy.idct also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.idct. This method simply + wraps the function, and so the docstring for ivy.idct also applies to + this method with minimal changes. Parameters ---------- @@ -1173,10 +1158,9 @@ def idct( norm: Optional[Union[Literal["ortho"], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.idct. This method simply wraps the - function, and so the docstring for ivy.idct also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.idct. This method + simply wraps the function, and so the docstring for ivy.idct also + applies to this method with minimal changes. Parameters ---------- @@ -1232,10 +1216,9 @@ def _static_fft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fft. This method simply wraps the - function, and so the docstring for ivy.fft also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fft. This method simply + wraps the function, and so the docstring for ivy.fft also applies to + this method with minimal changes. Parameters ---------- @@ -1304,10 +1287,9 @@ def fft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fft. This method simply wraps the - function, and so the docstring for ivy.fft also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fft. This method simply + wraps the function, and so the docstring for ivy.fft also applies to + this method with minimal changes. Parameters ---------- @@ -1375,10 +1357,9 @@ def static_ifft( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.ifft. This method simply wraps the - function, and so the docstring for ivy.ifft also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.ifft. This method simply + wraps the function, and so the docstring for ivy.ifft also applies to + this method with minimal changes. Parameters ---------- @@ -1442,10 +1423,9 @@ def ifft( n: Optional[Union[int, Tuple[int], ivy.Container]] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ): - """ - ivy.Container instance method variant of ivy.ifft. This method simply wraps the - function, and so the docstring for ivy.ifft also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.ifft. This method + simply wraps the function, and so the docstring for ivy.ifft also + applies to this method with minimal changes. Parameters ---------- @@ -1666,8 +1646,7 @@ def static_interpolate( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Down/up samples the input to the given size. The algorithm used for + """Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -1755,8 +1734,7 @@ def interpolate( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Down/up samples the input to the given size. The algorithm used for + """Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -1825,10 +1803,10 @@ def static_adaptive_avg_pool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.adaptive_avg_pool1d. This method - simply wraps the function, and so the docstring for ivy.adaptive_avg_pool1d also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.adaptive_avg_pool1d. This + method simply wraps the function, and so the docstring for + ivy.adaptive_avg_pool1d also applies to this method with minimal + changes. Parameters ---------- @@ -1863,9 +1841,8 @@ def adaptive_avg_pool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Apply a 1D adaptive average pooling over an input signal composed of several - input planes. + """Apply a 1D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -1897,10 +1874,10 @@ def static_adaptive_avg_pool2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.adaptive_avg_pool2d. This method - simply wraps the function, and so the docstring for ivy.adaptive_avg_pool2d also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.adaptive_avg_pool2d. This + method simply wraps the function, and so the docstring for + ivy.adaptive_avg_pool2d also applies to this method with minimal + changes. Parameters ---------- @@ -1935,9 +1912,8 @@ def adaptive_avg_pool2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Apply a 2D adaptive average pooling over an input signal composed of several - input planes. + """Apply a 2D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -1969,10 +1945,10 @@ def static_adaptive_max_pool2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.adaptive_max_pool2d. This method - simply wraps the function, and so the docstring for ivy.adaptive_max_pool2d also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.adaptive_max_pool2d. This + method simply wraps the function, and so the docstring for + ivy.adaptive_max_pool2d also applies to this method with minimal + changes. Parameters ---------- @@ -2007,9 +1983,8 @@ def adaptive_max_pool2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Apply a 2D adaptive maximum pooling over an input signal composed of several - input planes. + """Apply a 2D adaptive maximum pooling over an input signal composed of + several input planes. Parameters ---------- @@ -2044,8 +2019,7 @@ def static_ifftn( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.ifftn. + """ivy.Container static method variant of ivy.ifftn. This method simply wraps the function, and so the docstring for ivy.ifftn also applies to this method with minimal changes. @@ -2103,8 +2077,7 @@ def ifftn( norm: Union[str, ivy.Container] = "backward", out: Optional[Union[ivy.Array, ivy.Container]] = None, ): - """ - ivy.Container static method variant of ivy.ifftn. + """ivy.Container static method variant of ivy.ifftn. This method simply wraps the function, and so the docstring for ivy.ifftn also applies to this method with minimal changes. @@ -2188,8 +2161,7 @@ def static_rfft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rfft. + """ivy.Container static method variant of ivy.rfft. This method simply wraps the function, and so the docstring for ivy.rfft also applies to this method with minimal changes. @@ -2278,10 +2250,9 @@ def rfft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ): - """ - ivy.Container instance method variant of ivy.rfft. This method simply wraps the - function, and so the docstring for ivy.rfft also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.rfft. This method + simply wraps the function, and so the docstring for ivy.rfft also + applies to this method with minimal changes. Parameters ---------- @@ -2364,8 +2335,7 @@ def static_rfftn( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rfftn. + """ivy.Container static method variant of ivy.rfftn. This method simply wraps the function, and so the docstring for ivy.rfftn also applies to this method with minimal changes. @@ -2429,8 +2399,7 @@ def rfftn( norm: Union[str, ivy.Container] = "backward", out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - Compute the n-dimensional discrete Fourier Transform for real input. + """Compute the n-dimensional discrete Fourier Transform for real input. Parameters ---------- @@ -2477,8 +2446,7 @@ def static_stft( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stft. + """ivy.Container static method variant of ivy.stft. This method simply wraps the function, and so the docstring for ivy.stft also applies to this method with minimal changes. @@ -2542,8 +2510,7 @@ def stft( name: Optional[Union[str, ivy.Container]] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - Compute the Short-time Fourier Transform of signals. + """Compute the Short-time Fourier Transform of signals. Parameters ---------- @@ -2600,10 +2567,9 @@ def _static_sliding_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sliding_window. This method simply - wraps the function, and so the docstring for ivy.sliding_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.sliding_window. This + method simply wraps the function, and so the docstring for + ivy.sliding_window also applies to this method with minimal changes. Parameters ---------- @@ -2682,10 +2648,9 @@ def sliding_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sliding_window. This method simply - wraps the function, and so the docstring for ivy.sliding_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.sliding_window. This + method simply wraps the function, and so the docstring for + ivy.sliding_window also applies to this method with minimal changes. Parameters ---------- @@ -2761,8 +2726,7 @@ def static_max_unpool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_unpool1d. + """ivy.Container static method variant of ivy.max_unpool1d. Parameters ---------- @@ -2821,8 +2785,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Container: - """ - Compute a 1-D max unpooling given the 1-D pooled input x and its indices. + """Compute a 1-D max unpooling given the 1-D pooled input x and its + indices. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/linear_algebra.py b/ivy/data_classes/container/experimental/linear_algebra.py index b7f2d2ae67435..54e51634a4453 100644 --- a/ivy/data_classes/container/experimental/linear_algebra.py +++ b/ivy/data_classes/container/experimental/linear_algebra.py @@ -24,10 +24,9 @@ def static_eigh_tridiagonal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container]]: - """ - ivy.Container static method variant of ivy.eigh_tridiagonal. This method simply - wraps the function, and so the docstring for ivy.eigh_tridiagonal also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.eigh_tridiagonal. This + method simply wraps the function, and so the docstring for + ivy.eigh_tridiagonal also applies to this method with minimal changes. Parameters ---------- @@ -118,10 +117,9 @@ def eigh_tridiagonal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container]]: - """ - ivy.Container instance method variant of ivy.eigh_tridiagonal. This method - simply wraps the function, and so the docstring for ivy.eigh_tridiagonal also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.eigh_tridiagonal. This + method simply wraps the function, and so the docstring for + ivy.eigh_tridiagonal also applies to this method with minimal changes. Parameters ---------- @@ -236,10 +234,9 @@ def diagflat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diagflat. This method simply wraps - the function, and so the docstring for ivy.diagflat also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.diagflat. This method + simply wraps the function, and so the docstring for ivy.diagflat also + applies to this method with minimal changes. Examples -------- @@ -277,10 +274,9 @@ def static_kron( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.kron. This method simply wraps the - function, and so the docstring for ivy.kron also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.kron. This method simply + wraps the function, and so the docstring for ivy.kron also applies to + this method with minimal changes. Parameters ---------- @@ -329,10 +325,9 @@ def kron( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.kron. This method simply wraps the - function, and so the docstring for ivy.kron also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.kron. This method + simply wraps the function, and so the docstring for ivy.kron also + applies to this method with minimal changes. Examples -------- @@ -379,10 +374,9 @@ def matrix_exp( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diagflat. This method simply wraps - the function, and so the docstring for ivy.diagflat also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.diagflat. This method + simply wraps the function, and so the docstring for ivy.diagflat also + applies to this method with minimal changes. Examples -------- @@ -413,10 +407,9 @@ def static_eig( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.eig. This method simply wraps the - function, and so the docstring for ivy.eig also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.eig. This method simply + wraps the function, and so the docstring for ivy.eig also applies to + this method with minimal changes. Parameters ---------- @@ -466,10 +459,9 @@ def eig( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eig. This method simply wraps the - function, and so the docstring for ivy.eig also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.eig. This method simply + wraps the function, and so the docstring for ivy.eig also applies to + this method with minimal changes. Parameters ---------- @@ -519,10 +511,9 @@ def static_eigvals( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.eigvals. This method simply wraps the - function, and so the docstring for ivy.eigvals also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.eigvals. This method + simply wraps the function, and so the docstring for ivy.eigvals also + applies to this method with minimal changes. Parameters ---------- @@ -566,10 +557,9 @@ def eigvals( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eigvals. This method simply wraps - the function, and so the docstring for ivy.eigvals also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.eigvals. This method + simply wraps the function, and so the docstring for ivy.eigvals also + applies to this method with minimal changes. Parameters ---------- @@ -612,10 +602,9 @@ def static_adjoint( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.adjoint. This method simply wraps the - function, and so the docstring for ivy.adjoint also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.adjoint. This method + simply wraps the function, and so the docstring for ivy.adjoint also + applies to this method with minimal changes. Parameters ---------- @@ -661,10 +650,9 @@ def adjoint( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """ - ivy.Container instance method variant of ivy.adjoint. This method simply wraps - the function, and so the docstring for ivy.adjoint also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.adjoint. This method + simply wraps the function, and so the docstring for ivy.adjoint also + applies to this method with minimal changes. Examples -------- @@ -692,10 +680,9 @@ def static_multi_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.multi_dot. This method simply wraps - the function, and so the docstring for ivy.multi_dot also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.multi_dot. This method + simply wraps the function, and so the docstring for ivy.multi_dot also + applies to this method with minimal changes. Parameters ---------- @@ -750,10 +737,9 @@ def multi_dot( map_sequences: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.multi_dot. This method simply wraps - the function, and so the docstring for ivy.multi_dot also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.multi_dot. This method + simply wraps the function, and so the docstring for ivy.multi_dot also + applies to this method with minimal changes. Examples -------- @@ -792,10 +778,9 @@ def static_cond( p: Optional[Union[int, float, None, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.cond. This method simply wraps the - function, and so the docstring for ivy.cond also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cond. This method simply + wraps the function, and so the docstring for ivy.cond also applies to + this method with minimal changes. Parameters ---------- @@ -837,10 +822,9 @@ def cond( map_sequences: Union[bool, ivy.Container] = False, p: Optional[Union[int, float, None, ivy.Container]] = None, ): - """ - ivy.Container instance method variant of ivy.cond. This method simply wraps the - function, and so the docstring for ivy.cond also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cond. This method + simply wraps the function, and so the docstring for ivy.cond also + applies to this method with minimal changes. Parameters ---------- @@ -900,10 +884,9 @@ def static_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.mode_dot. This method simply wraps - the function, and so the docstring for ivy.mode_dot also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.mode_dot. This method + simply wraps the function, and so the docstring for ivy.mode_dot also + applies to this method with minimal changes. Parameters ---------- @@ -956,10 +939,9 @@ def mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container instance method variant of ivy.mode_dot. This method simply wraps - the function, and so the docstring for ivy.mode_dot also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.mode_dot. This method + simply wraps the function, and so the docstring for ivy.mode_dot also + applies to this method with minimal changes. Parameters ---------- @@ -1013,10 +995,9 @@ def static_multi_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.multi_mode_dot. This method simply - wraps the function, and so the docstring for ivy.multi_mode_dot also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.multi_mode_dot. This + method simply wraps the function, and so the docstring for + ivy.multi_mode_dot also applies to this method with minimal changes. Parameters ---------- @@ -1073,10 +1054,9 @@ def multi_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.multi_mode_dot. This method simply - wraps the function, and so the docstring for ivy.multi_mode_dot also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.multi_mode_dot. This + method simply wraps the function, and so the docstring for + ivy.multi_mode_dot also applies to this method with minimal changes. Parameters ---------- @@ -1130,10 +1110,9 @@ def static_svd_flip( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.svd_flip. This method simply wraps - the function, and so the docstring for ivy.svd_flip also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.svd_flip. This method + simply wraps the function, and so the docstring for ivy.svd_flip also + applies to this method with minimal changes. Parameters ---------- @@ -1172,10 +1151,9 @@ def svd_flip( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.svd_flip. This method simply wraps - the function, and so the docstring for ivy.svd_flip applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.svd_flip. This method + simply wraps the function, and so the docstring for ivy.svd_flip + applies to this method with minimal changes. Parameters ---------- @@ -1216,10 +1194,10 @@ def static_make_svd_non_negative( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.make_svd_non_negative. This method - simply wraps the function, and so the docstring for ivy.make_svd_non_negative - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.make_svd_non_negative. + This method simply wraps the function, and so the docstring for + ivy.make_svd_non_negative also applies to this method with minimal + changes. Parameters ---------- @@ -1263,10 +1241,9 @@ def make_svd_non_negative( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.make_svd_non_negative. This method - simply wraps the function, and so the docstring for ivy.make_svd_non_negative - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.make_svd_non_negative. + This method simply wraps the function, and so the docstring for + ivy.make_svd_non_negative applies to this method with minimal changes. Parameters ---------- @@ -1309,10 +1286,9 @@ def static_tensor_train( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.tensor_train. This method simply - wraps the function, and so the docstring for ivy.tensor_train also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.tensor_train. This method + simply wraps the function, and so the docstring for ivy.tensor_train + also applies to this method with minimal changes. Parameters ---------- @@ -1349,10 +1325,9 @@ def tensor_train( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container instance method variant of ivy.tensor_train. This method simply - wraps the function, and so the docstring for ivy.tensor_train also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.tensor_train. This + method simply wraps the function, and so the docstring for + ivy.tensor_train also applies to this method with minimal changes. Parameters ---------- @@ -1388,10 +1363,9 @@ def static_truncated_svd( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container, ivy.Container]]: - """ - ivy.Container static method variant of ivy.truncated_svd. This method simply - wraps the function, and so the docstring for ivy.truncated_svd also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.truncated_svd. This + method simply wraps the function, and so the docstring for + ivy.truncated_svd also applies to this method with minimal changes. Parameters ---------- @@ -1435,10 +1409,9 @@ def truncated_svd( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container, ivy.Container]]: - """ - ivy.Container instance method variant of ivy.truncated_svd. This method simply - wraps the function, and so the docstring for ivy.truncated_svd also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.truncated_svd. This + method simply wraps the function, and so the docstring for + ivy.truncated_svd also applies to this method with minimal changes. Parameters ---------- @@ -1490,10 +1463,9 @@ def static_initialize_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.initialize_tucker. This method simply - wraps the function, and so the docstring for ivy.initialize_tucker also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.initialize_tucker. This + method simply wraps the function, and so the docstring for + ivy.initialize_tucker also applies to this method with minimal changes. Parameters ---------- @@ -1564,10 +1536,9 @@ def initialize_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container instance method variant of ivy.initialize_tucker. This method - simply wraps the function, and so the docstring for ivy.initialize_tucker also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.initialize_tucker. This + method simply wraps the function, and so the docstring for + ivy.initialize_tucker also applies to this method with minimal changes. Parameters ---------- @@ -1641,10 +1612,9 @@ def static_partial_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.partial_tucker. This method simply - wraps the function, and so the docstring for ivy.partial_tucker also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.partial_tucker. This + method simply wraps the function, and so the docstring for + ivy.partial_tucker also applies to this method with minimal changes. Parameters ---------- @@ -1719,10 +1689,9 @@ def partial_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.partial_tucker. This method simply - wraps the function, and so the docstring for ivy.partial_tucker also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.partial_tucker. This + method simply wraps the function, and so the docstring for + ivy.partial_tucker also applies to this method with minimal changes. Parameters ---------- @@ -1797,10 +1766,9 @@ def static_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.tucker. This method simply wraps the - function, and so the docstring for ivy.tucker also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tucker. This method + simply wraps the function, and so the docstring for ivy.tucker also + applies to this method with minimal changes. Parameters ---------- @@ -1895,10 +1863,9 @@ def tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.tucker. This method simply wraps the - function, and so the docstring for ivy.tucker also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tucker. This method + simply wraps the function, and so the docstring for ivy.tucker also + applies to this method with minimal changes. Parameters ---------- @@ -1982,10 +1949,9 @@ def static_dot( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Array, ivy.Container]: - """ - Compute the dot product between two arrays `a` and `b` using the current - backend's implementation. The dot product is defined as the sum of the element- - wise product of the input arrays. + """Compute the dot product between two arrays `a` and `b` using the + current backend's implementation. The dot product is defined as the sum + of the element- wise product of the input arrays. Parameters ---------- @@ -2048,10 +2014,9 @@ def dot( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Array, ivy.Container]: - """ - Compute the dot product between two arrays `a` and `b` using the current - backend's implementation. The dot product is defined as the sum of the element- - wise product of the input arrays. + """Compute the dot product between two arrays `a` and `b` using the + current backend's implementation. The dot product is defined as the sum + of the element- wise product of the input arrays. Parameters ---------- @@ -2113,10 +2078,10 @@ def static_tt_matrix_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tt_matrix_to_tensor. This method - simply wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.tt_matrix_to_tensor. This + method simply wraps the function, and so the docstring for + ivy.tt_matrix_to_tensor also applies to this method with minimal + changes. Parameters ---------- @@ -2180,10 +2145,10 @@ def tt_matrix_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tt_matrix_to_tensor. This method - simply wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.tt_matrix_to_tensor. + This method simply wraps the function, and so the docstring for + ivy.tt_matrix_to_tensor also applies to this method with minimal + changes. Parameters ---------- @@ -2248,10 +2213,10 @@ def static_higher_order_moment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.higher_order_moment. This method - simply wraps the function, and so the docstring for ivy.higher_order_moment also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.higher_order_moment. This + method simply wraps the function, and so the docstring for + ivy.higher_order_moment also applies to this method with minimal + changes. Parameters ---------- @@ -2290,10 +2255,10 @@ def higher_order_moment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.higher_order_moment. This method - simply wraps the function, and so the docstring for ivy.higher_order_moment also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.higher_order_moment. + This method simply wraps the function, and so the docstring for + ivy.higher_order_moment also applies to this method with minimal + changes. Parameters ---------- @@ -2343,10 +2308,9 @@ def static_batched_outer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.batched_outer. This method simply - wraps the function, and so the docstring for ivy.batched_outer also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.batched_outer. This + method simply wraps the function, and so the docstring for + ivy.batched_outer also applies to this method with minimal changes. Parameters ---------- @@ -2403,10 +2367,9 @@ def batched_outer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.batched_outer. This method simply - wraps the function, and so the docstring for ivy.batched_outer also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.batched_outer. This + method simply wraps the function, and so the docstring for + ivy.batched_outer also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/losses.py b/ivy/data_classes/container/experimental/losses.py index e2bae0e848991..799c44adfcb25 100644 --- a/ivy/data_classes/container/experimental/losses.py +++ b/ivy/data_classes/container/experimental/losses.py @@ -20,10 +20,9 @@ def _static_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.l1_loss. This method simply wraps the - function, and so the docstring for ivy.l1_loss also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.l1_loss. This method + simply wraps the function, and so the docstring for ivy.l1_loss also + applies to this method with minimal changes. Parameters ---------- @@ -103,10 +102,9 @@ def l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.l1_loss. This method simply wraps - the function, and so the docstring for ivy.l1_loss also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.l1_loss. This method + simply wraps the function, and so the docstring for ivy.l1_loss also + applies to this method with minimal changes. Parameters ---------- @@ -175,10 +173,9 @@ def _static_log_poisson_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log_poisson_loss. This method simply - wraps the function, and so the docstring for ivy.log_poisson_loss also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.log_poisson_loss. This + method simply wraps the function, and so the docstring for + ivy.log_poisson_loss also applies to this method with minimal changes. Parameters ---------- @@ -269,10 +266,9 @@ def log_poisson_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log_poisson_loss. This method - simply wraps the function, and so the docstring for ivy.log_poisson_loss also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.log_poisson_loss. This + method simply wraps the function, and so the docstring for + ivy.log_poisson_loss also applies to this method with minimal changes. Parameters ---------- @@ -349,10 +345,9 @@ def _static_smooth_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.smooth_l1_loss. This method simply - wraps the function, and so the docstring for ivy. smooth_l1_loss also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.smooth_l1_loss. This + method simply wraps the function, and so the docstring for ivy. + smooth_l1_loss also applies to this method with minimal changes. Parameters ---------- @@ -439,10 +434,9 @@ def smooth_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.smooth_l1_loss. This method simply - wraps the function, and so the docstring for ivy. smooth_l1_loss also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.smooth_l1_loss. This + method simply wraps the function, and so the docstring for ivy. + smooth_l1_loss also applies to this method with minimal changes. Parameters ---------- @@ -518,10 +512,9 @@ def _static_huber_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of huber_loss. This method simply wraps the - function, and so the docstring for huber_loss also applies to this method with - minimal changes. + """ivy.Container static method variant of huber_loss. This method + simply wraps the function, and so the docstring for huber_loss also + applies to this method with minimal changes. Parameters ---------- @@ -608,10 +601,9 @@ def huber_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of huber_loss. This method simply wraps - the function, and so the docstring for huber_loss also applies to this method - with minimal changes. + """ivy.Container instance method variant of huber_loss. This method + simply wraps the function, and so the docstring for huber_loss also + applies to this method with minimal changes. Parameters ---------- @@ -683,10 +675,9 @@ def _static_soft_margin_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.soft_margin_loss. This method simply - wraps the function, and so the docstring for ivy.soft_margin_loss also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.soft_margin_loss. This + method simply wraps the function, and so the docstring for + ivy.soft_margin_loss also applies to this method with minimal changes. # Insert the docstring here @@ -742,10 +733,9 @@ def soft_margin_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.soft_margin_loss. This method - simply wraps the function, and so the docstring for ivy.soft_margin_loss also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.soft_margin_loss. This + method simply wraps the function, and so the docstring for + ivy.soft_margin_loss also applies to this method with minimal changes. # Insert the docstring here @@ -802,10 +792,9 @@ def _static_kl_div( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.kl_div. This method simply wraps the - function, and so the docstring for ivy.kl_div also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.kl_div. This method + simply wraps the function, and so the docstring for ivy.kl_div also + applies to this method with minimal changes. Parameters ---------- @@ -861,10 +850,9 @@ def kl_div( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.kl_div. This method simply wraps - the function, and so the docstring for ivy.kl_div also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.kl_div. This method + simply wraps the function, and so the docstring for ivy.kl_div also + applies to this method with minimal changes. Parameters ---------- @@ -920,10 +908,9 @@ def _static_poisson_nll_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container static method variant of ivy.poisson_nll_loss. This method - simplywraps the function, and so the docstring for ivy.poisson_nll_loss also - applies to this method with minimal changes. + r"""ivy.Container static method variant of ivy.poisson_nll_loss. This + method simplywraps the function, and so the docstring for + ivy.poisson_nll_loss also applies to this method with minimal changes. Parameters ---------- @@ -1026,10 +1013,9 @@ def poisson_nll_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.poisson_nll_loss. This method - simply wraps the function, and so the docstring for ivy. poisson_nll_loss also - applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.poisson_nll_loss. This + method simply wraps the function, and so the docstring for ivy. + poisson_nll_loss also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/manipulation.py b/ivy/data_classes/container/experimental/manipulation.py index 0621ae4be3267..20e72671746e1 100644 --- a/ivy/data_classes/container/experimental/manipulation.py +++ b/ivy/data_classes/container/experimental/manipulation.py @@ -33,10 +33,9 @@ def static_moveaxis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.moveaxis. This method simply wraps - the function, and so the docstring for ivy.moveaxis also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.moveaxis. This method + simply wraps the function, and so the docstring for ivy.moveaxis also + applies to this method with minimal changes. Parameters ---------- @@ -94,10 +93,9 @@ def moveaxis( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.moveaxis. This method simply wraps - the function, and so the docstring for ivy.flatten also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.moveaxis. This method + simply wraps the function, and so the docstring for ivy.flatten also + applies to this method with minimal changes. Parameters ---------- @@ -147,10 +145,9 @@ def static_heaviside( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.heaviside. This method simply wraps - the function, and so the docstring for ivy.heaviside also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.heaviside. This method + simply wraps the function, and so the docstring for ivy.heaviside also + applies to this method with minimal changes. Parameters ---------- @@ -195,10 +192,9 @@ def heaviside( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.heaviside. This method simply wraps - the function, and so the docstring for ivy.heaviside also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.heaviside. This method + simply wraps the function, and so the docstring for ivy.heaviside also + applies to this method with minimal changes. Parameters ---------- @@ -239,10 +235,9 @@ def static_flipud( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.flipud. This method simply wraps the - function, and so the docstring for ivy.flipud also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.flipud. This method + simply wraps the function, and so the docstring for ivy.flipud also + applies to this method with minimal changes. Parameters ---------- @@ -297,10 +292,9 @@ def flipud( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.flipud. This method simply wraps - the function, and so the docstring for ivy.flipud also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.flipud. This method + simply wraps the function, and so the docstring for ivy.flipud also + applies to this method with minimal changes. Parameters ---------- @@ -353,10 +347,9 @@ def vstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method + simply wraps the function, and so the docstring for ivy.stack also + applies to this method with minimal changes. Examples -------- @@ -397,10 +390,9 @@ def static_vstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.vstack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.vstack also applies to + this method with minimal changes. Examples -------- @@ -442,10 +434,9 @@ def hstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hstack. This method simply wraps - the function, and so the docstring for ivy.hstack also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.hstack. This method + simply wraps the function, and so the docstring for ivy.hstack also + applies to this method with minimal changes. Examples -------- @@ -484,10 +475,9 @@ def static_hstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hstack. This method simply wraps the - function, and so the docstring for ivy.hstack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.hstack. This method + simply wraps the function, and so the docstring for ivy.hstack also + applies to this method with minimal changes. Examples -------- @@ -522,10 +512,9 @@ def static_rot90( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rot90. This method simply wraps the - function, and so the docstring for ivy.rot90 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.rot90. This method simply + wraps the function, and so the docstring for ivy.rot90 also applies to + this method with minimal changes. Parameters ---------- @@ -597,10 +586,9 @@ def rot90( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rot90. This method simply wraps the - function, and so the docstring for ivy.rot90 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.rot90. This method simply + wraps the function, and so the docstring for ivy.rot90 also applies to + this method with minimal changes. Parameters ---------- @@ -672,10 +660,9 @@ def static_top_k( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[Tuple[ivy.Container, ivy.Container], ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.top_k. This method simply wraps the - function, and so the docstring for ivy.top_k also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.top_k. This method simply + wraps the function, and so the docstring for ivy.top_k also applies to + this method with minimal changes. Parameters ---------- @@ -755,10 +742,9 @@ def top_k( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.top_k. This method simply wraps the - function, and so the docstring for ivy.top_k also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.top_k. This method + simply wraps the function, and so the docstring for ivy.top_k also + applies to this method with minimal changes. Parameters ---------- @@ -832,10 +818,9 @@ def static_fliplr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fliplr. This method simply wraps the - function, and so the docstring for ivy.fliplr also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fliplr. This method + simply wraps the function, and so the docstring for ivy.fliplr also + applies to this method with minimal changes. Parameters ---------- @@ -900,10 +885,9 @@ def fliplr( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fliplr. This method simply wraps - the function, and so the docstring for ivy.fliplr also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.fliplr. This method + simply wraps the function, and so the docstring for ivy.fliplr also + applies to this method with minimal changes. Parameters ---------- @@ -953,10 +937,9 @@ def static_i0( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.i0. This method simply wraps the - function, and so the docstring for ivy.i0 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.i0. This method simply + wraps the function, and so the docstring for ivy.i0 also applies to + this method with minimal changes. Parameters ---------- @@ -998,10 +981,9 @@ def i0( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.i0. This method simply wraps the - function, and so the docstring for ivy.i0 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.i0. This method simply + wraps the function, and so the docstring for ivy.i0 also applies to + this method with minimal changes. Parameters ---------- @@ -1044,10 +1026,9 @@ def static_flatten( order: Union[str, ivy.Container] = "C", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.flatten. This method simply wraps the - function, and so the docstring for ivy.flatten also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.flatten. This method + simply wraps the function, and so the docstring for ivy.flatten also + applies to this method with minimal changes. Parameters ---------- @@ -1124,10 +1105,9 @@ def flatten( order: Union[str, ivy.Container] = "C", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.flatten. This method simply wraps - the function, and so the docstring for ivy.flatten also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.flatten. This method + simply wraps the function, and so the docstring for ivy.flatten also + applies to this method with minimal changes. Parameters ---------- @@ -1220,8 +1200,7 @@ def static_pad( out: Optional[ivy.Container] = None, **kwargs: Optional[Union[Any, ivy.Container]], ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.pad. + """ivy.Container static method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -1277,8 +1256,7 @@ def pad( out: Optional[ivy.Container] = None, **kwargs: Optional[Union[Any, ivy.Container]], ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.pad. + """ivy.Container instance method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -1313,10 +1291,9 @@ def static_vsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.vsplit. This method simply wraps the - function, and so the docstring for ivy.vsplit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.vsplit. This method + simply wraps the function, and so the docstring for ivy.vsplit also + applies to this method with minimal changes. Parameters ---------- @@ -1399,10 +1376,9 @@ def vsplit( *, copy: Optional[Union[bool, ivy.Container]] = None, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.vsplit. This method simply wraps - the function, and so the docstring for ivy.vsplit also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.vsplit. This method + simply wraps the function, and so the docstring for ivy.vsplit also + applies to this method with minimal changes. Parameters ---------- @@ -1471,10 +1447,9 @@ def static_dsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.dsplit. This method simply wraps the - function, and so the docstring for ivy.dsplit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.dsplit. This method + simply wraps the function, and so the docstring for ivy.dsplit also + applies to this method with minimal changes. Parameters ---------- @@ -1555,10 +1530,9 @@ def dsplit( *, copy: Optional[Union[bool, ivy.Container]] = None, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.dsplit. This method simply wraps - the function, and so the docstring for ivy.dsplit also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dsplit. This method + simply wraps the function, and so the docstring for ivy.dsplit also + applies to this method with minimal changes. Parameters ---------- @@ -1620,10 +1594,9 @@ def static_atleast_1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.atleast_1d. This method simply wraps - the function, and so the docstring for ivy.atleast_1d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.atleast_1d. This method + simply wraps the function, and so the docstring for ivy.atleast_1d also + applies to this method with minimal changes. Parameters ---------- @@ -1684,10 +1657,9 @@ def atleast_1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.atleast_1d. This method simply - wraps the function, and so the docstring for ivy.atleast_1d also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.atleast_1d. This method + simply wraps the function, and so the docstring for ivy.atleast_1d also + applies to this method with minimal changes. Parameters ---------- @@ -1761,10 +1733,9 @@ def dstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method + simply wraps the function, and so the docstring for ivy.stack also + applies to this method with minimal changes. Examples -------- @@ -1805,10 +1776,9 @@ def static_dstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.dstack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.dstack also applies to + this method with minimal changes. Examples -------- @@ -1842,10 +1812,9 @@ def static_atleast_2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.atleast_2d. This method simply wraps - the function, and so the docstring for ivy.atleast_2d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.atleast_2d. This method + simply wraps the function, and so the docstring for ivy.atleast_2d also + applies to this method with minimal changes. Parameters ---------- @@ -1906,10 +1875,9 @@ def atleast_2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.atleast_2d. This method simply - wraps the function, and so the docstring for ivy.atleast_2d also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.atleast_2d. This method + simply wraps the function, and so the docstring for ivy.atleast_2d also + applies to this method with minimal changes. Parameters ---------- @@ -1978,10 +1946,9 @@ def static_atleast_3d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.atleast_3d. This method simply wraps - the function, and so the docstring for ivy.atleast_3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.atleast_3d. This method + simply wraps the function, and so the docstring for ivy.atleast_3d also + applies to this method with minimal changes. Parameters ---------- @@ -2046,10 +2013,9 @@ def atleast_3d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.atleast_3d. This method simply - wraps the function, and so the docstring for ivy.atleast_3d also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.atleast_3d. This method + simply wraps the function, and so the docstring for ivy.atleast_3d also + applies to this method with minimal changes. Parameters ---------- @@ -2118,10 +2084,9 @@ def static_take_along_axis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.take_along_axis. This method simply - wraps the function, and so the docstring for ivy.take_along_axis also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.take_along_axis. This + method simply wraps the function, and so the docstring for + ivy.take_along_axis also applies to this method with minimal changes. Parameters ---------- @@ -2192,10 +2157,9 @@ def take_along_axis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.take_along_axis. This method simply - wraps the function, and so the docstring for ivy.take_along_axis also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.take_along_axis. This + method simply wraps the function, and so the docstring for + ivy.take_along_axis also applies to this method with minimal changes. Parameters ---------- @@ -2268,10 +2232,9 @@ def static_hsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.hsplit. This method simply wraps the - function, and so the docstring for ivy.hsplit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.hsplit. This method + simply wraps the function, and so the docstring for ivy.hsplit also + applies to this method with minimal changes. Parameters ---------- @@ -2345,10 +2308,9 @@ def hsplit( copy: Optional[Union[bool, ivy.Container]] = None, /, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.hsplit. This method simply wraps - the function, and so the docstring for ivy.hsplit also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.hsplit. This method + simply wraps the function, and so the docstring for ivy.hsplit also + applies to this method with minimal changes. Parameters ---------- @@ -2405,10 +2367,9 @@ def static_broadcast_shapes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.broadcast_shapes. This method simply - wraps the function, and so the docstring for ivy.hsplit also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.broadcast_shapes. This + method simply wraps the function, and so the docstring for ivy.hsplit + also applies to this method with minimal changes. Parameters ---------- @@ -2462,10 +2423,9 @@ def broadcast_shapes( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.broadcast_shapes. This method - simply wraps the function, and so the docstring for ivy.broadcast_shapes also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.broadcast_shapes. This + method simply wraps the function, and so the docstring for + ivy.broadcast_shapes also applies to this method with minimal changes. Parameters ---------- @@ -2602,10 +2562,9 @@ def static_as_strided( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.as_strided. This method simply - wraps the function, and so the docstring for ivy.as_strided also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.as_strided. This method + simply wraps the function, and so the docstring for ivy.as_strided also + applies to this method with minimal changes. Parameters ---------- @@ -2649,10 +2608,9 @@ def as_strided( strides: Union[Sequence[int], ivy.Container], /, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.as_strided. This method simply - wraps the function, and so the docstring for ivy.as_strided also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.as_strided. This method + simply wraps the function, and so the docstring for ivy.as_strided also + applies to this method with minimal changes. Parameters ---------- @@ -2686,10 +2644,10 @@ def static_concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.concat_from_sequence. This method - simply wraps the function, and so the docstring for ivy.concat_from_sequence - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.concat_from_sequence. + This method simply wraps the function, and so the docstring for + ivy.concat_from_sequence also applies to this method with minimal + changes. Parameters ---------- @@ -2790,10 +2748,9 @@ def concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method + simply wraps the function, and so the docstring for ivy.stack also + applies to this method with minimal changes. Parameters ---------- @@ -2871,10 +2828,9 @@ def associative_scan( reverse: Union[bool, ivy.Container] = False, axis: Union[int, ivy.Container] = 0, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.associative_scan. This method - simply wraps the function, and so the docstring for ivy.associative_scan also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.associative_scan. This + method simply wraps the function, and so the docstring for + ivy.associative_scan also applies to this method with minimal changes. Parameters ---------- @@ -2905,8 +2861,7 @@ def _static_unique_consecutive( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unique_consecutive. + """ivy.Container static method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -2932,8 +2887,7 @@ def unique_consecutive( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_consecutive. + """ivy.Container instance method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -2956,8 +2910,7 @@ def _static_fill_diagonal( *, wrap: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fill_diagonal. + """ivy.Container static method variant of ivy.fill_diagonal. This method simply wraps the function, and so the docstring for ivy.fill_diagonal also applies to this method with minimal @@ -2977,8 +2930,7 @@ def fill_diagonal( *, wrap: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fill_diagonal. + """ivy.Container instance method variant of ivy.fill_diagonal. This method simply wraps the function, and so the docstring for ivy.fill_diagonal also applies to this method with minimal @@ -3002,8 +2954,7 @@ def static_unfold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unfold. + """ivy.Container static method variant of ivy.unfold. This method simply wraps the function, and so the docstring for ivy.unfold also applies to this method with minimal @@ -3042,8 +2993,7 @@ def unfold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unfold. + """ivy.Container instance method variant of ivy.unfold. This method simply wraps the function, and so the docstring for ivy.unfold also applies to this method with minimal @@ -3079,8 +3029,7 @@ def static_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fold. + """ivy.Container static method variant of ivy.fold. This method simply wraps the function, and so the docstring for ivy.fold also applies to this method with minimal @@ -3121,8 +3070,7 @@ def fold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fold. + """ivy.Container instance method variant of ivy.fold. This method simply wraps the function, and so the docstring for ivy.fold also applies to this method with minimal @@ -3161,8 +3109,7 @@ def static_partial_unfold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.partial_unfold. + """ivy.Container static method variant of ivy.partial_unfold. This method simply wraps the function, and so the docstring for ivy.partial_unfold also applies to this method with minimal @@ -3213,8 +3160,7 @@ def partial_unfold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.partial_unfold. + """ivy.Container instance method variant of ivy.partial_unfold. This method simply wraps the function, and so the docstring for ivy.partial_unfold also applies to this method with minimal @@ -3259,8 +3205,7 @@ def static_partial_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.partial_fold. + """ivy.Container static method variant of ivy.partial_fold. This method simply wraps the function, and so the docstring for ivy.partial_fold also applies to this method with minimal @@ -3311,8 +3256,7 @@ def partial_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.partial_fold. + """ivy.Container instance method variant of ivy.partial_fold. This method simply wraps the function, and so the docstring for ivy.partial_fold also applies to this method with minimal @@ -3352,8 +3296,7 @@ def static_partial_tensor_to_vec( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.partial_tensor_to_vec. + """ivy.Container static method variant of ivy.partial_tensor_to_vec. This method simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec also applies to this method with minimal @@ -3401,8 +3344,7 @@ def partial_tensor_to_vec( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.partial_tensor_to_vec. + """ivy.Container instance method variant of ivy.partial_tensor_to_vec. This method simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec also applies to this method with minimal @@ -3440,8 +3382,7 @@ def static_partial_vec_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.partial_vec_to_tensor. + """ivy.Container static method variant of ivy.partial_vec_to_tensor. This method simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor also applies to this method with minimal @@ -3487,8 +3428,7 @@ def partial_vec_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.partial_vec_to_tensor. + """ivy.Container instance method variant of ivy.partial_vec_to_tensor. This method simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor also applies to this method with minimal @@ -3526,8 +3466,7 @@ def static_matricize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.matricize. + """ivy.Container static method variant of ivy.matricize. This method simply wraps the function, and so the docstring for ivy.matricize also applies to this method with minimal @@ -3573,8 +3512,7 @@ def matricize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.matricize. + """ivy.Container instance method variant of ivy.matricize. This method simply wraps the function, and so the docstring for ivy.matricize also applies to this method with minimal @@ -3609,8 +3547,7 @@ def static_soft_thresholding( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.soft_thresholding. + """ivy.Container static method variant of ivy.soft_thresholding. This method simply wraps the function, and so the docstring for ivy.soft_thresholding also applies to this method with minimal @@ -3654,8 +3591,7 @@ def soft_thresholding( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.soft_thresholding. + """ivy.Container instance method variant of ivy.soft_thresholding. This method simply wraps the function, and so the docstring for ivy.soft_thresholding also applies to this method with minimal @@ -3690,8 +3626,7 @@ def static_column_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.column_stack. + """ivy.Container static method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -3742,8 +3677,7 @@ def column_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.column_stack. + """ivy.Container instance method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -3803,8 +3737,7 @@ def _static_put_along_axis( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.put_along_axis. + """ivy.Container static method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal @@ -3840,8 +3773,7 @@ def put_along_axis( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.put_along_axis. + """ivy.Container instance method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal @@ -3875,8 +3807,7 @@ def _static_take( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.take. + """ivy.Container static method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -3976,8 +3907,7 @@ def take( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.take. + """ivy.Container instance method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -4069,10 +3999,9 @@ def _static_trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trim_zeros. This method simply wraps - the function, and so the docstring for ivy.trim_zeros also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.trim_zeros. This method + simply wraps the function, and so the docstring for ivy.trim_zeros also + applies to this method with minimal changes. Parameters ---------- @@ -4106,10 +4035,9 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ - ivy.Container instance method variant of ivy.trim_zeros. This method simply - wraps the function, and so the docstring for ivy.trim_zeros also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.trim_zeros. This method + simply wraps the function, and so the docstring for ivy.trim_zeros also + applies to this method with minimal changes. Parameters ---------- @@ -4154,10 +4082,9 @@ def concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.stack also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/norms.py b/ivy/data_classes/container/experimental/norms.py index aab171d3242df..72d8e3d7485da 100644 --- a/ivy/data_classes/container/experimental/norms.py +++ b/ivy/data_classes/container/experimental/norms.py @@ -14,10 +14,9 @@ def static_l1_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.l1_normalize. This method simply - wraps the function, and so the docstring for ivy.l1_normalize also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.l1_normalize. This method + simply wraps the function, and so the docstring for ivy.l1_normalize + also applies to this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def l1_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.l1_normalize. This method simply - wraps the function, and so the docstring for ivy.l1_normalize also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.l1_normalize. This + method simply wraps the function, and so the docstring for + ivy.l1_normalize also applies to this method with minimal changes. Parameters ---------- @@ -129,10 +127,9 @@ def static_l2_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.l2_normalize. This method simply - wraps the function, and so the docstring for ivy.l2_normalize also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.l2_normalize. This method + simply wraps the function, and so the docstring for ivy.l2_normalize + also applies to this method with minimal changes. Parameters ---------- @@ -193,10 +190,9 @@ def l2_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.l2_normalize. This method simply - wraps the function, and so the docstring for ivy.l2_normalize also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.l2_normalize. This + method simply wraps the function, and so the docstring for + ivy.l2_normalize also applies to this method with minimal changes. Parameters ---------- @@ -272,10 +268,9 @@ def static_batch_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.batch_norm. This method simply wraps - the function, and so the docstring for ivy.batch_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.batch_norm. This method + simply wraps the function, and so the docstring for ivy.batch_norm also + applies to this method with minimal changes. Parameters ---------- @@ -369,10 +364,9 @@ def batch_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.batch_norm. This method simply - wraps the function, and so the docstring for ivy.batch_norm also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.batch_norm. This method + simply wraps the function, and so the docstring for ivy.batch_norm also + applies to this method with minimal changes. Parameters ---------- @@ -466,10 +460,9 @@ def static_instance_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.instance_norm. This method simply - wraps the function, and so the docstring for ivy.instance_norm also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.instance_norm. This + method simply wraps the function, and so the docstring for + ivy.instance_norm also applies to this method with minimal changes. Parameters ---------- @@ -561,10 +554,9 @@ def instance_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.instance_norm. This method simply - wraps the function, and so the docstring for ivy.instance_norm also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.instance_norm. This + method simply wraps the function, and so the docstring for + ivy.instance_norm also applies to this method with minimal changes. Parameters ---------- @@ -647,10 +639,9 @@ def static_group_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.group_norm. This method simply wraps - the function, and so the docstring for ivy.group_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.group_norm. This method + simply wraps the function, and so the docstring for ivy.group_norm also + applies to this method with minimal changes. Parameters ---------- @@ -710,10 +701,9 @@ def group_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.group_norm. This method simply wraps - the function, and so the docstring for ivy.group_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.group_norm. This method + simply wraps the function, and so the docstring for ivy.group_norm also + applies to this method with minimal changes. Parameters ---------- @@ -768,10 +758,9 @@ def static_lp_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.lp_normalize. This method simply - wraps the function, and so the docstring for ivy.lp_normalize also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.lp_normalize. This method + simply wraps the function, and so the docstring for ivy.lp_normalize + also applies to this method with minimal changes. Parameters ---------- @@ -836,10 +825,9 @@ def lp_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.l2_normalize. This method simply - wraps the function, and so the docstring for ivy.l2_normalize also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.l2_normalize. This + method simply wraps the function, and so the docstring for + ivy.l2_normalize also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/random.py b/ivy/data_classes/container/experimental/random.py index 7544f92d3fafa..9a991587eba55 100644 --- a/ivy/data_classes/container/experimental/random.py +++ b/ivy/data_classes/container/experimental/random.py @@ -22,10 +22,9 @@ def static_dirichlet( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dirichlet. This method simply wraps - the function, and so the docstring for ivy.dirichlet also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.dirichlet. This method + simply wraps the function, and so the docstring for ivy.dirichlet also + applies to this method with minimal changes. Parameters ---------- @@ -89,10 +88,9 @@ def dirichlet( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dirichlet. This method simply wraps - the function, and so the docstring for ivy.shuffle also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dirichlet. This method + simply wraps the function, and so the docstring for ivy.shuffle also + applies to this method with minimal changes. Parameters ---------- @@ -158,10 +156,9 @@ def static_beta( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.beta. This method simply wraps the - function, and so the docstring for ivy.beta also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.beta. This method simply + wraps the function, and so the docstring for ivy.beta also applies to + this method with minimal changes. Parameters ---------- @@ -229,10 +226,9 @@ def beta( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.beta. This method simply wraps the - function, and so the docstring for ivy.beta also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.beta. This method + simply wraps the function, and so the docstring for ivy.beta also + applies to this method with minimal changes. Parameters ---------- @@ -299,10 +295,9 @@ def static_poisson( fill_value: Optional[Union[float, int, ivy.Container]] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.poisson. This method simply wraps the - function, and so the docstring for ivy.poisson also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.poisson. This method + simply wraps the function, and so the docstring for ivy.poisson also + applies to this method with minimal changes. Parameters ---------- @@ -369,10 +364,9 @@ def poisson( fill_value: Optional[Union[float, int, ivy.Container]] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.poisson. This method simply wraps - the function, and so the docstring for ivy.poisson also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.poisson. This method + simply wraps the function, and so the docstring for ivy.poisson also + applies to this method with minimal changes. Parameters ---------- @@ -575,10 +569,9 @@ def static_gamma( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.gamma. This method simply wraps the - function, and so the docstring for ivy.gamma also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.gamma. This method simply + wraps the function, and so the docstring for ivy.gamma also applies to + this method with minimal changes. Parameters ---------- @@ -646,10 +639,9 @@ def gamma( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ - ivy.Container method variant of ivy.gamma. This method simply wraps the - function, and so the docstring for ivy.gamma also applies to this method with - minimal changes. + """ivy.Container method variant of ivy.gamma. This method simply wraps + the function, and so the docstring for ivy.gamma also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/searching.py b/ivy/data_classes/container/experimental/searching.py index d261dd6637716..0886c307e45e0 100644 --- a/ivy/data_classes/container/experimental/searching.py +++ b/ivy/data_classes/container/experimental/searching.py @@ -19,10 +19,9 @@ def static_unravel_index( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unravel_index. This method simply - wraps the function, and so the docstring for ivy.unravel_index also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.unravel_index. This + method simply wraps the function, and so the docstring for + ivy.unravel_index also applies to this method with minimal changes. Parameters ---------- @@ -67,10 +66,9 @@ def unravel_index( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unravel_index. This method simply - wraps the function, and so the docstring for ivy.unravel_index also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.unravel_index. This + method simply wraps the function, and so the docstring for + ivy.unravel_index also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/sorting.py b/ivy/data_classes/container/experimental/sorting.py index a79109ea555e3..dc7c74258edb8 100644 --- a/ivy/data_classes/container/experimental/sorting.py +++ b/ivy/data_classes/container/experimental/sorting.py @@ -17,8 +17,7 @@ def static_invert_permutation( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.invert_permutation. + """ivy.Container static method variant of ivy.invert_permutation. This method simply wraps the function, and so the docstring for ivy.invert_permutation also applies to this method with minimal @@ -42,8 +41,7 @@ def invert_permutation( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.invert_permutation. + """ivy.Container instance method variant of ivy.invert_permutation. This method simply wraps the function, and so the docstring for ivy.invert_permutation also applies to this method with minimal @@ -69,10 +67,9 @@ def static_lexsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.lexsort. This method simply wraps the - function, and so the docstring for ivy.lexsort also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.lexsort. This method + simply wraps the function, and so the docstring for ivy.lexsort also + applies to this method with minimal changes. Parameters ---------- @@ -123,10 +120,9 @@ def lexsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.lexsort. This method simply wraps - the function, and so the docstring for ivy.lexsort also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.lexsort. This method + simply wraps the function, and so the docstring for ivy.lexsort also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/statistical.py b/ivy/data_classes/container/experimental/statistical.py index d7fa55b44c924..09c0e616384b1 100644 --- a/ivy/data_classes/container/experimental/statistical.py +++ b/ivy/data_classes/container/experimental/statistical.py @@ -28,10 +28,9 @@ def static_histogram( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.. This method simply wraps - the function, and so the docstring for ivy.histogram also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.. This method + simply wraps the function, and so the docstring for ivy.histogram also + applies to this method with minimal changes. Parameters ---------- @@ -135,10 +134,9 @@ def histogram( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.. This method simply - wraps the function, and so the docstring for ivy.histogram also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.. This + method simply wraps the function, and so the docstring for + ivy.histogram also applies to this method with minimal changes. Parameters ---------- @@ -235,10 +233,9 @@ def static_median( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.median. This method simply wraps the - function, and so the docstring for ivy.median also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.median. This method + simply wraps the function, and so the docstring for ivy.median also + applies to this method with minimal changes. Parameters ---------- @@ -288,10 +285,9 @@ def median( keepdims: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.median. This method simply wraps - the function, and so the docstring for ivy.median also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.median. This method + simply wraps the function, and so the docstring for ivy.median also + applies to this method with minimal changes. Parameters ---------- @@ -340,10 +336,9 @@ def static_nanmean( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nanmean. This method simply wraps the - function, and so the docstring for ivy.nanmean also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nanmean. This method + simply wraps the function, and so the docstring for ivy.nanmean also + applies to this method with minimal changes. Parameters ---------- @@ -401,10 +396,9 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nanmean. This method simply wraps - the function, and so the docstring for ivy.nanmean also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nanmean. This method + simply wraps the function, and so the docstring for ivy.nanmean also + applies to this method with minimal changes. Parameters ---------- @@ -459,10 +453,9 @@ def _static_nanmin( where: Optional[Union[ivy.Array, ivy.Container]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nanmin. This method simply wraps the - function, and so the docstring for ivy.nanmin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nanmin. This method + simply wraps the function, and so the docstring for ivy.nanmin also + applies to this method with minimal changes. Parameters ---------- @@ -521,10 +514,9 @@ def nanmin( initial: Optional[Union[int, float, complex, ivy.Container]] = None, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nanmin. This method simply wraps - the function, and so the docstring for ivy.nanmin also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nanmin. This method + simply wraps the function, and so the docstring for ivy.nanmin also + applies to this method with minimal changes. Parameters ---------- @@ -584,10 +576,9 @@ def static_nanprod( initial: Optional[Union[int, float, complex, ivy.Container]] = 1, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nanprod. This method simply wraps the - function, and so the docstring for ivy.nanprod also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nanprod. This method + simply wraps the function, and so the docstring for ivy.nanprod also + applies to this method with minimal changes. Parameters ---------- @@ -651,10 +642,9 @@ def nanprod( initial: Optional[Union[int, float, complex, ivy.Container]] = None, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nanprod. This method simply wraps - the function, and so the docstring for ivy.nanprod also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nanprod. This method + simply wraps the function, and so the docstring for ivy.nanprod also + applies to this method with minimal changes. Parameters ---------- @@ -717,10 +707,9 @@ def static_quantile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.quantile. This method simply wraps - the function, and so the docstring for ivy.quantile also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.quantile. This method + simply wraps the function, and so the docstring for ivy.quantile also + applies to this method with minimal changes. Parameters ---------- @@ -842,10 +831,9 @@ def quantile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.quantile. This method simply wraps - the function, and so the docstring for ivy.quantile also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.quantile. This method + simply wraps the function, and so the docstring for ivy.quantile also + applies to this method with minimal changes. Parameters ---------- @@ -966,10 +954,9 @@ def static_corrcoef( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.corrcoef. This method simply wraps - the function, and so the docstring for ivy.corrcoef also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.corrcoef. This method + simply wraps the function, and so the docstring for ivy.corrcoef also + applies to this method with minimal changes. Parameters ---------- @@ -1019,10 +1006,9 @@ def corrcoef( rowvar: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.corrcoef. This method simply wraps - the function, and so the docstring for ivy.corrcoef also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.corrcoef. This method + simply wraps the function, and so the docstring for ivy.corrcoef also + applies to this method with minimal changes. Parameters ---------- @@ -1068,10 +1054,9 @@ def static_nanmedian( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.median. This method simply wraps the - function, and so the docstring for ivy.median also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.median. This method + simply wraps the function, and so the docstring for ivy.median also + applies to this method with minimal changes. Parameters ---------- @@ -1124,10 +1109,9 @@ def nanmedian( overwrite_input: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nanmedian. This method simply wraps - the function, and so the docstring for ivy.nanmedian also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nanmedian. This method + simply wraps the function, and so the docstring for ivy.nanmedian also + applies to this method with minimal changes. Parameters ---------- @@ -1193,10 +1177,9 @@ def static_bincount( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bincount. This method simply wraps - the function, and so the docstring for ivy.bincount also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.bincount. This method + simply wraps the function, and so the docstring for ivy.bincount also + applies to this method with minimal changes. Parameters ---------- @@ -1243,10 +1226,9 @@ def bincount( minlength: Union[int, ivy.Container] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Array instance method variant of ivy.bincount. This method simply wraps the - function, and so the docstring for ivy.bincount also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.bincount. This method + simply wraps the function, and so the docstring for ivy.bincount also + applies to this method with minimal changes. Parameters ---------- @@ -1284,10 +1266,9 @@ def static_igamma( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.igamma. This method simply wraps the - function, and so the docstring for ivy.igamma also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.igamma. This method + simply wraps the function, and so the docstring for ivy.igamma also + applies to this method with minimal changes. Parameters ---------- @@ -1329,10 +1310,9 @@ def igamma( x: Union[ivy.Container, ivy.Array, ivy.NativeArray], out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.igamma. This method simply wraps - the function, and so the docstring for ivy.igamma also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.igamma. This method + simply wraps the function, and so the docstring for ivy.igamma also + applies to this method with minimal changes. Parameters ---------- @@ -1375,10 +1355,9 @@ def static_cov( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cov. This method simply wraps the - function, and so the docstring for ivy.cov also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cov. This method simply + wraps the function, and so the docstring for ivy.cov also applies to + this method with minimal changes. Parameters ---------- @@ -1492,10 +1471,9 @@ def cov( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cov. This method simply wraps the - function, and so the docstring for ivy.cov also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cov. This method simply + wraps the function, and so the docstring for ivy.cov also applies to + this method with minimal changes. Parameters ---------- @@ -1594,10 +1572,9 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cummax. This method simply wraps - the function, and so the docstring for ivy.cummax also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cummax. This method + simply wraps the function, and so the docstring for ivy.cummax also + applies to this method with minimal changes. Parameters ---------- @@ -1684,10 +1661,9 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cummin. This method simply wraps - the function, and so the docstring for ivy.cummin also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cummin. This method + simply wraps the function, and so the docstring for ivy.cummin also + applies to this method with minimal changes. Parameters ---------- @@ -1772,10 +1748,9 @@ def _static_cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cummax. This method simply wraps the - function, and so the docstring for ivy.cummax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cummax. This method + simply wraps the function, and so the docstring for ivy.cummax also + applies to this method with minimal changes. Parameters ---------- @@ -1862,10 +1837,9 @@ def _static_cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cummin. This method simply wraps the - function, and so the docstring for ivy.cummin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cummin. This method + simply wraps the function, and so the docstring for ivy.cummin also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/utility.py b/ivy/data_classes/container/experimental/utility.py index 876a9fad339e5..4218b878b282c 100644 --- a/ivy/data_classes/container/experimental/utility.py +++ b/ivy/data_classes/container/experimental/utility.py @@ -18,10 +18,10 @@ def static_optional_get_element( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.optional_get_element. This method - simply wraps the function, and so the docstring for ivy.optional_get_element - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.optional_get_element. + This method simply wraps the function, and so the docstring for + ivy.optional_get_element also applies to this method with minimal + changes. Parameters ---------- @@ -62,10 +62,10 @@ def optional_get_element( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.optional_get_element. This method - simply wraps the function, and so the docstring for ivy.optional_get_element - also applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.optional_get_element. + This method simply wraps the function, and so the docstring for + ivy.optional_get_element also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/container/general.py b/ivy/data_classes/container/general.py index 7d80783f03536..860fc6b0e57f2 100644 --- a/ivy/data_classes/container/general.py +++ b/ivy/data_classes/container/general.py @@ -22,10 +22,9 @@ def _static_is_native_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.is_native_array. This method simply - wraps the function, and so the docstring for ivy.is_native_array also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.is_native_array. This + method simply wraps the function, and so the docstring for + ivy.is_native_array also applies to this method with minimal changes. Parameters ---------- @@ -81,10 +80,10 @@ def is_native_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.is_native_array. This method simply - wraps the function, and so the docstring for ivy.ivy.is_native_array also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.is_native_array. This + method simply wraps the function, and so the docstring for + ivy.ivy.is_native_array also applies to this method with minimal + changes. Parameters ---------- @@ -140,10 +139,9 @@ def _static_is_ivy_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.is_ivy_array. This method simply - wraps the function, and so the docstring for ivy.is_ivy_array also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.is_ivy_array. This method + simply wraps the function, and so the docstring for ivy.is_ivy_array + also applies to this method with minimal changes. Parameters ---------- @@ -197,10 +195,10 @@ def is_ivy_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.is_native_array. This method simply - wraps the function, and so the docstring for ivy.ivy.is_native_array also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.is_native_array. This + method simply wraps the function, and so the docstring for + ivy.ivy.is_native_array also applies to this method with minimal + changes. Parameters ---------- @@ -254,10 +252,9 @@ def _static_is_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.is_array. This method simply wraps - the function, and so the docstring for ivy.ivy.is_array also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.is_array. This method + simply wraps the function, and so the docstring for ivy.ivy.is_array + also applies to this method with minimal changes. Parameters ---------- @@ -316,10 +313,9 @@ def is_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.is_array. This method simply wraps - the function, and so the docstring for ivy.is_array also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.is_array. This method + simply wraps the function, and so the docstring for ivy.is_array also + applies to this method with minimal changes. Parameters ---------- @@ -377,10 +373,9 @@ def _static_clip_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.clip_vector_norm. This method - simply wraps the function, and so the docstring for ivy.clip_vector_norm also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.clip_vector_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_vector_norm also applies to this method with minimal changes. Parameters ---------- @@ -449,10 +444,9 @@ def clip_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.clip_vector_norm. This method - simply wraps the function, and so the docstring for ivy.clip_vector_norm also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.clip_vector_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_vector_norm also applies to this method with minimal changes. Parameters ---------- @@ -523,10 +517,9 @@ def _static_inplace_update( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inplace_update. This method simply - wraps the function, and so the docstring for ivy.inplace_update also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.inplace_update. This + method simply wraps the function, and so the docstring for + ivy.inplace_update also applies to this method with minimal changes. Parameters ---------- @@ -592,10 +585,9 @@ def inplace_update( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inplace_update. This method simply - wraps the function, and so the docstring for ivy.inplace_update also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.inplace_update. This + method simply wraps the function, and so the docstring for + ivy.inplace_update also applies to this method with minimal changes. Parameters ---------- @@ -666,10 +658,9 @@ def _static_inplace_decrement( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.inplace_decrement. This method simply - wraps the function, and so the docstring for ivy.inplace_decrement also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.inplace_decrement. This + method simply wraps the function, and so the docstring for + ivy.inplace_decrement also applies to this method with minimal changes. Parameters ---------- @@ -746,10 +737,9 @@ def inplace_decrement( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inplace_decrement. This method - simply wraps the function, and so the docstring for ivy.inplace_decrement also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.inplace_decrement. This + method simply wraps the function, and so the docstring for + ivy.inplace_decrement also applies to this method with minimal changes. Parameters ---------- @@ -808,10 +798,9 @@ def _static_inplace_increment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.inplace_increment. This method simply - wraps the function, and so the docstring for ivy.inplace_increment also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.inplace_increment. This + method simply wraps the function, and so the docstring for + ivy.inplace_increment also applies to this method with minimal changes. Parameters ---------- @@ -888,10 +877,9 @@ def inplace_increment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inplace_increment. This method - wraps the function, and so the docstring for ivy.inplace_increment also applies - to this method with minimal changes. + """ivy.Container instance method variant of ivy.inplace_increment. This + method wraps the function, and so the docstring for + ivy.inplace_increment also applies to this method with minimal changes. Parameters ---------- @@ -949,10 +937,10 @@ def _static_assert_supports_inplace( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.assert_supports_inplace. This method - simply wraps the function, and so the docstring for ivy.assert_supports_inplace - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.assert_supports_inplace. + This method simply wraps the function, and so the docstring for + ivy.assert_supports_inplace also applies to this method with minimal + changes. Parameters ---------- @@ -993,10 +981,10 @@ def assert_supports_inplace( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.assert_supports_inplace. This - method simply wraps the function, and so the docstring for - ivy.assert_supports_inplace also applies to this method with minimal changes. + """ivy.Container instance method variant of + ivy.assert_supports_inplace. This method simply wraps the function, and + so the docstring for ivy.assert_supports_inplace also applies to this + method with minimal changes. Parameters ---------- @@ -1048,10 +1036,9 @@ def _static_all_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.all_equal. This method simply wraps - the function, and so the docstring for ivy.all_equal also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.all_equal. This method + simply wraps the function, and so the docstring for ivy.all_equal also + applies to this method with minimal changes. Parameters ---------- @@ -1126,10 +1113,9 @@ def all_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.all_equal. This method simply wraps - the function, and so the docstring for ivy.all_equal also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.all_equal. This method + simply wraps the function, and so the docstring for ivy.all_equal also + applies to this method with minimal changes. Parameters ---------- @@ -1228,10 +1214,9 @@ def _static_fourier_encode( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fourier_encode. This method simply - wraps the function, and so the docstring for ivy.fourier_encode also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.fourier_encode. This + method simply wraps the function, and so the docstring for + ivy.fourier_encode also applies to this method with minimal changes. Parameters ---------- @@ -1320,10 +1305,9 @@ def fourier_encode( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fourier_encode. This method simply - wraps the function, and so the docstring for ivy.fourier_encode also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.fourier_encode. This + method simply wraps the function, and so the docstring for + ivy.fourier_encode also applies to this method with minimal changes. Parameters ---------- @@ -1409,10 +1393,9 @@ def _static_gather( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.gather. This method simply wraps the - function, and so the docstring for ivy.gather also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.gather. This method + simply wraps the function, and so the docstring for ivy.gather also + applies to this method with minimal changes. Parameters ---------- @@ -1499,10 +1482,9 @@ def gather( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gather. This method simply wraps - the function, and so the docstring for ivy.gather also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.gather. This method + simply wraps the function, and so the docstring for ivy.gather also + applies to this method with minimal changes. Parameters ---------- @@ -1686,10 +1668,9 @@ def _static_scatter_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.scatter_nd. This method simply wraps - the function, and so the docstring for ivy.scatter_nd also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.scatter_nd. This method + simply wraps the function, and so the docstring for ivy.scatter_nd also + applies to this method with minimal changes. Parameters ---------- @@ -1782,10 +1763,9 @@ def scatter_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.scatter_nd. This method simply - wraps the function, and so the docstring for ivy.scatter_nd also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.scatter_nd. This method + simply wraps the function, and so the docstring for ivy.scatter_nd also + applies to this method with minimal changes. Parameters ---------- @@ -1877,10 +1857,9 @@ def _static_scatter_flat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.scatter_flat. This method simply - wraps the function, and so the docstring for ivy.scatter_flat also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.scatter_flat. This method + simply wraps the function, and so the docstring for ivy.scatter_flat + also applies to this method with minimal changes. Parameters ---------- @@ -1940,10 +1919,9 @@ def scatter_flat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.scatter_flat. This method simply - wraps the function, and so the docstring for ivy.scatter_flat also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.scatter_flat. This + method simply wraps the function, and so the docstring for + ivy.scatter_flat also applies to this method with minimal changes. Parameters ---------- @@ -2016,9 +1994,8 @@ def _static_gather_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Gather slices from all container params into a arrays with shape specified by - indices. + """Gather slices from all container params into a arrays with shape + specified by indices. Parameters ---------- @@ -2083,10 +2060,9 @@ def gather_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gather_nd. This method simply wraps - the function, and so the docstring for ivy.gather_nd also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.gather_nd. This method + simply wraps the function, and so the docstring for ivy.gather_nd also + applies to this method with minimal changes. Parameters ---------- @@ -2157,8 +2133,7 @@ def _static_einops_reduce( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - Perform einops reduce operation on each sub array in the container. + """Perform einops reduce operation on each sub array in the container. Parameters ---------- @@ -2229,10 +2204,9 @@ def einops_reduce( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.einops_reduce. This method simply - wraps the function, and so the docstring for ivy.einops_reduce also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.einops_reduce. This + method simply wraps the function, and so the docstring for + ivy.einops_reduce also applies to this method with minimal changes. Parameters ---------- @@ -2312,8 +2286,7 @@ def _static_einops_repeat( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - Perform einops repeat operation on each sub array in the container. + """Perform einops repeat operation on each sub array in the container. Parameters ---------- @@ -2382,10 +2355,9 @@ def einops_repeat( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.einops_repeat. This method simply - wraps the function, and so the docstring for ivy.einops_repeat also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.einops_repeat. This + method simply wraps the function, and so the docstring for + ivy.einops_repeat also applies to this method with minimal changes. Parameters ---------- @@ -2450,10 +2422,9 @@ def _static_value_is_nan( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.value_is_nan. This method simply - wraps the function, and so the docstring for ivy.value_is_nan also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.value_is_nan. This method + simply wraps the function, and so the docstring for ivy.value_is_nan + also applies to this method with minimal changes. Parameters ---------- @@ -2531,10 +2502,9 @@ def value_is_nan( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.value_is_nan. This method simply - wraps the function, and so the docstring for ivy.value_is_nan also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.value_is_nan. This + method simply wraps the function, and so the docstring for + ivy.value_is_nan also applies to this method with minimal changes. Parameters ---------- @@ -2606,10 +2576,9 @@ def _static_to_numpy( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_numpy. This method simply wraps - the function, and so the docstring for ivy.to_numpy also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.to_numpy. This method + simply wraps the function, and so the docstring for ivy.to_numpy also + applies to this method with minimal changes. Parameters ---------- @@ -2677,10 +2646,9 @@ def to_numpy( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_numpy. This method simply wraps - the function, and so the docstring for ivy.to_numpy also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_numpy. This method + simply wraps the function, and so the docstring for ivy.to_numpy also + applies to this method with minimal changes. Parameters ---------- @@ -2750,10 +2718,9 @@ def _static_to_scalar( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_scalar. This method simply wraps - the function, and so the docstring for ivy.to_scalar also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.to_scalar. This method + simply wraps the function, and so the docstring for ivy.to_scalar also + applies to this method with minimal changes. Parameters ---------- @@ -2807,10 +2774,9 @@ def to_scalar( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_scalar. This method simply wraps - the function, and so the docstring for ivy.to_scalar also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_scalar. This method + simply wraps the function, and so the docstring for ivy.to_scalar also + applies to this method with minimal changes. Parameters ---------- @@ -2867,10 +2833,9 @@ def _static_to_list( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_list. This method simply wraps the - function, and so the docstring for ivy.to_list also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.to_list. This method + simply wraps the function, and so the docstring for ivy.to_list also + applies to this method with minimal changes. Parameters ---------- @@ -2920,10 +2885,9 @@ def to_list( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_list. This method simply wraps - the function, and so the docstring for ivy.to_list also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_list. This method + simply wraps the function, and so the docstring for ivy.to_list also + applies to this method with minimal changes. Parameters ---------- @@ -2978,10 +2942,9 @@ def _static_stable_divide( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stable_divide. This method simply - wraps the function, and so the docstring for ivy.stable_divide also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.stable_divide. This + method simply wraps the function, and so the docstring for + ivy.stable_divide also applies to this method with minimal changes. Parameters ---------- @@ -3082,10 +3045,9 @@ def stable_divide( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stable_divide. This method simply - wraps the function, and so the docstring for ivy.stable_divide also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.stable_divide. This + method simply wraps the function, and so the docstring for + ivy.stable_divide also applies to this method with minimal changes. Parameters ---------- @@ -3168,10 +3130,9 @@ def _static_stable_pow( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stable_pow. This method simply wraps - the function, and so the docstring for ivy.stable_pow also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.stable_pow. This method + simply wraps the function, and so the docstring for ivy.stable_pow also + applies to this method with minimal changes. Parameters ---------- @@ -3257,10 +3218,9 @@ def stable_pow( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stable_pow. This method simply - wraps the function, and so the docstring for ivy.stable_pow also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.stable_pow. This method + simply wraps the function, and so the docstring for ivy.stable_pow also + applies to this method with minimal changes. Parameters ---------- @@ -3347,10 +3307,9 @@ def _static_einops_rearrange( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.einops_rearrange. This method simply - wraps the function, and so the docstring for ivy.einops_rearrange also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.einops_rearrange. This + method simply wraps the function, and so the docstring for + ivy.einops_rearrange also applies to this method with minimal changes. Parameters ---------- @@ -3435,10 +3394,9 @@ def einops_rearrange( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ): - """ - ivy.Container instance method variant of ivy.einops_rearrange. This method - simply wraps the function, and so the docstring for ivy.einops_rearrange also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.einops_rearrange. This + method simply wraps the function, and so the docstring for + ivy.einops_rearrange also applies to this method with minimal changes. Parameters ---------- @@ -3523,10 +3481,9 @@ def _static_clip_matrix_norm( p: Union[float, ivy.Container] = 2.0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.clip_matrix_norm. This method simply - wraps the function, and so the docstring for ivy.clip_matrix_norm also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.clip_matrix_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_matrix_norm also applies to this method with minimal changes. Parameters ---------- @@ -3593,10 +3550,9 @@ def clip_matrix_norm( p: Union[float, ivy.Container] = 2.0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.clip_matrix_norm. This method - simply wraps the function, and so the docstring for ivy.clip_matrix_norm also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.clip_matrix_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_matrix_norm also applies to this method with minimal changes. Parameters ---------- @@ -3660,10 +3616,10 @@ def _static_supports_inplace_updates( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.supports_inplace_updates. This method - simply wraps the function, and so the docstring for ivy.supports_inplace_updates - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.supports_inplace_updates. + This method simply wraps the function, and so the docstring for + ivy.supports_inplace_updates also applies to this method with minimal + changes. Parameters ---------- @@ -3707,10 +3663,10 @@ def supports_inplace_updates( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.supports_inplace_updates. This - method simply wraps the static function, and so the docstring for the static - variant also applies to this method with minimal changes. + """ivy.Container instance method variant of + ivy.supports_inplace_updates. This method simply wraps the static + function, and so the docstring for the static variant also applies to + this method with minimal changes. Parameters ---------- @@ -3777,10 +3733,9 @@ def _static_get_num_dims( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.get_num_dims. This method simply - wraps the function, and so the docstring for ivy.get_num_dims also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.get_num_dims. This + method simply wraps the function, and so the docstring for + ivy.get_num_dims also applies to this method with minimal changes. Parameters ---------- @@ -3854,10 +3809,9 @@ def get_num_dims( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.get_num_dims. This method simply - wraps the function, and so the docstring for ivy.get_num_dims also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.get_num_dims. This + method simply wraps the function, and so the docstring for + ivy.get_num_dims also applies to this method with minimal changes. Parameters ---------- @@ -3931,10 +3885,9 @@ def _static_array_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.array_equal. This method simply - wraps the function, and so the docstring for ivy.array_equal also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.array_equal. This + method simply wraps the function, and so the docstring for + ivy.array_equal also applies to this method with minimal changes. Parameters ---------- @@ -3996,10 +3949,9 @@ def array_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.array_equal. This method simply - wraps the function, and so the docstring for ivy.array_equal also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.array_equal. This + method simply wraps the function, and so the docstring for + ivy.array_equal also applies to this method with minimal changes. Parameters ---------- @@ -4070,10 +4022,9 @@ def static_isin( assume_unique: Union[bool, ivy.Container] = False, invert: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Container instance method variant of ivy.isin. This method simply wraps the - function, and so the docstring for ivy.isin also applies to this method with - minimal changes. + """Container instance method variant of ivy.isin. This method simply + wraps the function, and so the docstring for ivy.isin also applies to + this method with minimal changes. Parameters ---------- @@ -4120,10 +4071,9 @@ def isin( assume_unique: Union[bool, ivy.Container] = False, invert: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Container instance method variant of ivy.isin. This method simply wraps the - function, and so the docstring for ivy.isin also applies to this method with - minimal changes. + """Container instance method variant of ivy.isin. This method simply + wraps the function, and so the docstring for ivy.isin also applies to + this method with minimal changes. Parameters ---------- @@ -4163,10 +4113,9 @@ def static_itemsize( x: ivy.Container, /, ) -> ivy.Container: - """ - Container instance method variant of ivy.itemsize. This method simply wraps the - function, and so the docstring for ivy.itemsize also applies to this method with - minimal changes. + """Container instance method variant of ivy.itemsize. This method + simply wraps the function, and so the docstring for ivy.itemsize also + applies to this method with minimal changes. Parameters ---------- @@ -4191,10 +4140,9 @@ def itemsize( self: ivy.Container, /, ) -> ivy.Container: - """ - Container instance method variant of ivy.itemsize. This method simply wraps the - function, and so the docstring for ivy.itemsize also applies to this method with - minimal changes. + """Container instance method variant of ivy.itemsize. This method + simply wraps the function, and so the docstring for ivy.itemsize also + applies to this method with minimal changes. Parameters ---------- @@ -4213,10 +4161,9 @@ def static_strides( x: ivy.Container, /, ) -> ivy.Container: - """ - Container instance method variant of ivy.strides. This method simply wraps the - function, and so the docstring for ivy.strides also applies to this method with - minimal changes. + """Container instance method variant of ivy.strides. This method simply + wraps the function, and so the docstring for ivy.strides also applies + to this method with minimal changes. Parameters ---------- @@ -4241,10 +4188,9 @@ def strides( self: ivy.Container, /, ) -> ivy.Container: - """ - Container instance method variant of ivy.strides. This method simply wraps the - function, and so the docstring for ivy.strides also applies to this method with - minimal changes. + """Container instance method variant of ivy.strides. This method simply + wraps the function, and so the docstring for ivy.strides also applies + to this method with minimal changes. Parameters ---------- @@ -4268,10 +4214,9 @@ def _static_exists( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.exists. This method simply wraps - the function, and so the docstring for ivy.exists also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.exists. This method + simply wraps the function, and so the docstring for ivy.exists also + applies to this method with minimal changes. Parameters ---------- @@ -4330,10 +4275,9 @@ def exists( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.exists. This method simply wraps - the function, and so the docstring for ivy.exists also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.exists. This method + simply wraps the function, and so the docstring for ivy.exists also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/gradients.py b/ivy/data_classes/container/gradients.py index 94a51f311c380..a1848f648913f 100644 --- a/ivy/data_classes/container/gradients.py +++ b/ivy/data_classes/container/gradients.py @@ -19,10 +19,9 @@ def _static_stop_gradient( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stop_gradient. This method simply - wraps the function, and so the docstring for ivy.stop_gradient also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.stop_gradient. This + method simply wraps the function, and so the docstring for + ivy.stop_gradient also applies to this method with minimal changes. Parameters ---------- @@ -97,10 +96,9 @@ def stop_gradient( preserve_type: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stop_gradient. This method simply - wraps the function, and so the docstring for ivy.stop_gradient also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.stop_gradient. This + method simply wraps the function, and so the docstring for + ivy.stop_gradient also applies to this method with minimal changes. Parameters ---------- @@ -175,10 +173,9 @@ def adam_step( epsilon: Union[float, ivy.Container] = 1e-7, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.adam_step. This method simply wraps - the function, and so the docstring for ivy.adam_step also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.adam_step. This method + simply wraps the function, and so the docstring for ivy.adam_step also + applies to this method with minimal changes. Parameters ---------- @@ -271,9 +268,8 @@ def optimizer_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Update weights ws of some function, given the true or effective derivatives of - some cost c with respect to ws, [dc/dw for w in ws]. + """Update weights ws of some function, given the true or effective + derivatives of some cost c with respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -351,10 +347,10 @@ def gradient_descent_update( stop_gradients: Union[bool, ivy.Container] = True, out: ivy.Container = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gradient_descent_update. This - method simply wraps the function, and so the docstring for - ivy.gradient_descent_update also applies to this method with minimal changes. + """ivy.Container instance method variant of + ivy.gradient_descent_update. This method simply wraps the function, and + so the docstring for ivy.gradient_descent_update also applies to this + method with minimal changes. Parameters ---------- @@ -435,10 +431,9 @@ def lars_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive Rate Scaling - (LARS) method. + """Update weights ws of some function, given the derivatives of some + cost c with respect to ws, [dc/dw for w in ws], by applying Layerwise + Adaptive Rate Scaling (LARS) method. Parameters ---------- @@ -516,9 +511,8 @@ def adam_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, using ADAM update. `[reference] + """Update weights ws of some function, given the derivatives of some + cost c with respect to ws, using ADAM update. `[reference] `_ @@ -637,9 +631,9 @@ def lamb_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws], by applying LAMB method. + """Update weights ws of some function, given the derivatives of some + cost c with respect to ws, [dc/dw for w in ws], by applying LAMB + method. Parameters ---------- diff --git a/ivy/data_classes/container/layers.py b/ivy/data_classes/container/layers.py index aad198392b2e7..6d3e681cfbf2d 100644 --- a/ivy/data_classes/container/layers.py +++ b/ivy/data_classes/container/layers.py @@ -26,10 +26,9 @@ def _static_linear( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.linear. This method simply wraps the - function, and so the docstring for ivy.linear also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.linear. This method + simply wraps the function, and so the docstring for ivy.linear also + applies to this method with minimal changes. Parameters ---------- @@ -120,10 +119,9 @@ def linear( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.linear. This method simply wraps - the function, and so the docstring for ivy.linear also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.linear. This method + simply wraps the function, and so the docstring for ivy.linear also + applies to this method with minimal changes. Parameters ---------- @@ -203,10 +201,9 @@ def _static_dropout( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dropout. This method simply wraps the - function, and so the docstring for ivy.dropout also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.dropout. This method + simply wraps the function, and so the docstring for ivy.dropout also + applies to this method with minimal changes. Parameters ---------- @@ -291,10 +288,9 @@ def dropout( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dropout. This method simply wraps - the function, and so the docstring for ivy.dropout also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dropout. This method + simply wraps the function, and so the docstring for ivy.dropout also + applies to this method with minimal changes. Parameters ---------- @@ -376,10 +372,9 @@ def _static_dropout1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dropout1d. This method simply wraps - the function, and so the docstring for ivy.dropout1d also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.dropout1d. This method + simply wraps the function, and so the docstring for ivy.dropout1d also + applies to this method with minimal changes. Parameters ---------- @@ -448,10 +443,9 @@ def dropout1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dropout1d. This method simply wraps - the function, and so the docstring for ivy.dropout1d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dropout1d. This method + simply wraps the function, and so the docstring for ivy.dropout1d also + applies to this method with minimal changes. Parameters ---------- @@ -520,10 +514,9 @@ def _static_dropout2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dropout2d. This method simply wraps - the function, and so the docstring for ivy.dropout2d also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.dropout2d. This method + simply wraps the function, and so the docstring for ivy.dropout2d also + applies to this method with minimal changes. Parameters ---------- @@ -581,10 +574,9 @@ def dropout2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dropout2d. This method simply wraps - the function, and so the docstring for ivy.dropout2d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dropout2d. This method + simply wraps the function, and so the docstring for ivy.dropout2d also + applies to this method with minimal changes. Parameters ---------- @@ -653,10 +645,9 @@ def _static_dropout3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dropout3d. This method simply wraps - the function, and so the docstring for ivy.dropout3d also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.dropout3d. This method + simply wraps the function, and so the docstring for ivy.dropout3d also + applies to this method with minimal changes. Parameters ---------- @@ -714,10 +705,9 @@ def dropout3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dropout3d. This method simply wraps - the function, and so the docstring for ivy.dropout3d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dropout3d. This method + simply wraps the function, and so the docstring for ivy.dropout3d also + applies to this method with minimal changes. Parameters ---------- @@ -779,11 +769,10 @@ def _static_scaled_dot_product_attention( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.scaled_dot_product_attention. This - method simply wraps the function, and so the docstring for - ivy.scaled_dot_product_attention also applies to this method with minimal - changes. + """ivy.Container static method variant of + ivy.scaled_dot_product_attention. This method simply wraps the + function, and so the docstring for ivy.scaled_dot_product_attention + also applies to this method with minimal changes. Parameters ---------- @@ -902,11 +891,10 @@ def scaled_dot_product_attention( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.scaled_dot_product_attention. This - method simply wraps the function, and so the docstring for - ivy.scaled_dot_product_attention also applies to this method with minimal - changes. + """ivy.Container instance method variant of + ivy.scaled_dot_product_attention. This method simply wraps the + function, and so the docstring for ivy.scaled_dot_product_attention + also applies to this method with minimal changes. Parameters ---------- @@ -1206,10 +1194,9 @@ def _static_conv1d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv1d. This method simply wraps the - function, and so the docstring for ivy.conv1d also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.conv1d. This method + simply wraps the function, and so the docstring for ivy.conv1d also + applies to this method with minimal changes. Parameters ---------- @@ -1302,10 +1289,9 @@ def conv1d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conv1d. This method simply wraps - the function, and so the docstring for ivy.conv1d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.conv1d. This method + simply wraps the function, and so the docstring for ivy.conv1d also + applies to this method with minimal changes. Parameters ---------- @@ -1398,10 +1384,9 @@ def _static_conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv2d. This method simply wraps the - function, and so the docstring for ivy.conv2d also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.conv2d. This method + simply wraps the function, and so the docstring for ivy.conv2d also + applies to this method with minimal changes. Parameters ---------- @@ -1488,10 +1473,9 @@ def conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.conv2d`. This method simply wraps - the function, and so the docstring for `ivy.conv2d` also applies to this method - with minimal changes. + """ivy.Container instance method variant of `ivy.conv2d`. This method + simply wraps the function, and so the docstring for `ivy.conv2d` also + applies to this method with minimal changes. Parameters ---------- @@ -1578,10 +1562,9 @@ def _static_conv1d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv1d_transpose. This method simply - wraps the function, and so the docstring for ivy.conv1d_transpose also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.conv1d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv1d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -1676,10 +1659,9 @@ def conv1d_transpose( bias: Optional[ivy.Container] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container]: - """ - ivy.Container instance method variant of ivy.conv1d_transpose. This method - simply wraps the function, and so the docstring for ivy.conv1d_transpose also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.conv1d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv1d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -1774,10 +1756,9 @@ def _static_conv2d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv2d_transpose. This method simply - wraps the function, and so the docstring for ivy.conv2d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.conv2d_transpose. This + method simply wraps the function, and so the docstring for ivy.conv2d + also applies to this method with minimal changes. Parameters ---------- @@ -1878,10 +1859,9 @@ def conv2d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conv2d_transpose. This method - simply wraps the function, and so the docstring for ivy.conv2d also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.conv2d_transpose. This + method simply wraps the function, and so the docstring for ivy.conv2d + also applies to this method with minimal changes. Parameters ---------- @@ -1987,10 +1967,9 @@ def _static_depthwise_conv2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.depthwise_conv2d. This method simply - wraps the function, and so the docstring for ivy.depthwise_conv2d also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.depthwise_conv2d. This + method simply wraps the function, and so the docstring for + ivy.depthwise_conv2d also applies to this method with minimal changes. Parameters ---------- @@ -2060,10 +2039,9 @@ def depthwise_conv2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.depthwise_conv2d. This method - simply wraps the function, and so the docstring for ivy.depthwise_conv2d also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.depthwise_conv2d. This + method simply wraps the function, and so the docstring for + ivy.depthwise_conv2d also applies to this method with minimal changes. Parameters ---------- @@ -2132,10 +2110,9 @@ def _static_conv3d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv3d. This method simply wraps the - function, and so the docstring for ivy.conv3d also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.conv3d. This method + simply wraps the function, and so the docstring for ivy.conv3d also + applies to this method with minimal changes. Parameters ---------- @@ -2217,10 +2194,9 @@ def conv3d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conv3d. This method simply wraps - the function, and so the docstring for ivy.conv3d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.conv3d. This method + simply wraps the function, and so the docstring for ivy.conv3d also + applies to this method with minimal changes. Parameters ---------- @@ -2304,10 +2280,9 @@ def _static_conv3d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv3d_transpose. This method simply - wraps the function, and so the docstring for ivy.conv3d_transpose also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.conv3d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv3d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -2402,10 +2377,9 @@ def conv3d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conv3d_transpose. This method - simply wraps the function, and so the docstring for ivy.conv3d_transpose also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.conv3d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv3d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -2527,10 +2501,9 @@ def lstm_update( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.lstm_update. This method simply - wraps the function, and so the docstring for ivy.lstm_update also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.lstm_update. This + method simply wraps the function, and so the docstring for + ivy.lstm_update also applies to this method with minimal changes. Parameters ---------- @@ -2633,10 +2606,9 @@ def reduce_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.reduce_window. This method simply - wraps the function, and so the docstring for ivy.reduce_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.reduce_window. This + method simply wraps the function, and so the docstring for + ivy.reduce_window also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/linear_algebra.py b/ivy/data_classes/container/linear_algebra.py index 20a30dc92b22e..464b7be1fff7e 100644 --- a/ivy/data_classes/container/linear_algebra.py +++ b/ivy/data_classes/container/linear_algebra.py @@ -30,10 +30,9 @@ def _static_matmul( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.matmul. This method simply wraps the - function, and so the docstring for ivy.matul also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.matmul. This method + simply wraps the function, and so the docstring for ivy.matul also + applies to this method with minimal changes. Parameters ---------- @@ -104,10 +103,9 @@ def matmul( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.matmul. This method simply wraps - the function, and so the docstring for ivy.matmul also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.matmul. This method + simply wraps the function, and so the docstring for ivy.matmul also + applies to this method with minimal changes. Parameters ---------- @@ -174,10 +172,9 @@ def _static_cholesky( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cholesky. This method simply wraps - the function, and so the docstring for ivy.cholesky also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.cholesky. This method + simply wraps the function, and so the docstring for ivy.cholesky also + applies to this method with minimal changes. Parameters ---------- @@ -261,10 +258,9 @@ def cholesky( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cholesky. This method simply wraps - the function, and so the docstring for ivy.cholesky also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cholesky. This method + simply wraps the function, and so the docstring for ivy.cholesky also + applies to this method with minimal changes. Parameters ---------- @@ -336,10 +332,9 @@ def _static_cross( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cross. This method simply wraps the - function, and so the docstring for ivy.cross also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cross. This method simply + wraps the function, and so the docstring for ivy.cross also applies to + this method with minimal changes. Parameters ---------- @@ -422,10 +417,9 @@ def cross( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cross. This method simply wraps the - function, and so the docstring for ivy.cross also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cross. This method + simply wraps the function, and so the docstring for ivy.cross also + applies to this method with minimal changes. Parameters ---------- @@ -545,10 +539,9 @@ def _static_diagonal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.diagonal. This method simply wraps - the function, and so the docstring for ivy.diagonal also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.diagonal. This method + simply wraps the function, and so the docstring for ivy.diagonal also + applies to this method with minimal changes. Parameters ---------- @@ -631,10 +624,9 @@ def diagonal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diagonal. This method simply wraps - the function, and so the docstring for ivy.diagonal also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.diagonal. This method + simply wraps the function, and so the docstring for ivy.diagonal also + applies to this method with minimal changes. Parameters ---------- @@ -737,10 +729,9 @@ def diag( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diag. This method simply wraps the - function, and so the docstring for ivy.diag also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.diag. This method + simply wraps the function, and so the docstring for ivy.diag also + applies to this method with minimal changes. Examples -------- @@ -796,10 +787,9 @@ def eigh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eigh. This method simply wraps the - function, and so the docstring for ivy.eigh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.eigh. This method + simply wraps the function, and so the docstring for ivy.eigh also + applies to this method with minimal changes. Parameters ---------- @@ -868,10 +858,9 @@ def _static_eigvalsh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.eigvalsh. This method simply wraps - the function, and so the docstring for ivy.eigvalsh also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.eigvalsh. This method + simply wraps the function, and so the docstring for ivy.eigvalsh also + applies to this method with minimal changes. Parameters ---------- @@ -938,10 +927,9 @@ def eigvalsh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eigvalsh. This method simply wraps - the function, and so the docstring for ivy.eigvalsh also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.eigvalsh. This method + simply wraps the function, and so the docstring for ivy.eigvalsh also + applies to this method with minimal changes. Parameters ---------- @@ -1006,10 +994,9 @@ def _static_inner( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.inner. This method simply wraps the - function, and so the docstring for ivy.inner also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.inner. This method simply + wraps the function, and so the docstring for ivy.inner also applies to + this method with minimal changes. Return the inner product of two vectors ``x1`` and ``x2``. @@ -1079,10 +1066,9 @@ def inner( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inner. This method simply wraps the - function, and so the docstring for ivy.inner also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.inner. This method + simply wraps the function, and so the docstring for ivy.inner also + applies to this method with minimal changes. Return the inner product of two vectors ``self`` and ``x2``. @@ -1150,10 +1136,9 @@ def _static_inv( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.inv. This method simply wraps the - function, and so the docstring for ivy.inv also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.inv. This method simply + wraps the function, and so the docstring for ivy.inv also applies to + this method with minimal changes. Parameters ---------- @@ -1219,10 +1204,9 @@ def inv( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inv. This method simply wraps the - function, and so the docstring for ivy.inv also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.inv. This method simply + wraps the function, and so the docstring for ivy.inv also applies to + this method with minimal changes. Parameters ---------- @@ -1284,10 +1268,9 @@ def _static_pinv( rtol: Optional[Union[float, Tuple[float], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container special method variant of ivy.pinv. This method simply wraps the - function, and so the docstring for ivy.pinv also applies to this method with - minimal changes. + """ivy.Container special method variant of ivy.pinv. This method simply + wraps the function, and so the docstring for ivy.pinv also applies to + this method with minimal changes. Parameters ---------- @@ -1343,10 +1326,9 @@ def pinv( rtol: Optional[Union[float, Tuple[float], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.pinv. This method simply wraps the - function, and so the docstring for ivy.pinv also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.pinv. This method + simply wraps the function, and so the docstring for ivy.pinv also + applies to this method with minimal changes. Parameters ---------- @@ -1409,10 +1391,9 @@ def _static_matrix_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.matrix_norm. This method simply wraps - the function, and so the docstring for ivy.matrix_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.matrix_norm. This method + simply wraps the function, and so the docstring for ivy.matrix_norm + also applies to this method with minimal changes. Parameters ---------- @@ -1497,10 +1478,9 @@ def matrix_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.matrix_norm. This method simply - wraps the function, and so the docstring for ivy.matrix_norm also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.matrix_norm. This + method simply wraps the function, and so the docstring for + ivy.matrix_norm also applies to this method with minimal changes. Parameters ---------- @@ -1630,10 +1610,9 @@ def _static_matrix_rank( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.matrix_rank. This method returns the - rank (i.e., number of non-zero singular values) of a matrix (or a stack of - matrices). + """ivy.Container static method variant of ivy.matrix_rank. This method + returns the rank (i.e., number of non-zero singular values) of a matrix + (or a stack of matrices). Parameters ---------- @@ -1725,10 +1704,9 @@ def matrix_rank( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.matrix_rank. This method returns - the rank (i.e., number of non-zero singular values) of a matrix (or a stack of - matrices). + """ivy.Container instance method variant of ivy.matrix_rank. This + method returns the rank (i.e., number of non-zero singular values) of a + matrix (or a stack of matrices). Parameters ---------- @@ -1815,8 +1793,7 @@ def _static_matrix_transpose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Transpose a matrix (or a stack of matrices) ``x``. + """Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1872,8 +1849,7 @@ def matrix_transpose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Transpose a matrix (or a stack of matrices) ``x``. + """Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1928,10 +1904,9 @@ def _static_outer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.outer. This method simply wraps the - function, and so the docstring for ivy.outer also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.outer. This method simply + wraps the function, and so the docstring for ivy.outer also applies to + this method with minimal changes. Computes the outer product of two arrays, x1 and x2, by computing the tensor product along the last dimension of both arrays. @@ -2003,8 +1978,7 @@ def outer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Return the outer product of two arrays or containers. + """Return the outer product of two arrays or containers. The instance method implementation of the static method static_outer of the ivy.Container class. It calculates the outer product of two input arrays or @@ -2076,10 +2050,9 @@ def _static_qr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.qr. This method simply wraps the - function, and so the docstring for ivy.qr also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.qr. This method simply + wraps the function, and so the docstring for ivy.qr also applies to + this method with minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -2172,10 +2145,9 @@ def qr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.qr. This method simply wraps the - function, and so the docstring for ivy.qr also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.qr. This method simply + wraps the function, and so the docstring for ivy.qr also applies to + this method with minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -2266,10 +2238,9 @@ def _static_slogdet( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.slogdet. This method simply wraps the - function, and so the docstring for ivy.slogdet also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.slogdet. This method + simply wraps the function, and so the docstring for ivy.slogdet also + applies to this method with minimal changes. Parameters ---------- @@ -2338,10 +2309,9 @@ def slogdet( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.slogdet. This method simply wraps - the function, and so the docstring for ivy.slogdet also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.slogdet. This method + simply wraps the function, and so the docstring for ivy.slogdet also + applies to this method with minimal changes. Parameters ---------- @@ -2458,10 +2428,9 @@ def _static_svd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> Union[ivy.Container, Tuple[ivy.Container, ...]]: - """ - ivy.Container static method variant of ivy.svd. This method simply wraps the - function, and so the docstring for ivy.svd also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.svd. This method simply + wraps the function, and so the docstring for ivy.svd also applies to + this method with minimal changes. Parameters ---------- @@ -2531,10 +2500,9 @@ def svd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.svd. This method simply wraps the - function, and so the docstring for ivy.svd also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.svd. This method simply + wraps the function, and so the docstring for ivy.svd also applies to + this method with minimal changes. Parameters ---------- @@ -2749,9 +2717,9 @@ def _static_trace( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trace. This method Returns the sum - along the specified diagonals of a matrix (or a stack of matrices). + """ivy.Container static method variant of ivy.trace. This method + Returns the sum along the specified diagonals of a matrix (or a stack + of matrices). Parameters ---------- @@ -2842,9 +2810,9 @@ def trace( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.trace. This method Returns the sum - along the specified diagonals of a matrix (or a stack of matrices). + """ivy.Container instance method variant of ivy.trace. This method + Returns the sum along the specified diagonals of a matrix (or a stack + of matrices). Parameters ---------- @@ -2983,10 +2951,9 @@ def _static_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.vector_norm. This method simply wraps - the function, and so the docstring for ivy.vector_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.vector_norm. This method + simply wraps the function, and so the docstring for ivy.vector_norm + also applies to this method with minimal changes. Parameters ---------- @@ -3098,10 +3065,9 @@ def vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.vector_norm. This method simply - wraps the function, and so the docstring for ivy.vector_norm also applies to - this method with minimal changes. + r"""ivy.Container instance method variant of ivy.vector_norm. This + method simply wraps the function, and so the docstring for + ivy.vector_norm also applies to this method with minimal changes. Parameters ---------- @@ -3249,10 +3215,9 @@ def _static_vander( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.vander. This method simply wraps the - function, and so the docstring for ivy.vander also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.vander. This method + simply wraps the function, and so the docstring for ivy.vander also + applies to this method with minimal changes. Parameters ---------- @@ -3317,9 +3282,8 @@ def vander( increasing: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.vander. This method Returns the - Vandermonde matrix of the input array. + """ivy.Container instance method variant of ivy.vander. This method + Returns the Vandermonde matrix of the input array. Parameters ---------- @@ -3384,10 +3348,10 @@ def static_general_inner_product( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.general_inner_product. This method - simply wraps the function, and so the docstring for ivy.general_inner_product - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.general_inner_product. + This method simply wraps the function, and so the docstring for + ivy.general_inner_product also applies to this method with minimal + changes. Parameters ---------- @@ -3456,8 +3420,7 @@ def general_inner_product( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.general_inner_product. + """ivy.Container instance method variant of ivy.general_inner_product. This method simply wraps the function, and so the docstring for ivy.general_inner_product also applies to this method with diff --git a/ivy/data_classes/container/losses.py b/ivy/data_classes/container/losses.py index 4f3b65b47a39f..60dff4e8e4d2a 100644 --- a/ivy/data_classes/container/losses.py +++ b/ivy/data_classes/container/losses.py @@ -22,10 +22,9 @@ def _static_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cross_entropy. This method simply - wraps the function, and so the docstring for ivy.cross_entropy also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.cross_entropy. This + method simply wraps the function, and so the docstring for + ivy.cross_entropy also applies to this method with minimal changes. Parameters ---------- @@ -113,10 +112,9 @@ def cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cross_entropy. This method simply - wraps the function, and so the docstring for ivy.cross_entropy also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.cross_entropy. This + method simply wraps the function, and so the docstring for + ivy.cross_entropy also applies to this method with minimal changes. Parameters ---------- @@ -193,10 +191,10 @@ def _static_binary_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.binary_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.binary_cross_entropy - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.binary_cross_entropy. + This method simply wraps the function, and so the docstring for + ivy.binary_cross_entropy also applies to this method with minimal + changes. Parameters ---------- @@ -295,10 +293,10 @@ def binary_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.binary_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.binary_cross_entropy - also applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.binary_cross_entropy. + This method simply wraps the function, and so the docstring for + ivy.binary_cross_entropy also applies to this method with minimal + changes. Parameters ---------- @@ -384,10 +382,10 @@ def _static_sparse_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sparse_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.sparse_cross_entropy - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.sparse_cross_entropy. + This method simply wraps the function, and so the docstring for + ivy.sparse_cross_entropy also applies to this method with minimal + changes. Parameters ---------- @@ -474,10 +472,10 @@ def sparse_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sparse_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.sparse_cross_entropy - also applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.sparse_cross_entropy. + This method simply wraps the function, and so the docstring for + ivy.sparse_cross_entropy also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/container/manipulation.py b/ivy/data_classes/container/manipulation.py index 8c76a746a66d5..94e1ba3658401 100644 --- a/ivy/data_classes/container/manipulation.py +++ b/ivy/data_classes/container/manipulation.py @@ -32,8 +32,7 @@ def _static_concat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.concat. + """ivy.Container static method variant of ivy.concat. This method simply wraps the function, and so the docstring for ivy.concat also applies to this method with minimal changes. @@ -64,8 +63,7 @@ def concat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.concat. + """ivy.Container instance method variant of ivy.concat. This method simply wraps the function, and so the docstring for ivy.concat also applies to this method with minimal changes. @@ -95,10 +93,9 @@ def _static_expand_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.expand_dims. This method simply wraps - the function, and so the docstring for ivy.expand_dims also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.expand_dims. This method + simply wraps the function, and so the docstring for ivy.expand_dims + also applies to this method with minimal changes. Parameters ---------- @@ -194,10 +191,9 @@ def expand_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.expand_dims. This method simply - wraps the function, and so the docstring for ivy.expand_dims also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.expand_dims. This + method simply wraps the function, and so the docstring for + ivy.expand_dims also applies to this method with minimal changes. Parameters ---------- @@ -266,10 +262,9 @@ def _static_split( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.split. This method simply wraps the - function, and so the docstring for ivy.split also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.split. This method simply + wraps the function, and so the docstring for ivy.split also applies to + this method with minimal changes. Parameters ---------- @@ -349,10 +344,9 @@ def split( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.split. This method simply wraps the - function, and so the docstring for ivy.split also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.split. This method + simply wraps the function, and so the docstring for ivy.split also + applies to this method with minimal changes. Parameters ---------- @@ -429,10 +423,9 @@ def _static_permute_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.permute_dims. This method simply - wraps the function, and so the docstring for ivy.permute_dims also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.permute_dims. This method + simply wraps the function, and so the docstring for ivy.permute_dims + also applies to this method with minimal changes. Parameters ---------- @@ -491,10 +484,9 @@ def permute_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.permute_dims. This method simply - wraps the function, and so the docstring for ivy.permute_dims also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.permute_dims. This + method simply wraps the function, and so the docstring for + ivy.permute_dims also applies to this method with minimal changes. Parameters ---------- @@ -553,10 +545,9 @@ def _static_flip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.flip. This method simply wraps the - function, and so the docstring for ivy.flip also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.flip. This method simply + wraps the function, and so the docstring for ivy.flip also applies to + this method with minimal changes. Parameters ---------- @@ -640,10 +631,9 @@ def flip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.flip. This method simply wraps the - function, and so the docstring for ivy.flip also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.flip. This method + simply wraps the function, and so the docstring for ivy.flip also + applies to this method with minimal changes. Parameters ---------- @@ -729,10 +719,9 @@ def _static_reshape( order: Union[str, ivy.Container] = "C", allowzero: Union[bool, ivy.Container] = True, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.reshape. This method simply wraps the - function, and so the docstring for ivy.reshape also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.reshape. This method + simply wraps the function, and so the docstring for ivy.reshape also + applies to this method with minimal changes. Parameters ---------- @@ -847,10 +836,9 @@ def reshape( allowzero: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.reshape. This method simply wraps - the function, and so the docstring for ivy.reshape also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.reshape. This method + simply wraps the function, and so the docstring for ivy.reshape also + applies to this method with minimal changes. Parameters ---------- @@ -956,10 +944,9 @@ def _static_roll( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.roll. This method simply wraps the - function, and so the docstring for ivy.roll also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.roll. This method simply + wraps the function, and so the docstring for ivy.roll also applies to + this method with minimal changes. Parameters ---------- @@ -1048,10 +1035,9 @@ def roll( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.roll. This method simply wraps the - function, and so the docstring for ivy.roll also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.roll. This method + simply wraps the function, and so the docstring for ivy.roll also + applies to this method with minimal changes. Parameters ---------- @@ -1125,10 +1111,9 @@ def _static_squeeze( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.squeeze. This method simply wraps the - function, and so the docstring for ivy.squeeze also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.squeeze. This method + simply wraps the function, and so the docstring for ivy.squeeze also + applies to this method with minimal changes. Parameters ---------- @@ -1207,10 +1192,9 @@ def squeeze( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.squeeze. This method simply wraps - the function, and so the docstring for ivy.squeeze also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.squeeze. This method + simply wraps the function, and so the docstring for ivy.squeeze also + applies to this method with minimal changes. Parameters ---------- @@ -1293,10 +1277,9 @@ def _static_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.stack also applies to + this method with minimal changes. Parameters ---------- @@ -1390,10 +1373,9 @@ def stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method + simply wraps the function, and so the docstring for ivy.stack also + applies to this method with minimal changes. Parameters ---------- @@ -1465,10 +1447,9 @@ def _static_repeat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.repeat. This method simply wraps the - function, and so the docstring for ivy.repeat also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.repeat. This method + simply wraps the function, and so the docstring for ivy.repeat also + applies to this method with minimal changes. Examples -------- @@ -1504,10 +1485,9 @@ def repeat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.repeat. This method simply wraps - the function, and so the docstring for ivy.repeat also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.repeat. This method + simply wraps the function, and so the docstring for ivy.repeat also + applies to this method with minimal changes. Parameters ---------- @@ -1561,10 +1541,9 @@ def _static_tile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tile. This method simply wraps the - function, and so the docstring for ivy.tile also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tile. This method simply + wraps the function, and so the docstring for ivy.tile also applies to + this method with minimal changes. Parameters ---------- @@ -1617,10 +1596,9 @@ def tile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tile. This method simply wraps the - function, and so the docstring for ivy.tile also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.tile. This method + simply wraps the function, and so the docstring for ivy.tile also + applies to this method with minimal changes. Parameters ---------- @@ -1670,10 +1648,9 @@ def _static_constant_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.constant_pad. This method simply - wraps the function, and so the docstring for ivy.constant_pad also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.constant_pad. This method + simply wraps the function, and so the docstring for ivy.constant_pad + also applies to this method with minimal changes. Parameters ---------- @@ -1729,10 +1706,9 @@ def constant_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.constant_pad. This method simply - wraps the function, and so the docstring for ivy.constant_pad also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.constant_pad. This + method simply wraps the function, and so the docstring for + ivy.constant_pad also applies to this method with minimal changes. Parameters ---------- @@ -1787,10 +1763,9 @@ def _static_zero_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.zero_pad. This method simply wraps - the function, and so the docstring for ivy.zero_pad also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.zero_pad. This method + simply wraps the function, and so the docstring for ivy.zero_pad also + applies to this method with minimal changes. Parameters ---------- @@ -1854,10 +1829,9 @@ def zero_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.zero_pad. This method simply wraps - the function, and so the docstring for ivy.zero_pad also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.zero_pad. This method + simply wraps the function, and so the docstring for ivy.zero_pad also + applies to this method with minimal changes. Parameters ---------- @@ -1923,10 +1897,9 @@ def _static_swapaxes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.swapaxes. This method simply wraps - the function, and so the docstring for ivy.swapaxes also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.swapaxes. This method + simply wraps the function, and so the docstring for ivy.swapaxes also + applies to this method with minimal changes. Parameters ---------- @@ -1992,10 +1965,9 @@ def swapaxes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.swapaxes. This method simply wraps - the function, and so the docstring for ivy.swapaxes also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.swapaxes. This method + simply wraps the function, and so the docstring for ivy.swapaxes also + applies to this method with minimal changes. Parameters ---------- @@ -2062,10 +2034,9 @@ def _static_unstack( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unstack. This method simply wraps the - function, and so the docstring for ivy.unstack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.unstack. This method + simply wraps the function, and so the docstring for ivy.unstack also + applies to this method with minimal changes. Parameters ---------- @@ -2160,10 +2131,9 @@ def unstack( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unstack. This method simply wraps - the function, and so the docstring for ivy.unstack also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.unstack. This method + simply wraps the function, and so the docstring for ivy.unstack also + applies to this method with minimal changes. Parameters ---------- @@ -2244,10 +2214,9 @@ def _static_clip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.clip. This method simply wraps the - function, and so the docstring for ivy.clip also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.clip. This method simply + wraps the function, and so the docstring for ivy.clip also applies to + this method with minimal changes. Parameters ---------- @@ -2332,10 +2301,9 @@ def clip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.clip. This method simply wraps the - function, and so the docstring for ivy.clip also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.clip. This method + simply wraps the function, and so the docstring for ivy.clip also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/norms.py b/ivy/data_classes/container/norms.py index 948ff38dfbb94..39369ceba4e38 100644 --- a/ivy/data_classes/container/norms.py +++ b/ivy/data_classes/container/norms.py @@ -21,10 +21,9 @@ def layer_norm( new_std: Union[float, ivy.Container] = 1.0, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.layer_norm. This method simply - wraps the function, and so the docstring for ivy.layer_norm also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.layer_norm. This method + simply wraps the function, and so the docstring for ivy.layer_norm also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/random.py b/ivy/data_classes/container/random.py index bb7aa8c69dcc6..2932594f3fc43 100644 --- a/ivy/data_classes/container/random.py +++ b/ivy/data_classes/container/random.py @@ -23,10 +23,9 @@ def _static_random_uniform( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.random_uniform. This method simply - wraps the function, and so the docstring for ivy.random_uniform also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.random_uniform. This + method simply wraps the function, and so the docstring for + ivy.random_uniform also applies to this method with minimal changes. Parameters ---------- @@ -127,10 +126,9 @@ def random_uniform( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.random_uniform. This method simply - wraps the function, and so the docstring for ivy.random_uniform also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.random_uniform. This + method simply wraps the function, and so the docstring for + ivy.random_uniform also applies to this method with minimal changes. Parameters ---------- @@ -314,10 +312,9 @@ def _static_random_normal( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.random_normal. This method simply - wraps the function, and so the docstring for ivy.random_normal also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.random_normal. This + method simply wraps the function, and so the docstring for + ivy.random_normal also applies to this method with minimal changes. Parameters ---------- @@ -416,10 +413,9 @@ def random_normal( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.random_normal. This method simply - wraps the function, and so the docstring for ivy.random_normal also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.random_normal. This + method simply wraps the function, and so the docstring for + ivy.random_normal also applies to this method with minimal changes. Parameters ---------- @@ -604,10 +600,9 @@ def _static_multinomial( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.multinomial. This method simply wraps - the function, and so the docstring for ivy.multinomial also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.multinomial. This method + simply wraps the function, and so the docstring for ivy.multinomial + also applies to this method with minimal changes. Parameters ---------- @@ -679,10 +674,9 @@ def multinomial( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.multinomial. This method simply - wraps the function, and so the docstring for ivy.multinomial also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.multinomial. This + method simply wraps the function, and so the docstring for + ivy.multinomial also applies to this method with minimal changes. Parameters ---------- @@ -753,10 +747,9 @@ def _static_randint( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.randint. This method simply wraps the - function, and so the docstring for ivy.randint also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.randint. This method + simply wraps the function, and so the docstring for ivy.randint also + applies to this method with minimal changes. Parameters ---------- @@ -854,10 +847,9 @@ def randint( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.randint. This method simply wraps - the function, and so the docstring for ivy.randint also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.randint. This method + simply wraps the function, and so the docstring for ivy.randint also + applies to this method with minimal changes. Parameters ---------- @@ -1038,10 +1030,9 @@ def _static_shuffle( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.shuffle. This method simply wraps the - function, and so the docstring for ivy.shuffle also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.shuffle. This method + simply wraps the function, and so the docstring for ivy.shuffle also + applies to this method with minimal changes. Parameters ---------- @@ -1105,10 +1096,9 @@ def shuffle( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.shuffle. This method simply wraps - the function, and so the docstring for ivy.shuffle also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.shuffle. This method + simply wraps the function, and so the docstring for ivy.shuffle also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/searching.py b/ivy/data_classes/container/searching.py index c007d1f67cc8e..d8ceb13e8910c 100644 --- a/ivy/data_classes/container/searching.py +++ b/ivy/data_classes/container/searching.py @@ -20,10 +20,9 @@ def _static_argmax( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.argmax. This method simply wraps the - function, and so the docstring for ivy.argmax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.argmax. This method + simply wraps the function, and so the docstring for ivy.argmax also + applies to this method with minimal changes. Parameters ---------- @@ -81,10 +80,9 @@ def argmax( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.argmax. This method simply wraps - the function, and so the docstring for ivy.argmax also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.argmax. This method + simply wraps the function, and so the docstring for ivy.argmax also + applies to this method with minimal changes. Parameters ---------- @@ -143,10 +141,9 @@ def _static_argmin( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.argmin. This method simply wraps the - function, and so the docstring for ivy.argmin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.argmin. This method + simply wraps the function, and so the docstring for ivy.argmin also + applies to this method with minimal changes. Parameters ---------- @@ -205,10 +202,9 @@ def argmin( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.argmin. This method simply wraps - the function, and so the docstring for ivy.argmin also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.argmin. This method + simply wraps the function, and so the docstring for ivy.argmin also + applies to this method with minimal changes. Parameters ---------- @@ -275,10 +271,9 @@ def _static_nonzero( size: Optional[Union[int, ivy.Container]] = None, fill_value: Union[Number, ivy.Container] = 0, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nonzero. This method simply wraps the - function, and so the docstring for ivy.nonzero also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nonzero. This method + simply wraps the function, and so the docstring for ivy.nonzero also + applies to this method with minimal changes. Parameters ---------- @@ -315,10 +310,9 @@ def nonzero( size: Optional[Union[int, ivy.Container]] = None, fill_value: Union[Number, ivy.Container] = 0, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nonzero. This method simply wraps - the function, and so the docstring for ivy.nonzero also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nonzero. This method + simply wraps the function, and so the docstring for ivy.nonzero also + applies to this method with minimal changes. Parameters ---------- @@ -356,10 +350,9 @@ def _static_where( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.where. This method simply wraps the - function, and so the docstring for ivy.where also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.where. This method simply + wraps the function, and so the docstring for ivy.where also applies to + this method with minimal changes. Parameters ---------- @@ -402,10 +395,9 @@ def where( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.where. This method simply wraps the - function, and so the docstring for ivy.where also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.where. This method + simply wraps the function, and so the docstring for ivy.where also + applies to this method with minimal changes. Parameters ---------- @@ -452,10 +444,9 @@ def _static_argwhere( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.argwhere. This method simply wraps - the function, and so the docstring for ivy.argwhere also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.argwhere. This method + simply wraps the function, and so the docstring for ivy.argwhere also + applies to this method with minimal changes. Parameters ---------- @@ -518,10 +509,9 @@ def argwhere( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container instance method variant of ivy.argwhere. This method simply wraps - the function, and so the docstring for ivy.argwhere also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.argwhere. This method + simply wraps the function, and so the docstring for ivy.argwhere also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/set.py b/ivy/data_classes/container/set.py index e45c0e748ff86..930560637b588 100644 --- a/ivy/data_classes/container/set.py +++ b/ivy/data_classes/container/set.py @@ -19,10 +19,9 @@ def _static_unique_all( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unique_all. This method simply wraps - the function, and so the docstring for ivy.unique_all also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.unique_all. This method + simply wraps the function, and so the docstring for ivy.unique_all also + applies to this method with minimal changes. Parameters ---------- @@ -97,10 +96,9 @@ def unique_all( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_all. This method simply - wraps the function, and so the docstring for ivy.unique_all also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.unique_all. This method + simply wraps the function, and so the docstring for ivy.unique_all also + applies to this method with minimal changes. Parameters ---------- @@ -172,10 +170,9 @@ def _static_unique_counts( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unique_counts. This method simply - wraps the function, and so the docstring for ivy.unique_counts also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.unique_counts. This + method simply wraps the function, and so the docstring for + ivy.unique_counts also applies to this method with minimal changes. Parameters ---------- @@ -236,10 +233,9 @@ def unique_counts( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_counts. This method simply - wraps the function, and so the docstring for ivy.unique_counts also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.unique_counts. This + method simply wraps the function, and so the docstring for + ivy.unique_counts also applies to this method with minimal changes. Parameters ---------- @@ -326,9 +322,8 @@ def unique_values( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_values. This method simply - wraps the function and applies it on the container. + """ivy.Container instance method variant of ivy.unique_values. This + method simply wraps the function and applies it on the container. Parameters ---------- @@ -404,10 +399,9 @@ def _static_unique_inverse( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unique_inverse. This method simply - wraps the function, and so the docstring for ivy.unique_inverse also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.unique_inverse. This + method simply wraps the function, and so the docstring for + ivy.unique_inverse also applies to this method with minimal changes. Parameters ---------- @@ -469,10 +463,9 @@ def unique_inverse( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_inverse. This method simply - wraps the function, and so the docstring for ivy.unique_inverse also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.unique_inverse. This + method simply wraps the function, and so the docstring for + ivy.unique_inverse also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/sorting.py b/ivy/data_classes/container/sorting.py index 8b1938b5ad7c8..a6409a5f176c8 100644 --- a/ivy/data_classes/container/sorting.py +++ b/ivy/data_classes/container/sorting.py @@ -24,10 +24,9 @@ def _static_argsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.argsort. This method simply wraps the - function, and so the docstring for ivy.argsort also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.argsort. This method + simply wraps the function, and so the docstring for ivy.argsort also + applies to this method with minimal changes. Parameters ---------- @@ -138,10 +137,9 @@ def argsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.argsort. This method simply wraps - the function, and so the docstring for ivy.argsort also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.argsort. This method + simply wraps the function, and so the docstring for ivy.argsort also + applies to this method with minimal changes. Parameters ---------- @@ -222,10 +220,9 @@ def _static_sort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sort. This method simply wraps the - function, and so the docstring for ivy.sort also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sort. This method simply + wraps the function, and so the docstring for ivy.sort also applies to + this method with minimal changes. Examples -------- @@ -275,10 +272,9 @@ def sort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sort. This method simply wraps the - function, and so the docstring for ivy.sort also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sort. This method + simply wraps the function, and so the docstring for ivy.sort also + applies to this method with minimal changes. Examples -------- @@ -341,10 +337,9 @@ def static_msort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.msort. This method simply wraps the - function, and so the docstring for ivy.msort also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.msort. This method simply + wraps the function, and so the docstring for ivy.msort also applies to + this method with minimal changes. Parameters ---------- @@ -396,10 +391,9 @@ def msort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.msort. This method simply wraps the - function, and so the docstring for ivy.msort also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.msort. This method + simply wraps the function, and so the docstring for ivy.msort also + applies to this method with minimal changes. Parameters ---------- @@ -455,8 +449,7 @@ def _static_searchsorted( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.searchsorted. + """ivy.Container static method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal @@ -492,8 +485,7 @@ def searchsorted( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.searchsorted. + """ivy.Container instance method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal diff --git a/ivy/data_classes/container/statistical.py b/ivy/data_classes/container/statistical.py index 2d527a7a46b09..77ccb6ac0fd23 100644 --- a/ivy/data_classes/container/statistical.py +++ b/ivy/data_classes/container/statistical.py @@ -21,10 +21,9 @@ def min( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.min. This method simply wraps the - function, and so the docstring for ivy.min also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.min. This method simply + wraps the function, and so the docstring for ivy.min also applies to + this method with minimal changes. Parameters ---------- @@ -104,10 +103,9 @@ def max( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.max. This method simply wraps the - function, and so the docstring for ivy.max also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.max. This method simply + wraps the function, and so the docstring for ivy.max also applies to + this method with minimal changes. Parameters ---------- @@ -184,10 +182,9 @@ def mean( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.mean. This method simply wraps the - function, and so the docstring for ivy.mean also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.mean. This method + simply wraps the function, and so the docstring for ivy.mean also + applies to this method with minimal changes. Parameters ---------- @@ -319,10 +316,9 @@ def var( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.var. This method simply wraps the - function, and so the docstring for ivy.var also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.var. This method simply + wraps the function, and so the docstring for ivy.var also applies to + this method with minimal changes. Parameters ---------- @@ -437,10 +433,9 @@ def _static_var( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.var. This method simply wraps the - function, and so the docstring for ivy.var also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.var. This method simply + wraps the function, and so the docstring for ivy.var also applies to + this method with minimal changes. Parameters ---------- @@ -509,10 +504,9 @@ def _static_prod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.prod. This method simply wraps the - function, and so the docstring for ivy.prod also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.prod. This method simply + wraps the function, and so the docstring for ivy.prod also applies to + this method with minimal changes. Parameters ---------- @@ -648,10 +642,9 @@ def prod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.prod. This method simply wraps the - function, and so the docstring for ivy.prod also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.prod. This method + simply wraps the function, and so the docstring for ivy.prod also + applies to this method with minimal changes. Parameters ---------- @@ -840,10 +833,9 @@ def std( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.std. This method simply wraps the - function, and so the docstring for ivy.std also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.std. This method simply + wraps the function, and so the docstring for ivy.std also applies to + this method with minimal changes. Parameters ---------- @@ -990,10 +982,9 @@ def _static_cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cumsum. This method simply wraps the - function, and so the docstring for ivy.cumsum also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cumsum. This method + simply wraps the function, and so the docstring for ivy.cumsum also + applies to this method with minimal changes. Parameters ---------- @@ -1132,10 +1123,9 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cumsum. This method simply wraps - the function, and so the docstring for ivy.cumsum also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cumsum. This method + simply wraps the function, and so the docstring for ivy.cumsum also + applies to this method with minimal changes. Parameters ---------- @@ -1289,10 +1279,9 @@ def _static_cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cumprod. This method simply wraps the - function, and so the docstring for ivy.cumprod also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cumprod. This method + simply wraps the function, and so the docstring for ivy.cumprod also + applies to this method with minimal changes. Parameters ---------- @@ -1381,10 +1370,9 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cumprod. This method simply wraps - the function, and so the docstring for ivy.cumprod also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cumprod. This method + simply wraps the function, and so the docstring for ivy.cumprod also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/utility.py b/ivy/data_classes/container/utility.py index d6298db810436..4be1c16810d91 100644 --- a/ivy/data_classes/container/utility.py +++ b/ivy/data_classes/container/utility.py @@ -23,10 +23,9 @@ def _static_all( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.all. This method simply wraps the - function, and so the docstring for ivy.all also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.all. This method simply + wraps the function, and so the docstring for ivy.all also applies to + this method with minimal changes. Parameters ---------- @@ -108,10 +107,9 @@ def all( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.all. This method simply wraps the - function, and so the docstring for ivy.all also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.all. This method simply + wraps the function, and so the docstring for ivy.all also applies to + this method with minimal changes. Parameters ---------- @@ -193,10 +191,9 @@ def _static_any( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.any. This method simply wraps the - function, and so the docstring for ivy.any also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.any. This method simply + wraps the function, and so the docstring for ivy.any also applies to + this method with minimal changes. Parameters ---------- @@ -278,10 +275,9 @@ def any( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.any. This method simply wraps the - function, and so the docstring for ivy.any also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.any. This method simply + wraps the function, and so the docstring for ivy.any also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/wrapping.py b/ivy/data_classes/container/wrapping.py index c4c500cb8e04b..8bbb2b30b5809 100644 --- a/ivy/data_classes/container/wrapping.py +++ b/ivy/data_classes/container/wrapping.py @@ -9,8 +9,7 @@ def _wrap_function(function_name: str, static: bool) -> Callable: - """ - Wrap the function called `function_name`. + """Wrap the function called `function_name`. Parameters ---------- @@ -83,9 +82,8 @@ def add_ivy_container_instance_methods( static: Union[bool, ivy.Container] = False, to_ignore: Union[Iterable, ivy.Container] = (), ): - """ - Loop over all ivy modules such as activations, general, etc. and add the module - functions to ivy container as instance methods using _wrap_function. + """Loop over all ivy modules such as activations, general, etc. and add the + module functions to ivy container as instance methods using _wrap_function. Parameters ---------- diff --git a/ivy/data_classes/factorized_tensor/cp_tensor.py b/ivy/data_classes/factorized_tensor/cp_tensor.py index 72d72d7242641..9d1e9b060a917 100644 --- a/ivy/data_classes/factorized_tensor/cp_tensor.py +++ b/ivy/data_classes/factorized_tensor/cp_tensor.py @@ -76,8 +76,8 @@ def cp_copy(self): ) def mode_dot(self, matrix_or_vector, mode, keep_dim=False, copy=True): - """ - N-mode product of a CP tensor and a matrix or vector at the specified mode. + """N-mode product of a CP tensor and a matrix or vector at the + specified mode. Parameters ---------- @@ -107,8 +107,7 @@ def mode_dot(self, matrix_or_vector, mode, keep_dim=False, copy=True): ) def norm(self): - """ - Return the l2 norm of a CP tensor. + """Return the l2 norm of a CP tensor. Parameters ---------- @@ -130,8 +129,7 @@ def norm(self): return ivy.CPTensor.cp_norm(self) def normalize(self, inplace=True): - """ - Normalize the factors to unit length. + """Normalize the factors to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are normalized to unit Euclidean length @@ -179,8 +177,7 @@ def n_param(self): # ---------------# @staticmethod def validate_cp_tensor(cp_tensor): - """ - Validate a cp_tensor in the form (weights, factors) + """Validate a cp_tensor in the form (weights, factors) Return the rank and shape of the validated tensor @@ -239,9 +236,8 @@ def validate_cp_tensor(cp_tensor): @staticmethod def cp_n_param(tensor_shape, rank, weights=False): - """ - Return number of parameters of a CP decomposition for a given `rank` and full - `tensor_shape`. + """Return number of parameters of a CP decomposition for a given `rank` + and full `tensor_shape`. Parameters ---------- @@ -264,8 +260,7 @@ def cp_n_param(tensor_shape, rank, weights=False): @staticmethod def validate_cp_rank(tensor_shape, rank="same", rounding="round"): - """ - Return the rank of a CP Decomposition. + """Return the rank of a CP Decomposition. Parameters ---------- @@ -308,8 +303,7 @@ def validate_cp_rank(tensor_shape, rank="same", rounding="round"): @staticmethod def cp_normalize(cp_tensor): - """ - Return cp_tensor with factors normalised to unit length. + """Return cp_tensor with factors normalised to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are @@ -357,10 +351,10 @@ def cp_normalize(cp_tensor): @staticmethod def cp_flip_sign(cp_tensor, mode=0, func=None): - """ - Return cp_tensor with factors flipped to have positive signs. The sign of a - given column is determined by `func`, which is the mean by default. Any negative - signs are assigned to the mode indicated by `mode`. + """Return cp_tensor with factors flipped to have positive signs. The + sign of a given column is determined by `func`, which is the mean by + default. Any negative signs are assigned to the mode indicated by + `mode`. Parameters ---------- @@ -412,8 +406,7 @@ def cp_flip_sign(cp_tensor, mode=0, func=None): @staticmethod def cp_lstsq_grad(cp_tensor, tensor, return_loss=False, mask=None): - r""" - Compute (for a third-order tensor) + r"""Compute (for a third-order tensor) .. math:: @@ -474,8 +467,7 @@ def cp_lstsq_grad(cp_tensor, tensor, return_loss=False, mask=None): @staticmethod def cp_to_tensor(cp_tensor, mask=None): - """ - Turn the Khatri-product of matrices into a full tensor. + """Turn the Khatri-product of matrices into a full tensor. ``factor_matrices = [|U_1, ... U_n|]`` becomes a tensor shape ``(U[1].shape[0], U[2].shape[0], ... U[-1].shape[0])`` @@ -532,8 +524,7 @@ def cp_to_tensor(cp_tensor, mask=None): @staticmethod def cp_to_unfolded(cp_tensor, mode): - """ - Turn the khatri-product of matrices into an unfolded tensor. + """Turn the khatri-product of matrices into an unfolded tensor. turns ``factors = [|U_1, ... U_n|]`` into a mode-`mode` unfolding of the tensor @@ -573,8 +564,7 @@ def cp_to_unfolded(cp_tensor, mode): @staticmethod def cp_to_vec(cp_tensor): - """ - Turn the khatri-product of matrices into a vector. + """Turn the khatri-product of matrices into a vector. (the tensor ``factors = [|U_1, ... U_n|]`` is converted into a raveled mode-0 unfolding) @@ -599,8 +589,8 @@ def cp_to_vec(cp_tensor): @staticmethod def cp_mode_dot(cp_tensor, matrix_or_vector, mode, keep_dim=False, copy=False): - """ - N-mode product of a CP tensor and a matrix or vector at the specified mode. + """N-mode product of a CP tensor and a matrix or vector at the + specified mode. Parameters ---------- @@ -671,8 +661,7 @@ def cp_mode_dot(cp_tensor, matrix_or_vector, mode, keep_dim=False, copy=False): @staticmethod def cp_norm(cp_tensor): - """ - Return the l2 norm of a CP tensor. + """Return the l2 norm of a CP tensor. Parameters ---------- @@ -764,8 +753,7 @@ def cp_norm(cp_tensor): @staticmethod def unfolding_dot_khatri_rao(x, cp_tensor, mode): - """ - Mode-n unfolding times khatri-rao product of factors. + """Mode-n unfolding times khatri-rao product of factors. Parameters ---------- diff --git a/ivy/data_classes/factorized_tensor/parafac2_tensor.py b/ivy/data_classes/factorized_tensor/parafac2_tensor.py index 64b23361119cb..391467f6fb15f 100644 --- a/ivy/data_classes/factorized_tensor/parafac2_tensor.py +++ b/ivy/data_classes/factorized_tensor/parafac2_tensor.py @@ -90,8 +90,7 @@ def n_param(self): @classmethod def from_CPTensor(cls, cp_tensor, parafac2_tensor_ok=False): - """ - Create a Parafac2Tensor from a CPTensor. + """Create a Parafac2Tensor from a CPTensor. Parameters ---------- @@ -124,9 +123,8 @@ def from_CPTensor(cls, cp_tensor, parafac2_tensor_ok=False): # ---------------# @staticmethod def validate_parafac2_tensor(parafac2_tensor): - """ - Validate a parafac2_tensor in the form (weights, factors) Return the rank and - shape of the validated tensor. + """Validate a parafac2_tensor in the form (weights, factors) Return the + rank and shape of the validated tensor. Parameters ---------- @@ -210,8 +208,7 @@ def validate_parafac2_tensor(parafac2_tensor): @staticmethod def parafac2_normalise(parafac2_tensor): - """ - Return parafac2_tensor with factors normalised to unit length. + """Return parafac2_tensor with factors normalised to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are normalized to unit Euclidean length @@ -267,8 +264,7 @@ def parafac2_normalise(parafac2_tensor): @staticmethod def apply_parafac2_projections(parafac2_tensor): - """ - Apply the projection matrices to the evolving factor. + """Apply the projection matrices to the evolving factor. Parameters ---------- @@ -297,8 +293,8 @@ def apply_parafac2_projections(parafac2_tensor): @staticmethod def parafac2_to_slice(parafac2_tensor, slice_idx, validate=True): - """ - Generate a single slice along the first mode from the PARAFAC2 tensor. + """Generate a single slice along the first mode from the PARAFAC2 + tensor. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -362,8 +358,7 @@ def parafac2_to_slice(parafac2_tensor, slice_idx, validate=True): @staticmethod def parafac2_to_slices(parafac2_tensor, validate=True): - """ - Generate all slices along the first mode from a PARAFAC2 tensor. + """Generate all slices along the first mode from a PARAFAC2 tensor. Generates a list of all slices from a PARAFAC2 tensor. A list is returned since the tensor might have varying size along the second mode. To return @@ -432,8 +427,7 @@ def parafac2_to_slices(parafac2_tensor, validate=True): @staticmethod def parafac2_to_tensor(parafac2_tensor): - """ - Construct a full tensor from a PARAFAC2 decomposition. + """Construct a full tensor from a PARAFAC2 decomposition. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -494,9 +488,8 @@ def parafac2_to_tensor(parafac2_tensor): @staticmethod def parafac2_to_unfolded(parafac2_tensor, mode): - """ - Construct an unfolded tensor from a PARAFAC2 decomposition. Uneven slices are - padded by zeros. + """Construct an unfolded tensor from a PARAFAC2 decomposition. Uneven + slices are padded by zeros. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -547,9 +540,8 @@ def parafac2_to_unfolded(parafac2_tensor, mode): @staticmethod def parafac2_to_vec(parafac2_tensor): - """ - Construct a vectorized tensor from a PARAFAC2 decomposition. Uneven slices are - padded by zeros. + """Construct a vectorized tensor from a PARAFAC2 decomposition. Uneven + slices are padded by zeros. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by diff --git a/ivy/data_classes/factorized_tensor/tt_tensor.py b/ivy/data_classes/factorized_tensor/tt_tensor.py index 176f3b1fb5b23..783fa8e6d6f15 100644 --- a/ivy/data_classes/factorized_tensor/tt_tensor.py +++ b/ivy/data_classes/factorized_tensor/tt_tensor.py @@ -106,8 +106,7 @@ def validate_tt_tensor(tt_tensor): @staticmethod def tt_to_tensor(factors): - """ - Return the full tensor whose TT decomposition is given by 'factors'. + """Return the full tensor whose TT decomposition is given by 'factors'. Re-assembles 'factors', which represent a tensor in TT/Matrix-Product-State format # noqa: E501 into the corresponding full tensor @@ -138,8 +137,8 @@ def tt_to_tensor(factors): @staticmethod def tt_to_unfolded(factors, mode): - """ - Return the unfolding matrix of a tensor given in TT (or Tensor- Train) format. + """Return the unfolding matrix of a tensor given in TT (or Tensor- + Train) format. Reassembles a full tensor from 'factors' and returns its unfolding matrix with mode given by 'mode' @@ -160,9 +159,8 @@ def tt_to_unfolded(factors, mode): @staticmethod def tt_to_vec(factors): - """ - Return the tensor defined by its TT format ('factors') into its vectorized - format. + """Return the tensor defined by its TT format ('factors') into its + vectorized format. Parameters ---------- @@ -178,9 +176,8 @@ def tt_to_vec(factors): @staticmethod def _tt_n_param(tensor_shape, rank): - """ - Return the number of parameters of a MPS decomposition for a given `rank` and - full `tensor_shape`. + """Return the number of parameters of a MPS decomposition for a given + `rank` and full `tensor_shape`. Parameters ---------- @@ -208,8 +205,7 @@ def validate_tt_rank( rounding="round", allow_overparametrization=True, ): - """ - Return the rank of a TT Decomposition. + """Return the rank of a TT Decomposition. Parameters ---------- @@ -333,9 +329,8 @@ def validate_tt_rank( @staticmethod def pad_tt_rank(factor_list, n_padding=1, pad_boundaries=False): - """ - Pad the factors of a Tensor-Train so as to increase its rank without changing - its reconstruction. + """Pad the factors of a Tensor-Train so as to increase its rank without + changing its reconstruction. The tensor-train (ring) will be padded with 0s to increase its rank only but not the underlying tensor it represents. diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index 3083fb7978c08..69988981f00ab 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -223,8 +223,7 @@ def _build_view(original, view, fn, args, kwargs, index=None): def _check_in_nested_sequence(sequence, value=None, _type=None): - """ - Check `sequence` for either a `value` or a value of type `_type`. + """Check `sequence` for either a `value` or a value of type `_type`. Helper to recursively check if a N-level nested `sequence` contains either a `value` or contains a value of type `_type` and return a @@ -264,8 +263,7 @@ def _get_preferred_device(args, kwargs): def handle_array_function(fn): - """ - Wrap a function `fn` to be passed to array_function method. + """Wrap a function `fn` to be passed to array_function method. Wrap a function to extract the relevant argument types to be passed to array_function method. @@ -376,10 +374,9 @@ def _handle_array_like_without_promotion(*args, **kwargs): def inputs_to_native_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_native_arrays(*args, **kwargs): - """ - Convert all `ivy.Array` instances in both the positional and keyword arguments - into `ivy.NativeArray` instances, and then calls the function with the updated - arguments. + """Convert all `ivy.Array` instances in both the positional and keyword + arguments into `ivy.NativeArray` instances, and then calls the function + with the updated arguments. Parameters ---------- @@ -416,10 +413,9 @@ def _inputs_to_native_arrays(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays(*args, **kwargs): - """ - Convert all `ivy.NativeArray` instances in both the positional and keyword - arguments into `ivy.Array` instances, and then calls the function with the - updated arguments. + """Convert all `ivy.NativeArray` instances in both the positional and + keyword arguments into `ivy.Array` instances, and then calls the + function with the updated arguments. Parameters ---------- @@ -483,8 +479,7 @@ def _outputs_to_ivy_shapes(*args, **kwargs): def to_native_shapes_and_back(fn: Callable) -> Callable: - """ - Make `fn` receive `ivy.NativeShape` and return `ivy.Shape`. + """Make `fn` receive `ivy.NativeShape` and return `ivy.Shape`. Wrap `fn` so that input shapes are all converted to `ivy.NativeShape` instances and return shapes are all converted to @@ -496,9 +491,8 @@ def to_native_shapes_and_back(fn: Callable) -> Callable: def outputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_ivy_arrays(*args, **kwargs): - """ - Call the function, and then converts all `ivy.NativeArray` instances in the - function return into `ivy.Array` instances. + """Call the function, and then converts all `ivy.NativeArray` instances + in the function return into `ivy.Array` instances. Parameters ---------- @@ -526,9 +520,8 @@ def _outputs_to_ivy_arrays(*args, **kwargs): def output_to_native_arrays(fn: Callable) -> Callable: - """ - Call the function, and then converts all `ivy.Array` instances in the function - return into `ivy.NativeArray` instances. + """Call the function, and then converts all `ivy.Array` instances in the + function return into `ivy.NativeArray` instances. Parameters ---------- @@ -553,8 +546,7 @@ def _output_to_native_arrays(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Make `fn` receive `ivy.Array` and return `ivy.NativeArray`. + """Make `fn` receive `ivy.Array` and return `ivy.NativeArray`. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ivy.NativeArray` @@ -564,8 +556,7 @@ def to_ivy_arrays_and_back(fn: Callable) -> Callable: def to_native_arrays_and_back(fn: Callable) -> Callable: - """ - Make `fn` receive `ivy.NativeArray` and return `ivy.Array`. + """Make `fn` receive `ivy.NativeArray` and return `ivy.Array`. Wrap `fn` so that input arrays are all converted to `ivy.NativeArray` instances and return arrays are all converted to @@ -575,8 +566,7 @@ def to_native_arrays_and_back(fn: Callable) -> Callable: def frontend_outputs_to_ivy_arrays(fn: Callable) -> Callable: - """ - Wrap `fn` and convert all frontend arrays in its return to ivy arrays. + """Wrap `fn` and convert all frontend arrays in its return to ivy arrays. Used in cases when a frontend function receives a callable (frontend function) argument. To be able to use that callable in a composition @@ -596,8 +586,7 @@ def _outputs_to_ivy_arrays(*args, **kwargs): def handle_view(fn: Callable) -> Callable: - """ - Wrap `fn` and performs view handling if copy is False. + """Wrap `fn` and performs view handling if copy is False. Used for functional backends (Jax and TensorFlow). Checks if the first arg is a view or original array by checking if the ._base @@ -628,8 +617,7 @@ def _handle_view(*args, **kwargs): def handle_view_indexing(fn: Callable) -> Callable: - """ - Wrap `fn` and performs view handling specifically for indexing. + """Wrap `fn` and performs view handling specifically for indexing. As with NumPy it returns a copy if advanced indexing is performed. Used for functional backends (Jax and TensorFlow). Checks if the @@ -672,8 +660,8 @@ def _convert_numpy_arrays_to_backend_specific(*args): def handle_numpy_arrays_in_specific_backend(fn: Callable) -> Callable: - """ - Wrap `fn` and converts all `numpy.ndarray` inputs to `torch.Tensor` instances. + """Wrap `fn` and converts all `numpy.ndarray` inputs to `torch.Tensor` + instances. Used for functional backends (PyTorch). Converts all `numpy.ndarray` inputs to `torch.Tensor` instances. @@ -696,9 +684,8 @@ def _handle_numpy_array_in_torch(*args, **kwargs): def infer_dtype(fn: Callable) -> Callable: @functools.wraps(fn) def _infer_dtype(*args, dtype=None, **kwargs): - """ - Determine the correct `dtype`, and then calls the function with the `dtype` - passed explicitly. + """Determine the correct `dtype`, and then calls the function with the + `dtype` passed explicitly. Parameters ---------- @@ -734,8 +721,7 @@ def _infer_dtype(*args, dtype=None, **kwargs): def handle_device(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_device(*args, **kwargs): - """ - Move all array inputs of the function to `ivy.default_device()`. + """Move all array inputs of the function to `ivy.default_device()`. Parameters ---------- @@ -789,9 +775,8 @@ def handle_out_argument(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_out_argument(*args, out=None, **kwargs): - """ - Call `fn` with the `out` argument handled correctly for performing an inplace - update. + """Call `fn` with the `out` argument handled correctly for performing + an inplace update. Parameters ---------- @@ -883,10 +868,9 @@ def handle_nestable(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_nestable(*args, **kwargs): - """ - Call `fn` with the *nestable* property of the function correctly handled. This - means mapping the function to the container leaves if any containers are passed - in the input. + """Call `fn` with the *nestable* property of the function correctly + handled. This means mapping the function to the container leaves if any + containers are passed in the input. Parameters ---------- @@ -927,10 +911,9 @@ def cont_fn(*args, **kwargs): def handle_ragged(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_ragged(*args, **kwargs): - """ - Call `fn` with the *ragged* property of the function correctly handled. This - means mapping the function to the RaggedArray arrays if any RaggedArrays are - passed in the input. + """Call `fn` with the *ragged* property of the function correctly + handled. This means mapping the function to the RaggedArray arrays if + any RaggedArrays are passed in the input. Parameters ---------- @@ -988,8 +971,7 @@ def _handle_partial_mixed_function(*args, **kwargs): def temp_asarray_wrapper(fn: Callable) -> Callable: @functools.wraps(fn) def _temp_asarray_wrapper(*args, **kwargs): - """ - Convert `Tensor` into `ivy.Array` instances. + """Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -1022,12 +1004,11 @@ def _to_ivy_array(x): def _wrap_function( key: str, to_wrap: Callable, original: Callable, compositional: bool = False ) -> Callable: - """ - Apply wrapping to backend implementation `to_wrap` if the original implementation - `original` is also wrapped, and if `to_wrap` is not already wrapped. Attributes - `handle_nestable` etc are set during wrapping, hence indicate to us whether a - certain function has been wrapped or not. Also handles wrapping of the `linalg` - namespace. + """Apply wrapping to backend implementation `to_wrap` if the original + implementation `original` is also wrapped, and if `to_wrap` is not already + wrapped. Attributes `handle_nestable` etc are set during wrapping, hence + indicate to us whether a certain function has been wrapped or not. Also + handles wrapping of the `linalg` namespace. Parameters ---------- @@ -1228,8 +1209,8 @@ def _dtype_from_version(dic, version): def _versioned_attribute_factory(attribute_function, base): class VersionedAttributes(base): - """ - Class which add versioned attributes to a class, inheriting from `base`. + """Class which add versioned attributes to a class, inheriting from + `base`. Create a class which inherits `base` this way if isinstance is called on an instance of the class, it will return True if @@ -1258,8 +1239,7 @@ def __bool__(self): def _dtype_device_wrapper_creator(attrib, t): - """ - Create a wrapper for a dtype or device attribute. + """Create a wrapper for a dtype or device attribute. The wrapper returns the correct dtype or device for the current version of the backend. @@ -1359,8 +1339,8 @@ def _nest_has_nans(x): def handle_nans(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_nans(*args, **kwargs): - """ - Check for the existence of nans in all arrays in the `args` and `kwargs`. + """Check for the existence of nans in all arrays in the `args` and + `kwargs`. The presence of nans is then handled depending on the enabled `nan_policy`. @@ -1414,9 +1394,8 @@ def _handle_complex_input( complex_mode: Literal["split", "magnitude", "jax"] = "jax", **kwargs, ): - """ - Check whether the first positional argument is an array of complex type, and if - so handle it according to the provided `complex_mode`. + """Check whether the first positional argument is an array of complex + type, and if so handle it according to the provided `complex_mode`. The options are: `"jax"` (default): emulate the behaviour of the JAX framework. If the function @@ -1543,10 +1522,9 @@ def _handle_complex_input( def handle_backend_invalid(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_backend_invalid(*args, **kwargs): - """ - Check if any of the arguments (or nested arguments) passed to the function are - instances of ivy.Array or ivy.NativeArray. If so, it returns the function. If - not, it raises an InvalidBackendException. + """Check if any of the arguments (or nested arguments) passed to the + function are instances of ivy.Array or ivy.NativeArray. If so, it + returns the function. If not, it raises an InvalidBackendException. Parameters ---------- diff --git a/ivy/functional/backends/jax/activations.py b/ivy/functional/backends/jax/activations.py index 1120af0466f64..08f4f42c88ebf 100644 --- a/ivy/functional/backends/jax/activations.py +++ b/ivy/functional/backends/jax/activations.py @@ -1,4 +1,5 @@ -"""Collection of Jax activation functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax activation functions, wrapped to fit Ivy syntax and +signature.""" # global diff --git a/ivy/functional/backends/jax/device.py b/ivy/functional/backends/jax/device.py index e12164e617440..f21d9aa0cb66a 100644 --- a/ivy/functional/backends/jax/device.py +++ b/ivy/functional/backends/jax/device.py @@ -1,4 +1,5 @@ -"""Collection of Jax device functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax device functions, wrapped to fit Ivy syntax and +signature.""" # global import os diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index cb9c1edceab73..4bca2a71db150 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -1,4 +1,5 @@ -"""Collection of Jax general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax general functions, wrapped to fit Ivy syntax and +signature.""" # global import jax diff --git a/ivy/functional/backends/jax/gradients.py b/ivy/functional/backends/jax/gradients.py index 13ee80730c2b4..5e96bdd28c101 100644 --- a/ivy/functional/backends/jax/gradients.py +++ b/ivy/functional/backends/jax/gradients.py @@ -1,4 +1,5 @@ -"""Collection of Jax gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax gradient functions, wrapped to fit Ivy syntax and +signature.""" # global import jax diff --git a/ivy/functional/backends/jax/layers.py b/ivy/functional/backends/jax/layers.py index 37bd852c7c3a6..78a72fb2fb85b 100644 --- a/ivy/functional/backends/jax/layers.py +++ b/ivy/functional/backends/jax/layers.py @@ -1,4 +1,5 @@ -"""Collection of Jax network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax network layers, wrapped to fit Ivy syntax and +signature.""" # global import jax.lax as jlax diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index f277860762f4c..2c8ec9ca87f8e 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -1,4 +1,5 @@ -"""Collection of Jax random functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax random functions, wrapped to fit Ivy syntax and +signature.""" # global import jax diff --git a/ivy/functional/backends/mxnet/activations.py b/ivy/functional/backends/mxnet/activations.py index 96bd23c3ca96f..b72a333da33f1 100644 --- a/ivy/functional/backends/mxnet/activations.py +++ b/ivy/functional/backends/mxnet/activations.py @@ -1,5 +1,4 @@ -""" -MXNet activation functions. +"""MXNet activation functions. Collection of MXNet activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/mxnet/device.py b/ivy/functional/backends/mxnet/device.py index ece458d2d7c20..3d07258b4100c 100644 --- a/ivy/functional/backends/mxnet/device.py +++ b/ivy/functional/backends/mxnet/device.py @@ -1,5 +1,4 @@ -""" -MXNet device functions. +"""MXNet device functions. Collection of MXNet general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/mxnet/gradients.py b/ivy/functional/backends/mxnet/gradients.py index 97577e8634e6f..203640b7df2ef 100644 --- a/ivy/functional/backends/mxnet/gradients.py +++ b/ivy/functional/backends/mxnet/gradients.py @@ -1,4 +1,5 @@ -"""Collection of MXNet gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of MXNet gradient functions, wrapped to fit Ivy syntax and +signature.""" # global from typing import Sequence, Union diff --git a/ivy/functional/backends/mxnet/layers.py b/ivy/functional/backends/mxnet/layers.py index 5bb1ed3d5a26f..2450a2555131b 100644 --- a/ivy/functional/backends/mxnet/layers.py +++ b/ivy/functional/backends/mxnet/layers.py @@ -1,4 +1,5 @@ -"""Collection of MXNet network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of MXNet network layers, wrapped to fit Ivy syntax and +signature.""" # global import mxnet as mx diff --git a/ivy/functional/backends/mxnet/random.py b/ivy/functional/backends/mxnet/random.py index 875fc1ce304cb..033a6b26cce5d 100644 --- a/ivy/functional/backends/mxnet/random.py +++ b/ivy/functional/backends/mxnet/random.py @@ -1,5 +1,4 @@ -""" -MXNet random functions. +"""MXNet random functions. Collection of MXNet random functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/numpy/activations.py b/ivy/functional/backends/numpy/activations.py index cb9f698df3d39..714056b4b34c0 100644 --- a/ivy/functional/backends/numpy/activations.py +++ b/ivy/functional/backends/numpy/activations.py @@ -1,4 +1,5 @@ -"""Collection of Numpy activation functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy activation functions, wrapped to fit Ivy syntax and +signature.""" # global from typing import Optional, Union, Literal diff --git a/ivy/functional/backends/numpy/device.py b/ivy/functional/backends/numpy/device.py index d636feb8d8f25..b173e50154f92 100644 --- a/ivy/functional/backends/numpy/device.py +++ b/ivy/functional/backends/numpy/device.py @@ -1,4 +1,5 @@ -"""Collection of Numpy general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy general functions, wrapped to fit Ivy syntax and +signature.""" # global import os diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index 1b80e19a657cf..803e582bbbfaf 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -1,4 +1,5 @@ -"""Collection of Numpy general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy general functions, wrapped to fit Ivy syntax and +signature.""" # global from typing import Optional, Union, Sequence, Callable, Tuple diff --git a/ivy/functional/backends/numpy/gradients.py b/ivy/functional/backends/numpy/gradients.py index 1f930d0ebe687..d6ba1e9b55bd7 100644 --- a/ivy/functional/backends/numpy/gradients.py +++ b/ivy/functional/backends/numpy/gradients.py @@ -1,4 +1,5 @@ -"""Collection of NumPy gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of NumPy gradient functions, wrapped to fit Ivy syntax and +signature.""" # global import logging diff --git a/ivy/functional/backends/numpy/helpers.py b/ivy/functional/backends/numpy/helpers.py index b5ae02d3a09f0..965bb5067baca 100644 --- a/ivy/functional/backends/numpy/helpers.py +++ b/ivy/functional/backends/numpy/helpers.py @@ -4,8 +4,7 @@ def _scalar_output_to_0d_array(function: Callable) -> Callable: - """ - Convert scalar outputs to 0d arrays. + """Convert scalar outputs to 0d arrays. Sometimes NumPy functions return scalars e.g. `np.add` does when the inputs are both 0 dimensional. diff --git a/ivy/functional/backends/numpy/layers.py b/ivy/functional/backends/numpy/layers.py index d6d4ebc27b20a..5fe2e909e5e76 100644 --- a/ivy/functional/backends/numpy/layers.py +++ b/ivy/functional/backends/numpy/layers.py @@ -1,4 +1,5 @@ -"""Collection of Numpy network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy network layers, wrapped to fit Ivy syntax and +signature.""" # global import numpy as np diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index 203e283b1009f..cae6121a75e69 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -1,4 +1,5 @@ -"""Collection of Numpy random functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy random functions, wrapped to fit Ivy syntax and +signature.""" # global import numpy as np diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index 8182b0ef2263a..59c421f43ae6b 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/ivy/functional/backends/paddle/activations.py @@ -1,5 +1,4 @@ -""" -Paddle activation functions. +"""Paddle activation functions. Collection of Paddle activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/paddle/device.py b/ivy/functional/backends/paddle/device.py index 0270ccd9d1d5b..b1120da1d5657 100644 --- a/ivy/functional/backends/paddle/device.py +++ b/ivy/functional/backends/paddle/device.py @@ -1,4 +1,5 @@ -"""Collection of Paddle general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle general functions, wrapped to fit Ivy syntax and +signature.""" # global import os diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index e73890115fa69..866b2124fb281 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -748,8 +748,7 @@ def _EvaluatePolynomial(x, coefficients): def _is_scalar(x): - """ - Determines if the given tensor is a scalar. + """Determines if the given tensor is a scalar. Args: - x (paddle.Tensor): Input tensor. diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 88a2e8c591409..60f32855f4992 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -1,4 +1,5 @@ -"""Collection of Paddle general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle general functions, wrapped to fit Ivy syntax and +signature.""" # global from numbers import Number diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index 349b8218996ad..c39ef078758b1 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -1,4 +1,5 @@ -"""Collection of Paddle gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle gradient functions, wrapped to fit Ivy syntax and +signature.""" # global diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index 4798e13e3f64f..ad78d3d041b50 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -1,4 +1,5 @@ -"""Collection of Paddle network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle network layers, wrapped to fit Ivy syntax and +signature.""" from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/paddle/random.py b/ivy/functional/backends/paddle/random.py index c60fd5e24efea..512954b81ef3f 100644 --- a/ivy/functional/backends/paddle/random.py +++ b/ivy/functional/backends/paddle/random.py @@ -1,4 +1,5 @@ -"""Collection of Paddle random functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle random functions, wrapped to fit Ivy syntax and +signature.""" # global import paddle diff --git a/ivy/functional/backends/tensorflow/activations.py b/ivy/functional/backends/tensorflow/activations.py index 2a9797f11897d..5b757031a48c5 100644 --- a/ivy/functional/backends/tensorflow/activations.py +++ b/ivy/functional/backends/tensorflow/activations.py @@ -1,5 +1,4 @@ -""" -TensorFlow activation functions. +"""TensorFlow activation functions. Collection of TensorFlow activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/device.py b/ivy/functional/backends/tensorflow/device.py index bec64860d54a4..dd7c4cea4f6c9 100644 --- a/ivy/functional/backends/tensorflow/device.py +++ b/ivy/functional/backends/tensorflow/device.py @@ -1,5 +1,4 @@ -""" -Tensorflow device functions. +"""Tensorflow device functions. Collection of TensorFlow general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 7a018f41c9197..70db8f5b6d040 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -1,5 +1,4 @@ -""" -Tensorflow general functions. +"""Tensorflow general functions. Collection of TensorFlow general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/gradients.py b/ivy/functional/backends/tensorflow/gradients.py index d548e21bc7738..da688a2dd71f5 100644 --- a/ivy/functional/backends/tensorflow/gradients.py +++ b/ivy/functional/backends/tensorflow/gradients.py @@ -1,5 +1,4 @@ -""" -Tensorflow gradient functions. +"""Tensorflow gradient functions. Collection of TensorFlow gradient functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index a443e1c1706a3..973c0ec0011cc 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -1,4 +1,5 @@ -"""Collection of TensorFlow network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of TensorFlow network layers, wrapped to fit Ivy syntax and +signature.""" # global from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/tensorflow/random.py b/ivy/functional/backends/tensorflow/random.py index 8488efc1b1d9f..6dcd217c90a22 100644 --- a/ivy/functional/backends/tensorflow/random.py +++ b/ivy/functional/backends/tensorflow/random.py @@ -1,5 +1,4 @@ -""" -TensorFlow random functions. +"""TensorFlow random functions. Collection of TensorFlow random functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py index 50b592d5d9587..edfe28faa07db 100644 --- a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py @@ -118,9 +118,8 @@ def nanmedian( def _nanmedian_helper(input, axis=None, keepdims=False): - """ - The approach to Handle Nans in single dimensional plus multi-dimensional inputs are - composed on two-parts. + """The approach to Handle Nans in single dimensional plus multi-dimensional + inputs are composed on two-parts. PART 1: In this part, you have axis=None, it means we have to work on flattened data, we don't need to work on different axis.there are two cases here diff --git a/ivy/functional/backends/torch/activations.py b/ivy/functional/backends/torch/activations.py index 3e955b8aec7a0..0f67c20f47d5d 100644 --- a/ivy/functional/backends/torch/activations.py +++ b/ivy/functional/backends/torch/activations.py @@ -1,5 +1,4 @@ -""" -PyTorch activation functions. +"""PyTorch activation functions. Collection of PyTorch activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/torch/device.py b/ivy/functional/backends/torch/device.py index 59d35e007d109..4fdfb8ce1c035 100644 --- a/ivy/functional/backends/torch/device.py +++ b/ivy/functional/backends/torch/device.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and +signature.""" import inspect diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 8395caf0efd10..af7bc2d70daa4 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and +signature.""" # global from functools import reduce as _reduce diff --git a/ivy/functional/backends/torch/gradients.py b/ivy/functional/backends/torch/gradients.py index 3434409fa0509..207794f8c4eab 100644 --- a/ivy/functional/backends/torch/gradients.py +++ b/ivy/functional/backends/torch/gradients.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch gradient functions, wrapped to fit Ivy syntax and +signature.""" # global import torch diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index 8b278ebada027..b8490599076be 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch network layers, wrapped to fit Ivy syntax and +signature.""" from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index df83aee7eb286..cdb4c17761cdd 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch random functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch random functions, wrapped to fit Ivy syntax and +signature.""" # global import torch diff --git a/ivy/functional/frontends/jax/numpy/__init__.py b/ivy/functional/frontends/jax/numpy/__init__.py index 6972b2d115109..4b8a28a0a6ed9 100644 --- a/ivy/functional/frontends/jax/numpy/__init__.py +++ b/ivy/functional/frontends/jax/numpy/__init__.py @@ -390,8 +390,8 @@ def promote_types_jax( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -424,9 +424,8 @@ def promote_types_of_jax_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index 92db96fb8a2d2..75f67235c7391 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -345,8 +345,8 @@ def interpolate( def kl_div(logits, labels, reduction="mean"): - """ - Computes the Kullback-Leibler (KL) Divergence between the logits and the labels. + """Computes the Kullback-Leibler (KL) Divergence between the logits and the + labels. Parameters ---------- diff --git a/ivy/functional/frontends/mxnet/func_wrapper.py b/ivy/functional/frontends/mxnet/func_wrapper.py index 434e5755a7f11..6b8880d6f149e 100644 --- a/ivy/functional/frontends/mxnet/func_wrapper.py +++ b/ivy/functional/frontends/mxnet/func_wrapper.py @@ -61,8 +61,7 @@ def _handle_mxnet_out(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_mxnet(*args, **kwargs): - """ - Convert `ndarray.NDArray` into `ivy.Array` instances. + """Convert `ndarray.NDArray` into `ivy.Array` instances. Convert all `ndarray.NDArray` instances in both the positional and keyword arguments into `ivy.Array` instances, and then calls @@ -84,8 +83,7 @@ def _inputs_to_ivy_arrays_mxnet(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_mxnet(*args, **kwargs): - """ - Convert `ivy.Array` into `ndarray.NDArray` instances. + """Convert `ivy.Array` into `ndarray.NDArray` instances. Call the function, and then converts all `ivy.Array` instances in the function return into `ndarray.NDArray` instances. @@ -101,8 +99,7 @@ def _outputs_to_frontend_arrays_mxnet(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray.NDArray` diff --git a/ivy/functional/frontends/mxnet/numpy/__init__.py b/ivy/functional/frontends/mxnet/numpy/__init__.py index a3b0c6fab40a1..1f8fb0f1393f8 100644 --- a/ivy/functional/frontends/mxnet/numpy/__init__.py +++ b/ivy/functional/frontends/mxnet/numpy/__init__.py @@ -104,8 +104,8 @@ def promote_types_mxnet( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -132,9 +132,8 @@ def promote_types_of_mxnet_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/numpy/__init__.py b/ivy/functional/frontends/numpy/__init__.py index 8d2eac7018fd3..9cdf0c1278021 100644 --- a/ivy/functional/frontends/numpy/__init__.py +++ b/ivy/functional/frontends/numpy/__init__.py @@ -435,9 +435,8 @@ def promote_types_of_numpy_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given ivy array inputs to a common dtype based on numpy - type promotion rules. + """Promote the dtype of the given ivy array inputs to a common dtype based + on numpy type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/numpy/func_wrapper.py b/ivy/functional/frontends/numpy/func_wrapper.py index 0c2d35f5801f8..cdfc6aaae6137 100644 --- a/ivy/functional/frontends/numpy/func_wrapper.py +++ b/ivy/functional/frontends/numpy/func_wrapper.py @@ -212,9 +212,9 @@ def _to_ivy_array(x): def from_zero_dim_arrays_to_scalar(fn: Callable) -> Callable: @functools.wraps(fn) def _from_zero_dim_arrays_to_scalar(*args, **kwargs): - """ - Call the function, and then convert all 0 dimensional array instances in the - function to float numbers if out argument is not provided. + """Call the function, and then convert all 0 dimensional array + instances in the function to float numbers if out argument is not + provided. Parameters ---------- @@ -267,8 +267,7 @@ def _from_zero_dim_arrays_to_scalar(*args, **kwargs): def handle_numpy_casting(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_numpy_casting(*args, casting="same_kind", dtype=None, **kwargs): - """ - Check numpy casting type. + """Check numpy casting type. Parameters ---------- @@ -329,8 +328,8 @@ def _handle_numpy_casting(*args, casting="same_kind", dtype=None, **kwargs): def handle_numpy_casting_special(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_numpy_casting_special(*args, casting="same_kind", dtype=None, **kwargs): - """ - Check numpy casting type for special cases where output must be type bool. + """Check numpy casting type for special cases where output must be type + bool. Parameters ---------- @@ -418,10 +417,9 @@ def _handle_numpy_out(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_np(*args, **kwargs): - """ - Convert all `ndarray` instances in both the positional and keyword arguments - into `ivy.Array` instances, and then call the function with the updated - arguments. + """Convert all `ndarray` instances in both the positional and keyword + arguments into `ivy.Array` instances, and then call the function with + the updated arguments. Parameters ---------- @@ -448,9 +446,8 @@ def _inputs_to_ivy_arrays_np(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays(*args, order="K", **kwargs): - """ - Call the function, and then convert all `ivy.Array` instances returned by the - function into `ndarray` instances. + """Call the function, and then convert all `ivy.Array` instances + returned by the function into `ndarray` instances. Returns ------- @@ -512,8 +509,7 @@ def _outputs_to_frontend_arrays(*args, order="K", **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray` instances. diff --git a/ivy/functional/frontends/numpy/statistics/order_statistics.py b/ivy/functional/frontends/numpy/statistics/order_statistics.py index 1484182c4f62a..63209ffe912fa 100644 --- a/ivy/functional/frontends/numpy/statistics/order_statistics.py +++ b/ivy/functional/frontends/numpy/statistics/order_statistics.py @@ -11,8 +11,7 @@ def _cpercentile(N, percent, key=lambda x: x): - """ - Find the percentile of a list of values. + """Find the percentile of a list of values. @parameter N - is a list of values. Note N MUST BE already sorted. @parameter percent - a float value from 0.0 to 1.0. diff --git a/ivy/functional/frontends/onnx/__init__.py b/ivy/functional/frontends/onnx/__init__.py index 0c0b59d24c907..46a5fb5daad61 100644 --- a/ivy/functional/frontends/onnx/__init__.py +++ b/ivy/functional/frontends/onnx/__init__.py @@ -191,8 +191,8 @@ def promote_types_onnx( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -219,9 +219,8 @@ def promote_types_of_onnx_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/onnx/func_wrapper.py b/ivy/functional/frontends/onnx/func_wrapper.py index fb60b19615381..2bd6adaa3cb1e 100644 --- a/ivy/functional/frontends/onnx/func_wrapper.py +++ b/ivy/functional/frontends/onnx/func_wrapper.py @@ -49,8 +49,7 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_onnx(*args, **kwargs): - """ - Convert `Tensor` into `ivy.Array` instances. + """Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then calls the @@ -71,8 +70,7 @@ def _inputs_to_ivy_arrays_onnx(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_onnx(*args, **kwargs): - """ - Convert `ivy.Array` into `Tensor` instances. + """Convert `ivy.Array` into `Tensor` instances. Call the function, and then converts all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -89,8 +87,7 @@ def _outputs_to_frontend_arrays_onnx(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray.NDArray` diff --git a/ivy/functional/frontends/paddle/__init__.py b/ivy/functional/frontends/paddle/__init__.py index be293ee475839..58ae61580f139 100644 --- a/ivy/functional/frontends/paddle/__init__.py +++ b/ivy/functional/frontends/paddle/__init__.py @@ -156,8 +156,8 @@ def promote_types_paddle( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -184,9 +184,8 @@ def promote_types_of_paddle_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 5ea418f5153e6..bc72bd9aa7df1 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -97,8 +97,8 @@ def fftshift(x, axes=None, name=None): ) @to_ivy_arrays_and_back def hfft(x, n=None, axes=-1, norm="backward", name=None): - """Compute the FFT of a signal that has Hermitian symmetry, resulting in a real - spectrum.""" + """Compute the FFT of a signal that has Hermitian symmetry, resulting in a + real spectrum.""" # Determine the input shape and axis length input_shape = x.shape input_len = input_shape[axes] diff --git a/ivy/functional/frontends/paddle/func_wrapper.py b/ivy/functional/frontends/paddle/func_wrapper.py index c8c9e13acb0e0..4bc7db1821eb0 100644 --- a/ivy/functional/frontends/paddle/func_wrapper.py +++ b/ivy/functional/frontends/paddle/func_wrapper.py @@ -41,8 +41,7 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def new_fn(*args, **kwargs): - """ - Convert `Tensor` into `ivy.Array` instances. + """Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -64,8 +63,7 @@ def new_fn(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def new_fn(*args, **kwargs): - """ - Convert `ivy.Array` into `Tensor` instances. + """Convert `ivy.Array` into `Tensor` instances. Call the function, and then convert all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -89,8 +87,7 @@ def new_fn(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `Tensor` instances. diff --git a/ivy/functional/frontends/tensorflow/__init__.py b/ivy/functional/frontends/tensorflow/__init__.py index 8f41d31818161..fb8077c3672b7 100644 --- a/ivy/functional/frontends/tensorflow/__init__.py +++ b/ivy/functional/frontends/tensorflow/__init__.py @@ -53,10 +53,9 @@ @handle_exceptions def check_tensorflow_casting(x1, x2): - """ - Check whether the two arguments provided in the function have the same dtype, unless - one of them is an array_like or scalar, where it gets casted to the other input's - dtype. + """Check whether the two arguments provided in the function have the same + dtype, unless one of them is an array_like or scalar, where it gets casted + to the other input's dtype. Parameters ---------- diff --git a/ivy/functional/frontends/tensorflow/func_wrapper.py b/ivy/functional/frontends/tensorflow/func_wrapper.py index c72ff5565a19d..a25c8418885e2 100644 --- a/ivy/functional/frontends/tensorflow/func_wrapper.py +++ b/ivy/functional/frontends/tensorflow/func_wrapper.py @@ -37,8 +37,7 @@ def _to_ivy_array(x): # update kwargs dictionary keys helper def _update_kwarg_keys(kwargs: Dict, to_update: Dict) -> Dict: - """ - Update the key-word only arguments dictionary. + """Update the key-word only arguments dictionary. Parameters ---------- @@ -100,10 +99,9 @@ def _handle_tf_dtype(*args, dtype=None, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_tf(*args, **kwargs): - """ - Convert all `TensorFlow.Tensor` instances in both the positional and keyword - arguments into `ivy.Array` instances, and then call the function with the - updated arguments. + """Convert all `TensorFlow.Tensor` instances in both the positional and + keyword arguments into `ivy.Array` instances, and then call the + function with the updated arguments. Parameters ---------- @@ -142,10 +140,10 @@ def _inputs_to_ivy_arrays_tf(*args, **kwargs): def map_raw_ops_alias( alias: callable, kwargs_to_update: Optional[Dict] = None ) -> callable: - """ - Map the raw_ops function with its respective frontend alias function, as the - implementations of raw_ops is way similar to that of frontend functions, except that - only arguments are passed as key-word only in raw_ops functions. + """Map the raw_ops function with its respective frontend alias function, as + the implementations of raw_ops is way similar to that of frontend + functions, except that only arguments are passed as key-word only in + raw_ops functions. Parameters ---------- @@ -199,9 +197,8 @@ def _wraped_fn(**kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_tf(*args, **kwargs): - """ - Call the function, and then convert all `tensorflow.Tensor` instances in the - function return into `ivy.Array` instances. + """Call the function, and then convert all `tensorflow.Tensor` + instances in the function return into `ivy.Array` instances. Parameters ---------- diff --git a/ivy/functional/frontends/tensorflow/variable.py b/ivy/functional/frontends/tensorflow/variable.py index 7c75a71815528..c7b2e12236841 100644 --- a/ivy/functional/frontends/tensorflow/variable.py +++ b/ivy/functional/frontends/tensorflow/variable.py @@ -277,12 +277,14 @@ def indices(self): @property def dense_shape(self): - """A 1-D `Tensor` containing the shape of the corresponding dense tensor.""" + """A 1-D `Tensor` containing the shape of the corresponding dense + tensor.""" return self._dense_shape @property def device(self): - """The name of the device on which `values` will be produced, or `None`.""" + """The name of the device on which `values` will be produced, or + `None`.""" return self.values.device @property diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index e871198f0a823..d502cb7e90d50 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -191,8 +191,8 @@ def promote_types_torch( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -221,9 +221,8 @@ def promote_types_of_torch_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/torch/func_wrapper.py b/ivy/functional/frontends/torch/func_wrapper.py index c79cdd9782ceb..c7df1998d4faa 100644 --- a/ivy/functional/frontends/torch/func_wrapper.py +++ b/ivy/functional/frontends/torch/func_wrapper.py @@ -131,8 +131,7 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_torch(*args, **kwargs): - """ - Convert `Tensor` into `ivy.Array` instances. + """Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -169,8 +168,7 @@ def wrapper(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def outputs_to_frontend_arrays_torch(*args, **kwargs): - """ - Convert `ivy.Array` into `Tensor` instances. + """Convert `ivy.Array` into `Tensor` instances. Call the function, and then convert all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -267,8 +265,7 @@ def outputs_to_native_arrays_torch(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `Tensor` instances. @@ -277,8 +274,7 @@ def to_ivy_arrays_and_back(fn: Callable) -> Callable: def to_ivy_shape(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives `ivy.Shape` instances. + """Wrap `fn` so it receives `ivy.Shape` instances. Wrap `fn` so that any `torch_frontend.Size` arguments are converted to `ivy.Shape` instances. diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 209a91152c8a7..cd997a72c6d7f 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -277,8 +277,7 @@ def atan2(self, other): return torch_frontend.atan2(self, other) def view(self, *args, size=None): - """ - Reshape Tensor. + """Reshape Tensor. possible arguments are either: - size diff --git a/ivy/functional/frontends/xgboost/core.py b/ivy/functional/frontends/xgboost/core.py index 793a3f2f02886..0ec6ac791099e 100644 --- a/ivy/functional/frontends/xgboost/core.py +++ b/ivy/functional/frontends/xgboost/core.py @@ -121,9 +121,8 @@ def __init__(self, params=None, cache=None, model_file=None, compile=False): self._comp_binary_prediction(self.gbm.obj, cache[1]) def update(self, dtrain, dlabel, iteration, fobj=None): - """ - Update for one iteration, with objective function calculated internally. This - function should not be called directly by users. + """Update for one iteration, with objective function calculated + internally. This function should not be called directly by users. Parameters ---------- @@ -154,11 +153,10 @@ def predict( iteration_range=(0, 0), strict_shape=False, ): - """ - Predict with data. The full model will be used unless `iteration_range` is - specified, meaning user have to either slice the model or use the - ``best_iteration`` attribute to get prediction from best model returned from - early stopping. + """Predict with data. The full model will be used unless + `iteration_range` is specified, meaning user have to either slice the + model or use the ``best_iteration`` attribute to get prediction from + best model returned from early stopping. Parameters ---------- diff --git a/ivy/functional/frontends/xgboost/linear/updater_coordinate.py b/ivy/functional/frontends/xgboost/linear/updater_coordinate.py index 284fc2f5a64a0..7b7c08a64e716 100644 --- a/ivy/functional/frontends/xgboost/linear/updater_coordinate.py +++ b/ivy/functional/frontends/xgboost/linear/updater_coordinate.py @@ -8,15 +8,15 @@ def coordinate_updater(gpair, data, lr, weight, n_feat, n_iter, reg_alpha, reg_lambda): - """ - Implements one step of coordinate descent. The original optimizer implements - parallel calculations. The below code is an approximation of the original one, but - rather than computing the update direction for a single parameter at a time using a - for loop and cumulative gradients, it does the update in parallel by means of - matrix-vector multiplications. Given that xgboost's updater is non-deterministic, - the approximated and original implementations converge to pretty the same optima, - resulting in metrics' values(accuracy, f1-score) differing at a level of 0.001(for - separate runs metrics may end up being the same). + """Implements one step of coordinate descent. The original optimizer + implements parallel calculations. The below code is an approximation of the + original one, but rather than computing the update direction for a single + parameter at a time using a for loop and cumulative gradients, it does the + update in parallel by means of matrix-vector multiplications. Given that + xgboost's updater is non-deterministic, the approximated and original + implementations converge to pretty the same optima, resulting in metrics' + values(accuracy, f1-score) differing at a level of 0.001(for separate runs + metrics may end up being the same). Parameters ---------- diff --git a/ivy/functional/frontends/xgboost/sklearn.py b/ivy/functional/frontends/xgboost/sklearn.py index e2edeecb81802..3b80f8d6fa1fe 100644 --- a/ivy/functional/frontends/xgboost/sklearn.py +++ b/ivy/functional/frontends/xgboost/sklearn.py @@ -98,9 +98,8 @@ def __sklearn_is_fitted__(self): return hasattr(self, "_Booster") def get_booster(self): - """ - Get the underlying xgboost Booster of this model. This will raise an exception - when fit was not called. + """Get the underlying xgboost Booster of this model. This will raise an + exception when fit was not called. Returns ------- @@ -176,8 +175,7 @@ def fit( feature_weights=None, callbacks=None, ): - """ - Fit gradient boosting model. + """Fit gradient boosting model. Note that calling ``fit()`` multiple times will cause the model object to be re-fit from scratch. To resume training from a previous checkpoint, explicitly diff --git a/ivy/functional/frontends/xgboost/training.py b/ivy/functional/frontends/xgboost/training.py index cc727add4c5a6..cc67edb9f478d 100644 --- a/ivy/functional/frontends/xgboost/training.py +++ b/ivy/functional/frontends/xgboost/training.py @@ -18,8 +18,7 @@ def train( callbacks=None, custom_metric=None, ): - """ - Train a booster with given parameters. + """Train a booster with given parameters. Parameters ---------- diff --git a/ivy/functional/ivy/activations.py b/ivy/functional/ivy/activations.py index 2468219b98cde..8d3803b6c0777 100644 --- a/ivy/functional/ivy/activations.py +++ b/ivy/functional/ivy/activations.py @@ -48,8 +48,7 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the Gaussian error linear unit (GELU) activation function. + """Apply the Gaussian error linear unit (GELU) activation function. Parameters ---------- @@ -138,8 +137,7 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the leaky rectified linear unit function element-wise. + """Apply the leaky rectified linear unit function element-wise. If the input is complex, then by default each element is scaled by `alpha` if either its real part is strictly negative or if its real part is zero and its @@ -218,8 +216,7 @@ def log_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the log_softmax function element-wise. + """Apply the log_softmax function element-wise. Parameters ---------- @@ -314,8 +311,7 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the rectified linear unit function element-wise. + """Apply the rectified linear unit function element-wise. If the input is complex, then by default each element is set to zero if either its real part is strictly negative or if its real part is zero and its @@ -386,8 +382,7 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the sigmoid function element-wise. + """Apply the sigmoid function element-wise. Parameters ---------- @@ -473,8 +468,7 @@ def softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the softmax function element-wise. + """Apply the softmax function element-wise. Parameters ---------- @@ -571,8 +565,7 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the softplus function element-wise. + """Apply the softplus function element-wise. If the input is complex, then by default we apply the softplus operation `log(1+ exp(x))` to each element @@ -640,8 +633,7 @@ def softsign( /, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the softsign function element-wise. + """Apply the softsign function element-wise. Parameters ---------- @@ -683,8 +675,7 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the mish activation function element-wise. + """Apply the mish activation function element-wise. Parameters ---------- @@ -759,8 +750,7 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the hardswish activation function element-wise. + """Apply the hardswish activation function element-wise. Parameters ---------- diff --git a/ivy/functional/ivy/control_flow_ops.py b/ivy/functional/ivy/control_flow_ops.py index 9b2dda176ad85..9973de660b546 100644 --- a/ivy/functional/ivy/control_flow_ops.py +++ b/ivy/functional/ivy/control_flow_ops.py @@ -13,10 +13,9 @@ def if_else( orelse_fn: Callable, vars: Dict[str, Union[ivy.Array, ivy.NativeArray]], ) -> Any: - """ - Take a condition function and two functions as input. If the condition is True, the - first function is executed and its result is returned. Otherwise, the second - function is executed and its result is returned. + """Take a condition function and two functions as input. If the condition + is True, the first function is executed and its result is returned. + Otherwise, the second function is executed and its result is returned. Parameters ---------- @@ -67,9 +66,9 @@ def while_loop( body_fn: Callable, vars: Dict[str, Union[ivy.Array, ivy.NativeArray]], ) -> Any: - """ - Take a test function, a body function and a set of variables as input. The body - function is executed repeatedly while the test function returns True. + """Take a test function, a body function and a set of variables as input. + The body function is executed repeatedly while the test function returns + True. Parameters ---------- @@ -119,9 +118,8 @@ def for_loop( body_fn: Callable, vars: Iterable[Union[ivy.Array, ivy.NativeArray]], ): - """ - Loops over an iterable, passing the current iteration along with a tuple of - variables into the provided body function. + """Loops over an iterable, passing the current iteration along with a tuple + of variables into the provided body function. Parameters ---------- diff --git a/ivy/functional/ivy/creation.py b/ivy/functional/ivy/creation.py index 44c9f370b04ed..c032bc3b69134 100644 --- a/ivy/functional/ivy/creation.py +++ b/ivy/functional/ivy/creation.py @@ -44,10 +44,9 @@ def _asarray_handle_nestable(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_handle_nestable_wrapper(*args, **kwargs): - """ - Call `fn` with the *nestable* property of the function correctly handled. This - means mapping the function to the container leaves if any containers are passed - in the input. + """Call `fn` with the *nestable* property of the function correctly + handled. This means mapping the function to the container leaves if any + containers are passed in the input. Parameters ---------- @@ -136,9 +135,9 @@ def _remove_np_bfloat16(obj): def _asarray_to_native_arrays_and_back(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_to_native_arrays_and_back_wrapper(*args, dtype=None, **kwargs): - """ - Wrap `fn` so that input arrays are all converted to `ivy.NativeArray` instances - and return arrays are all converted to `ivy.Array` instances. + """Wrap `fn` so that input arrays are all converted to + `ivy.NativeArray` instances and return arrays are all converted to + `ivy.Array` instances. This wrapper is specifically for the backend implementations of asarray. @@ -160,10 +159,9 @@ def _asarray_to_native_arrays_and_back_wrapper(*args, dtype=None, **kwargs): def _asarray_infer_dtype(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_infer_dtype_wrapper(*args, dtype=None, **kwargs): - """ - Determine the correct `dtype`, and then calls the function with the `dtype` - passed explicitly. This wrapper is specifically for the backend implementations - of asarray. + """Determine the correct `dtype`, and then calls the function with the + `dtype` passed explicitly. This wrapper is specifically for the backend + implementations of asarray. Parameters ---------- @@ -218,10 +216,9 @@ def _infer_dtype(obj): def _asarray_infer_device(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_infer_device_wrapper(*args, device=None, **kwargs): - """ - Determine the correct `device`, and then calls the function with the `device` - passed explicitly. This wrapper is specifically for the backend implementations - of asarray. + """Determine the correct `device`, and then calls the function with the + `device` passed explicitly. This wrapper is specifically for the + backend implementations of asarray. Parameters ---------- @@ -299,9 +296,8 @@ def arange( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return evenly spaced values within a given interval, with the spacing being - specified. + """Return evenly spaced values within a given interval, with the spacing + being specified. Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function @@ -411,8 +407,7 @@ def asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Convert the input to an array. + """Convert the input to an array. Parameters ---------- @@ -497,8 +492,7 @@ def zeros( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array having a specified ``shape`` and filled with zeros. + """Return a new array having a specified ``shape`` and filled with zeros. Parameters ---------- @@ -562,8 +556,7 @@ def ones( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array having a specified ``shape`` and filled with ones. + """Return a new array having a specified ``shape`` and filled with ones. .. note:: @@ -661,9 +654,8 @@ def full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array filled with ``fill_value`` and having the same ``shape`` as an - input array ``x`` . + """Return a new array filled with ``fill_value`` and having the same + ``shape`` as an input array ``x`` . Parameters ---------- @@ -769,9 +761,8 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array filled with ones and having the same shape as an input array - ``x``. + """Return a new array filled with ones and having the same shape as an + input array ``x``. .. note:: @@ -889,9 +880,8 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array filled with zeros and having the same ``shape`` as an input array - ``x``. + """Return a new array filled with zeros and having the same ``shape`` as an + input array ``x``. Parameters ---------- @@ -1002,8 +992,8 @@ def tril( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the lower triangular part of a matrix (or a stack of matrices) ``x``. + """Return the lower triangular part of a matrix (or a stack of matrices) + ``x``. .. note:: @@ -1058,8 +1048,8 @@ def triu( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the upper triangular part of a matrix (or a stack of matrices) ``x``. + """Return the upper triangular part of a matrix (or a stack of matrices) + ``x``. .. note:: @@ -1116,8 +1106,7 @@ def empty( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array of given shape and type, filled with zeros. + """Return a new array of given shape and type, filled with zeros. Parameters ---------- @@ -1167,8 +1156,7 @@ def empty_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an uninitialized array with the same shape as an input array x. + """Return an uninitialized array with the same shape as an input array x. Parameters ---------- @@ -1222,8 +1210,8 @@ def eye( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a two-dimensional array with ones on the k diagonal and zeros elsewhere. + """Return a two-dimensional array with ones on the k diagonal and zeros + elsewhere. Parameters ---------- @@ -1365,8 +1353,8 @@ def linspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a certain number of evenly-spaced values in an interval along a given axis. + """Generate a certain number of evenly-spaced values in an interval along a + given axis. See :math:`arange` that allows to specify the step size of evenly spaced values in an interval. @@ -1468,8 +1456,7 @@ def meshgrid( indexing: str = "xy", out: Optional[ivy.Array] = None, ) -> List[ivy.Array]: - """ - Return coordinate matrices from coordinate vectors. + """Return coordinate matrices from coordinate vectors. Parameters ---------- @@ -1593,8 +1580,8 @@ def full( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array having a specified ``shape`` and filled with ``fill_value``. + """Return a new array having a specified ``shape`` and filled with + ``fill_value``. Parameters ---------- @@ -1696,8 +1683,7 @@ def full( def to_dlpack( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ): - """ - Return PyCapsule Object. + """Return PyCapsule Object. Parameters ---------- @@ -1736,9 +1722,8 @@ def to_dlpack( def from_dlpack( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Return a new array containing the data from another (array) object with a - ``__dlpack__`` method or PyCapsule Object. + """Return a new array containing the data from another (array) object with + a ``__dlpack__`` method or PyCapsule Object. Parameters ---------- @@ -1794,8 +1779,7 @@ def copy_array( to_ivy_array: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Copy an array. + """Copy an array. Parameters ---------- @@ -1900,8 +1884,7 @@ def native_array( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.NativeArray: - """ - Convert the input to a native array. + """Convert the input to a native array. Parameters ---------- @@ -1965,9 +1948,9 @@ def one_hot( device: Union[ivy.Device, ivy.NativeDevice] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a one-hot array. The locations represented by indices in the parameter - indices take value on_value, while all other locations take value off_value. + """Return a one-hot array. The locations represented by indices in the + parameter indices take value on_value, while all other locations take value + off_value. Parameters ---------- @@ -2081,9 +2064,8 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a certain number of evenly-spaced values in log space, in an interval along - a given axis. + """Generate a certain number of evenly-spaced values in log space, in an + interval along a given axis. Parameters ---------- @@ -2186,8 +2168,7 @@ def frombuffer( count: Optional[int] = -1, offset: Optional[int] = 0, ) -> ivy.Array: - r""" - Interpret a buffer as a 1-dimensional array. + r"""Interpret a buffer as a 1-dimensional array. .. note:: Note that either of the following must be true: @@ -2252,16 +2233,16 @@ def triu_indices( *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Tuple[ivy.Array]: - """ - Return the indices of the upper triangular part of a row by col matrix in a 2-by-N - shape (tuple of two N dimensional arrays), where the first row contains row - coordinates of all indices and the second row contains column coordinates. Indices - are ordered based on rows and then columns. The upper triangular part of the matrix - is defined as the elements on and above the diagonal. The argument k controls which - diagonal to consider. If k = 0, all elements on and above the main diagonal are - retained. A positive value excludes just as many diagonals above the main diagonal, - and similarly a negative value includes just as many diagonals below the main - diagonal. The main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, + """Return the indices of the upper triangular part of a row by col matrix + in a 2-by-N shape (tuple of two N dimensional arrays), where the first row + contains row coordinates of all indices and the second row contains column + coordinates. Indices are ordered based on rows and then columns. The upper + triangular part of the matrix is defined as the elements on and above the + diagonal. The argument k controls which diagonal to consider. If k = 0, + all elements on and above the main diagonal are retained. A positive value + excludes just as many diagonals above the main diagonal, and similarly a + negative value includes just as many diagonals below the main diagonal. The + main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, n_cols}−1]. Notes diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index e0d4e592068f1..8c55058f0d3ce 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -265,8 +265,8 @@ def astype( copy: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Copy an array to a specified data type irrespective of :ref:`type- promotion` rules. + """Copy an array to a specified data type irrespective of :ref:`type- + promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -365,8 +365,7 @@ def astype( @handle_array_function @handle_device def broadcast_arrays(*arrays: Union[ivy.Array, ivy.NativeArray]) -> List[ivy.Array]: - """ - Broadcasts one or more arrays against one another. + """Broadcasts one or more arrays against one another. Parameters ---------- @@ -453,8 +452,7 @@ def broadcast_to( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Broadcasts an array to a specified shape. + """Broadcasts an array to a specified shape. Parameters ---------- @@ -522,9 +520,8 @@ def can_cast( to: ivy.Dtype, /, ) -> bool: - """ - Determine if one data type can be cast to another data type according to :ref:`type- - promotion` rules. + """Determine if one data type can be cast to another data type according to + :ref:`type- promotion` rules. Parameters ---------- @@ -597,8 +594,7 @@ def finfo( type: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray], /, ) -> Finfo: - """ - Machine limits for floating-point data types. + """Machine limits for floating-point data types. Parameters ---------- @@ -685,8 +681,7 @@ def iinfo( type: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray], /, ) -> Iinfo: - """ - Machine limits for integer data types. + """Machine limits for integer data types. Parameters ---------- @@ -762,9 +757,8 @@ def iinfo( def result_type( *arrays_and_dtypes: Union[ivy.Array, ivy.NativeArray, ivy.Dtype] ) -> ivy.Dtype: - """ - Return the dtype that results from applying the type promotion rules (see - :ref:`type-promotion`) to the arguments. + """Return the dtype that results from applying the type promotion rules + (see :ref:`type-promotion`) to the arguments. .. note:: If provided mixed dtypes (e.g., integer and floating-point), the returned dtype @@ -917,8 +911,7 @@ def __exit__(self, exc_type, exc_val, exc_tb): @handle_exceptions def dtype_bits(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str], /) -> int: - """ - Get the number of bits used for representing the input data type. + """Get the number of bits used for representing the input data type. Parameters ---------- @@ -953,8 +946,7 @@ def dtype_bits(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str], /) -> int: @handle_exceptions def is_hashable_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: - """ - Check if the given data type is hashable or not. + """Check if the given data type is hashable or not. Parameters ---------- @@ -979,8 +971,7 @@ def is_hashable_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: @handle_exceptions def as_ivy_dtype(dtype_in: Union[ivy.Dtype, str], /) -> ivy.Dtype: - """ - Convert native data type to string representation. + """Convert native data type to string representation. Parameters ---------- @@ -997,8 +988,7 @@ def as_ivy_dtype(dtype_in: Union[ivy.Dtype, str], /) -> ivy.Dtype: @handle_exceptions def as_native_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> ivy.NativeDtype: - """ - Convert data type string representation to native data type. + """Convert data type string representation to native data type. Parameters ---------- @@ -1034,8 +1024,7 @@ def _check_complex128(input) -> bool: @handle_exceptions def closest_valid_dtype(type: Union[ivy.Dtype, str, None], /) -> Union[ivy.Dtype, str]: - """ - Determine the closest valid datatype to the datatype passed as input. + """Determine the closest valid datatype to the datatype passed as input. Parameters ---------- @@ -1172,8 +1161,7 @@ def default_float_dtype( def infer_default_dtype( dtype: Union[ivy.Dtype, ivy.NativeDtype, str], as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """ - Summary. + """Summary. Parameters ---------- @@ -1629,8 +1617,7 @@ def default_complex_dtype( def dtype( x: Union[ivy.Array, ivy.NativeArray], *, as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """ - Get the data type for input array x. + """Get the data type for input array x. Parameters ---------- @@ -1674,10 +1661,10 @@ def dtype( @handle_exceptions @handle_nestable def function_supported_dtypes(fn: Callable, recurse: bool = True) -> Union[Tuple, dict]: - """ - Return the supported data types of the current backend's function. The function - returns a dict containing the supported dtypes for the compositional and primary - implementations in case of partial mixed functions. + """Return the supported data types of the current backend's function. The + function returns a dict containing the supported dtypes for the + compositional and primary implementations in case of partial mixed + functions. Parameters ---------- @@ -1725,10 +1712,10 @@ def function_supported_dtypes(fn: Callable, recurse: bool = True) -> Union[Tuple def function_unsupported_dtypes( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """ - Return the unsupported data types of the current backend's function. The function - returns a dict containing the unsupported dtypes for the compositional and primary - implementations in case of partial mixed functions. + """Return the unsupported data types of the current backend's function. The + function returns a dict containing the unsupported dtypes for the + compositional and primary implementations in case of partial mixed + functions. Parameters ---------- @@ -1774,8 +1761,8 @@ def function_unsupported_dtypes( @handle_exceptions def invalid_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str, None], /) -> bool: - """ - Determine whether the provided data type is not support by the current framework. + """Determine whether the provided data type is not support by the current + framework. Parameters ---------- @@ -1813,8 +1800,7 @@ def is_bool_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is a bool data type. + """Determine whether the input data type is a bool data type. Parameters ---------- @@ -1853,8 +1839,7 @@ def is_int_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is an int data type. + """Determine whether the input data type is an int data type. Parameters ---------- @@ -1929,8 +1914,7 @@ def nested_fun(x): @handle_exceptions def check_float(x: Any) -> bool: - """ - Check if the input is a float or a float-like object. + """Check if the input is a float or a float-like object. Parameters ---------- @@ -1952,8 +1936,7 @@ def is_float_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is a float dtype. + """Determine whether the input data type is a float dtype. Parameters ---------- @@ -2001,8 +1984,7 @@ def is_uint_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is a uint dtype. + """Determine whether the input data type is a uint dtype. Parameters ---------- @@ -2049,8 +2031,7 @@ def is_complex_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is a complex dtype. + """Determine whether the input data type is a complex dtype. Parameters ---------- @@ -2098,8 +2079,8 @@ def promote_types( *, array_api_promotion: bool = False, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -2133,8 +2114,7 @@ def _promote(query): @handle_exceptions def set_default_dtype(dtype: Union[ivy.Dtype, ivy.NativeDtype, str], /): - """ - Set the datatype `dtype` as default data type. + """Set the datatype `dtype` as default data type. Parameters ---------- @@ -2169,8 +2149,7 @@ def set_default_dtype(dtype: Union[ivy.Dtype, ivy.NativeDtype, str], /): @handle_exceptions def set_default_float_dtype(float_dtype: Union[ivy.Dtype, str], /): - """ - Set the 'float_dtype' as the default data type. + """Set the 'float_dtype' as the default data type. Parameters ---------- @@ -2197,8 +2176,7 @@ def set_default_float_dtype(float_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_int_dtype(int_dtype: Union[ivy.Dtype, str], /): - """ - Set the 'int_dtype' as the default data type. + """Set the 'int_dtype' as the default data type. Parameters ---------- @@ -2225,8 +2203,7 @@ def set_default_int_dtype(int_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_uint_dtype(uint_dtype: Union[ivy.Dtype, str], /): - """ - Set the uint dtype to be default. + """Set the uint dtype to be default. Parameters ---------- @@ -2251,8 +2228,7 @@ def set_default_uint_dtype(uint_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_complex_dtype(complex_dtype: Union[ivy.Dtype, str], /): - """ - Set the 'complex_dtype' as the default data type. + """Set the 'complex_dtype' as the default data type. Parameters ---------- @@ -2283,9 +2259,8 @@ def type_promote_arrays( x2: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple: - """ - Type promote the input arrays, returning new arrays with the shared correct data - type. + """Type promote the input arrays, returning new arrays with the shared + correct data type. Parameters ---------- @@ -2305,8 +2280,7 @@ def type_promote_arrays( @handle_exceptions def unset_default_dtype(): - """ - Reset the current default dtype to the previous state. + """Reset the current default dtype to the previous state. Examples -------- @@ -2330,8 +2304,7 @@ def unset_default_dtype(): @handle_exceptions def unset_default_float_dtype(): - """ - Reset the current default float dtype to the previous state. + """Reset the current default float dtype to the previous state. Examples -------- @@ -2351,8 +2324,7 @@ def unset_default_float_dtype(): @handle_exceptions def unset_default_int_dtype(): - """ - Reset the current default int dtype to the previous state. + """Reset the current default int dtype to the previous state. Examples -------- @@ -2371,8 +2343,7 @@ def unset_default_int_dtype(): @handle_exceptions def unset_default_uint_dtype(): - """ - Reset the current default uint dtype to the previous state. + """Reset the current default uint dtype to the previous state. Examples -------- @@ -2391,8 +2362,7 @@ def unset_default_uint_dtype(): @handle_exceptions def unset_default_complex_dtype(): - """ - Reset the current default complex dtype to the previous state. + """Reset the current default complex dtype to the previous state. Examples -------- @@ -2412,8 +2382,8 @@ def unset_default_complex_dtype(): @handle_exceptions def valid_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str, None], /) -> bool: - """ - Determine whether the provided data type is supported by the current framework. + """Determine whether the provided data type is supported by the current + framework. Parameters ---------- @@ -2452,9 +2422,8 @@ def promote_types_of_inputs( *, array_api_promotion: bool = False, ) -> Tuple[ivy.NativeArray, ivy.NativeArray]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an @@ -2502,8 +2471,7 @@ def _get_target_dtype(scalar, arr): @handle_exceptions def is_native_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: - """ - Determine whether the input dtype is a Native dtype. + """Determine whether the input dtype is a Native dtype. Parameters ---------- diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index 0454871cb9f2f..56c34b44fa2ff 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -59,8 +59,7 @@ def __init__( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> None: - """ - Initialize the DefaultDevice class. + """Initialize the DefaultDevice class. Parameters ---------- @@ -76,8 +75,7 @@ def __init__( self._dev = device def __enter__(self): - """ - Enter the runtime context related to the specified device. + """Enter the runtime context related to the specified device. Returns ------- @@ -103,8 +101,7 @@ def __exit__( exc_val: Optional[Type[BaseException]], exc_tb: Optional[types.TracebackType], ) -> Union[ivy.Device, str]: - """ - Exit the runtime context related to the specified device. + """Exit the runtime context related to the specified device. Parameters ---------- @@ -178,8 +175,7 @@ def get_all_ivy_arrays_on_dev( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> ivy.Container: - """ - Get all ivy arrays which are currently alive on the specified device. + """Get all ivy arrays which are currently alive on the specified device. Parameters ---------- @@ -214,8 +210,8 @@ def get_all_ivy_arrays_on_dev( @handle_exceptions def num_ivy_arrays_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> int: - """ - Return the number of arrays which are currently alive on the specified device. + """Return the number of arrays which are currently alive on the specified + device. Parameters ---------- @@ -256,9 +252,8 @@ def print_all_ivy_arrays_on_dev( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, attr_only: bool = True, ) -> None: - """ - Print the shape and dtype for all ivy arrays which are currently alive on the - specified device. + """Print the shape and dtype for all ivy arrays which are currently alive + on the specified device. Parameters ---------- @@ -295,9 +290,8 @@ def print_all_ivy_arrays_on_dev( @handle_exceptions def set_soft_device_mode(mode: bool) -> None: - """ - Set the mode of whether to move input arrays to `ivy.default_device()` before - performing an operation. + """Set the mode of whether to move input arrays to `ivy.default_device()` + before performing an operation. Parameter --------- @@ -320,9 +314,8 @@ def set_soft_device_mode(mode: bool) -> None: @handle_exceptions def unset_soft_device_mode() -> None: - """ - Reset the mode of moving input arrays to `ivy.default_device()` before performing an - operation. + """Reset the mode of moving input arrays to `ivy.default_device()` before + performing an operation. Examples -------- @@ -350,8 +343,7 @@ def unset_soft_device_mode() -> None: def dev( x: Union[ivy.Array, ivy.NativeArray], /, *, as_native: bool = False ) -> Union[ivy.Device, ivy.NativeDevice]: - """ - Get the native device handle for input array x. + """Get the native device handle for input array x. Parameters ---------- @@ -389,8 +381,7 @@ def dev( @handle_exceptions def as_ivy_dev(device: Union[ivy.Device, str], /) -> ivy.Device: - """ - Convert device to string representation. + """Convert device to string representation. Parameters ---------- @@ -413,8 +404,7 @@ def as_ivy_dev(device: Union[ivy.Device, str], /) -> ivy.Device: @handle_exceptions def as_native_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> ivy.NativeDevice: - """ - Convert device string representation to native device type. + """Convert device string representation to native device type. Parameters ---------- @@ -458,8 +448,7 @@ def as_native_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> ivy.NativeD @handle_exceptions def clear_cached_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: - """ - Clear memory cache on target device. + """Clear memory cache on target device. Parameters ---------- @@ -478,9 +467,8 @@ def clear_cached_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> N @handle_exceptions def total_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> float: - """ - Get the total amount of memory (in GB) for a given device string. In case of CPU, - the total RAM is returned. + """Get the total amount of memory (in GB) for a given device string. In + case of CPU, the total RAM is returned. Parameters ---------- @@ -522,9 +510,8 @@ def used_mem_on_dev( *, process_specific: bool = False, ) -> float: - """ - Get the used memory (in GB) for a given device string. In case of CPU, the used RAM - is returned. + """Get the used memory (in GB) for a given device string. In case of CPU, + the used RAM is returned. Parameters ---------- @@ -582,9 +569,8 @@ def percent_used_mem_on_dev( *, process_specific: bool = False, ) -> float: - """ - Get the percentage used memory for a given device string. In case of CPU, the used - RAM is returned. + """Get the percentage used memory for a given device string. In case of + CPU, the used RAM is returned. Parameters ---------- @@ -644,8 +630,7 @@ def dev_util( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> float: - """ - Get the current utilization (%) for a given device. + """Get the current utilization (%) for a given device. Parameters ---------- @@ -687,8 +672,7 @@ def dev_util( @handle_exceptions def gpu_is_available() -> bool: - """ - Determine whether a GPU is available to use, with the backend framework. + """Determine whether a GPU is available to use, with the backend framework. Returns ------- @@ -705,8 +689,7 @@ def gpu_is_available() -> bool: @handle_exceptions def num_cpu_cores(*, logical: bool = True) -> int: - """ - Determine the number of cores available in the cpu. + """Determine the number of cores available in the cpu. Parameters ---------- @@ -731,8 +714,7 @@ def num_cpu_cores(*, logical: bool = True) -> int: @handle_exceptions def num_gpus() -> int: - """ - Determine the number of available GPUs, with the backend framework. + """Determine the number of available GPUs, with the backend framework. Returns ------- @@ -749,8 +731,7 @@ def num_gpus() -> int: @handle_exceptions def tpu_is_available() -> bool: - """ - Determine whether a TPU is available to use, with the backend framework. + """Determine whether a TPU is available to use, with the backend framework. Returns ------- @@ -778,12 +759,11 @@ def default_device( item: Optional[Union[list, tuple, dict, ivy.Array, ivy.NativeArray]] = None, as_native: Optional[bool] = None, ) -> Union[ivy.Device, ivy.NativeDevice]: - """ - Return the input device or the default device. If the as_native flag is set, the - device will be converted to a native device. If the item is provided, the item's - device is returned. If the device is not provided, the last default device is - returned. If a default device has not been set, the first gpu is returned if - available, otherwise the cpu is returned. + """Return the input device or the default device. If the as_native flag is + set, the device will be converted to a native device. If the item is + provided, the item's device is returned. If the device is not provided, the + last default device is returned. If a default device has not been set, the + first gpu is returned if available, otherwise the cpu is returned. Parameters ---------- @@ -845,8 +825,7 @@ def default_device( @handle_exceptions def set_default_device(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: - """ - Set the default device to given device instance. + """Set the default device to given device instance. Parameters ---------- @@ -877,8 +856,7 @@ def set_default_device(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: @handle_exceptions def unset_default_device() -> None: - """ - Reset the default device to "cpu". + """Reset the default device to "cpu". Examples -------- @@ -911,8 +889,8 @@ def to_device( stream: Optional[Union[int, Any]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Move the input array x to the desired device, specified by device string. + """Move the input array x to the desired device, specified by device + string. Parameters ---------- @@ -952,9 +930,8 @@ def split_factor( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, /, ) -> float: - """ - Get a device's global split factor, which can be used to scale the device's batch - splitting chunk sizes across the codebase. + """Get a device's global split factor, which can be used to scale the + device's batch splitting chunk sizes across the codebase. If the global split factor is set for a given device, returns the split factor value for the device from the split factors dictionary @@ -990,9 +967,8 @@ def split_factor( def set_split_factor( factor: float, /, *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None ) -> None: - """ - Set the global split factor for a given device, which can be used to scale batch - splitting chunk sizes for the device across the codebase. + """Set the global split factor for a given device, which can be used to + scale batch splitting chunk sizes for the device across the codebase. Parameters ---------- @@ -1049,10 +1025,9 @@ def split_func_call( stop_gradients: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Call a function by splitting its inputs along a given axis, and calling the function - in chunks, rather than feeding the entire input array at once. This can be useful to - reduce memory usage of the device the arrays are on. + """Call a function by splitting its inputs along a given axis, and calling + the function in chunks, rather than feeding the entire input array at once. + This can be useful to reduce memory usage of the device the arrays are on. Parameters ---------- @@ -1225,10 +1200,10 @@ def _get_devices(fn: Callable, complement: bool = True) -> Tuple: def function_supported_devices( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """ - Return the supported devices of the current backend's function. The function returns - a dict containing the supported devices for the compositional and primary - implementations in case of partial mixed functions. + """Return the supported devices of the current backend's function. The + function returns a dict containing the supported devices for the + compositional and primary implementations in case of partial mixed + functions. Parameters ---------- @@ -1277,10 +1252,10 @@ def function_supported_devices( def function_unsupported_devices( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """ - Return the unsupported devices of the current backend's function. The function - returns a dict containing the unsupported devices for the compositional and primary - implementations in case of partial mixed functions. + """Return the unsupported devices of the current backend's function. The + function returns a dict containing the unsupported devices for the + compositional and primary implementations in case of partial mixed + functions. Parameters ---------- @@ -1326,8 +1301,7 @@ def function_unsupported_devices( class Profiler(abc.ABC): - """ - The profiler class is used to profile the execution of some code. + """The profiler class is used to profile the execution of some code. Parameters ---------- @@ -1340,8 +1314,7 @@ def __init__(self, save_dir: str): @abc.abstractmethod def start(self): - """ - Start the profiler. + """Start the profiler. This should be called before the code to be profiled. """ @@ -1349,8 +1322,7 @@ def start(self): @abc.abstractmethod def stop(self): - """ - Stop the profiler. + """Stop the profiler. This should be called after the code to be profiled. """ diff --git a/ivy/functional/ivy/elementwise.py b/ivy/functional/ivy/elementwise.py index 6a250ecb3053f..b4bbe720a143d 100644 --- a/ivy/functional/ivy/elementwise.py +++ b/ivy/functional/ivy/elementwise.py @@ -36,10 +36,9 @@ def abs( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: # noqa - """ - Calculate the absolute value for each element ``x_i`` of the input array ``x`` - (i.e., the element-wise result has the same magnitude as the respective element in - ``x`` but has positive sign). + """Calculate the absolute value for each element ``x_i`` of the input array + ``x`` (i.e., the element-wise result has the same magnitude as the + respective element in ``x`` but has positive sign). .. note:: For signed integer data types, the absolute value of the minimum representable @@ -140,10 +139,10 @@ def acos( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the principal value of the - inverse cosine, having domain [-1, +1] and codomain [+0, +π], for each element x_i - of the input array x. Each element-wise result is expressed in radians. + """Calculate an implementation-dependent approximation of the principal + value of the inverse cosine, having domain [-1, +1] and codomain [+0, +π], + for each element x_i of the input array x. Each element-wise result is + expressed in radians. **Special cases** @@ -250,10 +249,9 @@ def acosh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the inverse hyperbolic - cosine, having domain ``[+1, +infinity]`` and codomain ``[+0, +infinity]``, for each - element ``x_i`` of the input array ``x``. + """Calculate an implementation-dependent approximation to the inverse + hyperbolic cosine, having domain ``[+1, +infinity]`` and codomain ``[+0, + +infinity]``, for each element ``x_i`` of the input array ``x``. **Special cases** @@ -361,9 +359,8 @@ def add( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the sum for each element ``x1_i`` of the input array ``x1`` with the - respective element ``x2_i`` of the input array ``x2``. + """Calculate the sum for each element ``x1_i`` of the input array ``x1`` + with the respective element ``x2_i`` of the input array ``x2``. **Special cases** @@ -511,11 +508,10 @@ def asin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the principal value of the - inverse sine, having domain ``[-1, +1]`` and codomain ``[-π/2, +π/2]`` for each - element ``x_i`` of the input array ``x``. Each element- wise result is expressed in - radians. + """Calculate an implementation-dependent approximation of the principal + value of the inverse sine, having domain ``[-1, +1]`` and codomain ``[-π/2, + +π/2]`` for each element ``x_i`` of the input array ``x``. Each element- + wise result is expressed in radians. **Special cases** @@ -600,10 +596,10 @@ def asinh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the inverse hyperbolic sine, - having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, - for each element ``x_i`` in the input array ``x``. + """Calculate an implementation-dependent approximation to the inverse + hyperbolic sine, having domain ``[-infinity, +infinity]`` and codomain + ``[-infinity, +infinity]``, for each element ``x_i`` in the input array + ``x``. **Special cases** @@ -709,11 +705,10 @@ def atan( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the principal value of the - inverse tangent, having domain ``[-infinity, +infinity]`` and codomain ``[-π/2, - +π/2]``, for each element ``x_i`` of the input array ``x``. Each element-wise result - is expressed in radians. + """Calculate an implementation-dependent approximation of the principal + value of the inverse tangent, having domain ``[-infinity, +infinity]`` and + codomain ``[-π/2, +π/2]``, for each element ``x_i`` of the input array + ``x``. Each element-wise result is expressed in radians. **Special cases** @@ -794,17 +789,17 @@ def atan2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the inverse tangent of the - quotient ``x1/x2``, having domain ``[-infinity, +infinity] x. [-infinity, - +infinity]`` (where the ``x`` notation denotes the set of ordered pairs of elements - ``(x1_i, x2_i)``) and codomain ``[-π, +π]``, for each pair of elements ``(x1_i, - x2_i)`` of the input arrays ``x1`` and ``x2``, respectively. Each element-wise - result is expressed in radians. The mathematical signs of ``x1_i and x2_i`` - determine the quadrant of each element-wise result. The quadrant (i.e., branch) is - chosen such that each element-wise result is the signed angle in radians between the - ray ending at the origin and passing through the point ``(1,0)`` and the ray ending - at the origin and passing through the point ``(x2_i, x1_i)``. + """Calculate an implementation-dependent approximation of the inverse + tangent of the quotient ``x1/x2``, having domain ``[-infinity, +infinity] + x. [-infinity, +infinity]`` (where the ``x`` notation denotes the set of + ordered pairs of elements ``(x1_i, x2_i)``) and codomain ``[-π, +π]``, for + each pair of elements ``(x1_i, x2_i)`` of the input arrays ``x1`` and + ``x2``, respectively. Each element-wise result is expressed in radians. The + mathematical signs of ``x1_i and x2_i`` determine the quadrant of each + element-wise result. The quadrant (i.e., branch) is chosen such that each + element-wise result is the signed angle in radians between the ray ending + at the origin and passing through the point ``(1,0)`` and the ray ending at + the origin and passing through the point ``(x2_i, x1_i)``. **Special cases** @@ -970,8 +965,8 @@ def atanh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array with the inverse hyperbolic tangent of the elements of ``x``. + """Return a new array with the inverse hyperbolic tangent of the elements + of ``x``. Parameters ---------- @@ -1073,10 +1068,9 @@ def bitwise_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the bitwise AND of the underlying binary representation of each element - ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """Compute the bitwise AND of the underlying binary representation of each + element ``x1_i`` of the input array ``x1`` with the respective element + ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -1167,8 +1161,8 @@ def bitwise_invert( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Inverts (flips) each bit for each element ``x_i`` of the input array ``x``. + """Inverts (flips) each bit for each element ``x_i`` of the input array + ``x``. Parameters ---------- @@ -1245,10 +1239,9 @@ def bitwise_left_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Shifts the bits of each element ``x1_i`` of the input array ``x1`` to the left by - appending ``x2_i`` (i.e., the respective element in the input array ``x2``) zeros to - the right of ``x1_i``. + """Shifts the bits of each element ``x1_i`` of the input array ``x1`` to + the left by appending ``x2_i`` (i.e., the respective element in the input + array ``x2``) zeros to the right of ``x1_i``. Parameters ---------- @@ -1296,10 +1289,9 @@ def bitwise_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the bitwise OR of the underlying binary representation of each element - ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """Compute the bitwise OR of the underlying binary representation of each + element ``x1_i`` of the input array ``x1`` with the respective element + ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -1385,9 +1377,9 @@ def bitwise_right_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Shifts the bits of each element ``x1_i`` of the input array ``x1`` to the right - according to the respective element ``x2_i`` of the input array ``x2``. + """Shifts the bits of each element ``x1_i`` of the input array ``x1`` to + the right according to the respective element ``x2_i`` of the input array + ``x2``. .. note:: This operation must be an arithmetic shift (i.e., sign-propagating) and thus @@ -1501,10 +1493,9 @@ def bitwise_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the bitwise XOR of the underlying binary representation of each element - ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """Compute the bitwise XOR of the underlying binary representation of each + element ``x1_i`` of the input array ``x1`` with the respective element + ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -1606,9 +1597,9 @@ def ceil( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round each element ``x_i`` of the input array ``x`` to the smallest (i.e., closest - to ``-infinity``) integer-valued number that is not less than ``x_i``. + """Round each element ``x_i`` of the input array ``x`` to the smallest + (i.e., closest to ``-infinity``) integer-valued number that is not less + than ``x_i``. **Special cases** @@ -1697,10 +1688,10 @@ def cos( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the cosine, having domain - ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each element ``x_i`` of - the input array ``x``. Each element ``x_i`` is assumed to be expressed in radians. + """Calculate an implementation-dependent approximation to the cosine, + having domain ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for + each element ``x_i`` of the input array ``x``. Each element ``x_i`` is + assumed to be expressed in radians. **Special cases** @@ -1784,10 +1775,9 @@ def cosh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the hyperbolic cosine, having - domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, for each - element ``x_i`` in the input array ``x``. + """Calculate an implementation-dependent approximation to the hyperbolic + cosine, having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, + +infinity]``, for each element ``x_i`` in the input array ``x``. **Special cases** @@ -1904,9 +1894,8 @@ def divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate the division for each element x1_i of the input array x1 with the - respective element x2_i of the input array x2. + r"""Calculate the division for each element x1_i of the input array x1 with + the respective element x2_i of the input array x2. **Special Cases** @@ -2096,9 +2085,8 @@ def equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of x1_i == x2_i for each element x1_i of the input array x1 - with the respective element x2_i of the input array x2. + """Compute the truth value of x1_i == x2_i for each element x1_i of the + input array x1 with the respective element x2_i of the input array x2. Parameters ---------- @@ -2213,11 +2201,11 @@ def exp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the exponential function, - having domain ``[-infinity, +infinity]`` and codomain ``[+0, +infinity]``, for each - element ``x_i`` of the input array ``x`` (``e`` raised to the power of ``x_i``, - where ``e`` is the base of the natural logarithm). + """Calculate an implementation-dependent approximation to the exponential + function, having domain ``[-infinity, +infinity]`` and codomain ``[+0, + +infinity]``, for each element ``x_i`` of the input array ``x`` (``e`` + raised to the power of ``x_i``, where ``e`` is the base of the natural + logarithm). .. note:: For complex floating-point operands, ``exp(conj(x))`` must @@ -2352,9 +2340,8 @@ def imag( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the imaginary part of a complex number for each element ``x_i`` of the input - array ``val``. + """Return the imaginary part of a complex number for each element ``x_i`` + of the input array ``val``. Parameters ---------- @@ -2406,8 +2393,7 @@ def angle( deg: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate Element-wise the angle for an array of complex numbers(x+yj). + """Calculate Element-wise the angle for an array of complex numbers(x+yj). Parameters ---------- @@ -2450,8 +2436,7 @@ def gcd( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the greatest common divisor of |x1| and |x2|. + """Return the greatest common divisor of |x1| and |x2|. Parameters ---------- @@ -2492,8 +2477,7 @@ def exp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate 2**p for all p in the input array. + """Calculate 2**p for all p in the input array. Parameters ---------- @@ -2533,10 +2517,9 @@ def expm1( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to ``exp(x)-1``, having domain - ``[-infinity, +infinity]`` and codomain ``[-1, +infinity]``, for each element - ``x_i`` of the input array ``x``. + """Calculate an implementation-dependent approximation to ``exp(x)-1``, + having domain ``[-infinity, +infinity]`` and codomain ``[-1, +infinity]``, + for each element ``x_i`` of the input array ``x``. .. note:: The purpose of this function is to calculate ``exp(x)-1.0`` more accurately when @@ -2660,9 +2643,9 @@ def floor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round each element ``x_i`` of the input array ``x`` to the greatest (i.e., closest - to ``+infinity``) integer-valued number that is not greater than ``x_i``. + """Round each element ``x_i`` of the input array ``x`` to the greatest + (i.e., closest to ``+infinity``) integer-valued number that is not greater + than ``x_i``. **Special cases** @@ -2751,10 +2734,10 @@ def floor_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Round the result of dividing each element x1_i of the input array x1 by the - respective element x2_i of the input array x2 to the greatest (i.e., closest to - +infinity) integer-value number that is not greater than the division result. + r"""Round the result of dividing each element x1_i of the input array x1 by + the respective element x2_i of the input array x2 to the greatest (i.e., + closest to +infinity) integer-value number that is not greater than the + division result. .. note:: For input arrays which promote to an integer data type, @@ -2949,10 +2932,9 @@ def fmin( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the element-wise minimums of two arrays. Differs from ivy.minimum in the - case where one of the elements is NaN. ivy.minimum returns the NaN element while - ivy.fmin returns the non-NaN element. + """Compute the element-wise minimums of two arrays. Differs from + ivy.minimum in the case where one of the elements is NaN. ivy.minimum + returns the NaN element while ivy.fmin returns the non-NaN element. Parameters ---------- @@ -2997,9 +2979,8 @@ def greater( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of x1_i < x2_i for each element x1_i of the input array x1 - with the respective element x2_i of the input array x2. + """Compute the truth value of x1_i < x2_i for each element x1_i of the + input array x1 with the respective element x2_i of the input array x2. Parameters ---------- @@ -3098,9 +3079,8 @@ def greater_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of x1_i >= x2_i for each element x1_i of the input array x1 - with the respective element x2_i of the input array x2. + """Compute the truth value of x1_i >= x2_i for each element x1_i of the + input array x1 with the respective element x2_i of the input array x2. Parameters ---------- @@ -3185,9 +3165,8 @@ def less_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of x1_i <= x2_i for each element x1_i of the input array x1 - with the respective element x2_i of the input array x2. + """Compute the truth value of x1_i <= x2_i for each element x1_i of the + input array x1 with the respective element x2_i of the input array x2. Parameters ---------- @@ -3272,9 +3251,8 @@ def multiply( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate the product for each element x1_i of the input array x1 with the - respective element x2_i of the input array x2. + r"""Calculate the product for each element x1_i of the input array x1 with + the respective element x2_i of the input array x2. .. note:: Floating-point multiplication is not always associative due to finite precision. @@ -3458,9 +3436,8 @@ def isfinite( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element ``x_i`` of the input array ``x`` to determine if finite (i.e., not - ``NaN`` and not equal to positive or negative infinity). + """Test each element ``x_i`` of the input array ``x`` to determine if + finite (i.e., not ``NaN`` and not equal to positive or negative infinity). Parameters ---------- @@ -3558,9 +3535,8 @@ def isinf( detect_negative: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element x_i of the input array x to determine if equal to positive or - negative infinity. + """Test each element x_i of the input array x to determine if equal to + positive or negative infinity. Parameters ---------- @@ -3681,9 +3657,8 @@ def isnan( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element ``x_i`` of the input array ``x`` to determine whether the element - is ``NaN``. + """Test each element ``x_i`` of the input array ``x`` to determine whether + the element is ``NaN``. Parameters ---------- @@ -3791,9 +3766,9 @@ def less( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of ``x1_i < x2_i`` for each element ``x1_i`` of the input - array ``x1`` with the respective element ``x2_i`` of the input array ``x2``. + """Compute the truth value of ``x1_i < x2_i`` for each element ``x1_i`` of + the input array ``x1`` with the respective element ``x2_i`` of the input + array ``x2``. Parameters ---------- @@ -3881,10 +3856,10 @@ def log( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the natural (base ``e``) - logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, - for each element ``x_i`` of the input array ``x``. + """Calculate an implementation-dependent approximation to the natural (base + ``e``) logarithm, having domain ``[0, +infinity]`` and codomain + ``[-infinity, +infinity]``, for each element ``x_i`` of the input array + ``x``. **Special cases** @@ -3982,10 +3957,9 @@ def log10( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate an implementation-dependent approximation to the base ``10`` logarithm, - having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, for each - element ``x_i`` of the input array ``x``. + r"""Calculate an implementation-dependent approximation to the base ``10`` + logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, + +infinity]``, for each element ``x_i`` of the input array ``x``. **Special cases** @@ -4077,9 +4051,8 @@ def log1p( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to log(1+x), where log refers to - the natural (base e) logarithm. + """Calculate an implementation-dependent approximation to log(1+x), where + log refers to the natural (base e) logarithm. .. note:: The purpose of this function is to calculate ``log(1+x)`` more accurately @@ -4196,10 +4169,9 @@ def log2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate an implementation-dependent approximation to the base ``2`` logarithm, - having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, for each - element ``x_i`` of the input array ``x``. + r"""Calculate an implementation-dependent approximation to the base ``2`` + logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, + +infinity]``, for each element ``x_i`` of the input array ``x``. **Special cases** @@ -4294,10 +4266,9 @@ def logaddexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the logarithm of the sum of exponentiations ``log(exp(x1) + exp(x2))`` for - each element ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` - of the input array ``x2``. + """Calculate the logarithm of the sum of exponentiations ``log(exp(x1) + + exp(x2))`` for each element ``x1_i`` of the input array ``x1`` with the + respective element ``x2_i`` of the input array ``x2``. **Special cases** @@ -4395,8 +4366,7 @@ def logaddexp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate log2(2**x1 + 2**x2). + """Calculate log2(2**x1 + 2**x2). Parameters ---------- @@ -4439,9 +4409,8 @@ def logical_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logical AND for each element x1_i of the input array x1 with the - respective element x2_i of the input array x2. + """Compute the logical AND for each element x1_i of the input array x1 with + the respective element x2_i of the input array x2. Parameters ---------- @@ -4540,8 +4509,8 @@ def logical_not( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logical NOT for each element ``x_i`` of the input array ``x``. + """Compute the logical NOT for each element ``x_i`` of the input array + ``x``. .. note:: While this specification recommends that this function only accept input arrays @@ -4638,9 +4607,8 @@ def logical_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logical OR for each element ``x1_i`` of the input array ``x1`` with the - respective element ``x2_i`` of the input array ``x2``. + """Compute the logical OR for each element ``x1_i`` of the input array + ``x1`` with the respective element ``x2_i`` of the input array ``x2``. .. note:: While this specification recommends that this function only accept input arrays @@ -4730,10 +4698,9 @@ def logical_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the bitwise XOR of the underlying binary representation of each element - ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """Compute the bitwise XOR of the underlying binary representation of each + element ``x1_i`` of the input array ``x1`` with the respective element + ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -4832,9 +4799,9 @@ def nan_to_num( neginf: Optional[Union[float, int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Replace NaN with zero and infinity with large finite numbers (default behaviour) or - with the numbers defined by the user using the nan, posinf and/or neginf keywords. + """Replace NaN with zero and infinity with large finite numbers (default + behaviour) or with the numbers defined by the user using the nan, posinf + and/or neginf keywords. Parameters ---------- @@ -4891,8 +4858,7 @@ def negative( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array with the negative value of each element in ``x``. + """Return a new array with the negative value of each element in ``x``. .. note:: For signed integer data types, the numerical negative of @@ -4978,9 +4944,9 @@ def not_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of ``x1_i != x2_i`` for each element ``x1_i`` of the input - array ``x1`` with the respective element ``x2_i`` of the input array ``x2``. + """Compute the truth value of ``x1_i != x2_i`` for each element ``x1_i`` of + the input array ``x1`` with the respective element ``x2_i`` of the input + array ``x2``. **Special Cases** @@ -5161,8 +5127,7 @@ def positive( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array with the positive value of each element in ``x``. + """Return a new array with the positive value of each element in ``x``. Parameters ---------- @@ -5238,11 +5203,10 @@ def pow( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of exponentiation by raising - each element ``x1_i`` (the base) of the input array ``x1`` to the power of ``x2_i`` - (the exponent), where ``x2_i`` is the corresponding element of the input array - ``x2``. + """Calculate an implementation-dependent approximation of exponentiation by + raising each element ``x1_i`` (the base) of the input array ``x1`` to the + power of ``x2_i`` (the exponent), where ``x2_i`` is the corresponding + element of the input array ``x2``. **Special cases** @@ -5384,11 +5348,10 @@ def real( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element ``x_i`` of the input array ``x`` to take only real part from it. - Returns a float array, where it only contains . If element has complex type with - zero complex part, the return value will be that element, else it only returns real - part. + """Test each element ``x_i`` of the input array ``x`` to take only real + part from it. Returns a float array, where it only contains . If element + has complex type with zero complex part, the return value will be that + element, else it only returns real part. Parameters ---------- @@ -5457,9 +5420,8 @@ def remainder( modulus: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the remainder of division for each element ``x1_i`` of the input array ``x1`` - and the respective element ``x2_i`` of the input array ``x2``. + """Return the remainder of division for each element ``x1_i`` of the input + array ``x1`` and the respective element ``x2_i`` of the input array ``x2``. .. note:: This function is equivalent to the Python modulus operator ``x1_i % x2_i``. For @@ -5587,9 +5549,8 @@ def round( decimals: Optional[int] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round each element ``x_i`` of the input array ``x`` to the nearest integer-valued - number. + """Round each element ``x_i`` of the input array ``x`` to the nearest + integer-valued number. .. note:: For complex floating-point operands, real and imaginary components @@ -5709,9 +5670,8 @@ def sign( np_variant: Optional[bool] = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Return an indication of the sign of a number for each element ``x_i`` of the input - array ``x``. + r"""Return an indication of the sign of a number for each element ``x_i`` of + the input array ``x``. The sign function (also known as the **signum function**) of a number :math:`x_{i}` is defined as @@ -5818,10 +5778,10 @@ def sin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate an implementation-dependent approximation to the sine, having domain - ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each element ``x_i`` of - the input array ``x``. Each element ``x_i`` is assumed to be expressed in radians. + r"""Calculate an implementation-dependent approximation to the sine, having + domain ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each + element ``x_i`` of the input array ``x``. Each element ``x_i`` is assumed + to be expressed in radians. .. note:: The sine is an entire function on the complex plane and has no branch cuts. @@ -5913,10 +5873,9 @@ def sinh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate an implementation-dependent approximation to the hyperbolic sine, having - domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, for each - element ``x_i`` of the input array ``x``. + r"""Calculate an implementation-dependent approximation to the hyperbolic + sine, having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, + +infinity]``, for each element ``x_i`` of the input array ``x``. .. math:: \operatorname{sinh}(x) = \frac{e^x - e^{-x}}{2} @@ -6037,11 +5996,10 @@ def sqrt( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate the square root, having domain ``[0, +infinity]`` and codomain ``[0, - +infinity]``, for each element ``x_i`` of the input array ``x``. After rounding, - each result must be indistinguishable from the infinitely precise result (as - required by IEEE 754). + r"""Calculate the square root, having domain ``[0, +infinity]`` and codomain + ``[0, +infinity]``, for each element ``x_i`` of the input array ``x``. + After rounding, each result must be indistinguishable from the infinitely + precise result (as required by IEEE 754). .. note:: After rounding, each result must be indistinguishable @@ -6169,8 +6127,7 @@ def square( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Each element ``x_i`` of the input array ``x``. + """Each element ``x_i`` of the input array ``x``. Parameters ---------- @@ -6244,9 +6201,8 @@ def subtract( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the difference for each element ``x1_i`` of the input array ``x1`` with - the respective element ``x2_i`` of the input array ``x2``. + """Calculate the difference for each element ``x1_i`` of the input array + ``x1`` with the respective element ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -6414,10 +6370,9 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the hyperbolic tangent, - having domain ``[-infinity, +infinity]`` and codomain ``[-1, +1]``, for each element - ``x_i`` of the input array ``x``. + """Calculate an implementation-dependent approximation to the hyperbolic + tangent, having domain ``[-infinity, +infinity]`` and codomain ``[-1, + +1]``, for each element ``x_i`` of the input array ``x``. **Special cases** @@ -6557,8 +6512,7 @@ def trapz( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Integrate along the given axis using the composite trapezoidal rule. + """Integrate along the given axis using the composite trapezoidal rule. If x is provided, the integration happens in sequence along its elements - they are not sorted.. @@ -6615,9 +6569,8 @@ def trunc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round each element x_i of the input array x to the integer-valued number that is - closest to but no greater than x_i. + """Round each element x_i of the input array x to the integer-valued number + that is closest to but no greater than x_i. **Special cases** @@ -6708,8 +6661,7 @@ def erf( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Gauss error function of ``x`` element-wise. + """Compute the Gauss error function of ``x`` element-wise. Parameters ---------- @@ -6772,8 +6724,7 @@ def maximum( use_where: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the max of x1 and x2 (i.e. x1 > x2 ? x1 : x2) element-wise. + """Return the max of x1 and x2 (i.e. x1 > x2 ? x1 : x2) element-wise. Parameters ---------- @@ -6864,8 +6815,7 @@ def minimum( use_where: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the min of x1 and x2 (i.e. x1 < x2 ? x1 : x2) element-wise. + """Return the min of x1 and x2 (i.e. x1 < x2 ? x1 : x2) element-wise. Parameters ---------- @@ -6955,8 +6905,7 @@ def reciprocal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array with the reciprocal of each element in ``x``. + """Return a new array with the reciprocal of each element in ``x``. Parameters ---------- @@ -6994,8 +6943,7 @@ def deg2rad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Convert the input from degrees to radians. + """Convert the input from degrees to radians. Parameters ---------- @@ -7073,8 +7021,7 @@ def rad2deg( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Convert the input from radians to degrees. + """Convert the input from radians to degrees. Parameters ---------- @@ -7151,9 +7098,8 @@ def trunc_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Perform element-wise integer division of the inputs rounding the results towards - zero. + """Perform element-wise integer division of the inputs rounding the results + towards zero. Parameters ---------- @@ -7212,11 +7158,10 @@ def isreal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element ``x_i`` of the input array ``x`` to determine whether the element - is real number. Returns a bool array, where True if input element is real. If - element has complex type with zero complex part, the return value for that element - is True. + """Test each element ``x_i`` of the input array ``x`` to determine whether + the element is real number. Returns a bool array, where True if input + element is real. If element has complex type with zero complex part, the + return value for that element is True. Parameters ---------- @@ -7278,8 +7223,7 @@ def fmod( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the element-wise remainder of divisions of two arrays. + """Compute the element-wise remainder of divisions of two arrays. Parameters ---------- @@ -7322,8 +7266,7 @@ def lcm( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the element-wise least common multiple (LCM) of x1 and x2. + """Compute the element-wise least common multiple (LCM) of x1 and x2. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/activations.py b/ivy/functional/ivy/experimental/activations.py index 1b1fda6b32a08..f9788a93ffadf 100644 --- a/ivy/functional/ivy/experimental/activations.py +++ b/ivy/functional/ivy/experimental/activations.py @@ -53,8 +53,7 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logit of x. + """Compute the logit of x. logit(x) = log(x / (1 - x)). @@ -107,8 +106,7 @@ def prelu( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Prelu takes input data (Array) and slope array as input, + """Prelu takes input data (Array) and slope array as input, and produces one output data (array) where the function f(x) = slope * x for x < 0, f(x) = x for x >= 0., is applied @@ -165,8 +163,7 @@ def thresholded_relu( threshold: Union[int, float] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the rectified linear unit function with custom threshold. + """Apply the rectified linear unit function with custom threshold. Parameters ---------- @@ -250,8 +247,7 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the rectified linear unit 6 function element-wise. + """Apply the rectified linear unit 6 function element-wise. Parameters ---------- @@ -306,8 +302,7 @@ def logsigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply element-wise Log-sigmoid of x. + """Apply element-wise Log-sigmoid of x. logsigmoid(x) = log(1 / (1 + exp(-x)). @@ -361,8 +356,7 @@ def logsigmoid( def selu( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Apply the scaled exponential linear unit function element-wise. + """Apply the scaled exponential linear unit function element-wise. Parameters ---------- @@ -420,8 +414,7 @@ def selu( def silu( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Apply the silu function element-wise. + """Apply the silu function element-wise. Parameters ---------- @@ -473,8 +466,7 @@ def elu( alpha: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the elu unit function element-wise. + """Apply the elu unit function element-wise. Parameters ---------- @@ -536,8 +528,7 @@ def hardtanh( min_val: float = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the hardtanh unit function element-wise. + """Apply the hardtanh unit function element-wise. Parameters ---------- @@ -596,8 +587,7 @@ def hardtanh( def tanhshrink( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Apply the tanhshrink function element-wise. + """Apply the tanhshrink function element-wise. Parameters ---------- @@ -650,8 +640,7 @@ def softshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the softshrink function element-wise. + """Apply the softshrink function element-wise. Parameters ---------- @@ -738,8 +727,7 @@ def threshold( value: float, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the threshold function element-wise. + """Apply the threshold function element-wise. Parameters ---------- @@ -798,9 +786,8 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the Continuously Differentiable Exponential Linear Unit (CELU) activation - function to each element of the input. + """Apply the Continuously Differentiable Exponential Linear Unit (CELU) + activation function to each element of the input. Parameters ---------- @@ -861,8 +848,7 @@ def scaled_tanh( beta: float = 0.67, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the scaled hyperbolic tangent (tanh) activation. + """Compute the scaled hyperbolic tangent (tanh) activation. The scaled tanh activation function is defined as: out = alpha * tanh(beta * x) @@ -940,8 +926,7 @@ def hardshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the hardshrink function element-wise. + """Apply the hardshrink function element-wise. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/creation.py b/ivy/functional/ivy/experimental/creation.py index ff9ed655f1592..f1871a3098b28 100644 --- a/ivy/functional/ivy/experimental/creation.py +++ b/ivy/functional/ivy/experimental/creation.py @@ -33,9 +33,8 @@ def vorbis_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an array that contains a vorbis power complementary window of size - window_length. + """Return an array that contains a vorbis power complementary window of + size window_length. Parameters ---------- @@ -76,9 +75,8 @@ def hann_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a Hann window. The Hanning window is a taper formed by using a weighted - cosine. + """Generate a Hann window. The Hanning window is a taper formed by using a + weighted cosine. Parameters ---------- @@ -125,8 +123,8 @@ def kaiser_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Kaiser window with window length window_length and shape beta. + """Compute the Kaiser window with window length window_length and shape + beta. Parameters ---------- @@ -172,9 +170,8 @@ def kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Kaiser bessel derived window with window length window_length and shape - beta. + """Compute the Kaiser bessel derived window with window length + window_length and shape beta. Parameters ---------- @@ -226,8 +223,7 @@ def hamming_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Hamming window with window length window_length. + """Compute the Hamming window with window length window_length. Parameters ---------- @@ -292,16 +288,16 @@ def tril_indices( *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Tuple[ivy.Array, ...]: - """ - Return the indices of the lower triangular part of a row by col matrix in a 2-by-N - shape (tuple of two N dimensional arrays), where the first row contains row - coordinates of all indices and the second row contains column coordinates. Indices - are ordered based on rows and then columns. The lower triangular part of the matrix - is defined as the elements on and below the diagonal. The argument k controls which - diagonal to consider. If k = 0, all elements on and below the main diagonal are - retained. A positive value excludes just as many diagonals below the main diagonal, - and similarly a negative value includes just as many diagonals above the main - diagonal. The main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, + """Return the indices of the lower triangular part of a row by col matrix + in a 2-by-N shape (tuple of two N dimensional arrays), where the first row + contains row coordinates of all indices and the second row contains column + coordinates. Indices are ordered based on rows and then columns. The lower + triangular part of the matrix is defined as the elements on and below the + diagonal. The argument k controls which diagonal to consider. If k = 0, + all elements on and below the main diagonal are retained. A positive value + excludes just as many diagonals below the main diagonal, and similarly a + negative value includes just as many diagonals above the main diagonal. The + main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, n_cols}−1]. Notes @@ -390,10 +386,9 @@ def eye_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a 2D array filled with ones on the k diagonal and zeros elsewhere. having the - same ``shape`` as the first and last dim of input array ``x``. input array ``x`` - should to be 2D. + """Return a 2D array filled with ones on the k diagonal and zeros + elsewhere. having the same ``shape`` as the first and last dim of input + array ``x``. input array ``x`` should to be 2D. Parameters ---------- @@ -483,8 +478,7 @@ def _iter_product(*args, repeat=1): def ndenumerate( input: Iterable, ) -> Generator: - """ - Multidimensional index iterator. + """Multidimensional index iterator. Parameters ---------- @@ -523,8 +517,7 @@ def _ndenumerate(input): def ndindex( shape: Tuple, ) -> Generator: - """ - Multidimensional index iterator. + """Multidimensional index iterator. Parameters ---------- @@ -557,8 +550,7 @@ def indices( dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, sparse: bool = False, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """ - Return an array representing the indices of a grid. + """Return an array representing the indices of a grid. Parameters ---------- @@ -618,9 +610,8 @@ def unsorted_segment_min( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Compute the minimum along segments of an array. Segments are defined by an integer - array of segment IDs. + """Compute the minimum along segments of an array. Segments are defined by + an integer array of segment IDs. Note ---- @@ -658,9 +649,8 @@ def unsorted_segment_sum( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Compute the sum of elements along segments of an array. Segments are defined by an - integer array of segment IDs. + """Compute the sum of elements along segments of an array. Segments are + defined by an integer array of segment IDs. Parameters ---------- @@ -698,10 +688,10 @@ def blackman_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a Blackman window. The Blackman window is a taper formed by using the first - three terms of a summation of cosines. It was designed to have close to the minimal - leakage possible. It is close to optimal, only slightly worse than a Kaiser window. + """Generate a Blackman window. The Blackman window is a taper formed by + using the first three terms of a summation of cosines. It was designed to + have close to the minimal leakage possible. It is close to optimal, only + slightly worse than a Kaiser window. Parameters ---------- @@ -747,8 +737,7 @@ def random_tucker( seed: Optional[int] = None, non_negative: Optional[bool] = False, ) -> Union[ivy.TuckerTensor, ivy.Array]: - """ - Generate a random Tucker tensor. + """Generate a random Tucker tensor. Parameters ---------- @@ -817,8 +806,7 @@ def random_cp( seed: Optional[int] = None, normalise_factors: Optional[bool] = True, ) -> Union[ivy.CPTensor, ivy.Array]: - """ - Generate a random CP tensor. + """Generate a random CP tensor. Parameters ---------- @@ -872,8 +860,7 @@ def random_tr( full: Optional[bool] = False, seed: Optional[int] = None, ) -> Union[ivy.TRTensor, ivy.Array]: - """ - Generate a random TR tensor. + """Generate a random TR tensor. Parameters ---------- @@ -931,8 +918,7 @@ def random_parafac2( seed: Optional[int] = None, normalise_factors: Optional[bool] = True, ) -> Union[ivy.Parafac2Tensor, ivy.Array]: - """ - Generate a random PARAFAC2 tensor. + """Generate a random PARAFAC2 tensor. Parameters ---------- @@ -988,8 +974,7 @@ def random_tt( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, seed: Optional[int] = None, ) -> Union[ivy.TTTensor, ivy.Array]: - """ - Generate a random TT/MPS tensor. + """Generate a random TT/MPS tensor. Parameters ---------- @@ -1098,10 +1083,10 @@ def mel_weight_matrix( lower_edge_hertz: float = 0.0, upper_edge_hertz: float = 3000.0, ): - """ - Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a - linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins frequency - information based on the [lower_edge_hertz, upper_edge_hertz] + """Generate a MelWeightMatrix that can be used to re-weight a Tensor + containing a linearly sampled frequency spectra (from DFT or STFT) into + num_mel_bins frequency information based on the [lower_edge_hertz, + upper_edge_hertz] range on the mel scale. This function defines the mel scale in terms of a frequency in hertz according to the following formula: mel(f) = 2595 * log10(1 + f/700) @@ -1149,9 +1134,8 @@ def unsorted_segment_mean( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Compute the mean of elements along segments of an array. Segments are defined by an - integer array of segment IDs. + """Compute the mean of elements along segments of an array. Segments are + defined by an integer array of segment IDs. Parameters ---------- @@ -1184,8 +1168,7 @@ def polyval( coeffs: Union[ivy.Array, ivy.NativeArray], x: Union[ivy.Array, ivy.NativeArray], ): - """ - Evaluate and return a polynomial at specific given values. + """Evaluate and return a polynomial at specific given values. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/elementwise.py b/ivy/functional/ivy/experimental/elementwise.py index 09a208c346a5b..83025fd5dd56f 100644 --- a/ivy/functional/ivy/experimental/elementwise.py +++ b/ivy/functional/ivy/experimental/elementwise.py @@ -32,8 +32,7 @@ def amax( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the maximum value of the input array ``x``. + """Calculate the maximum value of the input array ``x``. .. note:: ``amax`` is an alias of ``max`` and both function @@ -149,8 +148,7 @@ def amin( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the minimum value of the input array ``x``. + """Calculate the minimum value of the input array ``x``. .. note:: ``amin`` is an alias of ``min`` and both function @@ -265,8 +263,8 @@ def lgamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the natural logarithm of the absolute value of the gamma function on x. + """Compute the natural logarithm of the absolute value of the gamma + function on x. Parameters ---------- @@ -316,11 +314,11 @@ def sinc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the principal value of the - normalized sinc function, having domain ``(-infinity, +infinity)`` and codomain - ``[-0.217234, 1]``, for each element ``x_i`` of the input array ``x``. Each element - ``x_i`` is assumed to be expressed in radians. + """Calculate an implementation-dependent approximation of the principal + value of the normalized sinc function, having domain ``(-infinity, + +infinity)`` and codomain ``[-0.217234, 1]``, for each element ``x_i`` of + the input array ``x``. Each element ``x_i`` is assumed to be expressed in + radians. **Special cases** @@ -393,10 +391,9 @@ def fmax( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the element-wise maximums of two arrays. Differs from ivy.maximum in the - case where one of the elements is NaN. ivy.maximum returns the NaN element while - ivy.fmax returns the non-NaN element. + """Compute the element-wise maximums of two arrays. Differs from + ivy.maximum in the case where one of the elements is NaN. ivy.maximum + returns the NaN element while ivy.fmax returns the non-NaN element. Parameters ---------- @@ -439,11 +436,10 @@ def float_power( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Raise each base in x1 to the positionally-corresponding power in x2. x1 and x2 must - be broadcastable to the same shape. This differs from the power function in that - integers, float16, and float32 are promoted to floats with a minimum precision of - float64 so that the result is always inexact. + """Raise each base in x1 to the positionally-corresponding power in x2. x1 + and x2 must be broadcastable to the same shape. This differs from the power + function in that integers, float16, and float32 are promoted to floats with + a minimum precision of float64 so that the result is always inexact. Parameters ---------- @@ -488,9 +484,8 @@ def copysign( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Change the signs of x1 to match x2 x1 and x2 must be broadcastable to a common - shape. + """Change the signs of x1 to match x2 x1 and x2 must be broadcastable to a + common shape. Parameters ---------- @@ -538,8 +533,7 @@ def count_nonzero( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Count the number of non-zero values in the array a. + """Count the number of non-zero values in the array a. Parameters ---------- @@ -598,9 +592,8 @@ def nansum( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as - zero. + """Return the sum of array elements over a given axis treating Not a + Numbers (NaNs) as zero. Parameters ---------- @@ -657,8 +650,8 @@ def isclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a boolean array where two arrays are element-wise equal within a tolerance. + """Return a boolean array where two arrays are element-wise equal within a + tolerance. The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(b)) and the absolute difference @@ -718,8 +711,7 @@ def signbit( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return element-wise True where signbit is set (less than zero). + """Return element-wise True where signbit is set (less than zero). Parameters ---------- @@ -755,8 +747,7 @@ def hypot( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Return the hypotenuse given the two sides of a right angle triangle. + """Return the hypotenuse given the two sides of a right angle triangle. Parameters ---------- @@ -796,8 +787,7 @@ def diff( append: Optional[Union[ivy.Array, ivy.NativeArray, int, list, tuple]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the n-th discrete difference along the given axis. + """Return the n-th discrete difference along the given axis. Parameters ---------- @@ -852,9 +842,8 @@ def allclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> bool: - """ - Return a True if the two arrays are element-wise equal within given tolerance; - otherwise False. + """Return a True if the two arrays are element-wise equal within given + tolerance; otherwise False. The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(x2)) and the absolute difference @@ -923,9 +912,8 @@ def fix( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round an array of floats element-wise to nearest integer towards zero. The rounded - values are returned as floats. + """Round an array of floats element-wise to nearest integer towards zero. + The rounded values are returned as floats. Parameters ---------- @@ -963,8 +951,7 @@ def nextafter( *, out: Optional[ivy.Array] = None, ) -> bool: - """ - Return the next floating-point value after x1 towards x2, element-wise. + """Return the next floating-point value after x1 towards x2, element-wise. Parameters ---------- @@ -1005,9 +992,8 @@ def zeta( *, out: Optional[ivy.Array] = None, ) -> bool: - """ - Compute the Hurwitz zeta function elementwisely with each pair of floats in two - arrays. + """Compute the Hurwitz zeta function elementwisely with each pair of floats + in two arrays. Parameters ---------- @@ -1049,8 +1035,7 @@ def gradient( edge_order: int = 1, axis: Optional[Union[int, list, tuple]] = None, ) -> Union[ivy.Array, List[ivy.Array]]: - """ - Calculate gradient of x with respect to (w.r.t.) spacing. + """Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -1128,8 +1113,7 @@ def xlogy( *, out: Optional[ivy.Array] = None, ) -> bool: - """ - Compute x*log(y) element-wise so that the result is 0 if x = 0. + """Compute x*log(y) element-wise so that the result is 0 if x = 0. Parameters ---------- @@ -1173,9 +1157,8 @@ def binarizer( threshold: float = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Map the values of the input tensor to either 0 or 1, element-wise, based on the - outcome of a comparison against a threshold value. + """Map the values of the input tensor to either 0 or 1, element-wise, based + on the outcome of a comparison against a threshold value. Parameters ---------- @@ -1215,8 +1198,8 @@ def conj( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the complex conjugate for each element ``x_i`` of the input array ``x``. + """Return the complex conjugate for each element ``x_i`` of the input array + ``x``. For complex number of the form @@ -1299,8 +1282,7 @@ def ldexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return x1 * (2**x2), element-wise. + """Return x1 * (2**x2), element-wise. Parameters ---------- @@ -1342,8 +1324,8 @@ def lerp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a linear interpolation of two arrays start (given by input) and end. + """Return a linear interpolation of two arrays start (given by input) and + end. based on a scalar or array weight. input + weight * (end - input), element-wise. @@ -1469,8 +1451,7 @@ def frexp( *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Decompose the elements of x into mantissa and twos exponent. + """Decompose the elements of x into mantissa and twos exponent. Parameters ---------- @@ -1506,8 +1487,7 @@ def modf( *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Decompose the elements of x into fractional and integral parts. + """Decompose the elements of x into fractional and integral parts. Parameters ---------- @@ -1541,8 +1521,7 @@ def digamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logarithmic derivative of the gamma function at x. + """Compute the logarithmic derivative of the gamma function at x. Note ---- @@ -1582,9 +1561,8 @@ def sparsify_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Zeros out all elements in the tensor except `card` elements with maximum absolute - values. + """Zeros out all elements in the tensor except `card` elements with maximum + absolute values. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/general.py b/ivy/functional/ivy/experimental/general.py index cef0bc2091951..144f10256c7be 100644 --- a/ivy/functional/ivy/experimental/general.py +++ b/ivy/functional/ivy/experimental/general.py @@ -39,8 +39,8 @@ def reduce( axes: Union[int, Sequence[int]] = 0, keepdims: bool = False, ) -> ivy.Array: - """ - Reduces the input array's dimensions by applying a function along one or more axes. + """Reduces the input array's dimensions by applying a function along one or + more axes. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/gradients.py b/ivy/functional/ivy/experimental/gradients.py index 8c5466de75168..126a219d890f5 100644 --- a/ivy/functional/ivy/experimental/gradients.py +++ b/ivy/functional/ivy/experimental/gradients.py @@ -3,8 +3,7 @@ def bind_custom_gradient_function(func, custom_grad_func): - """ - Bind a custom gradient function to a function. + """Bind a custom gradient function to a function. Parameters ---------- @@ -23,8 +22,7 @@ def bind_custom_gradient_function(func, custom_grad_func): def vjp(func, *primals): - """ - Compute a (reverse-mode) vector-Jacobian product of `func`. + """Compute a (reverse-mode) vector-Jacobian product of `func`. Parameters ---------- @@ -43,8 +41,7 @@ def vjp(func, *primals): def jvp(func, primals, tangents): - """ - Compute a (forward-mode) Jacobian-vector product of `func`. + """Compute a (forward-mode) Jacobian-vector product of `func`. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index b88ac84f01efd..f8a122fb53e84 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -43,8 +43,7 @@ def max_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D max pool given 3-D input x. + """Compute a 1-D max pool given 3-D input x. Parameters ---------- @@ -131,8 +130,7 @@ def max_pool2d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D max pool given 4-D input x. + """Compute a 2-D max pool given 4-D input x. Parameters ---------- @@ -219,8 +217,7 @@ def max_pool3d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D max pool given 5-D input x. + """Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -306,8 +303,7 @@ def avg_pool1d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D avg pool given 3-D input x. + """Compute a 1-D avg pool given 3-D input x. Parameters ---------- @@ -389,8 +385,7 @@ def avg_pool2d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D average pool given 4-D input x. + """Compute a 2-D average pool given 4-D input x. Parameters ---------- @@ -477,8 +472,7 @@ def avg_pool3d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D avg pool given 5-D input x. + """Compute a 3-D avg pool given 5-D input x. Parameters ---------- @@ -565,8 +559,7 @@ def pool( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Perform an N-D pooling operation. + """Perform an N-D pooling operation. Parameters ---------- @@ -641,8 +634,7 @@ def dct( norm: Optional[Literal["ortho"]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the 1D Discrete Cosine Transformation of a given signal. + """Compute the 1D Discrete Cosine Transformation of a given signal. Parameters ---------- @@ -752,8 +744,7 @@ def idct( norm: Optional[Literal["ortho"]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the 1D Inverse Discrete Cosine Transformation of a given signal. + """Compute the 1D Inverse Discrete Cosine Transformation of a given signal. Parameters ---------- @@ -876,9 +867,8 @@ def fft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the one dimensional discrete Fourier transform given input at least 1-D - input x. + r"""Compute the one dimensional discrete Fourier transform given input at + least 1-D input x. Parameters ---------- @@ -946,11 +936,10 @@ def dropout1d( data_format: str = "NWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Randomly zero out entire channels with probability prob using samples from a - Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this - case, dropout1d performs a channel-wise dropout but assumes a channel is a 1D - feature map. + """Randomly zero out entire channels with probability prob using samples + from a Bernoulli distribution and the remaining channels are scaled by + (1/1-prob). In this case, dropout1d performs a channel-wise dropout but + assumes a channel is a 1D feature map. Parameters ---------- @@ -1022,11 +1011,10 @@ def dropout2d( data_format: str = "NHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Randomly zero out entire channels with probability prob using samples from a - Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this - case, dropout2d performs a channel-wise dropout but assumes a channel is a 2D - feature map. + """Randomly zero out entire channels with probability prob using samples + from a Bernoulli distribution and the remaining channels are scaled by + (1/1-prob). In this case, dropout2d performs a channel-wise dropout but + assumes a channel is a 2D feature map. Parameters ---------- @@ -1088,11 +1076,10 @@ def dropout3d( data_format: str = "NDHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Randomly zero out entire channels with probability prob using samples from a - Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this - case, dropout3d performs a channel-wise dropout but assumes a channel is a 1D - feature map. + """Randomly zero out entire channels with probability prob using samples + from a Bernoulli distribution and the remaining channels are scaled by + (1/1-prob). In this case, dropout3d performs a channel-wise dropout but + assumes a channel is a 1D feature map. Parameters ---------- @@ -1139,9 +1126,8 @@ def ifft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the one dimensional discrete Fourier transform given input at least 1-D - input x. + r"""Compute the one dimensional discrete Fourier transform given input at + least 1-D input x. Parameters ---------- @@ -1208,8 +1194,7 @@ def embedding( max_norm: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Embeds a given tensor of indices using a given tensor of weights. + """Embeds a given tensor of indices using a given tensor of weights. Parameters ---------- @@ -1262,8 +1247,7 @@ def dft( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the discrete Fourier transform of input. + """Compute the discrete Fourier transform of input. Parameters ---------- @@ -1767,9 +1751,8 @@ def interpolate( antialias: bool = False, # ToDo: add support for antialias out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Down/up samples the input to the given size. The algorithm used for interpolation is - determined by mode. + """Down/up samples the input to the given size. The algorithm used for + interpolation is determined by mode. Parameters ---------- @@ -2109,9 +2092,8 @@ def adaptive_max_pool2d( input: Union[ivy.Array, ivy.NativeArray], output_size: Union[Sequence[int], int], ): - """ - Apply a 2D adaptive maximum pooling over an input signal composed of several input - planes. + """Apply a 2D adaptive maximum pooling over an input signal composed of + several input planes. Parameters ---------- @@ -2202,9 +2184,8 @@ def adaptive_avg_pool1d( input: Union[ivy.Array, ivy.NativeArray], output_size: int, ) -> ivy.Array: - """ - Apply a 1D adaptive average pooling over an input signal composed of several input - planes. + """Apply a 1D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -2285,9 +2266,8 @@ def adaptive_avg_pool2d( input: Union[ivy.Array, ivy.NativeArray], output_size: Union[Sequence[int], int], ) -> ivy.Array: - """ - Apply a 2D adaptive average pooling over an input signal composed of several input - planes. + """Apply a 2D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -2499,8 +2479,7 @@ def sliding_window( dilation: Union[int, Tuple[int, int]] = 1, padding: Union[str, int, Tuple[int, int]] = "VALID", ) -> ivy.Array: - """ - Slide a window of specified dimension over all elements of an array. + """Slide a window of specified dimension over all elements of an array. Parameters ---------- @@ -2632,8 +2611,7 @@ def reduce_window( base_dilation: Union[int, Sequence[int]] = 1, window_dilation: Union[int, Sequence[int]] = 1, ) -> ivy.Array: - """ - Apply a reduction function to all elements in each window of an array. + """Apply a reduction function to all elements in each window of an array. Parameters ---------- @@ -2709,8 +2687,7 @@ def fft2( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the 2-dimensional discrete Fourier Transform. + r"""Compute the 2-dimensional discrete Fourier Transform. Parameters ---------- @@ -2786,8 +2763,7 @@ def ifftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the N-dimensional inverse discrete Fourier Transform. + r"""Compute the N-dimensional inverse discrete Fourier Transform. Parameters ---------- @@ -2871,8 +2847,8 @@ def rfft( norm: Literal["backward", "ortho", "forward"] = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the one-dimensional discrete Fourier transform for real-valued input. + """Compute the one-dimensional discrete Fourier transform for real-valued + input. .. note:: Applying the one-dimensional inverse discrete Fourier transform for @@ -2980,8 +2956,7 @@ def rfftn( norm: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the N-dimensional discrete Fourier Transform for real input. + """Compute the N-dimensional discrete Fourier Transform for real input. Parameters ---------- @@ -3072,8 +3047,7 @@ def stft( name: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Container static method variant of ivy.stft. + """ivy.Container static method variant of ivy.stft. This method simply wraps the function, and so the docstring for ivy.stft also applies to this method with minimal changes. @@ -3166,8 +3140,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Array: - """ - Compute a 1-D max unpooling given the 1-D pooled input x and its indices. + """Compute a 1-D max unpooling given the 1-D pooled input x and its + indices. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index 4aea8a58c4c3b..ccb4198d1a9a1 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -41,8 +41,8 @@ def eigh_tridiagonal( ] = None, tol: Optional[float] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array]]: - """ - Compute the eigenvalues and eigenvectors of a Hermitian tridiagonal matrix. + """Compute the eigenvalues and eigenvectors of a Hermitian tridiagonal + matrix. Parameters ---------- @@ -180,8 +180,7 @@ def diagflat( num_cols: int = -1, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Return a two-dimensional array with the flattened input as a diagonal. + """Return a two-dimensional array with the flattened input as a diagonal. Parameters ---------- @@ -243,9 +242,8 @@ def kron( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Kronecker product, a composite array made of blocks of the second array - scaled by the first. + """Compute the Kronecker product, a composite array made of blocks of the + second array scaled by the first. Parameters ---------- @@ -285,8 +283,7 @@ def matrix_exp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the matrix exponential of a square matrix. + """Compute the matrix exponential of a square matrix. Parameters ---------- @@ -390,8 +387,7 @@ def eigvals( x: Union[ivy.Array, ivy.NativeArray], /, ) -> ivy.Array: - """ - Compute eigenvalues of x. Returns a set of eigenvalues. + """Compute eigenvalues of x. Returns a set of eigenvalues. Parameters ---------- @@ -437,8 +433,7 @@ def adjoint( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the complex conjugate transpose of x. + """Compute the complex conjugate transpose of x. Parameters ---------- @@ -482,8 +477,8 @@ def solve_triangular( unit_diagonal: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the unique solution to the triangular system of linear equations AX = B. + """Return the unique solution to the triangular system of linear equations + AX = B. Parameters ---------- @@ -540,9 +535,8 @@ def multi_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the dot product of two or more matrices in a single function call, while - selecting the fastest evaluation order. + """Compute the dot product of two or more matrices in a single function + call, while selecting the fastest evaluation order. Parameters ---------- @@ -601,8 +595,7 @@ def cond( p: Optional[Union[int, float, str]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the condition number of x. + """Compute the condition number of x. Parameters ---------- @@ -649,8 +642,7 @@ def kronecker( reverse: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Kronecker product of a list of matrices. + """Kronecker product of a list of matrices. Parameters ---------- @@ -700,8 +692,7 @@ def khatri_rao( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Khatri-Rao product of a sequence of matrices. + """Khatri-Rao product of a sequence of matrices. This can be seen as a column-wise kronecker product. If one matrix only is given, that matrix is directly returned. @@ -805,8 +796,7 @@ def mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - N-mode product of a tensor and a matrix or vector at the specified mode. + """N-mode product of a tensor and a matrix or vector at the specified mode. Parameters ---------- @@ -899,8 +889,8 @@ def multi_mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - N-mode product of a tensor and several matrices or vectors over several modes. + r"""N-mode product of a tensor and several matrices or vectors over several + modes. Parameters ---------- @@ -968,8 +958,7 @@ def multi_mode_dot( def _svd_checks(x, n_eigenvecs=None): - """ - Run common checks to all of the SVD methods. + """Run common checks to all of the SVD methods. Parameters ---------- @@ -1020,11 +1009,10 @@ def svd_flip( /, u_based_decision: Optional[bool] = True, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Sign correction to ensure deterministic output from SVD. Adjusts the columns of u - and the rows of v such that the loadings in the columns in u that are largest in - absolute value are always positive. This function is borrowed from scikit- - learn/utils/extmath.py. + """Sign correction to ensure deterministic output from SVD. Adjusts the + columns of u and the rows of v such that the loadings in the columns in u + that are largest in absolute value are always positive. This function is + borrowed from scikit- learn/utils/extmath.py. Parameters ---------- @@ -1093,9 +1081,8 @@ def make_svd_non_negative( *, nntype: Optional[Literal["nndsvd", "nndsvda"]] = "nndsvd", ) -> Tuple[ivy.Array, ivy.Array]: - """ - Use NNDSVD method to transform SVD results into a non-negative form. This method - leads to more efficient solving with NNMF [1]. + """Use NNDSVD method to transform SVD results into a non-negative form. + This method leads to more efficient solving with NNMF [1]. Parameters ---------- @@ -1185,8 +1172,7 @@ def truncated_svd( compute_uv: bool = True, n_eigenvecs: Optional[int] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array, ivy.Array]]: - """ - Compute a truncated SVD on `x` using the standard SVD. + """Compute a truncated SVD on `x` using the standard SVD. Parameters ---------- @@ -1230,8 +1216,7 @@ def tensor_train( svd: Optional[Literal["truncated_svd"]] = "truncated_svd", verbose: Optional[bool] = False, ) -> ivy.TTTensor: - """ - TT decomposition via recursive SVD. + """TT decomposition via recursive SVD. Decomposes the input into a sequence of order-3 tensors (factors) Also known as Tensor-Train decomposition [1]_ @@ -1361,11 +1346,11 @@ def initialize_tucker( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, svd_mask_repeats: Optional[int] = 5, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ - Initialize core and factors used in `tucker`. The type of initialization is set - using `init`. If `init == 'random'` then initialize factor matrices using - `random_state`. If `init == 'svd'` then initialize the `m`th factor matrix using the - `rank` left singular vectors of the `m`th unfolding of the input tensor. + """Initialize core and factors used in `tucker`. The type of initialization + is set using `init`. If `init == 'random'` then initialize factor matrices + using `random_state`. If `init == 'svd'` then initialize the `m`th factor + matrix using the `rank` left singular vectors of the `m`th unfolding of the + input tensor. Parameters ---------- @@ -1477,8 +1462,7 @@ def partial_tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ - Partial tucker decomposition via Higher Order Orthogonal Iteration (HOI) + """Partial tucker decomposition via Higher Order Orthogonal Iteration (HOI) Decomposes `tensor` into a Tucker decomposition exclusively along the provided modes. @@ -1626,8 +1610,7 @@ def tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ): - """ - Tucker decomposition via Higher Order Orthogonal Iteration (HOI) + """Tucker decomposition via Higher Order Orthogonal Iteration (HOI) Decomposes `tensor` into a Tucker decomposition: ``tensor = [| core; factors[0], ...factors[-1] |]`` [1]_ @@ -1763,10 +1746,9 @@ def tt_matrix_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the full tensor whose TT-Matrix decomposition is given by 'factors' Re- - assembles 'factors', which represent a tensor in TT-Matrix format into the - corresponding full tensor. + """Return the full tensor whose TT-Matrix decomposition is given by + 'factors' Re- assembles 'factors', which represent a tensor in TT-Matrix + format into the corresponding full tensor. Parameters ---------- @@ -1834,10 +1816,9 @@ def dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the dot product between two arrays `a` and `b` using the current backend's - implementation. The dot product is defined as the sum of the element-wise product of - the input arrays. + """Compute the dot product between two arrays `a` and `b` using the current + backend's implementation. The dot product is defined as the sum of the + element-wise product of the input arrays. Parameters ---------- @@ -1895,8 +1876,7 @@ def general_inner_product( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generalised inner products between tensors. + """Generalised inner products between tensors. Takes the inner product between the last (respectively first) `n_modes` of `a` (respectively `b`) @@ -1985,8 +1965,7 @@ def higher_order_moment( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Higher-Order Moment. + """Compute the Higher-Order Moment. Parameters ---------- @@ -2033,8 +2012,7 @@ def batched_outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a generalized outer product of the tensors. + """Return a generalized outer product of the tensors. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/losses.py b/ivy/functional/ivy/experimental/losses.py index 7e45013b52f8a..0824093ca069d 100644 --- a/ivy/functional/ivy/experimental/losses.py +++ b/ivy/functional/ivy/experimental/losses.py @@ -28,13 +28,13 @@ def log_poisson_loss( reduction: str = "none", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the log-likelihood loss between the prediction and the target under the - assumption that the target has a Poisson distribution. Caveat: By default, this is - not the exact loss, but the loss minus a constant term [log(z!)]. That has no effect - for optimization, but does not play well with relative loss comparisons. To compute - an approximation of the log factorial term, specify ``compute_full_loss=True`` to - enable Stirling's Approximation. + """Compute the log-likelihood loss between the prediction and the target + under the assumption that the target has a Poisson distribution. Caveat: By + default, this is not the exact loss, but the loss minus a constant term + [log(z!)]. That has no effect for optimization, but does not play well with + relative loss comparisons. To compute an approximation of the log factorial + term, specify ``compute_full_loss=True`` to enable Stirling's + Approximation. Parameters ---------- @@ -169,8 +169,8 @@ def huber_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Huber loss (smooth L1 loss) between true and predicted values. + """Compute the Huber loss (smooth L1 loss) between true and predicted + values. Parameters ---------- @@ -234,8 +234,7 @@ def smooth_l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the smooth L1 loss between two input tensors. + """Compute the smooth L1 loss between two input tensors. Parameters ---------- @@ -363,8 +362,8 @@ def soft_margin_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the soft-margin hinge loss between predicted scores and true binary labels. + """Compute the soft-margin hinge loss between predicted scores and true + binary labels. Parameters ---------- @@ -424,8 +423,7 @@ def kl_div( log_target=False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Kullback-Leibler divergence loss between two input tensors + """Compute the Kullback-Leibler divergence loss between two input tensors (conventionally, probability distributions). Parameters @@ -511,8 +509,7 @@ def poisson_nll_loss( eps: float = 1e-8, reduction: str = "mean", ) -> ivy.Array: - r""" - Compute the Poisson Negative Log Likelihood Loss. + r"""Compute the Poisson Negative Log Likelihood Loss. This function calculates the negative log likelihood loss between the `input` and `target`under the assumption that diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index 3f3fd22d9c0cf..8fe94fbf57f2b 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -103,10 +103,10 @@ def flatten( order: Optional[str] = "C", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Flattens input by reshaping it into a one-dimensional tensor. If start_dim or - end_dim are passed, only dimensions starting with start_dim and ending with end_dim - are flattened. The order of elements in input is unchanged. + """Flattens input by reshaping it into a one-dimensional tensor. If + start_dim or end_dim are passed, only dimensions starting with start_dim + and ending with end_dim are flattened. The order of elements in input is + unchanged. Parameters ---------- @@ -260,8 +260,7 @@ def moveaxis( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Move axes of an array to new positions.. + """Move axes of an array to new positions.. Parameters ---------- @@ -310,8 +309,7 @@ def heaviside( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Heaviside step function for each element in x1. + """Compute the Heaviside step function for each element in x1. Parameters ---------- @@ -359,9 +357,9 @@ def flipud( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Flip array in the up/down direction. Flip the entries in each column in the up/down - direction. Rows are preserved, but appear in a different order than before. + """Flip array in the up/down direction. Flip the entries in each column in + the up/down direction. Rows are preserved, but appear in a different order + than before. Parameters ---------- @@ -403,8 +401,7 @@ def vstack( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Stack arrays in sequence vertically (row wise). + """Stack arrays in sequence vertically (row wise). Parameters ---------- @@ -448,8 +445,7 @@ def hstack( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Stack arrays in sequence horizotally (column wise). + """Stack arrays in sequence horizotally (column wise). Parameters ---------- @@ -495,9 +491,8 @@ def rot90( axes: Tuple[int, int] = (0, 1), out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Rotate an array by 90 degrees in the plane specified by axes. Rotation direction is - from the first towards the second axis. + """Rotate an array by 90 degrees in the plane specified by axes. Rotation + direction is from the first towards the second axis. Parameters ---------- @@ -583,8 +578,8 @@ def top_k( sorted: bool = True, out: Optional[tuple] = None, ) -> Tuple[ivy.Array, ivy.NativeArray]: - """ - Return the `k` largest elements of the given input array along a given axis. + """Return the `k` largest elements of the given input array along a given + axis. Parameters ---------- @@ -662,10 +657,9 @@ def fliplr( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Flip array in the left/right direction. Flip the entries in each column in the - left/right direction. Columns are preserved, but appear in a different order than - before. + """Flip array in the left/right direction. Flip the entries in each column + in the left/right direction. Columns are preserved, but appear in a + different order than before. Parameters ---------- @@ -708,8 +702,7 @@ def i0( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Bessel i0 function of x element-wise. + """Compute the Bessel i0 function of x element-wise. Parameters ---------- @@ -1053,8 +1046,7 @@ def pad( reflect_type: Literal["even", "odd"] = "even", **kwargs: Optional[Any], ) -> ivy.Array: - """ - Pad an array. + """Pad an array. Parameters ---------- @@ -1293,8 +1285,7 @@ def vsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Split an array vertically into multiple sub-arrays. + """Split an array vertically into multiple sub-arrays. Parameters ---------- @@ -1344,8 +1335,7 @@ def dsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Split an array into multiple sub-arrays along the 3rd axis. + """Split an array into multiple sub-arrays along the 3rd axis. Parameters ---------- @@ -1395,9 +1385,9 @@ def atleast_1d( *arys: Union[ivy.Array, ivy.NativeArray, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Convert inputs to arrays with at least one dimension. Scalar inputs are converted to - 1-dimensional arrays, whilst higher-dimensional inputs are preserved. + """Convert inputs to arrays with at least one dimension. Scalar inputs are + converted to 1-dimensional arrays, whilst higher-dimensional inputs are + preserved. Parameters ---------- @@ -1440,8 +1430,7 @@ def dstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Stack arrays in sequence depth wise (along third axis). + """Stack arrays in sequence depth wise (along third axis). Parameters ---------- @@ -1481,9 +1470,9 @@ def atleast_2d( *arys: Union[ivy.Array, ivy.NativeArray], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Convert inputs to arrays with at least two dimension. Scalar inputs are converted to - 2-dimensional arrays, whilst higher-dimensional inputs are preserved. + """Convert inputs to arrays with at least two dimension. Scalar inputs are + converted to 2-dimensional arrays, whilst higher-dimensional inputs are + preserved. Parameters ---------- @@ -1527,9 +1516,9 @@ def atleast_3d( *arys: Union[ivy.Array, ivy.NativeArray, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Convert inputs to arrays with at least three dimension. Scalar inputs are converted - to 3-dimensional arrays, whilst higher-dimensional inputs are preserved. + """Convert inputs to arrays with at least three dimension. Scalar inputs + are converted to 3-dimensional arrays, whilst higher-dimensional inputs are + preserved. Parameters ---------- @@ -1588,8 +1577,7 @@ def take_along_axis( mode: str = "fill", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Take values from the input array by matching 1d index and data slices. + """Take values from the input array by matching 1d index and data slices. Parameters ---------- @@ -1639,8 +1627,7 @@ def hsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Split an array into multiple sub-arrays horizontally. + """Split an array into multiple sub-arrays horizontally. Parameters ---------- @@ -1686,8 +1673,7 @@ def hsplit( @handle_exceptions @inputs_to_native_shapes def broadcast_shapes(*shapes: Union[List[int], List[Tuple]]) -> Tuple[int]: - """ - Broadcasts shapes. + """Broadcasts shapes. Parameters ---------- @@ -1728,8 +1714,8 @@ def expand( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Broadcast the input Array following the given shape and the broadcast rule. + """Broadcast the input Array following the given shape and the broadcast + rule. Parameters ---------- @@ -1770,9 +1756,8 @@ def put_along_axis( mode: Literal["sum", "min", "max", "mul", "mean", "replace"] = "replace", out: Optional[ivy.Array] = None, ) -> None: - """ - Put values into the input array by matching 1d index and data slices along a - specified axis. + """Put values into the input array by matching 1d index and data slices + along a specified axis. Parameters ---------- @@ -1865,8 +1850,7 @@ def as_strided( strides: Sequence[int], /, ) -> ivy.Array: - """ - Create a copy of the input array with the given shape and strides. + """Create a copy of the input array with the given shape and strides. Parameters ---------- @@ -1947,8 +1931,7 @@ def concat_from_sequence( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Concatenate a sequence of arrays along a new or an existing axis. + """Concatenate a sequence of arrays along a new or an existing axis. Parameters ---------- @@ -2054,8 +2037,7 @@ def associative_scan( reverse: bool = False, axis: int = 0, ) -> ivy.Array: - """ - Perform an associative scan over the given array. + """Perform an associative scan over the given array. Parameters ---------- @@ -2140,9 +2122,8 @@ def unique_consecutive( Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray], ]: - """ - Eliminates all but the first element from every consecutive group of equivalent - elements in ``x``. + """Eliminates all but the first element from every consecutive group of + equivalent elements in ``x``. Parameters ---------- @@ -2188,8 +2169,7 @@ def fill_diagonal( *, wrap: bool = False, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Fill the main diagonal of the given array of any dimensionality.. + """Fill the main diagonal of the given array of any dimensionality.. Parameters ---------- @@ -2255,8 +2235,7 @@ def unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the mode-`mode` unfolding of `tensor` with modes starting at `0`. + """Return the mode-`mode` unfolding of `tensor` with modes starting at `0`. Parameters ---------- @@ -2289,9 +2268,9 @@ def fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Refolds the mode-`mode` unfolding into a tensor of shape `shape` In other words, - refolds the n-mode unfolded tensor into the original tensor of the specified shape. + """Refolds the mode-`mode` unfolding into a tensor of shape `shape` In + other words, refolds the n-mode unfolded tensor into the original tensor of + the specified shape. Parameters ---------- @@ -2331,11 +2310,11 @@ def partial_unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Partial unfolding of a tensor while ignoring the specified number of dimensions at - the beginning and the end. For instance, if the first dimension of the tensor is the - number of samples, to unfold each sample, set skip_begin=1. This would, for each i - in ``range(tensor.shape[0])``, unfold ``tensor[i, ...]``. + """Partial unfolding of a tensor while ignoring the specified number of + dimensions at the beginning and the end. For instance, if the first + dimension of the tensor is the number of samples, to unfold each sample, + set skip_begin=1. This would, for each i in ``range(tensor.shape[0])``, + unfold ``tensor[i, ...]``. Parameters ---------- @@ -2388,8 +2367,7 @@ def partial_fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Re-folds a partially unfolded tensor. + """Re-folds a partially unfolded tensor. Parameters ---------- @@ -2431,9 +2409,8 @@ def partial_tensor_to_vec( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Partial vectorization of a tensor while ignoring the specified dimension at the - beginning and the end. + """Partial vectorization of a tensor while ignoring the specified dimension + at the beginning and the end. Parameters ---------- @@ -2476,8 +2453,7 @@ def partial_vec_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Refolds a partially vectorised tensor into a full one. + """Refolds a partially vectorised tensor into a full one. Parameters ---------- @@ -2512,8 +2488,7 @@ def matricize( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Matricizes the given tensor. + """Matricizes the given tensor. Parameters ---------- @@ -2570,8 +2545,7 @@ def soft_thresholding( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Soft-thresholding operator. + """Soft-thresholding operator. sign(tensor) * max[abs(tensor) - threshold, 0] @@ -2631,8 +2605,7 @@ def choose( out: None = None, mode: Union[str, None] = None, ) -> ivy.Array: - """ - Take values from the input array by matching 1d index and data slices. + """Take values from the input array by matching 1d index and data slices. Parameters ---------- @@ -2678,8 +2651,7 @@ def column_stack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Create a new array by horizontally stacking the arrays in arrays. + """Create a new array by horizontally stacking the arrays in arrays. Equivalent to `ivy.hstack(arrays)`, except each zero or one dimensional array `x` in arrays is first reshaped into a `(x.size(), 1)` column @@ -2751,8 +2723,7 @@ def take( fill_value: Optional[Number] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return elements of an array along an axis. + """Return elements of an array along an axis. .. note:: Conceptually, take(x, indices, axis=3) is equivalent to x[:,:,:,indices,...]; @@ -2859,10 +2830,9 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ - ivy.Container instance method variant of ivy.trim_zeros. This method simply wraps - the function, and so the docstring for ivy.trim_zeros also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.trim_zeros. This method + simply wraps the function, and so the docstring for ivy.trim_zeros also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/norms.py b/ivy/functional/ivy/experimental/norms.py index ddc8a1520cbb6..8688da4dccd0a 100644 --- a/ivy/functional/ivy/experimental/norms.py +++ b/ivy/functional/ivy/experimental/norms.py @@ -120,11 +120,11 @@ def local_response_norm( data_format: Optional[Literal["NHWC", "NCHW"]] = "NHWC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> ivy.Array: - """ - Apply local response normalization across the channels of a 4D input array. The 4-D - array is treated as a 3-D array of 1-D vectors (along the channel dimension), and - each vector is normalized independently. Within a given vector, each component is - divided by the squared sum of the neighbouring components. + """Apply local response normalization across the channels of a 4D input + array. The 4-D array is treated as a 3-D array of 1-D vectors (along the + channel dimension), and each vector is normalized independently. Within a + given vector, each component is divided by the squared sum of the + neighbouring components. Parameters ---------- @@ -453,8 +453,8 @@ def group_norm( data_format: Optional[str] = "NSC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply group normalization to the input array and returns the normalized input. + """Apply group normalization to the input array and returns the normalized + input. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/random.py b/ivy/functional/ivy/experimental/random.py index 5a653147a385a..e2fc3828473dc 100644 --- a/ivy/functional/ivy/experimental/random.py +++ b/ivy/functional/ivy/experimental/random.py @@ -29,11 +29,10 @@ def dirichlet( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draw size samples of dimension k from a Dirichlet distribution. A Dirichlet- - distributed random variable can be seen as a multivariate generalization of a Beta - distribution. The Dirichlet distribution is a conjugate prior of a multinomial - distribution in Bayesian inference. + """Draw size samples of dimension k from a Dirichlet distribution. A + Dirichlet- distributed random variable can be seen as a multivariate + generalization of a Beta distribution. The Dirichlet distribution is a + conjugate prior of a multinomial distribution in Bayesian inference. Parameters ---------- @@ -99,8 +98,8 @@ def beta( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an array filled with random values sampled from a beta distribution. + """Return an array filled with random values sampled from a beta + distribution. Parameters ---------- @@ -154,8 +153,8 @@ def gamma( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an array filled with random values sampled from a gamma distribution. + """Return an array filled with random values sampled from a gamma + distribution. Parameters ---------- @@ -205,8 +204,7 @@ def poisson( fill_value: Optional[Union[int, float]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from a poisson distribution. + """Draws samples from a poisson distribution. Parameters ---------- @@ -276,9 +274,8 @@ def bernoulli( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from Bernoulli distribution parameterized by probs or logits (but not - both) + """Draws samples from Bernoulli distribution parameterized by probs or + logits (but not both) Parameters ---------- diff --git a/ivy/functional/ivy/experimental/searching.py b/ivy/functional/ivy/experimental/searching.py index 25c8928a55f9e..69c7045f95e42 100644 --- a/ivy/functional/ivy/experimental/searching.py +++ b/ivy/functional/ivy/experimental/searching.py @@ -23,8 +23,8 @@ def unravel_index( *, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array]: - """ - Convert a flat index or array of flat indices into a tuple of coordinate arrays. + """Convert a flat index or array of flat indices into a tuple of coordinate + arrays. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/sorting.py b/ivy/functional/ivy/experimental/sorting.py index 0d2d18ddf3c88..0d170828570eb 100644 --- a/ivy/functional/ivy/experimental/sorting.py +++ b/ivy/functional/ivy/experimental/sorting.py @@ -22,8 +22,7 @@ def invert_permutation( x: Union[ivy.Array, ivy.NativeArray, list, tuple], /, ) -> ivy.Array: - """ - Compute the inverse of an index permutation. + """Compute the inverse of an index permutation. Parameters ---------- @@ -62,11 +61,11 @@ def lexsort( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Perform an indirect stable sort with an array of keys in ascending order, with the - last key used as primary sort order, second-to-last for secondary, and so on. Each - row of the key must have the same length, which will also be the length of the - returned array of integer indices, which describes the sort order. + """Perform an indirect stable sort with an array of keys in ascending + order, with the last key used as primary sort order, second-to-last for + secondary, and so on. Each row of the key must have the same length, which + will also be the length of the returned array of integer indices, which + describes the sort order. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/statistical.py b/ivy/functional/ivy/experimental/statistical.py index a7c6940e15a2d..756f066c02ecb 100644 --- a/ivy/functional/ivy/experimental/statistical.py +++ b/ivy/functional/ivy/experimental/statistical.py @@ -38,8 +38,7 @@ def histogram( density: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the histogram of the array ``a``. + """Compute the histogram of the array ``a``. .. note:: Given bins = [c0, ..., cK], defining intervals I0 = [c0, c1), I1 = [c1, c2), @@ -165,8 +164,7 @@ def median( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the median along the specified axis. + """Compute the median along the specified axis. Parameters ---------- @@ -213,8 +211,7 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the mean of all non-NaN elements along the specified dimensions. + """Compute the mean of all non-NaN elements along the specified dimensions. Parameters ---------- @@ -269,8 +266,7 @@ def nanmin( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return minimum of an array or minimum along an axis, ignoring any NaNs. + """Return minimum of an array or minimum along an axis, ignoring any NaNs. Parameters ---------- @@ -333,9 +329,8 @@ def nanprod( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the product of array elements over a given axis treating Not a Numbers - (NaNs) as ones. + """Compute the product of array elements over a given axis treating Not a + Numbers (NaNs) as ones. Parameters ---------- @@ -399,8 +394,7 @@ def quantile( interpolation: str = "linear", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the q-th quantile of the data along the specified axis. + """Compute the q-th quantile of the data along the specified axis. Parameters ---------- @@ -502,10 +496,9 @@ def nanmedian( overwrite_input: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanmedian. This method simply wraps the - function, and so the docstring for ivy.nanmedian also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nanmedian. This method simply + wraps the function, and so the docstring for ivy.nanmedian also applies to + this method with minimal changes. Parameters ---------- @@ -574,8 +567,7 @@ def bincount( minlength: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Count the number of occurrences of each value in an integer array. + """Count the number of occurrences of each value in an integer array. Parameters ---------- @@ -617,8 +609,7 @@ def igamma( x: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Compute the regularized lower gamma function of ``a`` and ``x``. + """Compute the regularized lower gamma function of ``a`` and ``x``. Parameters ---------- @@ -662,8 +653,7 @@ def cov( aweights: Optional[ivy.Array] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ) -> ivy.Array: - """ - Compute the covariance of matrix x1, or variables x1 and x2. + """Compute the covariance of matrix x1, or variables x1 and x2. Parameters ---------- @@ -806,9 +796,9 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a tuple containing the cumulative maximum of elements of input along the - given axis and index location of each maximum value found along the given axis. + """Return a tuple containing the cumulative maximum of elements of input + along the given axis and index location of each maximum value found along + the given axis. Parameters ---------- @@ -907,8 +897,7 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the cumulative minimum of the elements along a given axis. + """Return the cumulative minimum of the elements along a given axis. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/utility.py b/ivy/functional/ivy/experimental/utility.py index e33383151b01c..f16428089885c 100644 --- a/ivy/functional/ivy/experimental/utility.py +++ b/ivy/functional/ivy/experimental/utility.py @@ -16,11 +16,10 @@ def optional_get_element( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - If the input is a tensor or sequence type, it returns the input. If the input is an - optional type, it outputs the element in the input. It is an error if the input is - an empty optional-type (i.e. does not have an element) and the behavior is undefined - in this case. + """If the input is a tensor or sequence type, it returns the input. If the + input is an optional type, it outputs the element in the input. It is an + error if the input is an empty optional-type (i.e. does not have an + element) and the behavior is undefined in this case. Parameters ---------- diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index 879b3919c52d1..a1de906212d34 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -94,9 +94,9 @@ def __exit__(self, exc_type, exc_val, exc_tb): @handle_exceptions def set_precise_mode(mode: bool) -> None: - """ - Set the mode of whether to use a promotion table that avoids any precision loss or a - compute efficient table that avoids most wider-than- necessary promotions. + """Set the mode of whether to use a promotion table that avoids any + precision loss or a compute efficient table that avoids most wider-than- + necessary promotions. Parameter --------- @@ -122,9 +122,9 @@ def set_precise_mode(mode: bool) -> None: @handle_exceptions def unset_precise_mode() -> None: - """ - Reset the mode of whether to use a promotion table that avoids any precision loss or - a compute efficient table that avoids most wider-than- necessary promotions. + """Reset the mode of whether to use a promotion table that avoids any + precision loss or a compute efficient table that avoids most wider-than- + necessary promotions. Examples -------- @@ -187,8 +187,7 @@ def get_referrers_recursive( seen_set: Optional[set] = None, local_set: Optional[set] = None, ) -> ivy.Container: - """ - Recursively retrieve referrers for an object. + """Recursively retrieve referrers for an object. This function recursively fetches referrers for the specified `item` up to a given `max_depth`. @@ -285,8 +284,7 @@ def get_referrers_recursive_inner(): def is_native_array( x: Union[ivy.Array, ivy.NativeArray], /, *, exclusive: bool = False ) -> bool: - """ - Determine whether the input x is an :class:`ivy.NativeArray` instance. + """Determine whether the input x is an :class:`ivy.NativeArray` instance. Parameters ---------- @@ -322,8 +320,7 @@ def is_native_array( def is_ivy_array( x: Union[ivy.Array, ivy.NativeArray], /, *, exclusive: Optional[bool] = False ) -> bool: - """ - Determine whether the input x is a valid Ivy Array. + """Determine whether the input x is a valid Ivy Array. Parameters ---------- @@ -354,8 +351,7 @@ def is_ivy_array( @handle_exceptions @handle_backend_invalid def is_array(x: Any, /, *, exclusive: bool = False) -> bool: - """ - Determine whether the input x is either an Ivy Array or a Native Array. + """Determine whether the input x is either an Ivy Array or a Native Array. Parameters ---------- @@ -391,8 +387,7 @@ def is_array(x: Any, /, *, exclusive: bool = False) -> bool: @handle_exceptions def is_ivy_container(x: Any, /) -> bool: - """ - Determine whether the input x is an Ivy Container. + """Determine whether the input x is an Ivy Container. Parameters ---------- @@ -422,9 +417,8 @@ def is_ivy_container(x: Any, /) -> bool: @handle_exceptions def set_array_mode(mode: bool) -> None: - """ - Set the mode of whether to convert inputs to ivy.NativeArray, then convert outputs - back to ivy.Array. + """Set the mode of whether to convert inputs to ivy.NativeArray, then + convert outputs back to ivy.Array. It Stops the conversion of ivy.NativeArray to ivy.Array in the case when it is set to False. @@ -452,9 +446,8 @@ def set_array_mode(mode: bool) -> None: @handle_exceptions def unset_array_mode() -> None: - """ - Reset the mode of converting inputs to ivy.NativeArray, then converting outputs back - to ivy.Array to the previous state. + """Reset the mode of converting inputs to ivy.NativeArray, then converting + outputs back to ivy.Array to the previous state. Examples -------- @@ -478,8 +471,7 @@ def unset_array_mode() -> None: @handle_exceptions def set_nestable_mode(mode: bool) -> None: - """ - Set the mode of whether to check if function inputs are ivy.Container. + """Set the mode of whether to check if function inputs are ivy.Container. Parameter --------- @@ -504,9 +496,8 @@ def set_nestable_mode(mode: bool) -> None: @handle_exceptions def unset_nestable_mode() -> None: - """ - Reset the mode of whether to check if function inputs are ivy.Container to the - previous state. + """Reset the mode of whether to check if function inputs are ivy.Container + to the previous state. Examples -------- @@ -532,9 +523,9 @@ def unset_nestable_mode() -> None: @handle_exceptions def set_exception_trace_mode(mode: Literal["ivy", "full", "frontend"]) -> None: - """ - Set the mode of whether to show frontend-truncated exception stack traces, ivy- - truncated exception stack traces or full exception stack traces. + """Set the mode of whether to show frontend-truncated exception stack + traces, ivy- truncated exception stack traces or full exception stack + traces. Parameter --------- @@ -562,8 +553,7 @@ def set_exception_trace_mode(mode: Literal["ivy", "full", "frontend"]) -> None: @handle_exceptions def unset_exception_trace_mode() -> None: - """ - Reset the trace mode to the previously set mode. + """Reset the trace mode to the previously set mode. Examples -------- @@ -591,8 +581,8 @@ def unset_exception_trace_mode() -> None: @handle_exceptions def set_show_func_wrapper_trace_mode(mode: bool) -> None: - """ - Set the mode of whether to show the full stack trace with function wrapping traces. + """Set the mode of whether to show the full stack trace with function + wrapping traces. Parameter --------- @@ -617,9 +607,8 @@ def set_show_func_wrapper_trace_mode(mode: bool) -> None: @handle_exceptions def unset_show_func_wrapper_trace_mode() -> None: - """ - Reset the mode of whether to show the full stack trace with function wrapping - traces. + """Reset the mode of whether to show the full stack trace with function + wrapping traces. Examples -------- @@ -654,8 +643,7 @@ def array_equal( x1: Union[ivy.Array, ivy.NativeArray], /, ) -> bool: - """ - Determine whether two input arrays are equal across all elements. + """Determine whether two input arrays are equal across all elements. Parameters ---------- @@ -699,8 +687,7 @@ def array_equal( def all_equal( *xs: Iterable[Any], equality_matrix: bool = False ) -> Union[bool, ivy.Array, ivy.NativeArray]: - """ - Determine whether the inputs are all equal. + """Determine whether the inputs are all equal. Parameters ---------- @@ -793,8 +780,7 @@ def all_equal( def to_numpy( x: Union[ivy.Array, ivy.NativeArray], /, *, copy: bool = True ) -> np.ndarray: - """ - Convert an array into a numpy array. + """Convert an array into a numpy array. Parameters ---------- @@ -864,8 +850,7 @@ def isscalar(x: Any, /) -> bool: @handle_array_function @handle_device def to_scalar(x: Union[ivy.Array, ivy.NativeArray], /) -> Number: - """ - Convert an array with a single element into a scalar. + """Convert an array with a single element into a scalar. Parameters ---------- @@ -921,8 +906,7 @@ def to_scalar(x: Union[ivy.Array, ivy.NativeArray], /) -> Number: @handle_array_function @handle_device def to_list(x: Union[ivy.Array, ivy.NativeArray], /) -> List: - """ - Create a (possibly nested) list from input array. + """Create a (possibly nested) list from input array. Parameters ---------- @@ -999,8 +983,7 @@ def clip_vector_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Clips (limits) the vector p-norm of an array. + """Clips (limits) the vector p-norm of an array. Parameters ---------- @@ -1099,8 +1082,7 @@ def clip_matrix_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Clips (limits) the matrix norm of an array. + """Clips (limits) the matrix norm of an array. Parameters ---------- @@ -1183,8 +1165,7 @@ def fourier_encode( concat: bool = True, flatten: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Tuple]: - """ - Pad an array with fourier encodings. + """Pad an array with fourier encodings. Parameters ---------- @@ -1284,8 +1265,7 @@ def value_is_nan( *, include_infs: bool = True, ) -> bool: - """ - Determine whether the single valued array or scalar is of nan type. + """Determine whether the single valued array or scalar is of nan type. Parameters ---------- @@ -1343,9 +1323,8 @@ def value_is_nan( def has_nans( x: Union[ivy.Array, ivy.NativeArray], /, *, include_infs: bool = True ) -> bool: - """ - Determine whether the array contains any nans, as well as infs or -infs if - specified. + """Determine whether the array contains any nans, as well as infs or -infs + if specified. Parameters ---------- @@ -1404,8 +1383,7 @@ def has_nans( @handle_exceptions def exists(x: Any, /) -> bool: - """ - Check as to whether the input is None or not. + """Check as to whether the input is None or not. Parameters ---------- @@ -1486,8 +1464,7 @@ def default( rev: bool = False, with_callable: bool = False, ) -> Any: - """ - Return x provided it exists (is not None), else returns default value. + """Return x provided it exists (is not None), else returns default value. Parameters ---------- @@ -1578,8 +1555,7 @@ def default( @handle_exceptions def to_ivy_shape(shape: Union[ivy.Shape, ivy.NativeShape]) -> ivy.Shape: - """ - Return the input shape in ivy.Shape form. + """Return the input shape in ivy.Shape form. Parameters ---------- @@ -1600,8 +1576,7 @@ def to_ivy_shape(shape: Union[ivy.Shape, ivy.NativeShape]) -> ivy.Shape: def to_native_shape( shape: Union[ivy.Array, ivy.Shape, ivy.NativeShape, tuple, int, list] ) -> ivy.NativeShape: - """ - Return the input shape in its native backend framework form. + """Return the input shape in its native backend framework form. Parameters ---------- @@ -1643,9 +1618,8 @@ def to_native_shape( @handle_exceptions @handle_nestable def try_else_none(fn: Callable, *args: Any, **kwargs: Any) -> Union[Callable, None]: - """ - Try and return the function, otherwise return None if an exception was raised during - function execution. + """Try and return the function, otherwise return None if an exception was + raised during function execution. Parameters ---------- @@ -1688,8 +1662,7 @@ def try_else_none(fn: Callable, *args: Any, **kwargs: Any) -> Union[Callable, No @handle_exceptions def arg_names(receiver): - """ - Get the expected keyword arguments for a function or class constructor. + """Get the expected keyword arguments for a function or class constructor. Parameters ---------- @@ -1719,8 +1692,7 @@ def arg_names(receiver): def match_kwargs( kwargs: Dict, *receivers: Iterable[Callable], allow_duplicates: bool = False ) -> Union[List[Dict], Dict]: - """ - Match keyword arguments to either class or function receivers. + """Match keyword arguments to either class or function receivers. Parameters ---------- @@ -1766,8 +1738,7 @@ def match_kwargs( @handle_exceptions def cache_fn(func: Callable) -> Callable: - """ - Cache function outputs. + """Cache function outputs. A decorator to wrap a function, such that computed outputs are cached to avoid recalculating them later. @@ -1820,8 +1791,7 @@ def cached_fn(*args, **kwargs): @handle_exceptions def current_backend_str() -> Union[str, None]: - """ - Return framework string. + """Return framework string. Returns ------- @@ -1847,8 +1817,7 @@ def einops_rearrange( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - Perform einops rearrange operation on input array x. + """Perform einops rearrange operation on input array x. Parameters ---------- @@ -1983,8 +1952,7 @@ def einops_reduce( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - Perform einops reduce operation on input array x. + """Perform einops reduce operation on input array x. Parameters ---------- @@ -2060,8 +2028,7 @@ def einops_repeat( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - Perform einops repeat operation on input array x. + """Perform einops repeat operation on input array x. Parameters ---------- @@ -2121,8 +2088,8 @@ def einops_repeat( @handle_exceptions @handle_array_function def set_min_denominator(val: float) -> None: - """ - Set the global minimum denominator used by ivy for numerically stable division. + """Set the global minimum denominator used by ivy for numerically stable + division. Parameters ---------- @@ -2148,9 +2115,8 @@ def set_min_denominator(val: float) -> None: @handle_exceptions def unset_min_denominator() -> None: - """ - Reset the global minimum denominator used by ivy for numerically stable division to - the previous value. + """Reset the global minimum denominator used by ivy for numerically stable + division to the previous value. Examples -------- @@ -2176,8 +2142,8 @@ def unset_min_denominator() -> None: @handle_exceptions @handle_array_function def set_min_base(val: float) -> None: - """ - Set the global minimum base used by ivy for numerically stable power raising. + """Set the global minimum base used by ivy for numerically stable power + raising. Parameters ---------- @@ -2213,9 +2179,8 @@ def set_min_base(val: float) -> None: @handle_exceptions def unset_min_base() -> None: - """ - Reset the global minimum base used by ivy for numerically stable power raising to - the previous value. + """Reset the global minimum base used by ivy for numerically stable power + raising to the previous value. Examples -------- @@ -2247,9 +2212,8 @@ def stable_divide( *, min_denominator: Union[Number, ivy.Array, ivy.NativeArray] = None, ) -> Union[Number, ivy.Array]: - """ - Divide the numerator by the denominator, with min denominator added to the - denominator for numerical stability. + """Divide the numerator by the denominator, with min denominator added to + the denominator for numerical stability. Parameters ---------- @@ -2347,9 +2311,8 @@ def stable_pow( *, min_base: Optional[float] = None, ) -> Any: - """ - Raise the base by the power, with ivy.min_base added to the base when exponent > 1 - for numerical stability. + """Raise the base by the power, with ivy.min_base added to the base when + exponent > 1 for numerical stability. Parameters ---------- @@ -2437,8 +2400,7 @@ def stable_pow( @handle_exceptions def get_all_arrays_in_memory() -> List[Union[ivy.Array, ivy.NativeArray]]: - """ - Get all arrays which are currently alive. + """Get all arrays which are currently alive. Returns ------- @@ -2473,8 +2435,7 @@ def get_all_arrays_in_memory() -> List[Union[ivy.Array, ivy.NativeArray]]: @handle_exceptions def num_arrays_in_memory() -> int: - """ - Return the number of arrays which are currently alive. + """Return the number of arrays which are currently alive. Returns ------- @@ -2497,8 +2458,7 @@ def num_arrays_in_memory() -> int: @handle_exceptions def print_all_arrays_in_memory(): - """ - Print all native Ivy arrays in memory to the console. + """Print all native Ivy arrays in memory to the console. Gets all the native Ivy arrays which are currently alive(in the garbage collector) from get_all_arrays_in_memory() function and @@ -2514,8 +2474,7 @@ def print_all_arrays_in_memory(): @handle_exceptions @handle_array_function def set_queue_timeout(timeout: float): - """ - Set a timeout value (in seconds) for the global queue. + """Set a timeout value (in seconds) for the global queue. Set the global queue timeout value (in seconds) Default value without this function being called is 15 seconds. @@ -2546,8 +2505,7 @@ def set_queue_timeout(timeout: float): @handle_exceptions def unset_queue_timeout() -> None: - """ - Reset the global queue timeout value (in seconds) to the previous state. + """Reset the global queue timeout value (in seconds) to the previous state. Examples -------- @@ -2572,8 +2530,7 @@ def unset_queue_timeout() -> None: @handle_exceptions def set_tmp_dir(tmp_dr: str) -> None: - """ - Set the directory for saving temporary files. + """Set the directory for saving temporary files. Parameters ---------- @@ -2599,8 +2556,7 @@ def set_tmp_dir(tmp_dr: str) -> None: @handle_exceptions def unset_tmp_dir() -> None: - """ - Reset the directory for saving temporary files to the previous value. + """Reset the directory for saving temporary files to the previous value. Examples -------- @@ -2622,8 +2578,7 @@ def unset_tmp_dir() -> None: @handle_exceptions def container_types(): - """ - Summary. + """Summary. Returns ------- @@ -2640,8 +2595,8 @@ def container_types(): @handle_exceptions def inplace_arrays_supported() -> bool: - """ - Determine whether inplace arrays are supported for the current backend framework. + """Determine whether inplace arrays are supported for the current backend + framework. Returns ------- @@ -2653,8 +2608,8 @@ def inplace_arrays_supported() -> bool: @handle_exceptions def inplace_variables_supported() -> bool: - """ - Determine whether inplace variables are supported for the current backend framework. + """Determine whether inplace variables are supported for the current + backend framework. Returns ------- @@ -2669,8 +2624,7 @@ def inplace_variables_supported() -> bool: @inputs_to_native_arrays @handle_array_function def supports_inplace_updates(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """ - Return if in-place operations are supported for x's data type. + """Return if in-place operations are supported for x's data type. Determine whether in-place operations are supported for x's data type, by the current backend framework setting. @@ -2736,8 +2690,7 @@ def supports_inplace_updates(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: @inputs_to_native_arrays @handle_array_function def assert_supports_inplace(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """ - Assert that inplace operations are supported for x. + """Assert that inplace operations are supported for x. Parameters ---------- @@ -2809,8 +2762,7 @@ def get_item( *, copy: Optional[bool] = None, ) -> ivy.Array: - """ - Gather slices from x according to query array, identical to x[query]. + """Gather slices from x according to query array, identical to x[query]. Parameters ---------- @@ -2879,8 +2831,8 @@ def set_item( *, copy: Optional[bool] = False, ) -> ivy.Array: - """ - Replace slices of x (defined by query) with val, identical to x[query] = val. + """Replace slices of x (defined by query) with val, identical to x[query] = + val. Parameters ---------- @@ -3007,8 +2959,7 @@ def inplace_update( ensure_in_backend: bool = False, keep_input_dtype: bool = False, ) -> ivy.Array: - """ - Perform in-place update for the input array. + """Perform in-place update for the input array. This will always be performed on ivy.Array instances pass in the input, and will also be performed on the native array classes in the backend when the backend @@ -3104,8 +3055,7 @@ def inplace_update( @handle_exceptions def set_inplace_mode(mode: str = "lenient") -> None: - """ - Set the memory management behavior for in-place updates in Ivy. + """Set the memory management behavior for in-place updates in Ivy. By default, Ivy creates new arrays in the backend for in-place updates. However, this behavior can be controlled by the user @@ -3152,9 +3102,8 @@ def set_inplace_mode(mode: str = "lenient") -> None: @handle_exceptions def unset_inplace_mode() -> None: - """ - Reset the memory management behavior for in-place updates in Ivy to the previous - state. + """Reset the memory management behavior for in-place updates in Ivy to the + previous state. Examples -------- @@ -3183,8 +3132,7 @@ def inplace_decrement( x: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Perform in-place decrement for the input array. + """Perform in-place decrement for the input array. Parameters ---------- @@ -3255,8 +3203,7 @@ def inplace_increment( x: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Perform in-place increment for the input array. + """Perform in-place increment for the input array. Parameters ---------- @@ -3320,8 +3267,7 @@ def scatter_flat( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Scatter flat updates into a new flat array according to flat indices. + """Scatter flat updates into a new flat array according to flat indices. Parameters ---------- @@ -3410,8 +3356,7 @@ def scatter_nd( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Scatter updates into a new array according to indices. + """Scatter updates into a new array according to indices. Parameters ---------- @@ -3517,8 +3462,7 @@ def gather( batch_dims: int = 0, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Gather slices from params at axis according to indices. + """Gather slices from params at axis according to indices. Parameters ---------- @@ -3628,8 +3572,7 @@ def gather_nd( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Gather slices from params into a array with shape specified by indices. + """Gather slices from params into a array with shape specified by indices. Parameters ---------- @@ -3696,8 +3639,7 @@ def gather_nd( @handle_nestable @handle_array_function def multiprocessing(context: Optional[str] = None): - """ - Return backend-specific multiprocessing module. + """Return backend-specific multiprocessing module. Parameters ---------- @@ -3756,8 +3698,7 @@ def shape( *, as_array: bool = False, ) -> Union[ivy.Shape, ivy.NativeShape]: - """ - Return the shape of the array ``x``. + """Return the shape of the array ``x``. Parameters ---------- @@ -3791,8 +3732,7 @@ def shape( @handle_exceptions def set_shape_array_mode(mode: bool) -> None: - """ - Set the mode of returning shape as ivy.Array to the given mode instance. + """Set the mode of returning shape as ivy.Array to the given mode instance. Parameter --------- @@ -3817,8 +3757,7 @@ def set_shape_array_mode(mode: bool) -> None: @handle_exceptions def unset_shape_array_mode() -> None: - """ - Reset the mode of returning shape as ivy.Array to the previous state. + """Reset the mode of returning shape as ivy.Array to the previous state. Examples -------- @@ -3846,8 +3785,7 @@ def unset_shape_array_mode() -> None: def get_num_dims( x: Union[ivy.Array, ivy.NativeArray], /, *, as_array: bool = False ) -> int: - """ - Return the number of dimensions of the array x. + """Return the number of dimensions of the array x. Parameters ---------- @@ -3895,9 +3833,8 @@ def get_num_dims( @handle_exceptions def arg_info(fn: Callable, *, name: Optional[str] = None, idx: Optional[int] = None): - """ - Return the index and `inspect.Parameter` representation of the specified argument. - In the form of a dict with keys "idx" and "param". + """Return the index and `inspect.Parameter` representation of the specified + argument. In the form of a dict with keys "idx" and "param". Parameters ---------- @@ -4109,11 +4046,10 @@ def _get_devices_and_dtypes(fn, recurse=False, complement=True): @handle_exceptions @handle_nestable def function_supported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> Dict: - """ - Return the supported combination of devices and dtypes of the current backend's - function. The function returns a dict containing the supported combination of - devices and dtypes of the primary and compositional implementations in case of - partial mixed functions. + """Return the supported combination of devices and dtypes of the current + backend's function. The function returns a dict containing the supported + combination of devices and dtypes of the primary and compositional + implementations in case of partial mixed functions. Parameters ---------- @@ -4158,11 +4094,10 @@ def function_supported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> @handle_exceptions @handle_nestable def function_unsupported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> Dict: - """ - Return the unsupported combination of devices and dtypes of the current backend's - function. The function returns a dict containing the unsupported combination of - devices and dtypes of the primary and compositional implementations in case of - partial mixed functions. + """Return the unsupported combination of devices and dtypes of the current + backend's function. The function returns a dict containing the unsupported + combination of devices and dtypes of the primary and compositional + implementations in case of partial mixed functions. Parameters ---------- @@ -4208,8 +4143,7 @@ def vmap( in_axes: Union[int, Sequence[int], Sequence[None]] = 0, out_axes: int = 0, ) -> Callable: - """ - Vectorizing map. Creates a function which maps func over argument axes. + """Vectorizing map. Creates a function which maps func over argument axes. Parameters ---------- @@ -4274,8 +4208,7 @@ def isin( assume_unique: bool = False, invert: bool = False, ) -> ivy.Array: - """ - Test if each element of elements is in test_elements. + """Test if each element of elements is in test_elements. Parameters ---------- @@ -4322,8 +4255,7 @@ def itemsize( x: Union[ivy.Array, ivy.NativeArray], /, ) -> int: - """ - Return the size of the input array's elements. + """Return the size of the input array's elements. Parameters ---------- @@ -4355,8 +4287,7 @@ def strides( x: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple[int]: - """ - Return the input array's strides across each dimension. + """Return the input array's strides across each dimension. Parameters ---------- @@ -4387,8 +4318,7 @@ def strides( def is_ivy_nested_array(x: Any, /) -> bool: - """ - Determine whether the input x is an Ivy Nested Array. + """Determine whether the input x is an Ivy Nested Array. Parameters ---------- diff --git a/ivy/functional/ivy/gradients.py b/ivy/functional/ivy/gradients.py index 6740e800462a4..8e1a162112909 100644 --- a/ivy/functional/ivy/gradients.py +++ b/ivy/functional/ivy/gradients.py @@ -27,7 +27,8 @@ def _get_duplicate_index_chains(xs): - """Generate a list of duplicate index chains for a given nested structure.""" + """Generate a list of duplicate index chains for a given nested + structure.""" duplicate_index_chains = () if isinstance(xs, ivy.Container): duplicate_index_chains = xs.cont_duplicate_array_keychains() @@ -37,7 +38,8 @@ def _get_duplicate_index_chains(xs): def _arrays_to_float_variables(xs, xs_grad_idxs=None): - """Convert all required arrays to float variables for gradient calculation.""" + """Convert all required arrays to float variables for gradient + calculation.""" def inner_fn(x): if ivy.is_array(x, exclusive=True): @@ -103,8 +105,7 @@ def map_fn(x): def _get_required_float_variables(xs, xs_grad_idxs): - """ - Convert all required arrays to float variables for gradient calculation. + """Convert all required arrays to float variables for gradient calculation. Also, returns a list of duplicate index chains for the nested structure. @@ -127,7 +128,8 @@ def _get_required_float_variables(xs, xs_grad_idxs): def _get_native_variables_and_indices(x, reshape=True, idxs=None, create_var=False): - """Extract all relevant results from the output nested structure of a function.""" + """Extract all relevant results from the output nested structure of a + function.""" def map_fn(x_): if ivy.is_array(x_): @@ -167,7 +169,8 @@ def map_fn(x_): def _set_duplicates(xs, duplicate_index_chains): - """Set the duplicates in the nested structure to have the same reference.""" + """Set the duplicates in the nested structure to have the same + reference.""" originals = list( map( lambda key_chains: [key_chains[0]] * (len(key_chains) - 1), @@ -233,8 +236,7 @@ def _stop_grad_and_index(func_ret, retain_grads, grads): def _process_func_ret_and_grads(func_ret, grads, retain_grads): - """ - Stop gradients propagation. + """Stop gradients propagation. Set the gradients of non-finite values to zero, and stopping gradient propagation of the function results. @@ -272,8 +274,7 @@ def _non_finite_to_zero(xs): def _flatten_containers(inputs): - """ - Flatten containers into a single tuple of arrays. + """Flatten containers into a single tuple of arrays. Returns a flattened tuple of arrays and the indices of the arrays in the original containers. @@ -338,8 +339,7 @@ def _is_variable(x, exclusive=False, to_ignore=None) -> bool: def _variable_data( x: Union[ivy.Array, ivy.NativeArray] ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Get the contents of the input. + """Get the contents of the input. Parameters ---------- @@ -373,8 +373,7 @@ def stop_gradient( preserve_type: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Stop gradient computation. + """Stop gradient computation. Parameters ---------- @@ -450,9 +449,9 @@ def execute_with_gradients( xs_grad_idxs: Sequence[Sequence[Union[str, int]]] = ((0,),), ret_grad_idxs: Sequence[Sequence[Union[str, int]]] = ((0,),), ) -> Tuple[ivy.Array, ivy.Array]: - """ - Call function func with input of xs variables, and return the function result - func_ret and the gradients of each output variable w.r.t each input variable, + """Call function func with input of xs variables, and return the function + result func_ret and the gradients of each output variable w.r.t each input + variable, Parameters ---------- @@ -528,8 +527,7 @@ def execute_with_gradients( @handle_exceptions def value_and_grad(func: Callable) -> Callable: - """ - Create a function that evaluates both func and the gradient of func. + """Create a function that evaluates both func and the gradient of func. Parameters ---------- @@ -562,8 +560,7 @@ def value_and_grad(func: Callable) -> Callable: @handle_exceptions def jac(func: Callable) -> Callable: - """ - Call function func, and return func's Jacobian partial derivatives. + """Call function func, and return func's Jacobian partial derivatives. Parameters ---------- @@ -596,8 +593,7 @@ def jac(func: Callable) -> Callable: @handle_exceptions def grad(func: Callable, argnums: Union[int, Sequence[int]] = 0) -> Callable: - """ - Call function func, and return func's gradients. + """Call function func, and return func's gradients. Parameters ---------- @@ -647,9 +643,8 @@ def adam_step( epsilon: float = 1e-7, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - Compute adam step delta, given the derivatives of some cost c with respect to - weights ws, using ADAM update. `[reference] + """Compute adam step delta, given the derivatives of some cost c with + respect to weights ws, using ADAM update. `[reference] `_ @@ -798,9 +793,8 @@ def optimizer_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Update weights ws of some function, given the true or effective derivatives of some - cost c with respect to ws, [dc/dw for w in ws]. + """Update weights ws of some function, given the true or effective + derivatives of some cost c with respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -921,9 +915,8 @@ def gradient_descent_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws]. + """Update weights ws of some function, given the derivatives of some cost c + with respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -1015,10 +1008,9 @@ def lars_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive Rate Scaling - (LARS) method. + """Update weights ws of some function, given the derivatives of some cost c + with respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive + Rate Scaling (LARS) method. Parameters ---------- @@ -1120,9 +1112,8 @@ def adam_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, using ADAM update. `[reference] + """Update weights ws of some function, given the derivatives of some cost c + with respect to ws, using ADAM update. `[reference] `_ @@ -1287,9 +1278,8 @@ def lamb_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws], by applying LAMB method. + """Update weights ws of some function, given the derivatives of some cost c + with respect to ws, [dc/dw for w in ws], by applying LAMB method. Parameters ---------- diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 5db59cd1ee9e0..c525aaee04f24 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -44,10 +44,9 @@ def _in_projection( w, b=None, ): - """ - Projects query, key and value efficiently, depending on whether we are doing self- - attention (query is key is value) or cross-attention (key is value) or an attention - where query, key and value are all different. + """Projects query, key and value efficiently, depending on whether we are + doing self- attention (query is key is value) or cross-attention (key is + value) or an attention where query, key and value are all different. it is only used in multi_head_attention layer. @@ -264,8 +263,7 @@ def dropout( noise_shape: Optional[Sequence[int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Randomly setting a fraction of input tensor to zeroes with probability. + """Randomly setting a fraction of input tensor to zeroes with probability. `prob` at each update during training time to prevent possible overfitting. The inputs not set to 0 are scaled up `1 / (1 - prob)` by default, so that @@ -449,8 +447,7 @@ def scaled_dot_product_attention( training: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply scaled dot product attention to inputs x using optional mask. + """Apply scaled dot product attention to inputs x using optional mask. Parameters ---------- @@ -751,20 +748,20 @@ def multi_head_attention( training: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Apply multi-head attention to inputs x. This is an implementation of multi-headed - attention as described in the paper "Attention is all you Need" (Vaswani et al., - 2017). If `query`, `key`, `value` are the same, then this is self-attention. Each - timestep in `query` attends to the corresponding sequence in `key`, and returns a - fixed-width vector. This layer first projects `query`, `key` and `value`. These are - (effectively) a list of tensors of length `num_attention_heads`, where the - corresponding shapes are `(batch_size, , key_dim)`, `(batch_size, + """Apply multi-head attention to inputs x. This is an implementation of + multi-headed attention as described in the paper "Attention is all you + Need" (Vaswani et al., 2017). If `query`, `key`, `value` are the same, then + this is self-attention. Each timestep in `query` attends to the + corresponding sequence in `key`, and returns a fixed-width vector. This + layer first projects `query`, `key` and `value`. These are (effectively) a + list of tensors of length `num_attention_heads`, where the corresponding + shapes are `(batch_size, , key_dim)`, `(batch_size, , key_dim)`, `(batch_size, , - value_dim)`. Then, the query and key tensors are dot-producted and scaled. These are - softmaxed to obtain attention probabilities. The value tensors are then interpolated - by these probabilities, then concatenated back to a single tensor. Finally, the - result tensor with the last dimension as value_dim can take a linear projection and - return. + value_dim)`. Then, the query and key tensors are dot-producted and scaled. + These are softmaxed to obtain attention probabilities. The value tensors + are then interpolated by these probabilities, then concatenated back to a + single tensor. Finally, the result tensor with the last dimension as + value_dim can take a linear projection and return. Parameters ---------- @@ -1023,8 +1020,7 @@ def conv1d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D convolution given 3-D input x and filters arrays. + """Compute a 1-D convolution given 3-D input x and filters arrays. Parameters ---------- @@ -1134,8 +1130,8 @@ def conv1d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D transpose convolution given 3-D input x and filters arrays. + """Compute a 1-D transpose convolution given 3-D input x and filters + arrays. Parameters ---------- @@ -1284,8 +1280,7 @@ def conv2d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D convolution given 4-D input x and filters arrays. + """Compute a 2-D convolution given 4-D input x and filters arrays. Parameters ---------- @@ -1425,8 +1420,8 @@ def conv2d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D transpose convolution given 4-D input x and filters arrays. + """Compute a 2-D transpose convolution given 4-D input x and filters + arrays. Parameters ---------- @@ -1562,8 +1557,8 @@ def depthwise_conv2d( dilations: Union[int, Tuple[int, int]] = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D depthwise convolution given 4-D input ``x`` and filters arrays. + """Compute a 2-D depthwise convolution given 4-D input ``x`` and filters + arrays. Parameters ---------- @@ -1704,8 +1699,7 @@ def conv3d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D convolution given 5-D input x and filters arrays. + """Compute a 3-D convolution given 5-D input x and filters arrays. Parameters ---------- @@ -1826,8 +1820,8 @@ def conv3d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D transpose convolution given 5-D input x and filters arrays. + """Compute a 3-D transpose convolution given 5-D input x and filters + arrays. Parameters ---------- @@ -1970,9 +1964,8 @@ def conv_general_dilated( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D, 2-D, and 3-D convolution given 3-D, 4-D and 5-D input x respectively - and filters arrays. + """Compute a 1-D, 2-D, and 3-D convolution given 3-D, 4-D and 5-D input x + respectively and filters arrays. Parameters ---------- @@ -2055,9 +2048,8 @@ def conv_general_transpose( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D, 2-D, and 3-D transpose convolution given 3-D, 4-D and 5-D input x - respectively and filters arrays. + """Compute a 1-D, 2-D, and 3-D transpose convolution given 3-D, 4-D and 5-D + input x respectively and filters arrays. Parameters ---------- @@ -2197,9 +2189,8 @@ def conv( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D, 2-D, and 3-D transpose or dilated convolution given 3-D, 4-D and 5-D - input x respectively and filters arrays. + """Compute a 1-D, 2-D, and 3-D transpose or dilated convolution given 3-D, + 4-D and 5-D input x respectively and filters arrays. Parameters ---------- @@ -2296,8 +2287,8 @@ def lstm_update( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, recurrent_bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Perform long-short term memory update by unrolling time dimension of input array. + """Perform long-short term memory update by unrolling time dimension of + input array. Parameters ---------- @@ -2527,8 +2518,7 @@ def _get_x_data_format(dims: int = 2, data_format: str = "channel_first"): def _get_num_padded_values(i, p, n, k, s): - """ - Get number of padded values in a specific window. + """Get number of padded values in a specific window. Parameters ---------- diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index bd3c643f7e763..8831c28b7b64a 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -39,8 +39,7 @@ def cholesky( upper: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the cholesky decomposition of the x matrix. + """Compute the cholesky decomposition of the x matrix. Parameters ---------- @@ -183,8 +182,7 @@ def cross( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return cross product of 3-element vectors. + """Return cross product of 3-element vectors. If x1 and x2 are multi- dimensional arrays (i.e., both have a rank greater than 1), then the cross- product of each pair of corresponding 3-element vectors is @@ -283,8 +281,8 @@ def cross( def det( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Return the determinant of a square matrix (or a stack of square matrices)``x``. + """Return the determinant of a square matrix (or a stack of square + matrices)``x``. Parameters ---------- @@ -363,8 +361,8 @@ def diagonal( axis2: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the specified diagonals of a matrix (or a stack of matrices) ``x``. + """Return the specified diagonals of a matrix (or a stack of matrices) + ``x``. Parameters ---------- @@ -540,10 +538,9 @@ def eig( *, out: Optional[ivy.Array] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray]]: - """ - Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack of symmetric - matrices) ``x``, where ``Q`` is an orthogonal matrix (or a stack of matrices) and - ``L`` is a vector (or a stack of vectors). + """Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack + of symmetric matrices) ``x``, where ``Q`` is an orthogonal matrix (or a + stack of matrices) and ``L`` is a vector (or a stack of vectors). .. note:: The function ``eig`` currently behaves like ``eigh``, as @@ -594,10 +591,9 @@ def eigh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray]]: - r""" - Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack of symmetric - matrices) ``x``, where ``Q`` is an orthogonal matrix (or a stack of matrices) and - ``L`` is a vector (or a stack of vectors). + r"""Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack + of symmetric matrices) ``x``, where ``Q`` is an orthogonal matrix (or a + stack of matrices) and ``L`` is a vector (or a stack of vectors). .. note:: The function ``eig`` will be added in a future version of the specification, as @@ -707,8 +703,8 @@ def eigvalsh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the eigenvalues of a symmetric matrix (or a stack of symmetric matrices) x. + """Return the eigenvalues of a symmetric matrix (or a stack of symmetric + matrices) x. .. note:: The function ``eig`` will be added in a future version of the specification, as @@ -815,8 +811,7 @@ def inner( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the inner product of two vectors ``x1`` and ``x2``. + """Return the inner product of two vectors ``x1`` and ``x2``. Parameters ---------- @@ -894,9 +889,8 @@ def inv( adjoint: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the multiplicative inverse of a square matrix (or a stack of square matrices) - ``x``. + """Return the multiplicative inverse of a square matrix (or a stack of + square matrices) ``x``. Parameters ---------- @@ -992,8 +986,7 @@ def matmul( adjoint_b: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the matrix product. + """Compute the matrix product. Parameters ---------- @@ -1153,8 +1146,7 @@ def matrix_norm( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the matrix p-norm. + """Compute the matrix p-norm. Parameters ---------- @@ -1309,8 +1301,8 @@ def matrix_norm( def matrix_power( x: Union[ivy.Array, ivy.NativeArray], n: int, /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Raise a square matrix (or a stack of square matrices) x to an integer power n. + """Raise a square matrix (or a stack of square matrices) x to an integer + power n. Parameters ---------- @@ -1416,9 +1408,8 @@ def matrix_rank( hermitian: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the rank (i.e., number of non-zero singular values) of a matrix (or a stack - of matrices). + """Return the rank (i.e., number of non-zero singular values) of a matrix + (or a stack of matrices). Parameters ---------- @@ -1530,8 +1521,7 @@ def matrix_transpose( conjugate: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Transposes a matrix (or a stack of matrices) ``x``. + """Transposes a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1620,8 +1610,7 @@ def outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the outer product of two vectors ``x1`` and ``x2``. + """Return the outer product of two vectors ``x1`` and ``x2``. Parameters ---------- @@ -1711,9 +1700,8 @@ def pinv( rtol: Optional[Union[float, Tuple[float]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the (Moore-Penrose) pseudo-inverse of a matrix (or a stack of matrices) - ``x``. + """Return the (Moore-Penrose) pseudo-inverse of a matrix (or a stack of + matrices) ``x``. Parameters ---------- @@ -1787,10 +1775,9 @@ def qr( mode: str = "reduced", out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Return the qr decomposition x = QR of a full column rank matrix (or a stack of - matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an - upper-triangular matrix (or a stack of matrices). + """Return the qr decomposition x = QR of a full column rank matrix (or a + stack of matrices), where Q is an orthonormal matrix (or a stack of + matrices) and R is an upper-triangular matrix (or a stack of matrices). Parameters ---------- @@ -2008,9 +1995,8 @@ def solve( adjoint: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the solution x to the system of linear equations represented by the well- - determined (i.e., full rank) linear matrix equation Ax = B. + """Return the solution x to the system of linear equations represented by + the well- determined (i.e., full rank) linear matrix equation Ax = B. Parameters ---------- @@ -2138,11 +2124,11 @@ def svd( compute_uv: bool = True, full_matrices: bool = True, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """ - Return a singular value decomposition A = USVh of a matrix (or a stack of matrices) - ``x``, where ``U`` is a matrix (or a stack of matrices) with orthonormal columns, - ``S`` is a vector of non-negative numbers (or stack of vectors), and ``Vh`` is a - matrix (or a stack of matrices) with orthonormal rows. + """Return a singular value decomposition A = USVh of a matrix (or a stack + of matrices) ``x``, where ``U`` is a matrix (or a stack of matrices) with + orthonormal columns, ``S`` is a vector of non-negative numbers (or stack of + vectors), and ``Vh`` is a matrix (or a stack of matrices) with orthonormal + rows. Parameters ---------- @@ -2270,8 +2256,7 @@ def svdvals( driver: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the singular values of a matrix (or a stack of matrices) ``x``. + """Return the singular values of a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -2413,8 +2398,7 @@ def tensordot( axes: Union[int, Tuple[List[int], List[int]]] = 2, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a tensor contraction of x1 and x2 over specific axes. + """Return a tensor contraction of x1 and x2 over specific axes. .. note:: If either ``x1`` or ``x2`` has a complex floating-point data type, neither @@ -2514,9 +2498,8 @@ def trace( axis2: int = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the sum along the specified diagonals of a matrix (or a stack of matrices) - ``x``. + """Return the sum along the specified diagonals of a matrix (or a stack of + matrices) ``x``. **Special cases** @@ -2699,8 +2682,7 @@ def vecdot( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the (vector) dot product of two arrays. + """Compute the (vector) dot product of two arrays. Parameters ---------- @@ -2798,8 +2780,7 @@ def vector_norm( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the vector norm of a vector (or batch of vectors) ``x``. + r"""Compute the vector norm of a vector (or batch of vectors) ``x``. Parameters ---------- @@ -2944,9 +2925,8 @@ def diag( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the specified diagonals of the input array, or an array with the input - array's elements as diagonals. + """Return the specified diagonals of the input array, or an array with the + input array's elements as diagonals. Parameters ---------- @@ -3029,11 +3009,11 @@ def vander( increasing: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a Vandermonde matrix. The columns of the output matrix are elementwise - powers of the input vector x^{(N-1)}, x^{(N-2)}, ..., x^0x. If increasing is True, - the order of the columns is reversed x^0, x^1, ..., x^{(N-1)}. Such a matrix with a - geometric progression in each row is named for Alexandre-Theophile Vandermonde. + """Generate a Vandermonde matrix. The columns of the output matrix are + elementwise powers of the input vector x^{(N-1)}, x^{(N-2)}, ..., x^0x. If + increasing is True, the order of the columns is reversed x^0, x^1, ..., + x^{(N-1)}. Such a matrix with a geometric progression in each row is named + for Alexandre-Theophile Vandermonde. Parameters ---------- diff --git a/ivy/functional/ivy/losses.py b/ivy/functional/ivy/losses.py index 64201cf60f566..56bce17a0e5cc 100644 --- a/ivy/functional/ivy/losses.py +++ b/ivy/functional/ivy/losses.py @@ -44,8 +44,7 @@ def cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute cross-entropy between predicted and true discrete distributions. + """Compute cross-entropy between predicted and true discrete distributions. Parameters ---------- @@ -102,8 +101,7 @@ def binary_cross_entropy( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the binary cross entropy loss. + """Compute the binary cross entropy loss. Parameters ---------- @@ -281,8 +279,7 @@ def sparse_cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute sparse cross entropy between logits and labels. + """Compute sparse cross entropy between logits and labels. Parameters ---------- diff --git a/ivy/functional/ivy/manipulation.py b/ivy/functional/ivy/manipulation.py index 318c663b739b7..a039a9159e3a0 100644 --- a/ivy/functional/ivy/manipulation.py +++ b/ivy/functional/ivy/manipulation.py @@ -54,8 +54,7 @@ def concat( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Join a sequence of arrays along an existing axis. + """Join a sequence of arrays along an existing axis. Parameters ---------- @@ -114,9 +113,8 @@ def expand_dims( axis: Union[int, Sequence[int]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Expand the shape of an array by inserting a new axis (dimension) of size one at the - position specified by axis. + """Expand the shape of an array by inserting a new axis (dimension) of size + one at the position specified by axis. Parameters ---------- @@ -252,9 +250,8 @@ def flip( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Reverses the order of elements in an array along the given axis. The shape of the - array must be preserved. + """Reverses the order of elements in an array along the given axis. The + shape of the array must be preserved. Parameters ---------- @@ -347,8 +344,7 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Permutes the axes (dimensions) of an array x. + """Permutes the axes (dimensions) of an array x. Parameters ---------- @@ -450,8 +446,7 @@ def reshape( allowzero: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Give a new shape to an array without changing its data. + """Give a new shape to an array without changing its data. Parameters ---------- @@ -574,10 +569,10 @@ def roll( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, ivy.Container]: - """ - Roll array elements along a specified axis. Array elements that roll beyond the last - position are re-introduced at the first position. Array elements that roll beyond - the first position are re-introduced at the last position. + """Roll array elements along a specified axis. Array elements that roll + beyond the last position are re-introduced at the first position. Array + elements that roll beyond the first position are re-introduced at the last + position. Parameters ---------- @@ -688,8 +683,7 @@ def squeeze( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Remove singleton dimensions (axes) from x. + """Remove singleton dimensions (axes) from x. Parameters ---------- @@ -781,8 +775,7 @@ def stack( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Join a sequence of arrays along a new axis. + """Join a sequence of arrays along a new axis. Parameters ---------- @@ -869,8 +862,7 @@ def clip( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Clips (limits) the values in an array. + """Clips (limits) the values in an array. Given an interval, values outside the interval are clipped to the interval edges (element-wise). For example, if an interval of [0, 1] is specified, values smaller @@ -997,8 +989,7 @@ def constant_pad( value: Number = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Pad an array with a constant value. + """Pad an array with a constant value. Parameters ---------- @@ -1094,8 +1085,7 @@ def repeat( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Repeat values along a given dimension. + """Repeat values along a given dimension. Parameters ---------- @@ -1170,8 +1160,7 @@ def split( axis: int = 0, with_remainder: bool = False, ) -> List[ivy.Array]: - """ - Split an array into multiple sub-arrays. + """Split an array into multiple sub-arrays. Parameters ---------- @@ -1256,8 +1245,7 @@ def swapaxes( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Interchange two axes of an array. + """Interchange two axes of an array. Parameters ---------- @@ -1364,8 +1352,7 @@ def tile( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Construct an array by repeating x the number of times given by reps. + """Construct an array by repeating x the number of times given by reps. Parameters ---------- @@ -1447,8 +1434,7 @@ def unstack( axis: int = 0, keepdims: bool = False, ) -> List[ivy.Array]: - """ - Unpacks the given dimension of a rank-R array into rank-(R-1) arrays. + """Unpacks the given dimension of a rank-R array into rank-(R-1) arrays. Parameters ---------- @@ -1542,8 +1528,7 @@ def zero_pad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Pad an array with zeros. + """Pad an array with zeros. Parameters ---------- diff --git a/ivy/functional/ivy/meta.py b/ivy/functional/ivy/meta.py index 7ba70923ae8e6..5b3151c9accc6 100644 --- a/ivy/functional/ivy/meta.py +++ b/ivy/functional/ivy/meta.py @@ -26,8 +26,7 @@ def _compute_cost_and_update_grads( batched, num_tasks, ): - """ - Compute cost and update gradients. + """Compute cost and update gradients. This function computes the cost and updates gradients for optimization. @@ -474,8 +473,7 @@ def fomaml_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """ - Perform step of first order MAML. + """Perform step of first order MAML. Parameters ---------- @@ -590,8 +588,7 @@ def reptile_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """ - Perform a step of Reptile. + """Perform a step of Reptile. Parameters ---------- @@ -740,8 +737,7 @@ def maml_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """ - Perform step of vanilla second order MAML. + """Perform step of vanilla second order MAML. Parameters ---------- diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index 9ed54e924b8f1..dcf7993b5e987 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -20,8 +20,8 @@ def index_nest( index: Union[List[int], Tuple[int], Iterable[int]], /, ) -> Any: - """ - Index a nested object, using a tuple of indices or keys in the case of dicts. + """Index a nested object, using a tuple of indices or keys in the case of + dicts. Parameters ---------- @@ -92,8 +92,7 @@ def index_nest( @handle_exceptions def prune_nest_at_index(nest: Iterable, index: Tuple, /) -> None: - """ - Prune a nested object at a specified index. + """Prune a nested object at a specified index. Parameters ---------- @@ -117,8 +116,7 @@ def set_nest_at_index( shallow: bool = True, _result: Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """ - Set the value of a nested item at a specified index. + """Set the value of a nested item at a specified index. Parameters ---------- @@ -217,8 +215,8 @@ def set_nest_at_index( @handle_exceptions def insert_into_nest_at_index(nest: Iterable, index: Tuple, value) -> None: - """ - Recursively inserts a value into a nested data structure at a specified index. + """Recursively inserts a value into a nested data structure at a specified + index. This function traverses a nested data structure and inserts the provided `value` at the specified `index`. @@ -277,8 +275,7 @@ def map_nest_at_index( shallow: bool = True, _result: Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """ - Map a function to the value of a nested item at a specified index. + """Map a function to the value of a nested item at a specified index. Parameters ---------- @@ -382,9 +379,8 @@ def multi_index_nest( indices: Iterable[Iterable[int]], /, ) -> Iterable[Any]: - """ - Repeatedly index a nested object, using a tuple of tuples of indices or keys in the - case of dicts. + """Repeatedly index a nested object, using a tuple of tuples of indices or + keys in the case of dicts. Parameters ---------- @@ -449,8 +445,7 @@ def multi_index_nest( @handle_exceptions def prune_nest_at_indices(nest: Iterable, indices: Tuple, /) -> None: - """ - Prune a nested object at specified indices. + """Prune a nested object at specified indices. Parameters ---------- @@ -476,8 +471,8 @@ def set_nest_at_indices( /, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """ - Set the value of a nested item at specified indices with specified values. + """Set the value of a nested item at specified indices with specified + values. Parameters ---------- @@ -554,8 +549,8 @@ def set_nest_at_indices( @handle_exceptions def insert_into_nest_at_indices(nest: Iterable, indices: Tuple, values, /) -> None: - """ - Insert a value into the nested item at specified indices with specified values. + """Insert a value into the nested item at specified indices with specified + values. Parameters ---------- @@ -583,8 +578,7 @@ def map_nest_at_indices( /, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """ - Map a function to the values of a nested item at the specified indices. + """Map a function to the values of a nested item at the specified indices. Parameters ---------- @@ -668,9 +662,8 @@ def nested_argwhere( _base: bool = True, stop_after_n_found: Optional[int] = None, ) -> Union[Iterable, bool]: - """ - Check the leaf nodes of nested x via function fn, and returns all nest indices where - the method evaluates as True. + """Check the leaf nodes of nested x via function fn, and returns all nest + indices where the method evaluates as True. Parameters ---------- @@ -820,8 +813,7 @@ def all_nested_indices( _index: Optional[Union[int, Sequence[int]]] = None, _base: bool = True, ) -> List: - """ - Return indices of all the elements in nest. + """Return indices of all the elements in nest. Parameters ---------- @@ -916,8 +908,7 @@ def map( unique: Optional[Dict[str, Iterable[Any]]] = None, mean: bool = False, ) -> List: - """ - Apply a function on each item of an iterable x. + """Apply a function on each item of an iterable x. Parameters ---------- @@ -1027,10 +1018,9 @@ def nested_map( _dict_check_fn: Optional[Callable] = None, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, Iterable, Dict]: - """ - Apply a function on x in a nested manner, whereby all dicts, lists and tuples are - traversed to their lowest leaves before applying the method and returning x. If x is - not nested, the method is applied to x directly. + """Apply a function on x in a nested manner, whereby all dicts, lists and + tuples are traversed to their lowest leaves before applying the method and + returning x. If x is not nested, the method is applied to x directly. Parameters ---------- @@ -1242,9 +1232,8 @@ def nested_any( check_nests: bool = False, _base: bool = True, ) -> bool: - """ - Check the leaf nodes of nest x via function fn, and returns True if any evaluate to - True, else False. + """Check the leaf nodes of nest x via function fn, and returns True if any + evaluate to True, else False. Parameters ---------- @@ -1288,9 +1277,8 @@ def copy_nest( include_derived: bool = False, to_mutable: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """ - Copy a nest deeply, but without copying leaves of the nest, only the nest lists, - tuples and dicts are copied. + """Copy a nest deeply, but without copying leaves of the nest, only the + nest lists, tuples and dicts are copied. Parameters ---------- @@ -1391,9 +1379,8 @@ def nested_multi_map( config=None, to_ivy=True, ): - """ - Apply function to all array values from a collection of identically structured ivy - arrays. + """Apply function to all array values from a collection of identically + structured ivy arrays. Parameters ---------- @@ -1541,10 +1528,9 @@ def _found_in_index_chains(this_index_chain, index_chains): @handle_exceptions def duplicate_array_index_chains(nest: Union[ivy.Array, ivy.NativeArray, Iterable]): - """ - Group all unique index chains in a nest. This function is useful for finding all - unique index chains in a nest, and then duplicating the values at those index chains - for functional frameworks. + """Group all unique index chains in a nest. This function is useful for + finding all unique index chains in a nest, and then duplicating the values + at those index chains for functional frameworks. Parameters ---------- @@ -1572,8 +1558,7 @@ def duplicate_array_index_chains(nest: Union[ivy.Array, ivy.NativeArray, Iterabl def prune_empty(nest): - """ - Prune empty nests from a nest. + """Prune empty nests from a nest. Parameters ---------- diff --git a/ivy/functional/ivy/norms.py b/ivy/functional/ivy/norms.py index 0af316281855b..8812b94cc8a00 100644 --- a/ivy/functional/ivy/norms.py +++ b/ivy/functional/ivy/norms.py @@ -32,8 +32,7 @@ def layer_norm( new_std: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply Layer Normalization over a mini-batch of inputs. + """Apply Layer Normalization over a mini-batch of inputs. Parameters ---------- diff --git a/ivy/functional/ivy/random.py b/ivy/functional/ivy/random.py index 23949e11ba77a..ca9510b0a0179 100644 --- a/ivy/functional/ivy/random.py +++ b/ivy/functional/ivy/random.py @@ -106,11 +106,10 @@ def random_uniform( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from a uniform distribution. Samples are uniformly distributed over - the half-open interval ``[low, high)`` (includes ``low``, but excludes ``high``). In - other words, any value within the given interval is equally likely to be drawn by - uniform. + """Draws samples from a uniform distribution. Samples are uniformly + distributed over the half-open interval ``[low, high)`` (includes ``low``, + but excludes ``high``). In other words, any value within the given interval + is equally likely to be drawn by uniform. Parameters ---------- @@ -222,8 +221,7 @@ def random_normal( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from a normal distribution. + """Draws samples from a normal distribution. Parameters ---------- @@ -334,10 +332,10 @@ def multinomial( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from a multinomial distribution. Specifically, returns a tensor where - each row contains num_samples indices sampled from the multinomial probability - distribution located in the corresponding row of tensor input. + """Draws samples from a multinomial distribution. Specifically, returns a + tensor where each row contains num_samples indices sampled from the + multinomial probability distribution located in the corresponding row of + tensor input. Parameters ---------- @@ -444,9 +442,8 @@ def randint( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an array filled with random integers generated uniformly between low - (inclusive) and high (exclusive). + """Return an array filled with random integers generated uniformly between + low (inclusive) and high (exclusive). Parameters ---------- @@ -508,8 +505,7 @@ def randint( @handle_exceptions @handle_nestable def seed(*, seed_value: int = 0) -> None: - """ - Set the seed for random number generation. + """Set the seed for random number generation. Parameters ---------- @@ -539,8 +535,7 @@ def shuffle( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Shuffles the given array along a given axis. + """Shuffles the given array along a given axis. Parameters ---------- diff --git a/ivy/functional/ivy/searching.py b/ivy/functional/ivy/searching.py index ae440f221d0d8..0faf2e0efd258 100644 --- a/ivy/functional/ivy/searching.py +++ b/ivy/functional/ivy/searching.py @@ -39,10 +39,9 @@ def argmax( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices of the maximum values along a specified axis. When the maximum - value occurs multiple times, only the indices corresponding to the first occurrence - are returned. + """Return the indices of the maximum values along a specified axis. When + the maximum value occurs multiple times, only the indices corresponding to + the first occurrence are returned. Parameters ---------- @@ -156,10 +155,9 @@ def argmin( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices of the minimum values along a specified axis. When the minimum - value occurs multiple times, only the indices corresponding to the first occurrence - are returned. + """Return the indices of the minimum values along a specified axis. When + the minimum value occurs multiple times, only the indices corresponding to + the first occurrence are returned. Parameters ---------- @@ -264,8 +262,7 @@ def nonzero( size: Optional[int] = None, fill_value: Number = 0, ) -> Union[Tuple[ivy.Array], ivy.Array]: - """ - Return the indices of the array elements which are non-zero. + """Return the indices of the array elements which are non-zero. .. note:: If ``x`` has a complex floating-point data type, non-zero elements @@ -401,8 +398,7 @@ def where( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return elements chosen from x or y depending on condition. + """Return elements chosen from x or y depending on condition. Parameters ---------- @@ -485,8 +481,7 @@ def argwhere( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices of all non-zero elements of the input array. + """Return the indices of all non-zero elements of the input array. Parameters ---------- diff --git a/ivy/functional/ivy/set.py b/ivy/functional/ivy/set.py index 0c0d916b24cc4..10ae870d1b89a 100644 --- a/ivy/functional/ivy/set.py +++ b/ivy/functional/ivy/set.py @@ -38,10 +38,10 @@ def unique_all( Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray], ]: - """ - Return the unique elements of an input array ``x``, the first occurring indices for - each unique element in ``x``, the indices from the set of unique elements that - reconstruct ``x``, and the corresponding counts for each unique element in ``x``. + """Return the unique elements of an input array ``x``, the first occurring + indices for each unique element in ``x``, the indices from the set of + unique elements that reconstruct ``x``, and the corresponding counts for + each unique element in ``x``. .. admonition:: Data-dependent output shape :class: important @@ -161,9 +161,8 @@ def unique_inverse( *, axis: Optional[int] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray]]: - """ - Return the unique elements of an input array ``x``, and the indices from the set of - unique elements that reconstruct ``x``. + """Return the unique elements of an input array ``x``, and the indices from + the set of unique elements that reconstruct ``x``. .. admonition:: Data-dependent output shape :class: important @@ -276,8 +275,7 @@ def unique_values( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the unique elements of an input array ``x``. + """Return the unique elements of an input array ``x``. .. admonition:: Data-dependent output shape :class: important @@ -367,9 +365,8 @@ def unique_counts( x: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple[Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray]]: - """ - Return the unique elements of an input array ``x`` and the corresponding counts for - each unique element in ``x``. + """Return the unique elements of an input array ``x`` and the corresponding + counts for each unique element in ``x``. .. admonition:: Data-dependent output shape :class: important diff --git a/ivy/functional/ivy/sorting.py b/ivy/functional/ivy/sorting.py index fe073103f1541..7e3e7daaac313 100644 --- a/ivy/functional/ivy/sorting.py +++ b/ivy/functional/ivy/sorting.py @@ -36,8 +36,7 @@ def argsort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices that sort an array ``x`` along a specified axis. + """Return the indices that sort an array ``x`` along a specified axis. Parameters ---------- @@ -157,8 +156,7 @@ def sort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a sorted copy of an array. + """Return a sorted copy of an array. Parameters ---------- @@ -259,8 +257,7 @@ def msort( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a copy of an array sorted along the first axis. + """Return a copy of an array sorted along the first axis. Parameters ---------- @@ -308,8 +305,7 @@ def searchsorted( ret_dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices of the inserted elements in a sorted array. + """Return the indices of the inserted elements in a sorted array. Parameters ---------- diff --git a/ivy/functional/ivy/statistical.py b/ivy/functional/ivy/statistical.py index 0afd9b740b22c..59c0cc0ccc303 100644 --- a/ivy/functional/ivy/statistical.py +++ b/ivy/functional/ivy/statistical.py @@ -50,8 +50,7 @@ def min( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the minimum value of the input array ``x``. + """Calculate the minimum value of the input array ``x``. .. note:: When the number of elements over which to compute the minimum value is zero, the @@ -159,8 +158,7 @@ def max( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the maximum value of the input array ``x``. + """Calculate the maximum value of the input array ``x``. .. note:: When the number of elements over which to compute the maximum value is zero, the @@ -270,8 +268,7 @@ def mean( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the arithmetic mean of the input array ``x``. + """Calculate the arithmetic mean of the input array ``x``. **Special Cases** @@ -383,8 +380,7 @@ def prod( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the product of input array x elements. + """Calculate the product of input array x elements. **Special Cases** @@ -519,8 +515,7 @@ def std( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the standard deviation of the input array ``x``. + """Calculate the standard deviation of the input array ``x``. **Special Cases** @@ -658,8 +653,7 @@ def sum( keepdims: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the sum of the input array x. + """Calculate the sum of the input array x. **Special Cases** @@ -799,8 +793,7 @@ def var( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the variance of the input array x. + """Calculate the variance of the input array x. **Special Cases** @@ -916,8 +909,7 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the cumulative sum of the elements along a given axis. + """Return the cumulative sum of the elements along a given axis. Parameters ---------- @@ -1062,8 +1054,7 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the cumulative product of the elements along a given axis. + """Return the cumulative product of the elements along a given axis. Parameters ---------- @@ -1195,9 +1186,8 @@ def einsum( *operands: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Sum the product of the elements of the input operands along dimensions specified - using a notation based on the Einstein summation convention. + """Sum the product of the elements of the input operands along dimensions + specified using a notation based on the Einstein summation convention. Parameters ---------- diff --git a/ivy/functional/ivy/utility.py b/ivy/functional/ivy/utility.py index 09bd432b60291..d323e0f91cda5 100644 --- a/ivy/functional/ivy/utility.py +++ b/ivy/functional/ivy/utility.py @@ -33,8 +33,8 @@ def all( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test whether all input array elements evaluate to ``True`` along a specified axis. + """Test whether all input array elements evaluate to ``True`` along a + specified axis. .. note:: Positive infinity, negative infinity, and NaN must evaluate to ``True``. @@ -147,8 +147,8 @@ def any( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test whether any input array element evaluates to ``True`` along a specified axis. + """Test whether any input array element evaluates to ``True`` along a + specified axis. .. note:: Positive infinity, negative infinity, and NaN must evaluate to ``True``. diff --git a/ivy/stateful/activations.py b/ivy/stateful/activations.py index ae3991c099122..65d158af4b6cc 100644 --- a/ivy/stateful/activations.py +++ b/ivy/stateful/activations.py @@ -13,8 +13,7 @@ def __init__( approximate: bool = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the GELU activation function. + """Apply the GELU activation function. Parameters ---------- @@ -29,8 +28,7 @@ def __init__( Module.__init__(self) def _forward(self, x): - """ - Perform forward pass of the GELU activation. + """Perform forward pass of the GELU activation. Parameters ---------- @@ -58,8 +56,7 @@ def __init__(self): Module.__init__(self) def _forward(self, inputs): - """ - Perform forward pass of the GEGLU activation. + """Perform forward pass of the GEGLU activation. Parameters ---------- @@ -80,8 +77,7 @@ def __init__( self, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the RELU activation function. + """Apply the RELU activation function. Parameters ---------- @@ -117,8 +113,7 @@ def __init__( alpha: float = 0.2, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the LEAKY RELU activation function. + """Apply the LEAKY RELU activation function. Parameters ---------- @@ -161,8 +156,7 @@ def __init__( axis: Optional[int] = -1, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the LOG SOFTMAX activation function. + """Apply the LOG SOFTMAX activation function. Parameters ---------- @@ -201,8 +195,7 @@ def __init__( axis: int = -1, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the SOFTMAX activation function. + """Apply the SOFTMAX activation function. Parameters ---------- @@ -314,8 +307,7 @@ def _forward(self, x): class Sigmoid(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the SIGMOID activation function. + """Apply the SIGMOID activation function. Parameter ---------- @@ -347,8 +339,7 @@ def _extra_repr(self) -> str: class Tanh(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the TANH activation function. + """Apply the TANH activation function. Parameters ---------- @@ -380,8 +371,7 @@ def _extra_repr(self) -> str: class ReLU6(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the TANH activation function. + """Apply the TANH activation function. Parameters ---------- @@ -413,8 +403,7 @@ def _extra_repr(self) -> str: class Hardswish(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the HARDSWISH activation function. + """Apply the HARDSWISH activation function. Parameters ---------- @@ -450,8 +439,7 @@ def __init__( eps=None, complex_mode="jax", ): - """ - Apply the LOGIT activation function. + """Apply the LOGIT activation function. Parameters ---------- @@ -564,8 +552,7 @@ def _extra_repr(self) -> str: class LogSigmoid(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the LogSigmoid activation function. + """Apply the LogSigmoid activation function. Parameter ---------- diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index 1f91646840b5f..834096133f581 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -21,9 +21,8 @@ def to_ivy_module( devices=None, inplace_update=False, ): - """ - Convert an instance of a trainable module from a native framework into a trainable - ivy.Module instance. + """Convert an instance of a trainable module from a native framework into a + trainable ivy.Module instance. Parameters ---------- @@ -76,8 +75,7 @@ def from_haiku_module( device=None, devices=None, ): - """ - Convert a Haiku module instance to an Ivy module instance. + """Convert a Haiku module instance to an Ivy module instance. Parameters ---------- @@ -170,8 +168,7 @@ def from_flax_module( device=None, devices=None, ): - """ - Convert a Flax module instance to an Ivy module instance. + """Convert a Flax module instance to an Ivy module instance. Parameters ---------- @@ -260,8 +257,7 @@ def from_keras_module( device=None, devices=None, ): - """ - Convert a Keras module instance to an Ivy module instance. + """Convert a Keras module instance to an Ivy module instance. Parameters ---------- @@ -323,8 +319,7 @@ def from_paddle_module( device=None, devices=None, ): - """ - Convert a Paddle layer instance to an Ivy module instance. + """Convert a Paddle layer instance to an Ivy module instance. Parameters ---------- @@ -380,8 +375,7 @@ def from_torch_module( devices=None, inplace_update=False, ): - """ - Convert a Torch module instance to an Ivy module instance. + """Convert a Torch module instance to an Ivy module instance. Parameters ---------- @@ -440,8 +434,8 @@ def from_torch_module( ) def to_keras_module(self): - """ - Convert a `ivy.Module` module instance to a `tf.keras.Model` instance. + """Convert a `ivy.Module` module instance to a `tf.keras.Model` + instance. Returns ------- diff --git a/ivy/stateful/helpers.py b/ivy/stateful/helpers.py index 0cc4ad9b1b322..389b30c07eca7 100644 --- a/ivy/stateful/helpers.py +++ b/ivy/stateful/helpers.py @@ -19,8 +19,8 @@ def _find_variables( without_initialisation=False, _visited=None, ): - """ - Find all internal variables in obj. Return empty Container if obj is None. + """Find all internal variables in obj. Return empty Container if obj is + None. Parameters ---------- @@ -99,10 +99,10 @@ def _build_and_return_v(self, *args, **kwargs): @staticmethod def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): - """ - Extract the variables from the variables container v using the key - orig_key_chain and reinstantiate the duplicate variables that were removed by - _remove_duplicate_variables in their correct locations using keychain_mappings. + """Extract the variables from the variables container v using the key + orig_key_chain and reinstantiate the duplicate variables that were + removed by _remove_duplicate_variables in their correct locations using + keychain_mappings. Parameters ---------- @@ -136,8 +136,7 @@ def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): @staticmethod def _remove_duplicate_variables(vs, created, /): - """ - Remove duplicate variables in `vs` referring to `created`. + """Remove duplicate variables in `vs` referring to `created`. Parameters ---------- @@ -181,10 +180,9 @@ def found_dup_callback(x, kc): def _wrap_call_methods( self, keychain_mappings, /, *, key="", obj=None, _visited=None ): - """ - Wrap the call methods of the Module object by looping over all the items within - the module, wrapping the __call__ methods of all submodules using - _fn_with_var_arg. + """Wrap the call methods of the Module object by looping over all the + items within the module, wrapping the __call__ methods of all + submodules using _fn_with_var_arg. Parameters ---------- @@ -241,8 +239,8 @@ def _wrap_call_methods( return def _call(self, *args, v=None, buffers=None, **kwargs): - """ - Compute forward pass of the layer, treating layer instance as callable function. + """Compute forward pass of the layer, treating layer instance as + callable function. Parameters ---------- @@ -336,8 +334,7 @@ def _fn_with_var_arg_wrapper( return fn(*a, **kw, v=v) def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): - """ - Extract variables from `v_fn` and use it as inputs for `fn`. + """Extract variables from `v_fn` and use it as inputs for `fn`. Use `v_fn` to extract the variables and use the extracted variables as inputs to the call function fn of the module. @@ -353,9 +350,9 @@ def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): return _fn_with_var_arg_wrapper def _convert_tensors_to_numpy(self): - """ - Recursively traverses the module_dict attribute of a Module object and converts - every container containing tensors to numpy using the to_numpy() method. + """Recursively traverses the module_dict attribute of a Module object + and converts every container containing tensors to numpy using the + to_numpy() method. Returns ------- @@ -368,9 +365,9 @@ def _convert_tensors_to_numpy(self): self.v = self.v.to_numpy() def _convert_numpy_to_tensors(self): - """ - Recursively traverses the module_dict attribute of a Module object and converts - every container containing tensors to numpy using the to_numpy() method. + """Recursively traverses the module_dict attribute of a Module object + and converts every container containing tensors to numpy using the + to_numpy() method. Returns ------- diff --git a/ivy/stateful/initializers.py b/ivy/stateful/initializers.py index 1481fce608f80..5f2f0a7907add 100644 --- a/ivy/stateful/initializers.py +++ b/ivy/stateful/initializers.py @@ -12,8 +12,7 @@ class Initializer(abc.ABC): - """ - An initializer for internal variables for a layer. + """An initializer for internal variables for a layer. A neuron is a function of the form `a = g(z)`, where `g` is the activation functions and `z = w_1x_1 + w_2x_2 + ... + w_nx_n` where the @@ -31,8 +30,7 @@ def create_variables( fan_in: Optional[float] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ) -> ivy.Array: - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -59,8 +57,8 @@ def create_variables( class Constant(Initializer): def __init__(self, constant: float): - """ - Constant initializer, will fill in all values with the value of `constant`. + """Constant initializer, will fill in all values with the value of + `constant`. Parameters ---------- @@ -100,9 +98,9 @@ def __init__(self): class Uniform(Initializer): def __init__(self, numerator, fan_mode, power, gain): - """ - Initialize based on a uniform distribution, will fill in all values with values - drawn from a uniform (all values have an equal probability) distribution. + """Initialize based on a uniform distribution, will fill in all values + with values drawn from a uniform (all values have an equal probability) + distribution. with range `[-wlim, wlim]` (endpoints included) with `wlim` being calculated as `gain * (numerator / fan)**power`. This distribution helps with issues when @@ -141,8 +139,7 @@ def __init__(self, numerator, fan_mode, power, gain): def create_variables( self, var_shape, device, fan_out=None, fan_in=None, dtype=None ): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -215,8 +212,8 @@ def create_variables( class GlorotUniform(Uniform): def __init__(self): - """ - Initialize Glorot uniform, also known as the Xavier uniform initializer. + """Initialize Glorot uniform, also known as the Xavier uniform + initializer. It draws values from a uniform distribution `[-limit, limit]` where `limit = sqrt(6 / (fan_in + fan_out))` where `fan_in` and `fan_out` are the @@ -227,8 +224,7 @@ def __init__(self): class FirstLayerSiren(Uniform): def __init__(self): - """ - Initialize Siren uniform for the first layer. + """Initialize Siren uniform for the first layer. It draws values from a uniform distribution `[-limit, limit]` where `limit=fan_in` where `fan_in` is the number of input @@ -239,8 +235,7 @@ def __init__(self): class Siren(Uniform): def __init__(self, w0=30): - """ - Initialize Siren uniform initializer for the first layer. + """Initialize Siren uniform initializer for the first layer. It draws values from a uniform distribution `[-limit, limit]` where `limit=sqrt(6 / fan_in) / w0` where `fan_in` is the number @@ -255,8 +250,7 @@ def __init__(self, w0=30): class KaimingNormal(Initializer): def __init__(self, mean=0, fan_mode="fan_in"): - """ - Initialize Kaiming normal, also known as He Initialization. + """Initialize Kaiming normal, also known as He Initialization. It is an method for initializing layers that takes into account the non-linearity of activation functions. It uses a normal distribution centered @@ -292,8 +286,7 @@ def create_variables( negative_slope=0.0, dtype=None, ): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -369,8 +362,7 @@ def create_variables( class RandomNormal(Initializer): def __init__(self, mean=0.0, stddev=0.05, seed=None): - """ - Initialize with Random Normal Distribution. + """Initialize with Random Normal Distribution. It draws values from a Random Normal Distribution with given mean and standard deviation. @@ -394,8 +386,7 @@ def create_variables( device=None, dtype=None, ): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- diff --git a/ivy/stateful/layers.py b/ivy/stateful/layers.py index 69420663206a2..aa4460e699b3e 100644 --- a/ivy/stateful/layers.py +++ b/ivy/stateful/layers.py @@ -28,11 +28,11 @@ def __init__( v=None, dtype=None, ): - """ - Linear layer, also referred to as dense or fully connected. The layer receives - tensors with input_channels last dimension and returns a new tensor with - output_channels last dimension, following matrix multiplication with the weight - matrix and addition with the bias vector. + """Linear layer, also referred to as dense or fully connected. The + layer receives tensors with input_channels last dimension and returns a + new tensor with output_channels last dimension, following matrix + multiplication with the weight matrix and addition with the bias + vector. Parameters ---------- @@ -66,8 +66,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -103,8 +102,7 @@ def _create_variables(self, device=None, dtype=None): return v def _forward(self, x): - """ - Perform forward pass of the Linear layer. + """Perform forward pass of the Linear layer. Parameters ---------- @@ -138,9 +136,9 @@ def __init__( dtype=None, training: bool = True, ): - """ - Dropout layer. The layer randomly zeroes some of the elements of the input - tensor with probability p using samples from a Bernoull distribution. + """Dropout layer. The layer randomly zeroes some of the elements of the + input tensor with probability p using samples from a Bernoull + distribution. Parameters ---------- @@ -159,8 +157,7 @@ def __init__( Module.__init__(self, device=None, v=None, dtype=dtype, training=training) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -174,8 +171,7 @@ def _create_variables(self, device, dtype=None): return {} def _forward(self, inputs, dtype=None): - """ - Perform forward pass of the Linear layer. + """Perform forward pass of the Linear layer. Parameters ---------- @@ -226,8 +222,7 @@ def __init__( dtype=None, training=True, ): - """ - Multi Head Attention layer. + """Multi Head Attention layer. Parameters ---------- @@ -392,8 +387,7 @@ def _forward( return_attention_weights=False, average_attention_weights=True, ): - """ - Perform forward pass of the MultiHeadAttention layer. + """Perform forward pass of the MultiHeadAttention layer. Parameters ---------- @@ -485,8 +479,7 @@ def __init__( v=None, dtype=None, ): - """ - 1D convolutional layer. + """1D convolutional layer. Parameters ---------- @@ -538,8 +531,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -575,8 +567,7 @@ def _create_variables(self, device=None, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv1D layer. + """Perform forward pass of the Conv1D layer. Parameters ---------- @@ -631,8 +622,7 @@ def __init__( v=None, dtype=None, ): - """ - 1D transpose convolutional layer. + """1D transpose convolutional layer. Parameters ---------- @@ -687,8 +677,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -724,8 +713,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv1DTranspose layer. + """Perform forward pass of the Conv1DTranspose layer. Parameters ---------- @@ -782,8 +770,7 @@ def __init__( v=None, dtype=None, ): - """ - 2D convolutional layer. + """2D convolutional layer. Parameters ---------- @@ -837,8 +824,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -874,8 +860,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv2D layer. + """Perform forward pass of the Conv2D layer. Parameters ---------- @@ -930,8 +915,7 @@ def __init__( v=None, dtype=None, ): - """ - 2D convolutional transpose layer. + """2D convolutional transpose layer. Parameters ---------- @@ -988,8 +972,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1025,8 +1008,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv2DTranspose layer. + """Perform forward pass of the Conv2DTranspose layer. Parameters ---------- @@ -1082,8 +1064,7 @@ def __init__( v=None, dtype=None, ): - """ - Depthwise 2D convolutional layer. + """Depthwise 2D convolutional layer. Parameters ---------- @@ -1134,8 +1115,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1171,8 +1151,7 @@ def _create_variables(self, device, dtype): return v def _forward(self, inputs): - """ - Perform forward pass of the DepthwiseConv2D layer. + """Perform forward pass of the DepthwiseConv2D layer. Parameters ---------- @@ -1226,8 +1205,7 @@ def __init__( v=None, dtype=None, ): - """ - 3D convolutional layer. + """3D convolutional layer. Parameters ---------- @@ -1281,8 +1259,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1318,8 +1295,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv3D layer. + """Perform forward pass of the Conv3D layer. Parameters ---------- @@ -1375,8 +1351,7 @@ def __init__( v=None, dtype=None, ): - """ - 3D convolutional transpose layer. + """3D convolutional transpose layer. Parameters ---------- @@ -1434,8 +1409,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1471,8 +1445,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv3DTranspose layer. + """Perform forward pass of the Conv3DTranspose layer. Parameters ---------- @@ -1530,8 +1503,7 @@ def __init__( v=None, dtype=None, ): - """ - LSTM layer, which is a set of stacked lstm cells. + """LSTM layer, which is a set of stacked lstm cells. Parameters ---------- @@ -1571,8 +1543,8 @@ def __init__( # Public # def get_initial_state(self, batch_shape, dtype=None): - """ - Get the initial state of the hidden and cell states, if not provided explicitly. + """Get the initial state of the hidden and cell states, if not provided + explicitly. Parameters ---------- @@ -1597,8 +1569,7 @@ def get_initial_state(self, batch_shape, dtype=None): # Overridden def _create_variables(self, device=None, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1656,8 +1627,7 @@ def _create_variables(self, device=None, dtype=None): @handle_nestable def _forward(self, inputs, initial_state=None): - """ - Perform forward pass of the LSTM layer. + """Perform forward pass of the LSTM layer. Parameters ---------- @@ -1726,8 +1696,7 @@ def __init__( v=None, dtype=None, ): - """ - Class for applying Max Pooling over a mini-batch of inputs. + """Class for applying Max Pooling over a mini-batch of inputs. Parameters ---------- @@ -1747,8 +1716,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -1787,8 +1755,7 @@ def __init__( v=None, dtype=None, ): - """ - Class for applying Average Pooling over a mini-batch of inputs. + """Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -1808,8 +1775,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -1848,8 +1814,7 @@ def __init__( v=None, dtype=None, ): - """ - Class for applying Max Pooling over a mini-batch of inputs. + """Class for applying Max Pooling over a mini-batch of inputs. Parameters ---------- @@ -1869,8 +1834,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -1908,8 +1872,7 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying 3D Max Pooling over 5D inputs. + """Class for applying 3D Max Pooling over 5D inputs. Parameters ---------- @@ -1927,8 +1890,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -1967,8 +1929,7 @@ def __init__( ceil_mode=False, divisor_override=None, ): - """ - Class for applying Average Pooling over a mini-batch of inputs. + """Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -1998,8 +1959,7 @@ def __init__( Module.__init__(self) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2042,8 +2002,8 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying a 2D adaptive average pooling over mini-batch of inputs. + """Class for applying a 2D adaptive average pooling over mini-batch of + inputs. Parameters ---------- @@ -2056,8 +2016,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2087,8 +2046,8 @@ def __init__( dtype=None, ): # TODO: add data_format param - """ - Class for applying a 1D adaptive average pooling over mini-batch of inputs. + """Class for applying a 1D adaptive average pooling over mini-batch of + inputs. Parameters ---------- @@ -2102,8 +2061,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2137,8 +2095,7 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying FFT to input. + """Class for applying FFT to input. Parameters ---------- @@ -2158,8 +2115,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2198,8 +2154,7 @@ def __init__( *, data_format="NWC", ): - """ - Class for applying Average Pooling over a mini-batch of inputs. + """Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -2219,8 +2174,7 @@ def __init__( Module.__init__(self) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2257,8 +2211,8 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying the Discrete Cosine Transform over mini-batch of inputs. + """Class for applying the Discrete Cosine Transform over mini-batch of + inputs. Parameters ---------- @@ -2283,8 +2237,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2332,10 +2285,9 @@ def __init__( v=None, dtype=None, ): - """ - Class for embedding indices into a dense representation. The Embedding layer is - a simple lookup table for dense vectors. It's typically used to store word - embeddings and query them using indices. + """Class for embedding indices into a dense representation. The + Embedding layer is a simple lookup table for dense vectors. It's + typically used to store word embeddings and query them using indices. Parameters ---------- @@ -2366,8 +2318,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -2397,8 +2348,7 @@ def _pad_embd(self, indices, embd): return ivy.where(mask, mask_val, embd) def _forward(self, indices): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2425,9 +2375,8 @@ def _extra_repr(self): class Identity(Module): def __init__(self): - """ - Identity layer. The layer is argument insensitive and returns the input argument - as output when called. + """Identity layer. The layer is argument insensitive and returns the + input argument as output when called. It's typically used as a placeholder when no operation is to be performed. It doesn't have any learnable parameter. @@ -2435,8 +2384,7 @@ def __init__(self): Module.__init__(self) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2465,8 +2413,7 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying IFFT to input. + """Class for applying IFFT to input. Parameters ---------- @@ -2492,8 +2439,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- diff --git a/ivy/stateful/losses.py b/ivy/stateful/losses.py index 1970659dd3be1..77a47b94a0d1e 100644 --- a/ivy/stateful/losses.py +++ b/ivy/stateful/losses.py @@ -21,8 +21,7 @@ def __init__( def _forward( self, true, pred, *, compute_full_loss=None, axis=None, reduction=None ): - """ - Perform forward pass of the Log Poisson Loss. + """Perform forward pass of the Log Poisson Loss. true input array containing true labels. @@ -74,8 +73,7 @@ def __init__( Module.__init__(self) def _forward(self, true, pred, *, axis=None, epsilon=None, reduction=None): - """ - Perform forward pass of the Cross Entropy Loss. + """Perform forward pass of the Cross Entropy Loss. true input array containing true labels. diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index b6f21663635b3..4b42be6b4540e 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -53,9 +53,8 @@ def __init__( device=None, **kwargs, ): - """ - Initialize Ivy layer, which is a stateful object consisting of trainable - variables. + """Initialize Ivy layer, which is a stateful object consisting of + trainable variables. Parameters ---------- @@ -160,8 +159,7 @@ def build( dynamic_backend=None, **kwargs, ): - """ - Build the internal layers and variables for this module. + """Build the internal layers and variables for this module. Parameters ---------- @@ -304,9 +302,8 @@ def trace_graph( kwargs: Optional[Dict] = None, **trace_kwargs, ): - """ - Trace the `ivy.Module`'s `_unified_ivy_graph` or `_call` method to the target - backend. + """Trace the `ivy.Module`'s `_unified_ivy_graph` or `_call` method to + the target backend. Parameters ---------- @@ -339,8 +336,7 @@ def trace_graph( self._lazy_traced = False def register_buffer(self, name, value): - """ - Register a buffer. + """Register a buffer. Parameters ---------- @@ -352,8 +348,7 @@ def register_buffer(self, name, value): self._buffers.update({name: value}) def register_parameter(self, name, value): - """ - Register a parameter. + """Register a parameter. Parameters ---------- @@ -415,8 +410,7 @@ def show_graph( ) def save_weights(self, weights_path, /): - """ - Save the weights on the Module. + """Save the weights on the Module. Parameters ---------- @@ -431,8 +425,7 @@ def save_weights(self, weights_path, /): self.v.cont_to_disk_as_hdf5(weights_path) def save(self, filename): - """ - Save the module object to disk using pickle. + """Save the module object to disk using pickle. Parameters ---------- @@ -448,8 +441,7 @@ def save(self, filename): @staticmethod def load(filename): - """ - Load a module object from disk using pickle. + """Load a module object from disk using pickle. Parameters ---------- @@ -477,8 +469,7 @@ def __call__( buffers=None, **kwargs, ): - """ - Forward an input through current module. + """Forward an input through current module. Parameters ---------- @@ -575,9 +566,8 @@ def __repr__(self): # -----------------------------------# def _create_variables(self, *, device=None, dtype=None): - """ - Create internal trainable variables, and return as arbitrary nested dict. - Overridable. + """Create internal trainable variables, and return as arbitrary nested + dict. Overridable. Parameters ---------- @@ -594,8 +584,8 @@ def _create_variables(self, *, device=None, dtype=None): return {} def _build(self, *args, **kwargs) -> bool: - """ - Build the internal layers and variables for this module. Overridable. + """Build the internal layers and variables for this module. + Overridable. Returns ------- @@ -607,8 +597,8 @@ def _build(self, *args, **kwargs) -> bool: return True def _forward(self, *args, **kwargs): - """ - Forward pass of the layer, called after handling the optional input variables. + """Forward pass of the layer, called after handling the optional input + variables. Raises ------ @@ -617,8 +607,7 @@ def _forward(self, *args, **kwargs): raise ivy.utils.exceptions.IvyNotImplementedException def _extra_repr(self) -> str: - """ - Set the extra representation of the module. + """Set the extra representation of the module. To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line @@ -659,7 +648,8 @@ def buffers(self): @property def state_dict(self): - """Return the state_dict which is a collection of the variables and buffers.""" + """Return the state_dict which is a collection of the variables and + buffers.""" return {**self.v, **self.buffers} @property diff --git a/ivy/stateful/norms.py b/ivy/stateful/norms.py index 9e68fe433651e..5c8e3c44a53b5 100644 --- a/ivy/stateful/norms.py +++ b/ivy/stateful/norms.py @@ -19,8 +19,7 @@ def __init__( v=None, dtype=None, ): - """ - Class for applying Layer Normalization over a mini-batch of inputs. + """Class for applying Layer Normalization over a mini-batch of inputs. Parameters ---------- @@ -68,8 +67,7 @@ def _create_variables(self, device=None, dtype=None): return {} def _forward(self, inputs): - """ - Perform forward pass of the LayerNorm layer. + """Perform forward pass of the LayerNorm layer. Parameters ---------- @@ -113,8 +111,7 @@ def __init__( dtype=None, training=True, ): - """ - Class for applying Layer Normalization over a mini-batch of inputs. + """Class for applying Layer Normalization over a mini-batch of inputs. Parameters ---------- @@ -184,8 +181,7 @@ def _create_variables(self, device=None, dtype=None): return {} def _forward(self, inputs): - """ - Perform forward pass of the BatchNorm layer. + """Perform forward pass of the BatchNorm layer. Parameters ---------- diff --git a/ivy/stateful/optimizers.py b/ivy/stateful/optimizers.py index 9670c4e5aef7a..dafc66d90fbc3 100644 --- a/ivy/stateful/optimizers.py +++ b/ivy/stateful/optimizers.py @@ -24,8 +24,8 @@ def __init__( fallback_to_non_traced: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """ - Construct a general Optimizer. This is an abstract class, and must be derived. + """Construct a general Optimizer. This is an abstract class, and must + be derived. Parameters ---------- @@ -70,9 +70,9 @@ def __init__( @abc.abstractmethod def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v from update step, using nested grads - container. Override this abstract method with child class custom implementation. + """Update nested variables container v from update step, using nested + grads container. Override this abstract method with child class custom + implementation. Parameters ---------- @@ -93,8 +93,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): def _step_fn( self, v: ivy.Container, grads: ivy.Container, ignore_missing: bool = False ): - """ - Call the custom child step function implementation. + """Call the custom child step function implementation. Parameters ---------- @@ -118,8 +117,7 @@ def _step_fn( @abc.abstractmethod def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- @@ -133,8 +131,8 @@ def set_state(self, state: ivy.Container): def step( self, v: ivy.Container, grads: ivy.Container, ignore_missing: bool = False ): - """ - Update nested variables container v from overridden private self._step. + """Update nested variables container v from overridden private + self._step. Parameters ---------- @@ -169,8 +167,7 @@ def __init__( stop_gradients: bool = True, trace_on_next_step: bool = False, ): - """ - Construct a Stochastic-Gradient-Descent (SGD) optimizer. + """Construct a Stochastic-Gradient-Descent (SGD) optimizer. Parameters ---------- @@ -194,9 +191,8 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by gradient descent step, using nested - gradients container. + """Update nested variables container v by gradient descent step, using + nested gradients container. Parameters ---------- @@ -218,8 +214,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): ) def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- @@ -242,8 +237,7 @@ def __init__( stop_gradients: bool = True, trace_on_next_step: bool = False, ): - """ - Construct a Layer-wise Adaptive Rate Scaling (LARS) optimizer. + """Construct a Layer-wise Adaptive Rate Scaling (LARS) optimizer. Parameters ---------- @@ -270,9 +264,8 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by gradient descent step, using nested - gradients container. + """Update nested variables container v by gradient descent step, using + nested gradients container. Parameters ---------- @@ -295,8 +288,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): ) def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- @@ -322,8 +314,7 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """ - Construct an ADAM optimizer. + """Construct an ADAM optimizer. Parameters ---------- @@ -365,9 +356,8 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by Adam update step, using nested grads - container. + """Update nested variables container v by Adam update step, using + nested grads container. Parameters ---------- @@ -401,8 +391,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): return new_v def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- @@ -430,8 +419,7 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """ - Construct an ADAMW optimizer. + """Construct an ADAMW optimizer. Parameters ---------- @@ -473,9 +461,8 @@ def __init__( ) def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by AdamW update step, using nested grads - container. + """Update nested variables container v by AdamW update step, using + nested grads container. Parameters ---------- @@ -510,8 +497,7 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """ - Construct an LAMB optimizer. + """Construct an LAMB optimizer. Parameters ---------- @@ -558,9 +544,8 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by LAMB update step, using nested grads - container. + """Update nested variables container v by LAMB update step, using + nested grads container. Parameters ---------- @@ -596,8 +581,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): return new_v def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- diff --git a/ivy/stateful/sequential.py b/ivy/stateful/sequential.py index 3656b1f3b24af..08bf1a1f56465 100644 --- a/ivy/stateful/sequential.py +++ b/ivy/stateful/sequential.py @@ -16,9 +16,8 @@ def __init__( v: Optional[Union[ivy.Array, ivy.NativeArray]] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ): - """ - Initialize a sequential container. Modules will be added to it in the order they - are passed in the constructor. + """Initialize a sequential container. Modules will be added to it in + the order they are passed in the constructor. Parameters ---------- @@ -49,8 +48,7 @@ def __iter__(self): return iter(self._submodules) def _forward(self, inputs): - """ - Perform forward pass of the Sequential container. + """Perform forward pass of the Sequential container. Parameters ---------- diff --git a/ivy/utils/_importlib.py b/ivy/utils/_importlib.py index 2d6770a42c225..13503024aff14 100644 --- a/ivy/utils/_importlib.py +++ b/ivy/utils/_importlib.py @@ -74,8 +74,7 @@ def _from_import(name: str, package=None, mod_globals=None, from_list=(), level= def _absolute_import(name: str, asname=None, mod_globals=None): - """ - Handle absolute import statement :param name: + """Handle absolute import statement :param name: :return: """ diff --git a/ivy/utils/backend/ast_helpers.py b/ivy/utils/backend/ast_helpers.py index 795dc94e67931..8e5b2b54c6634 100644 --- a/ivy/utils/backend/ast_helpers.py +++ b/ivy/utils/backend/ast_helpers.py @@ -156,8 +156,7 @@ def _create_attrs_from_node(node, attrs=()): def _create_node(stmnt: str): - """ - Create an AST node from a given statement. + """Create an AST node from a given statement. Parameters ---------- diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 2012d8ed9ec03..3c8e373fea56d 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -75,8 +75,7 @@ def _get_backend_for_arg(arg_module_name): def _determine_backend_from_args(args): - """ - Return the appropriate Ivy backend, given some arguments. + """Return the appropriate Ivy backend, given some arguments. Parameters ---------- @@ -121,9 +120,8 @@ def _determine_backend_from_args(args): def set_backend_to_specific_version(backend): - """ - Update the backend dict to make the original function name point to the version - specific one. + """Update the backend dict to make the original function name point to the + version specific one. Parameters ---------- @@ -146,8 +144,8 @@ def set_backend_to_specific_version(backend): def current_backend(*args, **kwargs): - """ - Return the current backend. Priorities: global_backend > argument's backend. + """Return the current backend. Priorities: global_backend > argument's + backend. Parameters ---------- @@ -328,8 +326,7 @@ def _map_fn(x): @prevent_access_locally def set_backend(backend: str, dynamic: bool = False): - """ - Set `backend` to be the global backend. + """Set `backend` to be the global backend. Will also convert all Array and Container objects to the new backend if `dynamic` = True @@ -394,8 +391,7 @@ def set_backend(backend: str, dynamic: bool = False): def set_numpy_backend(): - """ - Set NumPy to be the global backend. + """Set NumPy to be the global backend. equivalent to `ivy.set_backend("numpy")`. """ # noqa @@ -403,8 +399,7 @@ def set_numpy_backend(): def set_jax_backend(): - """ - Set JAX to be the global backend. + """Set JAX to be the global backend. equivalent to `ivy.set_backend("jax")`. """ # noqa @@ -412,8 +407,7 @@ def set_jax_backend(): def set_tensorflow_backend(): - """ - Set TensorFlow to be the global backend. + """Set TensorFlow to be the global backend. equivalent to `ivy.set_backend("tensorflow")`. """ @@ -421,8 +415,7 @@ def set_tensorflow_backend(): def set_torch_backend(): - """ - Set torch to be the global backend. + """Set torch to be the global backend. equivalent to `ivy.set_backend("torch")`. """ # noqa @@ -430,8 +423,7 @@ def set_torch_backend(): def set_paddle_backend(): - """ - Set paddle to be the global backend. + """Set paddle to be the global backend. equivalent to `ivy.set_backend("paddle")`. """ # noqa @@ -439,8 +431,7 @@ def set_paddle_backend(): def set_mxnet_backend(): - """ - Set MXNet to be the global backend. + """Set MXNet to be the global backend. equivalent to `ivy.set_backend("mx")`. """ # noqa @@ -449,10 +440,9 @@ def set_mxnet_backend(): @prevent_access_locally def previous_backend(): - """ - Unset the current global backend, and adjusts the ivy dict such that either a - previously set global backend is then used as the backend, otherwise we return to - Ivy's implementations. + """Unset the current global backend, and adjusts the ivy dict such that + either a previously set global backend is then used as the backend, + otherwise we return to Ivy's implementations. Returns ------- diff --git a/ivy/utils/einsum_parser.py b/ivy/utils/einsum_parser.py index b7b20b89fc22c..697e47d39494b 100644 --- a/ivy/utils/einsum_parser.py +++ b/ivy/utils/einsum_parser.py @@ -12,8 +12,7 @@ def is_valid_einsum_char(x: str) -> bool: - """ - Check if the character ``x`` is valid for numpy einsum. **Examples:** + """Check if the character ``x`` is valid for numpy einsum. **Examples:** ```python is_valid_einsum_char("a") @@ -27,8 +26,7 @@ def is_valid_einsum_char(x: str) -> bool: def has_valid_einsum_chars_only(einsum_str: str) -> bool: # [x] - """ - Check if ``einsum_str`` contains only valid characters for numpy einsum. + """Check if ``einsum_str`` contains only valid characters for numpy einsum. **Examples:** ```python @@ -70,8 +68,7 @@ def get_symbol(i: int) -> str: def gen_unused_symbols(used: str, n: int) -> Iterator[str]: - """ - Generate ``n`` symbols that are not already in ``used``. + """Generate ``n`` symbols that are not already in ``used``. **Examples:** ```python @@ -90,9 +87,9 @@ def gen_unused_symbols(used: str, n: int) -> Iterator[str]: def find_output_str(subscripts: str) -> str: - """ - Find the output string for the inputs ``subscripts`` under canonical einstein - summation rules.That is, repeated indices are summed over by default. + """Find the output string for the inputs ``subscripts`` under canonical + einstein summation rules.That is, repeated indices are summed over by + default. Examples -------- @@ -114,9 +111,8 @@ def find_output_str(subscripts: str) -> str: def find_output_shape( inputs: List[str], shapes: List[TensorShapeType], output: str ) -> TensorShapeType: - """ - Find the output shape for given inputs, shapes and output string, taking into - account broadcasting. + """Find the output shape for given inputs, shapes and output string, taking + into account broadcasting. Examples -------- @@ -138,8 +134,7 @@ def find_output_shape( def possibly_convert_to_numpy(x: Any) -> Any: # possibly convert to native - """ - Convert things without a 'shape' to ndarrays, but leave everything else. + """Convert things without a 'shape' to ndarrays, but leave everything else. Examples -------- @@ -169,8 +164,8 @@ def possibly_convert_to_numpy(x: Any) -> Any: # possibly convert to native def convert_subscripts(old_sub: List[Any], symbol_map: Dict[Any, Any]) -> str: - """ - Convert user custom subscripts list to subscript string according to `symbol_map`. + """Convert user custom subscripts list to subscript string according to + `symbol_map`. Examples -------- @@ -224,9 +219,9 @@ def convert_interleaved_input( def legalise_einsum_expr(*operands: Any) -> str: - """ - Reproduction of einsum c side einsum parsing in python. **Parameters:** Intakes the - same inputs as `contract_path`, but NOT the keyword args. The only. + """Reproduction of einsum c side einsum parsing in python. **Parameters:** + Intakes the same inputs as `contract_path`, but NOT the keyword args. The + only. supported keyword argument is: - **shapes** - *(bool, optional)* Whether diff --git a/ivy/utils/einsum_path_helpers.py b/ivy/utils/einsum_path_helpers.py index 4dfe63aef2dca..a43fd5a1aaddf 100644 --- a/ivy/utils/einsum_path_helpers.py +++ b/ivy/utils/einsum_path_helpers.py @@ -11,8 +11,7 @@ def flop_count(idx_contraction, inner, num_terms, size_dictionary): - """ - Compute the number of FLOPS in the contraction. + """Compute the number of FLOPS in the contraction. Parameters ---------- @@ -47,8 +46,8 @@ def flop_count(idx_contraction, inner, num_terms, size_dictionary): def compute_size_by_dict(indices, idx_dict): - """ - Compute the product of the elements in indices based on the dictionary idx_dict. + """Compute the product of the elements in indices based on the dictionary + idx_dict. Parameters ---------- @@ -74,8 +73,7 @@ def compute_size_by_dict(indices, idx_dict): def find_contraction(positions, input_sets, output_set): - """ - Find the contraction for a given set of input and output sets. + """Find the contraction for a given set of input and output sets. Parameters ---------- @@ -131,10 +129,9 @@ def find_contraction(positions, input_sets, output_set): def optimal_path(input_sets, output_set, idx_dict, memory_limit): - """ - Compute all possible pair contractions, sieves the results based on ``memory_limit`` - and returns the lowest cost path. This algorithm scales factorial with respect to - the elements in the list ``input_sets``. + """Compute all possible pair contractions, sieves the results based on + ``memory_limit`` and returns the lowest cost path. This algorithm scales + factorial with respect to the elements in the list ``input_sets``. Parameters ---------- @@ -204,9 +201,8 @@ def optimal_path(input_sets, output_set, idx_dict, memory_limit): def parse_possible_contraction( positions, input_sets, output_set, idx_dict, memory_limit, path_cost, naive_cost ): - """ - Compute the cost (removed size + flops) and resultant indices for performing the - contraction specified by ``positions``. + """Compute the cost (removed size + flops) and resultant indices for + performing the contraction specified by ``positions``. Parameters ---------- @@ -261,9 +257,9 @@ def parse_possible_contraction( def update_other_results(results, best): - """ - Update the positions and provisional input_sets of ``results`` based on performing - the contraction result ``best``. Remove any involving the tensors contracted. + """Update the positions and provisional input_sets of ``results`` based on + performing the contraction result ``best``. Remove any involving the + tensors contracted. Parameters ---------- @@ -299,12 +295,12 @@ def update_other_results(results, best): def greedy_path(input_sets, output_set, idx_dict, memory_limit): - """ - Find the path by contracting the best pair until the input list is exhausted. The - best pair is found by minimizing the tuple ``(-prod(indices_removed), cost)``. What - this amounts to is prioritizing matrix multiplication or inner product operations, - then Hadamard like operations, and finally outer operations. Outer products are - limited by ``memory_limit``. This algorithm scales cubically with respect to the + """Find the path by contracting the best pair until the input list is + exhausted. The best pair is found by minimizing the tuple + ``(-prod(indices_removed), cost)``. What this amounts to is prioritizing + matrix multiplication or inner product operations, then Hadamard like + operations, and finally outer operations. Outer products are limited by + ``memory_limit``. This algorithm scales cubically with respect to the number of elements in the list ``input_sets``. Parameters @@ -411,8 +407,8 @@ def greedy_path(input_sets, output_set, idx_dict, memory_limit): def can_dot(inputs, result, idx_removed): - """ - Check if we can use BLAS (np.tensordot) call and its beneficial to do so. + """Check if we can use BLAS (np.tensordot) call and its beneficial to do + so. Parameters ---------- @@ -514,8 +510,7 @@ def can_dot(inputs, result, idx_removed): def parse_einsum_input(operands, subscripts=None): - """ - Reproduction of einsum c side einsum parsing in python. + """Reproduction of einsum c side einsum parsing in python. Returns ------- diff --git a/ivy/utils/exceptions.py b/ivy/utils/exceptions.py index 872b12b14cc33..a5395fda37319 100644 --- a/ivy/utils/exceptions.py +++ b/ivy/utils/exceptions.py @@ -141,8 +141,7 @@ def _get_traces(curr_obj, area, local_dict, target_name): def _check_if_path_found(path, full_path): - """ - Check if the path is found in the full path. + """Check if the path is found in the full path. Parameters ---------- @@ -163,8 +162,7 @@ def _check_if_path_found(path, full_path): def _configure_stack_trace(traceback): - """ - Configure the stack trace to be displayed in the console. + """Configure the stack trace to be displayed in the console. Parameters ---------- @@ -204,8 +202,7 @@ def _configure_stack_trace(traceback): def _add_native_error(default): - """ - Append the native error to the message if it exists. + """Append the native error to the message if it exists. Parameters ---------- @@ -338,8 +335,7 @@ def __init__(self, *messages, include_backend=False): def handle_exceptions(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_exceptions(*args, **kwargs): - """ - Catch all exceptions and raise them in IvyException. + """Catch all exceptions and raise them in IvyException. Parameters ---------- diff --git a/ivy/utils/inspection.py b/ivy/utils/inspection.py index 2fa60f6f9d839..77feceb756833 100644 --- a/ivy/utils/inspection.py +++ b/ivy/utils/inspection.py @@ -90,9 +90,8 @@ def _get_array_idxs(typ, idx_so_far=None): def fn_array_spec(fn): - """ - Return a specification of the function, indicating all arguments which include - arrays, and the indexes of these. + """Return a specification of the function, indicating all arguments which + include arrays, and the indexes of these. Parameters ---------- diff --git a/ivy/utils/logging.py b/ivy/utils/logging.py index 498424a976cb4..977f3add6f5ec 100644 --- a/ivy/utils/logging.py +++ b/ivy/utils/logging.py @@ -7,8 +7,7 @@ def set_logging_mode(mode): - """ - Set the current logging mode for Ivy. + """Set the current logging mode for Ivy. Possible modes are 'DEBUG', 'INFO', 'WARNING', 'ERROR'. """ @@ -22,7 +21,8 @@ def set_logging_mode(mode): def unset_logging_mode(): - """Remove the most recently set logging mode, returning to the previous one.""" + """Remove the most recently set logging mode, returning to the previous + one.""" if len(logging_mode_stack) > 1: # Remove the current mode logging_mode_stack.pop() diff --git a/ivy/utils/profiler.py b/ivy/utils/profiler.py index c168b1ce7253e..05b7d016a3a16 100644 --- a/ivy/utils/profiler.py +++ b/ivy/utils/profiler.py @@ -9,8 +9,7 @@ class Profiler(cProfile.Profile): - """ - A Profiler class that allows code profiling. + """A Profiler class that allows code profiling. Attributes ---------- diff --git a/ivy_tests/test_docstrings.py b/ivy_tests/test_docstrings.py index ab26afe70714a..4d4e73421cb20 100644 --- a/ivy_tests/test_docstrings.py +++ b/ivy_tests/test_docstrings.py @@ -51,8 +51,7 @@ def trim(*, docstring): def check_docstring_examples_run( *, fn, from_container=False, from_array=False, num_sig_fig=2 ): - """ - Performs docstring tests for a given function. + """Performs docstring tests for a given function. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/assertions.py b/ivy_tests/test_ivy/helpers/assertions.py index 539d01b0d9243..b2403339f7b5f 100644 --- a/ivy_tests/test_ivy/helpers/assertions.py +++ b/ivy_tests/test_ivy/helpers/assertions.py @@ -18,9 +18,8 @@ def assert_all_close( atol=1e-08, ground_truth_backend="TensorFlow", ): - """ - Match the ret_np and ret_from_gt_np inputs element-by-element to ensure that they - are the same. + """Match the ret_np and ret_from_gt_np inputs element-by-element to ensure + that they are the same. Parameters ---------- @@ -77,9 +76,8 @@ def assert_same_type_and_shape(values, this_key_chain=None): def assert_same_type(ret_from_target, ret_from_gt, backend_to_test, gt_backend): - """ - Assert that the return types from the target and ground truth frameworks are the - same. + """Assert that the return types from the target and ground truth frameworks + are the same. checks with a string comparison because with_backend returns different objects. Doesn't check recursively. @@ -108,8 +106,8 @@ def value_test( backend: str, ground_truth_backend="TensorFlow", ): - """ - Perform a value test for matching the arrays in ret_np_flat and ret_from_np_gt_flat. + """Perform a value test for matching the arrays in ret_np_flat and + ret_from_np_gt_flat. Parameters ---------- @@ -184,9 +182,8 @@ def value_test( def check_unsupported_dtype(*, fn, input_dtypes, all_as_kwargs_np): - """ - Check whether a function does not support the input data types or the output data - type. + """Check whether a function does not support the input data types or the + output data type. Parameters ---------- @@ -229,8 +226,7 @@ def check_unsupported_dtype(*, fn, input_dtypes, all_as_kwargs_np): def check_unsupported_device(*, fn, input_device, all_as_kwargs_np): - """ - Check whether a function does not support a given device. + """Check whether a function does not support a given device. Parameters ---------- @@ -268,8 +264,7 @@ def check_unsupported_device(*, fn, input_device, all_as_kwargs_np): def check_unsupported_device_and_dtype(*, fn, device, input_dtypes, all_as_kwargs_np): - """ - Check whether a function does not support a given device or data types. + """Check whether a function does not support a given device or data types. Parameters ---------- @@ -304,8 +299,7 @@ def check_unsupported_device_and_dtype(*, fn, device, input_dtypes, all_as_kwarg def test_unsupported_function(*, fn, args, kwargs): - """ - Test a function with an unsupported datatype to raise an exception. + """Test a function with an unsupported datatype to raise an exception. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 7f21c0bc413ab..3ae8e2c7d4e80 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -48,9 +48,8 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non def _find_instance_in_args(backend: str, args, array_indices, mask): - """ - Find the first element in the arguments that is considered to be an instance of - Array or Container class. + """Find the first element in the arguments that is considered to be an + instance of Array or Container class. Parameters ---------- @@ -387,9 +386,8 @@ def test_function( return_flat_np_arrays: bool = False, **all_as_kwargs_np, ): - """ - Test a function that consumes (or returns) arrays for the current backend by - comparing the result with numpy. + """Test a function that consumes (or returns) arrays for the current + backend by comparing the result with numpy. Parameters ---------- @@ -727,9 +725,8 @@ def test_frontend_function( test_values: bool = True, **all_as_kwargs_np, ): - """ - Test a frontend function for the current backend by comparing the result with the - function in the associated framework. + """Test a frontend function for the current backend by comparing the result + with the function in the associated framework. Parameters ---------- @@ -1612,9 +1609,8 @@ def test_method( on_device: str, return_flat_np_arrays: bool = False, ): - """ - Test a class-method that consumes (or returns) arrays for the current backend by - comparing the result with numpy. + """Test a class-method that consumes (or returns) arrays for the current + backend by comparing the result with numpy. Parameters ---------- @@ -1921,9 +1917,8 @@ def test_frontend_method( tolerance_dict: Optional[dict] = None, test_values: Union[bool, str] = True, ): - """ - Test a class-method that consumes (or returns) arrays for the current backend by - comparing the result with numpy. + """Test a class-method that consumes (or returns) arrays for the current + backend by comparing the result with numpy. Parameters ---------- @@ -2259,8 +2254,7 @@ def _get_framework_atol(atols: dict, current_fw: str): def _get_nested_np_arrays(nest): - """ - Search for a NumPy arrays in a nest. + """Search for a NumPy arrays in a nest. Parameters ---------- @@ -2290,8 +2284,7 @@ def create_args_kwargs( test_flags: Union[pf.FunctionTestFlags, pf.MethodTestFlags], on_device, ): - """ - Create arguments and keyword-arguments for the function to test. + """Create arguments and keyword-arguments for the function to test. Parameters ---------- @@ -2362,8 +2355,7 @@ def wrap_frontend_function_args(argument): def kwargs_to_args_n_kwargs(*, num_positional_args, kwargs): - """ - Split the kwargs into args and kwargs. + """Split the kwargs into args and kwargs. The first num_positional_args ported to args. """ @@ -2449,8 +2441,7 @@ def flatten_frontend_to_np(*, backend: str, ret): def get_ret_and_flattened_np_array( backend_to_test: str, fn, *args, test_trace=False, precision_mode=False, **kwargs ): - """ - Run func with args and kwargs. + """Run func with args and kwargs. Return the result along with its flattened version. """ diff --git a/ivy_tests/test_ivy/helpers/globals.py b/ivy_tests/test_ivy/helpers/globals.py index b97865b637e38..02d2f16d2b122 100644 --- a/ivy_tests/test_ivy/helpers/globals.py +++ b/ivy_tests/test_ivy/helpers/globals.py @@ -1,6 +1,5 @@ -""" -A state holder for testing, this is only intended to hold and store testing data to be -used by the test helpers to prune unsupported data. +"""A state holder for testing, this is only intended to hold and store testing +data to be used by the test helpers to prune unsupported data. Should not be used inside any of the test functions. """ @@ -59,7 +58,8 @@ class TestData: class InterruptedTest(BaseException): - """Indicate that a test tried to write global attributes while a test is running.""" + """Indicate that a test tried to write global attributes while a test is + running.""" def __init__(self, test_interrupted): super().__init__(f"{test_interrupted} was interrupted during execution.") diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py index 0de8cfe26b10c..a0d522617220d 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py @@ -23,8 +23,7 @@ def array_bools( draw, *, size=st.shared(number_helpers.ints(min_value=1, max_value=4), key="size") ): - """ - Draws a list of booleans with a given size. + """Draws a list of booleans with a given size. Parameters ---------- @@ -74,8 +73,7 @@ def array_bools( def list_of_size(*, x, size): - """ - Return a list of the given length with elements drawn randomly from x. + """Return a list of the given length with elements drawn randomly from x. Parameters ---------- @@ -157,8 +155,7 @@ def lists( max_size=None, size_bounds=None, ): - """ - Draws a list with a random bounded size from the data-set x. + """Draws a list with a random bounded size from the data-set x. Parameters ---------- @@ -313,8 +310,8 @@ def dtype_and_values( array_api_dtypes=False, shape_key="shape", ): - """ - Draws a list of arrays with elements from the given corresponding data types. + """Draws a list of arrays with elements from the given corresponding data + types. Parameters ---------- @@ -577,9 +574,8 @@ def dtype_values_axis( force_tuple_axis=False, ret_shape=False, ): - """ - Draws a list of arrays with elements from the given data type, and a random axis of - the arrays. + """Draws a list of arrays with elements from the given data type, and a + random axis of the arrays. Parameters ---------- @@ -817,10 +813,9 @@ def array_indices_axis( indices_same_dims=False, valid_bounds=True, ): - """ - Generate two arrays x & indices, the values in the indices array are indices of the - array x. Draws an integers randomly from the minimum and maximum number of - positional arguments a given function can take. + """Generate two arrays x & indices, the values in the indices array are + indices of the array x. Draws an integers randomly from the minimum and + maximum number of positional arguments a given function can take. Parameters ---------- @@ -1046,10 +1041,9 @@ def array_indices_put_along_axis( values=None, values_dtypes=get_dtypes("valid"), ): - """ - Generate two arrays x & indices, the values in the indices array are indices of the - array x. Draws an integers randomly from the minimum and maximum number of - positional arguments a given function can take. + """Generate two arrays x & indices, the values in the indices array are + indices of the array x. Draws an integers randomly from the minimum and + maximum number of positional arguments a given function can take. Parameters ---------- @@ -1238,8 +1232,7 @@ def arrays_and_axes( return_dtype=False, force_int_axis=False, ): - """ - Generate a list of arrays and axes. + """Generate a list of arrays and axes. Parameters ---------- @@ -1408,8 +1401,8 @@ def array_values( small_abs_safety_factor=1.1, safety_factor_scale="linear", ): - """ - Draws a list (of lists) of a given shape containing values of a given data type. + """Draws a list (of lists) of a given shape containing values of a given + data type. Parameters ---------- @@ -2175,11 +2168,10 @@ def create_concatenable_arrays_dtypes( dtypes, common_shape=None, ): - """ - Draws a random number of arrays with concatenable or stackable dimensions. Arrays - have same number of dimensions, but their shape can differ along a specified - dimension (concat_dim). If concat_dim is None, arrays have the same shape. Dtypes of - arrays can differ. + """Draws a random number of arrays with concatenable or stackable + dimensions. Arrays have same number of dimensions, but their shape can + differ along a specified dimension (concat_dim). If concat_dim is None, + arrays have the same shape. Dtypes of arrays can differ. Parameters ---------- @@ -2242,10 +2234,9 @@ def create_concatenable_arrays_dtypes( # helpers for tests (core and frontend) related to solve function @st.composite def get_first_solve_batch_matrix(draw, choose_adjoint=False): - """ - Generate non-singular left hand side of equation system possibly with a single batch - dimension at the beginning. Use get_second_solve_batch_matrix to get the right hand - side. + """Generate non-singular left hand side of equation system possibly with a + single batch dimension at the beginning. Use get_second_solve_batch_matrix + to get the right hand side. Parameters ---------- @@ -2302,10 +2293,9 @@ def get_first_solve_batch_matrix(draw, choose_adjoint=False): @st.composite def get_second_solve_batch_matrix(draw, allow_simplified=True, choose_side=False): - """ - Generate right hand side of equation system. Possible with a batch dimension and - possibly with several columns of values. Use get_first_solve_batch_matrix to - generate the left hand side. + """Generate right hand side of equation system. Possible with a batch + dimension and possibly with several columns of values. Use + get_first_solve_batch_matrix to generate the left hand side. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py index 31742e5519501..08838b35ae4e7 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py @@ -113,10 +113,10 @@ def get_dtypes( key=None, prune_function=True, ): - """ - Draws a valid dtypes for the test function. For frontend tests, it draws the data - types from the intersection between backend framework data types and frontend - framework dtypes, otherwise, draws it from backend framework data types. + """Draws a valid dtypes for the test function. For frontend tests, it draws + the data types from the intersection between backend framework data types + and frontend framework dtypes, otherwise, draws it from backend framework + data types. Parameters ---------- @@ -262,8 +262,7 @@ def array_dtypes( shared_dtype=False, array_api_dtypes=False, ): - """ - Draws a list of data types. + """Draws a list of data types. Parameters ---------- @@ -363,8 +362,7 @@ def array_dtypes( @st.composite def get_castable_dtype(draw, available_dtypes, dtype: str, x: Optional[list] = None): - """ - Draws castable dtypes for the given dtype based on the current backend. + """Draws castable dtypes for the given dtype based on the current backend. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 7662f4d2753f5..13369be1461dd 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -14,8 +14,7 @@ def matrix_is_stable(x, cond_limit=30): - """ - Check if a matrix is numerically stable or not. + """Check if a matrix is numerically stable or not. Used to avoid numerical instabilities in further computationally heavy calculations. @@ -62,8 +61,7 @@ def apply_safety_factor( large_abs_safety_factor=1.1, safety_factor_scale="linear", ): - """ - Apply safety factor scaling to numeric data type. + """Apply safety factor scaling to numeric data type. Parameters ---------- @@ -225,8 +223,8 @@ def two_broadcastable_shapes(draw): # https://github.com/data-apis/array-api-tests/array_api_tests/test_manipulation_functions.py @st.composite def reshape_shapes(draw, *, shape): - """ - Draws a random shape with the same number of elements as the given shape. + """Draws a random shape with the same number of elements as the given + shape. Parameters ---------- @@ -254,8 +252,7 @@ def reshape_shapes(draw, *, shape): # taken from https://github.com/HypothesisWorks/hypothesis/issues/1115 @st.composite def subsets(draw, *, elements): - """ - Draws a subset of elements from the given elements. + """Draws a subset of elements from the given elements. Parameters ---------- @@ -282,10 +279,9 @@ def get_shape( min_dim_size=1, max_dim_size=10, ): - """ - Draws a tuple of integers drawn randomly from [min_dim_size, max_dim_size] of size - drawn from min_num_dims to max_num_dims. Useful for randomly drawing the shape of an - array. + """Draws a tuple of integers drawn randomly from [min_dim_size, + max_dim_size] of size drawn from min_num_dims to max_num_dims. Useful for + randomly drawing the shape of an array. Parameters ---------- @@ -331,9 +327,8 @@ def get_shape( @st.composite def get_mean_std(draw, *, dtype): - """ - Draws two integers representing the mean and standard deviation for a given data - type. + """Draws two integers representing the mean and standard deviation for a + given data type. Parameters ---------- @@ -355,8 +350,8 @@ def get_mean_std(draw, *, dtype): @st.composite def get_bounds(draw, *, dtype): - """ - Draws two numbers; low and high, for a given data type such that low < high. + """Draws two numbers; low and high, for a given data type such that low < + high. Parameters ---------- @@ -402,8 +397,7 @@ def get_axis( force_tuple=False, force_int=False, ): - """ - Draws one or more axis for the given shape. + """Draws one or more axis for the given shape. Parameters ---------- @@ -517,8 +511,7 @@ def x_and_filters( depthwise=False, mixed_fn_compos=True, ): - """ - Draws a random x and filters for a convolution. + """Draws a random x and filters for a convolution. Parameters ---------- @@ -614,8 +607,8 @@ def x_and_filters( @st.composite def embedding_helper(draw, mixed_fn_compos=True): - """ - Obtain weights for embeddings, the corresponding indices, the padding indices. + """Obtain weights for embeddings, the corresponding indices, the padding + indices. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py index 55e07e3dd7442..71832e0cc3ff9 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py @@ -31,9 +31,8 @@ def floats( safety_factor_scale="linear", mixed_fn_compos=True, ): - """ - Draws an arbitrarily sized list of floats with a safety factor applied to avoid - values being generated at the edge of a dtype limit. + """Draws an arbitrarily sized list of floats with a safety factor applied + to avoid values being generated at the edge of a dtype limit. Parameters ---------- @@ -156,8 +155,7 @@ def ints( safety_factor_scale=None, mixed_fn_compos=True, ): - """ - Draws an integer with a safety factor if specified. + """Draws an integer with a safety factor if specified. Parameters ---------- @@ -221,8 +219,7 @@ def number( safety_factor_scale="linear", mixed_fn_compos=True, ): - """ - Draws integers or floats with a safety factor applied to values. + """Draws integers or floats with a safety factor applied to values. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index 4d20d861e1f17..865be68e7eac7 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -59,9 +59,8 @@ def _get_runtime_flag_value(flag): @st.composite def num_positional_args_method(draw, *, method): - """ - Draws an integers randomly from the minimum and maximum number of positional - arguments a given method can take. + """Draws an integers randomly from the minimum and maximum number of + positional arguments a given method can take. Parameters ---------- @@ -91,9 +90,8 @@ def num_positional_args_method(draw, *, method): @st.composite def num_positional_args(draw, *, fn_name: Optional[str] = None): - """ - Draws an integers randomly from the minimum and maximum number of positional - arguments a given function can take. + """Draws an integers randomly from the minimum and maximum number of + positional arguments a given function can take. Parameters ---------- @@ -158,8 +156,7 @@ def num_positional_args_helper(fn_name, backend): def _import_fn(fn_tree: str): - """ - Import a function from function tree string. + """Import a function from function tree string. Parameters ---------- @@ -209,8 +206,7 @@ def _get_method_supported_devices_dtypes_helper( def _get_method_supported_devices_dtypes( method_name: str, class_module: str, class_name: str ): - """ - Get supported devices and data types for a method in Ivy API. + """Get supported devices and data types for a method in Ivy API. Parameters ---------- @@ -278,8 +274,7 @@ def _get_supported_devices_dtypes_helper( def _get_supported_devices_dtypes(fn_name: str, fn_module: str): - """ - Get supported devices and data types for a function in Ivy API. + """Get supported devices and data types for a function in Ivy API. Parameters ---------- @@ -346,8 +341,7 @@ def handle_test( container_flags=BuiltContainerStrategy, **_given_kwargs, ): - """ - Test wrapper for Ivy functions. + """Test wrapper for Ivy functions. The wrapper sets the required test globals and creates test flags strategies. @@ -489,8 +483,7 @@ def handle_frontend_test( precision_mode=BuiltPrecisionModeStrategy, **_given_kwargs, ): - """ - Test wrapper for Ivy frontend functions. + """Test wrapper for Ivy frontend functions. The wrapper sets the required test globals and creates test flags strategies. @@ -640,8 +633,7 @@ def handle_method( method_container_flags=BuiltContainerStrategy, **_given_kwargs, ): - """ - Test wrapper for Ivy methods. + """Test wrapper for Ivy methods. The wrapper sets the required test globals and creates test flags strategies. @@ -759,8 +751,7 @@ def handle_frontend_method( generate_frontend_arrays=BuiltFrontendArrayStrategy, **_given_kwargs, ): - """ - Test wrapper for Ivy frontends methods. + """Test wrapper for Ivy frontends methods. The wrapper sets the required test globals and creates test flags strategies. diff --git a/ivy_tests/test_ivy/test_frontends/__init__.py b/ivy_tests/test_ivy/test_frontends/__init__.py index ebabc54c49ebc..e58ceb7d6761a 100644 --- a/ivy_tests/test_ivy/test_frontends/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/__init__.py @@ -1,6 +1,6 @@ class NativeClass: - """ - An empty class to represent a class that only exist in a specific framework. + """An empty class to represent a class that only exist in a specific + framework. Attributes ---------- @@ -9,8 +9,7 @@ class NativeClass: """ def __init__(self, native_class): - """ - Construct the native class object. + """Construct the native class object. Parameters ---------- diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py index 0924ab4d14c21..c027097165f2e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py @@ -268,8 +268,8 @@ def test_jax_eig( ): dtype, x = dtype_and_x x = np.array(x[0], dtype=dtype[0]) - """Make symmetric positive-definite since ivy does not support complex data dtypes - currently.""" + """Make symmetric positive-definite since ivy does not support complex data + dtypes currently.""" x = np.matmul(x.T, x) + np.identity(x.shape[0]) * 1e-3 ret, frontend_ret = helpers.test_frontend_function( diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py b/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py index 57785e80fa6bb..6ede0631199e7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py @@ -6,7 +6,8 @@ def convnumpy(argument): - """Convert NativeClass in argument to ivy frontend counterpart for numpy.""" + """Convert NativeClass in argument to ivy frontend counterpart for + numpy.""" if isinstance(argument, NativeClass): return numpy_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py index 878ed7e54c44d..d7287dc70ec57 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py @@ -27,8 +27,8 @@ def _array_and_axes_permute_helper( max_dim_size, allow_none=False, ): - """ - Return array, its dtype and either the random permutation of its axes or None. + """Return array, its dtype and either the random permutation of its axes or + None. Parameters ---------- @@ -276,9 +276,8 @@ def dtypes_values_casting_dtype( # ufunc num_positional_args helper @st.composite def get_num_positional_args_ufunc(draw, *, fn_name=None): - """ - Draws data randomly from numbers between nin and nargs where nin and nargs are - properties of the given ufunc. + """Draws data randomly from numbers between nin and nargs where nin and + nargs are properties of the given ufunc. Parameters ---------- diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py index d4015efc19a21..498c71af9b446 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py @@ -41,8 +41,8 @@ def test_numpy_eig( ): dtype, x = dtype_and_x x = np.array(x[0], dtype=dtype[0]) - """Make symmetric positive-definite since ivy does not support complex data dtypes - currently.""" + """Make symmetric positive-definite since ivy does not support complex data + dtypes currently.""" x = np.matmul(x.T, x) + np.identity(x.shape[0]) * 1e-3 ret, frontend_ret = helpers.test_frontend_function( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py b/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py index a2500afb3e86a..5b086cc0e5096 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py @@ -6,7 +6,8 @@ def convpaddle(argument): - """Convert NativeClass in argument to ivy frontend counter part for paddle.""" + """Convert NativeClass in argument to ivy frontend counter part for + paddle.""" if isinstance(argument, NativeClass): return paddle_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py b/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py index 3b53dda915477..85480fbc9a089 100644 --- a/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py @@ -5,7 +5,8 @@ def convscipy(argument): - """Convert NativeClass in argument to ivy frontend counterpart for scipy.""" + """Convert NativeClass in argument to ivy frontend counterpart for + scipy.""" if isinstance(argument, NativeClass): return scipy_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py index 58227bfafc4e0..2b7118d75a902 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py @@ -6,7 +6,8 @@ def convtensor(argument): - """Convert NativeClass in argument to ivy frontend counterpart for tensorflow.""" + """Convert NativeClass in argument to ivy frontend counterpart for + tensorflow.""" if isinstance(argument, NativeClass): return tensorflow_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index ba95184397d4f..44be3315bf271 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -121,8 +121,9 @@ def _get_shared_dtype(draw): @st.composite def _get_splits(draw, as_list=False): - """Generate valid splits, either by generating an integer that evenly divides the - axis or a list of splits that sum to the length of the axis being split.""" + """Generate valid splits, either by generating an integer that evenly + divides the axis or a list of splits that sum to the length of the axis + being split.""" shape = draw(st.shared(helpers.get_shape(min_num_dims=1), key="value_shape")) axis = draw( st.shared(helpers.get_axis(shape=shape, force_int=True), key="target_axis") diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py b/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py index aac6f175aa7c1..3187545f1376e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py @@ -6,7 +6,8 @@ def convtorch(argument): - """Convert NativeClass in argument to ivy frontend counterpart for torch.""" + """Convert NativeClass in argument to ivy frontend counterpart for + torch.""" if isinstance(argument, NativeClass): return torch_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 40e88dbcda2cc..4923c2051c28b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -541,7 +541,8 @@ def test_torch_eigvals( test_values=False, ) """In "ret" we have out eigenvalues calculated with our backend and in - "frontend_ret" are our eigenvalues calculated with the specified frontend.""" + "frontend_ret" are our eigenvalues calculated with the specified + frontend.""" """ Depending on the chosen framework there may be small differences between our diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py index e76b88adddc49..6745c947a6d5e 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py @@ -152,8 +152,9 @@ def _get_splits( allow_array_indices=True, is_mod_split=False, ): - """Generate valid splits, either by generating an integer that evenly divides the - axis or a list of splits that sum to the length of the axis being split.""" + """Generate valid splits, either by generating an integer that evenly + divides the axis or a list of splits that sum to the length of the axis + being split.""" shape = draw( st.shared(helpers.get_shape(min_num_dims=min_num_dims), key="value_shape") ) diff --git a/ivy_tests/test_ivy/test_misc/test_array.py b/ivy_tests/test_ivy/test_misc/test_array.py index 1c334ef0ebb92..c961c59d59f0b 100644 --- a/ivy_tests/test_ivy/test_misc/test_array.py +++ b/ivy_tests/test_ivy/test_misc/test_array.py @@ -2257,7 +2257,8 @@ def __ivy_array_function__(self, func, types, args, kwargs): return HANDLED_FUNCTIONS[func](*args, **kwargs) def implements(ivy_function): - """Register an __ivy_array_function__ implementation for MyArray objects.""" + """Register an __ivy_array_function__ implementation for MyArray + objects.""" def decorator(func): HANDLED_FUNCTIONS[ivy_function] = func diff --git a/scripts/eager_mode_benchmark/benchmark.py b/scripts/eager_mode_benchmark/benchmark.py index ba568a18de238..77b839bc3f647 100644 --- a/scripts/eager_mode_benchmark/benchmark.py +++ b/scripts/eager_mode_benchmark/benchmark.py @@ -104,9 +104,8 @@ def eager_benchmark( kwargs: Optional[Dict[str, Any]] = None, output_path="./report.csv", ): - """ - Benchmark the function or module passed in input on the required backends and - devices. + """Benchmark the function or module passed in input on the required + backends and devices. Parameters ---------- @@ -280,8 +279,7 @@ def visualize_speed_up( backends: Union[List[str], str] = "all", labels: Optional[Union[List[str], str]] = None, ): - """ - Visualize the speed up results stored in the csv. + """Visualize the speed up results stored in the csv. Parameters ---------- From e93c3cb402d77f7f32aae8c808f7eb4c5feb769f Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sat, 9 Dec 2023 16:50:41 +0400 Subject: [PATCH 328/978] Add distutils --- pyproject.toml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index f41dc8bb153c2..a6a62211cc662 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -2,6 +2,7 @@ requires = [ "setuptools>=42", "wheel", - "pip" + "pip", + "distutils" ] build-backend = "setuptools.build_meta" From dd663c040f3e40d64c005cce875763a3a6398f2e Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sat, 9 Dec 2023 16:53:56 +0400 Subject: [PATCH 329/978] Revert add distutils --- pyproject.toml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index a6a62211cc662..f41dc8bb153c2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -2,7 +2,6 @@ requires = [ "setuptools>=42", "wheel", - "pip", - "distutils" + "pip" ] build-backend = "setuptools.build_meta" From cf75d73358ab8422af410eb4466799dfee7d0246 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sat, 9 Dec 2023 19:16:46 +0400 Subject: [PATCH 330/978] sudo for installing ivy --- .github/workflows/intelligent-tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/intelligent-tests.yml b/.github/workflows/intelligent-tests.yml index 261cd5fd1014f..d4e2ec5de132a 100644 --- a/.github/workflows/intelligent-tests.yml +++ b/.github/workflows/intelligent-tests.yml @@ -54,7 +54,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem From 9898297a159b9e59679eafac754999cffead3cdb Mon Sep 17 00:00:00 2001 From: Alvin Vinod <63870684+alvin-98@users.noreply.github.com> Date: Sat, 9 Dec 2023 21:02:54 +0530 Subject: [PATCH 331/978] feat: add Numpy take function and its test (#27462) --- .../indexing_like_operations.py | 6 +++ .../test_indexing_like_operations.py | 39 +++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/ivy/functional/frontends/numpy/indexing_routines/indexing_like_operations.py b/ivy/functional/frontends/numpy/indexing_routines/indexing_like_operations.py index 4d56c0f208c1d..3cae814a951a3 100644 --- a/ivy/functional/frontends/numpy/indexing_routines/indexing_like_operations.py +++ b/ivy/functional/frontends/numpy/indexing_routines/indexing_like_operations.py @@ -98,3 +98,9 @@ def tril_indices(n, k=0, m=None): def unravel_index(indices, shape, order="C"): ret = [x.astype("int64") for x in ivy.unravel_index(indices, shape)] return tuple(ret) + + +@to_ivy_arrays_and_back +@handle_numpy_out +def take(a, indices, /, *, axis=None, out=None, mode="raise"): + return ivy.take(a, indices, axis=axis, out=out, mode=mode) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_indexing_like_operations.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_indexing_like_operations.py index 8a03463674b6e..342b705f03a0f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_indexing_like_operations.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_indexing_like_operations.py @@ -184,3 +184,42 @@ def test_numpy_take_along_axis( indices=indices, axis=axis, ) + + +@handle_frontend_test( + fn_tree="numpy.take", + dtype_x_indices_axis=helpers.array_indices_axis( + array_dtypes=helpers.get_dtypes("valid"), + indices_dtypes=["int32", "int64"], + min_num_dims=1, + max_num_dims=3, + min_dim_size=1, + max_dim_size=5, + indices_same_dims=True, + valid_bounds=False, + ), + mode=st.sampled_from(["clip", "wrap"]), +) +def test_numpy_take( + *, + dtype_x_indices_axis, + mode, + test_flags, + frontend, + backend_fw, + fn_tree, + on_device, +): + dtypes, x, indices, axis, _ = dtype_x_indices_axis + helpers.test_frontend_function( + input_dtypes=dtypes, + backend_to_test=backend_fw, + test_flags=test_flags, + frontend=frontend, + fn_tree=fn_tree, + on_device=on_device, + a=x, + indices=indices, + axis=axis, + mode=mode, + ) From 329d16cdfd509ea9cfd47e3538e6aaecf367c0b9 Mon Sep 17 00:00:00 2001 From: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> Date: Sat, 9 Dec 2023 21:40:04 +0530 Subject: [PATCH 332/978] Fixed linter issues (#27454) --- .pre-commit-config.yaml | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c4b505a64e319..45178cdf6c7a0 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -13,6 +13,12 @@ repos: language_version: python3 args: - "--preview" + exclude: > + (?x) + ( + ivy/functional/frontends/(?!.*(?:config\.py|__init__\.py)$).* | + ivy_tests/test_ivy/(?!.*(?:__init__\.py|conftest\.py|helpers/.*|test_frontends/config/.*$)).* + ) - repo: https://github.com/PyCQA/autoflake rev: v2.2.1 hooks: @@ -32,7 +38,7 @@ repos: - id: pydocstyle # Exclude everything in frontends except __init__.py, and func_wrapper.py exclude: 'ivy/functional/(frontends|backends)/(?!.*/func_wrapper\.py$).*(?!__init__\.py$)' -# - repo: https://github.com/unifyai/lint-hook -# rev: 2ea80bc854c7f74b09620151028579083ff92ec2 -# hooks: -# - id: ivy-lint + - repo: https://github.com/unifyai/lint-hook + rev: a72ffb17562d919311653d7f593cb537d1245c19 + hooks: + - id: ivy-lint From e14032df16fff75053695412560b8c7717f6f4f6 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 9 Dec 2023 16:11:48 +0000 Subject: [PATCH 333/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../numpy/fft/discrete_fourier_transform.py | 16 +- .../indexing_like_operations.py | 12 +- .../frontends/numpy/ma/MaskedArray.py | 13 +- .../arithmetic_operations.py | 10 +- .../statistics/averages_and_variances.py | 4 +- .../frontends/numpy/ufunc/methods.py | 24 +- .../frontends/paddle/nn/functional/pooling.py | 3 +- .../frontends/paddle/nn/functional/vision.py | 30 +- .../sklearn/model_selection/_split.py | 18 +- .../frontends/sklearn/tree/_criterion.py | 38 +- .../frontends/sklearn/tree/_tree.py | 27 +- .../frontends/tensorflow/keras/metrics.py | 13 +- ivy/functional/frontends/tensorflow/linalg.py | 12 +- ivy/functional/frontends/tensorflow/nn.py | 6 +- .../frontends/tensorflow/raw_ops.py | 8 +- .../frontends/torch/comparison_ops.py | 2 +- .../frontends/torch/miscellaneous_ops.py | 6 +- .../torch/nn/functional/distance_functions.py | 12 +- .../torch/nn/functional/loss_functions.py | 10 +- .../torch/nn/functional/vision_functions.py | 10 +- .../frontends/torch/nn/modules/module.py | 27 +- ivy/functional/frontends/xgboost/core.py | 12 +- ivy/functional/frontends/xgboost/gbm/gbm.py | 10 +- .../test_jax/test__src/test_tree_util.py | 18 +- .../test_jax/test_lax/test_operators.py | 32 +- .../test_jax/test_numpy/test_indexing.py | 6 +- .../test_jax/test_numpy/test_linalg.py | 6 +- .../test_jax/test_numpy/test_manipulations.py | 52 +- .../test_jax/test_numpy/test_statistical.py | 24 +- .../test_function/test_mindspore_nn_func.py | 20 +- .../test_numpy/test_func_wrapper.py | 28 +- .../test_indexing_like_operations.py | 34 +- .../test_matrix_and_vector_products.py | 24 +- ...olving_equations_and_inverting_matrices.py | 6 +- .../test_padding_arrays.py | 26 +- .../test_numpy/test_ndarray/test_ndarray.py | 14 +- .../test_nn/test_functional/test_common.py | 30 +- .../test_paddle/test_tensor/test_tensor.py | 138 +- .../test_tensorflow/test_func_wrapper.py | 32 +- .../test_tensorflow/test_general_functions.py | 52 +- .../test_tensorflow/test_linalg.py | 12 +- .../test_functional/test_vision_functions.py | 14 +- .../test_core/test_creation.py | 14 +- .../test_functional/test_core/test_general.py | 54 +- .../test_functional/test_core/test_meta.py | 382 +++-- .../test_core/test_gradients.py | 24 +- .../test_core/test_manipulation.py | 28 +- .../test_experimental/test_nn/test_layers.py | 30 +- ivy_tests/test_ivy/test_misc/test_array.py | 6 +- .../test_backend_handler.py | 10 +- .../test_ivy/test_misc/test_container.py | 1431 +++++++++-------- .../test_tucker_tensor.py | 6 +- .../test_misc/test_handle_exceptions.py | 20 +- .../test_ivy/test_stateful/test_layers.py | 92 +- .../test_ivy/test_stateful/test_modules.py | 50 +- 55 files changed, 1684 insertions(+), 1354 deletions(-) diff --git a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py index 796f1521b0aa0..bbf898a2c02d7 100644 --- a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py +++ b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py @@ -3,6 +3,14 @@ from ivy.func_wrapper import with_unsupported_dtypes +_SWAP_DIRECTION_MAP = { + None: "forward", + "backward": "forward", + "ortho": "ortho", + "forward": "backward", +} + + # --- Helpers --- # # --------------- # @@ -148,11 +156,3 @@ def rfftfreq(n, d=1.0): def rfftn(a, s=None, axes=None, norm=None): a = ivy.asarray(a, dtype=ivy.complex128) return ivy.rfftn(a, s=s, axes=axes, norm=norm) - - -_SWAP_DIRECTION_MAP = { - None: "forward", - "backward": "forward", - "ortho": "ortho", - "forward": "backward", -} diff --git a/ivy/functional/frontends/numpy/indexing_routines/indexing_like_operations.py b/ivy/functional/frontends/numpy/indexing_routines/indexing_like_operations.py index 3cae814a951a3..f5d7414b09c46 100644 --- a/ivy/functional/frontends/numpy/indexing_routines/indexing_like_operations.py +++ b/ivy/functional/frontends/numpy/indexing_routines/indexing_like_operations.py @@ -83,6 +83,12 @@ def put_along_axis(arr, indices, values, axis): ivy.put_along_axis(arr, indices, values, axis) +@to_ivy_arrays_and_back +@handle_numpy_out +def take(a, indices, /, *, axis=None, out=None, mode="raise"): + return ivy.take(a, indices, axis=axis, out=out, mode=mode) + + @to_ivy_arrays_and_back def take_along_axis(arr, indices, axis): return ivy.take_along_axis(arr, indices, axis) @@ -98,9 +104,3 @@ def tril_indices(n, k=0, m=None): def unravel_index(indices, shape, order="C"): ret = [x.astype("int64") for x in ivy.unravel_index(indices, shape)] return tuple(ret) - - -@to_ivy_arrays_and_back -@handle_numpy_out -def take(a, indices, /, *, axis=None, out=None, mode="raise"): - return ivy.take(a, indices, axis=axis, out=out, mode=mode) diff --git a/ivy/functional/frontends/numpy/ma/MaskedArray.py b/ivy/functional/frontends/numpy/ma/MaskedArray.py index 2eaf48cae2916..a97a447608cda 100644 --- a/ivy/functional/frontends/numpy/ma/MaskedArray.py +++ b/ivy/functional/frontends/numpy/ma/MaskedArray.py @@ -2,6 +2,8 @@ import ivy.functional.frontends.numpy as np_frontend import numpy as np + +masked = True masked_print_options = "--" nomask = False @@ -177,10 +179,12 @@ def _array_in_str(self): return masked_print_options return str(self._data.to_list()) if ivy.any(self._mask): - return str([ - masked_print_options if mask else x - for x, mask in zip(self._data.to_list(), self._mask.to_list()) - ]) + return str( + [ + masked_print_options if mask else x + for x, mask in zip(self._data.to_list(), self._mask.to_list()) + ] + ) return str(self._data.to_list()) @@ -192,7 +196,6 @@ def _is_masked_array(x): return isinstance(x, (np.ma.MaskedArray, np_frontend.ma.MaskedArray)) -masked = True # Instance Methods # # ---------------- # diff --git a/ivy/functional/frontends/numpy/mathematical_functions/arithmetic_operations.py b/ivy/functional/frontends/numpy/mathematical_functions/arithmetic_operations.py index 759e76272ca9a..ffe7dde3e21e2 100644 --- a/ivy/functional/frontends/numpy/mathematical_functions/arithmetic_operations.py +++ b/ivy/functional/frontends/numpy/mathematical_functions/arithmetic_operations.py @@ -91,10 +91,12 @@ def _divmod( ret = ivy.where( where, ret, - ([ - ivy.default(out, ivy.zeros_like(ret[0])), - ivy.default(out, ivy.zeros_like(ret[1])), - ]), + ( + [ + ivy.default(out, ivy.zeros_like(ret[0])), + ivy.default(out, ivy.zeros_like(ret[1])), + ] + ), out=out, ) return ret diff --git a/ivy/functional/frontends/numpy/statistics/averages_and_variances.py b/ivy/functional/frontends/numpy/statistics/averages_and_variances.py index f22f4756a95c8..3cfd82ed68ced 100644 --- a/ivy/functional/frontends/numpy/statistics/averages_and_variances.py +++ b/ivy/functional/frontends/numpy/statistics/averages_and_variances.py @@ -200,7 +200,9 @@ def var(x, /, *, axis=None, ddof=0.0, keepdims=False, out=None, dtype=None, wher dtype = ( dtype if dtype is not None - else ivy.float64 if ivy.is_int_dtype(x.dtype) else x.dtype + else ivy.float64 + if ivy.is_int_dtype(x.dtype) + else x.dtype ) ret = ivy.var(x, axis=axis, correction=ddof, keepdims=keepdims, out=out) ret = ( diff --git a/ivy/functional/frontends/numpy/ufunc/methods.py b/ivy/functional/frontends/numpy/ufunc/methods.py index 0a4a9c5bfb5c1..5d35a7a8a2448 100644 --- a/ivy/functional/frontends/numpy/ufunc/methods.py +++ b/ivy/functional/frontends/numpy/ufunc/methods.py @@ -214,20 +214,24 @@ def __init__(self, name) -> None: @property def nargs(self): sig = inspect.signature(self.func) - return len([ - param - for param in sig.parameters.values() - if param.kind in [param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD] - ]) + return len( + [ + param + for param in sig.parameters.values() + if param.kind in [param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD] + ] + ) @property def nin(self): sig = inspect.signature(self.func) - return len([ - param - for param in sig.parameters.values() - if param.kind == param.POSITIONAL_ONLY - ]) + return len( + [ + param + for param in sig.parameters.values() + if param.kind == param.POSITIONAL_ONLY + ] + ) @property def nout(self): diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index 910946dfbaf6e..ddb7dc569d8d6 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -118,8 +118,7 @@ def max_pool2d( if data_format not in ["NCHW", "NHWC"]: raise ValueError( "Attr(data_format) should be 'NCHW' or 'NHWC'. Received " - "Attr(data_format): %s." - % str(data_format) + "Attr(data_format): %s." % str(data_format) ) if data_format == "NHWC" and return_mask: diff --git a/ivy/functional/frontends/paddle/nn/functional/vision.py b/ivy/functional/frontends/paddle/nn/functional/vision.py index 935ce239a7dbb..73fcae0c89e1b 100644 --- a/ivy/functional/frontends/paddle/nn/functional/vision.py +++ b/ivy/functional/frontends/paddle/nn/functional/vision.py @@ -18,9 +18,9 @@ def affine_grid(theta, out_shape, align_corners=True): base_grid[:, :, :, 0] = ivy.linspace(-1, 1, W) base_grid[:, :, :, 1] = ivy.expand_dims(ivy.linspace(-1, 1, H), axis=-1) height_values = ivy.expand_dims(ivy.linspace(-1, 1, H), axis=-1) - base_grid[:, :, :, 1] = ivy.array([ - [[height_values[i]] * W for i in range(H)] - ])[:, :, :, 0] + base_grid[:, :, :, 1] = ivy.array( + [[[height_values[i]] * W for i in range(H)]] + )[:, :, :, 0] base_grid[:, :, :, 2] = ivy.full((H, W), 1) grid = ivy.matmul(base_grid.view((N, H * W, 3)), theta.swapaxes(1, 2)) return grid.view((N, H, W, 2)) @@ -32,9 +32,9 @@ def affine_grid(theta, out_shape, align_corners=True): height_values = ivy.expand_dims( ivy.linspace(-1, 1, H) * (H - 1) / H, axis=-1 ) - base_grid[:, :, :, 1] = ivy.array([ - [[height_values[i]] * W for i in range(H)] - ])[:, :, :, 0] + base_grid[:, :, :, 1] = ivy.array( + [[[height_values[i]] * W for i in range(H)]] + )[:, :, :, 0] base_grid[:, :, :, 2] = ivy.full((H, W), 1) grid = ivy.matmul(base_grid.view((N, H * W, 3)), ivy.swapaxes(theta, 1, 2)) return grid.view((N, H, W, 2)) @@ -45,9 +45,9 @@ def affine_grid(theta, out_shape, align_corners=True): base_grid[:, :, :, :, 0] = ivy.linspace(-1, 1, W) base_grid[:, :, :, :, 1] = ivy.expand_dims(ivy.linspace(-1, 1, H), axis=-1) height_values = ivy.linspace(-1, 1, H) - base_grid[:, :, :, :, 1] = ivy.array([ - [[[height_values[i]] * W for i in range(H)]] * D - ]) + base_grid[:, :, :, :, 1] = ivy.array( + [[[[height_values[i]] * W for i in range(H)]] * D] + ) base_grid[:, :, :, :, 2] = ivy.expand_dims( ivy.expand_dims(ivy.linspace(-1, 1, D), axis=-1), axis=-1 ) @@ -58,17 +58,17 @@ def affine_grid(theta, out_shape, align_corners=True): ivy.linspace(-1, 1, H) * (H - 1) / H, axis=-1 ) height_values = ivy.linspace(-1, 1, H) * (H - 1) / H - base_grid[:, :, :, :, 1] = ivy.array([ - [[[height_values[i]] * W for i in range(H)]] * D - ]) + base_grid[:, :, :, :, 1] = ivy.array( + [[[[height_values[i]] * W for i in range(H)]] * D] + ) base_grid[:, :, :, :, 2] = ivy.expand_dims( ivy.expand_dims(ivy.linspace(-1, 1, D) * (D - 1) / D, axis=-1), axis=-1 ) width_values = ivy.linspace(-1, 1, D) * (D - 1) / D - base_grid[:, :, :, :, 2] = ivy.array([ - [ivy.array([[width_values[i]] * W] * H) for i in range(D)] - ]) + base_grid[:, :, :, :, 2] = ivy.array( + [[ivy.array([[width_values[i]] * W] * H) for i in range(D)]] + ) base_grid[:, :, :, :, 3] = ivy.full((D, H, W), 1) grid = ivy.matmul(base_grid.view((N, D * H * W, 4)), theta.swapaxes(1, 2)) return grid.view((N, D, H, W, 3)) diff --git a/ivy/functional/frontends/sklearn/model_selection/_split.py b/ivy/functional/frontends/sklearn/model_selection/_split.py index 406ae7c7d22a2..ec6dc3d067f1e 100644 --- a/ivy/functional/frontends/sklearn/model_selection/_split.py +++ b/ivy/functional/frontends/sklearn/model_selection/_split.py @@ -83,10 +83,12 @@ def _iter_test_indices(self, X=None, y=None, groups=None): n_classes = len(y_idx) y_order = ivy.sort(y_encoded) - allocation = ivy.asarray([ - ivy.bincount(y_order[i :: self.n_splits], minlength=n_classes) - for i in range(self.n_splits) - ]) + allocation = ivy.asarray( + [ + ivy.bincount(y_order[i :: self.n_splits], minlength=n_classes) + for i in range(self.n_splits) + ] + ) test_folds = ivy.empty(len(y), dtype="int64") for k in range(n_classes): folds_for_class = ivy.arange(self.n_splits).repeat(allocation[:, k]) @@ -121,12 +123,16 @@ def train_test_split( n_train = ( ivy.floor(train_size * n_samples) if isinstance(train_size, float) - else float(train_size) if isinstance(train_size, int) else None + else float(train_size) + if isinstance(train_size, int) + else None ) n_test = ( ivy.ceil(test_size * n_samples) if isinstance(test_size, float) - else float(test_size) if isinstance(test_size, int) else None + else float(test_size) + if isinstance(test_size, int) + else None ) if train_size is None: n_train = n_samples - n_test diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index 2213df22946cf..092552ceeac3b 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -107,27 +107,33 @@ def init( def reset(self): self.pos = self.start - self.weighted_n_left, self.weighted_n_right, self.sum_left, self.sum_right = ( - _move_sums_classification( - self, - self.sum_left, - self.sum_right, - self.weighted_n_left, - self.weighted_n_right, - ) + ( + self.weighted_n_left, + self.weighted_n_right, + self.sum_left, + self.sum_right, + ) = _move_sums_classification( + self, + self.sum_left, + self.sum_right, + self.weighted_n_left, + self.weighted_n_right, ) return 0 def reverse_reset(self): self.pos = self.end - self.weighted_n_right, self.weighted_n_left, self.sum_right, self.sum_left = ( - _move_sums_classification( - self, - self.sum_right, - self.sum_left, - self.weighted_n_right, - self.weighted_n_left, - ) + ( + self.weighted_n_right, + self.weighted_n_left, + self.sum_right, + self.sum_left, + ) = _move_sums_classification( + self, + self.sum_right, + self.sum_left, + self.weighted_n_right, + self.weighted_n_left, ) return 0 diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index 4e8bf6622c75e..16dbf9cc6da74 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -4,10 +4,10 @@ EPSILON = ivy.finfo(ivy.double).eps INFINITY = ivy.inf INTPTR_MAX = ivy.iinfo(ivy.int32).max -TREE_UNDEFINED = -2 -_TREE_UNDEFINED = TREE_UNDEFINED TREE_LEAF = -1 +TREE_UNDEFINED = -2 _TREE_LEAF = TREE_LEAF +_TREE_UNDEFINED = TREE_UNDEFINED class Node: @@ -57,17 +57,19 @@ def _resize_c(self, capacity=INTPTR_MAX): dtype=ivy.float32, ) else: - self.value = ivy.concat([ - self.value, - ivy.zeros( - ( - int(capacity - self.capacity), - int(self.n_outputs), - int(self.max_n_classes), + self.value = ivy.concat( + [ + self.value, + ivy.zeros( + ( + int(capacity - self.capacity), + int(self.n_outputs), + int(self.max_n_classes), + ), + dtype=ivy.float32, ), - dtype=ivy.float32, - ), - ]) + ] + ) if capacity < self.node_count: self.node_count = capacity self.capacity = capacity @@ -199,7 +201,6 @@ def __init__( def build( self, tree, X, y, sample_weight=None, missing_values_in_feature_mask=None ): - if tree.max_depth <= 10: init_capacity = int(2 ** (tree.max_depth + 1)) - 1 else: diff --git a/ivy/functional/frontends/tensorflow/keras/metrics.py b/ivy/functional/frontends/tensorflow/keras/metrics.py index 2c8402c8b8067..d32ef36cf1ebc 100644 --- a/ivy/functional/frontends/tensorflow/keras/metrics.py +++ b/ivy/functional/frontends/tensorflow/keras/metrics.py @@ -96,10 +96,15 @@ def _top_k(input, topk): labels = ivy.shape(predictions)[1] # float comparison? - return ivy.array([ - (0 <= res < labels and ivy.min(top_k[ind] - predictions[ind, res]) <= 1e-9) - for ind, res in enumerate(targets) - ]) + return ivy.array( + [ + ( + 0 <= res < labels + and ivy.min(top_k[ind] - predictions[ind, res]) <= 1e-9 + ) + for ind, res in enumerate(targets) + ] + ) reshape = False y_true = ivy.array(y_true) diff --git a/ivy/functional/frontends/tensorflow/linalg.py b/ivy/functional/frontends/tensorflow/linalg.py index 90c896909a925..01a8f293f4497 100644 --- a/ivy/functional/frontends/tensorflow/linalg.py +++ b/ivy/functional/frontends/tensorflow/linalg.py @@ -496,11 +496,13 @@ def tridiagonal_solve( dim = diagonals[0].shape[0] diagonals[[0, -1], [-1, 0]] = 0 dummy_idx = [0, 0] - indices = ivy.array([ - [(i, i + 1) for i in range(dim - 1)] + [dummy_idx], - [(i, i) for i in range(dim)], - [dummy_idx] + [(i + 1, i) for i in range(dim - 1)], - ]) + indices = ivy.array( + [ + [(i, i + 1) for i in range(dim - 1)] + [dummy_idx], + [(i, i) for i in range(dim)], + [dummy_idx] + [(i + 1, i) for i in range(dim - 1)], + ] + ) constructed_matrix = ivy.scatter_nd( indices, diagonals, shape=ivy.array([dim, dim]) ) diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index 398f88faa8c65..7c473ff53e72e 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -314,9 +314,9 @@ def depthwise_conv2d( dilations = 1 if dilations is None else dilations strides, dilations = _reduce_strides_dilations(2, strides, dilations) fc = filter.shape[-2] - filter = filter.reshape([ - *filter.shape[0:2], 1, filter.shape[-2] * filter.shape[-1] - ]) + filter = filter.reshape( + [*filter.shape[0:2], 1, filter.shape[-2] * filter.shape[-1]] + ) return ivy.conv_general_dilated( input, filter, diff --git a/ivy/functional/frontends/tensorflow/raw_ops.py b/ivy/functional/frontends/tensorflow/raw_ops.py index 030e2be87b6fc..50ea03ed0cd3d 100644 --- a/ivy/functional/frontends/tensorflow/raw_ops.py +++ b/ivy/functional/frontends/tensorflow/raw_ops.py @@ -14,6 +14,7 @@ Acos = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.acos)) Acosh = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.acosh)) +Add = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.add)) AddN = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.add_n)) AddV2 = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.add)) ArgMax = to_ivy_arrays_and_back( @@ -248,6 +249,7 @@ ) Sin = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.sin)) Size = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.general_functions.size)) +Slice = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.slice)) Softmax = to_ivy_arrays_and_back( with_unsupported_dtypes( { @@ -280,6 +282,7 @@ Squeeze = to_ivy_arrays_and_back( map_raw_ops_alias(tf_frontend.general_functions.squeeze) ) +Sub = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.subtract)) Tan = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.tan)) Tanh = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.tanh)) Tile = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.general_functions.tile)) @@ -868,8 +871,3 @@ def Xlog1py(*, x, y, name="Xlog1py"): @to_ivy_arrays_and_back def ZerosLike(*, x, name="ZerosLike"): return ivy.zeros_like(x) - - -Add = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.add)) -Slice = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.slice)) -Sub = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.subtract)) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 80d55d6957f39..76d75d1eff808 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -295,8 +295,8 @@ def topk(input, k, dim=None, largest=True, sorted=True, *, out=None): return ivy.top_k(input, k, axis=dim, largest=largest, sorted=sorted, out=out) -gt = greater ge = greater_equal +gt = greater le = less_equal lt = less ne = not_equal diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 23eeef185e73e..446227f997913 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -60,9 +60,9 @@ def block_diag(*tensors): ret_dim_1 = 0 for idx, t_shape in enumerate(shapes_list): dim_0, dim_1 = t_shape - ret[ret_dim_0 : ret_dim_0 + dim_0, ret_dim_1 : ret_dim_1 + dim_1] = ( - ivy.copy_array(tensors_2d[idx]) - ) + ret[ + ret_dim_0 : ret_dim_0 + dim_0, ret_dim_1 : ret_dim_1 + dim_1 + ] = ivy.copy_array(tensors_2d[idx]) ret_dim_0 += dim_0 ret_dim_1 += dim_1 diff --git a/ivy/functional/frontends/torch/nn/functional/distance_functions.py b/ivy/functional/frontends/torch/nn/functional/distance_functions.py index ba8b6f0930cc1..d490f459a18f3 100644 --- a/ivy/functional/frontends/torch/nn/functional/distance_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/distance_functions.py @@ -45,9 +45,11 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def pdist(input, p=2): - x = ivy.array([ - abs(input[i] - input[j]) - for i in range(len(input) - 1) - for j in range(i + 1, len(input)) - ]) + x = ivy.array( + [ + abs(input[i] - input[j]) + for i in range(len(input) - 1) + for j in range(i + 1, len(input)) + ] + ) return ivy.vector_norm(x, ord=p, axis=1) diff --git a/ivy/functional/frontends/torch/nn/functional/loss_functions.py b/ivy/functional/frontends/torch/nn/functional/loss_functions.py index 2ba4f45d333fa..d82eb7b599e2c 100644 --- a/ivy/functional/frontends/torch/nn/functional/loss_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/loss_functions.py @@ -166,10 +166,12 @@ def calculate_loss(x1, x2, target): if target.ndim == 0: loss = calculate_loss(input1, input2, target) else: - loss = ivy.array([ - calculate_loss(input1[i], input2[i], target[i]) - for i in range(input1.shape[0]) - ]) + loss = ivy.array( + [ + calculate_loss(input1[i], input2[i], target[i]) + for i in range(input1.shape[0]) + ] + ) reduction = _get_reduction(reduction, size_average, reduce) loss = reduction(loss) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index 8b661a78b3fbc..26b103906b8c1 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -11,10 +11,12 @@ def _handle_padding_shape(padding, n, mode): - padding = tuple([ - (padding[i * 2], padding[i * 2 + 1]) - for i in range(int(len(padding) / 2) - 1, -1, -1) - ]) + padding = tuple( + [ + (padding[i * 2], padding[i * 2 + 1]) + for i in range(int(len(padding) / 2) - 1, -1, -1) + ] + ) if mode == "circular": padding = padding + ((0, 0),) * (n - len(padding)) else: diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index c59e52b5eb97c..66dc306159614 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -36,11 +36,13 @@ def _create_variables(self, device=None, dtype=None): # Create variables stored in the `__dict__` that were set # using direct `__setattr__` e.g. self.weight = ... v = ivy.Container( - OrderedDict([ - (k.replace(".", "/"), v) - for k, v in self.__dict__.items() - if isinstance(v, Parameter) - ]), + OrderedDict( + [ + (k.replace(".", "/"), v) + for k, v in self.__dict__.items() + if isinstance(v, Parameter) + ] + ), dynamic_backend=self._dynamic_backend, ) # Created variables that were added using `register_paramter`, @@ -48,12 +50,14 @@ def _create_variables(self, device=None, dtype=None): v = ( ivy.Container( OrderedDict( - ({ - _k.replace(".", "/"): _v - for (_k, _v) in self._v.items() - if _k.replace(".", "/") not in v - and not isinstance(_v, ivy.Container) - }), + ( + { + _k.replace(".", "/"): _v + for (_k, _v) in self._v.items() + if _k.replace(".", "/") not in v + and not isinstance(_v, ivy.Container) + } + ), **v, ) ) @@ -132,7 +136,6 @@ def get_submodule(self, target: str) -> "Module": mod: Module = self for item in atoms: - if not hasattr(mod, item): raise AttributeError( mod._get_name() + " has no attribute `" + item + "`" diff --git a/ivy/functional/frontends/xgboost/core.py b/ivy/functional/frontends/xgboost/core.py index 0ec6ac791099e..c5404abf5d839 100644 --- a/ivy/functional/frontends/xgboost/core.py +++ b/ivy/functional/frontends/xgboost/core.py @@ -103,11 +103,13 @@ def __init__(self, params=None, cache=None, model_file=None, compile=False): ) # add num_feature, num_target and num_instances to params - params.update({ - "num_feature": n_feat, - "num_output_group": n_output_group - 1, - "num_instances": n_inst, - }) + params.update( + { + "num_feature": n_feat, + "num_output_group": n_output_group - 1, + "num_instances": n_inst, + } + ) # create gbm(as for now only gblinear booster is available) self.gbm = GBLinear(params, compile=compile, cache=cache) diff --git a/ivy/functional/frontends/xgboost/gbm/gbm.py b/ivy/functional/frontends/xgboost/gbm/gbm.py index 8241acf4d29e1..41271ea82cc56 100644 --- a/ivy/functional/frontends/xgboost/gbm/gbm.py +++ b/ivy/functional/frontends/xgboost/gbm/gbm.py @@ -163,10 +163,12 @@ def _get_gradient(obj, pred, label, scale_pos_weight): # group weights for positive class are scaled w_scaled = ivy.where(label == 1.0, w * scale_pos_weight, w) - return ivy.hstack([ - obj.first_order_gradient(p, label) * w_scaled, - obj.second_order_gradient(p, label) * w_scaled, - ]) + return ivy.hstack( + [ + obj.first_order_gradient(p, label) * w_scaled, + obj.second_order_gradient(p, label) * w_scaled, + ] + ) def _pred(dt, w, base): diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test__src/test_tree_util.py b/ivy_tests/test_ivy/test_frontends/test_jax/test__src/test_tree_util.py index 5a53c51bd5196..171cf37f2d825 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test__src/test_tree_util.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test__src/test_tree_util.py @@ -87,14 +87,16 @@ def tree_strategy(max_depth=2): return leaf_strategy() else: return st.dictionaries( - keys=st.one_of(*[ - st.text( - alphabet=st.characters(min_codepoint=97, max_codepoint=122), - min_size=1, - max_size=1, - ).filter(lambda x: x not in used_keys) - for used_keys in [set()] - ]), + keys=st.one_of( + *[ + st.text( + alphabet=st.characters(min_codepoint=97, max_codepoint=122), + min_size=1, + max_size=1, + ).filter(lambda x: x not in used_keys) + for used_keys in [set()] + ] + ), values=st.one_of(leaf_strategy(), tree_strategy(max_depth - 1)), min_size=1, max_size=10, diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py index f355a902382ea..649b2cfaba96f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py @@ -460,24 +460,30 @@ def _x_and_filters(draw, dim=2, transpose=False, general=False): dim_num_st2 = st.sampled_from(["OIDHW", "DHWIO"]) dim_seq = [*range(0, dim + 2)] dimension_numbers = draw( - st.sampled_from([ - None, - (draw(dim_num_st1), draw(dim_num_st2), draw(dim_num_st1)), - ConvDimensionNumbers( - *map( - tuple, - draw( - st.lists(st.permutations(dim_seq), min_size=3, max_size=3) - ), - ) - ), - ]) + st.sampled_from( + [ + None, + (draw(dim_num_st1), draw(dim_num_st2), draw(dim_num_st1)), + ConvDimensionNumbers( + *map( + tuple, + draw( + st.lists( + st.permutations(dim_seq), min_size=3, max_size=3 + ) + ), + ) + ), + ] + ) ) else: dimension_numbers = ( ("NCH", "OIH", "NCH") if dim == 1 - else ("NCHW", "OIHW", "NCHW") if dim == 2 else ("NCDHW", "OIDHW", "NCDHW") + else ("NCHW", "OIHW", "NCHW") + if dim == 2 + else ("NCDHW", "OIDHW", "NCDHW") ) dim_nums = _dimension_numbers(dimension_numbers, dim + 2, transp=transpose) if not transpose: diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py index 5ebef754a9aab..4d76bfcc9a139 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py @@ -113,9 +113,9 @@ def test_jax_choose( on_device, ): dtypes, x, indices, axis, _ = dtype_x_indices_axis - choices = ivy.array([ - np.random.randint(0, 10, size=x.shape) for _ in range(len(dtypes)) - ]) + choices = ivy.array( + [np.random.randint(0, 10, size=x.shape) for _ in range(len(dtypes))] + ) helpers.test_frontend_function( input_dtypes=dtypes, backend_to_test=backend_fw, diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py index c027097165f2e..fb081e1cd406a 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py @@ -39,9 +39,9 @@ def _get_inv_square_matrices(draw): ) shape, ind = draw( - st.sampled_from([ - (generated_shape, generated_ind), (handpicked_shape, handpicked_ind) - ]) + st.sampled_from( + [(generated_shape, generated_ind), (handpicked_shape, handpicked_ind)] + ) ) input_dtype = draw( diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py index 92b3a644c42bb..2d9d150748115 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py @@ -111,19 +111,21 @@ def _get_input_and_block(draw): max_size=10, ) ) - x_dtypes, xs = zip(*[ - draw( - helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), - min_num_dims=1, - max_num_dims=5, - min_dim_size=2, - max_dim_size=10, - shape=shape, + x_dtypes, xs = zip( + *[ + draw( + helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_num_dims=1, + max_num_dims=5, + min_dim_size=2, + max_dim_size=10, + shape=shape, + ) ) - ) - for shape in shapes - ]) + for shape in shapes + ] + ) return x_dtypes, xs @@ -228,18 +230,20 @@ def _get_input_and_two_swapabble_axes(draw): @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from([ - "constant", - "edge", - "linear_ramp", - "maximum", - "mean", - "median", - "minimum", - "reflect", - "symmetric", - "wrap", - ]) + st.sampled_from( + [ + "constant", + "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", + "reflect", + "symmetric", + "wrap", + ] + ) ) if mode == "median": dtypes = "float" diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py index c972407723b23..28d6388d2af2c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_statistical.py @@ -546,17 +546,19 @@ def test_jax_cumsum( # einsum @handle_frontend_test( fn_tree="jax.numpy.einsum", - eq_n_op=st.sampled_from([ - ( - "ii", - np.arange(25).reshape(5, 5), - ), - ( - "ii->i", - np.arange(25).reshape(5, 5), - ), - ("ij,j", np.arange(25).reshape(5, 5), np.arange(5)), - ]), + eq_n_op=st.sampled_from( + [ + ( + "ii", + np.arange(25).reshape(5, 5), + ), + ( + "ii->i", + np.arange(25).reshape(5, 5), + ), + ("ij,j", np.arange(25).reshape(5, 5), np.arange(5)), + ] + ), dtype=helpers.get_dtypes("float", full=False), ) def test_jax_einsum( diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py index 8b07920b02287..46a0d22c152cd 100644 --- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py +++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py @@ -529,15 +529,17 @@ def test_mindspore_flatten( num_arrays=1, shared_dtype=True, ), - mode=st.sampled_from([ - "nearest", - "linear", - "bilinear", - "bicubic", - "trilinear", - "area", - "nearest-exact", - ]), + mode=st.sampled_from( + [ + "nearest", + "linear", + "bilinear", + "bicubic", + "trilinear", + "area", + "nearest-exact", + ] + ), align_corners=st.booleans(), recompute_scale_factor=st.booleans(), size_and_scale_factor=_size_and_scale_factor_strategy(), diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py index fc918a1d85da6..d93895355b185 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_func_wrapper.py @@ -23,17 +23,23 @@ @st.composite def _dtype_helper(draw): return draw( - st.sampled_from([ - draw(st.sampled_from([int, float, bool])), - ivy.as_native_dtype( - draw(helpers.get_dtypes("valid", full=False, prune_function=False))[0] - ), - np_frontend.dtype( - draw(helpers.get_dtypes("valid", full=False, prune_function=False))[0] - ), - draw(st.sampled_from(list(np_frontend.numpy_scalar_to_dtype.keys()))), - draw(st.sampled_from(list(np_frontend.numpy_str_to_type_table.keys()))), - ]) + st.sampled_from( + [ + draw(st.sampled_from([int, float, bool])), + ivy.as_native_dtype( + draw(helpers.get_dtypes("valid", full=False, prune_function=False))[ + 0 + ] + ), + np_frontend.dtype( + draw(helpers.get_dtypes("valid", full=False, prune_function=False))[ + 0 + ] + ), + draw(st.sampled_from(list(np_frontend.numpy_scalar_to_dtype.keys()))), + draw(st.sampled_from(list(np_frontend.numpy_str_to_type_table.keys()))), + ] + ) ) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_indexing_like_operations.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_indexing_like_operations.py index 342b705f03a0f..463bf32a3a750 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_indexing_like_operations.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_indexing_routines/test_indexing_like_operations.py @@ -151,21 +151,23 @@ def test_numpy_put_along_axis( @handle_frontend_test( - fn_tree="numpy.take_along_axis", + fn_tree="numpy.take", dtype_x_indices_axis=helpers.array_indices_axis( - array_dtypes=helpers.get_dtypes("numeric"), + array_dtypes=helpers.get_dtypes("valid"), indices_dtypes=["int32", "int64"], min_num_dims=1, - max_num_dims=5, + max_num_dims=3, min_dim_size=1, - max_dim_size=10, + max_dim_size=5, indices_same_dims=True, + valid_bounds=False, ), - test_with_out=st.just(False), + mode=st.sampled_from(["clip", "wrap"]), ) -def test_numpy_take_along_axis( +def test_numpy_take( *, dtype_x_indices_axis, + mode, test_flags, frontend, backend_fw, @@ -180,30 +182,29 @@ def test_numpy_take_along_axis( frontend=frontend, fn_tree=fn_tree, on_device=on_device, - arr=x, + a=x, indices=indices, axis=axis, + mode=mode, ) @handle_frontend_test( - fn_tree="numpy.take", + fn_tree="numpy.take_along_axis", dtype_x_indices_axis=helpers.array_indices_axis( - array_dtypes=helpers.get_dtypes("valid"), + array_dtypes=helpers.get_dtypes("numeric"), indices_dtypes=["int32", "int64"], min_num_dims=1, - max_num_dims=3, + max_num_dims=5, min_dim_size=1, - max_dim_size=5, + max_dim_size=10, indices_same_dims=True, - valid_bounds=False, ), - mode=st.sampled_from(["clip", "wrap"]), + test_with_out=st.just(False), ) -def test_numpy_take( +def test_numpy_take_along_axis( *, dtype_x_indices_axis, - mode, test_flags, frontend, backend_fw, @@ -218,8 +219,7 @@ def test_numpy_take( frontend=frontend, fn_tree=fn_tree, on_device=on_device, - a=x, + arr=x, indices=indices, axis=axis, - mode=mode, ) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py index db40d797d4039..e72396bb1f976 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_and_vector_products.py @@ -161,17 +161,19 @@ def test_numpy_dot( @handle_frontend_test( fn_tree="numpy.linalg.matrix_and_vector_products.einsum", gt_fn_tree="numpy.einsum", - args=st.sampled_from([ - ( - "ii", - np.arange(25).reshape(5, 5), - ), - ( - "ii->i", - np.arange(25).reshape(5, 5), - ), - ("ij,j", np.arange(25).reshape(5, 5), np.arange(5)), - ]), + args=st.sampled_from( + [ + ( + "ii", + np.arange(25).reshape(5, 5), + ), + ( + "ii->i", + np.arange(25).reshape(5, 5), + ), + ("ij,j", np.arange(25).reshape(5, 5), np.arange(5)), + ] + ), dtype=helpers.get_dtypes("float", full=False), ) def test_numpy_einsum( diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py index 1af6216ee5d01..3a12867c31bef 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_solving_equations_and_inverting_matrices.py @@ -27,9 +27,9 @@ def _get_inv_square_matrices(draw): ) shape, ind = draw( - st.sampled_from([ - (generated_shape, generated_ind), (handpicked_shape, handpicked_ind) - ]) + st.sampled_from( + [(generated_shape, generated_ind), (handpicked_shape, handpicked_ind)] + ) ) input_dtype = draw( diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py index 6156d1fd3b612..8fe30ac7ca58f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_padding_arrays.py @@ -13,18 +13,20 @@ @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from([ - "constant", - "edge", - "linear_ramp", - "maximum", - "mean", - "median", - "minimum", - "reflect", - "symmetric", - "wrap", - ]) + st.sampled_from( + [ + "constant", + "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", + "reflect", + "symmetric", + "wrap", + ] + ) ) if mode in ["median", "mean"]: dtypes = "float" diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py index 833da964cdfdd..6404b98dade7f 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py @@ -3545,12 +3545,14 @@ def test_numpy_sum( if ivy.current_backend_str() == "torch": assume(not method_flags.as_variable[0]) - where, input_dtypes, method_flags = ( - np_frontend_helpers.handle_where_and_array_bools( - where=where, - input_dtype=input_dtypes, - test_flags=method_flags, - ) + ( + where, + input_dtypes, + method_flags, + ) = np_frontend_helpers.handle_where_and_array_bools( + where=where, + input_dtype=input_dtypes, + test_flags=method_flags, ) where = ivy.array(where, dtype="bool") helpers.test_frontend_method( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py index c70b27ae2e3c2..f020caefc0d57 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py @@ -60,20 +60,22 @@ def _interp_args(draw, mode=None, mode_list=None): mode = draw(st.sampled_from(jax_modes)) else: mode = draw( - st.sampled_from([ - "linear", - "bilinear", - "trilinear", - "nearest", - "nearest-exact", - "area", - "tf_area", - "tf_bicubic", - "lanczos3", - "lanczos5", - "mitchellcubic", - "gaussian", - ]) + st.sampled_from( + [ + "linear", + "bilinear", + "trilinear", + "nearest", + "nearest-exact", + "area", + "tf_area", + "tf_bicubic", + "lanczos3", + "lanczos5", + "mitchellcubic", + "gaussian", + ] + ) ) elif mode_list: mode = draw(st.sampled_from(mode_list)) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 0921b094e50bb..5a911e9595be9 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -1144,40 +1144,6 @@ def test_paddle_abs( ) -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="acos", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), - ), -) -def test_paddle_tensor_acos( - dtype_and_x, - frontend_method_data, - init_flags, - method_flags, - frontend, - on_device, - backend_fw, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={}, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - - # acosh @handle_frontend_method( class_tree=CLASS_TREE, @@ -1213,41 +1179,6 @@ def test_paddle_acosh( ) -# add -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="add", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True - ), -) -def test_paddle_tensor_add( - dtype_and_x, - frontend_method_data, - init_flags, - method_flags, - frontend, - on_device, - backend_fw, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"y": x[1]}, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - - # add_ @handle_frontend_method( class_tree=CLASS_TREE, @@ -5374,6 +5305,75 @@ def test_paddle_tanh_( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="acos", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + ), +) +def test_paddle_tensor_acos( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + +# add +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="add", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle_tensor_add( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={"y": x[1]}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # chunk @handle_frontend_method( class_tree=CLASS_TREE, diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_func_wrapper.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_func_wrapper.py index 5d0290a5ea5cb..036a6fa1e8c54 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_func_wrapper.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_func_wrapper.py @@ -22,18 +22,26 @@ @st.composite def _dtype_helper(draw): return draw( - st.sampled_from([ - draw(helpers.get_dtypes("valid", prune_function=False, full=False))[0], - ivy.as_native_dtype( - draw(helpers.get_dtypes("valid", prune_function=False, full=False))[0] - ), - draw(st.sampled_from(list(tf_frontend.tensorflow_enum_to_type.values()))), - draw(st.sampled_from(list(tf_frontend.tensorflow_enum_to_type.keys()))), - np_frontend.dtype( - draw(helpers.get_dtypes("valid", prune_function=False, full=False))[0] - ), - draw(st.sampled_from(list(np_frontend.numpy_scalar_to_dtype.keys()))), - ]) + st.sampled_from( + [ + draw(helpers.get_dtypes("valid", prune_function=False, full=False))[0], + ivy.as_native_dtype( + draw(helpers.get_dtypes("valid", prune_function=False, full=False))[ + 0 + ] + ), + draw( + st.sampled_from(list(tf_frontend.tensorflow_enum_to_type.values())) + ), + draw(st.sampled_from(list(tf_frontend.tensorflow_enum_to_type.keys()))), + np_frontend.dtype( + draw(helpers.get_dtypes("valid", prune_function=False, full=False))[ + 0 + ] + ), + draw(st.sampled_from(list(np_frontend.numpy_scalar_to_dtype.keys()))), + ] + ) ) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py index 436047049f5e4..bec86d46301a2 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_general_functions.py @@ -228,11 +228,13 @@ def _multiple_shape_helper(draw): @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from([ - "CONSTANT", - "REFLECT", - "SYMMETRIC", - ]) + st.sampled_from( + [ + "CONSTANT", + "REFLECT", + "SYMMETRIC", + ] + ) ) dtype, input, shape = draw( helpers.dtype_and_values( @@ -283,19 +285,21 @@ def _sequence_mask_helper(draw): max_len = draw(st.integers(min_value=max_val, max_value=max_val)) dtype = draw( - st.sampled_from([ - "float16", - "uint8", - "complex128", - "bool", - "float64", - "int8", - "int16", - "complex64", - "float32", - "int32", - "int64", - ]) + st.sampled_from( + [ + "float16", + "uint8", + "complex128", + "bool", + "float64", + "int8", + "int16", + "complex64", + "float32", + "int32", + "int64", + ] + ) ) return in_dtype, lens, max_len, dtype @@ -725,11 +729,13 @@ def test_tensorflow_convert_to_tensor( # einsum @handle_frontend_test( fn_tree="tensorflow.einsum", - eq_n_op_n_shp=st.sampled_from([ - ("ii", (np.arange(25).reshape(5, 5),), ()), - ("ii->i", (np.arange(25).reshape(5, 5),), (5,)), - ("ij,j", (np.arange(25).reshape(5, 5), np.arange(5)), (5,)), - ]), + eq_n_op_n_shp=st.sampled_from( + [ + ("ii", (np.arange(25).reshape(5, 5),), ()), + ("ii->i", (np.arange(25).reshape(5, 5),), (5,)), + ("ij,j", (np.arange(25).reshape(5, 5), np.arange(5)), (5,)), + ] + ), dtype=helpers.get_dtypes("float", full=False), ) def test_tensorflow_einsum( diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py index 1a021be263a75..936a069aa950e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py @@ -1288,11 +1288,13 @@ def tridiagonal_compact_filter(x): dim = diagonals[0].shape[0] diagonals[[0, -1], [-1, 0]] = 0 dummy_idx = [0, 0] - indices = ivy.array([ - [(i, i + 1) for i in range(dim - 1)] + [dummy_idx], - [(i, i) for i in range(dim)], - [dummy_idx] + [(i + 1, i) for i in range(dim - 1)], - ]) + indices = ivy.array( + [ + [(i, i + 1) for i in range(dim - 1)] + [dummy_idx], + [(i, i) for i in range(dim)], + [dummy_idx] + [(i + 1, i) for i in range(dim - 1)], + ] + ) matrix = ivy.scatter_nd( indices, diagonals, ivy.array([dim, dim]), reduction="replace" ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py index 5d9de4b6aff10..912c3e82599be 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py @@ -78,12 +78,14 @@ def _pad_generator(draw, shape, mode): @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from([ - "constant", - "reflect", - "replicate", - "circular", - ]) + st.sampled_from( + [ + "constant", + "reflect", + "replicate", + "circular", + ] + ) ) min_v = 1 max_v = 5 diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_creation.py b/ivy_tests/test_ivy/test_functional/test_core/test_creation.py index c2686e8d00b35..99a105e454651 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_creation.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_creation.py @@ -46,12 +46,14 @@ def _asarray_helper(draw): )[-1] dtype = draw(st.sampled_from([dtype, None])) x = draw( - st.sampled_from([ - x, - x_list, - sh, - # nested_values, - ]) + st.sampled_from( + [ + x, + x_list, + sh, + # nested_values, + ] + ) ) return x_dtype, x, dtype diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index 0ce3c2eb561c7..ab35dc81db1a5 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -408,10 +408,12 @@ def test_arg_info(): @given( - x_n_value=st.sampled_from([ - [ivy.value_is_nan, ["x", "include_infs"]], - [ivy.clip_matrix_norm, ["x", "max_norm", "p", "out"]], - ]) + x_n_value=st.sampled_from( + [ + [ivy.value_is_nan, ["x", "include_infs"]], + [ivy.clip_matrix_norm, ["x", "max_norm", "p", "out"]], + ] + ) ) def test_arg_names(x_n_value): x, value = x_n_value @@ -710,15 +712,17 @@ def test_default(x, default_val, test_flags, backend_fw): and (ivy.array([x[1][0]], dtype="float32").shape[3] % 2 == 0) and (x[0][0] not in ["float16", "bfloat16"]) ), - pattern_and_axes_lengths=st.sampled_from([ - ("b h w c -> b h w c", {}), - ("b h w c -> (b h) w c", {}), - ("b h w c -> b c h w", {}), - ("b h w c -> h (b w) c", {}), - ("b h w c -> b (c h w)", {}), - ("b (h1 h) (w1 w) c -> (b h1 w1) h w c", {"h1": 2, "w1": 2}), - ("b (h h1) (w w1) c -> b h w (c h1 w1)", {"h1": 2, "w1": 2}), - ]), + pattern_and_axes_lengths=st.sampled_from( + [ + ("b h w c -> b h w c", {}), + ("b h w c -> (b h) w c", {}), + ("b h w c -> b c h w", {}), + ("b h w c -> h (b w) c", {}), + ("b h w c -> b (c h w)", {}), + ("b (h1 h) (w1 w) c -> (b h1 w1) h w c", {"h1": 2, "w1": 2}), + ("b (h h1) (w w1) c -> b h w (c h1 w1)", {"h1": 2, "w1": 2}), + ] + ), ) def test_einops_rearrange( dtype_x, pattern_and_axes_lengths, test_flags, backend_fw, fn_name, on_device @@ -754,9 +758,11 @@ def test_einops_rearrange( and (ivy.array([x[1][0]], dtype="float32").shape[3] % 2 == 0) and (x[0][0] not in ["float16", "bfloat16"]) ), - pattern_and_axes_lengths=st.sampled_from([ - ("b c (h1 h2) (w1 w2) -> b c h1 w1", {"h2": 2, "w2": 2}), - ]), + pattern_and_axes_lengths=st.sampled_from( + [ + ("b c (h1 h2) (w1 w2) -> b c h1 w1", {"h2": 2, "w2": 2}), + ] + ), floattypes=helpers.get_dtypes("float"), reduction=st.sampled_from(["min", "max", "sum", "mean", "prod"]), ) @@ -803,13 +809,15 @@ def test_einops_reduce( max_num_dims=2, min_dim_size=2, ), - pattern_and_axes_lengths=st.sampled_from([ - ("h w -> h w repeat", {"repeat": 2}), - ("h w -> (repeat h) w", {"repeat": 2}), - ("h w -> h (repeat w)", {"repeat": 2}), - ("h w -> (h h2) (w w2)", {"h2": 2, "w2": 2}), - ("h w -> w h", {}), - ]), + pattern_and_axes_lengths=st.sampled_from( + [ + ("h w -> h w repeat", {"repeat": 2}), + ("h w -> (repeat h) w", {"repeat": 2}), + ("h w -> h (repeat w)", {"repeat": 2}), + ("h w -> (h h2) (w w2)", {"h2": 2, "w2": 2}), + ("h w -> w h", {}), + ] + ), ) def test_einops_repeat( *, dtype_x, pattern_and_axes_lengths, test_flags, backend_fw, fn_name, on_device diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_meta.py b/ivy_tests/test_ivy/test_functional/test_core/test_meta.py index 54fceaf059e28..a0b3cc5723e1c 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_meta.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_meta.py @@ -45,32 +45,36 @@ def test_fomaml_step_overlapping_vars( # create variables if batched: - variables = ivy_backend.Container({ - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[0.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - "weight": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - }) + variables = ivy_backend.Container( + { + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[0.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + "weight": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + } + ) else: - variables = ivy_backend.Container({ - "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), - "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), - }) + variables = ivy_backend.Container( + { + "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), + "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), + } + ) # batch - batch = ivy_backend.Container({ - "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") - }) + batch = ivy_backend.Container( + {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} + ) # inner cost function def inner_cost_fn(batch_in, v): @@ -102,14 +106,16 @@ def outer_cost_fn(batch_in, v): # true gradient all_outer_grads = [] for sub_batch in batch_np.cont_unstack_conts(0, True, num_tasks): - all_outer_grads.append([ - ( - -i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 - - sub_batch["x"][0] * latent_np - ) - * (-1 if with_outer_cost_fn else 1) - for i in range(inner_grad_steps + 1) - ]) + all_outer_grads.append( + [ + ( + -i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 + - sub_batch["x"][0] * latent_np + ) + * (-1 if with_outer_cost_fn else 1) + for i in range(inner_grad_steps + 1) + ] + ) if average_across_steps: true_weight_grad = ( sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks @@ -118,9 +124,9 @@ def outer_cost_fn(batch_in, v): true_weight_grad = sum(og[-1] for og in all_outer_grads) / num_tasks # true latent gradient - true_latent_grad = np.array([ - (-1 - (num_tasks - 1) / 2) * (-1 if with_outer_cost_fn else 1) - ]) + true_latent_grad = np.array( + [(-1 - (num_tasks - 1) / 2) * (-1 if with_outer_cost_fn else 1)] + ) # true cost true_cost_dict = { @@ -212,24 +218,26 @@ def test_fomaml_step_shared_vars( # create variable if batched: - variables = ivy_backend.Container({ - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, + variables = ivy_backend.Container( + { + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) ) - ) - }) + } + ) else: - variables = ivy_backend.Container({ - "latent": variable_fn(ivy_backend.array([1.0], device=on_device)) - }) + variables = ivy_backend.Container( + {"latent": variable_fn(ivy_backend.array([1.0], device=on_device))} + ) # batch - batch = ivy_backend.Container({ - "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") - }) + batch = ivy_backend.Container( + {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} + ) # inner cost function def inner_cost_fn(batch_in, v): @@ -401,32 +409,36 @@ def test_fomaml_step_unique_vars( # create variables if batched: - variables = ivy_backend.Container({ - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[0.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - "weight": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - }) + variables = ivy_backend.Container( + { + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[0.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + "weight": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + } + ) else: - variables = ivy_backend.Container({ - "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), - "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), - }) + variables = ivy_backend.Container( + { + "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), + "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), + } + ) # batch - batch = ivy_backend.Container({ - "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") - }) + batch = ivy_backend.Container( + {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} + ) # inner cost function def inner_cost_fn(batch_in, v): @@ -458,14 +470,16 @@ def outer_cost_fn(batch_in, v): # true gradient all_outer_grads = [] for sub_batch in batch_np.cont_unstack_conts(0, True, num_tasks): - all_outer_grads.append([ - ( - -i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 - - sub_batch["x"][0] * latent_np - ) - * (-1 if with_outer_cost_fn else 1) - for i in range(inner_grad_steps + 1) - ]) + all_outer_grads.append( + [ + ( + -i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 + - sub_batch["x"][0] * latent_np + ) + * (-1 if with_outer_cost_fn else 1) + for i in range(inner_grad_steps + 1) + ] + ) if average_across_steps: true_weight_grad = ( sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks @@ -559,32 +573,36 @@ def test_maml_step_overlapping_vars( # create variables if batched: - variables = ivy_backend.Container({ - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[0.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - "weight": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - }) + variables = ivy_backend.Container( + { + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[0.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + "weight": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + } + ) else: - variables = ivy_backend.Container({ - "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), - "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), - }) + variables = ivy_backend.Container( + { + "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), + "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), + } + ) # batch - batch = ivy_backend.Container({ - "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") - }) + batch = ivy_backend.Container( + {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} + ) # inner cost function def inner_cost_fn(batch_in, v): @@ -616,14 +634,20 @@ def outer_cost_fn(batch_in, v): # true weight gradient all_outer_grads = [] for sub_batch in batch_np.cont_unstack_conts(0, True, num_tasks): - all_outer_grads.append([ - ( - -2 * i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 - - sub_batch["x"][0] * latent_np - ) - * (-1 if with_outer_cost_fn else 1) - for i in range(inner_grad_steps + 1) - ]) + all_outer_grads.append( + [ + ( + -2 + * i + * inner_learning_rate + * weight_np + * sub_batch["x"][0] ** 2 + - sub_batch["x"][0] * latent_np + ) + * (-1 if with_outer_cost_fn else 1) + for i in range(inner_grad_steps + 1) + ] + ) if average_across_steps: true_weight_grad = ( sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks @@ -632,9 +656,9 @@ def outer_cost_fn(batch_in, v): true_weight_grad = sum(og[-1] for og in all_outer_grads) / num_tasks # true latent gradient - true_latent_grad = np.array([ - (-1 - (num_tasks - 1) / 2) * (-1 if with_outer_cost_fn else 1) - ]) + true_latent_grad = np.array( + [(-1 - (num_tasks - 1) / 2) * (-1 if with_outer_cost_fn else 1)] + ) # true cost true_cost_dict = { @@ -724,24 +748,26 @@ def test_maml_step_shared_vars( # create variable if batched: - variables = ivy_backend.Container({ - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, + variables = ivy_backend.Container( + { + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) ) - ) - }) + } + ) else: - variables = ivy_backend.Container({ - "latent": variable_fn(ivy_backend.array([1.0], device=on_device)) - }) + variables = ivy_backend.Container( + {"latent": variable_fn(ivy_backend.array([1.0], device=on_device))} + ) # batch - batch = ivy_backend.Container({ - "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") - }) + batch = ivy_backend.Container( + {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} + ) # inner cost function def inner_cost_fn(batch_in, v): @@ -954,32 +980,36 @@ def test_maml_step_unique_vars( # create variables if batched: - variables = ivy_backend.Container({ - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[0.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - "weight": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, - ) - ), - }) + variables = ivy_backend.Container( + { + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[0.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + "weight": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) + ), + } + ) else: - variables = ivy_backend.Container({ - "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), - "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), - }) + variables = ivy_backend.Container( + { + "latent": variable_fn(ivy_backend.array([0.0], device=on_device)), + "weight": variable_fn(ivy_backend.array([1.0], device=on_device)), + } + ) # batch - batch = ivy_backend.Container({ - "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") - }) + batch = ivy_backend.Container( + {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} + ) # inner cost function def inner_cost_fn(batch_in, v): @@ -1011,14 +1041,20 @@ def outer_cost_fn(batch_in, v): # true gradient all_outer_grads = [] for sub_batch in batch_np.cont_unstack_conts(0, True, num_tasks): - all_outer_grads.append([ - ( - -2 * i * inner_learning_rate * weight_np * sub_batch["x"][0] ** 2 - - sub_batch["x"][0] * latent_np - ) - * (-1 if with_outer_cost_fn else 1) - for i in range(inner_grad_steps + 1) - ]) + all_outer_grads.append( + [ + ( + -2 + * i + * inner_learning_rate + * weight_np + * sub_batch["x"][0] ** 2 + - sub_batch["x"][0] * latent_np + ) + * (-1 if with_outer_cost_fn else 1) + for i in range(inner_grad_steps + 1) + ] + ) if average_across_steps: true_outer_grad = ( sum(sum(og) / len(og) for og in all_outer_grads) / num_tasks @@ -1107,24 +1143,26 @@ def test_reptile_step( # create variable if batched: - variables = ivy_backend.Container({ - "latent": variable_fn( - ivy_backend.repeat( - ivy_backend.array([[1.0]], device=on_device), - num_tasks, - axis=0, + variables = ivy_backend.Container( + { + "latent": variable_fn( + ivy_backend.repeat( + ivy_backend.array([[1.0]], device=on_device), + num_tasks, + axis=0, + ) ) - ) - }) + } + ) else: - variables = ivy_backend.Container({ - "latent": variable_fn(ivy_backend.array([1.0], device=on_device)) - }) + variables = ivy_backend.Container( + {"latent": variable_fn(ivy_backend.array([1.0], device=on_device))} + ) # batch - batch = ivy_backend.Container({ - "x": ivy_backend.arange(1, num_tasks + 1, dtype="float32") - }) + batch = ivy_backend.Container( + {"x": ivy_backend.arange(1, num_tasks + 1, dtype="float32")} + ) # inner cost function def inner_cost_fn(batch_in, v): diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_gradients.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_gradients.py index b5226c371a127..f34b3513a8290 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_gradients.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_gradients.py @@ -13,22 +13,26 @@ def _get_primals_and_tangents(x_, dtype, ivy_backend, primals_cont, tangents_cont): if primals_cont: - primals = ivy_backend.Container({ - "l": { - "a": ivy_backend.array(x_[0][0], dtype=dtype), - "b": ivy_backend.array(x_[0][1], dtype=dtype), + primals = ivy_backend.Container( + { + "l": { + "a": ivy_backend.array(x_[0][0], dtype=dtype), + "b": ivy_backend.array(x_[0][1], dtype=dtype), + } } - }) + ) else: primals = ivy_backend.array(x_[0], dtype=dtype) if tangents_cont: - tangents = ivy_backend.Container({ - "l": { - "a": ivy_backend.array([t[0] for t in x_[1]], dtype=dtype), - "b": ivy_backend.array([t[0] for t in x_[1]], dtype=dtype), + tangents = ivy_backend.Container( + { + "l": { + "a": ivy_backend.array([t[0] for t in x_[1]], dtype=dtype), + "b": ivy_backend.array([t[0] for t in x_[1]], dtype=dtype), + } } - }) + ) else: if primals_cont: tangents = ivy_backend.array([t[0] for t in x_[1]], dtype=dtype) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py index 0c0bb83992e84..87b09dccecfd6 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py @@ -205,19 +205,21 @@ def _matricize_data(draw): @st.composite def _pad_helper(draw): mode = draw( - st.sampled_from([ - "constant", - "dilated", - "edge", - "linear_ramp", - "maximum", - "mean", - "median", - "minimum", - "reflect", - "symmetric", - "wrap", - ]) + st.sampled_from( + [ + "constant", + "dilated", + "edge", + "linear_ramp", + "maximum", + "mean", + "median", + "minimum", + "reflect", + "symmetric", + "wrap", + ] + ) ) if mode in ["median", "minimum", "maximum", "linear_ramp"]: dtypes = "float" diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index ba074d564ba52..e02a2e1b49101 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -65,20 +65,22 @@ def _interp_args(draw, mode=None, mode_list=None): mode = draw(st.sampled_from(jax_modes)) else: mode = draw( - st.sampled_from([ - "linear", - "bilinear", - "trilinear", - "nearest", - "nearest-exact", - "area", - "tf_area", - "tf_bicubic", - "lanczos3", - "lanczos5", - "mitchellcubic", - "gaussian", - ]) + st.sampled_from( + [ + "linear", + "bilinear", + "trilinear", + "nearest", + "nearest-exact", + "area", + "tf_area", + "tf_bicubic", + "lanczos3", + "lanczos5", + "mitchellcubic", + "gaussian", + ] + ) ) elif mode_list: mode = draw(st.sampled_from(mode_list)) diff --git a/ivy_tests/test_ivy/test_misc/test_array.py b/ivy_tests/test_ivy/test_misc/test_array.py index c961c59d59f0b..3098bceadf03c 100644 --- a/ivy_tests/test_ivy/test_misc/test_array.py +++ b/ivy_tests/test_ivy/test_misc/test_array.py @@ -2553,9 +2553,9 @@ def test_array_property_strides(dtype_x, backend_fw): min_value=3.0, max_value=10.0, ), - op=st.sampled_from([ - "!=", ">", "<", ">=", "<=", "*", "/", "%", "==", "&", "@", "**", "/" - ]), + op=st.sampled_from( + ["!=", ">", "<", ">=", "<=", "*", "/", "%", "==", "&", "@", "**", "/"] + ), ) def test_dunder_wrapping( dtype_x, diff --git a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py index db75505b51629..16cee4a3dd4ef 100644 --- a/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py +++ b/ivy_tests/test_ivy/test_misc/test_backend_utils/test_backend_handler.py @@ -107,10 +107,12 @@ def test_dynamic_backend_all_combos(middle_backend, end_backend): # set the middle backend ivy.set_backend(middle_backend, dynamic=True) - var_cont = ivy.Container({ - "w": ivy.gradients._variable(ivy.array([10, 20, 30])), - "b": ivy.gradients._variable(ivy.array([40, 50, 60])), - }) + var_cont = ivy.Container( + { + "w": ivy.gradients._variable(ivy.array([10, 20, 30])), + "b": ivy.gradients._variable(ivy.array([40, 50, 60])), + } + ) # set dynamic_backend to true for all objects ivy_cont.dynamic_backend = True a.dynamic_backend = True diff --git a/ivy_tests/test_ivy/test_misc/test_container.py b/ivy_tests/test_ivy/test_misc/test_container.py index 4e0621b0ef31f..f9641e5e98cbe 100644 --- a/ivy_tests/test_ivy/test_misc/test_container.py +++ b/ivy_tests/test_ivy/test_misc/test_container.py @@ -19,9 +19,9 @@ def test_container_all_false(on_device): assert not Container({"a": False, "b": {"c": [1], "d": 0}}).cont_all_false() # noinspection PyBroadException try: - assert Container({ - "a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True} - }).cont_all_false(assert_is_bool=True) + assert Container( + {"a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True}} + ).cont_all_false(assert_is_bool=True) error_raised = False except IvyException: error_raised = True @@ -42,17 +42,17 @@ def test_container_all_key_chains(include_empty, on_device): def test_container_all_true(on_device): - assert not Container({ - "a": ivy.array([1], device=on_device), "b": {"c": [], "d": True} - }).cont_all_true() - assert Container({ - "a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True} - }).cont_all_true() + assert not Container( + {"a": ivy.array([1], device=on_device), "b": {"c": [], "d": True}} + ).cont_all_true() + assert Container( + {"a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True}} + ).cont_all_true() # noinspection PyBroadException try: - assert Container({ - "a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True} - }).cont_all_true(assert_is_bool=True) + assert Container( + {"a": ivy.array([1], device=on_device), "b": {"c": [1], "d": True}} + ).cont_all_true(assert_is_bool=True) error_raised = False except IvyException: error_raised = True @@ -103,10 +103,12 @@ def test_container_assert_contains(on_device): error_caught = True assert error_caught # sub-structure - sub_struc = Container({ - "c": ivy.array([3.0], device=on_device), - "d": ivy.array([4.0], device=on_device), - }) + sub_struc = Container( + { + "c": ivy.array([3.0], device=on_device), + "d": ivy.array([4.0], device=on_device), + } + ) try: not container.cont_assert_contains_sub_container(sub_struc) error_caught = False @@ -136,13 +138,15 @@ def test_container_assert_identical(on_device): arr3 = ivy.array([3], device=on_device) container0 = Container({"a": arr1, "b": {"c": arr2, "d": arr3}}) container1 = Container({"a": arr1, "b": {"c": arr2, "d": arr3}}) - container2 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) + container2 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) container3 = Container({"b": {"d": arr3}}) container4 = Container({"d": arr3}) @@ -177,36 +181,44 @@ def test_container_assert_identical(on_device): def test_container_assert_identical_structure(on_device): # without key_chains specification - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container1 = Container({ - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - }) - container2 = Container({ - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container1 = Container( + { + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + } + ) + container2 = Container( + { + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + "e": ivy.array([6], device=on_device), + }, + } + ) + container3 = Container( + { + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, "e": ivy.array([6], device=on_device), - }, - }) - container3 = Container({ - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - "e": ivy.array([6], device=on_device), - }) + } + ) container4 = Container({"b": {"d": ivy.array([4], device=on_device)}}) container5 = Container({"d": ivy.array([4], device=on_device)}) @@ -217,9 +229,9 @@ def test_container_assert_identical_structure(on_device): # without identical try: - ivy.Container.cont_assert_identical_structure([ - container0, container1, container2, container3 - ]) + ivy.Container.cont_assert_identical_structure( + [container0, container1, container2, container3] + ) error_caught = False except IvyException: error_caught = True @@ -314,20 +326,24 @@ def test_container_at_keys(on_device): def test_container_combine(on_device): - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "e": ivy.array([6], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "e": ivy.array([6], device=on_device), + }, + } + ) container_comb = ivy.Container.cont_combine(container_0, container_1) assert np.equal(ivy.to_numpy(container_comb.a), np.array([4])) assert np.equal(ivy.to_numpy(container_comb.b.c), np.array([5])) @@ -375,21 +391,25 @@ def test_container_common_key_chains(on_device): def test_container_cont_inplace_update(on_device): - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([1], device=on_device), - "d": ivy.array([2], device=on_device), - }, - }) + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([1], device=on_device), + "d": ivy.array([2], device=on_device), + }, + } + ) id0 = id(container0) - container1 = Container({ - "a": ivy.array([0], device=on_device), - "b": { - "c": ivy.array([0], device=on_device), - "d": ivy.array([0], device=on_device), - }, - }) + container1 = Container( + { + "a": ivy.array([0], device=on_device), + "b": { + "c": ivy.array([0], device=on_device), + "d": ivy.array([0], device=on_device), + }, + } + ) id1 = id(container1) assert ivy.Container.cont_all_false(container0.all_equal(container1)) container0.inplace_update(container1) @@ -425,10 +445,12 @@ def test_container_contains(on_device): assert not partial_sub_cont.cont_contains_sub_container(container, partial=True) # sub-structure - sub_struc = Container({ - "c": ivy.array([3.0], device=on_device), - "d": ivy.array([4.0], device=on_device), - }) + sub_struc = Container( + { + "c": ivy.array([3.0], device=on_device), + "d": ivy.array([4.0], device=on_device), + } + ) assert not container.cont_contains_sub_container(sub_struc) assert sub_struc not in container assert container.cont_contains_sub_structure(sub_struc) @@ -585,30 +607,36 @@ def test_container_deep_copy(on_device): def test_container_depth(on_device): - cont_depth1 = Container({ - "a": ivy.array([1], device=on_device), "b": ivy.array([2], device=on_device) - }) + cont_depth1 = Container( + {"a": ivy.array([1], device=on_device), "b": ivy.array([2], device=on_device)} + ) assert cont_depth1.cont_max_depth == 1 - cont_depth2 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) + cont_depth2 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) assert cont_depth2.cont_max_depth == 2 - cont_depth3 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": {"d": ivy.array([2], device=on_device)}, - "e": ivy.array([3], device=on_device), - }, - }) + cont_depth3 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": {"d": ivy.array([2], device=on_device)}, + "e": ivy.array([3], device=on_device), + }, + } + ) assert cont_depth3.cont_max_depth == 3 - cont_depth4 = Container({ - "a": ivy.array([1], device=on_device), - "b": {"c": {"d": {"e": ivy.array([2], device=on_device)}}}, - }) + cont_depth4 = Container( + { + "a": ivy.array([1], device=on_device), + "b": {"c": {"d": {"e": ivy.array([2], device=on_device)}}}, + } + ) assert cont_depth4.cont_max_depth == 4 @@ -626,20 +654,24 @@ def test_container_dev_str(on_device): def test_container_diff(on_device): # all different arrays - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "d": ivy.array([6], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "d": ivy.array([6], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a.diff_0), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.a.diff_1), np.array([4])) @@ -657,20 +689,24 @@ def test_container_diff(on_device): assert container_diff_same_only.cont_to_dict() == {} # some different arrays - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c.diff_0), np.array([2])) @@ -692,20 +728,24 @@ def test_container_diff(on_device): assert "d" in container_diff_same_only["b"] # all different keys - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "e": ivy.array([1], device=on_device), - "f": { - "g": ivy.array([2], device=on_device), - "h": ivy.array([3], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "e": ivy.array([1], device=on_device), + "f": { + "g": ivy.array([2], device=on_device), + "h": ivy.array([3], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a.diff_0), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.diff_0.c), np.array([2])) @@ -723,20 +763,24 @@ def test_container_diff(on_device): assert container_diff_same_only.cont_to_dict() == {} # some different keys - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "e": ivy.array([3], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "e": ivy.array([3], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c), np.array([2])) @@ -760,20 +804,24 @@ def test_container_diff(on_device): assert "e" not in container_diff_same_only["b"] # same containers - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c), np.array([2])) @@ -811,13 +859,15 @@ def test_container_duplicate_array_keychains(on_device): arr1 = ivy.array([1], device=on_device) arr2 = ivy.array([2], device=on_device) container0 = Container({"a": arr1, "b": {"c": arr1, "d": arr2}}) - container1 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([1], device=on_device), - "d": ivy.array([2], device=on_device), - }, - }) + container1 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([1], device=on_device), + "d": ivy.array([2], device=on_device), + }, + } + ) res = ivy.Container.cont_duplicate_array_keychains(container0) assert res == (("a", "b/c"),) res = ivy.Container.cont_duplicate_array_keychains(container1) @@ -861,9 +911,9 @@ def test_container_find_sub_structure(on_device): top_cont = Container(dict_in) # full - sub_cont = Container({ - "c": ivy.array([4], device=on_device), "d": ivy.array([5], device=on_device) - }) + sub_cont = Container( + {"c": ivy.array([4], device=on_device), "d": ivy.array([5], device=on_device)} + ) assert not top_cont.cont_find_sub_container(sub_cont) found_kc = top_cont.cont_find_sub_structure(sub_cont) assert found_kc == "b" @@ -880,13 +930,15 @@ def test_container_find_sub_structure(on_device): def test_container_flatten_key_chains(on_device): - container = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": {"d": ivy.array([2], device=on_device)}, - "e": {"f": {"g": ivy.array([3], device=on_device)}}, - }, - }) + container = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": {"d": ivy.array([2], device=on_device)}, + "e": {"f": {"g": ivy.array([3], device=on_device)}}, + }, + } + ) # full container_flat = container.cont_flatten_key_chains() @@ -970,10 +1022,12 @@ def test_container_from_dict_w_cont_types(on_device): dict_in = { "a": ivy.array([1], device=on_device), - "b": FlatMapping({ - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }), + "b": FlatMapping( + { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + } + ), } container = Container(dict_in) assert np.allclose(ivy.to_numpy(container["a"]), np.array([1])) @@ -1053,12 +1107,15 @@ def worker_fn(in_queue, out_queue, load_size, worker_id): keep_going = in_queue.get(timeout=0.1) except queue.Empty: continue - out_queue.put({ - "a": [ - ivy.to_native(ivy.array([1.0, 2.0, 3.0], device=on_device)) - * worker_id - ] * load_size - }) + out_queue.put( + { + "a": [ + ivy.to_native(ivy.array([1.0, 2.0, 3.0], device=on_device)) + * worker_id + ] + * load_size + } + ) workers = [] in_queues = [] @@ -1190,13 +1247,15 @@ def test_container_identical(on_device): arr3 = ivy.array([3], device=on_device) container0 = Container({"a": arr1, "b": {"c": arr2, "d": arr3}}) container1 = Container({"a": arr1, "b": {"c": arr2, "d": arr3}}) - container2 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) + container2 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) container3 = Container({"b": {"d": arr3}}) container4 = Container({"d": arr3}) @@ -1219,34 +1278,40 @@ def test_container_identical(on_device): def test_container_identical_array_shapes(on_device): # without key_chains specification - container0 = Container({ - "a": ivy.array([1, 2], device=on_device), - "b": { - "c": ivy.array([2, 3, 4], device=on_device), - "d": ivy.array([3, 4, 5, 6], device=on_device), - }, - }) - container1 = Container({ - "a": ivy.array([1, 2, 3, 4], device=on_device), - "b": { - "c": ivy.array([3, 4], device=on_device), - "d": ivy.array([3, 4, 5], device=on_device), - }, - }) - container2 = Container({ - "a": ivy.array([1, 2, 3, 4], device=on_device), - "b": { - "c": ivy.array([3, 4], device=on_device), - "d": ivy.array([3, 4, 5, 6], device=on_device), - }, - }) + container0 = Container( + { + "a": ivy.array([1, 2], device=on_device), + "b": { + "c": ivy.array([2, 3, 4], device=on_device), + "d": ivy.array([3, 4, 5, 6], device=on_device), + }, + } + ) + container1 = Container( + { + "a": ivy.array([1, 2, 3, 4], device=on_device), + "b": { + "c": ivy.array([3, 4], device=on_device), + "d": ivy.array([3, 4, 5], device=on_device), + }, + } + ) + container2 = Container( + { + "a": ivy.array([1, 2, 3, 4], device=on_device), + "b": { + "c": ivy.array([3, 4], device=on_device), + "d": ivy.array([3, 4, 5, 6], device=on_device), + }, + } + ) # with identical assert ivy.Container.cont_identical_array_shapes([container0, container1]) assert ivy.Container.cont_identical_array_shapes([container1, container0]) - assert ivy.Container.cont_identical_array_shapes([ - container1, container0, container1 - ]) + assert ivy.Container.cont_identical_array_shapes( + [container1, container0, container1] + ) assert not ivy.Container.cont_identical([container0, container2]) assert not ivy.Container.cont_identical([container1, container2]) assert not ivy.Container.cont_identical([container0, container1, container2]) @@ -1264,43 +1329,51 @@ def test_container_identical_configs(on_device): # without identical assert not ivy.Container.cont_identical_configs([container1, container2]) - assert not ivy.Container.cont_identical_configs([ - container1, container0, container2 - ]) + assert not ivy.Container.cont_identical_configs( + [container1, container0, container2] + ) def test_container_identical_structure(on_device): # without key_chains specification - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container1 = Container({ - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - }) - container2 = Container({ - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container1 = Container( + { + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + } + ) + container2 = Container( + { + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + "e": ivy.array([6], device=on_device), + }, + } + ) + container3 = Container( + { + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, "e": ivy.array([6], device=on_device), - }, - }) - container3 = Container({ - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - "e": ivy.array([6], device=on_device), - }) + } + ) container4 = Container({"b": {"d": ivy.array([4], device=on_device)}}) container5 = Container({"d": ivy.array([4], device=on_device)}) @@ -1313,9 +1386,9 @@ def test_container_identical_structure(on_device): assert not ivy.Container.cont_identical_structure([container2, container3]) assert not ivy.Container.cont_identical_structure([container0, container3]) assert not ivy.Container.cont_identical_structure([container1, container2]) - assert not ivy.Container.cont_identical_structure([ - container1, container0, container2 - ]) + assert not ivy.Container.cont_identical_structure( + [container1, container0, container2] + ) # partial assert ivy.Container.cont_identical_structure( @@ -1376,22 +1449,26 @@ def test_container_if_exists(on_device): def test_container_inplace(on_device): - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([1], device=on_device), - "d": ivy.array([2], device=on_device), - }, - }) + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([1], device=on_device), + "d": ivy.array([2], device=on_device), + }, + } + ) const = 3 arr = ivy.array([1], device=on_device) - container1 = Container({ - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - }) + container1 = Container( + { + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + } + ) special_funcs = [ "__add__", @@ -1443,20 +1520,24 @@ def test_container_key_chains_containing(include_empty, on_device): def test_container_list_join(on_device): - container_0 = Container({ - "a": [ivy.array([1], device=on_device)], - "b": { - "c": [ivy.array([2], device=on_device)], - "d": [ivy.array([3], device=on_device)], - }, - }) - container_1 = Container({ - "a": [ivy.array([4], device=on_device)], - "b": { - "c": [ivy.array([5], device=on_device)], - "d": [ivy.array([6], device=on_device)], - }, - }) + container_0 = Container( + { + "a": [ivy.array([1], device=on_device)], + "b": { + "c": [ivy.array([2], device=on_device)], + "d": [ivy.array([3], device=on_device)], + }, + } + ) + container_1 = Container( + { + "a": [ivy.array([4], device=on_device)], + "b": { + "c": [ivy.array([5], device=on_device)], + "d": [ivy.array([6], device=on_device)], + }, + } + ) container_list_joined = ivy.Container.cont_list_join([container_0, container_1]) assert np.allclose(ivy.to_numpy(container_list_joined["a"][0]), np.array([1])) assert np.allclose(ivy.to_numpy(container_list_joined.a[0]), np.array([1])) @@ -1473,20 +1554,24 @@ def test_container_list_join(on_device): def test_container_list_stack(on_device): - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "d": ivy.array([6], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "d": ivy.array([6], device=on_device), + }, + } + ) container_list_stacked = ivy.Container.cont_list_stack( [container_0, container_1], 0 ) @@ -1595,10 +1680,12 @@ def test_container_map(inplace, on_device): assert "b/d" not in container_mapped # with sequences - container_orig = Container({ - "a": ivy.array([1], device=on_device), - "b": [ivy.array([2], device=on_device), ivy.array([3], device=on_device)], - }) + container_orig = Container( + { + "a": ivy.array([1], device=on_device), + "b": [ivy.array([2], device=on_device), ivy.array([3], device=on_device)], + } + ) container = container_orig.cont_deep_copy() container_mapped = container.cont_map( lambda x, _: x + 1, inplace=inplace, map_sequences=True @@ -1613,13 +1700,15 @@ def test_container_map(inplace, on_device): @pytest.mark.parametrize("inplace", [True, False]) def test_container_map_sub_conts(inplace, on_device): # without key_chains specification - container_orig = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) + container_orig = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) def _add_e_attr(cont_in): cont_in.e = ivy.array([4], device=on_device) @@ -1651,20 +1740,24 @@ def _add_e_attr(cont_in): def test_container_multi_map(on_device): # without key_chains specification - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container1 = Container({ - "a": ivy.array([3], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([5], device=on_device), - }, - }) + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container1 = Container( + { + "a": ivy.array([3], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([5], device=on_device), + }, + } + ) # with key_chains to apply container_mapped = ivy.Container.cont_multi_map( @@ -1678,20 +1771,24 @@ def test_container_multi_map(on_device): assert np.allclose(ivy.to_numpy(container_mapped.b.d), np.array([[8]])) # with sequences - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": [ - ivy.array([2], device=on_device), - ivy.array([3], device=on_device), - ], - }) - container1 = Container({ - "a": ivy.array([3], device=on_device), - "b": [ - ivy.array([4], device=on_device), - ivy.array([5], device=on_device), - ], - }) + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": [ + ivy.array([2], device=on_device), + ivy.array([3], device=on_device), + ], + } + ) + container1 = Container( + { + "a": ivy.array([3], device=on_device), + "b": [ + ivy.array([4], device=on_device), + ivy.array([5], device=on_device), + ], + } + ) container_mapped = ivy.Container.cont_multi_map( lambda x, _: x[0] + x[1], @@ -1769,17 +1866,21 @@ def test_container_overwrite_at_key_chain(on_device): def test_container_overwrite_at_key_chains(on_device): - container = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - target_container = Container({ - "a": ivy.array([4], device=on_device), - "b": {"d": ivy.array([5], device=on_device)}, - }) + container = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + target_container = Container( + { + "a": ivy.array([4], device=on_device), + "b": {"d": ivy.array([5], device=on_device)}, + } + ) new_container = container.cont_overwrite_at_key_chains( target_container, inplace=False ) @@ -1949,17 +2050,19 @@ def _test_bc_exception(container_in): def test_container_prune_key_from_key_chains(on_device): - container = Container({ - "Ayy": ivy.array([1], device=on_device), - "Bee": { - "Cee": ivy.array([2], device=on_device), - "Dee": ivy.array([3], device=on_device), - }, - "Beh": { - "Ceh": ivy.array([4], device=on_device), - "Deh": ivy.array([5], device=on_device), - }, - }) + container = Container( + { + "Ayy": ivy.array([1], device=on_device), + "Bee": { + "Cee": ivy.array([2], device=on_device), + "Dee": ivy.array([3], device=on_device), + }, + "Beh": { + "Ceh": ivy.array([4], device=on_device), + "Deh": ivy.array([5], device=on_device), + }, + } + ) # absolute container_pruned = container.cont_prune_key_from_key_chains("Bee") @@ -2036,14 +2139,16 @@ def _test_bd_exception(container_in): def test_container_prune_keys_from_key_chains(on_device): - container = Container({ - "Ayy": ivy.array([1], device=on_device), - "Bee": { - "Cee": ivy.array([2], device=on_device), - "Dee": ivy.array([3], device=on_device), - }, - "Eee": {"Fff": ivy.array([4], device=on_device)}, - }) + container = Container( + { + "Ayy": ivy.array([1], device=on_device), + "Bee": { + "Cee": ivy.array([2], device=on_device), + "Dee": ivy.array([3], device=on_device), + }, + "Eee": {"Fff": ivy.array([4], device=on_device)}, + } + ) # absolute container_pruned = container.cont_prune_keys_from_key_chains(["Bee", "Eee"]) @@ -2073,20 +2178,24 @@ def test_container_prune_keys_from_key_chains(on_device): def test_container_reduce(on_device): - container_a = ivy.Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_b = ivy.Container({ - "a": ivy.array([2], device=on_device), - "b": { - "c": ivy.array([4], device=on_device), - "d": ivy.array([6], device=on_device), - }, - }) + container_a = ivy.Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_b = ivy.Container( + { + "a": ivy.array([2], device=on_device), + "b": { + "c": ivy.array([4], device=on_device), + "d": ivy.array([6], device=on_device), + }, + } + ) res = ivy.Container.cont_reduce([container_a, container_b], lambda x: x[0] + x[1]) assert np.allclose(ivy.to_numpy(res.a), np.array([3.0])) assert np.allclose(ivy.to_numpy(res.b.c), np.array([6])) @@ -2094,13 +2203,15 @@ def test_container_reduce(on_device): def test_container_remove_key_length_limit(on_device): - cont = Container({ - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - }) + cont = Container( + { + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + } + ) cont.cont_with_key_length_limit(5, inplace=True) default_key_length_limit = cont._key_length_limit id_cont = id(cont) @@ -2117,13 +2228,15 @@ def test_container_remove_key_length_limit(on_device): def test_container_remove_print_limit(on_device): - cont = Container({ - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - }) + cont = Container( + { + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + } + ) default_print_limit = cont._print_limit id_cont = id(cont) cont1 = cont.cont_remove_print_limit() @@ -2139,13 +2252,15 @@ def test_container_remove_print_limit(on_device): def test_container_reshape_like(on_device): - container = Container({ - "a": ivy.array([[1.0]], device=on_device), - "b": { - "c": ivy.array([[3.0], [4.0]], device=on_device), - "d": ivy.array([[5.0], [6.0], [7.0]], device=on_device), - }, - }) + container = Container( + { + "a": ivy.array([[1.0]], device=on_device), + "b": { + "c": ivy.array([[3.0], [4.0]], device=on_device), + "d": ivy.array([[5.0], [6.0], [7.0]], device=on_device), + }, + } + ) new_shapes = Container({"a": (1,), "b": {"c": (1, 2, 1), "d": (3, 1, 1)}}) # without leading shape @@ -2158,22 +2273,24 @@ def test_container_reshape_like(on_device): assert list(container_reshaped.b.d.shape) == [3, 1, 1] # with leading shape - container = Container({ - "a": ivy.array([[[1.0]], [[1.0]], [[1.0]]], device=on_device), - "b": { - "c": ivy.array( - [[[3.0], [4.0]], [[3.0], [4.0]], [[3.0], [4.0]]], device=on_device - ), - "d": ivy.array( - [ - [[5.0], [6.0], [7.0]], - [[5.0], [6.0], [7.0]], - [[5.0], [6.0], [7.0]], - ], - device=on_device, - ), - }, - }) + container = Container( + { + "a": ivy.array([[[1.0]], [[1.0]], [[1.0]]], device=on_device), + "b": { + "c": ivy.array( + [[[3.0], [4.0]], [[3.0], [4.0]], [[3.0], [4.0]]], device=on_device + ), + "d": ivy.array( + [ + [[5.0], [6.0], [7.0]], + [[5.0], [6.0], [7.0]], + [[5.0], [6.0], [7.0]], + ], + device=on_device, + ), + }, + } + ) container_reshaped = container.cont_reshape_like(new_shapes, leading_shape=[3]) assert list(container_reshaped["a"].shape) == [3, 1] assert list(container_reshaped.a.shape) == [3, 1] @@ -2184,13 +2301,15 @@ def test_container_reshape_like(on_device): def test_container_restructure(on_device): - container = Container({ - "a": ivy.array([[1, 2], [3, 4]], device=on_device), - "b": { - "c": ivy.array([[2, 4], [6, 8]], device=on_device), - "d": ivy.array([3, 6, 9, 12], device=on_device), - }, - }) + container = Container( + { + "a": ivy.array([[1, 2], [3, 4]], device=on_device), + "b": { + "c": ivy.array([[2, 4], [6, 8]], device=on_device), + "d": ivy.array([3, 6, 9, 12], device=on_device), + }, + } + ) container_restructured = container.cont_restructure( { "a": {"key_chain": "A", "pattern": "a b -> b a"}, @@ -2223,13 +2342,15 @@ def test_container_restructure(on_device): def test_container_restructure_key_chains(on_device): # single - container = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) + container = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) container_restructured = container.cont_restructure_key_chains({"a": "A"}) assert np.allclose(ivy.to_numpy(container_restructured["A"]), np.array([[1]])) assert np.allclose(ivy.to_numpy(container_restructured.A), np.array([[1]])) @@ -2239,16 +2360,18 @@ def test_container_restructure_key_chains(on_device): assert np.allclose(ivy.to_numpy(container_restructured.b.d), np.array([[3]])) # full - container = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_restructured = container.cont_restructure_key_chains({ - "a": "A", "b/c": "B/C", "b/d": "B/D" - }) + container = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_restructured = container.cont_restructure_key_chains( + {"a": "A", "b/c": "B/C", "b/d": "B/D"} + ) assert np.allclose(ivy.to_numpy(container_restructured["A"]), np.array([[1]])) assert np.allclose(ivy.to_numpy(container_restructured.A), np.array([[1]])) assert np.allclose(ivy.to_numpy(container_restructured["B/C"]), np.array([[2]])) @@ -2300,17 +2423,21 @@ def test_container_set_at_key_chain(on_device): def test_container_set_at_key_chains(on_device): - container = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - target_container = Container({ - "a": ivy.array([4], device=on_device), - "b": {"d": ivy.array([5], device=on_device)}, - }) + container = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + target_container = Container( + { + "a": ivy.array([4], device=on_device), + "b": {"d": ivy.array([5], device=on_device)}, + } + ) new_container = container.cont_set_at_key_chains(target_container, inplace=False) assert np.allclose(ivy.to_numpy(new_container["a"]), np.array([4])) assert np.allclose(ivy.to_numpy(new_container["b"]["c"]), np.array([2])) @@ -2340,9 +2467,9 @@ def test_container_set_at_keys(on_device): assert np.allclose(ivy.to_numpy(container["b"]), np.array([4])) assert not container.cont_has_key("c") # noqa assert not container.cont_has_key("d") # noqa - container = orig_container.cont_set_at_keys({ - "a": ivy.array([5], device=on_device), "c": ivy.array([6], device=on_device) - }) + container = orig_container.cont_set_at_keys( + {"a": ivy.array([5], device=on_device), "c": ivy.array([6], device=on_device)} + ) assert np.allclose(ivy.to_numpy(container["a"]), np.array([5])) assert np.allclose(ivy.to_numpy(container["b"]["c"]), np.array([6])) assert np.allclose(ivy.to_numpy(container["b"]["d"]), np.array([3])) @@ -2467,9 +2594,9 @@ def test_container_slice_keys(str_slice, on_device): # with dict, depth 0 sub_cont = Container({"a": a_val, "b": b_val, "c": c_val, "d": d_val, "e": e_val}) - cont = Container({ - "a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont - }) + cont = Container( + {"a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont} + ) cont_sliced = cont.cont_slice_keys({0: slc}) assert "a" not in cont_sliced assert Container.cont_identical([cont_sliced.b, sub_cont]) @@ -2480,9 +2607,9 @@ def test_container_slice_keys(str_slice, on_device): # with dict, depth 1 sub_cont = Container({"a": a_val, "b": b_val, "c": c_val, "d": d_val, "e": e_val}) sub_sub_cont = Container({"b": b_val, "c": c_val, "d": d_val}) - cont = Container({ - "a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont - }) + cont = Container( + {"a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont} + ) cont_sliced = cont.cont_slice_keys({1: slc}) assert Container.cont_identical([cont_sliced.a, sub_sub_cont]) assert Container.cont_identical([cont_sliced.b, sub_sub_cont]) @@ -2493,9 +2620,9 @@ def test_container_slice_keys(str_slice, on_device): # with dict, depth 0, 1 sub_cont = Container({"a": a_val, "b": b_val, "c": c_val, "d": d_val, "e": e_val}) sub_sub_cont = Container({"b": b_val, "c": c_val, "d": d_val}) - cont = Container({ - "a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont - }) + cont = Container( + {"a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont} + ) cont_sliced = cont.cont_slice_keys({0: slc, 1: slc}) assert "a" not in cont_sliced assert Container.cont_identical([cont_sliced.b, sub_sub_cont]) @@ -2506,9 +2633,9 @@ def test_container_slice_keys(str_slice, on_device): # all depths sub_cont = Container({"a": a_val, "b": b_val, "c": c_val, "d": d_val, "e": e_val}) sub_sub_cont = Container({"b": b_val, "c": c_val, "d": d_val}) - cont = Container({ - "a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont - }) + cont = Container( + {"a": sub_cont, "b": sub_cont, "c": sub_cont, "d": sub_cont, "e": sub_cont} + ) cont_sliced = cont.cont_slice_keys(slc, all_depths=True) assert "a" not in cont_sliced assert Container.cont_identical([cont_sliced.b, sub_sub_cont]) @@ -2590,20 +2717,24 @@ def test_container_split_conts(on_device): def test_container_structural_diff(on_device): # all different keys or shapes - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([[4]], device=on_device), - "b": { - "c": ivy.array([[[5]]], device=on_device), - "e": ivy.array([3], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([[4]], device=on_device), + "b": { + "c": ivy.array([[[5]]], device=on_device), + "e": ivy.array([3], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a.diff_0), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.a.diff_1), np.array([[4]])) @@ -2621,20 +2752,24 @@ def test_container_structural_diff(on_device): assert container_diff_same_only.cont_to_dict() == {} # some different shapes - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([[5]], device=on_device), - "d": ivy.array([6], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([[5]], device=on_device), + "d": ivy.array([6], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c.diff_0), np.array([2])) @@ -2656,20 +2791,24 @@ def test_container_structural_diff(on_device): assert "d" in container_diff_same_only["b"] # all different keys - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "e": ivy.array([4], device=on_device), - "f": { - "g": ivy.array([5], device=on_device), - "h": ivy.array([6], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "e": ivy.array([4], device=on_device), + "f": { + "g": ivy.array([5], device=on_device), + "h": ivy.array([6], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a.diff_0), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.diff_0.c), np.array([2])) @@ -2687,20 +2826,24 @@ def test_container_structural_diff(on_device): assert container_diff_same_only.cont_to_dict() == {} # some different keys - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "e": ivy.array([6], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "e": ivy.array([6], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c), np.array([2])) @@ -2724,20 +2867,24 @@ def test_container_structural_diff(on_device): assert "e" not in container_diff_same_only["b"] # all same - container_0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([2], device=on_device), - "d": ivy.array([3], device=on_device), - }, - }) - container_1 = Container({ - "a": ivy.array([4], device=on_device), - "b": { - "c": ivy.array([5], device=on_device), - "d": ivy.array([6], device=on_device), - }, - }) + container_0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([2], device=on_device), + "d": ivy.array([3], device=on_device), + }, + } + ) + container_1 = Container( + { + "a": ivy.array([4], device=on_device), + "b": { + "c": ivy.array([5], device=on_device), + "d": ivy.array([6], device=on_device), + }, + } + ) container_diff = ivy.Container.cont_structural_diff(container_0, container_1) assert np.equal(ivy.to_numpy(container_diff.a), np.array([1])) assert np.equal(ivy.to_numpy(container_diff.b.c), np.array([2])) @@ -2879,16 +3026,18 @@ def test_container_to_and_from_disk_as_pickled(on_device): def test_container_to_dict(on_device): - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([True], device=on_device), - "d": { - "g": ivy.array([2.0], device=on_device), - "h": ivy.array([3], device=on_device), + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([True], device=on_device), + "d": { + "g": ivy.array([2.0], device=on_device), + "h": ivy.array([3], device=on_device), + }, }, - }, - }) + } + ) res = ivy.Container.cont_to_dict(container0) assert res == {"a": 1, "b": {"c": True, "d": {"g": 2.0, "h": 3}}} @@ -3020,16 +3169,18 @@ def test_container_to_iterator_values(include_empty, on_device): def test_container_to_nested_list(on_device): - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([True], device=on_device), - "d": { - "g": ivy.array([2.0], device=on_device), - "h": ivy.array([3], device=on_device), + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([True], device=on_device), + "d": { + "g": ivy.array([2.0], device=on_device), + "h": ivy.array([3], device=on_device), + }, }, - }, - }) + } + ) res = ivy.Container.cont_to_nested_list(container0) assert res == [1, [True, [2.0, 3]]] @@ -3054,13 +3205,15 @@ def test_container_trim_key(on_device): def test_container_try_kc(on_device): - cont = Container({ - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - }) + cont = Container( + { + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + } + ) assert cont.cont_try_kc("a") == cont.a assert cont.cont_try_kc("b/c") == cont.b.c assert cont.cont_try_kc("b/d") == cont.b.d @@ -3073,21 +3226,25 @@ def test_container_unify(on_device): dev0 = on_device on_devices.append(dev0) conts = {} - conts[dev0] = Container({ - "a": ivy.array([1], device=dev0), - "b": {"c": ivy.array([2], device=dev0), "d": ivy.array([3], device=dev0)}, - }) + conts[dev0] = Container( + { + "a": ivy.array([1], device=dev0), + "b": {"c": ivy.array([2], device=dev0), "d": ivy.array([3], device=dev0)}, + } + ) if "gpu" in on_device and ivy.num_gpus() > 1: idx = ivy.num_gpus() - 1 dev1 = on_device[:-1] + str(idx) on_devices.append(dev1) - conts[dev1] = Container({ - "a": ivy.array([4], device=dev1), - "b": { - "c": ivy.array([5], device=dev1), - "d": ivy.array([6], device=dev1), - }, - }) + conts[dev1] = Container( + { + "a": ivy.array([4], device=dev1), + "b": { + "c": ivy.array([5], device=dev1), + "d": ivy.array([6], device=dev1), + }, + } + ) # test container_unified = ivy.Container.cont_unify(conts, dev0, "concat", 0) @@ -3122,13 +3279,15 @@ def test_container_unstack_conts(on_device): def test_container_with_default_key_color(on_device): - cont = Container({ - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - }) + cont = Container( + { + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + } + ) default_default_key_color = cont._default_key_color id_cont = id(cont) cont1 = cont.cont_with_default_key_color("red") @@ -3160,13 +3319,15 @@ def test_container_with_entries_as_lists(on_device): def test_container_with_ivy_backend(on_device): - container0 = Container({ - "a": ivy.array([1], device=on_device), - "b": { - "c": ivy.array([1], device=on_device), - "d": ivy.array([2], device=on_device), - }, - }) + container0 = Container( + { + "a": ivy.array([1], device=on_device), + "b": { + "c": ivy.array([1], device=on_device), + "d": ivy.array([2], device=on_device), + }, + } + ) id_container0 = id(container0) container0 = ivy.Container.cont_with_ivy_backend(container0, "numpy") assert container0.cont_config["ivyh"] == "numpy" @@ -3178,13 +3339,15 @@ def test_container_with_ivy_backend(on_device): def test_container_with_key_length_limit(on_device): - cont = Container({ - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - }) + cont = Container( + { + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + } + ) default_key_length_limit = cont._key_length_limit id_cont = id(cont) cont1 = cont.cont_with_key_length_limit(5) @@ -3200,13 +3363,15 @@ def test_container_with_key_length_limit(on_device): def test_container_with_print_indent(on_device): - cont = Container({ - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - }) + cont = Container( + { + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + } + ) default_print_indent = cont._print_indent id_cont = id(cont) cont1 = cont.cont_with_print_indent(default_print_indent + 5) @@ -3222,13 +3387,15 @@ def test_container_with_print_indent(on_device): def test_container_with_print_limit(on_device): - cont = Container({ - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - }) + cont = Container( + { + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + } + ) default_print_limit = cont._print_limit id_cont = id(cont) cont1 = cont.cont_with_print_limit(default_print_limit + 5) @@ -3243,13 +3410,15 @@ def test_container_with_print_limit(on_device): def test_container_with_print_line_spacing(on_device): - cont = Container({ - "a": ivy.array([0.0], device=on_device), - "b": { - "c": ivy.array([1.0], device=on_device), - "d": ivy.array([2.0], device=on_device), - }, - }) + cont = Container( + { + "a": ivy.array([0.0], device=on_device), + "b": { + "c": ivy.array([1.0], device=on_device), + "d": ivy.array([2.0], device=on_device), + }, + } + ) default_print_line_spacing = cont._print_line_spacing id_cont = id(cont) cont1 = cont.cont_with_print_line_spacing(default_print_line_spacing + 5) diff --git a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py index 1e2efc8fdb98c..bb03df0116781 100644 --- a/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py +++ b/ivy_tests/test_ivy/test_misc/test_factorized_tensor/test_tucker_tensor.py @@ -7,9 +7,9 @@ @pytest.mark.parametrize(("shape", "rank"), [((5, 4, 6), (3, 2, 3))]) def test_n_param_tucker(shape, rank): tucker_tensor = ivy.random_tucker(shape, rank) - true_n_param = ivy.prod(ivy.shape(tucker_tensor[0])) + ivy.sum([ - ivy.prod(ivy.shape(f)) for f in tucker_tensor[1] - ]) + true_n_param = ivy.prod(ivy.shape(tucker_tensor[0])) + ivy.sum( + [ivy.prod(ivy.shape(f)) for f in tucker_tensor[1]] + ) n_param = tucker_tensor.n_param assert np.allclose(n_param, true_n_param) diff --git a/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py b/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py index b13bf4d6915b1..2c379e20e8b51 100644 --- a/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py +++ b/ivy_tests/test_ivy/test_misc/test_handle_exceptions.py @@ -67,15 +67,17 @@ def test_non_ivy_errors_mapping(e, to_be_raised): @given( - e=st.sampled_from([ - Exception, - ZeroDivisionError, - BufferError, - AssertionError, - ImportError, - KeyError, - LookupError, - ]) + e=st.sampled_from( + [ + Exception, + ZeroDivisionError, + BufferError, + AssertionError, + ImportError, + KeyError, + LookupError, + ] + ) ) def test_non_ivy_errors_raising(e): with pytest.raises(IvyBackendException): diff --git a/ivy_tests/test_ivy/test_stateful/test_layers.py b/ivy_tests/test_ivy/test_stateful/test_layers.py index b421fbf483eab..40d1425775ed7 100644 --- a/ivy_tests/test_ivy/test_stateful/test_layers.py +++ b/ivy_tests/test_ivy/test_stateful/test_layers.py @@ -23,6 +23,9 @@ all_constant_initializers = (ivy.Zeros, ivy.Ones) all_gaussian_initializers = (ivy.KaimingNormal, ivy.Siren) all_uniform_initializers = (ivy.GlorotUniform, ivy.FirstLayerSiren, ivy.Siren) +all_initializers = ( + all_constant_initializers + all_uniform_initializers + all_gaussian_initializers +) # --- Helpers --- # @@ -1555,18 +1558,20 @@ def test_multi_head_attention_layer( # # Sequential # @handle_method( method_tree="Sequential.__call__", - bs_c_target=st.sampled_from([ - ( - [1, 2], - 5, - [ + bs_c_target=st.sampled_from( + [ + ( + [1, 2], + 5, [ - [-0.34784955, 0.47909835, 0.7241975, -0.82175905, -0.43836743], - [-0.34784955, 0.47909835, 0.7241975, -0.82175905, -0.43836743], - ] - ], - ) - ]), + [ + [-0.34784955, 0.47909835, 0.7241975, -0.82175905, -0.43836743], + [-0.34784955, 0.47909835, 0.7241975, -0.82175905, -0.43836743], + ] + ], + ) + ] + ), with_v=st.booleans(), seq_v=st.booleans(), dtype=helpers.get_dtypes("float", full=False), @@ -1605,34 +1610,40 @@ def test_sequential_layer( if with_v: np.random.seed(0) wlim = (6 / (channels + channels)) ** 0.5 - v = Container({ - "submodules": { - "v0": { - "w": _variable( - ivy.array( - np.random.uniform(-wlim, wlim, (channels, channels)), - dtype=dtype, - device=on_device, - ) - ), - "b": _variable( - ivy.zeros([channels], device=on_device, dtype=dtype) - ), - }, - "v2": { - "w": _variable( - ivy.array( - np.random.uniform(-wlim, wlim, (channels, channels)), - dtype=dtype, - device=on_device, - ) - ), - "b": _variable( - ivy.zeros([channels], device=on_device, dtype=dtype) - ), - }, + v = Container( + { + "submodules": { + "v0": { + "w": _variable( + ivy.array( + np.random.uniform( + -wlim, wlim, (channels, channels) + ), + dtype=dtype, + device=on_device, + ) + ), + "b": _variable( + ivy.zeros([channels], device=on_device, dtype=dtype) + ), + }, + "v2": { + "w": _variable( + ivy.array( + np.random.uniform( + -wlim, wlim, (channels, channels) + ), + dtype=dtype, + device=on_device, + ) + ), + "b": _variable( + ivy.zeros([channels], device=on_device, dtype=dtype) + ), + }, + } } - }) + ) else: v = None if seq_v: @@ -1675,8 +1686,3 @@ def test_sequential_layer( assert np.allclose( ivy.to_numpy(seq(x)), np.array(target), rtol=tolerance_dict[dtype] ) - - -all_initializers = ( - all_constant_initializers + all_uniform_initializers + all_gaussian_initializers -) diff --git a/ivy_tests/test_ivy/test_stateful/test_modules.py b/ivy_tests/test_ivy/test_stateful/test_modules.py index 3a0c97444e38d..63bd2c069ccd0 100644 --- a/ivy_tests/test_ivy/test_stateful/test_modules.py +++ b/ivy_tests/test_ivy/test_stateful/test_modules.py @@ -513,21 +513,23 @@ def test_module_w_partial_v( ivy.linspace(ivy.zeros(batch_shape), ivy.ones(batch_shape), input_channels), "float32", ) - v = ivy.Container({ - "linear0": { - "b": _variable(ivy.random_uniform(shape=[64])), - "w": _variable(ivy.random_uniform(shape=[64, 4])), - }, - "linear1": { - "b": _variable(ivy.random_uniform(shape=[64])), - "w": _variable(ivy.random_uniform(shape=[64, 64])), - "extra": _variable(ivy.random_uniform(shape=[64, 64])), - }, - "linear2": { - "b": _variable(ivy.random_uniform(shape=[5])), - "w": _variable(ivy.random_uniform(shape=[5, 64])), - }, - }) + v = ivy.Container( + { + "linear0": { + "b": _variable(ivy.random_uniform(shape=[64])), + "w": _variable(ivy.random_uniform(shape=[64, 4])), + }, + "linear1": { + "b": _variable(ivy.random_uniform(shape=[64])), + "w": _variable(ivy.random_uniform(shape=[64, 64])), + "extra": _variable(ivy.random_uniform(shape=[64, 64])), + }, + "linear2": { + "b": _variable(ivy.random_uniform(shape=[5])), + "w": _variable(ivy.random_uniform(shape=[5, 64])), + }, + } + ) try: TrainableModule( input_channels, @@ -542,13 +544,17 @@ def test_module_w_partial_v( ) except ivy.utils.exceptions.IvyException: pass - v = ivy.Container({ - "linear0": { - "b": _variable(ivy.random_uniform(shape=[64])), - }, - "linear1": {"w": _variable(ivy.random_uniform(shape=[64, 64]))}, - "linear2": {"b": _variable(ivy.random_uniform(shape=[output_channels]))}, - }) + v = ivy.Container( + { + "linear0": { + "b": _variable(ivy.random_uniform(shape=[64])), + }, + "linear1": {"w": _variable(ivy.random_uniform(shape=[64, 64]))}, + "linear2": { + "b": _variable(ivy.random_uniform(shape=[output_channels])) + }, + } + ) try: TrainableModule(input_channels, output_channels, device=on_device, v=v) raise Exception( From ee2f1d5e81fe26135acaac778af010d9f1528e90 Mon Sep 17 00:00:00 2001 From: Nwaamaka Iduwe <110701338+Nwaamaka-Iduwe@users.noreply.github.com> Date: Sat, 9 Dec 2023 23:19:50 +0100 Subject: [PATCH 334/978] feat: implemeneted "argmin" sorting/searching method for JAX (#27457) Co-authored by: joaozenobio --- .../frontends/jax/numpy/searching_sorting.py | 53 +++++++++++++++++++ .../test_numpy/test_searching_sorting.py | 36 +++++++++++++ 2 files changed, 89 insertions(+) diff --git a/ivy/functional/frontends/jax/numpy/searching_sorting.py b/ivy/functional/frontends/jax/numpy/searching_sorting.py index bd692378a6749..8f8e43a8f85e5 100644 --- a/ivy/functional/frontends/jax/numpy/searching_sorting.py +++ b/ivy/functional/frontends/jax/numpy/searching_sorting.py @@ -8,6 +8,7 @@ ) from ivy.functional.frontends.numpy.func_wrapper import from_zero_dim_arrays_to_scalar from ivy.func_wrapper import ( + with_supported_device_and_dtypes, with_unsupported_dtypes, ) @@ -26,6 +27,58 @@ def argmax(a, axis=None, out=None, keepdims=False): return ivy.argmax(a, axis=axis, keepdims=keepdims, out=out, dtype=ivy.int64) +# argmin +@to_ivy_arrays_and_back +@with_supported_device_and_dtypes( + { + "0.4.20 and below": { + "cpu": ( + "int16", + "int32", + "int64", + "float32", + "float64", + "uint8", + "uint16", + "uint32", + "uint64", + ) + } + }, + "jax", +) +def argmin(a, axis=None, out=None, keepdims=None): + if a is not None: + if isinstance(a, list): + if all(isinstance(elem, ivy.Array) for elem in a): + if len(a) == 1: + a = a[0] + else: + return [ + ivy.argmin( + ivy.to_native_arrays(elem), + axis=axis, + out=out, + keepdims=keepdims, + ) + for elem in a + ] + else: + raise ValueError( + "Input 'a' must be an Ivy array or a list of Ivy arrays." + ) + + if not isinstance(a, ivy.Array): + raise TypeError("Input 'a' must be an array.") + + if a.size == 0: + raise ValueError("Input 'a' must not be empty.") + + return ivy.argmin(a, axis=axis, out=out, keepdims=keepdims) + else: + raise ValueError("argmin takes at least 1 argument.") + + @to_ivy_arrays_and_back def argsort(a, axis=-1, kind="stable", order=None): if kind != "stable": diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_searching_sorting.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_searching_sorting.py index 13800e80a63d3..36d88e4710ec2 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_searching_sorting.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_searching_sorting.py @@ -105,6 +105,42 @@ def test_jax_argmax( ) +# argmin +@handle_frontend_test( + fn_tree="jax.numpy.argmin", + dtype_and_x=helpers.dtype_values_axis( + available_dtypes=helpers.get_dtypes("valid"), + force_int_axis=True, + min_num_dims=1, + valid_axis=True, + ), + keepdims=st.booleans(), +) +def test_jax_argmin( + *, + dtype_and_x, + keepdims, + on_device, + fn_tree, + frontend, + backend_fw, + test_flags, +): + input_dtype, x, axis = dtype_and_x + helpers.test_frontend_function( + input_dtypes=input_dtype, + frontend=frontend, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + a=x[0], + axis=axis, + out=None, + keepdims=keepdims, + ) + + # argsort @handle_frontend_test( fn_tree="jax.numpy.argsort", From 369b7c0275b0986531b293597b9a03bf3d505e4a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 10 Dec 2023 12:10:19 +0530 Subject: [PATCH 335/978] fix: Broke down `assertion statements` into multiple parts for better `debugging` purposes (#27464) Co-authored-by: NripeshN --- ivy/functional/backends/jax/sorting.py | 4 +--- .../backends/numpy/experimental/elementwise.py | 3 ++- ivy/functional/backends/numpy/sorting.py | 4 +--- ivy/functional/backends/paddle/sorting.py | 4 +--- ivy/functional/backends/tensorflow/sorting.py | 4 +--- ivy/functional/backends/torch/sorting.py | 4 +--- .../test_functional/test_core/test_random.py | 6 ++++-- .../test_experimental/test_core/test_creation.py | 3 ++- .../test_experimental/test_core/test_random.py | 12 ++++++++---- 9 files changed, 21 insertions(+), 23 deletions(-) diff --git a/ivy/functional/backends/jax/sorting.py b/ivy/functional/backends/jax/sorting.py index a633b8044004a..525aadfe4f8fe 100644 --- a/ivy/functional/backends/jax/sorting.py +++ b/ivy/functional/backends/jax/sorting.py @@ -56,9 +56,7 @@ def searchsorted( "only Integer data types are supported for ret_dtype." ) if sorter is not None: - assert ivy.is_int_dtype(sorter.dtype) and not ivy.is_uint_dtype( - sorter.dtype - ), TypeError( + assert ivy.is_int_dtype(sorter.dtype), TypeError( f"Only signed integer data type for sorter is allowed, got {sorter.dtype}." ) x = jnp.take_along_axis(x, sorter, axis=-1) diff --git a/ivy/functional/backends/numpy/experimental/elementwise.py b/ivy/functional/backends/numpy/experimental/elementwise.py index d81989479ff5c..453d2bf862846 100644 --- a/ivy/functional/backends/numpy/experimental/elementwise.py +++ b/ivy/functional/backends/numpy/experimental/elementwise.py @@ -432,7 +432,8 @@ def digamma( def sinpi(x): y = np.abs(x) % 2.0 n = np.round(2.0 * y) - assert n >= 0 and n <= 4 + assert n >= 0 + assert n <= 4 if n == 0: r = np.sin(np.pi * y) diff --git a/ivy/functional/backends/numpy/sorting.py b/ivy/functional/backends/numpy/sorting.py index a79ffbd715153..e5422ecd43d8d 100644 --- a/ivy/functional/backends/numpy/sorting.py +++ b/ivy/functional/backends/numpy/sorting.py @@ -67,9 +67,7 @@ def searchsorted( ) is_sorter_provided = sorter is not None if is_sorter_provided: - assert ivy.is_int_dtype(sorter.dtype) and not ivy.is_uint_dtype( - sorter.dtype - ), TypeError( + assert ivy.is_int_dtype(sorter.dtype), TypeError( f"Only signed integer data type for sorter is allowed, got {sorter.dtype}." ) if x.ndim != 1: diff --git a/ivy/functional/backends/paddle/sorting.py b/ivy/functional/backends/paddle/sorting.py index 0585c975204f9..d46e9b1c7e5a4 100644 --- a/ivy/functional/backends/paddle/sorting.py +++ b/ivy/functional/backends/paddle/sorting.py @@ -57,9 +57,7 @@ def searchsorted( ) if sorter is not None: - assert ivy.is_int_dtype(sorter.dtype) and not ivy.is_uint_dtype( - sorter.dtype - ), TypeError( + assert ivy.is_int_dtype(sorter.dtype), TypeError( f"Only signed integer data type for sorter is allowed, got {sorter.dtype}." ) if ivy.as_native_dtype(sorter.dtype) not in [paddle.int32, paddle.int64]: diff --git a/ivy/functional/backends/tensorflow/sorting.py b/ivy/functional/backends/tensorflow/sorting.py index ee2b1d3ca997d..47dd6b6e1cbed 100644 --- a/ivy/functional/backends/tensorflow/sorting.py +++ b/ivy/functional/backends/tensorflow/sorting.py @@ -69,9 +69,7 @@ def searchsorted( ) is_supported_int_ret_dtype = ret_dtype in [tf.int32, tf.int64] if sorter is not None: - assert ivy.is_int_dtype(sorter.dtype) and not ivy.is_uint_dtype( - sorter.dtype - ), TypeError( + assert ivy.is_int_dtype(sorter.dtype), TypeError( f"Only signed integer data type for sorter is allowed, got {sorter.dtype}." ) if sorter.dtype not in [tf.int32, tf.int64]: diff --git a/ivy/functional/backends/torch/sorting.py b/ivy/functional/backends/torch/sorting.py index 7d5f34341267c..5bb6fcb9c51b5 100644 --- a/ivy/functional/backends/torch/sorting.py +++ b/ivy/functional/backends/torch/sorting.py @@ -77,9 +77,7 @@ def searchsorted( ) if sorter is not None: sorter_dtype = ivy.as_native_dtype(sorter.dtype) - assert ivy.is_int_dtype(sorter_dtype) and not ivy.is_uint_dtype( - sorter_dtype - ), TypeError( + assert ivy.is_int_dtype(sorter_dtype), TypeError( f"Only signed integer data type for sorter is allowed, got {sorter_dtype }." ) if sorter_dtype is not torch.int64: diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_random.py b/ivy_tests/test_ivy/test_functional/test_core/test_random.py index 13a6e7652448f..9d775b56477fe 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_random.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_random.py @@ -146,8 +146,10 @@ def call(): ret=ret_gt, backend=test_flags.ground_truth_backend ) for u, v in zip(ret, ret_gt): - assert ivy.all(u >= low) and ivy.all(u < high) - assert ivy.all(v >= low) and ivy.all(v < high) + assert ivy.all(u >= low) + assert ivy.all(u < high) + assert ivy.all(v >= low) + assert ivy.all(v < high) # random_normal diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_creation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_creation.py index 151cc3fcb344d..786b4475afb12 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_creation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_creation.py @@ -388,7 +388,8 @@ def test_ndenumerate(dtype_and_x): for (index1, x1), (index2, x2) in zip( np.ndenumerate(values), ivy.ndenumerate(values) ): - assert index1 == index2 and x1 == x2.to_numpy() + assert index1 == index2 + assert x1 == x2.to_numpy() # ndindex diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_random.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_random.py index 5f53a416ebd1a..730c1749af982 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_random.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_random.py @@ -84,8 +84,10 @@ def test_beta( ) with BackendHandler.update_backend(backend_fw) as ivy_backend: for u, v in zip(ret, ret_gt): - assert ivy_backend.all(u >= 0) and ivy_backend.all(u <= 1) - assert ivy_backend.all(v >= 0) and ivy_backend.all(v <= 1) + assert ivy_backend.all(u >= 0) + assert ivy_backend.all(u <= 1) + assert ivy_backend.all(v >= 0) + assert ivy_backend.all(v <= 1) # dirichlet @@ -139,8 +141,10 @@ def call(): assert ivy_backend.all( ivy_backend.sum(u, axis=-1) == ivy_backend.sum(v, axis=-1) ) - assert ivy_backend.all(u >= 0) and ivy_backend.all(u <= 1) - assert ivy_backend.all(v >= 0) and ivy_backend.all(v <= 1) + assert ivy_backend.all(u >= 0) + assert ivy_backend.all(u <= 1) + assert ivy_backend.all(v >= 0) + assert ivy_backend.all(v <= 1) # gamma From 010eaf45f046cfeca9c5a5a3ae15c074677bae01 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sun, 10 Dec 2023 11:19:11 +0400 Subject: [PATCH 336/978] Update optional_apple_silicon_2.txt --- requirements/optional_apple_silicon_2.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements/optional_apple_silicon_2.txt b/requirements/optional_apple_silicon_2.txt index 7a3325ede80c3..8891f94d942d8 100644 --- a/requirements/optional_apple_silicon_2.txt +++ b/requirements/optional_apple_silicon_2.txt @@ -11,3 +11,4 @@ pandas pyspark autoflake # for backend generation snakeviz # for profiling +ml-dtypes==0.2.0 From 3d8175d486636c15ec0b03bf9886ea5423296593 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sun, 10 Dec 2023 11:48:26 +0400 Subject: [PATCH 337/978] Update optional_apple_silicon_2.txt --- requirements/optional_apple_silicon_2.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements/optional_apple_silicon_2.txt b/requirements/optional_apple_silicon_2.txt index 8891f94d942d8..8deb0b3a7d599 100644 --- a/requirements/optional_apple_silicon_2.txt +++ b/requirements/optional_apple_silicon_2.txt @@ -1,5 +1,4 @@ torch-scatter # torch_scatter requires a prior existing installation of torch, hence 2 optional files -functorch scipy dm-haiku # mod_name=haiku flax From 66b4c9ef73f8818842f8b06b6c5de21317e5d3dd Mon Sep 17 00:00:00 2001 From: ksheroz <87086877+ksheroz@users.noreply.github.com> Date: Mon, 11 Dec 2023 01:11:45 +0500 Subject: [PATCH 338/978] feat: Paddle Frontend: tensor __lt__ (#27651) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 16 ++++++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index e18f35a224a08..28af9753bfeb8 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -105,6 +105,22 @@ def __mul__(self, y, /, name=None): def __gt__(self, y, /, name=None): return paddle_frontend.logic.greater_than(self, y) + @with_unsupported_dtypes( + { + "2.5.2 and below": ( + "bool", + "uint8", + "int8", + "int16", + "complex64", + "complex128", + ) + }, + "paddle", + ) + def __lt__(self, y, /, name=None): + return paddle_frontend.logic.less_than(self, y) + @with_unsupported_dtypes( { "2.5.2 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 5a911e9595be9..cdd2de8a7127b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -462,6 +462,43 @@ def test_paddle___le__( ) +# __lt__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__lt__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___lt__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __mul__ @handle_frontend_method( class_tree=CLASS_TREE, From 212904d017aac35f6f92875cde266598a36af288 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 11 Dec 2023 10:12:54 +0000 Subject: [PATCH 339/978] fix: remove the parameter mismatch in test_unique_inverse --- ivy_tests/test_ivy/test_functional/test_core/test_set.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_set.py b/ivy_tests/test_ivy/test_functional/test_core/test_set.py index 69f9be2fbf241..a401e5d063805 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_set.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_set.py @@ -70,17 +70,19 @@ def test_unique_counts(*, dtype_and_x, test_flags, backend_fw, fn_name, on_devic # unique_inverse @handle_test( fn_tree="functional.ivy.unique_inverse", - dtype_and_x=helpers.dtype_and_values( + dtype_x_axis=helpers.dtype_values_axis( available_dtypes=helpers.get_dtypes("valid"), min_num_dims=2, min_dim_size=2, + force_int_axis=True, + valid_axis=True, ), test_with_out=st.just(False), test_gradients=st.just(False), ) def test_unique_inverse(*, dtype_x_axis, test_flags, backend_fw, fn_name, on_device): dtype, x, axis = dtype_x_axis - assume(not np.any(np.isclose(x, 0.0), axis=axis)) + assume(not np.any(np.any(np.isclose(x[0], 0.0), axis=axis))) helpers.test_function( input_dtypes=dtype, From 835fa3709a01c2845b5d10b225ea88ed48aeaa6b Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 11 Dec 2023 10:58:17 +0000 Subject: [PATCH 340/978] fix: only update number of classes when n_output is one in decision tree classfier based on https://github.com/scikit-learn/scikit-learn/blob/0496f4877c2e6e7f050d573284001cc2ecdbbcf7/sklearn/tree/_classes.py#L474 --- ivy/functional/frontends/sklearn/tree/_classes.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_classes.py b/ivy/functional/frontends/sklearn/tree/_classes.py index 109887524d374..9880d8d6d7486 100644 --- a/ivy/functional/frontends/sklearn/tree/_classes.py +++ b/ivy/functional/frontends/sklearn/tree/_classes.py @@ -132,8 +132,9 @@ def _fit( self.min_impurity_decrease, ) builder.build(self.tree_, X, y, sample_weight, missing_values_in_feature_mask) - self.n_classes_ = self.n_classes_[0] - self.classes_ = self.classes_[0] + if self.n_outputs_ == 1: + self.n_classes_ = self.n_classes_[0] + self.classes_ = self.classes_[0] return self def predict(self, X, check_input=True): From 95a288a786d0d6b0e0216aae379265b9c0d7d8d3 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 11 Dec 2023 17:31:56 +0530 Subject: [PATCH 341/978] feat: Added the data_format argument to ivy.adaptive_avg_pool2d to allow channel last input passed to the function, similar to other conv and pooling layers. (#27732) --- ivy/data_classes/array/experimental/layers.py | 10 ++++-- .../container/experimental/layers.py | 14 ++++++-- .../backends/torch/experimental/layers.py | 15 +++++++-- .../mindspore/ops/function/nn_func.py | 2 +- .../frontends/paddle/nn/functional/pooling.py | 2 +- .../torch/nn/functional/pooling_functions.py | 2 +- ivy/functional/ivy/experimental/layers.py | 32 ++++++++++++++++--- ivy/stateful/layers.py | 9 ++++-- .../test_experimental/test_nn/test_layers.py | 6 ++-- .../test_ivy/test_stateful/test_layers.py | 8 +++-- 10 files changed, 78 insertions(+), 22 deletions(-) diff --git a/ivy/data_classes/array/experimental/layers.py b/ivy/data_classes/array/experimental/layers.py index 5ca1f26c26d36..257b29e8d766e 100644 --- a/ivy/data_classes/array/experimental/layers.py +++ b/ivy/data_classes/array/experimental/layers.py @@ -824,6 +824,9 @@ def adaptive_avg_pool1d( def adaptive_avg_pool2d( self: ivy.Array, output_size: Union[Sequence[int], int], + /, + *, + data_format: str = "NHWC", ) -> ivy.Array: """Apply a 2D adaptive average pooling over an input signal composed of several input planes. @@ -831,11 +834,11 @@ def adaptive_avg_pool2d( Parameters ---------- self - Input array. Must have shape (N, C, H_in, W_in) or (C, H_in, W_in) where N - is the batch dimension, C is the feature dimension, and H_in and W_in are - the 2 spatial dimensions. + A 3D or 4D input array. Should have a floating-point data type. output_size Spatial output size. + data_format + "NHWC" or "NCHW". Defaults to "NHWC". Returns ------- @@ -845,6 +848,7 @@ def adaptive_avg_pool2d( return ivy.adaptive_avg_pool2d( self._data, output_size, + data_format=data_format, ) def adaptive_max_pool2d( diff --git a/ivy/data_classes/container/experimental/layers.py b/ivy/data_classes/container/experimental/layers.py index 023cf2554bfd6..cc980962c2e48 100644 --- a/ivy/data_classes/container/experimental/layers.py +++ b/ivy/data_classes/container/experimental/layers.py @@ -1868,11 +1868,13 @@ def adaptive_avg_pool1d( def static_adaptive_avg_pool2d( input: Union[ivy.Array, ivy.NativeArray, ivy.Container], output_size: Union[Sequence[int], int, ivy.Container], + /, *, key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, to_apply: Union[bool, ivy.Container] = True, prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, + data_format: str = "NHWC", ) -> ivy.Container: """ivy.Container static method variant of ivy.adaptive_avg_pool2d. This method simply wraps the function, and so the docstring for @@ -1882,11 +1884,11 @@ def static_adaptive_avg_pool2d( Parameters ---------- input - Input array. Must have shape (N, C, H_in, W_in) or (C, H_in, W_in) where N - is the batch dimension, C is the feature dimension, and H_in and W_in are - the 2 spatial dimensions. + A 3D or 4D input array. Should have a floating-point data type. output_size Spatial output size. + data_format + "NHWC" or "NCHW". Defaults to "NHWC". Returns ------- @@ -1901,16 +1903,19 @@ def static_adaptive_avg_pool2d( to_apply=to_apply, prune_unapplied=prune_unapplied, map_sequences=map_sequences, + data_format=data_format, ) def adaptive_avg_pool2d( self: ivy.Container, output_size: Union[int, ivy.Container], + /, *, key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, to_apply: Union[bool, ivy.Container] = True, prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, + data_format: str = "NHWC", ) -> ivy.Container: """Apply a 2D adaptive average pooling over an input signal composed of several input planes. @@ -1921,6 +1926,8 @@ def adaptive_avg_pool2d( Input container. output_size Spatial output size. + data_format + "NHWC" or "NCHW". Defaults to "NHWC". Returns ------- @@ -1933,6 +1940,7 @@ def adaptive_avg_pool2d( to_apply=to_apply, prune_unapplied=prune_unapplied, map_sequences=map_sequences, + data_format=data_format, ) @staticmethod diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 09776b38d44aa..6439e66caf418 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -967,8 +967,19 @@ def adaptive_avg_pool1d(input, output_size): @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) -def adaptive_avg_pool2d(input, output_size): - return torch.nn.functional.adaptive_avg_pool2d(input, output_size) +def adaptive_avg_pool2d(input, output_size, /, *, data_format: str = "NHWC"): + squeeze = False + if input.ndim == 3: + input = torch.unsqueeze(input, 0) + squeeze = True + permuted_input = False + if data_format == "NHWC": + input = torch.permute(input, (0, input.ndim - 1, *range(1, input.ndim - 1))) + permuted_input = True + ret = torch.nn.functional.adaptive_avg_pool2d(input, output_size) + ret = torch.permute(ret, (0, *range(2, input.ndim), 1)) if permuted_input else ret + ret = torch.squeeze(ret, 0) if squeeze else ret + return ret @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index 75f67235c7391..864119a245bc0 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -105,7 +105,7 @@ def _valid_shapes(input, weight, bias, stride, padding, groups, transpose=False) ) @to_ivy_arrays_and_back def adaptive_avg_pool2d(input, output_size): - return ivy.adaptive_avg_pool2d(input, output_size) + return ivy.adaptive_avg_pool2d(input, output_size, data_format="NCHW") @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index ddb7dc569d8d6..b79af86a25392 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -15,7 +15,7 @@ def adaptive_avg_pool1d(x, output_size, name=None): @to_ivy_arrays_and_back @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") def adaptive_avg_pool2d(x, output_size, data_format="NCHW", name=None): - return ivy.adaptive_avg_pool2d(x, output_size) + return ivy.adaptive_avg_pool2d(x, output_size, data_format=data_format) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 5b5becf55fd29..4b32c2627096a 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -34,7 +34,7 @@ def adaptive_avg_pool1d(input, output_size): ) @to_ivy_arrays_and_back def adaptive_avg_pool2d(input, output_size): - return ivy.adaptive_avg_pool2d(input, output_size) + return ivy.adaptive_avg_pool2d(input, output_size, data_format="NCHW") @with_unsupported_dtypes( diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index f8a122fb53e84..3408fb8eba801 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -2265,6 +2265,9 @@ def adaptive_avg_pool1d( def adaptive_avg_pool2d( input: Union[ivy.Array, ivy.NativeArray], output_size: Union[Sequence[int], int], + /, + *, + data_format: str = "NHWC", ) -> ivy.Array: """Apply a 2D adaptive average pooling over an input signal composed of several input planes. @@ -2272,11 +2275,11 @@ def adaptive_avg_pool2d( Parameters ---------- input - Input array. Must have shape (N, C, H_in, W_in) or (C, H_in, W_in) where N is - the batch dimension, C is the feature dimension, and H_in and W_in are the 2 - spatial dimensions. + A 3D or 4D input array. Should have a floating-point data type. output_size Spatial output size. + data_format + "NHWC" or "NCHW". Defaults to "NHWC". Returns ------- @@ -2292,6 +2295,12 @@ def adaptive_avg_pool2d( f"Got {len(input.shape)}D input, but only 3D and 4D inputs are supported.", ) + permuted_input = False + if data_format == "NHWC": + input = ivy.permute_dims(input, (0, input.ndim - 1, *range(1, input.ndim - 1))) + data_format = "NCHW" + permuted_input = True + if isinstance(output_size, int): output_size = (output_size, output_size) @@ -2301,6 +2310,11 @@ def adaptive_avg_pool2d( pooled_output = ivy.avg_pool2d( input, kernel_size, stride, "VALID", data_format="NCHW" ) + pooled_output = ( + ivy.permute_dims(pooled_output, (0, *range(2, input.ndim), 1)) + if permuted_input + else pooled_output + ) if squeeze: return ivy.squeeze(pooled_output, axis=0) return pooled_output @@ -2313,10 +2327,15 @@ def adaptive_avg_pool2d( ) # to numpy and back in order to bypass a slicing error in tensorflow - vals = ivy.array(input.to_numpy()[..., _expand_to_dim(idxh, 4), idxw]) + vals = input[..., _expand_to_dim(idxh, 4), idxw] if not adaptive_h and not adaptive_w: ret = ivy.mean(vals, axis=(-3, -1)) + ret = ( + ivy.permute_dims(ret, (0, *range(2, input.ndim), 1)) + if permuted_input + else ret + ) ret = ivy.squeeze(ret, axis=0) if squeeze else ret return ret @@ -2331,6 +2350,11 @@ def adaptive_avg_pool2d( ret = ret + vals[..., i, :, j] pooled_output = ret / (length_h * length_w).astype(vals.dtype) + pooled_output = ( + ivy.permute_dims(pooled_output, (0, *range(2, input.ndim), 1)) + if permuted_input + else pooled_output + ) pooled_output = ivy.squeeze(pooled_output, axis=0) if squeeze else pooled_output return pooled_output diff --git a/ivy/stateful/layers.py b/ivy/stateful/layers.py index aa4460e699b3e..e2cad240cccf8 100644 --- a/ivy/stateful/layers.py +++ b/ivy/stateful/layers.py @@ -1999,6 +1999,9 @@ class AdaptiveAvgPool2d(Module): def __init__( self, output_size, + /, + *, + data_format="NHWC", device=None, dtype=None, ): @@ -2009,10 +2012,13 @@ def __init__( ---------- output_size the target output size of the image. + data_format + NHWC" or "NCHW". Defaults to "NHWC". device device on which to create the layer's variables 'cuda:0', 'cuda:1', 'cpu' """ self._output_size = output_size + self._data_format = data_format Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): @@ -2030,8 +2036,7 @@ def _forward(self, x): # TODO: test again once adaptive_avg_pool2d is # implemented for the missing backends. return ivy.adaptive_avg_pool2d( - x, - self._output_size, + x, self._output_size, data_format=self._data_format ) def _extra_repr(self): diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index e02a2e1b49101..1425e1eaf79fe 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -502,7 +502,7 @@ def test_adaptive_avg_pool1d( available_dtypes=helpers.get_dtypes("float"), min_num_dims=3, max_num_dims=4, - min_dim_size=1, + min_dim_size=2, max_value=100, min_value=-100, ), @@ -513,11 +513,12 @@ def test_adaptive_avg_pool1d( ), helpers.ints(min_value=1, max_value=5), ), + data_format=st.sampled_from(["NCHW", "NHWC"]), test_with_out=st.just(False), ground_truth_backend="torch", ) def test_adaptive_avg_pool2d( - *, dtype_and_x, output_size, test_flags, backend_fw, fn_name, on_device + *, dtype_and_x, output_size, data_format, test_flags, backend_fw, fn_name, on_device ): input_dtype, x = dtype_and_x helpers.test_function( @@ -528,6 +529,7 @@ def test_adaptive_avg_pool2d( fn_name=fn_name, input=x[0], output_size=output_size, + data_format=data_format, ) diff --git a/ivy_tests/test_ivy/test_stateful/test_layers.py b/ivy_tests/test_ivy/test_stateful/test_layers.py index 40d1425775ed7..a315c74766451 100644 --- a/ivy_tests/test_ivy/test_stateful/test_layers.py +++ b/ivy_tests/test_ivy/test_stateful/test_layers.py @@ -278,7 +278,8 @@ def array_for_adaptive( ) ) output_size = size[0] if num_out_size == 1 else size - return dtypes, arrays, output_size + data_format = draw(st.sampled_from(["NCHW", "NHWC"])) + return dtypes, arrays, output_size, data_format # --- Main --- # @@ -301,7 +302,7 @@ def test_adaptive_avg_pool1d_layer( method_flags, backend_fw, ): - input_dtype, x, out_size = dt_arr_size + input_dtype, x, out_size, _ = dt_arr_size helpers.test_method( ground_truth_backend=ground_truth_backend, backend_to_test=backend_fw, @@ -337,7 +338,7 @@ def test_adaptive_avg_pool2d_layer( method_flags, backend_fw, ): - input_dtype, x, out_size = dt_arr_size + input_dtype, x, out_size, data_format = dt_arr_size helpers.test_method( ground_truth_backend=ground_truth_backend, backend_to_test=backend_fw, @@ -345,6 +346,7 @@ def test_adaptive_avg_pool2d_layer( method_flags=method_flags, init_all_as_kwargs_np={ "output_size": out_size, + "data_format": data_format, "device": on_device, "dtype": input_dtype[0], }, From ef98ac9ab4425c1a8f57cd283bead11520861866 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 11 Dec 2023 17:35:50 +0530 Subject: [PATCH 342/978] fix: Added version-specific implementations to vmap and uncommented torch-scatter (#27440) Co-authored-by: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Co-authored-by: NripeshN --- .../requirement_mappings_apple_silicon.json | 2 +- ivy/functional/backends/torch/general.py | 20 ++++++++++++++++++- requirements/optional.txt | 3 +-- requirements/optional_apple_silicon_gpu_2.txt | 2 +- requirements/optional_gpu.txt | 1 - 5 files changed, 22 insertions(+), 6 deletions(-) diff --git a/docker/requirement_mappings_apple_silicon.json b/docker/requirement_mappings_apple_silicon.json index ea1d78d80539d..789a2e6e36789 100644 --- a/docker/requirement_mappings_apple_silicon.json +++ b/docker/requirement_mappings_apple_silicon.json @@ -1,6 +1,6 @@ { "tensorflow": ["tensorflow-macos", "tensorflow-probability"], "jax": ["jaxlib", "dm-haiku", "flax"], - "torch": ["torch-scatter", "functorch"], + "torch": ["torch-scatter"], "mxnet": ["mxnet"] } diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index af7bc2d70daa4..0d7e18ca1de49 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -514,7 +514,7 @@ def shape( @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) -def vmap( +def vmap_v_1p13p1_and_below( func: Callable, in_axes: Union[int, Sequence[int], Sequence[None]] = 0, out_axes: int = 0, @@ -531,6 +531,24 @@ def new_fun(*args): return _vmap +@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) +def vmap_v_2p0p0_and_above( + func: Callable, + in_axes: Union[int, Sequence[int], Sequence[None]] = 0, + out_axes: int = 0, +) -> Callable: + @ivy.output_to_native_arrays + @ivy.inputs_to_native_arrays + def _vmap(*args): + def new_fun(*args): + return ivy.to_native(func(*args)) + + new_func = torch.vmap(new_fun, in_axes, out_axes) + return new_func(*args) + + return _vmap + + @with_unsupported_dtypes( {"2.1.1 and below": ("bfloat16", "float16", "complex", "bool")}, backend_version ) diff --git a/requirements/optional.txt b/requirements/optional.txt index e34585650624e..a86e4aab24dfb 100644 --- a/requirements/optional.txt +++ b/requirements/optional.txt @@ -11,8 +11,7 @@ jaxlib # unpinned, we test for latest version now paddlepaddle # unpinned , mod_name=paddle tensorflow-cpu # unpinned, we test for latest version now, mod_name=tensorflow torch # unpinned, we test for latest version now -# torch-scatter # unpinned, mod_name=torch_scatter -functorch # unpinned, we test for latest version now +torch-scatter # unpinned, mod_name=torch_scatter scipy # unpinned dm-haiku # unpinned mod_name=haiku flax diff --git a/requirements/optional_apple_silicon_gpu_2.txt b/requirements/optional_apple_silicon_gpu_2.txt index 7a3325ede80c3..8deb0b3a7d599 100644 --- a/requirements/optional_apple_silicon_gpu_2.txt +++ b/requirements/optional_apple_silicon_gpu_2.txt @@ -1,5 +1,4 @@ torch-scatter # torch_scatter requires a prior existing installation of torch, hence 2 optional files -functorch scipy dm-haiku # mod_name=haiku flax @@ -11,3 +10,4 @@ pandas pyspark autoflake # for backend generation snakeviz # for profiling +ml-dtypes==0.2.0 diff --git a/requirements/optional_gpu.txt b/requirements/optional_gpu.txt index 0810e836b9ba1..38ae84c72f26f 100644 --- a/requirements/optional_gpu.txt +++ b/requirements/optional_gpu.txt @@ -11,7 +11,6 @@ jaxlib # unpinned, we test for latest version now tensorflow # unpinned, we test for latest version now torch # unpinned, we test for latest version now torch-scatter # unpinned, mod_name=torch_scatter -functorch # unpinned, we test for latest version now scipy # unpinned dm-haiku # unpinned mod_name=haiku flax From 06c92e6435ab7b776a43bf1d33c3b37205bc60ed Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 11 Dec 2023 18:24:09 +0530 Subject: [PATCH 343/978] fix: Fixed arguments in `staticmethod` (#27467) --- ivy/data_classes/container/general.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/data_classes/container/general.py b/ivy/data_classes/container/general.py index 860fc6b0e57f2..e372a016796d4 100644 --- a/ivy/data_classes/container/general.py +++ b/ivy/data_classes/container/general.py @@ -1545,7 +1545,7 @@ def gather( @staticmethod def _static_has_nans( - self: ivy.Container, + x: ivy.Container, /, *, include_infs: Union[bool, ivy.Container] = True, @@ -1560,7 +1560,7 @@ def _static_has_nans( Parameters ---------- - self + x The container to check for nans. include_infs Whether to include infs and -infs in the check. Default is True. @@ -1593,7 +1593,7 @@ def _static_has_nans( """ return ContainerBase.cont_multi_map_in_function( "has_nans", - self, + x, include_infs=include_infs, key_chains=key_chains, to_apply=to_apply, From 01c6946ce5ebcab110304bca92a9837870a2cda7 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 11 Dec 2023 18:47:33 +0530 Subject: [PATCH 344/978] fix: Fixed raising `TypeError` instead or `ValueError` (#27736) --- ivy/functional/backends/jax/experimental/losses.py | 2 +- ivy/functional/backends/numpy/experimental/creation.py | 2 +- ivy/functional/backends/numpy/experimental/elementwise.py | 2 +- ivy/functional/backends/numpy/experimental/losses.py | 2 +- ivy/functional/backends/numpy/sorting.py | 2 +- ivy/functional/backends/paddle/experimental/creation.py | 2 +- ivy/functional/backends/paddle/sorting.py | 2 +- ivy/functional/backends/tensorflow/experimental/losses.py | 2 +- ivy/functional/backends/tensorflow/sorting.py | 2 +- ivy/functional/backends/torch/experimental/creation.py | 2 +- ivy/functional/backends/torch/sorting.py | 2 +- ivy/functional/frontends/numpy/ndarray/ndarray.py | 2 +- ivy/functional/frontends/torch/creation_ops.py | 2 +- ivy/utils/assertions.py | 2 +- 14 files changed, 14 insertions(+), 14 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/losses.py b/ivy/functional/backends/jax/experimental/losses.py index 5b39d166bc5ff..b03072f362d7b 100644 --- a/ivy/functional/backends/jax/experimental/losses.py +++ b/ivy/functional/backends/jax/experimental/losses.py @@ -83,7 +83,7 @@ def _validate_poisson_nll_params( # Validate dtypes for parameter, name in zip([input, label], ["input", "label"]): if parameter.dtype not in allowed_dtypes: - raise ValueError( + raise TypeError( "The dtype of '%s' in poisson_nll_loss should be one of %s, but" " received %s." % (name, allowed_dtypes, parameter.dtype) ) diff --git a/ivy/functional/backends/numpy/experimental/creation.py b/ivy/functional/backends/numpy/experimental/creation.py index 97d6325605a41..8add9faa6c67e 100644 --- a/ivy/functional/backends/numpy/experimental/creation.py +++ b/ivy/functional/backends/numpy/experimental/creation.py @@ -98,7 +98,7 @@ def unsorted_segment_min( elif data.dtype in [np.int32, np.int64, np.int8, np.int16, np.uint8]: init_val = np.iinfo(data.dtype).max else: - raise ValueError("Unsupported data type") + raise TypeError("Unsupported data type") res = np.full((num_segments,) + data.shape[1:], init_val, dtype=data.dtype) diff --git a/ivy/functional/backends/numpy/experimental/elementwise.py b/ivy/functional/backends/numpy/experimental/elementwise.py index 453d2bf862846..47fed86917172 100644 --- a/ivy/functional/backends/numpy/experimental/elementwise.py +++ b/ivy/functional/backends/numpy/experimental/elementwise.py @@ -571,7 +571,7 @@ def erfc( out: Optional[np.ndarray] = None, ) -> np.ndarray: if x.dtype not in [np.float16, np.float32, np.float64]: - raise ValueError("Input must be of type float16, float32, or float64.") + raise TypeError("Input must be of type float16, float32, or float64.") input_dtype = x.dtype diff --git a/ivy/functional/backends/numpy/experimental/losses.py b/ivy/functional/backends/numpy/experimental/losses.py index bf34147ac80ec..25c01279aa54d 100644 --- a/ivy/functional/backends/numpy/experimental/losses.py +++ b/ivy/functional/backends/numpy/experimental/losses.py @@ -97,7 +97,7 @@ def _validate_poisson_nll_params( # Validate dtypes for parameter, name in zip([input, label], ["input", "label"]): if parameter.dtype not in allowed_dtypes: - raise ValueError( + raise TypeError( f"The dtype of '{name}' in poisson_nll_loss should be one of" f" {allowed_dtypes}, but received {parameter.dtype}." ) diff --git a/ivy/functional/backends/numpy/sorting.py b/ivy/functional/backends/numpy/sorting.py index e5422ecd43d8d..bbc49f1076797 100644 --- a/ivy/functional/backends/numpy/sorting.py +++ b/ivy/functional/backends/numpy/sorting.py @@ -62,7 +62,7 @@ def searchsorted( ret_dtype: np.dtype = np.int64, out: Optional[np.ndarray] = None, ) -> np.ndarray: - assert ivy.is_int_dtype(ret_dtype), ValueError( + assert ivy.is_int_dtype(ret_dtype), TypeError( "only Integer data types are supported for ret_dtype." ) is_sorter_provided = sorter is not None diff --git a/ivy/functional/backends/paddle/experimental/creation.py b/ivy/functional/backends/paddle/experimental/creation.py index 4a0da45868140..6dedf411c06a7 100644 --- a/ivy/functional/backends/paddle/experimental/creation.py +++ b/ivy/functional/backends/paddle/experimental/creation.py @@ -115,7 +115,7 @@ def unsorted_segment_min( elif data.dtype == paddle.int64: init_val = 9223372036854775807 else: - raise ValueError("Unsupported data type") + raise TypeError("Unsupported data type") # Using paddle.full is causing integer overflow for int64 res = paddle.empty((num_segments,) + tuple(data.shape[1:]), dtype=data.dtype) res[:] = init_val diff --git a/ivy/functional/backends/paddle/sorting.py b/ivy/functional/backends/paddle/sorting.py index d46e9b1c7e5a4..26d78dbe0cc06 100644 --- a/ivy/functional/backends/paddle/sorting.py +++ b/ivy/functional/backends/paddle/sorting.py @@ -52,7 +52,7 @@ def searchsorted( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: right = True if side == "right" else False - assert ivy.is_int_dtype(ret_dtype), ValueError( + assert ivy.is_int_dtype(ret_dtype), TypeError( "only Integer data types are supported for ret_dtype." ) diff --git a/ivy/functional/backends/tensorflow/experimental/losses.py b/ivy/functional/backends/tensorflow/experimental/losses.py index cffbd02cee440..3994af1646866 100644 --- a/ivy/functional/backends/tensorflow/experimental/losses.py +++ b/ivy/functional/backends/tensorflow/experimental/losses.py @@ -87,7 +87,7 @@ def _validate_poisson_nll_params( # Validate dtypes for parameter, name in zip([input, label], ["input", "label"]): if parameter.dtype not in allowed_dtypes: - raise ValueError( + raise TypeError( f"The dtype of '{name}' in poisson_nll_loss should be one of" f" {allowed_dtypes}, but received {parameter.dtype}." ) diff --git a/ivy/functional/backends/tensorflow/sorting.py b/ivy/functional/backends/tensorflow/sorting.py index 47dd6b6e1cbed..2d24b032d2643 100644 --- a/ivy/functional/backends/tensorflow/sorting.py +++ b/ivy/functional/backends/tensorflow/sorting.py @@ -64,7 +64,7 @@ def searchsorted( ret_dtype: tf.DType = tf.int64, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - assert ivy.is_int_dtype(ret_dtype), ValueError( + assert ivy.is_int_dtype(ret_dtype), TypeError( "only Integer data types are supported for ret_dtype." ) is_supported_int_ret_dtype = ret_dtype in [tf.int32, tf.int64] diff --git a/ivy/functional/backends/torch/experimental/creation.py b/ivy/functional/backends/torch/experimental/creation.py index 09ce3fbd05694..73252430cd783 100644 --- a/ivy/functional/backends/torch/experimental/creation.py +++ b/ivy/functional/backends/torch/experimental/creation.py @@ -139,7 +139,7 @@ def unsorted_segment_min( elif data.dtype in [torch.int32, torch.int64, torch.int8, torch.int16, torch.uint8]: init_val = torch.iinfo(data.dtype).max else: - raise ValueError("Unsupported data type") + raise TypeError("Unsupported data type") res = torch.full( (num_segments,) + data.shape[1:], init_val, dtype=data.dtype, device=data.device diff --git a/ivy/functional/backends/torch/sorting.py b/ivy/functional/backends/torch/sorting.py index 5bb6fcb9c51b5..f9c9a829966f0 100644 --- a/ivy/functional/backends/torch/sorting.py +++ b/ivy/functional/backends/torch/sorting.py @@ -72,7 +72,7 @@ def searchsorted( ret_dtype: torch.dtype = torch.int64, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: - assert ivy.is_int_dtype(ret_dtype), ValueError( + assert ivy.is_int_dtype(ret_dtype), TypeError( "only Integer data types are supported for ret_dtype." ) if sorter is not None: diff --git a/ivy/functional/frontends/numpy/ndarray/ndarray.py b/ivy/functional/frontends/numpy/ndarray/ndarray.py index 31ff643ec4888..8aeab75ad40dc 100644 --- a/ivy/functional/frontends/numpy/ndarray/ndarray.py +++ b/ivy/functional/frontends/numpy/ndarray/ndarray.py @@ -732,7 +732,7 @@ def _unsigned_int_bytes_repr(item_val, /, *, dtype=None): elif ivy.is_uint_dtype(dtype): return _unsigned_int_bytes_repr(scalar_value, dtype=dtype) else: - raise ValueError("Unsupported data type for the array.") + raise TypeError("Unsupported data type for the array.") else: if order == "F": array = np_frontend.ravel(array, order="F").ivy_array diff --git a/ivy/functional/frontends/torch/creation_ops.py b/ivy/functional/frontends/torch/creation_ops.py index 866d4a9cb0459..59db82c4b8e15 100644 --- a/ivy/functional/frontends/torch/creation_ops.py +++ b/ivy/functional/frontends/torch/creation_ops.py @@ -82,7 +82,7 @@ def complex( *, out=None, ): - assert real.dtype == imag.dtype, ValueError( + assert real.dtype == imag.dtype, TypeError( "Expected real and imag to have the same dtype, " f" but got real.dtype = {real.dtype} and imag.dtype = {imag.dtype}." ) diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index 77f4cce892390..3e3de358e8884 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -211,7 +211,7 @@ def check_unsorted_segment_valid_params(data, segment_ids, num_segments): num_segments = num_segments.item() if segment_ids.dtype not in valid_dtypes: - raise ValueError("segment_ids must have an integer dtype") + raise TypeError("segment_ids must have an integer dtype") if data.shape[0] != segment_ids.shape[0]: raise ValueError("The length of segment_ids should be equal to data.shape[0].") From c27622c7f6affa12d9f136008702170181aa9207 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 11 Dec 2023 15:35:51 +0000 Subject: [PATCH 345/978] feat: add tree pruning method in decision tree classifier based on https://github.com/scikit-learn/scikit-learn/blob/3b06962d280f8776e3e94c7aed862081a82a9cc6/sklearn/tree/_classes.py#L609 --- ivy/functional/frontends/sklearn/tree/_classes.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_classes.py b/ivy/functional/frontends/sklearn/tree/_classes.py index 9880d8d6d7486..acc2702bd8c64 100644 --- a/ivy/functional/frontends/sklearn/tree/_classes.py +++ b/ivy/functional/frontends/sklearn/tree/_classes.py @@ -135,8 +135,16 @@ def _fit( if self.n_outputs_ == 1: self.n_classes_ = self.n_classes_[0] self.classes_ = self.classes_[0] + self._prune_tree() return self + def _prune_tree(self): + if self.ccp_alpha == 0.0: + return + n_classes = ivy.atleast_1d(self.n_classes_) + pruned_tree = Tree(self.n_features_in_, n_classes, self.n_outputs_) + self.tree_ = pruned_tree + def predict(self, X, check_input=True): proba = self.tree_.predict(X) n_samples = X.shape[0] From cdaaabcf1d4b640f0897dded4f7a85f605bea19c Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 11 Dec 2023 15:43:27 +0000 Subject: [PATCH 346/978] feat: add sum_missing inititializer for classification criterion --- ivy/functional/frontends/sklearn/tree/_criterion.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index 092552ceeac3b..b7c791875b283 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -105,6 +105,11 @@ def init( self.reset() return 0 + def init_sum_missing(self): + self.sum_missing = ivy.zeros( + (self.n_outputs, self.max_n_classes), dtype=ivy.float64 + ) + def reset(self): self.pos = self.start ( From 5e9482bde186d1e067a6e59239e3358b8da6c5c3 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 11 Dec 2023 15:46:24 +0000 Subject: [PATCH 347/978] feat: add missing values initializer and with usage in node_split_best function based on https://github.com/scikit-learn/scikit-learn/blob/3b06962d280f8776e3e94c7aed862081a82a9cc6/sklearn/tree/_criterion.pyx#L424 --- .../frontends/sklearn/tree/_criterion.py | 18 ++++++++++++++++++ .../frontends/sklearn/tree/_splitter.py | 1 + 2 files changed, 19 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index b7c791875b283..01a4d425b8f77 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -110,6 +110,24 @@ def init_sum_missing(self): (self.n_outputs, self.max_n_classes), dtype=ivy.float64 ) + def init_missing(self, n_missing): + w = 1.0 + self.n_missing = n_missing + if n_missing == 0: + return + self.sum_missing[0 : self.n_outputs, 0 : self.max_n_classes] = 0 + self.weighted_n_missing = 0.0 + for p in range(self.end - n_missing, self.end): + i = self.sample_indices[p] + if self.sample_weight is not None: + w = self.sample_weight[i] + + for k in range(self.n_outputs): + c = int(self.y[i, k]) + self.sum_missing[k, c] += w + + self.weighted_n_missing += w + def reset(self): self.pos = self.start ( diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index 0d170f8ed7949..c03191ea43a6a 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -383,6 +383,7 @@ def node_split_best( f_i -= 1 features[f_i], features[f_j] = features[f_j], features[f_i] has_missing = n_missing != 0 + criterion.init_missing(n_missing) n_searches = 2 if has_missing else 1 for i in range(n_searches): missing_go_to_left = i == 1 From 5631631b3b61153792b3c148d0710a2c84975247 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 11 Dec 2023 17:47:44 +0000 Subject: [PATCH 348/978] fix: add node_value method to ensure tree value is evaluated correctly in depthfirst build method. remove n_missing = 0 assumption in ClassificationCriterion --- ivy/functional/frontends/sklearn/tree/_criterion.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_criterion.py b/ivy/functional/frontends/sklearn/tree/_criterion.py index 01a4d425b8f77..90458f27ef5cc 100644 --- a/ivy/functional/frontends/sklearn/tree/_criterion.py +++ b/ivy/functional/frontends/sklearn/tree/_criterion.py @@ -54,7 +54,6 @@ def __init__(self, n_outputs: int, n_classes: ivy.Array): self.weighted_n_right = 0.0 self.weighted_n_missing = 0.0 self.n_classes = ivy.empty(n_outputs, dtype=ivy.int16) - self.n_missing = 0 # todo: remove this assumption max_n_classes = 0 for k in range(n_outputs): @@ -110,6 +109,12 @@ def init_sum_missing(self): (self.n_outputs, self.max_n_classes), dtype=ivy.float64 ) + def node_value(self, dest, node_id): + for k in range(self.n_outputs): + n_cls = ivy.to_scalar(self.n_classes[k]) + dest[node_id, k, :n_cls] = self.sum_total[k, :n_cls] + return dest + def init_missing(self, n_missing): w = 1.0 self.n_missing = n_missing @@ -141,6 +146,7 @@ def reset(self): self.sum_right, self.weighted_n_left, self.weighted_n_right, + self.missing_go_to_left, ) return 0 @@ -157,6 +163,7 @@ def reverse_reset(self): self.sum_left, self.weighted_n_right, self.weighted_n_left, + not self.missing_go_to_left, ) return 0 @@ -237,7 +244,9 @@ def children_impurity( # --------------- # -def _move_sums_classification(criterion, sum_1, sum_2, weighted_n_1, weighted_n_2): +def _move_sums_classification( + criterion, sum_1, sum_2, weighted_n_1, weighted_n_2, put_missing_in_1 +): for k in range(criterion.n_outputs): n = int(criterion.n_classes[k]) sum_1[k, :n] = 0 From 41b07b2a192b4b3bcc2c2f9315b04a80a4469271 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 12 Dec 2023 09:56:22 +0000 Subject: [PATCH 349/978] chore: move currently failing docstring tests to temporary skip open to be fixed by the community --- ivy_tests/test_docstrings.py | 45 ++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/ivy_tests/test_docstrings.py b/ivy_tests/test_docstrings.py index 4d4e73421cb20..a9d48a68b4011 100644 --- a/ivy_tests/test_docstrings.py +++ b/ivy_tests/test_docstrings.py @@ -170,6 +170,39 @@ def check_docstring_examples_run( "svdvals", "nested_map", "dill", + "hardtanh", + "hardshrink", + "rfft", + "general_inner_product", + "l1_loss", + "smooth_l1_loss", + "poisson_nll_loss", + "choose", + "cummax", + "one_hot", + "tpu_is_available", + "log2", + "maximum", + "minimum", + "get_referrers_recursive", + "clip_vector_norm", + "set_min_base", + "scatter_flat", + "scatter_nd", + "gather", + "multiprocessing", + "execute_with_gradients", + "solve", + "tensordot", + "cross_entropy", + "binary_cross_entropy", + "sparse_cross_entropy", + "reptile_step", + "insert_into_nest_at_index", + "if_else", + "while_loop", + "trace_graph", + "set_tmp_dir", ] # skip list for array and container docstrings @@ -189,6 +222,18 @@ def check_docstring_examples_run( "scaled_dot_product_attention", # temp list for array/container methods "einops_reduce", + "array_equal", + "batched_outer", + "huber_loss", + "softshrink", + "tt_matrix_to_tensor", + "unsorted_segment_mean", + "array_equal", + "batched_outer", + "huber_loss", + "kl_div", + "soft_margin_loss", + "threshold", ] # comment out the line below in future to check for the functions in temp skip list From 5cd6f371488a605860bdc27bfc531ee422429abc Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 12 Dec 2023 15:46:20 +0000 Subject: [PATCH 350/978] fix: use ivy.take in Tree's predict method instead of ivy gather avoiding dimension mismatches in torch backend between X_threshold and tree.value --- ivy/functional/frontends/sklearn/tree/_tree.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ivy/functional/frontends/sklearn/tree/_tree.py b/ivy/functional/frontends/sklearn/tree/_tree.py index 16dbf9cc6da74..53fc4e604c4f1 100644 --- a/ivy/functional/frontends/sklearn/tree/_tree.py +++ b/ivy/functional/frontends/sklearn/tree/_tree.py @@ -119,8 +119,7 @@ def _add_node( def predict(self, X): X_applied = self.apply(X) - X_threshold = ivy.where(X_applied > X.shape[0], X.shape[0] - 1, X_applied) - out = ivy.gather(self.value, X_threshold, axis=0) + out = ivy.take(self.value, X_applied, axis=0) if self.n_outputs == 1: out = out.reshape((X.shape[0], self.max_n_classes)) return out From 89a1ea7da0e53de7ba7cd8daa02d2aa20a31a281 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 12 Dec 2023 22:17:09 +0530 Subject: [PATCH 351/978] fix: removed the conditionals to avoid a trivial computation in the batch_norm function so that gradients propagate in all cases --- ivy/functional/backends/tensorflow/experimental/norms.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/norms.py b/ivy/functional/backends/tensorflow/experimental/norms.py index 0e62c92a4a75c..8f23815853b7e 100644 --- a/ivy/functional/backends/tensorflow/experimental/norms.py +++ b/ivy/functional/backends/tensorflow/experimental/norms.py @@ -110,11 +110,8 @@ def batch_norm( inv = 1.0 / tf.math.sqrt(variance + eps) offset = 0 if offset is None else offset - if scale is not None and any(s != 1 for s in scale): - inv = tf.math.multiply(inv, scale) - xnormalized = tf.math.multiply(x, inv) - if any(s != 0 for s in offset): - xnormalized = tf.math.add(xnormalized, offset) + inv = tf.math.multiply(inv, scale) + xnormalized = tf.math.add(tf.math.multiply(x, inv), offset) xnormalized = tf.math.subtract(xnormalized, tf.math.multiply(mean, inv)) # the above approach is faster than tf.nn.batch_normalization From d9a3aaf2a616f711d5e80224b2bc8c312dea7d37 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 12 Dec 2023 22:23:39 +0530 Subject: [PATCH 352/978] fix: added the None check back for batch_norm --- ivy/functional/backends/tensorflow/experimental/norms.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/experimental/norms.py b/ivy/functional/backends/tensorflow/experimental/norms.py index 8f23815853b7e..ef4c5d7d5e8b6 100644 --- a/ivy/functional/backends/tensorflow/experimental/norms.py +++ b/ivy/functional/backends/tensorflow/experimental/norms.py @@ -110,7 +110,8 @@ def batch_norm( inv = 1.0 / tf.math.sqrt(variance + eps) offset = 0 if offset is None else offset - inv = tf.math.multiply(inv, scale) + if scale is not None: + inv = tf.math.multiply(inv, scale) xnormalized = tf.math.add(tf.math.multiply(x, inv), offset) xnormalized = tf.math.subtract(xnormalized, tf.math.multiply(mean, inv)) # the above approach is faster than tf.nn.batch_normalization From cb2ccabe5b30ecc4c7a491439c9df8504f10685a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 12 Dec 2023 23:20:26 +0530 Subject: [PATCH 353/978] feat: Updated `black` formatter version and modified all the files according to it. (#27740) --- .pre-commit-config.yaml | 2 +- ivy/data_classes/container/base.py | 38 ++-- .../factorized_tensor/cp_tensor.py | 10 +- .../factorized_tensor/tucker_tensor.py | 16 +- ivy/data_classes/nested_array/base.py | 6 +- ivy/functional/backends/jax/random.py | 10 +- ivy/functional/backends/mxnet/creation.py | 22 +- .../mxnet/experimental/linear_algebra.py | 12 +- .../backends/mxnet/experimental/norms.py | 24 +- ivy/functional/backends/mxnet/set.py | 14 +- ivy/functional/backends/numpy/random.py | 10 +- .../tensorflow/experimental/layers.py | 6 +- ivy/functional/backends/tensorflow/random.py | 10 +- ivy/functional/backends/tensorflow/set.py | 12 +- ivy/functional/backends/torch/general.py | 12 +- ivy/functional/backends/torch/random.py | 10 +- ivy/functional/backends/torch/set.py | 6 +- ivy/functional/ivy/experimental/layers.py | 12 +- .../ivy/experimental/linear_algebra.py | 26 +-- ivy/functional/ivy/nest.py | 6 +- ivy/utils/backend/handler.py | 6 +- ivy/utils/exceptions.py | 6 +- ivy_tests/test_ivy/conftest.py | 14 +- .../test_ivy/helpers/function_testing.py | 212 ++++++++---------- ivy_tests/test_ivy/helpers/multiprocessing.py | 74 +++--- ivy_tests/test_ivy/helpers/testing_helpers.py | 16 +- scripts/backend_generation/generate.py | 6 +- scripts/determine_tests/determine_tests.py | 12 +- 28 files changed, 278 insertions(+), 332 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 45178cdf6c7a0..2484a461e3be8 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: - id: check-toml - id: end-of-file-fixer - repo: https://github.com/psf/black-pre-commit-mirror - rev: 23.11.0 + rev: 23.12.0 hooks: - id: black language_version: python3 diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index ea24b676a9154..74cee571ae367 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -1488,9 +1488,9 @@ def _cont_get_shape(self): if not sub_shapes: return sub_shapes min_num_dims = min(len(sub_shape) for sub_shape in sub_shapes) - sub_shapes_array = np.asarray([ - sub_shape[0:min_num_dims] for sub_shape in sub_shapes - ]) + sub_shapes_array = np.asarray( + [sub_shape[0:min_num_dims] for sub_shape in sub_shapes] + ) sub_shapes_array = np.where(sub_shapes_array == 0, -1, sub_shapes_array) mask = np.prod(sub_shapes_array / sub_shapes_array[0:1], 0) == 1 # noinspection PyTypeChecker @@ -1843,15 +1843,11 @@ def cont_unstack_conts(self, axis, keepdims=False, dim_size=None): if keepdims: # noinspection PyTypeChecker return [ - self[ - ( - slice(i, i + 1, 1) - if axis == 0 - else tuple( - [slice(None, None, None)] * axis + [slice(i, i + 1, 1)] - ) - ) - ] + self[( + slice(i, i + 1, 1) + if axis == 0 + else tuple([slice(None, None, None)] * axis + [slice(i, i + 1, 1)]) + )] for i in range(dim_size) ] # noinspection PyTypeChecker @@ -3657,9 +3653,9 @@ def cont_show_sub_container(self, sub_cont_or_keychain): # prepend these lines to the sub-container sub_repr = ( "\n" - + "\n".join([ - " " * num_spaces_to_add + s for s in sub_repr[1:-1].split("\n") - ]) + + "\n".join( + [" " * num_spaces_to_add + s for s in sub_repr[1:-1].split("\n")] + ) + "\n" ) @@ -3735,9 +3731,9 @@ def _pre_pad_alpha_line(str_in): # 10 dimensions is a sensible upper bound for the number in a single array for i in range(2, 10): indented = indented.replace(" " * (i - 1) + "[" * i, "[" * i) - indented = "\n".join([ - s for s in indented.split("\n") if bool(s) and not s.isspace() - ]) + indented = "\n".join( + [s for s in indented.split("\n") if bool(s) and not s.isspace()] + ) return indented def _align_arrays(str_in): @@ -3845,9 +3841,9 @@ def _add_newline(str_in): for i, ss in enumerate(str_in_split) ]) - json_dumped_str = '":'.join([ - _add_newline(s) for s in json_dumped_str.split('":') - ]) + json_dumped_str = '":'.join( + [_add_newline(s) for s in json_dumped_str.split('":')] + ) # improve tf formatting if ivy.backend_stack and ivy.current_backend_str() == "tensorflow": json_dumped_str_split = json_dumped_str.split("'Variable:") diff --git a/ivy/data_classes/factorized_tensor/cp_tensor.py b/ivy/data_classes/factorized_tensor/cp_tensor.py index 9d1e9b060a917..7798966181f95 100644 --- a/ivy/data_classes/factorized_tensor/cp_tensor.py +++ b/ivy/data_classes/factorized_tensor/cp_tensor.py @@ -68,12 +68,10 @@ def to_unfolded(self, mode): return ivy.CPTensor.cp_to_unfolded(self, mode) def cp_copy(self): - return CPTensor( - ( - ivy.copy_array(self.weights), - [ivy.copy_array(self.factors[i]) for i in range(len(self.factors))], - ) - ) + return CPTensor(( + ivy.copy_array(self.weights), + [ivy.copy_array(self.factors[i]) for i in range(len(self.factors))], + )) def mode_dot(self, matrix_or_vector, mode, keep_dim=False, copy=True): """N-mode product of a CP tensor and a matrix or vector at the diff --git a/ivy/data_classes/factorized_tensor/tucker_tensor.py b/ivy/data_classes/factorized_tensor/tucker_tensor.py index 0e329f6b54a53..17f5d27f6c0c3 100644 --- a/ivy/data_classes/factorized_tensor/tucker_tensor.py +++ b/ivy/data_classes/factorized_tensor/tucker_tensor.py @@ -83,12 +83,10 @@ def to_unfolded(self, mode): return TuckerTensor.tucker_to_unfolded(self, mode) def tucker_copy(self): - return TuckerTensor( - ( - deepcopy(self.core), - [deepcopy(self.factors[i]) for i in range(len(self.factors))], - ) - ) + return TuckerTensor(( + deepcopy(self.core), + [deepcopy(self.factors[i]) for i in range(len(self.factors))], + )) def to_vec(self): return TuckerTensor.tucker_to_vec(self) @@ -288,9 +286,9 @@ def validate_tucker_rank( # number of parameters coming from the fixed modes # (these don't have a variable size as a fun of fraction_param) - n_fixed_params = ivy.sum([ - s**2 for _, s in fixed_modes - ]) # size of the factors + n_fixed_params = ivy.sum( + [s**2 for _, s in fixed_modes] + ) # size of the factors n_modes_compressed -= len(fixed_modes) else: n_fixed_params = 0 diff --git a/ivy/data_classes/nested_array/base.py b/ivy/data_classes/nested_array/base.py index 2534a9412706e..188f1c731cfa2 100644 --- a/ivy/data_classes/nested_array/base.py +++ b/ivy/data_classes/nested_array/base.py @@ -139,9 +139,9 @@ def ragged_multi_map(fn, ragged_arrays): args.append(ivy.copy_nest(ragged.data)) ret = ivy.nested_multi_map(lambda x, _: fn(x), args) # infer dtype, shape, and device from the first array in the ret data - broadcasted_shape = ivy.NestedArray.broadcast_shapes([ - arg.shape for arg in ragged_arrays - ]) + broadcasted_shape = ivy.NestedArray.broadcast_shapes( + [arg.shape for arg in ragged_arrays] + ) # infer ragged_rank from broadcasted shape for i, dim in enumerate(broadcasted_shape[::-1]): if dim is None: diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index 2c8ec9ca87f8e..21299380b363a 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -106,12 +106,10 @@ def multinomial( if probs is None: probs = ( - jnp.ones( - ( - batch_size, - population_size, - ) - ) + jnp.ones(( + batch_size, + population_size, + )) / population_size ) orig_probs_shape = list(probs.shape) diff --git a/ivy/functional/backends/mxnet/creation.py b/ivy/functional/backends/mxnet/creation.py index d32d312efc394..5da540614b9e3 100644 --- a/ivy/functional/backends/mxnet/creation.py +++ b/ivy/functional/backends/mxnet/creation.py @@ -35,18 +35,16 @@ def arange( @_asarray_handle_nestable @_asarray_inputs_to_native_shapes def asarray( - obj: Union[ - ( - None, - mx.ndarray.NDArray, - bool, - int, - float, - NestedSequence, - SupportsBufferProtocol, - np.ndarray, - ) - ], + obj: Union[( + None, + mx.ndarray.NDArray, + bool, + int, + float, + NestedSequence, + SupportsBufferProtocol, + np.ndarray, + )], /, *, copy: Optional[bool] = None, diff --git a/ivy/functional/backends/mxnet/experimental/linear_algebra.py b/ivy/functional/backends/mxnet/experimental/linear_algebra.py index dd31f5eeb070d..458c945791b83 100644 --- a/ivy/functional/backends/mxnet/experimental/linear_algebra.py +++ b/ivy/functional/backends/mxnet/experimental/linear_algebra.py @@ -15,13 +15,11 @@ def eigh_tridiagonal( Union[(Tuple[(int, int)], List[int], None, mx.ndarray.NDArray)] ] = None, tol: Optional[float] = None, -) -> Union[ - ( - None, - mx.ndarray.NDArray, - Tuple[(Union[(None, mx.ndarray.NDArray)], Union[(None, mx.ndarray.NDArray)])], - ) -]: +) -> Union[( + None, + mx.ndarray.NDArray, + Tuple[(Union[(None, mx.ndarray.NDArray)], Union[(None, mx.ndarray.NDArray)])], +)]: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/mxnet/experimental/norms.py b/ivy/functional/backends/mxnet/experimental/norms.py index 19fea95289a8d..da6b8b5311adf 100644 --- a/ivy/functional/backends/mxnet/experimental/norms.py +++ b/ivy/functional/backends/mxnet/experimental/norms.py @@ -26,13 +26,11 @@ def batch_norm( eps: float = 1e-05, momentum: float = 0.1, out: Optional[None] = None, -) -> Tuple[ - ( - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - ) -]: +) -> Tuple[( + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], +)]: raise IvyNotImplementedException() @@ -48,13 +46,11 @@ def instance_norm( eps: float = 1e-05, momentum: float = 0.1, out: Optional[None] = None, -) -> Tuple[ - ( - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - ) -]: +) -> Tuple[( + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], +)]: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/mxnet/set.py b/ivy/functional/backends/mxnet/set.py index cb9a9cc9906e6..1617ed1539d12 100644 --- a/ivy/functional/backends/mxnet/set.py +++ b/ivy/functional/backends/mxnet/set.py @@ -6,14 +6,12 @@ def unique_all( x: Union[(None, mx.ndarray.NDArray)], /, *, axis: Optional[int] = None -) -> Tuple[ - ( - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - ) -]: +) -> Tuple[( + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], +)]: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index cae6121a75e69..a08d6a7d3addb 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -69,12 +69,10 @@ def multinomial( np.random.seed(seed) if probs is None: probs = ( - np.ones( - ( - batch_size, - population_size, - ) - ) + np.ones(( + batch_size, + population_size, + )) / population_size ) orig_probs_shape = list(probs.shape) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 9cff4a5eb70ba..722ea553bbe95 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -1302,9 +1302,9 @@ def static_output_shape(input_shape, shape, axes): def _right_pad_or_crop(tensor, shape): input_shape = tf.shape(tensor) shape = tf.convert_to_tensor(shape, dtype=tf.dtypes.int32) - with tf.control_dependencies([ - tf.debugging.assert_less_equal(tf.size(shape), tf.size(input_shape)) - ]): + with tf.control_dependencies( + [tf.debugging.assert_less_equal(tf.size(shape), tf.size(input_shape))] + ): shape = tf.identity(shape) shape = tf.concat([input_shape[: tf.size(input_shape) - tf.size(shape)], shape], 0) diff --git a/ivy/functional/backends/tensorflow/random.py b/ivy/functional/backends/tensorflow/random.py index 6dcd217c90a22..bd7981740a755 100644 --- a/ivy/functional/backends/tensorflow/random.py +++ b/ivy/functional/backends/tensorflow/random.py @@ -80,12 +80,10 @@ def multinomial( ) -> Union[tf.Tensor, tf.Variable]: if probs is None: probs = ( - tf.ones( - ( - batch_size, - population_size, - ) - ) + tf.ones(( + batch_size, + population_size, + )) / population_size ) diff --git a/ivy/functional/backends/tensorflow/set.py b/ivy/functional/backends/tensorflow/set.py index a4979773ddf4a..cc766363a3b0b 100644 --- a/ivy/functional/backends/tensorflow/set.py +++ b/ivy/functional/backends/tensorflow/set.py @@ -37,9 +37,9 @@ def unique_all( if x.dtype.is_floating and tf.reduce_any(tf.math.is_nan(values)): unique_nan = tf.math.is_nan(values) nan_index = tf.reshape(tf.where(tf.math.is_nan(x)), [-1]) - non_nan_index = tf.experimental.numpy.array([ - tensor_list.index(val) for val in values if not tf.math.is_nan(val) - ]) + non_nan_index = tf.experimental.numpy.array( + [tensor_list.index(val) for val in values if not tf.math.is_nan(val)] + ) indices = tf.experimental.numpy.full( fill_value=float("NaN"), shape=values.shape ).numpy() @@ -58,9 +58,9 @@ def unique_all( if by_value: values_ = tf.experimental.numpy.moveaxis(values, axis, 0) values_ = tf.reshape(values_, (values_.shape[0], -1)) - sort_idx = tf.stack([ - i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1])) - ]) + sort_idx = tf.stack( + [i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1]))] + ) sort_idx = tf.cast(sort_idx, tf.int32) values = tf.gather(values, sort_idx, axis=axis) counts = tf.gather(counts, sort_idx) diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 0d7e18ca1de49..08c8c6edffbbc 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -230,9 +230,9 @@ def gather_nd_helper(params, indices): indices_for_flat_tiled = torch.reshape( torch.sum(indices * indices_scales, -1, keepdim=True), (-1, 1) ).repeat(*[1, implicit_indices_factor]) - implicit_indices = torch.unsqueeze( - torch.arange(implicit_indices_factor), 0 - ).repeat(*[indices_for_flat_tiled.shape[0], 1]) + implicit_indices = torch.unsqueeze(torch.arange(implicit_indices_factor), 0).repeat( + *[indices_for_flat_tiled.shape[0], 1] + ) indices_for_flat = indices_for_flat_tiled + implicit_indices flat_indices_for_flat = torch.reshape(indices_for_flat, (-1,)).type(torch.long) flat_gather = torch.gather(flat_params, 0, flat_indices_for_flat) @@ -469,9 +469,9 @@ def scatter_nd( indices_for_flat_tiled = torch.reshape( torch.sum(indices * indices_scales, -1, keepdim=True), (-1, 1) ).repeat(*[1, implicit_indices_factor]) - implicit_indices = torch.unsqueeze( - torch.arange(implicit_indices_factor), 0 - ).repeat(*[indices_for_flat_tiled.shape[0], 1]) + implicit_indices = torch.unsqueeze(torch.arange(implicit_indices_factor), 0).repeat( + *[indices_for_flat_tiled.shape[0], 1] + ) indices_for_flat = indices_for_flat_tiled + implicit_indices flat_indices_for_flat = torch.reshape(indices_for_flat, (-1,)).type(torch.long) global torch_scatter diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index cdb4c17761cdd..0871269316e62 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -78,12 +78,10 @@ def multinomial( ) -> torch.Tensor: if probs is None: probs = ( - torch.ones( - ( - batch_size, - population_size, - ) - ) + torch.ones(( + batch_size, + population_size, + )) / population_size ) if seed: diff --git a/ivy/functional/backends/torch/set.py b/ivy/functional/backends/torch/set.py index 397f81ea59745..080f918d55099 100644 --- a/ivy/functional/backends/torch/set.py +++ b/ivy/functional/backends/torch/set.py @@ -62,9 +62,9 @@ def unique_all( else: values_ = torch.moveaxis(values, axis, 0) values_ = torch.reshape(values_, (values_.shape[0], -1)) - sort_idx = torch.tensor([ - i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1])) - ]) + sort_idx = torch.tensor( + [i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1]))] + ) ivy_torch = ivy.current_backend() values = ivy_torch.gather(values, sort_idx, axis=axis) counts = ivy_torch.gather(counts, sort_idx) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 3408fb8eba801..f860e166c8d75 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1405,13 +1405,11 @@ def _tf_area_interpolate(x, size, scale, dims): d_in, d_in1, d_index = _tf_area_indices(d_dim, scale[0]) h_in, h_in1, h_index = _tf_area_indices(h_dim, scale[1]) w_in, w_in1, w_index = _tf_area_indices(w_dim, scale[2]) - sum_data = ivy.zeros( - ( - d_index[1] - d_index[0], - h_index[1] - h_index[0], - w_index[1] - w_index[0], - ) - ) + sum_data = ivy.zeros(( + d_index[1] - d_index[0], + h_index[1] - h_index[0], + w_index[1] - w_index[0], + )) for d_ind in range(d_index[0], d_index[1]): scale_z = _tf_area_dim_scale( d_ind, d_in, scale[0], d_in1 diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index ccb4198d1a9a1..92e92992e53af 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -1051,14 +1051,12 @@ def svd_flip( ) V = V * signs[:, None] if ivy.shape(U)[1] > ivy.shape(V)[0]: - signs = ivy.concat( - ( - signs, - ivy.ones( - ivy.shape(U)[1] - ivy.shape(V)[0], - ), - ) - ) + signs = ivy.concat(( + signs, + ivy.ones( + ivy.shape(U)[1] - ivy.shape(V)[0], + ), + )) U = U * signs[: ivy.shape(U)[1]] return U, V @@ -1678,13 +1676,13 @@ def tucker( return ivy.TuckerTensor((core, factors)) fixed_factors = sorted(fixed_factors) - modes_fixed, factors_fixed = zip(*[ - (i, f) for (i, f) in enumerate(factors) if i in fixed_factors - ]) + modes_fixed, factors_fixed = zip( + *[(i, f) for (i, f) in enumerate(factors) if i in fixed_factors] + ) core = multi_mode_dot(core, factors_fixed, modes=modes_fixed) - modes, factors = zip(*[ - (i, f) for (i, f) in enumerate(factors) if i not in fixed_factors - ]) + modes, factors = zip( + *[(i, f) for (i, f) in enumerate(factors) if i not in fixed_factors] + ) init = (core, list(factors)) rank = ivy.TuckerTensor.validate_tucker_rank(x.shape, rank=rank) diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index dcf7993b5e987..39b49a647ea89 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -1466,9 +1466,9 @@ def nested_multi_map( ( return_nest.append(ret) if isinstance(return_nest, (list)) - else return_nest.update({ - val if is_dict else list(nest)[index]: ret - }) + else return_nest.update( + {val if is_dict else list(nest)[index]: ret} + ) ) else: values = nests diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 3c8e373fea56d..9099e9f926ccf 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -525,9 +525,9 @@ def choose_random_backend(excluded=None): or not installed.""", as_array=False, ) - f = np.random.choice([ - f_srt for f_srt in list(_backend_dict.keys()) if f_srt not in excluded - ]) + f = np.random.choice( + [f_srt for f_srt in list(_backend_dict.keys()) if f_srt not in excluded] + ) if f is None: excluded.append(f) continue diff --git a/ivy/utils/exceptions.py b/ivy/utils/exceptions.py index a5395fda37319..8daf070899ab9 100644 --- a/ivy/utils/exceptions.py +++ b/ivy/utils/exceptions.py @@ -120,9 +120,9 @@ def _get_traces(curr_obj, area, local_dict, target_name): curr_obj[3] = rooted_src_list[i] curr_obj[1] += i break - elif builtins.any([ - name in rooted_src_list[i] for name in non_lib_objs_name_list - ]): + elif builtins.any( + [name in rooted_src_list[i] for name in non_lib_objs_name_list] + ): found = False for name in non_lib_objs_name_list: if name in rooted_src_list[i]: diff --git a/ivy_tests/test_ivy/conftest.py b/ivy_tests/test_ivy/conftest.py index 9cb8e15586fb8..06b4054ff086f 100644 --- a/ivy_tests/test_ivy/conftest.py +++ b/ivy_tests/test_ivy/conftest.py @@ -198,14 +198,12 @@ def pytest_configure(config): continue for trace_graph in trace_modes: for implicit in implicit_modes: - TEST_PARAMS_CONFIG.append( - ( - device, - backend_str, - trace_graph, - implicit, - ) - ) + TEST_PARAMS_CONFIG.append(( + device, + backend_str, + trace_graph, + implicit, + )) process_cl_flags(config) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 3ae8e2c7d4e80..2b7a844e894bf 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -479,17 +479,15 @@ def test_function( if mod_backend[backend_to_test]: # multiprocessing proc, input_queue, output_queue = mod_backend[backend_to_test] - input_queue.put( - ( - "function_backend_computation", - backend_to_test, - test_flags, - all_as_kwargs_np, - input_dtypes, - on_device, - fn_name, - ) - ) + input_queue.put(( + "function_backend_computation", + backend_to_test, + test_flags, + all_as_kwargs_np, + input_dtypes, + on_device, + fn_name, + )) ( ret_from_target, ret_np_flat_from_target, @@ -528,22 +526,20 @@ def test_function( # compute the return with a Ground Truth backend if mod_backend[ground_truth_backend]: proc, input_queue, output_queue = mod_backend[ground_truth_backend] - input_queue.put( - ( - "function_ground_truth_computation", - ground_truth_backend, - on_device, - args_np, - arg_np_arrays, - arrays_args_indices, - kwargs_np, - arrays_kwargs_indices, - kwarg_np_arrays, - input_dtypes, - test_flags, - fn_name, - ) - ) + input_queue.put(( + "function_ground_truth_computation", + ground_truth_backend, + on_device, + args_np, + arg_np_arrays, + arrays_args_indices, + kwargs_np, + arrays_kwargs_indices, + kwarg_np_arrays, + input_dtypes, + test_flags, + fn_name, + )) ( ret_from_gt, ret_np_from_gt_flat, @@ -575,15 +571,13 @@ def test_function( if test_flags.transpile: if mod_backend[backend_to_test]: proc, input_queue, output_queue = mod_backend[backend_to_test] - input_queue.put( - ( - "transpile_if_required_backend", - backend_to_test, - fn_name, - args_np, - kwargs_np, - ) - ) + input_queue.put(( + "transpile_if_required_backend", + backend_to_test, + fn_name, + args_np, + kwargs_np, + )) else: _transpile_if_required_backend( backend_to_test, fn_name, args=args_np, kwargs=kwargs_np @@ -1221,25 +1215,23 @@ def gradient_test( if mod_backend[backend_to_test]: # do this using multiprocessing proc, input_queue, output_queue = mod_backend[backend_to_test] - input_queue.put( - ( - "gradient_backend_computation", - backend_to_test, - args_np, - arg_np_vals, - args_idxs, - kwargs_np, - kwarg_np_vals, - kwargs_idxs, - input_dtypes, - test_flags, - on_device, - fn, - test_trace, - xs_grad_idxs, - ret_grad_idxs, - ) - ) + input_queue.put(( + "gradient_backend_computation", + backend_to_test, + args_np, + arg_np_vals, + args_idxs, + kwargs_np, + kwarg_np_vals, + kwargs_idxs, + input_dtypes, + test_flags, + on_device, + fn, + test_trace, + xs_grad_idxs, + ret_grad_idxs, + )) grads_np_flat = output_queue.get() else: @@ -1263,26 +1255,24 @@ def gradient_test( if mod_backend[ground_truth_backend]: # do this using multiprocessing proc, input_queue, output_queue = mod_backend[ground_truth_backend] - input_queue.put( - ( - "gradient_ground_truth_computation", - ground_truth_backend, - on_device, - fn, - input_dtypes, - all_as_kwargs_np, - args_np, - arg_np_vals, - args_idxs, - kwargs_np, - kwarg_np_vals, - test_flags, - kwargs_idxs, - test_trace, - xs_grad_idxs, - ret_grad_idxs, - ) - ) + input_queue.put(( + "gradient_ground_truth_computation", + ground_truth_backend, + on_device, + fn, + input_dtypes, + all_as_kwargs_np, + args_np, + arg_np_vals, + args_idxs, + kwargs_np, + kwarg_np_vals, + test_flags, + kwargs_idxs, + test_trace, + xs_grad_idxs, + ret_grad_idxs, + )) grads_np_from_gt_flat = output_queue.get() else: grads_np_from_gt_flat = test_gradient_ground_truth_computation( @@ -1690,24 +1680,22 @@ def test_method( if mod_backend[backend_to_test]: # yep, multiprocessing proc, input_queue, output_queue = mod_backend[backend_to_test] - input_queue.put( - ( - "method_backend_computation", - init_input_dtypes, - init_flags, - backend_to_test, - init_all_as_kwargs_np, - on_device, - method_input_dtypes, - method_flags, - method_all_as_kwargs_np, - class_name, - method_name, - init_with_v, - test_trace, - method_with_v, - ) - ) + input_queue.put(( + "method_backend_computation", + init_input_dtypes, + init_flags, + backend_to_test, + init_all_as_kwargs_np, + on_device, + method_input_dtypes, + method_flags, + method_all_as_kwargs_np, + class_name, + method_name, + init_with_v, + test_trace, + method_with_v, + )) ( ret, ret_np_flat, @@ -1756,26 +1744,24 @@ def test_method( if mod_backend[ground_truth_backend]: # yep, multiprocessing proc, input_queue, output_queue = mod_backend[ground_truth_backend] - input_queue.put( - ( - "method_ground_truth_computation", - ground_truth_backend, - on_device, - org_con_data, - args_np_method, - met_arg_np_vals, - met_args_idxs, - kwargs_np_method, - met_kwarg_np_vals, - met_kwargs_idxs, - method_input_dtypes, - method_flags, - class_name, - method_name, - test_trace, - v_np, - ) - ) + input_queue.put(( + "method_ground_truth_computation", + ground_truth_backend, + on_device, + org_con_data, + args_np_method, + met_arg_np_vals, + met_args_idxs, + kwargs_np_method, + met_kwarg_np_vals, + met_kwargs_idxs, + method_input_dtypes, + method_flags, + class_name, + method_name, + test_trace, + v_np, + )) ( ret_from_gt, ret_np_from_gt_flat, diff --git a/ivy_tests/test_ivy/helpers/multiprocessing.py b/ivy_tests/test_ivy/helpers/multiprocessing.py index 39234c644de27..86f2d20971336 100644 --- a/ivy_tests/test_ivy/helpers/multiprocessing.py +++ b/ivy_tests/test_ivy/helpers/multiprocessing.py @@ -101,21 +101,19 @@ def backend_proc(input_queue, output_queue): ) # ret_from_target to be none, because main process has # framework imports blocked - output_queue.put( - ( - (None), - ret_np_flat_from_target, - ret_device, - args_np, - arg_np_arrays, - arrays_args_indices, - kwargs_np, - arrays_kwargs_indices, - kwarg_np_arrays, - test_flags, - input_dtypes, - ) - ) + output_queue.put(( + (None), + ret_np_flat_from_target, + ret_device, + args_np, + arg_np_arrays, + arrays_args_indices, + kwargs_np, + arrays_kwargs_indices, + kwarg_np_arrays, + test_flags, + input_dtypes, + )) elif data[0] == "function_ground_truth_computation": # it's the ground_truth return computation ( @@ -152,15 +150,13 @@ def backend_proc(input_queue, output_queue): fn_name, ) # ret_from gt is none because main process has frameworks is None - output_queue.put( - ( - (None), - ret_np_from_gt_flat, - ret_from_gt_device, - test_flags, - fw_list, - ) - ) + output_queue.put(( + (None), + ret_np_from_gt_flat, + ret_from_gt_device, + test_flags, + fw_list, + )) elif data[0] == "gradient_backend_computation": # gradient testing , part where it uses the backend ( @@ -283,22 +279,20 @@ def backend_proc(input_queue, output_queue): method_with_v, ) # ret is none here, because main process doesn't import framework - output_queue.put( - ( - (None), - ret_np_flat, - ret_device, - org_con_data, - args_np_method, - met_arg_np_vals, - met_args_idxs, - kwargs_np_method, - met_kwarg_np_vals, - met_kwargs_idxs, - v_np, - fw_list, - ) - ) + output_queue.put(( + (None), + ret_np_flat, + ret_device, + org_con_data, + args_np_method, + met_arg_np_vals, + met_args_idxs, + kwargs_np_method, + met_kwarg_np_vals, + met_kwargs_idxs, + v_np, + fw_list, + )) elif data[0] == "method_ground_truth_computation": ( diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index 865be68e7eac7..1628eb85cd84d 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -230,15 +230,13 @@ def _get_method_supported_devices_dtypes( if mod_backend[backend_str]: # we gotta do this using multiprocessing proc, input_queue, output_queue = mod_backend[backend_str] - input_queue.put( - ( - "method supported dtypes", - method_name, - class_module.__name__, - class_name, - backend_str, - ) - ) + input_queue.put(( + "method supported dtypes", + method_name, + class_module.__name__, + class_name, + backend_str, + )) supported_device_dtypes[backend_str] = output_queue.get() else: supported_device_dtypes[backend_str] = ( diff --git a/scripts/backend_generation/generate.py b/scripts/backend_generation/generate.py index f10355a0148c2..90886b67f61b4 100644 --- a/scripts/backend_generation/generate.py +++ b/scripts/backend_generation/generate.py @@ -154,9 +154,9 @@ def _should_install_backend(package_name): if ret.lower() == "y": try: # Install backend - subprocess.check_call([ - sys.executable, "-m", "pip", "install", package_name - ]) + subprocess.check_call( + [sys.executable, "-m", "pip", "install", package_name] + ) global _backend_is_installed _backend_is_installed = True with open("../../requirements/optional.txt", "a") as reqr_file: diff --git a/scripts/determine_tests/determine_tests.py b/scripts/determine_tests/determine_tests.py index fb0c284001f11..ef60b4d28c335 100644 --- a/scripts/determine_tests/determine_tests.py +++ b/scripts/determine_tests/determine_tests.py @@ -100,13 +100,13 @@ def main(): # if it is a PR, we must check that the tests added were in the files_changes if len(sys.argv) >= 3 and sys.argv[2] == "pr": relevant_added_tests = [] - subprocess.run([ - "git", "remote", "add", "upstream", "https://github.com/unifyai/ivy" - ]) + subprocess.run( + ["git", "remote", "add", "upstream", "https://github.com/unifyai/ivy"] + ) subprocess.run(["git", "fetch", "upstream"]) - lca_sha = subprocess.check_output([ - "git", "merge-base", "HEAD", "upstream/main" - ]) + lca_sha = subprocess.check_output( + ["git", "merge-base", "HEAD", "upstream/main"] + ) lca_hash = lca_sha.decode().strip() for commit in Repository(".", single=lca_hash).traverse_commits(): lca_commit = commit._c_object From 1f6264e1be8946b4b142668a0201fbaa73ee0810 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 12 Dec 2023 20:31:53 +0000 Subject: [PATCH 354/978] fix: remove axis parameter from jax.reshape call as the reshape function does not take any axis arg --- ivy/functional/backends/jax/set.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/set.py b/ivy/functional/backends/jax/set.py index d8b1864435912..d61f0234bccdd 100644 --- a/ivy/functional/backends/jax/set.py +++ b/ivy/functional/backends/jax/set.py @@ -96,7 +96,7 @@ def unique_inverse( values = jnp.append(values, jnp.full(nan_count - 1, jnp.nan), axis=0).astype( x.dtype ) - inverse_indices = jnp.reshape(inverse_indices, x.shape, axis=0) + inverse_indices = jnp.reshape(inverse_indices, x.shape) return Results(values, inverse_indices) From 8d0bf2b887355ea8c93c0cde12e6e5f80ca81154 Mon Sep 17 00:00:00 2001 From: kurshakuz Date: Wed, 13 Dec 2023 18:09:37 +0600 Subject: [PATCH 355/978] docs: Extend the access to Unify API key to all of our users (#27742) --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 91ae3f63899a5..44bd3b7170790 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ -> 🚀 We are granting pilot access to **Ivy\'s Tracer and Transpiler** -> to some users, [join the waitlist](https://console.unify.ai/) if you +> 🚀 We are granting access to **Ivy\'s Tracer and Transpiler** +> to all of our users, [sign up on our console](https://console.unify.ai/) if you > want to test them out! From a6611fc7c707c18f014fd9937518491d4f54222d Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 13 Dec 2023 19:49:49 +0530 Subject: [PATCH 356/978] chore: updated the cuda version in the GPU docker image to be 12.2 instead of 11.8 due to cudnn conflicts after recent tensorflow release --- docker/gpu_framework_directory.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docker/gpu_framework_directory.py b/docker/gpu_framework_directory.py index 21ed1e2fcf989..6c52a79876bab 100644 --- a/docker/gpu_framework_directory.py +++ b/docker/gpu_framework_directory.py @@ -40,12 +40,12 @@ def install_pkg(path, pkg, base="fw/"): subprocess.run( f"yes |pip3 install --upgrade {pkg} --target" f" {path} --default-timeout=100 --extra-index-url" - " https://download.pytorch.org/whl/cu118 --no-cache-dir", + " --no-cache-dir", shell=True, ) elif pkg.split("==")[0] if "==" in pkg else pkg == "jax": subprocess.run( - f"yes |pip install --upgrade --target {path} 'jax[cuda11_pip]' -f" + f"yes |pip install --upgrade --target {path} 'jax[cuda12_pip]' -f" " https://storage.googleapis.com/jax-releases/jax_cuda_releases.html " " --no-cache-dir", shell=True, @@ -53,7 +53,7 @@ def install_pkg(path, pkg, base="fw/"): elif pkg.split("==")[0] if "==" in pkg else pkg == "paddle": subprocess.run( "yes |pip install " - f" paddlepaddle-gpu=={get_latest_package_version('paddlepaddle')}.post117" + f" paddlepaddle-gpu=={get_latest_package_version('paddlepaddle')}.post120" f" --target {path} -f" " https://www.paddlepaddle.org.cn/whl/linux/mkl/avx/stable.html " " --no-cache-dir", From 068513ff5c792cee2ece30a3da3295ef4587ea38 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 13 Dec 2023 20:52:51 +0530 Subject: [PATCH 357/978] fix: Fixed raising `broad exceptions` at few places. (#27744) --- ivy/data_classes/nested_array/base.py | 4 +++- ivy/func_wrapper.py | 2 +- ivy/functional/backends/mxnet/device.py | 2 +- ivy/functional/backends/paddle/manipulation.py | 2 +- ivy/functional/frontends/torch/tensor.py | 2 +- ivy_tests/test_ivy/helpers/function_testing.py | 2 +- ivy_tests/test_ivy/test_functional/test_core/test_general.py | 4 ++-- 7 files changed, 10 insertions(+), 8 deletions(-) diff --git a/ivy/data_classes/nested_array/base.py b/ivy/data_classes/nested_array/base.py index 188f1c731cfa2..21accbd881094 100644 --- a/ivy/data_classes/nested_array/base.py +++ b/ivy/data_classes/nested_array/base.py @@ -128,7 +128,9 @@ def map_fn(vals): return inspect_fn(*a, **kw) if num_nest == 0: - raise Exception(f"No RaggedArrays found in args or kwargs of function {fn}") + raise ValueError( + f"No RaggedArrays found in args or kwargs of function {fn}" + ) ret = ivy.NestedArray.ragged_multi_map(map_fn, nests) return ret diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index 69988981f00ab..f008c017fd784 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -1180,7 +1180,7 @@ def _dtype_from_version(dic, version): # If version dict is empty, then there is an error if not dic: - raise Exception("No version found in the dictionary") + raise ValueError("No version found in the dictionary") # If key is already in the dictionary, return the value if version in dic: diff --git a/ivy/functional/backends/mxnet/device.py b/ivy/functional/backends/mxnet/device.py index 3d07258b4100c..1064e52b7aa21 100644 --- a/ivy/functional/backends/mxnet/device.py +++ b/ivy/functional/backends/mxnet/device.py @@ -50,7 +50,7 @@ def as_native_dev(device: str, /): elif "gpu" in device: mx_dev = "gpu" else: - raise Exception(f"dev input {device} not supported.") + raise ValueError(f"dev input {device} not supported.") if device.find(":") != -1: mx_dev_id = int(device[device.find(":") + 1 :]) else: diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index 03dc9acca403a..f3bb163807d58 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -221,7 +221,7 @@ def stack( first_shape = arrays[0].shape if any(arr.shape != first_shape for arr in arrays): - raise Exception("Shapes of all inputs must match") + raise ValueError("Shapes of all inputs must match") if 0 in first_shape: return ivy.empty( first_shape[:axis] + [len(arrays)] + first_shape[axis:], dtype=dtype diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index cd997a72c6d7f..c469b235e949f 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1826,7 +1826,7 @@ def tile(self, *reps): def apply_(self, callable, /): if self.device != "cpu": - raise Exception("apply_ is only supported on cpu tensors") + raise ValueError("apply_ is only supported on cpu tensors") self.ivy_array = callable(self.ivy_array) return self diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 2b7a844e894bf..c86ac233d22e8 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -158,7 +158,7 @@ def test_function_backend_computation( if ("out" in kwargs or test_flags.with_out) and "out" not in inspect.signature( getattr(ivy, fn_name) ).parameters: - raise Exception(f"Function {fn_name} does not have an out parameter") + raise RuntimeError(f"Function {fn_name} does not have an out parameter") # Run either as an instance method or from the API directly with BackendHandler.update_backend(fw) as ivy_backend: diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index ab35dc81db1a5..951c1d05e804c 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -1208,7 +1208,7 @@ def test_inplace_arrays_supported(backend_fw): elif backend_fw in ["jax", "tensorflow", "paddle"]: assert not ivy_backend.inplace_arrays_supported() else: - raise Exception("Unrecognized framework") + raise RuntimeError("Unrecognized framework") # inplace_decrement @@ -1329,7 +1329,7 @@ def test_inplace_variables_supported(backend_fw): elif backend_fw in ["jax", "paddle"]: assert not ivy_backend.inplace_variables_supported() else: - raise Exception("Unrecognized framework") + raise RuntimeError("Unrecognized framework") # is_array From feeef6ebc57429850d686b66cc57425a2b411b92 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Wed, 13 Dec 2023 21:37:59 +0400 Subject: [PATCH 358/978] fix: update discord invitation link --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 89d573f39917f..37cfa8e39bd59 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -48,4 +48,4 @@ Please, follow the next process when you work on your subtask: [![Video](https://img.youtube.com/vi/wBKTOGmwfbo/0.jpg)](https://www.youtube.com/embed/wBKTOGmwfbo) -For questions, please reach out on [discord](https://discord.gg/sd2yYCha) in the [todo list issues channel](https://discord.com/channels/799879767196958751/982728618469912627)! +For questions, please reach out on [discord](https://discord.gg/MDK979Ga) in the [todo list issues channel](https://discord.com/channels/799879767196958751/982728618469912627)! From a395c0a565f4f02a81393e67f715333dc63d5f1c Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 14 Dec 2023 04:35:48 +0530 Subject: [PATCH 359/978] fix: Added `timeout` argument in requests call (#27746) --- docker/gpu_framework_directory.py | 2 +- scripts/run_tests/helpers.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docker/gpu_framework_directory.py b/docker/gpu_framework_directory.py index 6c52a79876bab..d5ecc15c70ecc 100644 --- a/docker/gpu_framework_directory.py +++ b/docker/gpu_framework_directory.py @@ -15,7 +15,7 @@ def get_latest_package_version(package_name): try: url = f"https://pypi.org/pypi/{package_name}/json" - response = requests.get(url) + response = requests.get(url, timeout=10) response.raise_for_status() package_info = response.json() return package_info["info"]["version"] diff --git a/scripts/run_tests/helpers.py b/scripts/run_tests/helpers.py index 9d2f1a7928571..2380fb1f78ce6 100644 --- a/scripts/run_tests/helpers.py +++ b/scripts/run_tests/helpers.py @@ -4,7 +4,7 @@ def get_latest_package_version(package_name): try: url = f"https://pypi.org/pypi/{package_name}/json" - response = requests.get(url) + response = requests.get(url, timeout=10) response.raise_for_status() package_info = response.json() return package_info["info"]["version"] From 8d1df683619499d831f6100a2b1d8bfee3681a5a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 14 Dec 2023 18:54:33 +0530 Subject: [PATCH 360/978] fix: Fixed wrong links in docs. (#27748) --- docs/overview/contributing/open_tasks.rst | 2 +- docs/overview/contributing/the_basics.rst | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/overview/contributing/open_tasks.rst b/docs/overview/contributing/open_tasks.rst index 081f7946d6488..6b6f80cb1ec7e 100644 --- a/docs/overview/contributing/open_tasks.rst +++ b/docs/overview/contributing/open_tasks.rst @@ -3,7 +3,7 @@ Open Tasks .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`open tasks channel`: https://discord.com/channels/799879767196958751/985156466963021854 +.. _`open tasks channel`: https://discord.com/channels/799879767196958751/982728618469912627 .. _`issue description`: https://github.com/unifyai/ivy/issues/1526 .. _`reference API`: https://numpy.org/doc/stable/reference/routines.linalg.html .. _`imports`: https://github.com/unifyai/ivy/blob/38dbb607334cb32eb513630c4496ad0024f80e1c/ivy/functional/frontends/numpy/__init__.py#L27 diff --git a/docs/overview/contributing/the_basics.rst b/docs/overview/contributing/the_basics.rst index dd43ce0ae0a19..6209f295be4c3 100644 --- a/docs/overview/contributing/the_basics.rst +++ b/docs/overview/contributing/the_basics.rst @@ -7,7 +7,6 @@ The Basics .. _`Atlassian tutorial`: https://www.atlassian.com/git/tutorials/saving-changes/git-stash .. _`fork management channel`: https://discord.com/channels/799879767196958751/982728689408167956 .. _`pull requests channel`: https://discord.com/channels/799879767196958751/982728733859414056 -.. _`commit frequency channel`: https://discord.com/channels/799879767196958751/982728822317256712 .. _`PyCharm blog`: https://www.jetbrains.com/help/pycharm/finding-and-replacing-text-in-file.html .. _`Debugging`: https://www.jetbrains.com/help/pycharm/debugging-code.html @@ -599,4 +598,4 @@ with PyCharm This should have hopefully given you a good understanding of the basics for contributing. -If you have any questions, please feel free to reach out on `discord`_ in the `todo list issues channel`_, `fork management channel`_, `pull requests channel`_, `commit frequency channel`_ depending on the question! +If you have any questions, please feel free to reach out on `discord`_ in the `todo list issues channel`_, `fork management channel`_, `pull requests channel`_, depending on the question! From 5e58f073535f2c73dd11d4a4e7f0abb1066b4be0 Mon Sep 17 00:00:00 2001 From: guillesanbri Date: Thu, 14 Dec 2023 14:49:12 +0100 Subject: [PATCH 361/978] Update get_started.rst with api key instructions (#27749) --- docs/overview/get_started.rst | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/overview/get_started.rst b/docs/overview/get_started.rst index 42b3e1e1f12c3..6ef698dab4046 100644 --- a/docs/overview/get_started.rst +++ b/docs/overview/get_started.rst @@ -59,9 +59,8 @@ where OS-specific and IDE-specific instructions and video tutorials to install I Ivy's tracer and transpiler ----------------------------- -To use Ivy's tracer and transpiler, you'll need an **API key**. We are starting to -grant pilot access to certain users, so you can `join the waitlist `_ -if you want to get one! +To use Ivy's tracer and transpiler, you'll need an **API key**. If you don't have one yet, you can +register in `the console `_ to get it! Ivy Folder ~~~~~~~~~~ From 4eda5bfb91e45d182afc75f21c3b200253ee64c0 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 14 Dec 2023 13:50:57 +0000 Subject: [PATCH 362/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/get_started.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/get_started.rst b/docs/overview/get_started.rst index 6ef698dab4046..50d66ffe7ceb7 100644 --- a/docs/overview/get_started.rst +++ b/docs/overview/get_started.rst @@ -59,7 +59,7 @@ where OS-specific and IDE-specific instructions and video tutorials to install I Ivy's tracer and transpiler ----------------------------- -To use Ivy's tracer and transpiler, you'll need an **API key**. If you don't have one yet, you can +To use Ivy's tracer and transpiler, you'll need an **API key**. If you don't have one yet, you can register in `the console `_ to get it! Ivy Folder From b8ffd4f59546b759ccc9b6da797daf7184eb7201 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 14 Dec 2023 22:15:56 +0530 Subject: [PATCH 363/978] feat: Updated `jax` version to 0.4.23 (#27753) Co-authored-by: joaozenobio --- ivy/functional/backends/jax/__init__.py | 24 ++++---- ivy/functional/backends/jax/elementwise.py | 28 +++++----- .../backends/jax/experimental/elementwise.py | 2 +- .../backends/jax/experimental/layers.py | 6 +- .../backends/jax/experimental/random.py | 2 +- .../backends/jax/experimental/sorting.py | 2 +- .../backends/jax/experimental/statistical.py | 6 +- ivy/functional/backends/jax/general.py | 4 +- ivy/functional/backends/jax/linear_algebra.py | 56 +++++++++---------- ivy/functional/backends/jax/manipulation.py | 2 +- ivy/functional/backends/jax/random.py | 2 +- ivy/functional/backends/jax/searching.py | 4 +- ivy/functional/backends/jax/sorting.py | 2 +- ivy/functional/backends/jax/statistical.py | 4 +- ivy/functional/frontends/__init__.py | 2 +- ivy/functional/frontends/jax/lax/operators.py | 8 +-- .../jax/nn/non_linear_activations.py | 2 +- .../frontends/jax/numpy/creation.py | 6 +- ivy/functional/frontends/jax/numpy/linalg.py | 4 +- ivy/functional/frontends/jax/numpy/logic.py | 4 +- .../jax/numpy/mathematical_functions.py | 12 ++-- .../frontends/jax/numpy/searching_sorting.py | 4 +- .../frontends/jax/numpy/statistical.py | 6 +- ivy/functional/frontends/jax/random.py | 32 +++++------ 24 files changed, 112 insertions(+), 112 deletions(-) diff --git a/ivy/functional/backends/jax/__init__.py b/ivy/functional/backends/jax/__init__.py index 171ffe5a794d4..b0d52c4819e6d 100644 --- a/ivy/functional/backends/jax/__init__.py +++ b/ivy/functional/backends/jax/__init__.py @@ -101,7 +101,7 @@ def _array_unflatten(aux_data, children): # update these to add new dtypes valid_dtypes = { - "0.4.21 and below": ( + "0.4.23 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -120,7 +120,7 @@ def _array_unflatten(aux_data, children): ) } valid_numeric_dtypes = { - "0.4.21 and below": ( + "0.4.23 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -139,7 +139,7 @@ def _array_unflatten(aux_data, children): } valid_int_dtypes = { - "0.4.21 and below": ( + "0.4.23 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -152,12 +152,12 @@ def _array_unflatten(aux_data, children): } valid_uint_dtypes = { - "0.4.21 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) + "0.4.23 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) } valid_float_dtypes = { - "0.4.21 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) + "0.4.23 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) } -valid_complex_dtypes = {"0.4.21 and below": (ivy.complex64, ivy.complex128)} +valid_complex_dtypes = {"0.4.23 and below": (ivy.complex64, ivy.complex128)} # leave these untouched @@ -172,12 +172,12 @@ def _array_unflatten(aux_data, children): # invalid data types # update these to add new dtypes -invalid_dtypes = {"0.4.21 and below": ()} -invalid_numeric_dtypes = {"0.4.21 and below": ()} -invalid_int_dtypes = {"0.4.21 and below": ()} -invalid_float_dtypes = {"0.4.21 and below": ()} -invalid_uint_dtypes = {"0.4.21 and below": ()} -invalid_complex_dtypes = {"0.4.21 and below": ()} +invalid_dtypes = {"0.4.23 and below": ()} +invalid_numeric_dtypes = {"0.4.23 and below": ()} +invalid_int_dtypes = {"0.4.23 and below": ()} +invalid_float_dtypes = {"0.4.23 and below": ()} +invalid_uint_dtypes = {"0.4.23 and below": ()} +invalid_complex_dtypes = {"0.4.23 and below": ()} # leave these untouched invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index 909da651c29e6..8da329110a6d5 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -72,7 +72,7 @@ def atanh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arctanh(x) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def bitwise_and( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -84,14 +84,14 @@ def bitwise_and( return jnp.bitwise_and(x1, x2) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def bitwise_invert( x: Union[int, JaxArray], /, *, out: Optional[JaxArray] = None ) -> JaxArray: return jnp.bitwise_not(x) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def bitwise_left_shift( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -103,7 +103,7 @@ def bitwise_left_shift( return jnp.left_shift(x1, x2) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def bitwise_or( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -115,7 +115,7 @@ def bitwise_or( return jnp.bitwise_or(x1, x2) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def bitwise_right_shift( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -127,7 +127,7 @@ def bitwise_right_shift( return jnp.right_shift(x1, x2) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def bitwise_xor( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -139,7 +139,7 @@ def bitwise_xor( return jnp.bitwise_xor(x1, x2) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def ceil(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -151,7 +151,7 @@ def cos(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.cos(x) -@with_unsupported_dtypes({"0.4.21 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("float16",)}, backend_version) def cosh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.cosh(x) @@ -191,7 +191,7 @@ def expm1(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.expm1(x) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def floor(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -199,7 +199,7 @@ def floor(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.floor(x) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def floor_divide( x1: Union[float, JaxArray], x2: Union[float, JaxArray], @@ -427,7 +427,7 @@ def pow( return jnp.power(x1, x2) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def remainder( x1: Union[float, JaxArray], x2: Union[float, JaxArray], @@ -524,7 +524,7 @@ def tanh( return jnp.tanh(x) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def trunc(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -564,7 +564,7 @@ def angle( # ------# -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def erf(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jax.scipy.special.erf(x) @@ -615,7 +615,7 @@ def isreal(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.isreal(x) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def fmod( x1: JaxArray, x2: JaxArray, diff --git a/ivy/functional/backends/jax/experimental/elementwise.py b/ivy/functional/backends/jax/experimental/elementwise.py index 1ebf9d8c99ff8..1880fd049e412 100644 --- a/ivy/functional/backends/jax/experimental/elementwise.py +++ b/ivy/functional/backends/jax/experimental/elementwise.py @@ -50,7 +50,7 @@ def sinc(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: @with_supported_dtypes( - {"0.4.21 and below": ("float16", "float32", "float64")}, backend_version + {"0.4.23 and below": ("float16", "float32", "float64")}, backend_version ) def lgamma(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jlax.lgamma(x) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 475749cadcc31..3b66486a28dfe 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -440,7 +440,7 @@ def avg_pool3d( return res -@with_supported_dtypes({"0.4.21 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"0.4.23 and below": ("float32", "float64")}, backend_version) def dct( x: JaxArray, /, @@ -822,7 +822,7 @@ def ifftn( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, backend_version + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version ) def embedding( weights: JaxArray, @@ -870,7 +870,7 @@ def rfft( return ret -@with_unsupported_dtypes({"0.4.21 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("float16", "complex")}, backend_version) def rfftn( x: JaxArray, s: Optional[Sequence[int]] = None, diff --git a/ivy/functional/backends/jax/experimental/random.py b/ivy/functional/backends/jax/experimental/random.py index 4675cf0d8293d..17b2d54037a99 100644 --- a/ivy/functional/backends/jax/experimental/random.py +++ b/ivy/functional/backends/jax/experimental/random.py @@ -56,7 +56,7 @@ def beta( return jax.random.beta(rng_input, a, b, shape, dtype) -@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, backend_version) def gamma( alpha: Union[float, JaxArray], beta: Union[float, JaxArray], diff --git a/ivy/functional/backends/jax/experimental/sorting.py b/ivy/functional/backends/jax/experimental/sorting.py index 9dcc596eae53c..c73727cc612c7 100644 --- a/ivy/functional/backends/jax/experimental/sorting.py +++ b/ivy/functional/backends/jax/experimental/sorting.py @@ -23,7 +23,7 @@ def invert_permutation( # lexsort -@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, backend_version) def lexsort( keys: JaxArray, /, diff --git a/ivy/functional/backends/jax/experimental/statistical.py b/ivy/functional/backends/jax/experimental/statistical.py index f83e98bee4c88..c2ac4780dcee9 100644 --- a/ivy/functional/backends/jax/experimental/statistical.py +++ b/ivy/functional/backends/jax/experimental/statistical.py @@ -10,7 +10,7 @@ @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16",)}, + {"0.4.23 and below": ("bfloat16",)}, backend_version, ) def histogram( @@ -121,7 +121,7 @@ def histogram( @with_unsupported_dtypes( - {"0.4.21 and below": ("complex64", "complex128")}, backend_version + {"0.4.23 and below": ("complex64", "complex128")}, backend_version ) def median( input: JaxArray, @@ -406,7 +406,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "bfloat16", "bool", ) diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index 4bca2a71db150..a21e94b23fc12 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -102,7 +102,7 @@ def array_equal(x0: JaxArray, x1: JaxArray, /) -> bool: return bool(jnp.array_equal(x0, x1)) -@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, backend_version) def to_numpy(x: JaxArray, /, *, copy: bool = True) -> np.ndarray: if copy: return np.array(_to_array(x)) @@ -421,7 +421,7 @@ def vmap( ) -@with_unsupported_dtypes({"0.4.21 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("float16", "bfloat16")}, backend_version) def isin( elements: JaxArray, test_elements: JaxArray, diff --git a/ivy/functional/backends/jax/linear_algebra.py b/ivy/functional/backends/jax/linear_algebra.py index c5243e5c404de..70cfd1c32047d 100644 --- a/ivy/functional/backends/jax/linear_algebra.py +++ b/ivy/functional/backends/jax/linear_algebra.py @@ -20,7 +20,7 @@ @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def cholesky( @@ -34,7 +34,7 @@ def cholesky( return ret -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def cross( x1: JaxArray, x2: JaxArray, @@ -51,14 +51,14 @@ def cross( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def det(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.linalg.det(x) -@with_unsupported_dtypes({"0.4.21 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("float16", "bfloat16")}, backend_version) def eig(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> Tuple[JaxArray]: result_tuple = NamedTuple( "eig", [("eigenvalues", JaxArray), ("eigenvectors", JaxArray)] @@ -67,7 +67,7 @@ def eig(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> Tuple[JaxArray]: return result_tuple(eigenvalues, eigenvectors) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def diagonal( x: JaxArray, /, @@ -104,7 +104,7 @@ def tensorsolve( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def eigh( @@ -118,7 +118,7 @@ def eigh( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def eigvalsh( @@ -127,14 +127,14 @@ def eigvalsh( return jnp.linalg.eigvalsh(x, UPLO=UPLO) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def inner(x1: JaxArray, x2: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: x1, x2 = ivy.promote_types_of_inputs(x1, x2) return jnp.inner(x1, x2) @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def inv( @@ -155,7 +155,7 @@ def inv( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matmul( @@ -181,7 +181,7 @@ def matmul( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matrix_norm( @@ -202,13 +202,13 @@ def matrix_norm( return jnp.linalg.norm(x, ord=ord, axis=axis, keepdims=keepdims) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def matrix_power(x: JaxArray, n: int, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.linalg.matrix_power(x, n) @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matrix_rank( @@ -239,7 +239,7 @@ def matrix_rank( @with_unsupported_dtypes( - {"0.4.21 and below": ("int", "float16", "complex")}, + {"0.4.23 and below": ("int", "float16", "complex")}, backend_version, ) def matrix_transpose( @@ -251,7 +251,7 @@ def matrix_transpose( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def outer( @@ -266,7 +266,7 @@ def outer( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def pinv( @@ -284,7 +284,7 @@ def pinv( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def qr( @@ -296,7 +296,7 @@ def qr( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def slogdet( @@ -309,7 +309,7 @@ def slogdet( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def solve( @@ -351,7 +351,7 @@ def solve( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svd( @@ -368,7 +368,7 @@ def svd( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svdvals( @@ -378,7 +378,7 @@ def svdvals( return jnp.linalg.svd(x, compute_uv=False) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def tensordot( x1: JaxArray, x2: JaxArray, @@ -392,7 +392,7 @@ def tensordot( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def trace( @@ -407,7 +407,7 @@ def trace( return jnp.trace(x, offset=offset, axis1=axis1, axis2=axis2, out=out) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def vecdot( x1: JaxArray, x2: JaxArray, /, *, axis: int = -1, out: Optional[JaxArray] = None ) -> JaxArray: @@ -415,7 +415,7 @@ def vecdot( return jnp.tensordot(x1, x2, axes=(axis, axis)) -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def vector_norm( x: JaxArray, /, @@ -445,7 +445,7 @@ def vector_norm( # ------# -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def diag( x: JaxArray, /, @@ -457,7 +457,7 @@ def diag( @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "complex")}, + {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def vander( @@ -473,7 +473,7 @@ def vander( @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/jax/manipulation.py b/ivy/functional/backends/jax/manipulation.py index c7bc18b42c636..3d3b7c792a21c 100644 --- a/ivy/functional/backends/jax/manipulation.py +++ b/ivy/functional/backends/jax/manipulation.py @@ -226,7 +226,7 @@ def clip( return x -@with_unsupported_dtypes({"0.4.21 and below": ("uint64",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("uint64",)}, backend_version) def constant_pad( x: JaxArray, /, diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index 21299380b363a..c2e98759fe2c4 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -83,7 +83,7 @@ def random_normal( return jax.random.normal(rng_input, shape, dtype=dtype) * std + mean -@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/jax/searching.py b/ivy/functional/backends/jax/searching.py index a2a6a7381ec2d..2e2a321aa26fb 100644 --- a/ivy/functional/backends/jax/searching.py +++ b/ivy/functional/backends/jax/searching.py @@ -12,7 +12,7 @@ # ------------------ # -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def argmax( x: JaxArray, /, @@ -38,7 +38,7 @@ def argmax( return ret -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def argmin( x: JaxArray, /, diff --git a/ivy/functional/backends/jax/sorting.py b/ivy/functional/backends/jax/sorting.py index 525aadfe4f8fe..fde2f9e9910df 100644 --- a/ivy/functional/backends/jax/sorting.py +++ b/ivy/functional/backends/jax/sorting.py @@ -78,7 +78,7 @@ def searchsorted( # msort -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def msort( a: Union[JaxArray, list, tuple], /, diff --git a/ivy/functional/backends/jax/statistical.py b/ivy/functional/backends/jax/statistical.py index 3524c4ff88d36..3ea7390120149 100644 --- a/ivy/functional/backends/jax/statistical.py +++ b/ivy/functional/backends/jax/statistical.py @@ -38,7 +38,7 @@ def max( @with_unsupported_dtypes( - {"0.4.21 and below": "bfloat16"}, + {"0.4.23 and below": "bfloat16"}, backend_version, ) def mean( @@ -143,7 +143,7 @@ def var( # ------# -@with_unsupported_dtypes({"0.4.21 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": "bfloat16"}, backend_version) def cumprod( x: JaxArray, /, diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 712f483d3df7e..a5d07002848f8 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -5,7 +5,7 @@ "torch": "2.1.1", "tensorflow": "2.15.0", "numpy": "1.25.2", - "jax": "0.4.21", + "jax": "0.4.23", "scipy": "1.10.1", "paddle": "2.5.2", "sklearn": "1.3.0", diff --git a/ivy/functional/frontends/jax/lax/operators.py b/ivy/functional/frontends/jax/lax/operators.py index 935911d628424..c0967b50436d7 100644 --- a/ivy/functional/frontends/jax/lax/operators.py +++ b/ivy/functional/frontends/jax/lax/operators.py @@ -157,7 +157,7 @@ def broadcast(operand, sizes): @with_supported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "float32", "float64", @@ -309,7 +309,7 @@ def cosh(x): @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16", "float16", "bool", "complex64", "complex128")}, + {"0.4.23 and below": ("bfloat16", "float16", "bool", "complex64", "complex128")}, "jax", ) @to_ivy_arrays_and_back @@ -400,7 +400,7 @@ def erf(x): @with_supported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "float32", "float64", @@ -465,7 +465,7 @@ def imag(x): @with_unsupported_dtypes( - {"0.4.21 and below": ("bool", "bfloat16")}, + {"0.4.23 and below": ("bool", "bfloat16")}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/nn/non_linear_activations.py b/ivy/functional/frontends/jax/nn/non_linear_activations.py index 726114cbac3e1..71114b968d1b4 100644 --- a/ivy/functional/frontends/jax/nn/non_linear_activations.py +++ b/ivy/functional/frontends/jax/nn/non_linear_activations.py @@ -289,7 +289,7 @@ def sigmoid(x): @with_supported_dtypes( - {"0.4.21 and below": ("complex", "float")}, + {"0.4.23 and below": ("complex", "float")}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/numpy/creation.py b/ivy/functional/frontends/jax/numpy/creation.py index b83c1ff83d27e..50e912565ec45 100644 --- a/ivy/functional/frontends/jax/numpy/creation.py +++ b/ivy/functional/frontends/jax/numpy/creation.py @@ -17,7 +17,7 @@ @with_unsupported_device_and_dtypes( { - "0.4.21 and below": { + "0.4.23 and below": { "cpu": ( "float16", "bflooat16", @@ -196,7 +196,7 @@ def iterable(y): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -217,7 +217,7 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/frontends/jax/numpy/linalg.py b/ivy/functional/frontends/jax/numpy/linalg.py index 04c18eec1313f..4e014dee3178f 100644 --- a/ivy/functional/frontends/jax/numpy/linalg.py +++ b/ivy/functional/frontends/jax/numpy/linalg.py @@ -88,7 +88,7 @@ def multi_dot(arrays, *, precision=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"0.4.21 and below": ("float32", "float64")}, + {"0.4.23 and below": ("float32", "float64")}, "jax", ) def norm(x, ord=None, axis=None, keepdims=False): @@ -127,7 +127,7 @@ def svd(a, /, *, full_matrices=True, compute_uv=True, hermitian=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.21 and below": ("float16", "bfloat16")}, "jax") +@with_unsupported_dtypes({"0.4.23 and below": ("float16", "bfloat16")}, "jax") def tensorinv(a, ind=2): old_shape = ivy.shape(a) prod = 1 diff --git a/ivy/functional/frontends/jax/numpy/logic.py b/ivy/functional/frontends/jax/numpy/logic.py index d5a28d2803509..e1bc10cd40f16 100644 --- a/ivy/functional/frontends/jax/numpy/logic.py +++ b/ivy/functional/frontends/jax/numpy/logic.py @@ -101,7 +101,7 @@ def equal(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, "jax") +@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, "jax") def fromfunction(function, shape, *, dtype=float, **kwargs): def canonicalize_shape(shape, context="shape argument"): if isinstance(shape, int): @@ -285,7 +285,7 @@ def right_shift(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16", "bool")}, "jax") +@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16", "bool")}, "jax") def setxor1d(ar1, ar2, assume_unique=False): common_dtype = ivy.promote_types(ivy.dtype(ar1), ivy.dtype(ar2)) ar1 = ivy.asarray(ar1, dtype=common_dtype) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 9e661cad4746e..70874ade1a5d8 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -76,7 +76,7 @@ def around(a, decimals=0, out=None): @with_unsupported_dtypes( - {"0.4.21 and below": ("bfloat16",)}, + {"0.4.23 and below": ("bfloat16",)}, "jax", ) @to_ivy_arrays_and_back @@ -420,7 +420,7 @@ def expm1( @with_unsupported_dtypes( - {"0.4.21 and below": ("uint16",)}, + {"0.4.23 and below": ("uint16",)}, "jax", ) @to_ivy_arrays_and_back @@ -584,7 +584,7 @@ def minimum(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.21 and below": ("complex",)}, "jax") +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, "jax") def mod(x1, x2, /): x1, x2 = promote_types_of_jax_inputs(x1, x2) return ivy.remainder(x1, x2) @@ -626,7 +626,7 @@ def negative( @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "bfloat16", "float16", ) @@ -671,7 +671,7 @@ def polyadd(a1, a2): @with_unsupported_dtypes( - {"0.4.21 and below": ("float16",)}, + {"0.4.23 and below": ("float16",)}, "jax", ) @to_ivy_arrays_and_back @@ -713,7 +713,7 @@ def polydiv(u, v, *, trim_leading_zeros=False): @with_unsupported_dtypes( - {"0.4.21 and below": ("float16",)}, + {"0.4.23 and below": ("float16",)}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/numpy/searching_sorting.py b/ivy/functional/frontends/jax/numpy/searching_sorting.py index 8f8e43a8f85e5..cf0973d83d4a4 100644 --- a/ivy/functional/frontends/jax/numpy/searching_sorting.py +++ b/ivy/functional/frontends/jax/numpy/searching_sorting.py @@ -16,7 +16,7 @@ @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -111,7 +111,7 @@ def argwhere(a, /, *, size=None, fill_value=None): @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "uint8", "int8", "bool", diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py index 43ed0fe0499b7..8c26ec22e3c75 100644 --- a/ivy/functional/frontends/jax/numpy/statistical.py +++ b/ivy/functional/frontends/jax/numpy/statistical.py @@ -103,7 +103,7 @@ def corrcoef(x, y=None, rowvar=True): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.21 and below": ("float16", "bfloat16")}, "jax") +@with_unsupported_dtypes({"0.4.23 and below": ("float16", "bfloat16")}, "jax") def correlate(a, v, mode="valid", precision=None): if ivy.get_num_dims(a) != 1 or ivy.get_num_dims(v) != 1: raise ValueError("correlate() only support 1-dimensional inputs.") @@ -572,7 +572,7 @@ def ptp(a, axis=None, out=None, keepdims=False): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.21 and below": ("complex64", "complex128", "bfloat16", "bool", "float16")}, + {"0.4.23 and below": ("complex64", "complex128", "bfloat16", "bool", "float16")}, "jax", ) def quantile( @@ -597,7 +597,7 @@ def quantile( @handle_jax_dtype -@with_unsupported_dtypes({"0.4.21 and below": ("bfloat16",)}, "jax") +@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, "jax") @to_ivy_arrays_and_back def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=None): axis = tuple(axis) if isinstance(axis, list) else axis diff --git a/ivy/functional/frontends/jax/random.py b/ivy/functional/frontends/jax/random.py index 898b45aa05a5a..6fbc288c0aeb6 100644 --- a/ivy/functional/frontends/jax/random.py +++ b/ivy/functional/frontends/jax/random.py @@ -38,7 +38,7 @@ def PRNGKey(seed): @to_ivy_arrays_and_back @with_supported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float32", "float64", ) @@ -70,7 +70,7 @@ def bernoulli(key, p=0.5, shape=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -85,7 +85,7 @@ def beta(key, a, b, shape=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -133,7 +133,7 @@ def cauchy(key, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -149,7 +149,7 @@ def dirichlet(key, alpha, shape=None, dtype="float32"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.21 and below": "uint32"}, + {"0.4.23 and below": "uint32"}, "jax", ) def double_sided_maxwell(key, loc, scale, shape=(), dtype="float64"): @@ -168,7 +168,7 @@ def double_sided_maxwell(key, loc, scale, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -196,7 +196,7 @@ def fold_in(key, data): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -212,7 +212,7 @@ def gamma(key, a, shape=None, dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -231,7 +231,7 @@ def generalized_normal(key, p, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -255,7 +255,7 @@ def gumbel(key, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -270,7 +270,7 @@ def loggamma(key, a, shape=None, dtype="float64"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.21 and below": ("float16", "bfloat16")}, + {"0.4.23 and below": ("float16", "bfloat16")}, "jax", ) def logistic(key, shape=(), dtype="float64"): @@ -301,7 +301,7 @@ def maxwell(key, shape, dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -358,7 +358,7 @@ def orthogonal(key, n, shape=(), dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.21 and below": ( + "0.4.23 and below": ( "float16", "bfloat16", ) @@ -393,7 +393,7 @@ def permutation(key, x, axis=0, independent=False): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.21 and below": ("unsigned", "int8", "int16")}, + {"0.4.23 and below": ("unsigned", "int8", "int16")}, "jax", ) def poisson(key, lam, shape=None, dtype=None): @@ -404,7 +404,7 @@ def poisson(key, lam, shape=None, dtype=None): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.21 and below": ("unsigned", "int8", "int16")}, + {"0.4.23 and below": ("unsigned", "int8", "int16")}, "jax", ) def rademacher(key, shape, dtype="int64"): @@ -418,7 +418,7 @@ def rademacher(key, shape, dtype="int64"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.21 and below": ("unsigned", "int8", "int16")}, + {"0.4.23 and below": ("unsigned", "int8", "int16")}, "jax", ) def randint(key, shape, minval, maxval, dtype="int64"): From 3420c3dfc8ad278fb87f8c07817ca2078d72c497 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 15 Dec 2023 00:55:38 +0530 Subject: [PATCH 364/978] fix: Added missing `staticmethod` decorator (#27751) --- ivy/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/__init__.py b/ivy/__init__.py index a816d0b255fd5..54a493d5f7e6e 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -429,6 +429,7 @@ def assert_has_rank(self, rank): if self.rank not in (None, rank): raise ValueError(f"Shape {self} must have rank {rank}") + @staticmethod def unknown_shape(rank=None, **kwargs): if rank is None and "ndims" in kwargs: rank = kwargs.pop("ndims") @@ -457,6 +458,7 @@ def with_rank_at_most(self, rank): else: return self + @staticmethod def as_shape(shape): if isinstance(shape, Shape): return shape From 5f591f9e31d0ae726d41ca0ab7ec4719e316f9f5 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 15 Dec 2023 05:11:53 +0400 Subject: [PATCH 365/978] Add MacOS binaries --- available_configs.json | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/available_configs.json b/available_configs.json index da04c67cda05a..2b0292df9890b 100644 --- a/available_configs.json +++ b/available_configs.json @@ -3,9 +3,12 @@ "cp38-cp38-manylinux_2_17_x86_64", "cp39-cp39-manylinux_2_17_x86_64", "cp310-cp310-manylinux_2_17_x86_64", - "cp311-cp311-manylinux_2_17_x86_64" + "cp311-cp311-manylinux_2_17_x86_64", + "cp310-cp310-macosx_arm64_darwin", + "cp311-cp311-macosx_arm64_darwin" ], "engines": [ - "cp310-cp310-manylinux_2_17_x86_64" + "cp310-cp310-manylinux_2_17_x86_64", + "cp310-cp310-macosx_arm64_darwin" ] } From 08611cd5dfc6d22c73e7ce763371e501b5869247 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 15 Dec 2023 21:59:55 +0400 Subject: [PATCH 366/978] Update available_configs.json --- available_configs.json | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/available_configs.json b/available_configs.json index 2b0292df9890b..1be6f4a48bb34 100644 --- a/available_configs.json +++ b/available_configs.json @@ -8,7 +8,6 @@ "cp311-cp311-macosx_arm64_darwin" ], "engines": [ - "cp310-cp310-manylinux_2_17_x86_64", - "cp310-cp310-macosx_arm64_darwin" + "cp310-cp310-manylinux_2_17_x86_64" ] } From 822b98c14c34cbeb2aa206a41eb55bbd40327c01 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Fri, 15 Dec 2023 18:38:13 +0000 Subject: [PATCH 367/978] Update compiler.py --- ivy/compiler/compiler.py | 40 ++++++++++++++++++++++++---------------- 1 file changed, 24 insertions(+), 16 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index ba5f858ee07d7..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -1,4 +1,4 @@ -from typing import Callable, Optional, List, Union, Iterable, Tuple, Mapping +from typing import Callable, Optional, List, Union, Iterable, Sequence, Mapping def trace_graph( @@ -10,18 +10,18 @@ def trace_graph( include_generators: bool = True, array_caching: bool = True, with_numpy: bool = True, + modes_to_trace: str = "all", backend_compile: bool = False, static_argnums: Optional[Union[int, Iterable[int]]] = None, static_argnames: Optional[Union[str, Iterable[str]]] = None, - mode: Optional[str] = None, + compile_mode: Optional[str] = None, graph_caching: bool = False, - args: Optional[Tuple] = None, + args: Optional[Sequence] = None, kwargs: Optional[Mapping] = None, params_v=None, v=None ): - """Take `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -37,14 +37,17 @@ def trace_graph( include array creation/generation functions as part of the graph array_caching cache the constant arrays that appear as arguments to the functions in the graph + modes_to_trace + the module mode(s) which should be traced when tracing a trainable module + can be either "all", "train" or "eval". backend_compile whether to apply the native compilers, i.e. tf.function, after ivy's tracing static_argnums for jax's jit compilation static_argnames for jax's jit compilation - mode - for torch's compilation + compile_mode + mode for torch's compilation graph_caching whether to cache the traced graph args @@ -88,8 +91,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" + from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -101,10 +104,11 @@ def trace_graph( include_generators=include_generators, array_caching=array_caching, with_numpy=with_numpy, + modes_to_trace=modes_to_trace, backend_compile=backend_compile, static_argnums=static_argnums, static_argnames=static_argnames, - mode=mode, + compile_mode=compile_mode, graph_caching=graph_caching, args=args, kwargs=kwargs, @@ -121,12 +125,13 @@ def transpile( backend_compile: bool = False, static_argnums: Optional[Union[int, Iterable[int]]] = None, static_argnames: Optional[Union[str, Iterable[str]]] = None, - mode: Optional[str] = None, + compile_mode: Optional[str] = None, graph_caching: bool = False, + modes_to_trace: str = "all", stateful: Optional[List] = None, arg_stateful_idxs: Optional[List] = None, kwarg_stateful_idxs: Optional[List] = None, - args: Optional[Tuple] = None, + args: Optional[Sequence] = None, kwargs: Optional[Mapping] = None, params_v=None, v=None @@ -150,8 +155,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" + from ._compiler import transpile as _transpile return _transpile( @@ -162,8 +167,9 @@ def transpile( backend_compile=backend_compile, static_argnums=static_argnums, static_argnames=static_argnames, - mode=mode, + compile_mode=compile_mode, graph_caching=graph_caching, + modes_to_trace=modes_to_trace, stateful=stateful, arg_stateful_idxs=arg_stateful_idxs, kwarg_stateful_idxs=kwarg_stateful_idxs, @@ -178,9 +184,10 @@ def unify( *objs: Callable, source: Optional[str] = None, graph_caching: bool = False, - args: Optional[Tuple] = None, + args: Optional[Sequence] = None, kwargs: Optional[Mapping] = None, with_numpy: bool = True, + modes_to_trace: str = "all", **transpile_kwargs ): from ._compiler import unify as _unify @@ -192,5 +199,6 @@ def unify( args=args, kwargs=kwargs, with_numpy=with_numpy, + modes_to_trace=modes_to_trace, **transpile_kwargs, ) From d57a9bbe817e23929f95f144f8d5137956215606 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 15 Dec 2023 18:39:45 +0000 Subject: [PATCH 368/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From 5a3f69a5cb0d78a694d9305dfd82e345567569f7 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Fri, 15 Dec 2023 18:41:41 +0000 Subject: [PATCH 369/978] Update compiler.py --- ivy/compiler/compiler.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,7 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" from ._compiler import trace_graph as _trace_graph @@ -157,8 +155,7 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" from ._compiler import transpile as _transpile From 54a53c7931b0823eee04239e6b3f9314f4433006 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 15 Dec 2023 18:43:19 +0000 Subject: [PATCH 370/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From 5d4fc4c58ad730d5fc90d92e6157d65fcf4c6f43 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Fri, 15 Dec 2023 18:59:26 +0000 Subject: [PATCH 371/978] Update compiler.py --- ivy/compiler/compiler.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,7 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" from ._compiler import trace_graph as _trace_graph @@ -157,8 +155,7 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" from ._compiler import transpile as _transpile From 0a7cedeb9feec0ae792589f868d8f59b696395e2 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 15 Dec 2023 19:00:59 +0000 Subject: [PATCH 372/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From bed1e7bedd6882272eea72a213058921523a1e63 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sat, 16 Dec 2023 19:34:28 +0000 Subject: [PATCH 373/978] Update compiler.py --- ivy/compiler/compiler.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,7 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" from ._compiler import trace_graph as _trace_graph @@ -157,8 +155,7 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" from ._compiler import transpile as _transpile From 6434dee8a7e6a0e4b4c8b5022d02c05277252569 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 16 Dec 2023 19:36:04 +0000 Subject: [PATCH 374/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From 42855063492c21f23cd2e01e861b837aa1207dd4 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sat, 16 Dec 2023 23:57:45 +0400 Subject: [PATCH 375/978] Update optional.txt --- requirements/optional.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/optional.txt b/requirements/optional.txt index a86e4aab24dfb..df07ce15dd0a8 100644 --- a/requirements/optional.txt +++ b/requirements/optional.txt @@ -11,7 +11,7 @@ jaxlib # unpinned, we test for latest version now paddlepaddle # unpinned , mod_name=paddle tensorflow-cpu # unpinned, we test for latest version now, mod_name=tensorflow torch # unpinned, we test for latest version now -torch-scatter # unpinned, mod_name=torch_scatter +# torch-scatter # unpinned, mod_name=torch_scatter scipy # unpinned dm-haiku # unpinned mod_name=haiku flax From 8aa98c563bc4748d590c69a2ce22b677d291e1eb Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sat, 16 Dec 2023 20:05:24 +0000 Subject: [PATCH 376/978] Update compiler.py --- ivy/compiler/compiler.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,7 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" from ._compiler import trace_graph as _trace_graph @@ -157,8 +155,7 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" from ._compiler import transpile as _transpile From 11deb83c970fa49574ce23a0908006d8a149db1b Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 16 Dec 2023 20:06:56 +0000 Subject: [PATCH 377/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From 1838f6d90a5b1f8079b3539ebbaea2439ab87a97 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sat, 16 Dec 2023 20:24:32 +0000 Subject: [PATCH 378/978] Update compiler.py --- ivy/compiler/compiler.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,7 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" from ._compiler import trace_graph as _trace_graph @@ -157,8 +155,7 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" from ._compiler import transpile as _transpile From a11f51d8537bc5d03deb7448c77504d004c76708 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 16 Dec 2023 20:26:05 +0000 Subject: [PATCH 379/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From a7fd9afad1cf9da2a541823f361e34a27a0607b6 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sat, 16 Dec 2023 20:33:59 +0000 Subject: [PATCH 380/978] Update compiler.py --- ivy/compiler/compiler.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,7 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" from ._compiler import trace_graph as _trace_graph @@ -157,8 +155,7 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" from ._compiler import transpile as _transpile From 0948e8ab4885bc9eed76b85d625ba29f10712b2f Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 16 Dec 2023 20:35:33 +0000 Subject: [PATCH 381/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From fd9bf218b4d2351006fe0084b8cbc5598638b231 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sun, 17 Dec 2023 20:22:53 +0400 Subject: [PATCH 382/978] Updated open tasks explains fixing failing test --- docs/overview/contributing/open_tasks.rst | 318 ++++++++++++---------- 1 file changed, 170 insertions(+), 148 deletions(-) diff --git a/docs/overview/contributing/open_tasks.rst b/docs/overview/contributing/open_tasks.rst index 6b6f80cb1ec7e..bca053e241726 100644 --- a/docs/overview/contributing/open_tasks.rst +++ b/docs/overview/contributing/open_tasks.rst @@ -1,6 +1,6 @@ Open Tasks ========== - + .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm .. _`open tasks channel`: https://discord.com/channels/799879767196958751/982728618469912627 @@ -8,127 +8,72 @@ Open Tasks .. _`reference API`: https://numpy.org/doc/stable/reference/routines.linalg.html .. _`imports`: https://github.com/unifyai/ivy/blob/38dbb607334cb32eb513630c4496ad0024f80e1c/ivy/functional/frontends/numpy/__init__.py#L27 .. _`Deep Dive`: ../deep_dive.rst - + Here, we explain all tasks which are currently open for contributions from the community! - + This section of the docs will be updated frequently, whereby new tasks will be added and completed tasks will be removed. The tasks outlined here are generally broad high-level tasks, each of which is made up of many individual sub-tasks, distributed across task-specific `ToDo List Issues `_. - + Please read about :ref:`overview/contributing/the_basics:ToDo List Issues` in detail before continuing. All tasks should be selected and allocated as described in the ToDo List Issues section. We make no mention of task selection and allocation in the explanations below, which instead focus on the steps to complete only once a sub-task has been allocated to you. - + The tasks currently open are: - + +#. Fixing Failing Tests #. Function Formatting #. Frontend APIs #. Ivy Experimental API - + We try to explain these tasks as clearly as possible, but in cases where things are not clear, then please feel free to reach out on `discord`_ in the `open tasks channel`_! - + Please always use the latest commit on GitHub when working on any of these tasks, **DO NOT** develop your code using the latest PyPI release of :code:`ivy`. - -Function Formatting -------------------- - -Currently, we have many ToDo list issues `open `_ for a general function formatting task, which is explained below. - -Each function in each submodule should be updated to follow the implementation instructions given in the `Deep Dive`_ section. -The updates should be applied for the: - -#. ivy API -#. all backend APIs -#. array instance methods -#. container instance methods -#. array operators -#. array reverse operators -#. container operators -#. container reverse operators - -The `Deep Dive`_ is an **essential** resource for learning how each of these functions/methods should be implemented. -Before starting any contribution task, you should go through the `Deep Dive`_, and familiarize yourself with the content. - -At the time of writing, many of the functions are not implemented as they should be. -You will need to make changes to the current implementations, but you do not need to address *all* sections of the `Deep Dive`_ in detail. -Specifically, you **do not** need to address the following: - -#. Implement the hypothesis testing for the function -#. Get the tests passing for your function, if they are failing before you start - -However, everything else covered in the `Deep Dive`_ must be addressed. -Some common important tasks are: - -#. Remove all :code:`lambda` and direct bindings for the backend functions (in :code:`ivy.functional.backends`), with each function instead defined using :code:`def`. -#. Implement the following if they don't exist but should do: :class:`ivy.Array` instance method, :class:`ivy.Container` instance method, :class:`ivy.Array` special method, :class:`ivy.Array` reverse special method, :class:`ivy.Container` special method, :class:`ivy.Container` reverse special method. -#. Make sure that the aforementioned methods are added into the correct category-specific parent class, such as :class:`ivy.ArrayWithElementwise`, :class:`ivy.ContainerWithManipulation` etc. -#. Correct all of the `Function Arguments <../deep_dive/function_arguments.rst>`_ and the type hints for every function **and** its *relevant methods*, including those you did not implement yourself. -#. Add the correct `Docstrings <../deep_dive/docstrings.rst>`_ to every function **and** its *relevant methods*, including those you did not implement yourself. -#. Add thorough `Docstring Examples <../deep_dive/docstring_examples.rst>`_ for every function **and** its *relevant methods* and ensure they pass the docstring tests. - -Formatting checklist -~~~~~~~~~~~~~~~~~~~~ - -After creating your Pull Request on github, you should then produce the checklist for the formatting task as follows: - -1. Add a comment with the following format: :code:`add_reformatting_checklist_` on your PR, where ** is the name of the category that the function belongs to. - An example of this is shown below. - -.. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_generator.png?raw=true - :width: 420 - -Using this formatting will then trigger our github automation bots to update your comment with the proper markdown text for the checklist. -These updates might take a few moments to take effect, so please be patient 🙂. - -2. After adding the checklist to your PR, you should then modify this checklist with the status of each item according to the symbols(emojis) within the LEGEND section. - -.. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_legend.png?raw=true - :width: 420 - -3. When all check items are marked as (✅, ⏩, or 🆗), you should request a review for your PR and we will start checking your implementation and marking the items as complete using the checkboxes next to them. - -.. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_checked.png?raw=true - :width: 420 - -4. In case you are stuck or need help with one of the checklist items, please add the 🆘 symbol next to the item on the checklist, and proceed to add a comment elaborating on your point of struggle with this item. -The PR assignee will then see this comment and address your issues. - -.. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_SOS.png?raw=true - :width: 420 - -**Notes**: - -1. It is important that the PR author is the one to add the checklist generating comment in order to ensure they will have access to edit and update it later. -2. The checklist items' statuses should be manually updated by the PR author. - It does not automatically run any tests to update them! -3. Do not edit the checklist text, only the emoji symbols. 😅 -4. Please refrain from using the checkboxes next to checklist items. - - + +Fixing Failing Tests +-------------------- + +In the Ivy repository, we've identified a range of functions and tests that currently fall short of our quality standards. The root of these issues is not always clear-cut. In some instances, the problem may lie within the functions themselves, while in others, it could be the tests, which were crafted by various contributors, that are at fault. This situation presents a unique opportunity for community involvement. We are actively inviting contributions from our community to help tackle these challenges. + +How to Contribute +~~~~~~~~~~~~~~~~~ + +**Identifying Issues** + +To get started, visit our issues page: `Failing Tests `_. Here, you will find a list of open issues labeled as "Failing Test" and "ToDo". These issues are categorised under various frameworks supported by our repository. We encourage you to select a framework you're comfortable with or interested in contributing to. + +**Selecting a Test** + +Within each framework, tests are classified as either "Priority Open" or "Other Open." While we prioritize fixing the "Priority Open" tests, contributions towards any test, including those labeled "Other Open," are highly valuable. Each test issue is linked directly to the specific failing workflow. This linkage provides you with immediate access to the details of what exactly is failing and the context around it. + +**Making Your Contribution** + +After selecting a test to work on, please fork the repository and create a new branch for your fix. Ensure that your solution addresses the issue effectively and doesn't introduce new errors. Once you're confident in your fix, submit a pull request to the main repository. Our team will review your contribution, provide feedback if necessary, and then merge your changes once they meet our standards. + Frontend APIs ------------- - + For this task, the goal will be to implement functions for each of the frontend functional APIs (see `Ivy as a Transpiler <../design/ivy_as_a_transpiler.rst>`_), with frontend APIs implemented for: :code:`JAX`, :code:`NumPy`, :code:`TensorFlow` :code:`PyTorch`, :code:`Paddle`, :code:`Scipy`, :code:`MXNet` and :code:`MindSpore`. - + Currently, we have many ToDo list issues `open `_ for this task. - + The general workflow for this task is: - + #. Find the correct location for the function by following the :ref:`overview/contributing/open_tasks:Where to place a frontend function` subsection below #. Implement the function by following the `Ivy Frontends <../deep_dive/ivy_frontends.rst>`_ guide #. Write tests for your function by following the `Ivy Frontend Tests <../deep_dive/ivy_frontends_tests.rst>`_ guide #. Verify that the tests for your function are passing - + If you feel as though there is an ivy function :code:`ivy.` clearly missing, which would make your frontend function much simpler to implement, then you should first do the following: - + #. Create a new issue with the title :code:`ivy.` #. Add the labels :code:`Suggestion`, :code:`Experimental`, :code:`Ivy API` and :code:`Next Release` to it #. Then simply leave this issue open. - + At some point, a member of our team will assess whether it should be added, and if so, they will add it to another appropriate ToDo list issue (see the open task below). You do not need to wait for this in order to proceed. - + After this, you then have two options for how to proceed: - + #. Try to implement the function as a composition of currently present ivy functions, as explained in the :ref:`overview/deep_dive/ivy_frontends:Short Frontend Implementations` sub-section of the `Ivy Frontends <../deep_dive/ivy_frontends.rst>`_ guide, and add the :code:`#ToDo` comment in the implementation as explained. Once the PR is merged, your sub-task issue will then be closed as normal. #. Alternatively, if you do not want to try and implement the frontend function compositionally, or if this is not feasible, then you can simply choose another frontend function to work on. @@ -137,9 +82,9 @@ After this, you then have two options for how to proceed: In either case, you should add the label "Pending other Issue" to the frontend sub-task issue, and leave it open. This issue will then still show up as open in the original frontend ToDo list, helpfully preventing others from working on this problematic frontend function, which depends on the unimplemented :code:`ivy.`. Finally, you should add a comment to the issue with the contents: :code:`pending `, which links to the :code:`ivy.` issue, making the "Pending other Issue" label more informative. - + There are a few other points to take note of when working on your chosen frontend function: - + #. You should only implement **one** frontend function. #. The frontend function is framework-specific, thus it should be implemented in its respective frontend framework only. #. Each frontend function should be tested on all backends to ensure that conversions are working correctly. @@ -147,24 +92,24 @@ There are a few other points to take note of when working on your chosen fronten #. Some frontend functions shown in the ToDo list issues are aliases of other functions. If you detect that this is the case, then you should add all aliases in your PR, with a single implementation and then simple bindings to this implementation, such as :code:` = `. If you notice that an alias function has already been implemented and pushed, then you can simply add this one-liner binding and get this very simple PR merged. - + In the case where your chosen function exists in all frameworks by default, but is not implemented in Ivy's functional API, please convert your existing GitHub issue to request for the function to be added to Ivy. Meanwhile, you can select another frontend function to work on from the ToDo list! If you're stuck on a function that requires complex compositions, you're allowed to reselect a function too! - + Where to place a frontend function ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - + The placement of new frontend functions for a given backend should follow the categorisation of the backend API as faithfully as possible. In each `issue description`_, there will be a link to the relevant `reference API`_. Check where the function you're working on is located, e.g. :code:`numpy.inner` falls under :code:`numpy.linalg`. Then, in the Ivy source code, check :code:`ivy/functional/frontends/[backend]` for pre-existing files which best match the function's category in the backend reference API. - + Taking :code:`numpy.inner` as an example, we can see that there are a few :code:`ivy/functional/frontends/numpy` sub-directories to choose from: - + .. code-block:: bash :emphasize-lines: 4 - + creation_routines fft indexing_routines @@ -179,126 +124,203 @@ Taking :code:`numpy.inner` as an example, we can see that there are a few :code: sorting_searching_counting statistics ufunc - + There is a :code:`linalg` sub-directory, so we choose this. Then we need to choose from the files in this hierarchy: - + .. code-block:: bash :emphasize-lines: 3 - + __init__.py decompositions.py matrix_and_vector_products.py matrix_eigenvalues.py norms_and_other_numbers.py solving_equations_and_inverting_matrices.py - - + + This may require a bit of reasoning. :code:`inner` calculates the inner product of two arrays, so :code:`matrix_and_vector_products.py` seems like the most appropriate option. It is important to note that some functions require the :code:`np.linalg.[func]` namespace, as can gleamed from the numpy `reference API`_. These functions are listed out under the :code:`functional/frontends/numpy/__init__.py` `imports`_. There are some functions which have not been implemented yet, and are therefore commented out. Once you have finished the implementation of one of these functions, uncomment it from the list. - - + + The location of :code:`test_numpy_inner` should mirror the location of its corresponding function, this time in :code:`ivy_tests/test_ivy/test_frontends/[backend]`. - + If you're unsure about where to put the function you're working on, explore the content of these files to see if you can find a similar function. In :code:`matrix_and_vector_products.py`, we can see other functions such as :code:`outer` that are similar to :code:`inner`. This is confirmation that we've found the correct place! If many of the files are empty and you're unsure where to place your function, feel free to ask the member of the Ivy team reviewing your PR. - + Frontend checklist ~~~~~~~~~~~~~~~~~~ - + After creating a frontend-related Pull Request on github, you will notice a checklist is automatically added. This checklist describes the main points that need to be taken into consideration when adding a new frontend function. Please do not worry if you don't understand everything in that checklist! It's mainly there for the reviewer to make sure everything has been done correctly. - + However, you can still use the checklist as a reference in cases where you do understand the content, if you find it helpful in your development efforts. In that case, feel free to update any "not completed" (marked with ❌) items of the list to "stuck" (🆘) and/or "ready for review" (✅) status. Your reviewer will make sure to guide you as needed 🙂. - + **Notes**: - + 1. More details on how to update the checklist items can be found in the :ref:`overview/contributing/open_tasks:Formatting checklist` part of our docs. 2. Do not edit the checklist text, only the emoji symbols. 3. Please refrain from using the checkboxes next to checklist items. - + + +Function Formatting +------------------- + +Currently, we have many ToDo list issues `open `_ for a general function formatting task, which is explained below. + +Each function in each submodule should be updated to follow the implementation instructions given in the `Deep Dive`_ section. +The updates should be applied for the: + +#. ivy API +#. all backend APIs +#. array instance methods +#. container instance methods +#. array operators +#. array reverse operators +#. container operators +#. container reverse operators + +The `Deep Dive`_ is an **essential** resource for learning how each of these functions/methods should be implemented. +Before starting any contribution task, you should go through the `Deep Dive`_, and familiarize yourself with the content. + +At the time of writing, many of the functions are not implemented as they should be. +You will need to make changes to the current implementations, but you do not need to address *all* sections of the `Deep Dive`_ in detail. +Specifically, you **do not** need to address the following: + +#. Implement the hypothesis testing for the function +#. Get the tests passing for your function, if they are failing before you start + +However, everything else covered in the `Deep Dive`_ must be addressed. +Some common important tasks are: + +#. Remove all :code:`lambda` and direct bindings for the backend functions (in :code:`ivy.functional.backends`), with each function instead defined using :code:`def`. +#. Implement the following if they don't exist but should do: :class:`ivy.Array` instance method, :class:`ivy.Container` instance method, :class:`ivy.Array` special method, :class:`ivy.Array` reverse special method, :class:`ivy.Container` special method, :class:`ivy.Container` reverse special method. +#. Make sure that the aforementioned methods are added into the correct category-specific parent class, such as :class:`ivy.ArrayWithElementwise`, :class:`ivy.ContainerWithManipulation` etc. +#. Correct all of the `Function Arguments <../deep_dive/function_arguments.rst>`_ and the type hints for every function **and** its *relevant methods*, including those you did not implement yourself. +#. Add the correct `Docstrings <../deep_dive/docstrings.rst>`_ to every function **and** its *relevant methods*, including those you did not implement yourself. +#. Add thorough `Docstring Examples <../deep_dive/docstring_examples.rst>`_ for every function **and** its *relevant methods* and ensure they pass the docstring tests. + +Formatting checklist +~~~~~~~~~~~~~~~~~~~~ + +After creating your Pull Request on github, you should then produce the checklist for the formatting task as follows: + +1. Add a comment with the following format: :code:`add_reformatting_checklist_` on your PR, where ** is the name of the category that the function belongs to. + An example of this is shown below. + +.. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_generator.png?raw=true + :width: 420 + +Using this formatting will then trigger our github automation bots to update your comment with the proper markdown text for the checklist. +These updates might take a few moments to take effect, so please be patient 🙂. + +2. After adding the checklist to your PR, you should then modify this checklist with the status of each item according to the symbols(emojis) within the LEGEND section. + +.. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_legend.png?raw=true + :width: 420 + +3. When all check items are marked as (✅, ⏩, or 🆗), you should request a review for your PR and we will start checking your implementation and marking the items as complete using the checkboxes next to them. + +.. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_checked.png?raw=true + :width: 420 + +4. In case you are stuck or need help with one of the checklist items, please add the 🆘 symbol next to the item on the checklist, and proceed to add a comment elaborating on your point of struggle with this item. +The PR assignee will then see this comment and address your issues. + +.. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_SOS.png?raw=true + :width: 420 + +**Notes**: + +1. It is important that the PR author is the one to add the checklist generating comment in order to ensure they will have access to edit and update it later. +2. The checklist items' statuses should be manually updated by the PR author. + It does not automatically run any tests to update them! +3. Do not edit the checklist text, only the emoji symbols. 😅 +4. Please refrain from using the checkboxes next to checklist items. + + Ivy Experimental API -------------------- - + The goal of this task is to add functions to the existing Ivy API which would help with the implementation for many of the functions in the frontend. - + Your task is to implement these functions in Ivy, along with their Implementation in the respective backends which are :code:`Jax`, :code:`PyTorch`, :code:`TensorFlow` :code:`NumPy` and :code:`Paddle`. You must also implement tests for these functions. - + There is only one central ToDo list `issue `_ for this task. - + A general workflow for these tasks would be: - + #. Analyze the function type, we have a very detailed section for it in the deep dive `Function Types Guide <../deep_dive/function_types.rst>`_ #. Every function will have a different file structure according to the function type, refer to :ref:`overview/contributing/open_tasks:Where to place a backend function` subsection below. #. Implement the container instance method in :mod:`ivy/container/experimental/[relevant_submodule].py` and the array instance method in :mod:`ivy/array/experimental/[relevant_submodule].py` #. Write tests for the function using the `Ivy Tests <../deep_dive/ivy_tests.rst>`_ guide, and make sure they are passing. - + A few points to keep in mind while doing this: - + #. Make sure all the positional arguments are positional-only and optional arguments are keyword-only. #. In case some tests require function-specific parameters, you can create composite hypothesis strategies using the :code:`draw` function in the hypothesis library. - + If you’re stuck on a function which requires complex compositions, feel free to reselect a function - + Extending the Ivy API ~~~~~~~~~~~~~~~~~~~~~~~ - + We primarily invite contributors to work on the tasks listed as :ref:`overview/contributing/open_tasks:Open Tasks`, as these are on our current roadmap. As a result of this, we prompt everyone interested in contributing to our Experimental API to do so under the :ref:`Ivy Experimental API Open Task `. - + However, if you would like to extend Ivy's functionality with a new function, you are invited to open an issue using the *Missing Function Suggestion* template as described in :ref:`overview/contributing/open_tasks:Creating an Issue on Ivy's GitHub using a Template`. - + In this template form, you'll be asked to fill in the reason you think we should implement the suggested function, as well as the links to any native implementations of the suggested function. - + We will review your issue as soon as possible and let you know if it's been accepted or not. In case we deem that the suggested function fits our roadmap, we will add it as a subtask to the `Ivy Experimental API Open Task `_. - + Where to place a backend function ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - + The placement of the backend function should be in the proper location to follow the proper structure as guided below. - + There are multiple types of backend functions as discussed above, we will go through 3 of those which you will encounter while adding a backend function in our Functional API: - + **Primary Functions** - + Implement the function in :mod:`ivy/functional/ivy/experimental/[relevant_submodule].py` simply deferring to their backend-specific implementation (where ivy.current_backend(x).function_name() is called), refer to the :ref:`Ivy API Guide ` to get a clearer picture of how this must be done. Then, implement the functions in each of the backend files :mod:`ivy/functional/backends/backend_name/experimental/[relevant_submodule].py`, you can refer to the :ref:`Backend API Guide ` for this. - + **Compositional Functions** - + Implement the function in :mod:`ivy/functional/ivy/experimental/[relevant_submodule].py`, we will not use the primary function approach in this case, the implementation will be a composition of functions from Ivy's functional API. You can refer to :ref:`overview/deep_dive/function_types:Compositional Functions` for a better understanding of this. You don't need to add any implementation in any other file in this case. - + **Mixed Functions** - + Sometimes, a function may only be provided by some of the supported backends. In this case, we have to take a mixed approach. You can say that this is a mix of both primary and a compositional function. For this, you have to implement the function in :mod:`ivy/functional/ivy/experimental/[relevant_submodule].py`, where the implementation will be a composition of functions from Ivy's functional API. After you are done with this, you then have to implement the functions in each of the backend files :mod:`ivy/functional/backends/backend_name/experimental/[relevant_submodule].py`. - + **Other Function Types** - + :ref:`overview/deep_dive/function_types:Standalone Functions`, :ref:`overview/deep_dive/function_types:Nestable Functions` and :ref:`overview/deep_dive/function_types:Convenience Functions` are the ones which you will rarely come across while implementing a function from the ToDo List but they are an essential part of the Ivy API. - - + + Creating an Issue on Ivy's GitHub using a Template ---------------------------------------------------- - + #. Go to the `GitHub Ivy `_ page, select the Issues tab, and click on the green button :code:`New issue` at the centre-right of the screen. #. You will see 5 options. Each option has a predetermined form. To start filling in the form, click on the green button at the right which says :code:`Get started`. The options are explained as follows: - + * Bug Report: In case you find a bug in our API, you have to provide details in the form and the issue will be assigned to one of our team members to look into. * Feature request: @@ -310,10 +332,10 @@ Creating an Issue on Ivy's GitHub using a Template * Questions: If you want to interact with the Ivy community to ask for any type of help, discussing and more! #. To submit your issue, you will have to complete the requirements in the form and click on the green button :code:`Submit new issue` at the right-bottom of the screen. - - + + **Round Up** - + This should have hopefully given you a good understanding of the basics for contributing. - + If you have any questions, please feel free to reach out on `discord`_ in the `open tasks channel`_! From f5e406fcffdb343511b7805781c1f6b95dc97f65 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 17 Dec 2023 16:24:44 +0000 Subject: [PATCH 383/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/contributing/open_tasks.rst | 210 +++++++++++----------- 1 file changed, 105 insertions(+), 105 deletions(-) diff --git a/docs/overview/contributing/open_tasks.rst b/docs/overview/contributing/open_tasks.rst index bca053e241726..de80e03222b7c 100644 --- a/docs/overview/contributing/open_tasks.rst +++ b/docs/overview/contributing/open_tasks.rst @@ -1,6 +1,6 @@ Open Tasks ========== - + .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm .. _`open tasks channel`: https://discord.com/channels/799879767196958751/982728618469912627 @@ -8,72 +8,72 @@ Open Tasks .. _`reference API`: https://numpy.org/doc/stable/reference/routines.linalg.html .. _`imports`: https://github.com/unifyai/ivy/blob/38dbb607334cb32eb513630c4496ad0024f80e1c/ivy/functional/frontends/numpy/__init__.py#L27 .. _`Deep Dive`: ../deep_dive.rst - + Here, we explain all tasks which are currently open for contributions from the community! - + This section of the docs will be updated frequently, whereby new tasks will be added and completed tasks will be removed. The tasks outlined here are generally broad high-level tasks, each of which is made up of many individual sub-tasks, distributed across task-specific `ToDo List Issues `_. - + Please read about :ref:`overview/contributing/the_basics:ToDo List Issues` in detail before continuing. All tasks should be selected and allocated as described in the ToDo List Issues section. We make no mention of task selection and allocation in the explanations below, which instead focus on the steps to complete only once a sub-task has been allocated to you. - + The tasks currently open are: - + #. Fixing Failing Tests #. Function Formatting #. Frontend APIs #. Ivy Experimental API - + We try to explain these tasks as clearly as possible, but in cases where things are not clear, then please feel free to reach out on `discord`_ in the `open tasks channel`_! - + Please always use the latest commit on GitHub when working on any of these tasks, **DO NOT** develop your code using the latest PyPI release of :code:`ivy`. - + Fixing Failing Tests -------------------- - + In the Ivy repository, we've identified a range of functions and tests that currently fall short of our quality standards. The root of these issues is not always clear-cut. In some instances, the problem may lie within the functions themselves, while in others, it could be the tests, which were crafted by various contributors, that are at fault. This situation presents a unique opportunity for community involvement. We are actively inviting contributions from our community to help tackle these challenges. - + How to Contribute ~~~~~~~~~~~~~~~~~ - + **Identifying Issues** - + To get started, visit our issues page: `Failing Tests `_. Here, you will find a list of open issues labeled as "Failing Test" and "ToDo". These issues are categorised under various frameworks supported by our repository. We encourage you to select a framework you're comfortable with or interested in contributing to. - + **Selecting a Test** - + Within each framework, tests are classified as either "Priority Open" or "Other Open." While we prioritize fixing the "Priority Open" tests, contributions towards any test, including those labeled "Other Open," are highly valuable. Each test issue is linked directly to the specific failing workflow. This linkage provides you with immediate access to the details of what exactly is failing and the context around it. - + **Making Your Contribution** - + After selecting a test to work on, please fork the repository and create a new branch for your fix. Ensure that your solution addresses the issue effectively and doesn't introduce new errors. Once you're confident in your fix, submit a pull request to the main repository. Our team will review your contribution, provide feedback if necessary, and then merge your changes once they meet our standards. - + Frontend APIs ------------- - + For this task, the goal will be to implement functions for each of the frontend functional APIs (see `Ivy as a Transpiler <../design/ivy_as_a_transpiler.rst>`_), with frontend APIs implemented for: :code:`JAX`, :code:`NumPy`, :code:`TensorFlow` :code:`PyTorch`, :code:`Paddle`, :code:`Scipy`, :code:`MXNet` and :code:`MindSpore`. - + Currently, we have many ToDo list issues `open `_ for this task. - + The general workflow for this task is: - + #. Find the correct location for the function by following the :ref:`overview/contributing/open_tasks:Where to place a frontend function` subsection below #. Implement the function by following the `Ivy Frontends <../deep_dive/ivy_frontends.rst>`_ guide #. Write tests for your function by following the `Ivy Frontend Tests <../deep_dive/ivy_frontends_tests.rst>`_ guide #. Verify that the tests for your function are passing - + If you feel as though there is an ivy function :code:`ivy.` clearly missing, which would make your frontend function much simpler to implement, then you should first do the following: - + #. Create a new issue with the title :code:`ivy.` #. Add the labels :code:`Suggestion`, :code:`Experimental`, :code:`Ivy API` and :code:`Next Release` to it #. Then simply leave this issue open. - + At some point, a member of our team will assess whether it should be added, and if so, they will add it to another appropriate ToDo list issue (see the open task below). You do not need to wait for this in order to proceed. - + After this, you then have two options for how to proceed: - + #. Try to implement the function as a composition of currently present ivy functions, as explained in the :ref:`overview/deep_dive/ivy_frontends:Short Frontend Implementations` sub-section of the `Ivy Frontends <../deep_dive/ivy_frontends.rst>`_ guide, and add the :code:`#ToDo` comment in the implementation as explained. Once the PR is merged, your sub-task issue will then be closed as normal. #. Alternatively, if you do not want to try and implement the frontend function compositionally, or if this is not feasible, then you can simply choose another frontend function to work on. @@ -82,9 +82,9 @@ After this, you then have two options for how to proceed: In either case, you should add the label "Pending other Issue" to the frontend sub-task issue, and leave it open. This issue will then still show up as open in the original frontend ToDo list, helpfully preventing others from working on this problematic frontend function, which depends on the unimplemented :code:`ivy.`. Finally, you should add a comment to the issue with the contents: :code:`pending `, which links to the :code:`ivy.` issue, making the "Pending other Issue" label more informative. - + There are a few other points to take note of when working on your chosen frontend function: - + #. You should only implement **one** frontend function. #. The frontend function is framework-specific, thus it should be implemented in its respective frontend framework only. #. Each frontend function should be tested on all backends to ensure that conversions are working correctly. @@ -92,24 +92,24 @@ There are a few other points to take note of when working on your chosen fronten #. Some frontend functions shown in the ToDo list issues are aliases of other functions. If you detect that this is the case, then you should add all aliases in your PR, with a single implementation and then simple bindings to this implementation, such as :code:` = `. If you notice that an alias function has already been implemented and pushed, then you can simply add this one-liner binding and get this very simple PR merged. - + In the case where your chosen function exists in all frameworks by default, but is not implemented in Ivy's functional API, please convert your existing GitHub issue to request for the function to be added to Ivy. Meanwhile, you can select another frontend function to work on from the ToDo list! If you're stuck on a function that requires complex compositions, you're allowed to reselect a function too! - + Where to place a frontend function ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - + The placement of new frontend functions for a given backend should follow the categorisation of the backend API as faithfully as possible. In each `issue description`_, there will be a link to the relevant `reference API`_. Check where the function you're working on is located, e.g. :code:`numpy.inner` falls under :code:`numpy.linalg`. Then, in the Ivy source code, check :code:`ivy/functional/frontends/[backend]` for pre-existing files which best match the function's category in the backend reference API. - + Taking :code:`numpy.inner` as an example, we can see that there are a few :code:`ivy/functional/frontends/numpy` sub-directories to choose from: - + .. code-block:: bash :emphasize-lines: 4 - + creation_routines fft indexing_routines @@ -124,58 +124,58 @@ Taking :code:`numpy.inner` as an example, we can see that there are a few :code: sorting_searching_counting statistics ufunc - + There is a :code:`linalg` sub-directory, so we choose this. Then we need to choose from the files in this hierarchy: - + .. code-block:: bash :emphasize-lines: 3 - + __init__.py decompositions.py matrix_and_vector_products.py matrix_eigenvalues.py norms_and_other_numbers.py solving_equations_and_inverting_matrices.py - - + + This may require a bit of reasoning. :code:`inner` calculates the inner product of two arrays, so :code:`matrix_and_vector_products.py` seems like the most appropriate option. It is important to note that some functions require the :code:`np.linalg.[func]` namespace, as can gleamed from the numpy `reference API`_. These functions are listed out under the :code:`functional/frontends/numpy/__init__.py` `imports`_. There are some functions which have not been implemented yet, and are therefore commented out. Once you have finished the implementation of one of these functions, uncomment it from the list. - - + + The location of :code:`test_numpy_inner` should mirror the location of its corresponding function, this time in :code:`ivy_tests/test_ivy/test_frontends/[backend]`. - + If you're unsure about where to put the function you're working on, explore the content of these files to see if you can find a similar function. In :code:`matrix_and_vector_products.py`, we can see other functions such as :code:`outer` that are similar to :code:`inner`. This is confirmation that we've found the correct place! If many of the files are empty and you're unsure where to place your function, feel free to ask the member of the Ivy team reviewing your PR. - + Frontend checklist ~~~~~~~~~~~~~~~~~~ - + After creating a frontend-related Pull Request on github, you will notice a checklist is automatically added. This checklist describes the main points that need to be taken into consideration when adding a new frontend function. Please do not worry if you don't understand everything in that checklist! It's mainly there for the reviewer to make sure everything has been done correctly. - + However, you can still use the checklist as a reference in cases where you do understand the content, if you find it helpful in your development efforts. In that case, feel free to update any "not completed" (marked with ❌) items of the list to "stuck" (🆘) and/or "ready for review" (✅) status. Your reviewer will make sure to guide you as needed 🙂. - + **Notes**: - + 1. More details on how to update the checklist items can be found in the :ref:`overview/contributing/open_tasks:Formatting checklist` part of our docs. 2. Do not edit the checklist text, only the emoji symbols. 3. Please refrain from using the checkboxes next to checklist items. - - + + Function Formatting ------------------- - + Currently, we have many ToDo list issues `open `_ for a general function formatting task, which is explained below. - + Each function in each submodule should be updated to follow the implementation instructions given in the `Deep Dive`_ section. The updates should be applied for the: - + #. ivy API #. all backend APIs #. array instance methods @@ -184,143 +184,143 @@ The updates should be applied for the: #. array reverse operators #. container operators #. container reverse operators - + The `Deep Dive`_ is an **essential** resource for learning how each of these functions/methods should be implemented. Before starting any contribution task, you should go through the `Deep Dive`_, and familiarize yourself with the content. - + At the time of writing, many of the functions are not implemented as they should be. You will need to make changes to the current implementations, but you do not need to address *all* sections of the `Deep Dive`_ in detail. Specifically, you **do not** need to address the following: - + #. Implement the hypothesis testing for the function #. Get the tests passing for your function, if they are failing before you start - + However, everything else covered in the `Deep Dive`_ must be addressed. Some common important tasks are: - + #. Remove all :code:`lambda` and direct bindings for the backend functions (in :code:`ivy.functional.backends`), with each function instead defined using :code:`def`. #. Implement the following if they don't exist but should do: :class:`ivy.Array` instance method, :class:`ivy.Container` instance method, :class:`ivy.Array` special method, :class:`ivy.Array` reverse special method, :class:`ivy.Container` special method, :class:`ivy.Container` reverse special method. #. Make sure that the aforementioned methods are added into the correct category-specific parent class, such as :class:`ivy.ArrayWithElementwise`, :class:`ivy.ContainerWithManipulation` etc. #. Correct all of the `Function Arguments <../deep_dive/function_arguments.rst>`_ and the type hints for every function **and** its *relevant methods*, including those you did not implement yourself. #. Add the correct `Docstrings <../deep_dive/docstrings.rst>`_ to every function **and** its *relevant methods*, including those you did not implement yourself. #. Add thorough `Docstring Examples <../deep_dive/docstring_examples.rst>`_ for every function **and** its *relevant methods* and ensure they pass the docstring tests. - + Formatting checklist ~~~~~~~~~~~~~~~~~~~~ - + After creating your Pull Request on github, you should then produce the checklist for the formatting task as follows: - + 1. Add a comment with the following format: :code:`add_reformatting_checklist_` on your PR, where ** is the name of the category that the function belongs to. An example of this is shown below. - + .. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_generator.png?raw=true :width: 420 - + Using this formatting will then trigger our github automation bots to update your comment with the proper markdown text for the checklist. These updates might take a few moments to take effect, so please be patient 🙂. - + 2. After adding the checklist to your PR, you should then modify this checklist with the status of each item according to the symbols(emojis) within the LEGEND section. - + .. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_legend.png?raw=true :width: 420 - + 3. When all check items are marked as (✅, ⏩, or 🆗), you should request a review for your PR and we will start checking your implementation and marking the items as complete using the checkboxes next to them. - + .. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_checked.png?raw=true :width: 420 - + 4. In case you are stuck or need help with one of the checklist items, please add the 🆘 symbol next to the item on the checklist, and proceed to add a comment elaborating on your point of struggle with this item. The PR assignee will then see this comment and address your issues. - + .. image:: https://github.com/unifyai/unifyai.github.io/blob/main/img/externally_linked/contributing/open_tasks/checklist_SOS.png?raw=true :width: 420 - + **Notes**: - + 1. It is important that the PR author is the one to add the checklist generating comment in order to ensure they will have access to edit and update it later. 2. The checklist items' statuses should be manually updated by the PR author. It does not automatically run any tests to update them! 3. Do not edit the checklist text, only the emoji symbols. 😅 4. Please refrain from using the checkboxes next to checklist items. - - + + Ivy Experimental API -------------------- - + The goal of this task is to add functions to the existing Ivy API which would help with the implementation for many of the functions in the frontend. - + Your task is to implement these functions in Ivy, along with their Implementation in the respective backends which are :code:`Jax`, :code:`PyTorch`, :code:`TensorFlow` :code:`NumPy` and :code:`Paddle`. You must also implement tests for these functions. - + There is only one central ToDo list `issue `_ for this task. - + A general workflow for these tasks would be: - + #. Analyze the function type, we have a very detailed section for it in the deep dive `Function Types Guide <../deep_dive/function_types.rst>`_ #. Every function will have a different file structure according to the function type, refer to :ref:`overview/contributing/open_tasks:Where to place a backend function` subsection below. #. Implement the container instance method in :mod:`ivy/container/experimental/[relevant_submodule].py` and the array instance method in :mod:`ivy/array/experimental/[relevant_submodule].py` #. Write tests for the function using the `Ivy Tests <../deep_dive/ivy_tests.rst>`_ guide, and make sure they are passing. - + A few points to keep in mind while doing this: - + #. Make sure all the positional arguments are positional-only and optional arguments are keyword-only. #. In case some tests require function-specific parameters, you can create composite hypothesis strategies using the :code:`draw` function in the hypothesis library. - + If you’re stuck on a function which requires complex compositions, feel free to reselect a function - + Extending the Ivy API ~~~~~~~~~~~~~~~~~~~~~~~ - + We primarily invite contributors to work on the tasks listed as :ref:`overview/contributing/open_tasks:Open Tasks`, as these are on our current roadmap. As a result of this, we prompt everyone interested in contributing to our Experimental API to do so under the :ref:`Ivy Experimental API Open Task `. - + However, if you would like to extend Ivy's functionality with a new function, you are invited to open an issue using the *Missing Function Suggestion* template as described in :ref:`overview/contributing/open_tasks:Creating an Issue on Ivy's GitHub using a Template`. - + In this template form, you'll be asked to fill in the reason you think we should implement the suggested function, as well as the links to any native implementations of the suggested function. - + We will review your issue as soon as possible and let you know if it's been accepted or not. In case we deem that the suggested function fits our roadmap, we will add it as a subtask to the `Ivy Experimental API Open Task `_. - + Where to place a backend function ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - + The placement of the backend function should be in the proper location to follow the proper structure as guided below. - + There are multiple types of backend functions as discussed above, we will go through 3 of those which you will encounter while adding a backend function in our Functional API: - + **Primary Functions** - + Implement the function in :mod:`ivy/functional/ivy/experimental/[relevant_submodule].py` simply deferring to their backend-specific implementation (where ivy.current_backend(x).function_name() is called), refer to the :ref:`Ivy API Guide ` to get a clearer picture of how this must be done. Then, implement the functions in each of the backend files :mod:`ivy/functional/backends/backend_name/experimental/[relevant_submodule].py`, you can refer to the :ref:`Backend API Guide ` for this. - + **Compositional Functions** - + Implement the function in :mod:`ivy/functional/ivy/experimental/[relevant_submodule].py`, we will not use the primary function approach in this case, the implementation will be a composition of functions from Ivy's functional API. You can refer to :ref:`overview/deep_dive/function_types:Compositional Functions` for a better understanding of this. You don't need to add any implementation in any other file in this case. - + **Mixed Functions** - + Sometimes, a function may only be provided by some of the supported backends. In this case, we have to take a mixed approach. You can say that this is a mix of both primary and a compositional function. For this, you have to implement the function in :mod:`ivy/functional/ivy/experimental/[relevant_submodule].py`, where the implementation will be a composition of functions from Ivy's functional API. After you are done with this, you then have to implement the functions in each of the backend files :mod:`ivy/functional/backends/backend_name/experimental/[relevant_submodule].py`. - + **Other Function Types** - + :ref:`overview/deep_dive/function_types:Standalone Functions`, :ref:`overview/deep_dive/function_types:Nestable Functions` and :ref:`overview/deep_dive/function_types:Convenience Functions` are the ones which you will rarely come across while implementing a function from the ToDo List but they are an essential part of the Ivy API. - - + + Creating an Issue on Ivy's GitHub using a Template ---------------------------------------------------- - + #. Go to the `GitHub Ivy `_ page, select the Issues tab, and click on the green button :code:`New issue` at the centre-right of the screen. #. You will see 5 options. Each option has a predetermined form. To start filling in the form, click on the green button at the right which says :code:`Get started`. The options are explained as follows: - + * Bug Report: In case you find a bug in our API, you have to provide details in the form and the issue will be assigned to one of our team members to look into. * Feature request: @@ -332,10 +332,10 @@ Creating an Issue on Ivy's GitHub using a Template * Questions: If you want to interact with the Ivy community to ask for any type of help, discussing and more! #. To submit your issue, you will have to complete the requirements in the form and click on the green button :code:`Submit new issue` at the right-bottom of the screen. - - + + **Round Up** - + This should have hopefully given you a good understanding of the basics for contributing. - + If you have any questions, please feel free to reach out on `discord`_ in the `open tasks channel`_! From 1980cd46a832ea1b669cc3cf687353219b96ba03 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sun, 17 Dec 2023 21:08:06 +0400 Subject: [PATCH 384/978] Update the_basics.rst --- docs/overview/contributing/the_basics.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/the_basics.rst b/docs/overview/contributing/the_basics.rst index 6209f295be4c3..1c2f3966ce8c9 100644 --- a/docs/overview/contributing/the_basics.rst +++ b/docs/overview/contributing/the_basics.rst @@ -52,7 +52,7 @@ We make extensive use of `ToDo list issues Date: Mon, 18 Dec 2023 00:25:43 +0400 Subject: [PATCH 385/978] Feat: Apple silicon binaries setup --- available_configs.json | 3 --- binaries.json | 25 ----------------------- ivy/utils/binaries.py | 10 ++++++++- requirements/optional_apple_silicon_1.txt | 1 + setup.py | 7 ++++++- test.py | 14 +++++++++++++ 6 files changed, 30 insertions(+), 30 deletions(-) create mode 100644 test.py diff --git a/available_configs.json b/available_configs.json index 1be6f4a48bb34..e5d54f88d050d 100644 --- a/available_configs.json +++ b/available_configs.json @@ -6,8 +6,5 @@ "cp311-cp311-manylinux_2_17_x86_64", "cp310-cp310-macosx_arm64_darwin", "cp311-cp311-macosx_arm64_darwin" - ], - "engines": [ - "cp310-cp310-manylinux_2_17_x86_64" ] } diff --git a/binaries.json b/binaries.json index f77586c81524f..697738c67c50a 100644 --- a/binaries.json +++ b/binaries.json @@ -65,31 +65,6 @@ "X.so" ] } - ], - "engines": [ - "ivy2xla.so", - { - "XLA": { - "rust_api": { - "python_frontend": [ - "activations.so", - "creation.so", - "elementwise.so", - "general.so", - "ivy2xla.so", - "layers.so", - "linear_algebra.so", - "manipulation.so", - "norms.so", - "stateful_activations.so", - "stateful_layers.so", - "stateful_norms.so", - "statistical.so", - "xla_core.so" - ] - } - } - } ] } } diff --git a/ivy/utils/binaries.py b/ivy/utils/binaries.py index 34948140db9c8..edb7859218827 100644 --- a/ivy/utils/binaries.py +++ b/ivy/utils/binaries.py @@ -75,7 +75,15 @@ def cleanup_and_fetch_binaries(clean=True): print("Cleaning up existing binaries --> done") print("Downloading new binaries...") - all_tags = list(tags.sys_tags()) + # if apple silicon and python version os.sys.version >= 3.10.* and darwin + if "arm64" in os.uname().machine and os.sys.version_info[:2] >= (3, 10) and os.uname().sysname == "Darwin": + all_tags = ["cp310-cp310-macosx_arm64_darwin"] + # if apple silicon and python version os.sys.version >= 3.11.* and darwin + elif "arm64" in os.uname().machine and os.sys.version_info[:2] >= (3, 11) and os.uname().sysname == "Darwin": + all_tags = ["cp311-cp311-macosx_arm64_darwin"] + else: + all_tags = list(tags.sys_tags()) + version = os.environ["VERSION"] if "VERSION" in os.environ else "main" terminate = False diff --git a/requirements/optional_apple_silicon_1.txt b/requirements/optional_apple_silicon_1.txt index 7f32348c59d41..834822a43a716 100644 --- a/requirements/optional_apple_silicon_1.txt +++ b/requirements/optional_apple_silicon_1.txt @@ -13,3 +13,4 @@ tensorflow-probability # mod_name=tensorflow_probability torch paddlepaddle # unpinned , mod_name=paddle torchvision +cryptography diff --git a/setup.py b/setup.py index e98695ecf1b84..04c6331b0d810 100644 --- a/setup.py +++ b/setup.py @@ -57,7 +57,12 @@ def _strip(line): else: from pip._vendor.packaging import tags - all_tags = list(tags.sys_tags()) + if "arm64" in os.uname().machine and os.uname().sysname == "Darwin" and os.sys.version_info[:2] >= (3, 10) and os.sys.version_info[:2] < (3, 11): + all_tags = ["cp310-cp310-macosx_arm64_darwin"] + elif "arm64" in os.uname().machine and os.uname().sysname == "Darwin" and os.sys.version_info[:2] >= (3, 11) and os.sys.version_info[:2] < (3, 12): + all_tags = ["cp311-cp311-macosx_arm64_darwin"] + else: + all_tags = list(tags.sys_tags()) # download binaries for the tag with highest precedence for tag in all_tags: diff --git a/test.py b/test.py new file mode 100644 index 0000000000000..a04dd9e6d7944 --- /dev/null +++ b/test.py @@ -0,0 +1,14 @@ +import ivy +import torch +ivy.set_backend("jax") + +def normalize(x): + mean = torch.mean(x) + std = torch.std(x) + return torch.div(torch.sub(x, mean), std) + +# convert the function to Ivy code +ivy_normalize = ivy.unify(normalize) + +# trace the Ivy code into jax functions +jax_normalize = ivy.trace_graph(ivy_normalize) \ No newline at end of file From 7a7e53c7df70ae14ce62eaea60ff8f1ea5a39f80 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 17 Dec 2023 20:27:20 +0000 Subject: [PATCH 386/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/utils/binaries.py | 14 +++++++++++--- setup.py | 14 ++++++++++++-- test.py | 5 ++++- 3 files changed, 27 insertions(+), 6 deletions(-) diff --git a/ivy/utils/binaries.py b/ivy/utils/binaries.py index edb7859218827..e1bb99da3c4fb 100644 --- a/ivy/utils/binaries.py +++ b/ivy/utils/binaries.py @@ -76,14 +76,22 @@ def cleanup_and_fetch_binaries(clean=True): print("Downloading new binaries...") # if apple silicon and python version os.sys.version >= 3.10.* and darwin - if "arm64" in os.uname().machine and os.sys.version_info[:2] >= (3, 10) and os.uname().sysname == "Darwin": + if ( + "arm64" in os.uname().machine + and os.sys.version_info[:2] >= (3, 10) + and os.uname().sysname == "Darwin" + ): all_tags = ["cp310-cp310-macosx_arm64_darwin"] # if apple silicon and python version os.sys.version >= 3.11.* and darwin - elif "arm64" in os.uname().machine and os.sys.version_info[:2] >= (3, 11) and os.uname().sysname == "Darwin": + elif ( + "arm64" in os.uname().machine + and os.sys.version_info[:2] >= (3, 11) + and os.uname().sysname == "Darwin" + ): all_tags = ["cp311-cp311-macosx_arm64_darwin"] else: all_tags = list(tags.sys_tags()) - + version = os.environ["VERSION"] if "VERSION" in os.environ else "main" terminate = False diff --git a/setup.py b/setup.py index 04c6331b0d810..c61ac547230ce 100644 --- a/setup.py +++ b/setup.py @@ -57,9 +57,19 @@ def _strip(line): else: from pip._vendor.packaging import tags - if "arm64" in os.uname().machine and os.uname().sysname == "Darwin" and os.sys.version_info[:2] >= (3, 10) and os.sys.version_info[:2] < (3, 11): + if ( + "arm64" in os.uname().machine + and os.uname().sysname == "Darwin" + and os.sys.version_info[:2] >= (3, 10) + and os.sys.version_info[:2] < (3, 11) + ): all_tags = ["cp310-cp310-macosx_arm64_darwin"] - elif "arm64" in os.uname().machine and os.uname().sysname == "Darwin" and os.sys.version_info[:2] >= (3, 11) and os.sys.version_info[:2] < (3, 12): + elif ( + "arm64" in os.uname().machine + and os.uname().sysname == "Darwin" + and os.sys.version_info[:2] >= (3, 11) + and os.sys.version_info[:2] < (3, 12) + ): all_tags = ["cp311-cp311-macosx_arm64_darwin"] else: all_tags = list(tags.sys_tags()) diff --git a/test.py b/test.py index a04dd9e6d7944..a3c408d749199 100644 --- a/test.py +++ b/test.py @@ -1,14 +1,17 @@ import ivy import torch + ivy.set_backend("jax") + def normalize(x): mean = torch.mean(x) std = torch.std(x) return torch.div(torch.sub(x, mean), std) + # convert the function to Ivy code ivy_normalize = ivy.unify(normalize) # trace the Ivy code into jax functions -jax_normalize = ivy.trace_graph(ivy_normalize) \ No newline at end of file +jax_normalize = ivy.trace_graph(ivy_normalize) From 19d5b9273ec03ee17f32f0f9a75af902a5f52c71 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 18 Dec 2023 00:36:07 +0400 Subject: [PATCH 387/978] Add MC.so to binaries.json --- binaries.json | 1 + 1 file changed, 1 insertion(+) diff --git a/binaries.json b/binaries.json index 697738c67c50a..5366fdd7b1585 100644 --- a/binaries.json +++ b/binaries.json @@ -40,6 +40,7 @@ "LX.so", "L.so", + "MC.so", "MI.so", "ML.so", "MV.so", From 5cd5a43581477a855816db759e83bde0642e00b0 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 18 Dec 2023 00:56:54 +0400 Subject: [PATCH 388/978] Add new shared object files to binaries.json and update installation script --- binaries.json | 6 +++++- install_dependencies.sh | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/binaries.json b/binaries.json index 5366fdd7b1585..8f31596c7a3a7 100644 --- a/binaries.json +++ b/binaries.json @@ -41,8 +41,10 @@ "L.so", "MC.so", + "MD.so", "MI.so", "ML.so", + "MM.so", "MV.so", "MX.so", "M.so", @@ -63,7 +65,9 @@ "XM.so", "XV.so", "XX.so", - "X.so" + "X.so", + + "IIC.so" ] } ] diff --git a/install_dependencies.sh b/install_dependencies.sh index 6fa84d7003008..911662965c6e3 100755 --- a/install_dependencies.sh +++ b/install_dependencies.sh @@ -1,6 +1,6 @@ # This shell script is required by the doc-builder. Moving it might break # the doc-building pipeline - +pip install -e . pip install -r requirements/requirements.txt if [[ $(arch) == 'arm64' ]]; then brew install pandoc From 76c0bfc680f4083967a490710df4f2c23e65efd2 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 18 Dec 2023 01:08:29 +0400 Subject: [PATCH 389/978] Remove unused code --- test.py | 17 ----------------- 1 file changed, 17 deletions(-) delete mode 100644 test.py diff --git a/test.py b/test.py deleted file mode 100644 index a3c408d749199..0000000000000 --- a/test.py +++ /dev/null @@ -1,17 +0,0 @@ -import ivy -import torch - -ivy.set_backend("jax") - - -def normalize(x): - mean = torch.mean(x) - std = torch.std(x) - return torch.div(torch.sub(x, mean), std) - - -# convert the function to Ivy code -ivy_normalize = ivy.unify(normalize) - -# trace the Ivy code into jax functions -jax_normalize = ivy.trace_graph(ivy_normalize) From 3ac0b0371be323441cdec34703b14f9551b40432 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 18 Dec 2023 01:58:25 +0000 Subject: [PATCH 390/978] Update compiler.py --- ivy/compiler/compiler.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,7 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" from ._compiler import trace_graph as _trace_graph @@ -157,8 +155,7 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" from ._compiler import transpile as _transpile From adc43a1ffc81ab0192f77186ea66c7c9c170172f Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 18 Dec 2023 01:59:59 +0000 Subject: [PATCH 391/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From 08e43027edef9f47e600ebdd04999bc01beb1746 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 18 Dec 2023 02:55:10 +0000 Subject: [PATCH 392/978] Update compiler.py --- ivy/compiler/compiler.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,7 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" from ._compiler import trace_graph as _trace_graph @@ -157,8 +155,7 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" from ._compiler import transpile as _transpile From 64dc7bfc8dcb104bde692966a4488042f6478aa6 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 18 Dec 2023 02:56:42 +0000 Subject: [PATCH 393/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..48523daeefc20 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,7 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph @@ -155,7 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile From cc99df569700875943390c040989854267715d0f Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 18 Dec 2023 11:19:07 +0530 Subject: [PATCH 394/978] fix: reverted the changes to binaries.json and compiler.py related to the new binaries due to config and other errors (#27769) --- binaries.json | 7 +------ ivy/compiler/compiler.py | 33 +++++++++++---------------------- 2 files changed, 12 insertions(+), 28 deletions(-) diff --git a/binaries.json b/binaries.json index 8f31596c7a3a7..697738c67c50a 100644 --- a/binaries.json +++ b/binaries.json @@ -40,11 +40,8 @@ "LX.so", "L.so", - "MC.so", - "MD.so", "MI.so", "ML.so", - "MM.so", "MV.so", "MX.so", "M.so", @@ -65,9 +62,7 @@ "XM.so", "XV.so", "XX.so", - "X.so", - - "IIC.so" + "X.so" ] } ] diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 48523daeefc20..ba5f858ee07d7 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -1,4 +1,4 @@ -from typing import Callable, Optional, List, Union, Iterable, Sequence, Mapping +from typing import Callable, Optional, List, Union, Iterable, Tuple, Mapping def trace_graph( @@ -10,18 +10,17 @@ def trace_graph( include_generators: bool = True, array_caching: bool = True, with_numpy: bool = True, - modes_to_trace: str = "all", backend_compile: bool = False, static_argnums: Optional[Union[int, Iterable[int]]] = None, static_argnames: Optional[Union[str, Iterable[str]]] = None, - compile_mode: Optional[str] = None, + mode: Optional[str] = None, graph_caching: bool = False, - args: Optional[Sequence] = None, + args: Optional[Tuple] = None, kwargs: Optional[Mapping] = None, params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend + """Take `fn` and traces it into a more efficient composition of backend operations. Parameters @@ -38,17 +37,14 @@ def trace_graph( include array creation/generation functions as part of the graph array_caching cache the constant arrays that appear as arguments to the functions in the graph - modes_to_trace - the module mode(s) which should be traced when tracing a trainable module - can be either "all", "train" or "eval". backend_compile whether to apply the native compilers, i.e. tf.function, after ivy's tracing static_argnums for jax's jit compilation static_argnames for jax's jit compilation - compile_mode - mode for torch's compilation + mode + for torch's compilation graph_caching whether to cache the traced graph args @@ -94,7 +90,6 @@ def trace_graph( >>> print(time.time() - start) 0.0001785755157470703 """ - from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -106,11 +101,10 @@ def trace_graph( include_generators=include_generators, array_caching=array_caching, with_numpy=with_numpy, - modes_to_trace=modes_to_trace, backend_compile=backend_compile, static_argnums=static_argnums, static_argnames=static_argnames, - compile_mode=compile_mode, + mode=mode, graph_caching=graph_caching, args=args, kwargs=kwargs, @@ -127,13 +121,12 @@ def transpile( backend_compile: bool = False, static_argnums: Optional[Union[int, Iterable[int]]] = None, static_argnames: Optional[Union[str, Iterable[str]]] = None, - compile_mode: Optional[str] = None, + mode: Optional[str] = None, graph_caching: bool = False, - modes_to_trace: str = "all", stateful: Optional[List] = None, arg_stateful_idxs: Optional[List] = None, kwarg_stateful_idxs: Optional[List] = None, - args: Optional[Sequence] = None, + args: Optional[Tuple] = None, kwargs: Optional[Mapping] = None, params_v=None, v=None @@ -159,7 +152,6 @@ def transpile( ------- Either a transpiled Graph or a non-initialized LazyGraph. """ - from ._compiler import transpile as _transpile return _transpile( @@ -170,9 +162,8 @@ def transpile( backend_compile=backend_compile, static_argnums=static_argnums, static_argnames=static_argnames, - compile_mode=compile_mode, + mode=mode, graph_caching=graph_caching, - modes_to_trace=modes_to_trace, stateful=stateful, arg_stateful_idxs=arg_stateful_idxs, kwarg_stateful_idxs=kwarg_stateful_idxs, @@ -187,10 +178,9 @@ def unify( *objs: Callable, source: Optional[str] = None, graph_caching: bool = False, - args: Optional[Sequence] = None, + args: Optional[Tuple] = None, kwargs: Optional[Mapping] = None, with_numpy: bool = True, - modes_to_trace: str = "all", **transpile_kwargs ): from ._compiler import unify as _unify @@ -202,6 +192,5 @@ def unify( args=args, kwargs=kwargs, with_numpy=with_numpy, - modes_to_trace=modes_to_trace, **transpile_kwargs, ) From 9ba0c21147cdd7bdc2f65d714046c368b1690ecf Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 18 Dec 2023 17:29:12 +0400 Subject: [PATCH 395/978] Refactor setup.py to include all system tags --- setup.py | 17 +---------------- 1 file changed, 1 insertion(+), 16 deletions(-) diff --git a/setup.py b/setup.py index c61ac547230ce..e98695ecf1b84 100644 --- a/setup.py +++ b/setup.py @@ -57,22 +57,7 @@ def _strip(line): else: from pip._vendor.packaging import tags - if ( - "arm64" in os.uname().machine - and os.uname().sysname == "Darwin" - and os.sys.version_info[:2] >= (3, 10) - and os.sys.version_info[:2] < (3, 11) - ): - all_tags = ["cp310-cp310-macosx_arm64_darwin"] - elif ( - "arm64" in os.uname().machine - and os.uname().sysname == "Darwin" - and os.sys.version_info[:2] >= (3, 11) - and os.sys.version_info[:2] < (3, 12) - ): - all_tags = ["cp311-cp311-macosx_arm64_darwin"] - else: - all_tags = list(tags.sys_tags()) + all_tags = list(tags.sys_tags()) # download binaries for the tag with highest precedence for tag in all_tags: From c1b2cb40931b848954b2f4c2cb4ac0bac98ba6fe Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 18 Dec 2023 21:29:08 +0530 Subject: [PATCH 396/978] fix: Fixed arguments in `staticmethod` (#27767) --- ivy/data_classes/container/experimental/linear_algebra.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/data_classes/container/experimental/linear_algebra.py b/ivy/data_classes/container/experimental/linear_algebra.py index 54e51634a4453..697d0ef749e52 100644 --- a/ivy/data_classes/container/experimental/linear_algebra.py +++ b/ivy/data_classes/container/experimental/linear_algebra.py @@ -768,7 +768,7 @@ def multi_dot( @staticmethod def static_cond( - self: ivy.Container, + x: ivy.Container, /, *, key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, @@ -784,7 +784,7 @@ def static_cond( Parameters ---------- - self + x container with input arrays. p order of the norm of the matrix (see ivy.norm). @@ -803,7 +803,7 @@ def static_cond( """ return ContainerBase.cont_multi_map_in_function( "cond", - self, + x, p=p, out=out, key_chains=key_chains, From ccce717738c9ee53bd7a91c7eb4132fa13633b40 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 18 Dec 2023 21:29:39 +0530 Subject: [PATCH 397/978] feat: Replaced `pydocstyle` with `ruff` and modified files accordingly (#27761) --- .pre-commit-config.yaml | 10 +++---- .../paddle/experimental/elementwise.py | 2 ++ ivy/functional/frontends/torch/tensor.py | 1 + ivy/functional/ivy/device.py | 1 + ivy_tests/test_docstrings.py | 1 - pyproject.toml | 30 +++++++++++++++++++ 6 files changed, 39 insertions(+), 6 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 2484a461e3be8..2e231afb1f7a7 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -32,12 +32,12 @@ repos: rev: v1.7.5 hooks: - id: docformatter - - repo: https://github.com/pycqa/pydocstyle - rev: 6.3.0 + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.1.8 hooks: - - id: pydocstyle - # Exclude everything in frontends except __init__.py, and func_wrapper.py - exclude: 'ivy/functional/(frontends|backends)/(?!.*/func_wrapper\.py$).*(?!__init__\.py$)' + # Run the linter. + - id: ruff + args: [ --fix ] - repo: https://github.com/unifyai/lint-hook rev: a72ffb17562d919311653d7f593cb537d1245c19 hooks: diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 866b2124fb281..597087dbfe65a 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -751,9 +751,11 @@ def _is_scalar(x): """Determines if the given tensor is a scalar. Args: + ---- - x (paddle.Tensor): Input tensor. Returns: + ------- - bool: True if the tensor is a scalar, False otherwise. """ return x.size == 1 and x.dim() == 0 and tuple(x.shape) == () diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index c469b235e949f..bc16b2b84d2bf 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -285,6 +285,7 @@ def view(self, *args, size=None): - list of ints - torch.Size object - ints + Parameters ---------- args:int arguments diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index 56c34b44fa2ff..9187040ad1ffc 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -297,6 +297,7 @@ def set_soft_device_mode(mode: bool) -> None: --------- mode boolean whether to move input arrays + Examples -------- >>> ivy.set_soft_device_mode(False) diff --git a/ivy_tests/test_docstrings.py b/ivy_tests/test_docstrings.py index a9d48a68b4011..0f582920243ef 100644 --- a/ivy_tests/test_docstrings.py +++ b/ivy_tests/test_docstrings.py @@ -68,7 +68,6 @@ def check_docstring_examples_run( ------- None if the test passes, else marks the test as failed. """ - """ Functions skipped as their output dependent on outside factors: diff --git a/pyproject.toml b/pyproject.toml index f41dc8bb153c2..23f6dc2c85e4a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,3 +5,33 @@ requires = [ "pip" ] build-backend = "setuptools.build_meta" + +[tool.ruff] +target-version = "py38" + +select = ["D"] # Enabling Only pydocstyle checks as of now (https://docs.astral.sh/ruff/rules/#pydocstyle-d) + +ignore = [ + "D100", # Missing docstring in public module. + "D101", # Missing docstring in public class. + "D102", # Missing docstring in public method. + "D103", # Missing docstring in public function. + "D104", # Missing docstring in public package. + "D105", # Missing docstring in magic method. + "D106", # Missing docstring in public nested class. + "D107", # Missing docstring in `__init__`. + "D203", # 1 blank line required before class docstring. + "D205", # 1 blank line required between summary line and description. + "D212", # Multi-line docstring summary should start at the first line. + "D213", # Multi-line docstring summary should start at the second line. + "D209", # Multi-line docstring closing quotes should be on a separate line. + "D400", # First line should end with a period. + "D401", # First line of docstring should be in imperative mood. + "D415", # First line should end with a period, question mark, or exclamation point. + "D416", # Section name should end with a colon ("Attributes"). + "D417", # Missing argument description in the docstring for argument "X". +] + +exclude = [ +'ivy/functional/(frontends|backends)/(?!.*/func_wrapper\.py$).*(?!__init__\.py$)', +] From 5abff06cacd31b88c689cde8302a91e3dbd5b4ec Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 18 Dec 2023 21:35:45 +0530 Subject: [PATCH 398/978] refactor: Refactored and reformatted for better readability and efficiency (#27734) Co-authored-by: ivy-branch Co-authored-by: Kareem Morsy --- ivy/data_classes/container/base.py | 6 +++--- ivy/functional/backends/jax/data_type.py | 5 +---- .../backends/jax/experimental/losses.py | 8 ++++---- ivy/functional/backends/numpy/data_type.py | 5 +---- .../backends/numpy/experimental/losses.py | 4 ++-- ivy/functional/backends/numpy/random.py | 2 +- ivy/functional/backends/paddle/data_type.py | 5 +---- .../paddle/experimental/elementwise.py | 6 +++--- .../backends/paddle/experimental/losses.py | 4 ++-- ivy/functional/backends/paddle/random.py | 2 +- .../backends/tensorflow/data_type.py | 5 +---- .../backends/tensorflow/experimental/losses.py | 4 ++-- ivy/functional/backends/tensorflow/random.py | 2 +- ivy/functional/backends/torch/data_type.py | 5 +---- .../backends/torch/experimental/statistical.py | 2 +- ivy/functional/backends/torch/random.py | 2 +- .../jax/lax/control_flow_operators.py | 2 +- ivy/functional/frontends/jax/numpy/creation.py | 2 +- .../jax/numpy/mathematical_functions.py | 18 +++++++++--------- .../numpy/logic/truth_value_testing.py | 5 +---- .../frontends/numpy/ndarray/ndarray.py | 2 +- .../frontends/paddle/nn/functional/common.py | 8 ++++---- .../frontends/paddle/nn/functional/loss.py | 5 ++--- .../frontends/paddle/nn/functional/pooling.py | 2 +- .../frontends/sklearn/tree/_splitter.py | 8 ++++---- .../frontends/tensorflow/general_functions.py | 2 +- ivy/functional/frontends/tensorflow/tensor.py | 10 ++++------ .../frontends/tensorflow/variable.py | 2 +- .../indexing_slicing_joining_mutating_ops.py | 5 ++--- .../torch/nn/functional/vision_functions.py | 2 +- .../frontends/torch/nn/modules/module.py | 2 +- ivy/stateful/helpers.py | 4 ++-- ivy/stateful/module.py | 16 ++++++++-------- ivy/utils/assertions.py | 2 +- ivy/utils/backend/handler.py | 6 +++--- ivy/utils/einsum_path_helpers.py | 6 +++--- ivy/utils/exceptions.py | 7 ++----- .../test_nn/test_functional/test_common.py | 4 ++-- .../test_tensorflow/test_linalg.py | 2 +- .../test_functional/test_core/test_nest.py | 2 +- .../test_ivy/test_stateful/test_modules.py | 6 +++--- scripts/run_tests/run_tests.py | 2 +- 42 files changed, 87 insertions(+), 112 deletions(-) diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index 74cee571ae367..a265766f69aa2 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -1245,7 +1245,7 @@ def h5_file_size(h5_obj_or_filepath): size = 0 batch_size = 0 - for key, value in h5_obj.items(): + for value in h5_obj.values(): if isinstance(value, h5py.Group): size_to_add, batch_size = ivy.Container.h5_file_size(value) size += size_to_add @@ -1285,7 +1285,7 @@ def shuffle_h5_file(h5_obj_or_filepath, seed_value=0): else: h5_obj = h5_obj_or_filepath - for key, value in h5_obj.items(): + for value in h5_obj.values(): if isinstance(value, h5py.Group): ivy.Container.shuffle_h5_file(value, seed_value) elif isinstance(value, h5py.Dataset): @@ -2160,7 +2160,7 @@ def cont_to_iterator_values(self, include_empty=False): Iterator for the container values. """ - for key, value in self.items(): + for value in self.values(): if isinstance(value, ivy.Container) and (not include_empty or value): # noinspection PyCompatibility yield from value.cont_to_iterator_values(include_empty) diff --git a/ivy/functional/backends/jax/data_type.py b/ivy/functional/backends/jax/data_type.py index e25e54e745bbe..5f2a13bb68113 100644 --- a/ivy/functional/backends/jax/data_type.py +++ b/ivy/functional/backends/jax/data_type.py @@ -267,7 +267,4 @@ def dtype_bits(dtype_in: Union[jnp.dtype, str, np.dtype], /) -> int: def is_native_dtype(dtype_in: Union[jnp.dtype, str], /) -> bool: if not ivy.is_hashable_dtype(dtype_in): return False - if dtype_in in ivy_dtype_dict: - return True - else: - return False + return dtype_in in ivy_dtype_dict diff --git a/ivy/functional/backends/jax/experimental/losses.py b/ivy/functional/backends/jax/experimental/losses.py index b03072f362d7b..24359a26366be 100644 --- a/ivy/functional/backends/jax/experimental/losses.py +++ b/ivy/functional/backends/jax/experimental/losses.py @@ -84,22 +84,22 @@ def _validate_poisson_nll_params( for parameter, name in zip([input, label], ["input", "label"]): if parameter.dtype not in allowed_dtypes: raise TypeError( - "The dtype of '%s' in poisson_nll_loss should be one of %s, but" - " received %s." % (name, allowed_dtypes, parameter.dtype) + f"The dtype of '{name}' in poisson_nll_loss should be one of" + f" {allowed_dtypes}, but received {parameter.dtype}." ) # Validate epsilon if epsilon <= 0: raise ValueError( "The value of `epsilon` in poisson_nll_loss should be positive, but" - " received %f, which is not allowed" % epsilon + f" received {epsilon}, which is not allowed." ) # Validate reduction if reduction not in ["sum", "mean", "none"]: raise ValueError( "The value of 'reduction' in poisson_nll_loss should be 'sum', 'mean' or" - " 'none', but received %s, which is not allowed." % reduction + f" 'none', but received {reduction}, which is not allowed." ) # Validate shape diff --git a/ivy/functional/backends/numpy/data_type.py b/ivy/functional/backends/numpy/data_type.py index a748843b6513e..facd6d6f3b645 100644 --- a/ivy/functional/backends/numpy/data_type.py +++ b/ivy/functional/backends/numpy/data_type.py @@ -260,7 +260,4 @@ def dtype_bits(dtype_in: Union[np.dtype, str], /) -> int: def is_native_dtype(dtype_in: Union[np.dtype, str], /) -> bool: if not ivy.is_hashable_dtype(dtype_in): return False - if dtype_in in ivy_dtype_dict: - return True - else: - return False + return dtype_in in ivy_dtype_dict diff --git a/ivy/functional/backends/numpy/experimental/losses.py b/ivy/functional/backends/numpy/experimental/losses.py index 25c01279aa54d..35cc06af9c8c4 100644 --- a/ivy/functional/backends/numpy/experimental/losses.py +++ b/ivy/functional/backends/numpy/experimental/losses.py @@ -106,14 +106,14 @@ def _validate_poisson_nll_params( if epsilon <= 0: raise ValueError( "The value of `epsilon` in poisson_nll_loss should be positive, but" - " received %f, which is not allowed" % epsilon + f" received {epsilon}, which is not allowed." ) # Validate reduction if reduction not in ["sum", "mean", "none"]: raise ValueError( "The value of 'reduction' in poisson_nll_loss should be 'sum', 'mean' or" - " 'none', but received %s, which is not allowed." % reduction + f" 'none', but received {reduction}, which is not allowed." ) # Validate shape diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index a08d6a7d3addb..3df9936a21769 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -109,7 +109,7 @@ def randint( return np.random.randint(low, high, shape, dtype=dtype) -def seed(*, seed_value: int = 0) -> None: +def seed(*, seed_value: int = 0): np.random.seed(seed_value) return diff --git a/ivy/functional/backends/paddle/data_type.py b/ivy/functional/backends/paddle/data_type.py index 2aca8cca43f87..6112117f2e6d5 100644 --- a/ivy/functional/backends/paddle/data_type.py +++ b/ivy/functional/backends/paddle/data_type.py @@ -274,7 +274,4 @@ def dtype_bits(dtype_in: Union[paddle.dtype, str], /) -> int: def is_native_dtype(dtype_in: Union[paddle.dtype, str], /) -> bool: if not ivy.is_hashable_dtype(dtype_in): return False - if dtype_in in ivy_dtype_dict: - return True - else: - return False + return dtype_in in ivy_dtype_dict diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 597087dbfe65a..1d9802da6c154 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -750,12 +750,12 @@ def _EvaluatePolynomial(x, coefficients): def _is_scalar(x): """Determines if the given tensor is a scalar. - Args: + Args ---- - x (paddle.Tensor): Input tensor. - Returns: - ------- + Return + ------ - bool: True if the tensor is a scalar, False otherwise. """ return x.size == 1 and x.dim() == 0 and tuple(x.shape) == () diff --git a/ivy/functional/backends/paddle/experimental/losses.py b/ivy/functional/backends/paddle/experimental/losses.py index 665720fbe0df7..7e3d245bbed72 100644 --- a/ivy/functional/backends/paddle/experimental/losses.py +++ b/ivy/functional/backends/paddle/experimental/losses.py @@ -173,14 +173,14 @@ def _validate_poisson_nll_params( if epsilon <= 0: raise ValueError( "The value of `epsilon` in poisson_nll_loss should be positive, but" - " received %f, which is not allowed" % epsilon + f" received {epsilon}, which is not allowed." ) # Validate reduction if reduction not in ["sum", "mean", "none"]: raise ValueError( "The value of 'reduction' in poisson_nll_loss should be 'sum', 'mean' or" - " 'none', but received %s, which is not allowed." % reduction + f" 'none', but received {reduction}, which is not allowed." ) # Validate shape diff --git a/ivy/functional/backends/paddle/random.py b/ivy/functional/backends/paddle/random.py index 512954b81ef3f..3579c42c8bbb7 100644 --- a/ivy/functional/backends/paddle/random.py +++ b/ivy/functional/backends/paddle/random.py @@ -140,7 +140,7 @@ def randint( return _retval if shape else _retval.squeeze(axis=0) -def seed(*, seed_value: int = 0) -> None: +def seed(*, seed_value: int = 0): _ = paddle.seed(seed_value) return diff --git a/ivy/functional/backends/tensorflow/data_type.py b/ivy/functional/backends/tensorflow/data_type.py index 22e8c1f0a78d6..8b7209debc852 100644 --- a/ivy/functional/backends/tensorflow/data_type.py +++ b/ivy/functional/backends/tensorflow/data_type.py @@ -273,10 +273,7 @@ def dtype_bits(dtype_in: Union[tf.DType, str, np.dtype], /) -> int: def is_native_dtype(dtype_in: Union[tf.DType, str], /) -> bool: if not ivy.is_hashable_dtype(dtype_in): return False - if dtype_in in ivy_dtype_dict and isinstance(dtype_in, tf.dtypes.DType): - return True - else: - return False + return bool(dtype_in in ivy_dtype_dict and isinstance(dtype_in, tf.dtypes.DType)) # ToDo: diff --git a/ivy/functional/backends/tensorflow/experimental/losses.py b/ivy/functional/backends/tensorflow/experimental/losses.py index 3994af1646866..ecc812b53c085 100644 --- a/ivy/functional/backends/tensorflow/experimental/losses.py +++ b/ivy/functional/backends/tensorflow/experimental/losses.py @@ -96,14 +96,14 @@ def _validate_poisson_nll_params( if epsilon <= 0: raise ValueError( "The value of `epsilon` in poisson_nll_loss should be positive, but" - " received %f, which is not allowed" % epsilon + f" received {epsilon}, which is not allowed." ) # Validate reduction if reduction not in ["sum", "mean", "none"]: raise ValueError( "The value of 'reduction' in poisson_nll_loss should be 'sum', 'mean' or" - " 'none', but received %s, which is not allowed." % reduction + f" 'none', but received {reduction}, which is not allowed." ) # Validate shape diff --git a/ivy/functional/backends/tensorflow/random.py b/ivy/functional/backends/tensorflow/random.py index bd7981740a755..dcb320508614d 100644 --- a/ivy/functional/backends/tensorflow/random.py +++ b/ivy/functional/backends/tensorflow/random.py @@ -142,7 +142,7 @@ def randint( return tf.cast(tf.random.uniform(shape, low, high, "float32", seed=seed), dtype) -def seed(*, seed_value: int = 0) -> None: +def seed(*, seed_value: int = 0): tf.random.set_seed(seed_value) return diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index 37087890c10fa..d5e0fd7cd2e9f 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -227,7 +227,4 @@ def dtype_bits(dtype_in: Union[torch.dtype, str, np.dtype], /) -> int: def is_native_dtype(dtype_in: Union[torch.dtype, str], /) -> bool: if not ivy.is_hashable_dtype(dtype_in): return False - if dtype_in in ivy_dtype_dict and isinstance(dtype_in, torch.dtype): - return True - else: - return False + return bool(dtype_in in ivy_dtype_dict and isinstance(dtype_in, torch.dtype)) diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index 3c89b0a90d592..247308cf01eba 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -645,7 +645,7 @@ def cummin( dtype = ivy.as_native_dtype(dtype) if dtype is None: dtype = _infer_dtype(x.dtype) - if not (reverse): + if not reverse: ret = torch.cummin(x, axis)[0] else: ret = torch.cummin(torch.flip(x, dims=(axis,)), axis)[0] diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index 0871269316e62..95538ea9960ad 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -114,7 +114,7 @@ def randint( return (torch.rand(shape, device=device) * rand_range + low).to(dtype) -def seed(*, seed_value: int = 0) -> None: +def seed(*, seed_value: int = 0): torch.manual_seed(seed_value) torch.cuda.manual_seed(seed_value) if hasattr(torch.backends, "mps"): diff --git a/ivy/functional/frontends/jax/lax/control_flow_operators.py b/ivy/functional/frontends/jax/lax/control_flow_operators.py index 107c87e6eb08a..e9f58b95ddbac 100644 --- a/ivy/functional/frontends/jax/lax/control_flow_operators.py +++ b/ivy/functional/frontends/jax/lax/control_flow_operators.py @@ -19,7 +19,7 @@ def cond(pred, true_fun, false_fun, *operands, operand=None, linear=None): @to_ivy_arrays_and_back def fori_loop(lower, upper, body_fun, init_val): - if not (callable(body_fun)): + if not callable(body_fun): raise ivy.exceptions.IvyException( "jax.lax.fori_loop: Argument body_fun should be callable." ) diff --git a/ivy/functional/frontends/jax/numpy/creation.py b/ivy/functional/frontends/jax/numpy/creation.py index 50e912565ec45..0ee3781d3c64b 100644 --- a/ivy/functional/frontends/jax/numpy/creation.py +++ b/ivy/functional/frontends/jax/numpy/creation.py @@ -275,7 +275,7 @@ def setdiff1d(ar1, ar2, assume_unique=False, *, size=None, fill_value=None): if size is None: return ar1[mask] else: - if not (assume_unique): + if not assume_unique: # Set mask to zero at locations corresponding to unique() padding. n_unique = ar1.size + 1 - (ar1 == ar1[0]).sum(dtype=ivy.int64) mask = ivy.where(ivy.arange(ar1.size) < n_unique, mask, False) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 70874ade1a5d8..3c7b864f20500 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -366,8 +366,8 @@ def einsum_path(subscripts, *operands, optimize="greedy"): # Explicit "einsum_path" is usually trusted, but we detect this kind of # mistake in order to prevent from returning an intermediate value. raise RuntimeError( - "Invalid einsum_path is specified: {} more operands has to be " - "contracted.".format(len(input_list) - 1) + f"Invalid einsum_path is specified: {len(input_list) - 1} " + "more operands has to be contracted." ) # Return the path along with a nice string representation @@ -377,13 +377,13 @@ def einsum_path(subscripts, *operands, optimize="greedy"): speedup = naive_cost / opt_cost max_i = max(size_list) - path_print = " Complete contraction: %s\n" % overall_contraction - path_print += " Naive scaling: %d\n" % len(indices) - path_print += " Optimized scaling: %d\n" % max(scale_list) - path_print += " Naive FLOP count: %.3e\n" % naive_cost - path_print += " Optimized FLOP count: %.3e\n" % opt_cost - path_print += " Theoretical speedup: %3.3f\n" % speedup - path_print += " Largest intermediate: %.3e elements\n" % max_i + path_print = f" Complete contraction: {overall_contraction}\n" + path_print += f" Naive scaling: {len(indices)}\n" + path_print += f" Optimized scaling: {max(scale_list)}\n" + path_print += f" Naive FLOP count: {naive_cost:.3e}\n" + path_print += f" Optimized FLOP count: {opt_cost:.3e}\n" + path_print += f" Theoretical speedup: {speedup:3.3f}\n" + path_print += f" Largest intermediate: {max_i:.3e} elements\n" path_print += "-" * 74 + "\n" path_print += "%6s %24s %40s\n" % header path_print += "-" * 74 diff --git a/ivy/functional/frontends/numpy/logic/truth_value_testing.py b/ivy/functional/frontends/numpy/logic/truth_value_testing.py index 0421def6ee57e..5d0a3b9276f2d 100644 --- a/ivy/functional/frontends/numpy/logic/truth_value_testing.py +++ b/ivy/functional/frontends/numpy/logic/truth_value_testing.py @@ -55,10 +55,7 @@ def iscomplexobj(x): if x.ndim == 0: return ivy.is_complex_dtype(ivy.dtype(x)) for ele in x: - if ivy.is_complex_dtype(ivy.dtype(ele)): - return True - else: - return False + return bool(ivy.is_complex_dtype(ivy.dtype(ele))) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/numpy/ndarray/ndarray.py b/ivy/functional/frontends/numpy/ndarray/ndarray.py index 8aeab75ad40dc..dc54cdbdd7267 100644 --- a/ivy/functional/frontends/numpy/ndarray/ndarray.py +++ b/ivy/functional/frontends/numpy/ndarray/ndarray.py @@ -329,7 +329,7 @@ def flatten(self, order="C"): def fill(self, num, /): self.ivy_array = np_frontend.full(self.shape, num).ivy_array - return + return None def repeat(self, repeats, axis=None): return np_frontend.repeat(self, repeats, axis=axis) diff --git a/ivy/functional/frontends/paddle/nn/functional/common.py b/ivy/functional/frontends/paddle/nn/functional/common.py index ef27e44b2fa41..4f513b23cf5a9 100644 --- a/ivy/functional/frontends/paddle/nn/functional/common.py +++ b/ivy/functional/frontends/paddle/nn/functional/common.py @@ -103,7 +103,7 @@ def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): # Input checking if isinstance(kernel_sizes, int): kernel_sizes = [kernel_sizes, kernel_sizes] - elif not (isinstance(kernel_sizes, (list, tuple))): + elif not isinstance(kernel_sizes, (list, tuple)): raise ivy.exceptions.IvyError( "Expected kernel size input as type int, tuple or list but got" f" {type(kernel_sizes)}" @@ -111,14 +111,14 @@ def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): if isinstance(strides, int): strides = [strides, strides] - elif not (isinstance(strides, (list, tuple))): + elif not isinstance(strides, (list, tuple)): raise ivy.exceptions.IvyError( f"Expected strides input as type int, tuple or list but got {type(strides)}" ) if isinstance(dilations, int): dilations = [dilations, dilations] - elif not (isinstance(dilations, (list, tuple))): + elif not isinstance(dilations, (list, tuple)): raise ivy.exceptions.IvyError( "Expected dilations input as type int, tuple or list but got" f" {type(dilations)}" @@ -126,7 +126,7 @@ def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): if isinstance(paddings, int): paddings = [paddings, paddings] - elif not (isinstance(paddings, (list, tuple))): + elif not isinstance(paddings, (list, tuple)): raise ivy.exceptions.IvyError( "Expected paddings, input as type int, tuple or list but got" f" {type(paddings)}" diff --git a/ivy/functional/frontends/paddle/nn/functional/loss.py b/ivy/functional/frontends/paddle/nn/functional/loss.py index 52d07db32110b..5951a446501b8 100644 --- a/ivy/functional/frontends/paddle/nn/functional/loss.py +++ b/ivy/functional/frontends/paddle/nn/functional/loss.py @@ -135,14 +135,13 @@ def dice_loss(input, label, epsilon=0.00001, name=None): len(input.shape) == len(label.shape), message=str( "The rank of input and label should be equal, " - "but received input: %d, label: %d." % (len(input.shape), len(label.shape)) + f"but received input: {len(input.shape)}, label: {len(label.shape)}." ), ) ivy.assertions.check_true( label.shape[-1] == 1, message=str( - "The last dimension of label should be 1, but received %d." - % label.shape[-1] + f"The last dimension of label should be 1, but received {label.shape[-1]}." ), ) ivy.assertions.check_true( diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index b79af86a25392..261176db7211c 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -118,7 +118,7 @@ def max_pool2d( if data_format not in ["NCHW", "NHWC"]: raise ValueError( "Attr(data_format) should be 'NCHW' or 'NHWC'. Received " - "Attr(data_format): %s." % str(data_format) + f"Attr(data_format): {data_format}." ) if data_format == "NHWC" and return_mask: diff --git a/ivy/functional/frontends/sklearn/tree/_splitter.py b/ivy/functional/frontends/sklearn/tree/_splitter.py index c03191ea43a6a..6325b84ca2b0b 100644 --- a/ivy/functional/frontends/sklearn/tree/_splitter.py +++ b/ivy/functional/frontends/sklearn/tree/_splitter.py @@ -424,10 +424,10 @@ def node_split_best( feature_values[p_prev] / 2.0 + feature_values[p] / 2.0 ) - if ( - current_split.threshold == feature_values[p] - or current_split.threshold == ivy.inf - or current_split.threshold == -ivy.inf + if current_split.threshold in ( + feature_values[p], + ivy.inf, + -ivy.inf, ): current_split.threshold = feature_values[p_prev] diff --git a/ivy/functional/frontends/tensorflow/general_functions.py b/ivy/functional/frontends/tensorflow/general_functions.py index d96945f4e82f9..322becf12c4b4 100644 --- a/ivy/functional/frontends/tensorflow/general_functions.py +++ b/ivy/functional/frontends/tensorflow/general_functions.py @@ -20,7 +20,7 @@ def _num_to_bit_list(value, num_dims): - return list(map(int, "{:0{size}b}".format(value, size=num_dims)))[::-1] + return list(map(int, f"{value:0{num_dims}b}"))[::-1] # --- Main --- # diff --git a/ivy/functional/frontends/tensorflow/tensor.py b/ivy/functional/frontends/tensorflow/tensor.py index e70c78c13e1a5..b9b9745af3ae3 100644 --- a/ivy/functional/frontends/tensorflow/tensor.py +++ b/ivy/functional/frontends/tensorflow/tensor.py @@ -10,9 +10,7 @@ class EagerTensor: def __init__(self, array): - self._ivy_array = ( - ivy.array(array) if not isinstance(array, ivy.Array) else array - ) + self._ivy_array = array if isinstance(array, ivy.Array) else ivy.array(array) def __repr__(self): return ( @@ -244,9 +242,9 @@ def __str__(self): if self.rank is None: return "" elif self.rank == 1: - return "(%s,)" % self._dims[0] + return f"({self._dims[0]},)" else: - return "(%s)" % ", ".join(str(d) for d in self._dims) + return f'({", ".join(str(d) for d in self._dims)})' # Properties # # ---------- # @@ -334,7 +332,7 @@ def unknown_shape(rank=None, **kwargs): if rank is None and "ndims" in kwargs: rank = kwargs.pop("ndims") if kwargs: - raise TypeError("Unknown argument: %s" % kwargs) + raise TypeError(f"Unknown argument: {kwargs}") if rank is None: return TensorShape(None) else: diff --git a/ivy/functional/frontends/tensorflow/variable.py b/ivy/functional/frontends/tensorflow/variable.py index c7b2e12236841..bf6feeedde71d 100644 --- a/ivy/functional/frontends/tensorflow/variable.py +++ b/ivy/functional/frontends/tensorflow/variable.py @@ -297,7 +297,7 @@ def __repr__(self): self._indices, self._values, ( - ", dense_shape=%s" % (self._dense_shape,) + f", dense_shape={self._dense_shape}" if self._dense_shape is not None else "" ), diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py index e904fda02498b..6f5775164c066 100644 --- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py +++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py @@ -89,7 +89,7 @@ def diagonal_scatter(input, src, offset=0, dim1=0, dim2=1): diagonal_indices = ivy.diagonal( indices.reshape(input.shape), offset=offset, axis1=dim1, axis2=dim2 ) - if not (src.shape == diagonal_indices.shape): + if src.shape != diagonal_indices.shape: raise ivy.utils.exceptions.IvyException( "src must have shape equal to specified diagonal of input. src size =" f" {src.shape}, diagonal size = {diagonal_indices.shape}" @@ -420,8 +420,7 @@ def swapdims(input, dim0, dim1): def t(input): if input.ndim > 2: raise ivy.utils.exceptions.IvyException( - "t(input) expects a tensor with <= 2 dimensions, but self is %dD" - % input.ndim + f"t(input) expects a tensor with <= 2 dimensions, but self is {input.ndim}D" ) if input.ndim == 2: return ivy.swapaxes(input, 0, 1) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index 26b103906b8c1..998aa75061dd7 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -388,7 +388,7 @@ def interpolate( mode=mode, scale_factor=scale_factor, recompute_scale_factor=recompute_scale_factor, - align_corners=True if align_corners else False, + align_corners=bool(align_corners), antialias=antialias, ) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 66dc306159614..5f33aac3eebc9 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -67,7 +67,7 @@ def _create_variables(self, device=None, dtype=None): return v def _build(self, *args, **kwargs): - for _, module in self.__dict__.items(): + for module in self.__dict__.values(): if isinstance(module, Module) and module is not self: if not module.built: module.build( diff --git a/ivy/stateful/helpers.py b/ivy/stateful/helpers.py index 389b30c07eca7..202acfde78d37 100644 --- a/ivy/stateful/helpers.py +++ b/ivy/stateful/helpers.py @@ -360,7 +360,7 @@ def _convert_tensors_to_numpy(self): The converted Module object. """ if self.module_dict: - for _, module in self.module_dict.items(): + for module in self.module_dict.values(): module._convert_tensors_to_numpy() self.v = self.v.to_numpy() @@ -375,7 +375,7 @@ def _convert_numpy_to_tensors(self): The converted Module object. """ if self.module_dict: - for _, module in self.module_dict.items(): + for module in self.module_dict.values(): module._convert_numpy_to_tensors() self.v = self.v.to_ivy() else: diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 4b42be6b4540e..195ea30ea1f1f 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -250,7 +250,7 @@ def build( # build any child 'on_call' layers if not built and from_call: # update child modules to share the same device - for k, v in self.__dict__.items(): + for v in self.__dict__.values(): if isinstance(v, ivy.Module): v._device = self._device @@ -375,7 +375,7 @@ def eval(self): def to_device(self, device): """Move the weights and buffers to the specified device.""" self._device = ivy.default(device, self._device) - for _, obj in self.state_dict.items(): + for obj in self.state_dict.values(): if isinstance(obj, ivy.Module): obj.to_device(device) elif ivy.is_array(obj) or ivy.is_ivy_container(obj): @@ -544,7 +544,7 @@ def __repr__(self): if extra_repr: extra_lines = extra_repr.split("\n") child_lines = [] - for key, _ in self.v.items(): + for key in self.v.keys(): if isinstance(getattr(self, key, None), Module): mod_str = repr(getattr(self, key)) mod_str = self._addindent(mod_str, 2) @@ -693,7 +693,7 @@ def _forward(self, *a, **kw): a, kw = ivy.args_to_native(*a, **kw) params_hk = self._dict_to_hk_flat_map(self.v.cont_to_dict()) ret = self._native_module.apply(params_hk, 0, *a, **kw) - nested = True if isinstance(ret, tuple) else False + nested = isinstance(ret, tuple) return ivy.to_native(ret, nested=nested) def _hk_flat_map_to_dict(self, hk_flat_map): @@ -756,7 +756,7 @@ def _forward(self, *a, **kw): a, kw = ivy.args_to_native(*a, **kw) params_fx = flax.core.freeze(self.v.cont_to_dict()) ret = self._native_module.apply(params_fx, *a, **kw) - nested = True if isinstance(ret, tuple) else False + nested = isinstance(ret, tuple) return ivy.to_native(ret, nested=nested) @@ -782,7 +782,7 @@ def _build(self, *args, **kwargs): def _forward(self, *a, **kw): a, kw = ivy.args_to_native(*a, **kw) ret = self._native_module(*a, **kw) - nested = True if isinstance(ret, tuple) else False + nested = isinstance(ret, tuple) return ivy.to_native(ret, nested=nested) @@ -811,7 +811,7 @@ def _build(self, *args, **kwargs): def _forward(self, *a, **kw): a, kw = ivy.args_to_native(*a, **kw) ret = self._native_module(*a, **kw) - nested = True if isinstance(ret, tuple) else False + nested = isinstance(ret, tuple) return ivy.to_native(ret, nested=nested) @@ -876,5 +876,5 @@ def _forward(self, *a, **kw): a, kw = ivy.args_to_native(*a, **kw) self._update_v(self.v) ret = self._native_module(*a, **kw) - nested = True if isinstance(ret, tuple) else False + nested = isinstance(ret, tuple) return ivy.to_native(ret, nested=nested) diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index 3e3de358e8884..2d5e5a87960cd 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -269,7 +269,7 @@ def check_one_way_broadcastable(x1, x2): if len(x1) > len(x2): return False for a, b in zip(x1[::-1], x2[::-1]): - if a == 1 or a == b: + if a in (1, b): pass else: return False diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 9099e9f926ccf..702766db6cb79 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -102,7 +102,7 @@ def _determine_backend_from_args(args): args = args.data if isinstance(args, dict): - for key, value in args.items(): + for value in args.values(): # recursively call the function for each value in the dictionary lib = _determine_backend_from_args(value) if lib: @@ -376,7 +376,7 @@ def set_backend(backend: str, dynamic: bool = False): _set_module_backend(ivy_original_dict, ivy, backend) # following snippet is required to update the ivy.functional namespace with # backend-specific functions - for key, _ in ivy.__dict__.items(): + for key in ivy.__dict__.keys(): if key in ivy.functional.__dict__ and not key.startswith("__"): ivy.functional.__dict__[key] = ivy.__dict__[key] @@ -558,7 +558,7 @@ def with_backend(backend: str, cached: bool = True): ivy_pack.__dict__.copy(), ivy_pack, backend_module ) # TODO use a refactored code from ivy.set_backend - for key, _ in ivy_pack.__dict__.items(): + for key in ivy_pack.__dict__.keys(): if key in ivy_pack.functional.__dict__ and not key.startswith("__"): ivy_pack.functional.__dict__[key] = ivy_pack.ivy.__dict__[key] ivy_pack.backend_stack.append(backend_module) diff --git a/ivy/utils/einsum_path_helpers.py b/ivy/utils/einsum_path_helpers.py index a43fd5a1aaddf..465a0122e695e 100644 --- a/ivy/utils/einsum_path_helpers.py +++ b/ivy/utils/einsum_path_helpers.py @@ -604,12 +604,12 @@ def parse_einsum_input(operands, subscripts=None): tmp_subscripts = subscripts.replace(",", "") for s in sorted(set(tmp_subscripts)): if s not in (einsum_symbols): - raise ValueError("Character %s is not a valid symbol." % s) + raise ValueError(f"Character {s} is not a valid symbol.") if tmp_subscripts.count(s) == 1: output_subscript += s normal_inds = "".join(sorted(set(output_subscript) - set(out_ellipse))) - subscripts += "->" + out_ellipse + normal_inds + subscripts += f"->{out_ellipse}{normal_inds}" # Build output string if does not exist if "->" in subscripts: @@ -621,7 +621,7 @@ def parse_einsum_input(operands, subscripts=None): output_subscript = "" for s in sorted(set(tmp_subscripts)): if s not in einsum_symbols: - raise ValueError("Character %s is not a valid symbol." % s) + raise ValueError(f"Character {s} is not a valid symbol.") if tmp_subscripts.count(s) == 1: output_subscript += s diff --git a/ivy/utils/exceptions.py b/ivy/utils/exceptions.py index 8daf070899ab9..d8f35b27a5b0e 100644 --- a/ivy/utils/exceptions.py +++ b/ivy/utils/exceptions.py @@ -155,10 +155,7 @@ def _check_if_path_found(path, full_path): ret True if the path is found, False otherwise """ - if path in full_path: - return True - else: - return False + return path in full_path def _configure_stack_trace(traceback): @@ -177,7 +174,7 @@ def _configure_stack_trace(traceback): frontend_path = os.path.join("ivy", "functional", "frontends") wrapper_path = os.path.join("ivy", "func_wrapper.py") - while 1 and tb.tb_next: + while tb.tb_next: frame = tb.tb_next.tb_frame file_path = frame.f_code.co_filename if trace_mode == "ivy": diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py index f020caefc0d57..871bbe9ea7092 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_common.py @@ -80,7 +80,7 @@ def _interp_args(draw, mode=None, mode_list=None): elif mode_list: mode = draw(st.sampled_from(mode_list)) align_corners = draw(st.booleans()) - if (curr_backend == "tensorflow" or curr_backend == "jax") and not mixed_fn_compos: + if curr_backend in ["tensorflow", "jax"] and not mixed_fn_compos: align_corners = False if mode == "linear": num_dims = 3 @@ -157,7 +157,7 @@ def _interp_args(draw, mode=None, mode_list=None): ) recompute_scale_factor = False scale_factor = None - if (curr_backend == "tensorflow" or curr_backend == "jax") and not mixed_fn_compos: + if curr_backend in ["tensorflow", "jax"] and not mixed_fn_compos: if not recompute_scale_factor: recompute_scale_factor = True diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py index 936a069aa950e..716f149551848 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py @@ -1308,7 +1308,7 @@ def tridiagonal_matrix_filter(x): for i in range(dim): for j in range(dim): cell = x[i][j] - if i == j or i == j - 1 or i == j + 1: + if i in [j, j - 1, j + 1]: if cell == 0: return False else: diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_nest.py b/ivy_tests/test_ivy/test_functional/test_core/test_nest.py index be259bb20e3ff..ab0f09ccc811a 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_nest.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_nest.py @@ -259,7 +259,7 @@ def test_nested_any(x, fn): map_nested_dicts(x_copy, fn) def is_true_any(ob): - for k, v in ob.items(): + for v in ob.values(): if isinstance(v, dict): is_true_any(v) if isinstance(v, list): diff --git a/ivy_tests/test_ivy/test_stateful/test_modules.py b/ivy_tests/test_ivy/test_stateful/test_modules.py index 63bd2c069ccd0..45dcb1ae7c6e4 100644 --- a/ivy_tests/test_ivy/test_stateful/test_modules.py +++ b/ivy_tests/test_ivy/test_stateful/test_modules.py @@ -226,17 +226,17 @@ def assertion(x, on_device): raise AssertionError def model_assert(mod, on_device): - for key, obj in mod.v.items(): + for obj in mod.v.values(): if isinstance(obj, ivy.Module): return model_assert(obj, on_device) if isinstance(obj, (ivy.Container, dict)): - for item1, item2 in obj.items(): + for item2 in obj.values(): assertion(item2.device, on_device) else: assertion(obj.device, on_device) if getattr(mod, "buffers", None): - for key, obj in mod.buffers.items(): + for obj in mod.buffers.values(): if isinstance(obj, (ivy.Container, dict)): ivy.nested_map(lambda x: assertion(x.device, on_device), obj) else: diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index c86ac15803e5f..88c9558b5bc0f 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -73,7 +73,7 @@ backends = [backend.strip()] backend_name, backend_version = backend.split("/") other_backends = [ - fw for fw in BACKENDS if (fw != backend_name and fw != "paddle") + fw for fw in BACKENDS if (fw not in (backend_name, "paddle")) ] for other_backend in other_backends: backends.append( From e25f92ce516bb8e36e7431c70ec7a71a8f56bef9 Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Mon, 18 Dec 2023 21:21:00 +0000 Subject: [PATCH 399/978] feat: implemented tensorflow backend for lstm on cpu and gpu, and updated torch frontend lstm to use ivy.lstm_update (#27762) --- ivy/functional/backends/tensorflow/layers.py | 105 ++++++++++++++++++ .../torch/nn/functional/layer_functions.py | 89 ++++++--------- ivy/functional/ivy/layers.py | 22 +++- 3 files changed, 158 insertions(+), 58 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 973c0ec0011cc..51223de2aec18 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -6,6 +6,7 @@ import tensorflow as tf from tensorflow.python.types.core import Tensor +from keras.src.layers.rnn import gru_lstm_utils # local import ivy @@ -700,6 +701,110 @@ def conv_general_transpose( return res +def _cpu_lstm( + x, init_h, init_c, kernel, recurrent_kernel, bias, recurrent_bias, time_major +): + def step(cell_inputs, cell_states): + h_tm1 = cell_states[0] # previous memory state + c_tm1 = cell_states[1] # previous carry state + + z = tf.keras.backend.dot(cell_inputs, kernel) + bias + z += tf.keras.backend.dot(h_tm1, recurrent_kernel) + recurrent_bias + + z0, z1, z2, z3 = tf.split(z, 4, axis=-1) + + i = tf.sigmoid(z0) + f = tf.sigmoid(z1) + c = f * c_tm1 + i * tf.tanh(z2) + o = tf.sigmoid(z3) + + h = o * tf.tanh(c) + return h, [h, c] + + _, outputs, new_states = tf.keras.backend.rnn( + step, + x, + [init_h, init_c], + time_major=time_major, + ) + return outputs, new_states + + +def _gpu_lstm( + x, init_h, init_c, kernel, recurrent_kernel, bias, recurrent_bias, time_major +): + if not time_major: + x = tf.transpose(x, perm=(1, 0, 2)) + + init_h = tf.expand_dims(init_h, axis=0) + init_c = tf.expand_dims(init_c, axis=0) + + weights = tf.split(kernel, 4, axis=1) + weights += tf.split(recurrent_kernel, 4, axis=1) + full_bias = tf.concat((recurrent_bias, bias), axis=0) + params = gru_lstm_utils.canonical_to_params( + weights=weights, + biases=tf.split(full_bias, 8), + shape=tf.constant([-1]), + transpose_weights=True, + ) + outputs, h, c, _ = tf.raw_ops.CudnnRNN( + input=x, + input_h=init_h, + input_c=init_c, + params=params, + rnn_mode="lstm", + ) + return outputs, (h, c) + + +def lstm_update( + x: Union[tf.Tensor, tf.Variable], + init_h: Union[tf.Tensor, tf.Variable], + init_c: Union[tf.Tensor, tf.Variable], + kernel: Union[tf.Tensor, tf.Variable], + recurrent_kernel: Union[tf.Tensor, tf.Variable], + /, + *, + bias: Optional[Union[tf.Tensor, tf.Variable]] = None, + recurrent_bias: Optional[Union[tf.Tensor, tf.Variable]] = None, + time_major: bool = False, +) -> Tuple[Tensor, Tuple[Tensor, Tensor]]: + dev = x.device + x = x.data + init_h = init_h.data + init_c = init_c.data + kernel = kernel.data + recurrent_kernel = recurrent_kernel.data + bias = bias.data if bias is not None else bias + recurrent_bias = ( + recurrent_bias.data if recurrent_bias is not None else recurrent_bias + ) + if "cpu" in dev: + outputs, new_states = _cpu_lstm( + x, + init_h, + init_c, + kernel, + recurrent_kernel, + bias, + recurrent_bias, + time_major, + ) + else: + outputs, new_states = _gpu_lstm( + x, + init_h, + init_c, + kernel, + recurrent_kernel, + bias, + recurrent_bias, + time_major, + ) + return outputs, new_states + + def nms( boxes, scores=None, diff --git a/ivy/functional/frontends/torch/nn/functional/layer_functions.py b/ivy/functional/frontends/torch/nn/functional/layer_functions.py index 0f3b1cf74a82b..1790447af84c0 100644 --- a/ivy/functional/frontends/torch/nn/functional/layer_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/layer_functions.py @@ -96,6 +96,7 @@ def _generic_lstm( (weight_ih, weight_hh), (bias_i, bias_h), bidirectional, + batch_first=batch_first, batch_sizes=batch_sizes, ) h_outs.append(h_out) @@ -114,59 +115,32 @@ def _generic_lstm( def _lstm_cell( - x, init_h, init_c, kernel, recurrent_kernel, bias, recurrent_bias, batch_sizes=None + x, + init_h, + init_c, + kernel, + recurrent_kernel, + bias, + recurrent_bias, + batch_first, + batch_sizes=None, ): - x_shape = x.shape - batch_shape = x_shape[1:-1] - timesteps = x_shape[0] - input_channels = x_shape[-1] - - Wi = kernel - Wi_x = ivy.reshape( - ivy.matmul(ivy.reshape(x, (-1, input_channels)), Wi) - + (bias if bias is not None else 0), - [timesteps, *batch_shape, -1], + init_h = ivy.squeeze(init_h, axis=0) + init_c = ivy.squeeze(init_c, axis=0) + out, states = ivy.lstm_update( + x, + init_h, + init_c, + kernel, + recurrent_kernel, + bias=bias, + recurrent_bias=recurrent_bias, + time_major=not batch_first, ) - Wii_x, Wif_x, Wig_x, Wio_x = ivy.split(Wi_x, num_or_size_splits=4, axis=-1) - Wh = recurrent_kernel - ht = init_h - ct = init_c - ht_list = [] - ct_list = [] - - for Wii_xt, Wif_xt, Wig_xt, Wio_xt in zip( - ivy.unstack(Wii_x, axis=0), - ivy.unstack(Wif_x, axis=0), - ivy.unstack(Wig_x, axis=0), - ivy.unstack(Wio_x, axis=0), - ): - htm1 = ht - ctm1 = ct - Wh_htm1 = ivy.matmul(htm1, Wh) + ( - recurrent_bias if recurrent_bias is not None else 0 - ) - Whi_htm1, Whf_htm1, Whg_htm1, Who_htm1 = ivy.split( - Wh_htm1, num_or_size_splits=4, axis=-1 - ) - it = ivy.sigmoid(Wii_xt + Whi_htm1) - ft = ivy.sigmoid(Wif_xt + Whf_htm1) - gt = ivy.tanh(Wig_xt + Whg_htm1) - ot = ivy.sigmoid(Wio_xt + Who_htm1) - ct = ft * ctm1 + it * gt - ht = ot * ivy.tanh(ct) - ct_list.append(ct) - ht_list.append(ht) - - if batch_sizes is None: - c = ct_list[-1] - h = ht_list[-1] - output = ivy.concat(ht_list, axis=0) - else: - ct_list = ivy.concat(ct_list, axis=0) - output = ht_list = ivy.concat(ht_list, axis=0) - c = _extract_states(ct_list, batch_sizes) - h = _extract_states(ht_list, batch_sizes) - return output, (h, c) + h, c = states + h = ivy.expand_dims(h) if len(h.shape) == 2 else h + c = ivy.expand_dims(c) if len(c.shape) == 2 else c + return out, (h, c) def _lstm_full( @@ -193,10 +167,17 @@ def _lstm_full( ) -def _lstm_layer(x, hidden, weights, biases, bidirectional, batch_sizes=None): +def _lstm_layer( + x, hidden, weights, biases, bidirectional, batch_first, batch_sizes=None +): if not bidirectional: result, (h, c) = _lstm_cell( - x, *hidden, *weights, *biases, batch_sizes=batch_sizes + x, + *hidden, + *weights, + *biases, + batch_first=batch_first, + batch_sizes=batch_sizes, ) else: result_fw, (h_fw, c_fw) = _lstm_cell( @@ -207,6 +188,7 @@ def _lstm_layer(x, hidden, weights, biases, bidirectional, batch_sizes=None): weights[1][0], biases[0][0], biases[1][0], + batch_first=batch_first, batch_sizes=batch_sizes, ) x_reversed = ivy.flip(x, axis=0) @@ -218,6 +200,7 @@ def _lstm_layer(x, hidden, weights, biases, bidirectional, batch_sizes=None): weights[1][1], biases[0][1], biases[1][1], + batch_first=batch_first, batch_sizes=batch_sizes, ) result_bw = ivy.flip(result_bw, axis=0) diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index c525aaee04f24..741aba99eaf5d 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -2286,14 +2286,16 @@ def lstm_update( *, bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, recurrent_bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, -) -> Tuple[ivy.Array, ivy.Array]: + time_major: bool = False, +) -> Tuple[ivy.Array, Tuple[ivy.Array, ivy.Array]]: """Perform long-short term memory update by unrolling time dimension of input array. Parameters ---------- x - input tensor of LSTM layer *[batch_shape, t, in]*. + input tensor of LSTM layer *[batch_shape, t, in]* if time_major=False, + else *[t, batch_shape, in]*. init_h initial state tensor for the cell output *[batch_shape, out]*. init_c @@ -2306,13 +2308,19 @@ def lstm_update( bias for cell kernel *[4 x out]*. (Default value = None) recurrent_bias bias for cell recurrent kernel *[4 x out]*. (Default value = None) + time_major + whether or not the input tensor `x` has the time dimension before batch dim. Returns ------- ret - hidden state for all timesteps *[batch_shape,t,out]* and cell state for last - timestep *[batch_shape,out]* + hidden state for all timesteps of shape *[batch_shape,t,out]* if time_major + is False, else *[t, batch_shape, out]*, and a tuple containing the final cell + states, both of shape *[batch_shape,out]*. """ + # ToDo: test_lstm_update needs to be fixed + if time_major: + x = ivy.swapaxes(x, 0, 1) # get shapes x_shape = list(x.shape) batch_shape = x_shape[:-2] @@ -2364,7 +2372,11 @@ def lstm_update( hts_list.append(ivy.expand_dims(ht, axis=-2)) - return ivy.concat(hts_list, axis=-2), ct + ret = ivy.concat(hts_list, axis=-2) + if time_major: + ret = ivy.swapaxes(ret, 0, 1) + + return ret, (ht, ct) # Helpers # From 542ec99588202b9d8fdb40a43c43f891db83a114 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 19 Dec 2023 13:14:31 +0530 Subject: [PATCH 400/978] chore: removed the _valid_shapes assertion check from _conv to avoid the code from breaking on transpilation if we optimize for the data_format (#27772) --- .../nn/functional/convolution_functions.py | 60 ------------------- 1 file changed, 60 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index f0adcfb744056..e2915292071d5 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -13,7 +13,6 @@ def _conv(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): dims = len(input.shape) - 2 - _valid_shapes(input, weight, bias, stride, padding, groups) if isinstance(padding, str): padding = padding.upper() @@ -104,65 +103,6 @@ def _get_transpose_pad(padding, output_padding, dims): return asymmetric_padding -def _valid_shapes(input, weight, bias, stride, padding, groups, transpose=False): - in_channels = input.shape[1] - out_channels = weight.shape[0] if not transpose else weight.shape[1] * groups - - ivy.utils.assertions.check_equal( - in_channels % groups, - 0, - message="in_channels must be divisible by groups", - as_array=False, - ) - ivy.utils.assertions.check_equal( - out_channels % groups, - 0, - message="out_channels must be divisible by groups", - as_array=False, - ) - - if bias is not None: - ivy.utils.assertions.check_equal( - bias.shape[0], - out_channels, - message="bias must be same shape as out_channels", - as_array=False, - ) - - if padding == "same": - if isinstance(stride, int): - ivy.utils.assertions.check_equal( - stride, - 1, - message="padding cannot be 'same' for stride > 1", - as_array=False, - ) - else: - for i in stride: - ivy.utils.assertions.check_equal( - i, - 1, - message="padding cannot be 'same' for stride > 1", - as_array=False, - ) - - if not transpose: - in_channels_by_groups = weight.shape[1] - ivy.utils.assertions.check_equal( - in_channels, - in_channels_by_groups * groups, - message="in_channels must be consistent between input and weight", - as_array=False, - ) - else: - ivy.utils.assertions.check_equal( - in_channels, - weight.shape[0], - message="in_channels must be consistent between input and weight", - as_array=False, - ) - - # --- Main --- # # ------------ # From 23bee99357ec457dbba1c3da8b21c33478b402e9 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 19 Dec 2023 13:44:24 +0530 Subject: [PATCH 401/978] chore(ci): added a command to delete the pulled image from the runner before ending the tests to avoid stale images being retained --- scripts/run_tests/run_tests.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 88c9558b5bc0f..7c411eac86d74 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -237,6 +237,10 @@ # delete the container os.system("docker rm -f test-container") + + # delete pulled image before terminating + if device == "gpu": + os.system("docker rmi $(docker images | grep 'unifyai/ivy:latest-gpu')") # if any tests fail, the workflow fails if failed: From a496db7d27f592d9ffa9aecbc4e5d4eb98e0424b Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 19 Dec 2023 08:15:50 +0000 Subject: [PATCH 402/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scripts/run_tests/run_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 7c411eac86d74..db92381504c32 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -237,7 +237,7 @@ # delete the container os.system("docker rm -f test-container") - + # delete pulled image before terminating if device == "gpu": os.system("docker rmi $(docker images | grep 'unifyai/ivy:latest-gpu')") From 664b961d8a0dd9079a3e0089e30b058371b54747 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 19 Dec 2023 14:44:28 +0530 Subject: [PATCH 403/978] feat: Updated `torch` version mapping from `2.1.1` to `2.1.2` (#27760) --- ivy/functional/backends/torch/__init__.py | 24 +- ivy/functional/backends/torch/activations.py | 20 +- ivy/functional/backends/torch/creation.py | 8 +- ivy/functional/backends/torch/data_type.py | 2 +- ivy/functional/backends/torch/elementwise.py | 100 ++--- .../torch/experimental/activations.py | 26 +- .../backends/torch/experimental/creation.py | 6 +- .../torch/experimental/elementwise.py | 26 +- .../backends/torch/experimental/layers.py | 38 +- .../torch/experimental/linear_algebra.py | 4 +- .../backends/torch/experimental/losses.py | 10 +- .../torch/experimental/manipulation.py | 10 +- .../backends/torch/experimental/norms.py | 12 +- .../backends/torch/experimental/random.py | 6 +- .../backends/torch/experimental/sorting.py | 4 +- .../torch/experimental/statistical.py | 14 +- ivy/functional/backends/torch/general.py | 12 +- ivy/functional/backends/torch/layers.py | 30 +- .../backends/torch/linear_algebra.py | 52 +-- ivy/functional/backends/torch/manipulation.py | 4 +- ivy/functional/backends/torch/norms.py | 2 +- ivy/functional/backends/torch/random.py | 2 +- ivy/functional/backends/torch/searching.py | 4 +- ivy/functional/backends/torch/set.py | 8 +- ivy/functional/backends/torch/sorting.py | 8 +- ivy/functional/backends/torch/statistical.py | 14 +- ivy/functional/frontends/__init__.py | 2 +- .../frontends/torch/blas_and_lapack_ops.py | 2 +- .../frontends/torch/comparison_ops.py | 18 +- .../frontends/torch/creation_ops.py | 12 +- .../indexing_slicing_joining_mutating_ops.py | 4 +- ivy/functional/frontends/torch/linalg.py | 60 +-- .../frontends/torch/miscellaneous_ops.py | 34 +- .../nn/functional/convolution_functions.py | 12 +- .../torch/nn/functional/distance_functions.py | 6 +- .../torch/nn/functional/dropout_functions.py | 10 +- .../torch/nn/functional/layer_functions.py | 4 +- .../torch/nn/functional/linear_functions.py | 2 +- .../torch/nn/functional/loss_functions.py | 32 +- .../non_linear_activation_functions.py | 46 +- .../frontends/torch/nn/functional/norms.py | 8 +- .../torch/nn/functional/pooling_functions.py | 22 +- .../torch/nn/functional/sparse_functions.py | 2 +- .../torch/nn/functional/vision_functions.py | 12 +- .../frontends/torch/pointwise_ops.py | 106 ++--- .../frontends/torch/random_sampling.py | 8 +- .../frontends/torch/reduction_ops.py | 26 +- ivy/functional/frontends/torch/tensor.py | 408 +++++++++--------- .../frontends/torch/tensor_functions.py | 6 +- ivy/functional/frontends/torch/utilities.py | 2 +- ivy/functional/frontends/torchvision/ops.py | 4 +- 51 files changed, 647 insertions(+), 647 deletions(-) diff --git a/ivy/functional/backends/torch/__init__.py b/ivy/functional/backends/torch/__init__.py index 15cf5702edaac..922b6ff3506bb 100644 --- a/ivy/functional/backends/torch/__init__.py +++ b/ivy/functional/backends/torch/__init__.py @@ -129,7 +129,7 @@ def rep_method(*args, **kwargs): # update these to add new dtypes valid_dtypes = { - "2.1.1 and below": ( + "2.1.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -147,7 +147,7 @@ def rep_method(*args, **kwargs): valid_numeric_dtypes = { - "2.1.1 and below": ( + "2.1.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -163,13 +163,13 @@ def rep_method(*args, **kwargs): } valid_int_dtypes = { - "2.1.1 and below": (ivy.int8, ivy.int16, ivy.int32, ivy.int64, ivy.uint8) + "2.1.2 and below": (ivy.int8, ivy.int16, ivy.int32, ivy.int64, ivy.uint8) } valid_float_dtypes = { - "2.1.1 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) + "2.1.2 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) } -valid_uint_dtypes = {"2.1.1 and below": (ivy.uint8,)} -valid_complex_dtypes = {"2.1.1 and below": (ivy.complex64, ivy.complex128)} +valid_uint_dtypes = {"2.1.2 and below": (ivy.uint8,)} +valid_complex_dtypes = {"2.1.2 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -182,17 +182,17 @@ def rep_method(*args, **kwargs): # invalid data types # update these to add new dtypes invalid_dtypes = { - "2.1.1 and below": ( + "2.1.2 and below": ( ivy.uint16, ivy.uint32, ivy.uint64, ) } -invalid_numeric_dtypes = {"2.1.1 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_int_dtypes = {"2.1.1 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_float_dtypes = {"2.1.1 and below": ()} -invalid_uint_dtypes = {"2.1.1 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_complex_dtypes = {"2.1.1 and below": ()} +invalid_numeric_dtypes = {"2.1.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_int_dtypes = {"2.1.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_float_dtypes = {"2.1.2 and below": ()} +invalid_uint_dtypes = {"2.1.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_complex_dtypes = {"2.1.2 and below": ()} invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) # leave these untouched diff --git a/ivy/functional/backends/torch/activations.py b/ivy/functional/backends/torch/activations.py index 0f67c20f47d5d..e341d123ec230 100644 --- a/ivy/functional/backends/torch/activations.py +++ b/ivy/functional/backends/torch/activations.py @@ -18,14 +18,14 @@ import ivy.functional.backends.torch as torch_backend -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def relu( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: return torch.relu(x) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def leaky_relu( x: torch.Tensor, /, @@ -37,7 +37,7 @@ def leaky_relu( return torch.nn.functional.leaky_relu(x, alpha) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def gelu( x: torch.Tensor, /, @@ -51,7 +51,7 @@ def gelu( return torch.nn.functional.gelu(x) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def sigmoid( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -63,7 +63,7 @@ def sigmoid( sigmoid.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def softmax( x: torch.Tensor, /, @@ -80,7 +80,7 @@ def softmax( return torch.nn.functional.softmax(x, axis) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def softplus( x: torch.Tensor, /, @@ -97,7 +97,7 @@ def softplus( # Softsign -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def softsign(x: torch.Tensor, /, out: Optional[torch.Tensor] = None) -> torch.Tensor: # return x / (1 + torch.abs(x)) return torch.nn.functional.softsign(x) @@ -107,7 +107,7 @@ def softsign(x: torch.Tensor, /, out: Optional[torch.Tensor] = None) -> torch.Te @with_unsupported_dtypes( - {"2.1.1 and below": ("float16",)}, + {"2.1.2 and below": ("float16",)}, backend_version, ) def log_softmax( @@ -128,7 +128,7 @@ def log_softmax( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16",)}, + {"2.1.2 and below": ("float16",)}, backend_version, ) def mish( @@ -146,7 +146,7 @@ def mish( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "complex", "float16", ) diff --git a/ivy/functional/backends/torch/creation.py b/ivy/functional/backends/torch/creation.py index e675c1caa6fd0..4674ddbd17399 100644 --- a/ivy/functional/backends/torch/creation.py +++ b/ivy/functional/backends/torch/creation.py @@ -47,7 +47,7 @@ def _differentiable_linspace(start, stop, num, *, device, dtype=None): return res -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def arange( start: float, /, @@ -95,7 +95,7 @@ def _stack_tensors(x, dtype): return x -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) @_asarray_to_native_arrays_and_back @_asarray_infer_device @_asarray_handle_nestable @@ -166,7 +166,7 @@ def empty_like( return torch.empty_like(x, dtype=dtype, device=device) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) def eye( n_rows: int, n_cols: Optional[int] = None, @@ -276,7 +276,7 @@ def _slice_at_axis(sl, axis): @with_unsupported_device_and_dtypes( - {"2.1.1 and below": {"cpu": ("float16",)}}, backend_version + {"2.1.2 and below": {"cpu": ("float16",)}}, backend_version ) def linspace( start: Union[torch.Tensor, float], diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index d5e0fd7cd2e9f..05faab29b6c2e 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -180,7 +180,7 @@ def as_ivy_dtype( ) -@with_unsupported_dtypes({"2.1.1 and below": ("uint16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, backend_version) def as_native_dtype( dtype_in: Union[torch.dtype, str, bool, int, float, np.dtype] ) -> torch.dtype: diff --git a/ivy/functional/backends/torch/elementwise.py b/ivy/functional/backends/torch/elementwise.py index 6fc4dbee20bd2..fd95b2089f6a3 100644 --- a/ivy/functional/backends/torch/elementwise.py +++ b/ivy/functional/backends/torch/elementwise.py @@ -38,7 +38,7 @@ def add( add.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_xor( x1: Union[int, bool, torch.Tensor], @@ -54,7 +54,7 @@ def bitwise_xor( bitwise_xor.support_native_out = True -@with_supported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_supported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def imag( val: torch.Tensor, /, @@ -67,7 +67,7 @@ def imag( imag.support_native_out = False -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def expm1(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -77,7 +77,7 @@ def expm1(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te expm1.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_invert( x: Union[int, bool, torch.Tensor], /, *, out: Optional[torch.Tensor] = None @@ -129,7 +129,7 @@ def equal( equal.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def less_equal( x1: Union[float, torch.Tensor], @@ -145,7 +145,7 @@ def less_equal( less_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_and( x1: Union[int, bool, torch.Tensor], @@ -161,7 +161,7 @@ def bitwise_and( bitwise_and.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def ceil(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -175,7 +175,7 @@ def ceil(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten ceil.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def floor(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -189,7 +189,7 @@ def floor(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te floor.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def fmin( x1: torch.Tensor, x2: torch.Tensor, @@ -203,7 +203,7 @@ def fmin( fmin.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def asin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -213,7 +213,7 @@ def asin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten asin.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def asinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -223,7 +223,7 @@ def asinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te asinh.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sign( x: torch.Tensor, @@ -245,7 +245,7 @@ def sign( sign.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sqrt(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -255,7 +255,7 @@ def sqrt(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten sqrt.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def cosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -265,7 +265,7 @@ def cosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten cosh.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log10(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -275,14 +275,14 @@ def log10(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te log10.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log2(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) return torch.log2(x, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def log1p(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -298,7 +298,7 @@ def isnan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te return torch.isnan(x) -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def less( x1: Union[float, torch.Tensor], @@ -329,7 +329,7 @@ def multiply( multiply.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def cos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -370,7 +370,7 @@ def divide( divide.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def greater( x1: Union[float, torch.Tensor], @@ -386,7 +386,7 @@ def greater( greater.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def greater_equal( x1: Union[float, torch.Tensor], @@ -402,7 +402,7 @@ def greater_equal( greater_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def acos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -412,7 +412,7 @@ def acos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten acos.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float",)}, backend_version) @handle_numpy_arrays_in_specific_backend def lcm( x1: torch.Tensor, @@ -458,7 +458,7 @@ def logical_or( logical_or.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def acosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -468,7 +468,7 @@ def acosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te acosh.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -504,7 +504,7 @@ def not_equal( not_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def tanh( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None @@ -516,7 +516,7 @@ def tanh( tanh.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def floor_divide( x1: Union[float, torch.Tensor], @@ -537,7 +537,7 @@ def floor_divide( floor_divide.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_or( x1: Union[int, bool, torch.Tensor], @@ -553,7 +553,7 @@ def bitwise_or( bitwise_or.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -618,7 +618,7 @@ def pow( pow.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def round( x: torch.Tensor, /, *, decimals: int = 0, out: Optional[torch.Tensor] = None @@ -659,7 +659,7 @@ def trapz( trapz.support_native_out = False -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def trunc(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -692,7 +692,7 @@ def abs( abs.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def logaddexp( x1: torch.Tensor, x2: torch.Tensor, /, *, out: Optional[torch.Tensor] = None @@ -704,7 +704,7 @@ def logaddexp( logaddexp.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def logaddexp2( x1: Union[torch.Tensor, float, list, tuple], @@ -723,7 +723,7 @@ def logaddexp2( logaddexp2.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def tan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -733,7 +733,7 @@ def tan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens tan.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def atan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -744,7 +744,7 @@ def atan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version ) # TODO Fixed in PyTorch 1.12.1 (this note excludes complex) @handle_numpy_arrays_in_specific_backend def atan2( @@ -757,7 +757,7 @@ def atan2( atan2.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -767,7 +767,7 @@ def log(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens log.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def exp(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -808,7 +808,7 @@ def subtract( subtract.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def remainder( x1: Union[float, torch.Tensor], @@ -836,7 +836,7 @@ def remainder( remainder.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def atanh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -846,7 +846,7 @@ def atanh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te atanh.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_right_shift( x1: Union[int, bool, torch.Tensor], @@ -863,7 +863,7 @@ def bitwise_right_shift( bitwise_right_shift.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_left_shift( x1: Union[int, bool, torch.Tensor], @@ -883,7 +883,7 @@ def bitwise_left_shift( # ------# -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def erf(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -893,7 +893,7 @@ def erf(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens erf.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def minimum( x1: Union[float, torch.Tensor], @@ -912,7 +912,7 @@ def minimum( minimum.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def maximum( x1: Union[float, torch.Tensor], @@ -931,7 +931,7 @@ def maximum( maximum.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def reciprocal( x: Union[float, torch.Tensor], /, *, out: Optional[torch.Tensor] = None @@ -944,7 +944,7 @@ def reciprocal( @with_unsupported_dtypes( - {"2.1.1 and below": ("complex64", "complex128")}, backend_version + {"2.1.2 and below": ("complex64", "complex128")}, backend_version ) @handle_numpy_arrays_in_specific_backend def deg2rad(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: @@ -955,7 +955,7 @@ def deg2rad(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch. @with_unsupported_dtypes( - {"2.1.1 and below": ("complex64", "complex128")}, backend_version + {"2.1.2 and below": ("complex64", "complex128")}, backend_version ) @handle_numpy_arrays_in_specific_backend def rad2deg(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: @@ -965,7 +965,7 @@ def rad2deg(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch. rad2deg.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def trunc_divide( x1: Union[float, torch.Tensor], @@ -989,7 +989,7 @@ def isreal(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.T @with_unsupported_dtypes( - {"2.1.1 and below": ("bfloat16", "complex")}, + {"2.1.2 and below": ("bfloat16", "complex")}, backend_version, ) @handle_numpy_arrays_in_specific_backend diff --git a/ivy/functional/backends/torch/experimental/activations.py b/ivy/functional/backends/torch/experimental/activations.py index e4717f870ad2d..230e429e4bc98 100644 --- a/ivy/functional/backends/torch/experimental/activations.py +++ b/ivy/functional/backends/torch/experimental/activations.py @@ -10,7 +10,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def logit( x: torch.Tensor, /, @@ -22,7 +22,7 @@ def logit( return torch.logit(x, eps=eps, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("complex", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex", "float16")}, backend_version) def thresholded_relu( x: torch.Tensor, /, @@ -33,14 +33,14 @@ def thresholded_relu( return torch.threshold(x, threshold=threshold, value=0) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def relu6( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: return torch.nn.functional.relu6(x) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def logsigmoid( input: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -49,7 +49,7 @@ def logsigmoid( return torch.nn.functional.logsigmoid(input) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def selu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: ret = torch.nn.functional.selu(x) if ivy.exists(out): @@ -57,12 +57,12 @@ def selu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def silu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.nn.functional.silu(x) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def elu( x: torch.Tensor, /, *, alpha: float = 1.0, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -74,7 +74,7 @@ def elu( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "complex", "float16", "bfloat16", @@ -93,7 +93,7 @@ def celu( return torch.celu(x, alpha=alpha) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def hardtanh( x: torch.Tensor, /, @@ -108,7 +108,7 @@ def hardtanh( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def tanhshrink( x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -118,7 +118,7 @@ def tanhshrink( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def threshold( x: torch.Tensor, /, @@ -133,7 +133,7 @@ def threshold( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def softshrink( x: torch.Tensor, /, *, lambd: float = 0.5, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -154,7 +154,7 @@ def scaled_tanh( return alpha * torch.nn.functional.tanh(beta * x) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def hardshrink( x: torch.Tensor, /, *, lambd: float = 0.5, out: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/ivy/functional/backends/torch/experimental/creation.py b/ivy/functional/backends/torch/experimental/creation.py index 73252430cd783..2c332f82d06ea 100644 --- a/ivy/functional/backends/torch/experimental/creation.py +++ b/ivy/functional/backends/torch/experimental/creation.py @@ -20,7 +20,7 @@ @with_unsupported_device_and_dtypes( - {"2.1.1 and below": {"cpu": ("float16",)}}, + {"2.1.2 and below": {"cpu": ("float16",)}}, backend_version, ) def kaiser_window( @@ -87,7 +87,7 @@ def vorbis_window( vorbis_window.support_native_out = False -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def hann_window( size: int, /, @@ -152,7 +152,7 @@ def unsorted_segment_min( return res -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def blackman_window( size: int, /, diff --git a/ivy/functional/backends/torch/experimental/elementwise.py b/ivy/functional/backends/torch/experimental/elementwise.py index c7b1188fa34e5..faa58bff5650f 100644 --- a/ivy/functional/backends/torch/experimental/elementwise.py +++ b/ivy/functional/backends/torch/experimental/elementwise.py @@ -16,7 +16,7 @@ @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "complex64", "complex128", ) @@ -40,7 +40,7 @@ def amax( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "complex64", "complex128", ) @@ -62,12 +62,12 @@ def amin( amin.support_native_out = True -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, backend_version) def lgamma(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.lgamma(x, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def fmax( x1: torch.Tensor, x2: torch.Tensor, @@ -82,7 +82,7 @@ def fmax( fmax.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def sinc(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) return torch.sinc(x, out=out) @@ -158,7 +158,7 @@ def count_nonzero( count_nonzero.support_native_out = False -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def nansum( x: torch.Tensor, /, @@ -227,7 +227,7 @@ def signbit( signbit.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def hypot( x1: torch.Tensor, x2: torch.Tensor, @@ -252,7 +252,7 @@ def allclose( return torch.tensor(ret) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def fix( x: torch.Tensor, /, @@ -265,7 +265,7 @@ def fix( fix.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def nextafter( x1: torch.Tensor, x2: torch.Tensor, @@ -319,7 +319,7 @@ def gradient( @with_supported_dtypes( - {"2.1.1 and below": ("float16", "float32", "float64")}, + {"2.1.2 and below": ("float16", "float32", "float64")}, backend_version, ) def xlogy( @@ -382,7 +382,7 @@ def _are_suitable_types_for_torch_lerp(input, end, weight): return True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def lerp( input: torch.Tensor, end: torch.Tensor, @@ -420,7 +420,7 @@ def modf( return torch.resolve_modf(input=modf_x) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def digamma( x: torch.Tensor, /, @@ -433,7 +433,7 @@ def digamma( digamma.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def erfc( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 6439e66caf418..c2a6a3f501794 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -29,7 +29,7 @@ def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_ return x, kernel, strides, depth_pooling -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def max_pool1d( x: torch.Tensor, kernel: Union[int, Tuple[int, ...]], @@ -94,7 +94,7 @@ def max_pool1d( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -170,7 +170,7 @@ def max_pool2d( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -282,7 +282,7 @@ def _get_specific_pad(x_shape, kernel, strides, padding, dims): return padding, pad_specific -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def avg_pool1d( x: torch.Tensor, kernel: Union[int, Tuple[int]], @@ -374,7 +374,7 @@ def _adjust_num_padded_values_to_ceil( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -478,7 +478,7 @@ def avg_pool2d( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -581,7 +581,7 @@ def avg_pool3d( return res -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, backend_version) def dct( x: torch.Tensor, /, @@ -694,7 +694,7 @@ def idct( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -740,7 +740,7 @@ def fft( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", "complex", @@ -774,7 +774,7 @@ def dropout( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16",)}, + {"2.1.2 and below": ("float16",)}, backend_version, ) def dropout1d( @@ -797,7 +797,7 @@ def dropout1d( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16",)}, + {"2.1.2 and below": ("float16",)}, backend_version, ) def dropout2d( @@ -822,7 +822,7 @@ def dropout2d( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -881,7 +881,7 @@ def ifft( return torch.fft.ifft(x, n, dim, norm, out=out).resolve_conj() -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def embedding( weights: torch.Tensor, indices: torch.Tensor, @@ -954,19 +954,19 @@ def interpolate( ) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def adaptive_max_pool2d( input: torch.Tensor, output_size: Union[Sequence[int], int] ) -> torch.Tensor: return torch.nn.functional.adaptive_max_pool2d(input, output_size) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def adaptive_avg_pool1d(input, output_size): return torch.nn.functional.adaptive_avg_pool1d(input, output_size) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def adaptive_avg_pool2d(input, output_size, /, *, data_format: str = "NHWC"): squeeze = False if input.ndim == 3: @@ -982,7 +982,7 @@ def adaptive_avg_pool2d(input, output_size, /, *, data_format: str = "NHWC"): return ret -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def fft2( x: torch.Tensor, *, @@ -1048,7 +1048,7 @@ def rfft( return ret -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def rfftn( x: torch.Tensor, s: Optional[Sequence[int]] = None, @@ -1086,7 +1086,7 @@ def rfftn( # stft @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index 53cb4e04c7063..e73e9f297d7c1 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -12,7 +12,7 @@ from ivy.functional.ivy.experimental.linear_algebra import _check_valid_dimension_size -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def diagflat( x: torch.Tensor, /, @@ -176,7 +176,7 @@ def solve_triangular( solve_triangular.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def multi_dot( x: Sequence[torch.Tensor], /, diff --git a/ivy/functional/backends/torch/experimental/losses.py b/ivy/functional/backends/torch/experimental/losses.py index e5b227a01f55d..fbd5a899d964e 100644 --- a/ivy/functional/backends/torch/experimental/losses.py +++ b/ivy/functional/backends/torch/experimental/losses.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( - {"2.1.1 and below": ("unit8", "int8", "int16", "int32", "int64", "bool")}, + {"2.1.2 and below": ("unit8", "int8", "int16", "int32", "int64", "bool")}, backend_version, ) def l1_loss( @@ -30,7 +30,7 @@ def l1_loss( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "complex", "uint8", "int8", @@ -59,7 +59,7 @@ def smooth_l1_loss( @with_unsupported_dtypes( - {"2.1.1 and below": ("uint8", "int8", "int16", "int32", "int64", "bool")}, + {"2.1.2 and below": ("uint8", "int8", "int16", "int32", "int64", "bool")}, backend_version, ) def huber_loss( @@ -77,7 +77,7 @@ def huber_loss( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "uint8", "int8", @@ -104,7 +104,7 @@ def soft_margin_loss( @with_supported_dtypes( - {"2.1.1 and below": ("float",)}, + {"2.1.2 and below": ("float",)}, backend_version, ) def kl_div( diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index 62162125e9137..14265cebd1eea 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -60,7 +60,7 @@ def heaviside( @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex64", "complex128")}, + {"2.1.2 and below": ("float32", "float64", "complex64", "complex128")}, backend_version, ) def pad( @@ -238,7 +238,7 @@ def fliplr( fliplr.support_native_out = False -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def i0( x: torch.Tensor, /, @@ -331,7 +331,7 @@ def atleast_3d( return transformed -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def take_along_axis( arr: torch.Tensor, indices: torch.Tensor, @@ -409,7 +409,7 @@ def expand( expand.support_native_out = False -@with_unsupported_dtypes({"2.1.1 and below": ("complex", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex", "float16")}, backend_version) def unique_consecutive( x: torch.Tensor, /, @@ -439,7 +439,7 @@ def column_stack( return torch.column_stack(arrays) -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, backend_version) def put_along_axis( arr: torch.Tensor, indices: torch.Tensor, diff --git a/ivy/functional/backends/torch/experimental/norms.py b/ivy/functional/backends/torch/experimental/norms.py index 6861955d2f652..f29b0283833c2 100644 --- a/ivy/functional/backends/torch/experimental/norms.py +++ b/ivy/functional/backends/torch/experimental/norms.py @@ -18,7 +18,7 @@ def l1_normalize( l1_normalize.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def l2_normalize( x: torch.Tensor, /, @@ -32,7 +32,7 @@ def l2_normalize( l2_normalize.support_native_out = True -@with_supported_dtypes({"2.1.1 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.1.2 and below": ("float",)}, backend_version) def local_response_norm( x: torch.Tensor, size, @@ -56,7 +56,7 @@ def local_response_norm( return ret -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def batch_norm( x: torch.Tensor, mean: torch.Tensor, @@ -102,7 +102,7 @@ def batch_norm( ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def instance_norm( x: torch.Tensor, mean: torch.Tensor, @@ -150,7 +150,7 @@ def instance_norm( ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def group_norm( x: torch.Tensor, num_groups: int = 1, @@ -175,7 +175,7 @@ def group_norm( return xnormalized -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def lp_normalize( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/experimental/random.py b/ivy/functional/backends/torch/experimental/random.py index cfc13707667a7..a4d5b116b0782 100644 --- a/ivy/functional/backends/torch/experimental/random.py +++ b/ivy/functional/backends/torch/experimental/random.py @@ -13,7 +13,7 @@ # dirichlet -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def dirichlet( alpha: Union[torch.tensor, float, Sequence[float]], /, @@ -32,7 +32,7 @@ def dirichlet( ) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) def beta( alpha: Union[float, torch.Tensor], beta: Union[float, torch.Tensor], @@ -53,7 +53,7 @@ def beta( return ret -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) def gamma( alpha: Union[float, torch.Tensor], beta: Union[float, torch.Tensor], diff --git a/ivy/functional/backends/torch/experimental/sorting.py b/ivy/functional/backends/torch/experimental/sorting.py index 10b9ce8defd1e..e37526f3fb7d1 100644 --- a/ivy/functional/backends/torch/experimental/sorting.py +++ b/ivy/functional/backends/torch/experimental/sorting.py @@ -33,7 +33,7 @@ def lexsort( return torch.tensor([0]) _, result = torch.sort(keys[0], dim=axis, stable=True) # result = torch.argsort(keys[0], dim=axis, stable=True) - # only valid for torch > 2.1.1 + # only valid for torch > 2.1.2 if shape[0] == 1: return result for i in range(1, shape[0]): @@ -41,7 +41,7 @@ def lexsort( ind = key[result] _, temp = torch.sort(ind, dim=axis, stable=True) # temp = torch.argsort(ind, dim=axis, stable=True) - # only valid for torch > 2.1.1 + # only valid for torch > 2.1.2 result = result[temp] return result diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index 247308cf01eba..efad6240c1400 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -12,7 +12,7 @@ @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "uint8", "int8", "int16", @@ -139,7 +139,7 @@ def histogram( histogram.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bool")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bool")}, backend_version) def median( input: torch.Tensor, /, @@ -364,7 +364,7 @@ def _compute_quantile_wrapper( ) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def quantile( a: torch.Tensor, q: Union[torch.Tensor, float], @@ -445,7 +445,7 @@ def _nanmedian(input, axis, keepdims): return ret -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def nanmedian( input: torch.Tensor, /, @@ -533,7 +533,7 @@ def igamma( igamma.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def cov( x1: torch.Tensor, x2: torch.Tensor = None, @@ -590,7 +590,7 @@ def cov( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "complex")}, + {"2.1.2 and below": ("float16", "complex")}, backend_version, ) def cummax( @@ -627,7 +627,7 @@ def cummax( @with_unsupported_dtypes( { - "2.1.1 and below": ("uint8", "float16", "bfloat16"), + "2.1.2 and below": ("uint8", "float16", "bfloat16"), "1.12.1 and above": ("uint8", "float16"), }, backend_version, diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 08c8c6edffbbc..2fb22fc355458 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -54,7 +54,7 @@ def is_native_array(x, /, *, exclusive=False): return False -@with_unsupported_dtypes({"2.1.1 and below": ("complex", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex", "bfloat16")}, backend_version) def array_equal(x0: torch.Tensor, x1: torch.Tensor, /) -> bool: x0, x1 = ivy.promote_types_of_inputs(x0, x1) return torch.equal(x0, x1) @@ -354,7 +354,7 @@ def multiprocessing(context: Optional[str] = None): @with_unsupported_dtypes( { - "2.1.1 and below": ("bfloat16",), + "2.1.2 and below": ("bfloat16",), }, backend_version, ) @@ -406,7 +406,7 @@ def scatter_flat( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -513,7 +513,7 @@ def shape( return ivy.Shape(x.shape) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) def vmap_v_1p13p1_and_below( func: Callable, in_axes: Union[int, Sequence[int], Sequence[None]] = 0, @@ -531,7 +531,7 @@ def new_fun(*args): return _vmap -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) def vmap_v_2p0p0_and_above( func: Callable, in_axes: Union[int, Sequence[int], Sequence[None]] = 0, @@ -550,7 +550,7 @@ def new_fun(*args): @with_unsupported_dtypes( - {"2.1.1 and below": ("bfloat16", "float16", "complex", "bool")}, backend_version + {"2.1.2 and below": ("bfloat16", "float16", "complex", "bool")}, backend_version ) def isin( elements: torch.tensor, diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index b8490599076be..2a7640b33db3f 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -14,7 +14,7 @@ @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex")}, + {"2.1.2 and below": ("float32", "float64", "complex")}, backend_version, ) def multi_head_attention( @@ -117,7 +117,7 @@ def multi_head_attention( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def linear( @@ -254,7 +254,7 @@ def _tranpose_padding( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -287,7 +287,7 @@ def conv1d( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv1d_v_1p9p0_and_above( @@ -325,7 +325,7 @@ def conv1d_v_1p9p0_and_above( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", "complex", @@ -379,7 +379,7 @@ def conv1d_transpose( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -412,7 +412,7 @@ def conv2d( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv2d_v_1p9p0_and_above( @@ -450,7 +450,7 @@ def conv2d_v_1p9p0_and_above( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", "complex", @@ -507,7 +507,7 @@ def conv2d_transpose( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", "complex", @@ -548,7 +548,7 @@ def depthwise_conv2d( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version ) # noinspection PyUnresolvedReferences def conv3d( @@ -580,7 +580,7 @@ def conv3d( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version ) def conv3d_v_1p9p0_and_above( x: torch.Tensor, @@ -616,7 +616,7 @@ def conv3d_v_1p9p0_and_above( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -669,7 +669,7 @@ def conv3d_transpose( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_dilated( @@ -718,7 +718,7 @@ def conv_general_dilated( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_dilated_v_1p9p0_and_above( @@ -772,7 +772,7 @@ def conv_general_dilated_v_1p9p0_and_above( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_transpose( diff --git a/ivy/functional/backends/torch/linear_algebra.py b/ivy/functional/backends/torch/linear_algebra.py index 763b1f07a28dd..59302f23b3468 100644 --- a/ivy/functional/backends/torch/linear_algebra.py +++ b/ivy/functional/backends/torch/linear_algebra.py @@ -18,7 +18,7 @@ @with_unsupported_dtypes( - {"2.1.1 and below": ("bfloat16", "float16", "complex")}, + {"2.1.2 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def cholesky( @@ -42,7 +42,7 @@ def cholesky( cholesky.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) def cross( x1: torch.Tensor, x2: torch.Tensor, @@ -70,7 +70,7 @@ def cross( cross.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def det(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.linalg.det(x, out=out) @@ -90,7 +90,7 @@ def diagonal( return torch.diagonal(x, offset=offset, dim1=axis1, dim2=axis2) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def eigh( x: torch.Tensor, /, *, UPLO: str = "L", out: Optional[torch.Tensor] = None ) -> Tuple[torch.Tensor]: @@ -104,7 +104,7 @@ def eigh( eigh.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def eigvalsh( x: torch.Tensor, /, *, UPLO: str = "L", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -114,7 +114,7 @@ def eigvalsh( eigvalsh.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) def inner( x1: torch.Tensor, x2: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -134,7 +134,7 @@ def inner( inner.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def inv( x: torch.Tensor, /, @@ -160,7 +160,7 @@ def inv( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "bool")}, backend_version + {"2.1.2 and below": ("float16", "bfloat16", "bool")}, backend_version ) def matmul( x1: torch.Tensor, @@ -193,7 +193,7 @@ def matmul( matmul.support_native_out = True -@with_supported_dtypes({"2.1.1 and below": ("float", "complex")}, backend_version) +@with_supported_dtypes({"2.1.2 and below": ("float", "complex")}, backend_version) def matrix_norm( x: torch.Tensor, /, @@ -209,7 +209,7 @@ def matrix_norm( matrix_norm.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def eig( x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> Tuple[torch.Tensor]: @@ -223,7 +223,7 @@ def eig( eig.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def matrix_power( x: torch.Tensor, n: int, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -233,7 +233,7 @@ def matrix_power( matrix_power.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def matrix_rank( x: torch.Tensor, /, @@ -281,7 +281,7 @@ def matrix_transpose( return torch.swapaxes(x, -1, -2) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def outer( x1: torch.Tensor, x2: torch.Tensor, @@ -296,7 +296,7 @@ def outer( outer.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def pinv( x: torch.Tensor, /, @@ -312,7 +312,7 @@ def pinv( pinv.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def tensorsolve( x1: torch.Tensor, x2: torch.Tensor, @@ -324,7 +324,7 @@ def tensorsolve( return torch.linalg.tensorsolve(x1, x2, dims=axes) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def qr( x: torch.Tensor, /, @@ -346,7 +346,7 @@ def qr( return ret -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def slogdet( x: torch.Tensor, /, @@ -361,7 +361,7 @@ def slogdet( slogdet.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def solve( x1: torch.Tensor, x2: torch.Tensor, @@ -397,7 +397,7 @@ def solve( return ret -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def svd( x: torch.Tensor, /, *, full_matrices: bool = True, compute_uv: bool = True ) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]: @@ -414,7 +414,7 @@ def svd( return results(D) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def svdvals( x: torch.Tensor, /, @@ -430,7 +430,7 @@ def svdvals( # ToDo: re-add int32 support once # (https://github.com/pytorch/pytorch/issues/84530) is fixed -@with_supported_dtypes({"2.1.1 and below": ("float32",)}, backend_version) +@with_supported_dtypes({"2.1.2 and below": ("float32",)}, backend_version) def tensordot( x1: torch.Tensor, x2: torch.Tensor, @@ -449,7 +449,7 @@ def tensordot( return ret -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def trace( x: torch.Tensor, /, @@ -489,7 +489,7 @@ def vecdot( vecdot.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("integer",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("integer",)}, backend_version) def vector_norm( x: torch.Tensor, /, @@ -515,7 +515,7 @@ def vector_norm( # ----- # -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def diag( x: torch.Tensor, /, @@ -526,7 +526,7 @@ def diag( return torch.diag(x, diagonal=k) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def vander( x: torch.tensor, /, @@ -552,7 +552,7 @@ def vander( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/torch/manipulation.py b/ivy/functional/backends/torch/manipulation.py index 4cfb62addec6e..86cf88bb8e919 100644 --- a/ivy/functional/backends/torch/manipulation.py +++ b/ivy/functional/backends/torch/manipulation.py @@ -239,7 +239,7 @@ def split( @with_unsupported_dtypes( - {"2.1.1 and below": ("int8", "int16", "uint8")}, backend_version + {"2.1.2 and below": ("int8", "int16", "uint8")}, backend_version ) def repeat( x: torch.Tensor, @@ -308,7 +308,7 @@ def swapaxes( @with_unsupported_dtypes( - {"2.1.1 and below": ("bool", "float16", "complex")}, backend_version + {"2.1.2 and below": ("bool", "float16", "complex")}, backend_version ) def clip( x: torch.Tensor, diff --git a/ivy/functional/backends/torch/norms.py b/ivy/functional/backends/torch/norms.py index 6f24af1ad998f..4d2803259ad58 100644 --- a/ivy/functional/backends/torch/norms.py +++ b/ivy/functional/backends/torch/norms.py @@ -5,7 +5,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def layer_norm( x: torch.Tensor, normalized_idxs: List[int], diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index 95538ea9960ad..efc61ba4c52a1 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -63,7 +63,7 @@ def random_normal( random_normal.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/torch/searching.py b/ivy/functional/backends/torch/searching.py index b3d436fff5618..847d9b6da30d4 100644 --- a/ivy/functional/backends/torch/searching.py +++ b/ivy/functional/backends/torch/searching.py @@ -13,7 +13,7 @@ # ------------------ # -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def argmax( x: torch.Tensor, /, @@ -41,7 +41,7 @@ def argmax( return ret -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def argmin( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/set.py b/ivy/functional/backends/torch/set.py index 080f918d55099..333d90e14c47f 100644 --- a/ivy/functional/backends/torch/set.py +++ b/ivy/functional/backends/torch/set.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( { - "2.1.1 and below": ("complex", "float16"), + "2.1.2 and below": ("complex", "float16"), }, backend_version, ) @@ -84,7 +84,7 @@ def unique_all( @with_unsupported_dtypes( { - "2.1.1 and below": ("float16",), + "2.1.2 and below": ("float16",), }, backend_version, ) @@ -98,7 +98,7 @@ def unique_counts(x: torch.Tensor, /) -> Tuple[torch.Tensor, torch.Tensor]: @with_unsupported_dtypes( { - "2.1.1 and below": ("float16",), + "2.1.2 and below": ("float16",), }, backend_version, ) @@ -124,7 +124,7 @@ def unique_inverse( @with_unsupported_dtypes( { - "2.1.1 and below": ("float16", "complex"), + "2.1.2 and below": ("float16", "complex"), }, backend_version, ) diff --git a/ivy/functional/backends/torch/sorting.py b/ivy/functional/backends/torch/sorting.py index f9c9a829966f0..bbb7475faf966 100644 --- a/ivy/functional/backends/torch/sorting.py +++ b/ivy/functional/backends/torch/sorting.py @@ -8,7 +8,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def argsort( x: torch.Tensor, /, @@ -29,7 +29,7 @@ def argsort( argsort.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def sort( x: torch.Tensor, /, @@ -51,7 +51,7 @@ def sort( # msort -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def msort( a: Union[torch.Tensor, list, tuple], /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -61,7 +61,7 @@ def msort( msort.support_native_out = True -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def searchsorted( x: torch.Tensor, v: torch.Tensor, diff --git a/ivy/functional/backends/torch/statistical.py b/ivy/functional/backends/torch/statistical.py index a7651c255b030..dfb1b501bdd61 100644 --- a/ivy/functional/backends/torch/statistical.py +++ b/ivy/functional/backends/torch/statistical.py @@ -14,7 +14,7 @@ # -------------------# -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) def min( x: torch.Tensor, /, @@ -66,7 +66,7 @@ def max( max.support_native_out = True -@with_supported_dtypes({"2.1.1 and below": ("float", "complex")}, backend_version) +@with_supported_dtypes({"2.1.2 and below": ("float", "complex")}, backend_version) def mean( x: torch.Tensor, /, @@ -101,7 +101,7 @@ def _infer_dtype(dtype: torch.dtype) -> torch.dtype: # the function to break the upcasting rule defined in the Array API Standard @with_unsupported_dtypes( { - "2.1.1 and below": ("uint8", "float16", "bfloat16"), + "2.1.2 and below": ("uint8", "float16", "bfloat16"), }, backend_version, ) @@ -129,7 +129,7 @@ def prod( @with_unsupported_dtypes( - {"2.1.1 and below": ("int8", "int16", "int32", "int64", "float16")}, + {"2.1.2 and below": ("int8", "int16", "int32", "int64", "float16")}, backend_version, ) def std( @@ -166,7 +166,7 @@ def std( # Function does support uint8, but allowing support for unsigned will cause # the function to break the upcasting rule defined in the Array API Standard -@with_unsupported_dtypes({"2.1.1 and below": ("uint8",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("uint8",)}, backend_version) def sum( x: torch.Tensor, /, @@ -228,7 +228,7 @@ def var( # TODO: bfloat16 support is added in PyTorch 1.12.1 @with_unsupported_dtypes( { - "2.1.1 and below": ("uint8", "float16", "bfloat16"), + "2.1.2 and below": ("uint8", "float16", "bfloat16"), }, backend_version, ) @@ -319,7 +319,7 @@ def cumsum( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16",)}, + {"2.1.2 and below": ("float16",)}, backend_version, ) def einsum( diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index a5d07002848f8..83fa1be55a9e1 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -2,7 +2,7 @@ versions = { - "torch": "2.1.1", + "torch": "2.1.2", "tensorflow": "2.15.0", "numpy": "1.25.2", "jax": "0.4.23", diff --git a/ivy/functional/frontends/torch/blas_and_lapack_ops.py b/ivy/functional/frontends/torch/blas_and_lapack_ops.py index 9cc767415b192..116fb8c80934c 100644 --- a/ivy/functional/frontends/torch/blas_and_lapack_ops.py +++ b/ivy/functional/frontends/torch/blas_and_lapack_ops.py @@ -201,7 +201,7 @@ def svd(input, some=True, compute_uv=True, *, out=None): return ret -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def trapezoid(y, x=None, *, dx=None, dim=-1): if x is not None: diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 76d75d1eff808..fc7591d156487 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -98,14 +98,14 @@ def fmin(input, other, *, out=None): ) -@with_unsupported_dtypes({"2.1.1 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def greater(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.greater(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def greater_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -142,7 +142,7 @@ def isfinite(input): return ivy.isfinite(input) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def isin(elements, test_elements, *, assume_unique=False, invert=False): input_elements_copy = ivy.reshape(ivy.to_ivy(elements), (-1,)) @@ -210,14 +210,14 @@ def isposinf(input, *, out=None): return ivy.logical_and(is_inf, pos_sign_bit, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def isreal(input): return ivy.isreal(input) @with_unsupported_dtypes( - {"2.1.1 and below": ("bfloat16", "float16", "bool", "complex")}, "torch" + {"2.1.2 and below": ("bfloat16", "float16", "bool", "complex")}, "torch" ) @to_ivy_arrays_and_back def kthvalue(input, k, dim=-1, keepdim=False, *, out=None): @@ -241,14 +241,14 @@ def kthvalue(input, k, dim=-1, keepdim=False, *, out=None): return ret -@with_unsupported_dtypes({"2.1.1 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def less(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.less(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def less_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -272,7 +272,7 @@ def msort(input, *, out=None): return ivy.sort(input, axis=0, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def not_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -287,7 +287,7 @@ def sort(input, *, dim=-1, descending=False, stable=False, out=None): return namedtuple("sort", ["values", "indices"])(values, indices) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def topk(input, k, dim=None, largest=True, sorted=True, *, out=None): if dim is None: diff --git a/ivy/functional/frontends/torch/creation_ops.py b/ivy/functional/frontends/torch/creation_ops.py index 59db82c4b8e15..4f4d9134a9738 100644 --- a/ivy/functional/frontends/torch/creation_ops.py +++ b/ivy/functional/frontends/torch/creation_ops.py @@ -12,7 +12,7 @@ @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def arange( start=0, end=None, @@ -74,7 +74,7 @@ def asarray( return ivy.asarray(obj, copy=copy, dtype=dtype, device=device) -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def complex( real, @@ -208,7 +208,7 @@ def heaviside(input, values, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def linspace( start, end, @@ -225,7 +225,7 @@ def linspace( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def logspace( start, end, @@ -273,7 +273,7 @@ def ones_like_v_0p4p0_and_above( return ret -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def polar( abs, @@ -285,7 +285,7 @@ def polar( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def range( *args, dtype=None, diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py index 6f5775164c066..792c5796e8b03 100644 --- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py +++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py @@ -74,7 +74,7 @@ def conj(input): # diagonal_scatter @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "float16", ) @@ -215,7 +215,7 @@ def index_copy(input, dim, index, source, *, out=None): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "uint16", "uint32", "uint64", diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index b3a5e36743d34..d34c0c5c09e2b 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -9,7 +9,7 @@ @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def cholesky(input, *, upper=False, out=None): return ivy.cholesky(input, upper=upper, out=out) @@ -31,14 +31,14 @@ def cholesky_ex(input, *, upper=False, check_errors=False, out=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64", "complex")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64", "complex")}, "torch") def cond(input, p=None, *, out=None): return ivy.cond(input, p=p, out=out) @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def cross(input, other, *, dim=None, out=None): return torch_frontend.miscellaneous_ops.cross(input, other, dim=dim, out=out) @@ -46,7 +46,7 @@ def cross(input, other, *, dim=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def det(A, *, out=None): return ivy.det(A, out=out) @@ -63,13 +63,13 @@ def divide(input, other, *, rounding_mode=None, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") def eig(input, *, out=None): return ivy.eig(input, out=out) @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64", "complex128")}, + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64", "complex128")}, "torch", ) def eigh(A, UPLO="L", *, out=None): @@ -78,7 +78,7 @@ def eigh(A, UPLO="L", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def eigvals(input, *, out=None): ret = ivy.eigvals(input) @@ -89,7 +89,7 @@ def eigvals(input, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def eigvalsh(input, UPLO="L", *, out=None): ret = ivy.eigvalsh(input, UPLO=UPLO, out=out) @@ -102,7 +102,7 @@ def eigvalsh(input, UPLO="L", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def inv(A, *, out=None): return ivy.inv(A, out=out) @@ -110,7 +110,7 @@ def inv(A, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def inv_ex(A, *, check_errors=False, out=None): if ivy.any(ivy.det(A) == 0): @@ -129,7 +129,7 @@ def inv_ex(A, *, check_errors=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def lu_factor(A, *, pivot=True, out=None): return ivy.lu_factor(A, pivot=pivot, out=out) @@ -137,21 +137,21 @@ def lu_factor(A, *, pivot=True, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matmul(input, other, *, out=None): return ivy.matmul(input, other, out=out) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64", "complex")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64", "complex")}, "torch") def matrix_exp(A): return ivy.matrix_exp(A) @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_norm(input, ord="fro", dim=(-2, -1), keepdim=False, *, dtype=None, out=None): if "complex" in ivy.as_ivy_dtype(input.dtype): @@ -163,7 +163,7 @@ def matrix_norm(input, ord="fro", dim=(-2, -1), keepdim=False, *, dtype=None, ou @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_power(A, n, *, out=None): return ivy.matrix_power(A, n, out=out) @@ -171,7 +171,7 @@ def matrix_power(A, n, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_rank(A, *, atol=None, rtol=None, hermitian=False, out=None): return ivy.matrix_rank(A, atol=atol, rtol=rtol, hermitian=hermitian, out=out) @@ -179,7 +179,7 @@ def matrix_rank(A, *, atol=None, rtol=None, hermitian=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def multi_dot(tensors, *, out=None): return ivy.multi_dot(tensors, out=out) @@ -187,7 +187,7 @@ def multi_dot(tensors, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex64", "complex128")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex64", "complex128")}, "torch" ) def norm(input, ord=None, dim=None, keepdim=False, *, dtype=None, out=None): if dim is None and (ord is not None): @@ -207,7 +207,7 @@ def norm(input, ord=None, dim=None, keepdim=False, *, dtype=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def pinv(input, *, atol=None, rtol=None, hermitian=False, out=None): # TODO: add handling for hermitian @@ -226,7 +226,7 @@ def pinv(input, *, atol=None, rtol=None, hermitian=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def qr(A, mode="reduced", *, out=None): if mode == "reduced": @@ -244,7 +244,7 @@ def qr(A, mode="reduced", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def slogdet(A, *, out=None): sign, logabsdet = ivy.slogdet(A) @@ -260,7 +260,7 @@ def slogdet(A, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def solve(A, B, *, left=True, out=None): if left: @@ -274,7 +274,7 @@ def solve(A, B, *, left=True, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def solve_ex(A, B, *, left=True, check_errors=False, out=None): try: @@ -302,7 +302,7 @@ def solve_ex(A, B, *, left=True, check_errors=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def svd(A, /, *, full_matrices=True, driver=None, out=None): # TODO: add handling for driver and out @@ -311,7 +311,7 @@ def svd(A, /, *, full_matrices=True, driver=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def svdvals(A, *, driver=None, out=None): if driver in ["gesvd", "gesvdj", "gesvda", None]: @@ -322,7 +322,7 @@ def svdvals(A, *, driver=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def tensorinv(input, ind=2, *, out=None): not_invertible = "Reshaped tensor is not invertible" @@ -349,14 +349,14 @@ def tensorinv(input, ind=2, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def tensorsolve(A, B, dims=None, *, out=None): return ivy.tensorsolve(A, B, axes=dims, out=out) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("integer", "float", "complex")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("integer", "float", "complex")}, "torch") def vander(x, N=None): if len(x.shape) < 1: raise RuntimeError("Input dim must be greater than or equal to 1.") @@ -389,7 +389,7 @@ def vander(x, N=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def vecdot(x, y, *, dim=-1, out=None): if "complex" in ivy.as_ivy_dtype(x.dtype): @@ -399,7 +399,7 @@ def vecdot(x, y, *, dim=-1, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def vector_norm(input, ord=2, dim=None, keepdim=False, *, dtype=None, out=None): return ivy.vector_norm( diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 446227f997913..9369885c74745 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -74,7 +74,7 @@ def broadcast_shapes(*shapes): return ivy.broadcast_shapes(*shapes) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def broadcast_to(tensor, shape): return ivy.broadcast_to(tensor, shape) @@ -113,7 +113,7 @@ def cov(input, /, *, correction=1, fweights=None, aweights=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def cross(input, other, dim=None, *, out=None): if dim is None: dim = -1 @@ -124,7 +124,7 @@ def cross(input, other, dim=None, *, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "uint16", "uint32", "uint64", @@ -152,7 +152,7 @@ def cumprod(input, dim, *, dtype=None, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.1 and below": ("uint8", "bfloat16", "float16"), "1.12.1": ()}, + {"2.1.2 and below": ("uint8", "bfloat16", "float16"), "1.12.1": ()}, "torch", ) def cumsum(input, dim, *, dtype=None, out=None): @@ -167,7 +167,7 @@ def diag(input, diagonal=0, *, out=None): @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) @to_ivy_arrays_and_back def diagflat(x, offset=0, name=None): @@ -175,7 +175,7 @@ def diagflat(x, offset=0, name=None): return arr -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def diagonal(input, offset=0, dim1=0, dim2=1): return ivy.diagonal(input, offset=offset, axis1=dim1, axis2=dim2) @@ -183,14 +183,14 @@ def diagonal(input, offset=0, dim1=0, dim2=1): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.1 and below": ("int8", "float16", "bfloat16", "bool")}, "torch" + {"2.1.2 and below": ("int8", "float16", "bfloat16", "bool")}, "torch" ) def diff(input, n=1, dim=-1, prepend=None, append=None): return ivy.diff(input, n=n, axis=dim, prepend=prepend, append=append, out=None) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def einsum(equation, *operands): if len(operands) == 1 and isinstance(operands[0], (list, tuple)): operands = operands[0] @@ -242,14 +242,14 @@ def kron(input, other, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("int8",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("int8",)}, "torch") def lcm(input, other, *, out=None): return ivy.lcm(input, other, out=out) @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", "integer", @@ -287,7 +287,7 @@ def ravel(input): return ivy.reshape(input, (-1,)) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def renorm(input, p, dim, maxnorm, *, out=None): # Torch hardcodes this magic number @@ -328,7 +328,7 @@ def renorm(input, p, dim, maxnorm, *, out=None): @with_supported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "int32", "int64", ) @@ -458,7 +458,7 @@ def searchsorted( return ret -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def tensordot(a, b, dims=2, out=None): a, b = promote_types_of_torch_inputs(a, b) @@ -466,7 +466,7 @@ def tensordot(a, b, dims=2, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def trace(input): if "int" in input.dtype: input = input.astype("int64") @@ -480,7 +480,7 @@ def tril(input, diagonal=0, *, out=None): return ivy.tril(input, k=diagonal, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("int8", "uint8", "int16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("int8", "uint8", "int16")}, "torch") @to_ivy_arrays_and_back def tril_indices(row, col, offset=0, *, dtype=ivy.int64, device="cpu", layout=None): sample_matrix = ivy.tril(ivy.ones((row, col), device=device), k=offset) @@ -511,7 +511,7 @@ def vander(x, N=None, increasing=False): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def view_as_complex(input): if ivy.shape(input)[-1] != 2: raise ivy.exceptions.IvyError("The last dimension must have a size of 2") @@ -529,7 +529,7 @@ def view_as_complex(input): @with_supported_dtypes( - {"2.1.1 and below": ("complex64", "complex128")}, + {"2.1.2 and below": ("complex64", "complex128")}, "torch", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index e2915292071d5..2ca1b3a09086b 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -107,7 +107,7 @@ def _get_transpose_pad(padding, output_padding, dims): # ------------ # -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -121,7 +121,7 @@ def conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -135,7 +135,7 @@ def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -149,7 +149,7 @@ def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose1d( input, @@ -188,7 +188,7 @@ def conv_transpose1d( ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose2d( input, @@ -227,7 +227,7 @@ def conv_transpose2d( ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose3d( input, diff --git a/ivy/functional/frontends/torch/nn/functional/distance_functions.py b/ivy/functional/frontends/torch/nn/functional/distance_functions.py index d490f459a18f3..029079540ca98 100644 --- a/ivy/functional/frontends/torch/nn/functional/distance_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/distance_functions.py @@ -4,7 +4,7 @@ from ivy.func_wrapper import with_unsupported_dtypes -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def cosine_similarity(x1, x2, *, dim=1, eps=1e-08): x1, x2 = torch_frontend.promote_types_of_torch_inputs(x1, x2) @@ -28,7 +28,7 @@ def cosine_similarity(x1, x2, *, dim=1, eps=1e-08): return cosine -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): x1, x2 = torch_frontend.promote_types_of_torch_inputs(x1, x2) @@ -42,7 +42,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): return ivy.vector_norm(x1 - x2 + eps, ord=p, axis=output_dim - 1, keepdims=keepdim) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def pdist(input, p=2): x = ivy.array( diff --git a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py index 3247afeb2cd66..e384bc25e023e 100644 --- a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py @@ -7,7 +7,7 @@ # ToDo: this function will be simplified once ivy.alpha_dropout is implemented @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") def alpha_dropout(input, p=0.5, training=False, inplace=False): if p == 0.0 or not training or input.shape == () or input.shape == (0,): @@ -28,13 +28,13 @@ def alpha_dropout(input, p=0.5, training=False, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def dropout(input, p=0.5, training=True, inplace=False): return ivy.dropout(input, p, scale=True, training=training) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def dropout1d(input, p=0.5, training=True, inplace=False): if inplace: return ivy.dropout1d(input, p, training=training, data_format="NCW", out=input) @@ -42,7 +42,7 @@ def dropout1d(input, p=0.5, training=True, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def dropout2d(input, p=0.5, training=True, inplace=False): if input.ndim < 2: raise ValueError("Feature dropout requires at least 2 dimensions in the input") @@ -55,7 +55,7 @@ def dropout2d(input, p=0.5, training=True, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def dropout3d(input, p=0.5, training=True, inplace=False): if inplace: return ivy.dropout3d( diff --git a/ivy/functional/frontends/torch/nn/functional/layer_functions.py b/ivy/functional/frontends/torch/nn/functional/layer_functions.py index 1790447af84c0..7ed6d8d90354e 100644 --- a/ivy/functional/frontends/torch/nn/functional/layer_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/layer_functions.py @@ -292,7 +292,7 @@ def _transform_weights_no_bias(layer_weights, layer_index): @with_supported_device_and_dtypes( - {"2.1.1 and below": {"cpu": ("float32", "float64")}}, + {"2.1.2 and below": {"cpu": ("float32", "float64")}}, "torch", ) @to_ivy_arrays_and_back @@ -304,7 +304,7 @@ def lstm(*args, **kwargs): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def multi_head_attention_forward( query, key, diff --git a/ivy/functional/frontends/torch/nn/functional/linear_functions.py b/ivy/functional/frontends/torch/nn/functional/linear_functions.py index e4bafdaed2e47..6246a013db9e9 100644 --- a/ivy/functional/frontends/torch/nn/functional/linear_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/linear_functions.py @@ -4,7 +4,7 @@ from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def linear(input, weight, bias=None): return ivy.linear(input, weight, bias=bias) diff --git a/ivy/functional/frontends/torch/nn/functional/loss_functions.py b/ivy/functional/frontends/torch/nn/functional/loss_functions.py index d82eb7b599e2c..6c9acb5fe3578 100644 --- a/ivy/functional/frontends/torch/nn/functional/loss_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/loss_functions.py @@ -72,7 +72,7 @@ def _get_reduction_string(size_average, reduce): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def binary_cross_entropy( input, target, weight=None, size_average=None, reduce=None, reduction="mean" ): @@ -113,7 +113,7 @@ def binary_cross_entropy_with_logits( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def cosine_embedding_loss( input1, input2, target, margin=0.0, size_average=None, reduce=None, reduction="mean" ): @@ -214,7 +214,7 @@ def cross_entropy( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("bool", "integer")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bool", "integer")}, "torch") def gaussian_nll_loss(input, target, var, full=False, eps=1e-6, reduction="mean"): input, target = torch_frontend.promote_types_of_torch_inputs(input, target) target, var = torch_frontend.promote_types_of_torch_inputs(target, var) @@ -246,7 +246,7 @@ def gaussian_nll_loss(input, target, var, full=False, eps=1e-6, reduction="mean" @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def hinge_embedding_loss( input, @@ -281,7 +281,7 @@ def huber_loss( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def kl_div( input, target, size_average=None, reduce=None, reduction="mean", log_target=False ): @@ -297,7 +297,7 @@ def kl_div( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("float", "complex")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float", "complex")}, "torch") def l1_loss( input, target, @@ -312,7 +312,7 @@ def l1_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def margin_ranking_loss( input1, input2, @@ -331,7 +331,7 @@ def margin_ranking_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def mse_loss(input, target, size_average=None, reduce=None, reduction="mean"): reduction = _get_reduction(reduction, size_average, reduce) result = ivy.square(input - target) @@ -340,7 +340,7 @@ def mse_loss(input, target, size_average=None, reduce=None, reduction="mean"): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def multilabel_margin_loss( input, target, size_average=None, reduce=None, reduction="mean" ): @@ -360,7 +360,7 @@ def multilabel_margin_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def multilabel_soft_margin_loss( input, target, @@ -390,7 +390,7 @@ def multilabel_soft_margin_loss( @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "int8", "int16", "int32")}, "torch" + {"2.1.2 and below": ("float16", "int8", "int16", "int32")}, "torch" ) def nll_loss( input, @@ -436,7 +436,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def poisson_nll_loss( input, target, @@ -463,7 +463,7 @@ def poisson_nll_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def smooth_l1_loss( input, target, @@ -476,7 +476,7 @@ def smooth_l1_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def soft_margin_loss( input, target, @@ -488,7 +488,7 @@ def soft_margin_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def triplet_margin_loss( anchor, positive, @@ -543,7 +543,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def triplet_margin_with_distance_loss( anchor, positive, diff --git a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py index 2c606b3eeee7f..fab88dd69bc05 100644 --- a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py @@ -7,7 +7,7 @@ @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "complex", "float16", ) @@ -38,7 +38,7 @@ def elu_(input, alpha=1.0): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -63,7 +63,7 @@ def glu(input, dim=-1): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def gumbel_softmax(logits, tau=1, hard=False, eps=1e-10, dim=-1): gumbels = -ivy.empty_like(logits).exponential().log() gumbels = (logits + gumbels) / tau @@ -100,30 +100,30 @@ def hardswish(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def hardtanh(input, min_val=-1.0, max_val=1.0, inplace=False): less = ivy.where(ivy.less(input, min_val), min_val, input) return ivy.where(ivy.greater(input, max_val), max_val, less).astype(input.dtype) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def hardtanh_(input, min_val=-1.0, max_val=1.0): return hardtanh(input, min_val=min_val, max_val=max_val, inplace=True) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def leaky_relu(input, negative_slope=0.01, inplace=False): return ivy.leaky_relu(input, alpha=negative_slope) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def leaky_relu_(input, negative_slope=0.01): return leaky_relu(input, negative_slope=negative_slope, inplace=True) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("float",)}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float",)}, "torch") def local_response_norm(input, size, alpha=0.0001, beta=0.75, k=1.0): non_batched = input.ndim == 3 if non_batched: @@ -137,7 +137,7 @@ def local_response_norm(input, size, alpha=0.0001, beta=0.75, k=1.0): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def log_softmax(input, dim=None, _stacklevel=3, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -149,7 +149,7 @@ def log_softmax(input, dim=None, _stacklevel=3, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -188,7 +188,7 @@ def relu(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") def relu6(input, inplace=False): return ivy.relu6(input) @@ -199,7 +199,7 @@ def relu_(input): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def rrelu(input, lower=1.0 / 8, upper=1.0 / 3, training=False, inplace=False): if training: # alpha = ivy.random_uniform(low=lower, high=upper) @@ -212,13 +212,13 @@ def rrelu(input, lower=1.0 / 8, upper=1.0 / 3, training=False, inplace=False): ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def rrelu_(input, lower=1.0 / 8, upper=1.0 / 3, training=False): return rrelu(input, lower=lower, upper=upper, training=training, inplace=True) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def scaled_dot_product_attention( query, key, value, attn_mask=None, dropout_p=0.0, is_causal=False, scale=None ): @@ -239,19 +239,19 @@ def selu(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def sigmoid(input): return ivy.sigmoid(input) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def silu(input, inplace=False): return ivy.multiply(input, ivy.sigmoid(input)) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def softmax(input, dim=None, _stacklevel=3, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -259,7 +259,7 @@ def softmax(input, dim=None, _stacklevel=3, dtype=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def softmin(input, dim=None, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -269,7 +269,7 @@ def softmin(input, dim=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -293,23 +293,23 @@ def softsign(input): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def tanh(input): return ivy.tanh(input) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def tanhshrink(input): return ivy.subtract(input, ivy.tanh(input)) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def threshold(input, threshold, value, inplace=False): return ivy.where(ivy.greater(input, threshold), input, value) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def threshold_(input, threshold, value): return threshold(input, threshold, value, inplace=True) diff --git a/ivy/functional/frontends/torch/nn/functional/norms.py b/ivy/functional/frontends/torch/nn/functional/norms.py index c489dbee9f5d0..b1f5531fcd6aa 100644 --- a/ivy/functional/frontends/torch/nn/functional/norms.py +++ b/ivy/functional/frontends/torch/nn/functional/norms.py @@ -5,7 +5,7 @@ @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "float16", ) @@ -43,7 +43,7 @@ def batch_norm( @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -58,7 +58,7 @@ def group_norm(input, num_groups, weight=None, bias=None, eps=1e-05): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "float16", ) @@ -93,7 +93,7 @@ def instance_norm( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-05): shape = ivy.shape(input) if isinstance(normalized_shape, int) and normalized_shape == shape[-1]: diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 4b32c2627096a..03cf6a1e78a12 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "float16", ) @@ -25,7 +25,7 @@ def adaptive_avg_pool1d(input, output_size): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -39,7 +39,7 @@ def adaptive_avg_pool2d(input, output_size): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "float16", ) @@ -57,7 +57,7 @@ def adaptive_max_pool2d( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16",)}, + {"2.1.2 and below": ("float16",)}, "torch", ) @to_ivy_arrays_and_back @@ -83,7 +83,7 @@ def avg_pool1d( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16",)}, + {"2.1.2 and below": ("float16",)}, "torch", ) @to_ivy_arrays_and_back @@ -111,7 +111,7 @@ def avg_pool2d( @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16")}, + {"2.1.2 and below": ("float16", "bfloat16")}, "torch", ) @to_ivy_arrays_and_back @@ -140,7 +140,7 @@ def avg_pool3d( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -172,7 +172,7 @@ def lp_pool1d(input, norm_type, kernel_size, stride=None, ceil_mode=False): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -201,7 +201,7 @@ def lp_pool2d(input, norm_type, kernel_size, stride=None, ceil_mode=False): return ivy.pow(ivy.multiply(out, kernel_mul), p).astype(input.dtype) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool1d( input, @@ -227,7 +227,7 @@ def max_pool1d( ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool2d( input, @@ -253,7 +253,7 @@ def max_pool2d( ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool3d( input, diff --git a/ivy/functional/frontends/torch/nn/functional/sparse_functions.py b/ivy/functional/frontends/torch/nn/functional/sparse_functions.py index 1be9407cd50f9..d0ef9cd0f3976 100644 --- a/ivy/functional/frontends/torch/nn/functional/sparse_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/sparse_functions.py @@ -33,7 +33,7 @@ def embedding( return ret -@with_supported_dtypes({"2.1.1 and below": ("int64",)}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("int64",)}, "torch") @to_ivy_arrays_and_back def one_hot(tensor, num_classes=-1): return ivy.astype(ivy.one_hot(tensor, num_classes), tensor.dtype) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index 998aa75061dd7..e6d96dbfbb367 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -30,7 +30,7 @@ def _handle_padding_shape(padding, n, mode): # ------------ # -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def affine_grid(theta, size, align_corners=False): if len(size) == 4: @@ -93,7 +93,7 @@ def cubic_conv2(A, x): return ((A * x - 5 * A) * x + 8 * A) * x - 4 * A -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def grid_sample( input, grid, mode="bilinear", padding_mode="zeros", align_corners=False @@ -348,7 +348,7 @@ def grid_sample_padding(grid, padding_mode, align_corners, borders=None): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "float16", ) @@ -505,7 +505,7 @@ def reflect(x, low2, high2): return x -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample( input, @@ -523,7 +523,7 @@ def upsample( ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample_bilinear(input, size=None, scale_factor=None): return interpolate( @@ -531,7 +531,7 @@ def upsample_bilinear(input, size=None, scale_factor=None): ) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample_nearest(input, size=None, scale_factor=None): return interpolate(input, size=size, scale_factor=scale_factor, mode="nearest") diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py index ed698fccf6bd9..33e7e15db2ba9 100644 --- a/ivy/functional/frontends/torch/pointwise_ops.py +++ b/ivy/functional/frontends/torch/pointwise_ops.py @@ -13,13 +13,13 @@ def abs(input, *, out=None): return ivy.abs(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def acos(input, *, out=None): return ivy.acos(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def acosh(input, *, out=None): return ivy.acosh(input, out=out) @@ -35,13 +35,13 @@ def add(input, other, *, alpha=1, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def addcdiv(input, tensor1, tensor2, *, value=1, out=None): return ivy.add(input, ivy.multiply(value, ivy.divide(tensor1, tensor2)), out=out) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def addcmul(input, tensor1, tensor2, *, value=1, out=None): return ivy.add(input, ivy.multiply(value, ivy.multiply(tensor1, tensor2)), out=out) @@ -51,32 +51,32 @@ def angle(input, *, out=None): return ivy.angle(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def asin(input, *, out=None): return ivy.asin(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def asinh(input, *, out=None): return ivy.asinh(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def atan(input, *, out=None): return ivy.atan(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def atan2(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.atan2(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def atanh(input, *, out=None): return ivy.atanh(input, out=out) @@ -117,13 +117,13 @@ def bitwise_xor(input, other, *, out=None): return ivy.bitwise_xor(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def ceil(input, *, out=None): return ivy.ceil(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def clamp(input, min=None, max=None, *, out=None): ivy.utils.assertions.check_all_or_any_fn( @@ -152,7 +152,7 @@ def copysign(input, other, *, out=None): return ivy.copysign(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def cos(input, *, out=None): return ivy.cos(input, out=out) @@ -181,31 +181,31 @@ def div(input, other, *, rounding_mode=None, out=None): return ivy.divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def erf(input, *, out=None): return ivy.erf(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def erfc(input, *, out=None): return 1.0 - ivy.erf(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def exp(input, *, out=None): return ivy.exp(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def exp2(input, out=None): return ivy.exp2(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def expm1(input, out=None): return ivy.expm1(input, out=out) @@ -223,7 +223,7 @@ def float_power(input, exponent, *, out=None): return ivy.float_power(input, exponent, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def floor(input, *, out=None): return ivy.floor(input, out=out) @@ -234,7 +234,7 @@ def floor_divide(input, other, *, out=None): return ivy.floor_divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def fmod(x1, x2, out=None): return ivy.fmod(x1, x2, out=out) @@ -245,31 +245,31 @@ def frac(input, *, out=None): return input - ivy.sign(input) * ivy.floor(ivy.abs(input)) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def frexp(input, *, out=None): return ivy.frexp(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def gradient(input, *, spacing=1, dim=None, edge_order=1): return ivy.gradient(input, spacing=spacing, edge_order=edge_order, axis=dim) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def hypot(input, other, *, out=None): return ivy.hypot(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def i0(input, *, out=None): return ivy.i0(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def igamma(input, other, *, out=None): return ivy.igamma(input, x=other, out=out) @@ -280,7 +280,7 @@ def imag(input): return ivy.imag(input) -@with_supported_dtypes({"2.1.1 and below": ("float16", "float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float16", "float32", "float64")}, "torch") @to_ivy_arrays_and_back def ldexp(input, other, *, out=None): value = ivy.pow(2, other, out=out) @@ -288,49 +288,49 @@ def ldexp(input, other, *, out=None): return value -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def lerp(input, end, weight, *, out=None): return ivy.lerp(input, end, weight, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def lgamma(input, *, out=None): return ivy.lgamma(input, out=out) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def log(input, *, out=None): return ivy.log(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log10(input, *, out=None): return ivy.log10(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log1p(input, *, out=None): return ivy.log1p(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log2(input, *, out=None): return ivy.log2(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def logaddexp(x1, x2, out=None): return ivy.logaddexp(x1, x2, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def logaddexp2(x1, x2, out=None): return ivy.logaddexp2(x1, x2, out=out) @@ -359,13 +359,13 @@ def logical_xor(input, other, *, out=None): return ivy.logical_xor(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def logit(input, eps=None, *, out=None): return ivy.logit(input, eps=eps, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def masked_fill(input, mask, value): return ivy.where(mask, value, input, out=input) @@ -378,7 +378,7 @@ def mul(input, other, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def mvlgamma(input, p, *, out=None): ivy.assertions.check_greater( p, 1, allow_equal=True, message="p has to be greater than or equal to 1" @@ -393,19 +393,19 @@ def mvlgamma(input, p, *, out=None): ) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def nan_to_num(input, nan=0.0, posinf=None, neginf=None, *, out=None): return ivy.nan_to_num(input, nan=nan, posinf=posinf, neginf=neginf, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bool",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bool",)}, "torch") @to_ivy_arrays_and_back def negative(input, *, out=None): return ivy.negative(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") @to_ivy_arrays_and_back def nextafter(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -417,7 +417,7 @@ def positive(input, *, out=None): return ivy.positive(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bool",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bool",)}, "torch") @to_ivy_arrays_and_back def pow(input, exponent, *, out=None): if not ivy.is_array(exponent): @@ -460,7 +460,7 @@ def remainder(input, other, *, out=None): return ivy.remainder(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def round(input, *, decimals=0, out=None): m = ivy.full(input.shape, 10.0**decimals) @@ -469,7 +469,7 @@ def round(input, *, decimals=0, out=None): return ivy.divide(rounded, m, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def rsqrt(input, *, out=None): return ivy.reciprocal(ivy.sqrt(input), out=out) @@ -488,43 +488,43 @@ def sgn(input, *, out=None): return ivy.sign(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sigmoid(input, *, out=None): return ivy.sigmoid(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def sign(input, *, out=None): return ivy.sign(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def signbit(input, *, out=None): return ivy.signbit(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sin(input, *, out=None): return ivy.sin(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sinc(input, *, out=None): return ivy.sinc(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sinh(input, *, out=None): return ivy.sinh(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sqrt(input, *, out=None): return ivy.sqrt(input, out=out) @@ -541,13 +541,13 @@ def subtract(input, other, *, alpha=1, out=None): return ivy.subtract(input, other * alpha, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def tan(input, *, out=None): return ivy.tan(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def tanh(input, *, out=None): return ivy.tanh(input, out=out) @@ -559,13 +559,13 @@ def true_divide(input, other, *, out=None): return ivy.divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def trunc(input, *, out=None): return ivy.trunc(input, out=out) -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def xlogy(input, other, *, out=None): return ivy.xlogy(input, other, out=out) diff --git a/ivy/functional/frontends/torch/random_sampling.py b/ivy/functional/frontends/torch/random_sampling.py index 4b3b21bad1160..16f7b8494105d 100644 --- a/ivy/functional/frontends/torch/random_sampling.py +++ b/ivy/functional/frontends/torch/random_sampling.py @@ -5,7 +5,7 @@ @with_supported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float32", "float64", ) @@ -26,7 +26,7 @@ def manual_seed(seed: int): @with_supported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float32", "float64", ) @@ -49,7 +49,7 @@ def multinomial(input, num_samples, replacement=False, *, generator=None, out=No @with_supported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float32", "float64", ) @@ -64,7 +64,7 @@ def normal(mean, std, *, generator=None, out=None): @with_supported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float32", "float64", ) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 6870cbece2f72..c40bb033b9824 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -32,7 +32,7 @@ def amin(input, dim=None, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def aminmax(input, *, dim=None, keepdim=False, out=None): minmax_tuple = namedtuple("minmax", ["min", "max"]) return minmax_tuple( @@ -51,7 +51,7 @@ def any(input, dim=None, keepdim=False, *, out=None): return ret -@with_unsupported_dtypes({"2.1.1 and below": ("complex", "bool")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("complex", "bool")}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def argmax(input, dim=None, keepdim=False): @@ -67,7 +67,7 @@ def argmin(input, dim=None, keepdim=False): @numpy_to_torch_style_args @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.1 and below": ("uint8", "int8")}, + {"2.1.2 and below": ("uint8", "int8")}, "torch", ) def count_nonzero(input, dim=None): @@ -163,7 +163,7 @@ def median(input, dim=None, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.1 and below": ("complex64", "complex128")}, + {"2.1.2 and below": ("complex64", "complex128")}, "torch", ) def min(*input, dim=None, keepdim=False, out=None): @@ -234,7 +234,7 @@ def nanmedian(input, dim=None, keepdim=False, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float", "int")}, + {"2.1.2 and below": ("float", "int")}, "torch", ) def nansum(input, dim=None, keepdim=False, *, dtype=None): @@ -244,7 +244,7 @@ def nansum(input, dim=None, keepdim=False, *, dtype=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float", "complex")}, + {"2.1.2 and below": ("float", "complex")}, "torch", ) def norm(input, p="fro", dim=None, keepdim=False, out=None, dtype=None): @@ -270,7 +270,7 @@ def norm(input, p="fro", dim=None, keepdim=False, out=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -286,7 +286,7 @@ def prod(input, dim=None, keepdim=False, *, dtype=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def quantile(input, q, dim=None, keepdim=False, *, interpolation="linear", out=None): return ivy.quantile( input, q, axis=dim, keepdims=keepdim, interpolation=interpolation, out=out @@ -295,14 +295,14 @@ def quantile(input, q, dim=None, keepdim=False, *, interpolation="linear", out=N @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def std(input, dim=None, unbiased=True, keepdim=False, *, out=None): return ivy.std(input, axis=dim, correction=int(unbiased), keepdims=keepdim, out=out) @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def std_mean(input, dim, unbiased, keepdim=False, *, out=None): temp_std = ivy.std( input, axis=dim, correction=int(unbiased), keepdims=keepdim, out=out @@ -347,7 +347,7 @@ def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=No @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "complex", ) @@ -369,7 +369,7 @@ def unique_consecutive(input, return_inverse, return_counts, dim): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -384,7 +384,7 @@ def var(input, dim, unbiased, keepdim=False, *, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index bc16b2b84d2bf..23a45a28f533d 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -146,20 +146,20 @@ def reshape(self, *args, shape=None): else: raise ValueError("reshape() got no values for argument 'shape'") - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @with_unsupported_dtypes({"2.5.1 and below": ("float16",)}, "paddle") def reshape_as(self, other): return torch_frontend.reshape(self, other.shape) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def add(self, other, *, alpha=1): return torch_frontend.add(self, other, alpha=alpha) - # @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + # @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def divide(self, other, *, out=None): return torch_frontend.divide(self, other, out=out) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def sub(self, other, *, alpha=1): return torch_frontend.sub(self, other, alpha=alpha) @@ -174,105 +174,105 @@ def any(self, dim=None, keepdim=False): def all(self, dim=None, keepdim=False): return torch_frontend.all(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def add_(self, other, *, alpha=1): self.ivy_array = self.add(other, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addmm(self, mat1, mat2, *, beta=1, alpha=1): return torch_frontend.addmm(self, mat1, mat2, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addmm_(self, mat1, mat2, *, beta=1, alpha=1): self.ivy_array = self.addmm(mat1, mat2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addmv(self, mat, vec, *, beta=1, alpha=1): return torch_frontend.addmv(self, mat, vec, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addmv_(self, mat, vec, *, beta=1, alpha=1): self.ivy_array = torch_frontend.addmv( self, mat, vec, beta=beta, alpha=alpha ).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addbmm(self, batch1, batch2, *, beta=1, alpha=1): return torch_frontend.addbmm(self, batch1, batch2, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addbmm_(self, batch1, batch2, *, beta=1, alpha=1): self.ivy_array = self.addbmm(batch1, batch2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def subtract_(self, other, *, alpha=1): self.ivy_array = self.sub(other, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def asin(self): return torch_frontend.asin(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def asin_(self): self.ivy_array = self.asin().ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def sum(self, dim=None, keepdim=False, *, dtype=None): return torch_frontend.sum(self, dim=dim, keepdim=keepdim, dtype=dtype) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def sin(self): return torch_frontend.sin(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def sin_(self): self.ivy_array = self.sin().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def sinh(self): return torch_frontend.sinh(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def sinh_(self): self.ivy_array = self.sinh().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def cos(self): return torch_frontend.cos(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def cos_(self): self.ivy_array = self.cos().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def cosh(self): return torch_frontend.cosh(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def cosh_(self): self.ivy_array = self.cosh().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def atan(self): return torch_frontend.atan(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def atan_(self): self.ivy_array = self.atan().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def atan2(self, other): return torch_frontend.atan2(self, other) @@ -318,56 +318,56 @@ def float(self, memory_format=None): def double(self): return self.to(torch_frontend.float64) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def asinh(self): return torch_frontend.asinh(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def asinh_(self): self.ivy_array = self.asinh().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def tan(self): return torch_frontend.tan(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def tan_(self): self.ivy_array = self.tan().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def tanh(self): return torch_frontend.tanh(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def tanh_(self): self.ivy_array = self.tanh().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def atanh(self): return torch_frontend.atanh(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def atanh_(self): self.ivy_array = self.atanh().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def log(self): return torch_frontend.log(self) - @with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def log2_(self): self.ivy_array = self.log2().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def logit(self): return torch_frontend.logit(self) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "uint16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "uint16")}, "torch") def copy_(self, other, non_blocking=False): ivy.utils.assertions.check_one_way_broadcastable( self.ivy_array.shape, torch_frontend.tensor(other).ivy_array.shape @@ -375,31 +375,31 @@ def copy_(self, other, non_blocking=False): self._ivy_array = torch_frontend.tensor(other).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def log_(self): self.ivy_array = self.log().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def log2(self): return torch_frontend.log2(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def relu(self): return torch_frontend_nn.relu(self) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") def amax(self, dim=None, keepdim=False): return torch_frontend.amax(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") def amin(self, dim=None, keepdim=False): return torch_frontend.amin(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("complex", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("complex", "float16")}, "torch") def aminmax(self, dim=None, keepdim=False): return torch_frontend.aminmax(self, dim=dim, keepdim=keepdim) @@ -410,7 +410,7 @@ def abs_(self): self.ivy_array = self.abs().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def logical_and(self, other): return torch_frontend.logical_and(self, other) @@ -421,11 +421,11 @@ def logical_not_(self): self.ivy_array = ivy.astype(self.logical_not().ivy_array, self.dtype) return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def logical_or(self, other): return torch_frontend.logical_or(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def logical_xor(self, other): return torch_frontend.logical_xor(self, other) @@ -435,14 +435,14 @@ def bitwise_not(self): def bitwise_and(self, other): return torch_frontend.bitwise_and(self, other) - @with_supported_dtypes({"2.1.1 and below": ("integer",)}, "torch") + @with_supported_dtypes({"2.1.2 and below": ("integer",)}, "torch") def bitwise_or(self, other): return torch_frontend.bitwise_or(self, other) def bitwise_left_shift(self, other): return torch_frontend.bitwise_left_shift(self, other) - @with_supported_dtypes({"2.1.1 and below": ("integer",)}, "torch") + @with_supported_dtypes({"2.1.2 and below": ("integer",)}, "torch") def bitwise_or_(self, other): self.ivy_array = self.bitwise_or(other).ivy_array return self @@ -470,13 +470,13 @@ def new_ones( size, dtype=dtype, device=device, requires_grad=requires_grad ) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def floor(self, *, out=None): return torch_frontend.floor(self) @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "uint8", "uint32", @@ -493,7 +493,7 @@ def not_equal(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "uint8", "uint32", @@ -512,12 +512,12 @@ def not_equal_(self, other, *, out=None): def equal(self, other): return torch_frontend.equal(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def erf(self, *, out=None): return torch_frontend.erf(self, out=out) @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "bfloat16")}, "torch" + {"2.1.2 and below": ("float32", "float64", "bfloat16")}, "torch" ) def erf_(self, *, out=None): self.ivy_array = self.erf(out=out).ivy_array @@ -624,11 +624,11 @@ def to(self, *args, **kwargs): ) return cast_tensor - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def acos(self): return torch_frontend.acos(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def acos_(self): self.ivy_array = self.acos().ivy_array return self @@ -648,7 +648,7 @@ def new_tensor( _data = ivy.asarray(data, copy=True, dtype=dtype, device=device) return torch_frontend.tensor(_data) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def view_as(self, other): return self.view(size=other.shape) @@ -677,7 +677,7 @@ def detach_(self): self.ivy_array = self.detach().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, "torch") @numpy_to_torch_style_args def unsqueeze(self, dim): return torch_frontend.unsqueeze(self, dim) @@ -765,7 +765,7 @@ def max(self, dim=None, keepdim=False): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "complex", "bfloat16", "bool", @@ -791,15 +791,15 @@ def is_cuda(self): def is_meta(self): return "meta" in ivy.dev(self.ivy_array) - @with_unsupported_dtypes({"2.1.1 and below": ("uint16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("uint16", "bool")}, "torch") def positive(self): return torch_frontend.positive(self) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def pow(self, exponent): return torch_frontend.pow(self, exponent) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def pow_(self, exponent): self.ivy_array = self.pow(exponent).ivy_array return self @@ -820,7 +820,7 @@ def matmul(self, other): return torch_frontend.matmul(self, other) @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_power(self, n, *, out=None): return torch_frontend.linalg.matrix_power(self, n, out=out) @@ -829,20 +829,20 @@ def argwhere(self): return torch_frontend.argwhere(self) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("complex", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("complex", "bool")}, "torch") def argmax(self, dim=None, keepdim=False): return torch_frontend.argmax(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") def argmin(self, dim=None, keepdim=False): return torch_frontend.argmin(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") def argsort(self, dim=-1, descending=False): return torch_frontend.argsort(self, dim=dim, descending=descending) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def ceil(self): return torch_frontend.ceil(self) @@ -865,22 +865,22 @@ def permute(self, *args, dims=None): raise ValueError("permute() got no values for argument 'dims'") @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def mean(self, dim=None, keepdim=False): return torch_frontend.mean(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @numpy_to_torch_style_args def nanmean(self, dim=None, keepdim=False): return torch_frontend.nanmean(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @numpy_to_torch_style_args def nansum(self, dim=None, keepdim=False): return torch_frontend.nansum(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def median(self, dim=None, keepdim=False): return torch_frontend.median(self, dim=dim, keepdim=keepdim) @@ -898,32 +898,32 @@ def flatten(self, start_dim=0, end_dim=-1): return torch_frontend.flatten(self, start_dim, end_dim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def cumsum(self, dim, *, dtype=None): return torch_frontend.cumsum(self, dim, dtype=dtype) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def cumsum_(self, dim, *, dtype=None): self.ivy_array = self.cumsum(dim, dtype=dtype).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def inverse(self): return torch_frontend.inverse(self) - @with_unsupported_dtypes({"2.1.1 and below": ("bool", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bool", "bfloat16")}, "torch") def neg(self): return torch_frontend.negative(self) - @with_unsupported_dtypes({"2.1.1 and below": ("bool",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bool",)}, "torch") def neg_(self): self.ivy_array = torch_frontend.negative(self).ivy_array return self __neg__ = neg - @with_unsupported_dtypes({"2.1.1 and below": ("bool", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bool", "bfloat16")}, "torch") def negative(self): return torch_frontend.negative(self) @@ -946,7 +946,7 @@ def type(self, dtype=None, non_blocking=False, **kwargs): else: return str(self.dtype) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def type_as(self, other): if self.dtype != other.dtype: self.ivy_array = ivy.astype(self.ivy_array, other.dtype) @@ -961,7 +961,7 @@ def squeeze(self, dim=None): return torch_frontend.squeeze(self, dim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, "torch") def squeeze_(self, dim=None): self.ivy_array = self.squeeze(dim).ivy_array return self @@ -985,35 +985,35 @@ def tril_(self, diagonal=0): def index_select(self, dim, index): return torch_frontend.index_select(self, dim, index) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def clamp(self, min=None, max=None): return torch_frontend.clamp(self, min=min, max=max) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def clamp_(self, min=None, max=None): self.ivy_array = self.clamp(min=min, max=max).ivy_array return self @with_unsupported_dtypes( - {"2.1.1 and below": ("bool", "bfloat16", "float16", "complex")}, "torch" + {"2.1.2 and below": ("bool", "bfloat16", "float16", "complex")}, "torch" ) def clamp_min(self, min=None): return torch_frontend.clamp(self, min=min) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def sqrt(self): return torch_frontend.sqrt(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def rsqrt(self): return torch_frontend.rsqrt(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def rsqrt_(self): self.ivy_array = self.rsqrt().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def sqrt_(self): self.ivy_array = self.sqrt().ivy_array return self @@ -1024,7 +1024,7 @@ def where(self, condition, other): def clone(self, memory_format=None): return torch_frontend.tensor(ivy.array(self.ivy_array, copy=True)) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def acosh(self): return torch_frontend.acosh(self) @@ -1037,38 +1037,38 @@ def masked_fill_(self, mask, value): self.ivy_array = self.masked_fill(mask, value).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def index_add_(self, dim, index, source, *, alpha=1): self.ivy_array = torch_frontend.index_add( self, dim, index, source, alpha=alpha ).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def index_add(self, dim, index, source, *, alpha=1): return torch_frontend.index_add( self._ivy_array, dim, index, source, alpha=alpha ) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def acosh_(self): self.ivy_array = self.acosh().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def numpy(self): return np_frontend_array(self.ivy_array) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def sigmoid(self): return torch_frontend.sigmoid(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def sigmoid_(self): self.ivy_array = self.sigmoid().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def softmax(self, dim=None, dtype=None): return torch_frontend.nn.functional.softmax(self, dim=dim, dtype=dtype) @@ -1100,7 +1100,7 @@ def remainder(self, other, *, out=None): return torch_frontend.remainder(self, other, out=out) @with_supported_dtypes( - {"2.1.1 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" + {"2.1.2 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" ) def reciprocal_(self): self.ivy_array = torch_frontend.reciprocal(self).ivy_array @@ -1118,12 +1118,12 @@ def bitwise_and_(self, other): self.ivy_array = self.bitwise_and(other).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def atan2_(self, other): self.ivy_array = self.atan2(other).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def fmax(self, other): return torch_frontend.fmax(self, other) @@ -1133,20 +1133,20 @@ def fmin(self, other): def msort(self): return torch_frontend.msort(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def trunc(self): return torch_frontend.trunc(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def trunc_(self): self.ivy_array = self.trunc().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def fix(self): return torch_frontend.fix(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def fix_(self): self.ivy_array = self.fix().ivy_array return self @@ -1157,11 +1157,11 @@ def isinf(self): def is_complex(self): return torch_frontend.is_complex(self._ivy_array) - @with_unsupported_dtypes({"2.1.1 and below": ("uint16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("uint16", "bfloat16")}, "torch") def is_floating_point(self): return torch_frontend.is_floating_point(self._ivy_array) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def isreal(self): return torch_frontend.isreal(self._ivy_array) @@ -1172,11 +1172,11 @@ def addr_(self, vec1, vec2, *, beta=1, alpha=1): self.ivy_array = self.addr(vec1, vec2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def dot(self, tensor): return torch_frontend.dot(self, tensor) - @with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def bernoulli(self, *, generator=None, out=None): return torch_frontend.bernoulli(self._ivy_array, generator=generator, out=out) @@ -1191,19 +1191,19 @@ def __bool__(self): "Use a.any() or a.all()" ) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __add__(self, other): return torch_frontend.add(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __mod__(self, other): return torch_frontend.remainder(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __pow__(self, exponent): return self.pow(exponent) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __rpow__(self, other): return torch_frontend.pow(other, self) @@ -1225,30 +1225,30 @@ def __iter__(self): for i in range(self.shape[0]): yield self[i] - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __radd__(self, other): return torch_frontend.add(other, self) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __mul__(self, other): return torch_frontend.mul(self, other) - @with_unsupported_dtypes({"2.1.1 and below": "bfloat16"}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": "bfloat16"}, "torch") def __matmul__(self, other): return torch_frontend.matmul(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __rmul__(self, other): return torch_frontend.mul(other, self) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __sub__(self, other): return torch_frontend.subtract(self, other) def __truediv__(self, other): return torch_frontend.div(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def __floordiv__(self, other): return torch_frontend.floor_divide(self, other) @@ -1303,39 +1303,39 @@ def __float__(self): item = item.real return float(item) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __eq__(self, other): return torch_frontend.eq(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") def __gt__(self, other): return torch_frontend.greater(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __ge__(self, other): return torch_frontend.greater_equal(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __ne__(self, other): return self.ne(other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __rsub__(self, other): return torch_frontend.subtract(other, self) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __lt__(self, other): return torch_frontend.less(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __le__(self, other): return torch_frontend.less_equal(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def __or__(self, other): return torch_frontend.bitwise_or(self, other) - @with_supported_dtypes({"2.1.1 and below": ("integer", "bool")}, "torch") + @with_supported_dtypes({"2.1.2 and below": ("integer", "bool")}, "torch") def __invert__(self): return torch_frontend.bitwise_not(self) @@ -1369,7 +1369,7 @@ def item(self): ) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def cumprod(self, dim, dtype): return torch_frontend.cumprod(self, dim, dtype=dtype) @@ -1382,26 +1382,26 @@ def cov(self, /, *, correction=1, fweights=None, aweights=None): self, correction=correction, fweights=fweights, aweights=aweights ) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") def exp(self): return torch_frontend.exp(self) @with_unsupported_dtypes( - {"2.1.1 and below": ("bfloat16", "float16", "complex")}, "torch" + {"2.1.2 and below": ("bfloat16", "float16", "complex")}, "torch" ) def expm1(self): return torch_frontend.expm1(self) # remove "bfloat16" from the below decorator after fixing ivy.Array.__repr__ method @with_unsupported_dtypes( - {"2.1.1 and below": ("bfloat16", "float16", "complex")}, "torch" + {"2.1.2 and below": ("bfloat16", "float16", "complex")}, "torch" ) def expm1_(self): self.ivy_array = torch_frontend.expm1(self).ivy_array return self # fmt: off - @with_unsupported_dtypes({"2.1.1 and below": ("int8", "int16", "int32", "int64", "uint8", "bool", "float16",)},"torch",) # noqa + @with_unsupported_dtypes({"2.1.2 and below": ("int8", "int16", "int32", "int64", "uint8", "bool", "float16",)},"torch",) # noqa def exp_(self): self.ivy_array = self.exp().ivy_array return self @@ -1410,33 +1410,33 @@ def exp_(self): def mul(self, other): return torch_frontend.mul(self, other) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def ceil_(self): self.ivy_array = torch_frontend.ceil(self).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def mul_(self, other): self.ivy_array = self.mul(other).ivy_array # the return dtype is the same as the input dtype self.ivy_array = self.to(self.dtype).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") def round(self, *, decimals=0): return torch_frontend.round(self, decimals=decimals) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") def round_(self, *, decimals=0): self.ivy_array = self.round(decimals=decimals).ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def cross(self, other, dim=-1): return torch_frontend.cross(self, other, dim=dim) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def det(self): return torch_frontend.det(self) @@ -1455,13 +1455,13 @@ def nonzero(self, as_tuple=False): def mm(self, mat2): return torch_frontend.mm(self, mat2) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") def square(self): return torch_frontend.square(self._ivy_array) @with_supported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "float32", "float64", @@ -1480,16 +1480,16 @@ def square_(self): self.ivy_array = torch_frontend.square(self._ivy_array).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def log10(self): return torch_frontend.log10(self._ivy_array) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def log10_(self): self.ivy_array = self.log10().ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, "torch") def zero_(self): self.ivy_array = torch_frontend.zeros_like(self).ivy_array return self @@ -1499,7 +1499,7 @@ def short(self, memory_format=None): return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def prod(self, dim=None, keepdim=False, *, dtype=None): return torch_frontend.prod(self, dim=dim, keepdim=keepdim, dtype=dtype) @@ -1511,7 +1511,7 @@ def div_(self, other, *, rounding_mode=None): return self @with_supported_dtypes( - {"2.1.1 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" + {"2.1.2 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" ) def true_divide_(self, other): self.ivy_array = self.div(other, rounding_mode=None).ivy_array @@ -1527,26 +1527,26 @@ def normal_(self, mean=0, std=1, *, generator=None): ) return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addcdiv(self, tensor1, tensor2, *, value=1): return torch_frontend.addcdiv(self, tensor1, tensor2, value=value) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addcmul(self, tensor1, tensor2, *, value=1): return torch_frontend.addcmul(self, tensor1, tensor2, value=value) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addcmul_(self, tensor1, tensor2, *, value=1): self.ivy_array = self.addcmul(tensor1, tensor2, value=value).ivy_array return self sign_decorator_dtypes = ("float16", "complex", "bool") - @with_unsupported_dtypes({"2.1.1 and below": sign_decorator_dtypes}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": sign_decorator_dtypes}, "torch") def sign(self): return torch_frontend.sign(self._ivy_array) - @with_unsupported_dtypes({"2.1.1 and below": sign_decorator_dtypes}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": sign_decorator_dtypes}, "torch") def sign_(self): self.ivy_array = self.sign().ivy_array return self @@ -1557,11 +1557,11 @@ def std(self, dim=None, unbiased=True, keepdim=False, *, out=None): self, dim=dim, unbiased=unbiased, keepdim=keepdim, out=out ) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def fmod(self, other, *, out=None): return torch_frontend.fmod(self, other, out=out) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def fmod_(self, other): self.ivy_array = self.fmod(other).ivy_array return self @@ -1572,96 +1572,96 @@ def norm(self, p="fro", dim=None, keepdim=False, dtype=None): def tolist(self): return self._ivy_array.to_list() - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def multiply(self, other, *, out=None): return torch_frontend.multiply(self, other, out=out) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def multiply_(self, other, *, out=None): self.ivy_array = torch_frontend.multiply(self, other, out=out).ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") def topk(self, k, dim=None, largest=True, sorted=True): return torch_frontend.topk(self, k, dim=dim, largest=largest, sorted=sorted) rshift_dtypes = ("float16", "bfloat16", "float32", "float64", "bool", "complex") - @with_unsupported_dtypes({"2.1.1 and below": rshift_dtypes}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": rshift_dtypes}, "torch") def bitwise_right_shift(self, other, *, out=None): return torch_frontend.bitwise_right_shift(self._ivy_array, other) @with_supported_dtypes( - {"2.1.1 and below": ("uint8", "int8", "int32", "int64")}, "torch" + {"2.1.2 and below": ("uint8", "int8", "int32", "int64")}, "torch" ) def bitwise_right_shift_(self, other, *, out=None): self.ivy_array = self.bitwise_right_shift(other, out=out).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def logdet(self): chol = torch_frontend.cholesky(self) return 2 * torch_frontend.sum( torch_frontend.log(torch_frontend.real(torch_frontend.diagonal(chol))) ) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def copysign(self, other, *, out=None): return torch_frontend.copysign(self, other, out=out) @with_supported_dtypes( - {"2.1.1 and below": ("float16", "float32", "float64")}, "torch" + {"2.1.2 and below": ("float16", "float32", "float64")}, "torch" ) def copysign_(self, other, *, out=None): self.ivy_array = self.copysign(other, out=out).ivy_array return self @with_unsupported_dtypes( - {"2.1.1 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.1.2 and below": ("complex", "bfloat16", "bool")}, "torch" ) def greater(self, other, *, out=None): return torch_frontend.greater(self, other, out=out) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "bool")}, "torch") def greater_(self, other): self.ivy_array = ivy.astype(self.greater(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.1 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.1.2 and below": ("complex", "bfloat16", "bool")}, "torch" ) def greater_equal(self, other, *, out=None): return torch_frontend.greater_equal(self, other, out=out) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "bool")}, "torch") def greater_equal_(self, other): self.ivy_array = ivy.astype(self.greater_equal(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.1 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.1.2 and below": ("complex", "bfloat16", "bool")}, "torch" ) def less(self, other, *, out=None): return torch_frontend.less(self, other, out=out) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "bool")}, "torch") def less_(self, other): self.ivy_array = ivy.astype(self.less(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.1 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.1.2 and below": ("complex", "bfloat16", "bool")}, "torch" ) def less_equal(self, other, *, out=None): return torch_frontend.less_equal(self, other, out=out) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "bool")}, "torch") def less_equal_(self, other): self.ivy_array = ivy.astype(self.less_equal(other).ivy_array, self.dtype) return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def eq_(self, other): self.ivy_array = ivy.astype( torch_frontend.eq(self, other).ivy_array, self.dtype @@ -1690,13 +1690,13 @@ def stride(self, dim=None): return strides @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "bfloat16")}, "torch" + {"2.1.2 and below": ("float32", "float64", "bfloat16")}, "torch" ) def log1p(self): promoted_type = ivy.promote_types(self.dtype, "float32") return torch_frontend.log1p(self).to(promoted_type) - @with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def log1p_(self): promoted_type = ivy.promote_types(self.dtype, "float32") self.ivy_array = torch_frontend.log1p(self).to(promoted_type).ivy_array @@ -1716,14 +1716,14 @@ def baddbmm_(self, batch1, batch2, *, beta=1, alpha=1): def bmm(self, mat2): return torch_frontend.bmm(self, mat2=mat2) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def floor_(self): self.ivy_array = self.floor().ivy_array return self @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "complex", "float64", @@ -1739,7 +1739,7 @@ def diff(self, n=1, dim=-1, prepend=None, append=None): def diag(self, diagonal=0): return torch_frontend.diag(self, diagonal=diagonal) - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def diagonal(self, offset=0, dim1=0, dim2=1): return torch_frontend.diagonal(self, offset=offset, dim1=dim1, dim2=dim2) @@ -1747,14 +1747,14 @@ def gather(self, dim, index): return torch_frontend.gather(self, dim=dim, index=index) @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add_(self, dim, index, src): self.ivy_array = ivy.put_along_axis(self.ivy_array, index, src, dim, mode="sum") return self @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_(self, dim, index, src, *, reduce=None): if reduce is None: @@ -1771,7 +1771,7 @@ def scatter_(self, dim, index, src, *, reduce=None): return self @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce_(self, dim, index, src, reduce, *, include_self=True): if reduce == "prod": @@ -1782,19 +1782,19 @@ def scatter_reduce_(self, dim, index, src, reduce, *, include_self=True): return self @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add(self, dim, index, src): return torch_frontend.scatter_add(self, dim, index, src) @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter(self, dim, index, src): return torch_frontend.scatter_reduce(self, dim, index, src, reduce="replace") @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce(self, dim, index, src, reduce, *, include_self=True): return torch_frontend.scatter_reduce(self, dim, index, src, reduce=reduce) @@ -1805,14 +1805,14 @@ def take_along_dim(self, indices, dim): def movedim(self, source, destination): return torch_frontend.movedim(self, source=source, destination=destination) - @with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") def addcdiv_(self, tensor1, tensor2, *, value=1): self.ivy_array = self.addcdiv( tensor1=tensor1, tensor2=tensor2, value=value ).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") def cholesky(self, upper=False): return torch_frontend.cholesky(self, upper=upper) @@ -1851,7 +1851,7 @@ def backward(self, gradient=None, retain_graph=None, create_graph=False): else: next_function(_grad_list[idx]) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def logaddexp(self, other): return torch_frontend.logaddexp(self, other) @@ -1875,17 +1875,17 @@ def adjoint(self): return torch_frontend.adjoint(self) @with_unsupported_dtypes( - {"2.1.1 and below": ("int16", "float16", "bfloat16")}, "torch" + {"2.1.2 and below": ("int16", "float16", "bfloat16")}, "torch" ) def conj(self): return torch_frontend.conj(self) - @with_unsupported_dtypes({"2.1.1 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def svd(self, some=True, compute_uv=True, *, out=None): return torch_frontend.svd(self, some=some, compute_uv=compute_uv, out=out) @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16", "float32", "float64", "complex")}, + {"2.1.2 and below": ("float16", "bfloat16", "float32", "float64", "complex")}, "torch", ) def gcd(self, other, *, out=None): @@ -1893,7 +1893,7 @@ def gcd(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", "uint16", @@ -1913,7 +1913,7 @@ def char(self): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", "float32", @@ -1930,7 +1930,7 @@ def lcm(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", "float32", @@ -1951,7 +1951,7 @@ def lcm_(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "int8", "uint8", @@ -1968,7 +1968,7 @@ def triu_(self, diagonal=0): return self @with_unsupported_dtypes( - {"2.1.1 and below": ("float16", "bfloat16")}, + {"2.1.2 and below": ("float16", "bfloat16")}, "torch", ) def quantile(self, q, dim=None, keepdim=False, *, interpolation="linear", out=None): @@ -1978,7 +1978,7 @@ def quantile(self, q, dim=None, keepdim=False, *, interpolation="linear", out=No @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "int8", "int16", "uint8", @@ -2010,7 +2010,7 @@ def random_( @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "integer", "unsigned", "bfloat16", @@ -2029,13 +2029,13 @@ def uniform_(self, from_=0, to=1, *, generator=None): ) return self - @with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def frac(self, name=None): return torch_frontend.frac(self._ivy_array) @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -2047,7 +2047,7 @@ def sinc(self): @with_supported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float32", "float64", "bfloat16", @@ -2059,7 +2059,7 @@ def sinc_(self): self.ivy_array = torch_frontend.sinc(self).ivy_array return self - @with_unsupported_dtypes({"2.1.1 and below": ("uint8",)}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": ("uint8",)}, "torch") def index_fill(self, dim, index, value): arr = torch_frontend.moveaxis(self, dim, 0) arr[ivy.to_list(index)] = value @@ -2068,7 +2068,7 @@ def index_fill(self, dim, index, value): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "int8", "uint8", @@ -2091,7 +2091,7 @@ def unique_consecutive(self, return_inverse, return_counts, dim): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "uint16", "uint32", "uint64", @@ -2108,7 +2108,7 @@ def cummax(self, dim): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "int8", "uint8", @@ -2126,7 +2126,7 @@ def triu(self, diagonal=0): return torch_frontend.triu(self, diagonal) @with_unsupported_dtypes( - {"2.1.1 and below": ("bfloat16",)}, + {"2.1.2 and below": ("bfloat16",)}, "torch", ) def xlogy_(self, *, other, out=None): @@ -2135,7 +2135,7 @@ def xlogy_(self, *, other, out=None): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "uint8", "uint32", @@ -2152,7 +2152,7 @@ def ne(self, other): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "uint8", "uint32", @@ -2169,7 +2169,7 @@ def ne_(self, other): @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "bfloat16", "int8", "uint8", @@ -2189,7 +2189,7 @@ def unique(self, sorted=True, return_inverse=False, return_counts=False, dim=Non @with_unsupported_dtypes( { - "2.1.1 and below": ( + "2.1.2 and below": ( "float16", "bfloat16", ) @@ -2199,7 +2199,7 @@ def unique(self, sorted=True, return_inverse=False, return_counts=False, dim=Non def xlogy(self, *, other, out=None): return torch_frontend.xlogy(self, other, out=out) - @with_unsupported_dtypes({"2.1.1 and below": "complex"}, "torch") + @with_unsupported_dtypes({"2.1.2 and below": "complex"}, "torch") def minimum(self, other, *, out=None): return torch_frontend.minimum(self, other=other, out=out) @@ -2207,7 +2207,7 @@ def rad2deg(self, *, out=None): return torch_frontend.rad2deg(self, out=out) @with_supported_dtypes( - {"2.1.1 and below": "valid"}, + {"2.1.2 and below": "valid"}, "torch", ) def corrcoef(self): diff --git a/ivy/functional/frontends/torch/tensor_functions.py b/ivy/functional/frontends/torch/tensor_functions.py index 792e1f2d20c17..34fa5f29d7034 100644 --- a/ivy/functional/frontends/torch/tensor_functions.py +++ b/ivy/functional/frontends/torch/tensor_functions.py @@ -31,7 +31,7 @@ def numel(input): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter(input, dim, index, src): return ivy.put_along_axis(input, index, src, dim, mode="replace") @@ -39,7 +39,7 @@ def scatter(input, dim, index, src): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add(input, dim, index, src): return ivy.put_along_axis(input, index, src, dim, mode="sum") @@ -47,7 +47,7 @@ def scatter_add(input, dim, index, src): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.1 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce(input, dim, index, src, reduce, *, include_self=True): mode_mappings = { diff --git a/ivy/functional/frontends/torch/utilities.py b/ivy/functional/frontends/torch/utilities.py index 4ec08129df43e..48fa393c14410 100644 --- a/ivy/functional/frontends/torch/utilities.py +++ b/ivy/functional/frontends/torch/utilities.py @@ -20,7 +20,7 @@ def _assert(condition, message): # ------------ # -@with_supported_dtypes({"2.1.1 and above": ("int64",)}, "torch") +@with_supported_dtypes({"2.1.2 and above": ("int64",)}, "torch") @to_ivy_arrays_and_back def bincount(x, weights=None, minlength=0): return ivy.bincount(x, weights=weights, minlength=minlength) diff --git a/ivy/functional/frontends/torchvision/ops.py b/ivy/functional/frontends/torchvision/ops.py index 1a4e7fbf49e05..4ef4e86eecf44 100644 --- a/ivy/functional/frontends/torchvision/ops.py +++ b/ivy/functional/frontends/torchvision/ops.py @@ -25,7 +25,7 @@ def box_area(boxes): @with_unsupported_device_and_dtypes( { - "2.1.1 and below": { + "2.1.2 and below": { "cpu": ("float16",), } }, @@ -51,7 +51,7 @@ def remove_small_boxes(boxes, min_size): return ivy.nonzero((w >= min_size) & (h >= min_size))[0] -@with_supported_dtypes({"2.1.1 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def roi_align( input, boxes, output_size, spatial_scale=1.0, sampling_ratio=1, aligned=False From 6edf6d87d4d9192bf0e750dce6608166add950ac Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 19 Dec 2023 15:41:11 +0530 Subject: [PATCH 404/978] fix(ci): updated the docker rmi command in run_tests.py --- scripts/run_tests/run_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index db92381504c32..ac5704b461004 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -240,7 +240,7 @@ # delete pulled image before terminating if device == "gpu": - os.system("docker rmi $(docker images | grep 'unifyai/ivy:latest-gpu')") + os.system("docker rmi unifyai/ivy:latest-gpu") # if any tests fail, the workflow fails if failed: From 6bb0df461b002a75a9df35d3420e06893a5c2c52 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Tue, 19 Dec 2023 13:08:58 +0000 Subject: [PATCH 405/978] Update compiler.py --- ivy/compiler/compiler.py | 40 ++++++++++++++++++++++++---------------- 1 file changed, 24 insertions(+), 16 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index ba5f858ee07d7..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -1,4 +1,4 @@ -from typing import Callable, Optional, List, Union, Iterable, Tuple, Mapping +from typing import Callable, Optional, List, Union, Iterable, Sequence, Mapping def trace_graph( @@ -10,18 +10,18 @@ def trace_graph( include_generators: bool = True, array_caching: bool = True, with_numpy: bool = True, + modes_to_trace: str = "all", backend_compile: bool = False, static_argnums: Optional[Union[int, Iterable[int]]] = None, static_argnames: Optional[Union[str, Iterable[str]]] = None, - mode: Optional[str] = None, + compile_mode: Optional[str] = None, graph_caching: bool = False, - args: Optional[Tuple] = None, + args: Optional[Sequence] = None, kwargs: Optional[Mapping] = None, params_v=None, v=None ): - """Take `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -37,14 +37,17 @@ def trace_graph( include array creation/generation functions as part of the graph array_caching cache the constant arrays that appear as arguments to the functions in the graph + modes_to_trace + the module mode(s) which should be traced when tracing a trainable module + can be either "all", "train" or "eval". backend_compile whether to apply the native compilers, i.e. tf.function, after ivy's tracing static_argnums for jax's jit compilation static_argnames for jax's jit compilation - mode - for torch's compilation + compile_mode + mode for torch's compilation graph_caching whether to cache the traced graph args @@ -88,8 +91,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" + from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -101,10 +104,11 @@ def trace_graph( include_generators=include_generators, array_caching=array_caching, with_numpy=with_numpy, + modes_to_trace=modes_to_trace, backend_compile=backend_compile, static_argnums=static_argnums, static_argnames=static_argnames, - mode=mode, + compile_mode=compile_mode, graph_caching=graph_caching, args=args, kwargs=kwargs, @@ -121,12 +125,13 @@ def transpile( backend_compile: bool = False, static_argnums: Optional[Union[int, Iterable[int]]] = None, static_argnames: Optional[Union[str, Iterable[str]]] = None, - mode: Optional[str] = None, + compile_mode: Optional[str] = None, graph_caching: bool = False, + modes_to_trace: str = "all", stateful: Optional[List] = None, arg_stateful_idxs: Optional[List] = None, kwarg_stateful_idxs: Optional[List] = None, - args: Optional[Tuple] = None, + args: Optional[Sequence] = None, kwargs: Optional[Mapping] = None, params_v=None, v=None @@ -150,8 +155,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" + from ._compiler import transpile as _transpile return _transpile( @@ -162,8 +167,9 @@ def transpile( backend_compile=backend_compile, static_argnums=static_argnums, static_argnames=static_argnames, - mode=mode, + compile_mode=compile_mode, graph_caching=graph_caching, + modes_to_trace=modes_to_trace, stateful=stateful, arg_stateful_idxs=arg_stateful_idxs, kwarg_stateful_idxs=kwarg_stateful_idxs, @@ -178,9 +184,10 @@ def unify( *objs: Callable, source: Optional[str] = None, graph_caching: bool = False, - args: Optional[Tuple] = None, + args: Optional[Sequence] = None, kwargs: Optional[Mapping] = None, with_numpy: bool = True, + modes_to_trace: str = "all", **transpile_kwargs ): from ._compiler import unify as _unify @@ -192,5 +199,6 @@ def unify( args=args, kwargs=kwargs, with_numpy=with_numpy, + modes_to_trace=modes_to_trace, **transpile_kwargs, ) From fa160c096ed6c8bca1af3603985b407ad9181bf0 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 19 Dec 2023 13:10:49 +0000 Subject: [PATCH 406/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..535e749daff4b 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,8 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" - + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -155,8 +156,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" - + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile return _transpile( From a52d921b18162372bb9636f1b1dd299bf14e492e Mon Sep 17 00:00:00 2001 From: NripeshN Date: Tue, 19 Dec 2023 13:22:00 +0000 Subject: [PATCH 407/978] Update compiler.py --- ivy/compiler/compiler.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 535e749daff4b..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" + from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -156,8 +155,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" + from ._compiler import transpile as _transpile return _transpile( From 4809c2a70cfc15b5c910e4b577e5643956faacc9 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 19 Dec 2023 13:23:28 +0000 Subject: [PATCH 408/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/compiler/compiler.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..535e749daff4b 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,8 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" - + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -155,8 +156,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" - + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile return _transpile( From f0ed697556d841060f5b59529e651944890039d3 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Tue, 19 Dec 2023 18:02:27 +0400 Subject: [PATCH 409/978] Update available_configs.json --- available_configs.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/available_configs.json b/available_configs.json index e5d54f88d050d..21eb28357ddc5 100644 --- a/available_configs.json +++ b/available_configs.json @@ -4,7 +4,7 @@ "cp39-cp39-manylinux_2_17_x86_64", "cp310-cp310-manylinux_2_17_x86_64", "cp311-cp311-manylinux_2_17_x86_64", - "cp310-cp310-macosx_arm64_darwin", - "cp311-cp311-macosx_arm64_darwin" + "cp310-cp310-macosx_12_0_arm64", + "cp311-cp311-macosx_12_0_arm64" ] } From 55e0176ff41951aa7dbba9e7f8b5ad052bfc0ebd Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Tue, 19 Dec 2023 20:37:34 +0400 Subject: [PATCH 410/978] Update available_configs.json and binaries.json (#27776) --- binaries.json | 7 ++++++- ivy/utils/binaries.py | 17 +---------------- 2 files changed, 7 insertions(+), 17 deletions(-) diff --git a/binaries.json b/binaries.json index 697738c67c50a..8f31596c7a3a7 100644 --- a/binaries.json +++ b/binaries.json @@ -40,8 +40,11 @@ "LX.so", "L.so", + "MC.so", + "MD.so", "MI.so", "ML.so", + "MM.so", "MV.so", "MX.so", "M.so", @@ -62,7 +65,9 @@ "XM.so", "XV.so", "XX.so", - "X.so" + "X.so", + + "IIC.so" ] } ] diff --git a/ivy/utils/binaries.py b/ivy/utils/binaries.py index e1bb99da3c4fb..5f050892f2044 100644 --- a/ivy/utils/binaries.py +++ b/ivy/utils/binaries.py @@ -75,22 +75,7 @@ def cleanup_and_fetch_binaries(clean=True): print("Cleaning up existing binaries --> done") print("Downloading new binaries...") - # if apple silicon and python version os.sys.version >= 3.10.* and darwin - if ( - "arm64" in os.uname().machine - and os.sys.version_info[:2] >= (3, 10) - and os.uname().sysname == "Darwin" - ): - all_tags = ["cp310-cp310-macosx_arm64_darwin"] - # if apple silicon and python version os.sys.version >= 3.11.* and darwin - elif ( - "arm64" in os.uname().machine - and os.sys.version_info[:2] >= (3, 11) - and os.uname().sysname == "Darwin" - ): - all_tags = ["cp311-cp311-macosx_arm64_darwin"] - else: - all_tags = list(tags.sys_tags()) + all_tags = list(tags.sys_tags()) version = os.environ["VERSION"] if "VERSION" in os.environ else "main" terminate = False From 6ddb9c5c453e3cb6d3b772d0453ea608c4820c1d Mon Sep 17 00:00:00 2001 From: Manik Sheokand <106806012+pixel3user@users.noreply.github.com> Date: Tue, 19 Dec 2023 18:42:20 +0100 Subject: [PATCH 411/978] feat: add segment_sum function to Ivy TensorFlow frontend (#27459) Co-authored-by: manik Co-authored-by: ivy-branch --- ivy/functional/frontends/tensorflow/math.py | 19 +++++++++++ .../test_tensorflow/test_math.py | 33 +++++++++++++++++++ 2 files changed, 52 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index c3a56fa3ec55f..d0d974b5b6f36 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -637,6 +637,25 @@ def scalar_mul(scalar, x, name="scalar_mul"): return ivy.multiply(x, scalar).astype(x.dtype) +@with_unsupported_dtypes( + {"2.15.0 and below": ("float16", "bool", "int16", "int8")}, + "tensorflow", +) +@to_ivy_arrays_and_back +def segment_sum(data, segment_ids, name="segment_sum"): + data = ivy.array(data) + segment_ids = ivy.array(segment_ids) + ivy.utils.assertions.check_equal( + list(segment_ids.shape), [list(data.shape)[0]], as_array=False + ) + sum_array = ivy.zeros( + tuple([int(segment_ids[-1] + 1)] + (list(data.shape))[1:]), dtype=data.dtype + ) + for i in range((segment_ids).shape[0]): + sum_array[segment_ids[i]] = sum_array[segment_ids[i]] + data[i] + return sum_array + + @to_ivy_arrays_and_back def sigmoid(x, name=None): return ivy.sigmoid(x) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py index 90e44c3a4c1e2..1ad9f4d2e1987 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py @@ -2650,6 +2650,39 @@ def test_tensorflow_scalar_mul( ) +@handle_frontend_test( + fn_tree="tensorflow.math.segment_sum", + data=helpers.array_values(dtype=helpers.get_dtypes("valid"), shape=(5, 6)), + segment_ids=helpers.array_values( + dtype=helpers.get_dtypes("signed_integer", prune_function=True), + shape=(5,), + min_value=0, + max_value=4, + ), + test_with_out=st.just(False), +) +def test_tensorflow_segment_sum( + *, + data, + segment_ids, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + helpers.test_frontend_function( + input_dtypes=[str(data.dtype), "int32", "int64"], + frontend=frontend, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + data=data, + segment_ids=np.sort(segment_ids), + ) + + # sigmoid @handle_frontend_test( fn_tree="tensorflow.math.sigmoid", From 083ebb35b5039fa2ed3e7ce98f285c56ec675c49 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 19 Dec 2023 19:31:18 +0000 Subject: [PATCH 412/978] feat: add torch frontend tensor methods index_put and its inplace version along with tests with some todos regarding dtype specification based on https://pytorch.org/docs/stable/generated/torch.Tensor.index_put_.html --- ivy/functional/frontends/torch/tensor.py | 15 +++ .../test_frontends/test_torch/test_tensor.py | 98 +++++++++++++++++++ 2 files changed, 113 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 23a45a28f533d..46f95c5ec0641 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2213,6 +2213,21 @@ def rad2deg(self, *, out=None): def corrcoef(self): return torch_frontend.corrcoef(self) + def index_put(self, indices, values, accumulate=False): + ret = self.clone() + if accumulate: + ret[indices[0]] += values + else: + ret[indices[0]] = values + return ret + + def index_put_(self, indices, values, accumulate=False): + if accumulate: + self[indices] += values + else: + self[indices] = values + return self + # Method aliases absolute, absolute_ = abs, abs_ clip, clip_ = clamp, clamp_ diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index ad382206bb170..ab4c97560d58c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -7692,6 +7692,104 @@ def test_torch_index_fill( ) +# todo: remove dtype specifications +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="index_put", + x_and_indices=helpers.array_indices_axis( + array_dtypes=st.just(("float32",)), + indices_dtypes=st.just(("int64",)), + ), + values=helpers.dtype_and_values( + available_dtypes=st.just(("float32",)), max_num_dims=1, max_dim_size=1 + ), + accumulate=st.booleans(), +) +def test_torch_index_put( + x_and_indices, + values, + accumulate, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x, indices, *_ = x_and_indices + values_dtype, values = values + init_dtypes = [input_dtype[0]] + method_dtypes = [input_dtype[1], values_dtype[0]] + helpers.test_frontend_method( + init_input_dtypes=init_dtypes, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x, + }, + method_input_dtypes=method_dtypes, + method_all_as_kwargs_np={ + "indices": (indices,), + "values": values[0], + "accumulate": accumulate, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="index_put_", + x_and_indices=helpers.array_indices_axis( + array_dtypes=st.just(("float32",)), + indices_dtypes=st.just(("int64",)), + ), + values=helpers.dtype_and_values( + available_dtypes=st.just(("float32",)), max_num_dims=1, max_dim_size=1 + ), + accumulate=st.booleans(), + test_inplace=st.just(True), +) +def test_torch_index_put_( + x_and_indices, + values, + accumulate, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x, indices, *_ = x_and_indices + values_dtype, values = values + init_dtypes = [input_dtype[0]] + method_dtypes = [input_dtype[1], values_dtype[0]] + helpers.test_frontend_method( + init_input_dtypes=init_dtypes, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x, + }, + method_input_dtypes=method_dtypes, + method_all_as_kwargs_np={ + "indices": (indices,), + "values": values[0], + "accumulate": accumulate, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # index_select @handle_frontend_method( class_tree=CLASS_TREE, From 979b519ecc541a3e0f3ff096bb5163324e5eae61 Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Wed, 20 Dec 2023 11:26:16 +0500 Subject: [PATCH 413/978] (fix)(TF backend): optimized the backend implementation of `ivy.linear` for TF backend to make use of `tf.matmul` for the 2D input case (#27733) --- ivy/functional/backends/tensorflow/layers.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 51223de2aec18..8129446f31c38 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -30,7 +30,20 @@ def linear( bias: Optional[Union[tf.Tensor, tf.Variable]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - return tf.einsum("...i,...ji->...j", x, weight) + bias + # TODO: try to generalize this for >=2 dimensions + if len(x.shape) == 2 and len(weight.shape) == 2: + if x.shape[-1] == weight.shape[-2]: + result = tf.matmul(x, weight) + elif x.shape[-1] == weight.shape[-1]: + result = tf.matmul(x, weight, transpose_b=True) + else: + result = tf.einsum("...i,...ji->...j", x, weight) + else: + result = tf.einsum("...i,...ji->...j", x, weight) + + if bias is not None: + return tf.add(result, bias) + return result def _x_dil_before_conv(x, dims, x_dilations, data_format): From 3c6d6afee9812fdca8ee73b5bb10b3c3660e4e49 Mon Sep 17 00:00:00 2001 From: Anudeep Sanapala <71971574+anudeeps0306@users.noreply.github.com> Date: Fri, 22 Dec 2023 13:56:23 +0530 Subject: [PATCH 414/978] feat: implemented invert paddle instance method (#27783) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 3 ++ .../test_paddle/test_tensor/test_tensor.py | 36 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 28af9753bfeb8..8bd38aa24fe26 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -217,6 +217,9 @@ def __float__(self): def __xor__(self, y, /, name=None): return paddle_frontend.logic.bitwise_xor(self, y) + def __invert__(self, out=None, name=None): + return paddle_frontend.logic.bitwise_not(self) + def __len__(self): return len(self._ivy_array) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index cdd2de8a7127b..1ba4e50382149 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -832,6 +832,42 @@ def test_paddle__int__( ) +# invert +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__invert__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + max_num_dims=0, + ), +) +def test_paddle__invert__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + frontend, + on_device, +): + input_dtypes, xs = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtypes, + backend_to_test=backend_fw, + method_input_dtypes=input_dtypes, + init_all_as_kwargs_np={ + "object": xs[0], + }, + method_all_as_kwargs_np={}, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # __len__ @handle_frontend_method( class_tree=CLASS_TREE, From 1111458cf2da49bee0581e71390b8c2f05cab29a Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Fri, 22 Dec 2023 13:41:00 +0000 Subject: [PATCH 415/978] slight reimplementation of gpu lstm to fix multiversion tests (#27785) --- ivy/functional/backends/tensorflow/layers.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 8129446f31c38..a983821bd6a13 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -6,7 +6,6 @@ import tensorflow as tf from tensorflow.python.types.core import Tensor -from keras.src.layers.rnn import gru_lstm_utils # local import ivy @@ -743,6 +742,12 @@ def step(cell_inputs, cell_states): return outputs, new_states +def _format_weights_for_gpu(weights, biases, shape): + weights = [tf.reshape(tf.transpose(x), shape) for x in weights] + biases = [tf.reshape(x, shape) for x in biases] + return tf.concat(weights + biases, axis=0) + + def _gpu_lstm( x, init_h, init_c, kernel, recurrent_kernel, bias, recurrent_bias, time_major ): @@ -755,11 +760,10 @@ def _gpu_lstm( weights = tf.split(kernel, 4, axis=1) weights += tf.split(recurrent_kernel, 4, axis=1) full_bias = tf.concat((recurrent_bias, bias), axis=0) - params = gru_lstm_utils.canonical_to_params( + params = _format_weights_for_gpu( weights=weights, biases=tf.split(full_bias, 8), shape=tf.constant([-1]), - transpose_weights=True, ) outputs, h, c, _ = tf.raw_ops.CudnnRNN( input=x, From c02d5c29adbf3243d674521551cedffc0b488b12 Mon Sep 17 00:00:00 2001 From: Alvin Vinod <63870684+alvin-98@users.noreply.github.com> Date: Sat, 23 Dec 2023 19:43:35 +0530 Subject: [PATCH 416/978] feat: added numpy column stack function and its test (#27777) Co-authored-by: NripeshN --- .../manipulation_routines/joining_arrays.py | 10 ++++++ .../test_joining_arrays.py | 32 +++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/ivy/functional/frontends/numpy/manipulation_routines/joining_arrays.py b/ivy/functional/frontends/numpy/manipulation_routines/joining_arrays.py index f32d7cd46fe2d..7035054cbf14a 100644 --- a/ivy/functional/frontends/numpy/manipulation_routines/joining_arrays.py +++ b/ivy/functional/frontends/numpy/manipulation_routines/joining_arrays.py @@ -10,6 +10,16 @@ import ivy.functional.frontends.numpy as np_frontend +@to_ivy_arrays_and_back +def column_stack(tup): + out_dtype = ivy.dtype(tup[0]) + for i in tup: + out_dtype = ivy.as_ivy_dtype( + np_frontend.promote_numpy_dtypes(i.dtype, out_dtype) + ) + return ivy.column_stack(tup) + + @handle_numpy_out @handle_numpy_dtype @to_ivy_arrays_and_back diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_joining_arrays.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_joining_arrays.py index 3102a5f40bc25..f4164ca35b473 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_joining_arrays.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_manipulation_routines/test_joining_arrays.py @@ -41,6 +41,38 @@ def _arrays_idx_n_dtypes(draw): # ------------ # +# column_stack +@handle_frontend_test( + fn_tree="numpy.column_stack", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + shared_dtype=True, + num_arrays=helpers.ints(min_value=2, max_value=10), + shape=helpers.get_shape( + min_num_dims=1, + ), + ), +) +def test_numpy_column_stack( + dtype_and_x, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + input_dtype, xs = dtype_and_x + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + tup=xs, + ) + + # concat @handle_frontend_test( fn_tree="numpy.concatenate", From 5f58f81dd0f668bf93dcddf90da7dfccdf9c59a8 Mon Sep 17 00:00:00 2001 From: JAYABHARGAVI B <90489745+jayaatgh@users.noreply.github.com> Date: Sat, 23 Dec 2023 20:24:43 +0530 Subject: [PATCH 417/978] feat: Paddle Frontend Implementation of Special method __long__ (#27433) Implementation of Paddle method __long__ --- .../frontends/paddle/tensor/tensor.py | 17 ++++++++ .../test_paddle/test_tensor/test_tensor.py | 40 +++++++++++++++++++ 2 files changed, 57 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 8bd38aa24fe26..09d662d5b3dc6 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -240,6 +240,23 @@ def __rdiv__(self, y, /, name=None): def __int__(self): return int(self._ivy_array) + @with_unsupported_dtypes( + { + "2.5.2 and below": ( + "bool", + "unsigned", + "int8", + "int32", + "int64", + "float16", + "bfloat16", + ) + }, + "paddle", + ) + def __long__(self): + return int(self._ivy_array) + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 1ba4e50382149..87a9e59d7889b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -904,6 +904,46 @@ def test_paddle__len__( ) +# long +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__long__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("integer"), + max_num_dims=0, + min_value=-1e15, + max_value=1e15, + ), +) +def test_paddle__long__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + frontend, + on_device, +): + input_dtypes, xs = dtype_and_x + # Numpy doesn't support complex to int conversion + assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) + helpers.test_frontend_method( + init_input_dtypes=input_dtypes, + backend_to_test=backend_fw, + method_input_dtypes=input_dtypes, + init_all_as_kwargs_np={ + "object": xs[0], + }, + method_all_as_kwargs_np={}, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # __ne__ @handle_frontend_method( class_tree=CLASS_TREE, From b2389e068f59442e711ce07427b3eafd3a89cf1e Mon Sep 17 00:00:00 2001 From: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> Date: Sun, 24 Dec 2023 01:20:31 +0530 Subject: [PATCH 418/978] fixed expm1 method in the PyTorch frontend (#21745) Co-authored-by: NripeshN --- ivy/functional/frontends/torch/tensor.py | 4 ++-- ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 46f95c5ec0641..c825718d8a2e9 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1386,8 +1386,8 @@ def cov(self, /, *, correction=1, fweights=None, aweights=None): def exp(self): return torch_frontend.exp(self) - @with_unsupported_dtypes( - {"2.1.2 and below": ("bfloat16", "float16", "complex")}, "torch" + @with_supported_dtypes( + {"2.1.2 and below": ("bfloat16", "float32", "float64")}, "torch" ) def expm1(self): return torch_frontend.expm1(self) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index ab4c97560d58c..4c525a69e0c52 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -6533,7 +6533,7 @@ def test_torch_expand_as( init_tree="torch.tensor", method_name="expm1", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), ), ) def test_torch_expm1( From 1e528f0d301e8b2a377424fd768d4fedfcffd20e Mon Sep 17 00:00:00 2001 From: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> Date: Sun, 24 Dec 2023 01:28:30 +0530 Subject: [PATCH 419/978] Added logaddexp2 method to the PyTorch frontend (#21804) Co-authored-by: NripeshN --- ivy/functional/frontends/torch/tensor.py | 5 +++ .../test_frontends/test_torch/test_tensor.py | 42 +++++++++++++++++++ 2 files changed, 47 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index c825718d8a2e9..ba131b8fa34d7 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1855,6 +1855,11 @@ def backward(self, gradient=None, retain_graph=None, create_graph=False): def logaddexp(self, other): return torch_frontend.logaddexp(self, other) + @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + def logaddexp2(self, other): + self.ivy_array = torch_frontend.logaddexp2(self, other).ivy_array + return self + def angle(self): return torch_frontend.angle(self) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 4c525a69e0c52..e79b86ece43f4 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -12964,6 +12964,48 @@ def test_torch_tensor_erfc_( ) +# logaddexp2 +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="logaddexp2", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + num_arrays=2, + min_num_dims=1, + min_value=-100, + max_value=100, + shared_dtype=True, + ), +) +def test_torch_tensor_logaddexp2( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "other": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # positive @handle_frontend_method( class_tree=CLASS_TREE, From 0953df11c8036e556164c9a52cbca79f5248d292 Mon Sep 17 00:00:00 2001 From: usayrimrehman <80469631+usayrimrehman@users.noreply.github.com> Date: Mon, 25 Dec 2023 12:25:29 +0300 Subject: [PATCH 420/978] feat: implement UnsortedSegmentProd function for Tensorflow Frontend (#27365) Co-authored-by: NripeshN --- .../frontends/tensorflow/raw_ops.py | 33 ++++++++++ .../test_tensorflow/test_raw_ops.py | 62 +++++++++++++++++++ 2 files changed, 95 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/raw_ops.py b/ivy/functional/frontends/tensorflow/raw_ops.py index 50ea03ed0cd3d..1db6e68e803af 100644 --- a/ivy/functional/frontends/tensorflow/raw_ops.py +++ b/ivy/functional/frontends/tensorflow/raw_ops.py @@ -853,6 +853,39 @@ def Unpack(*, value, num, axis=0, name="Unpack"): return ivy.unstack(value, axis=axis)[:num] +@with_supported_dtypes( + { + "2.15.0 and below": ( + "int8", + "int16", + "int32", + "int64", + "float32", + "float64", + "complex64", + "complex128", + ) + }, + "tensorflow", +) +@to_ivy_arrays_and_back +def UnsortedSegmentProd(*, data, segment_ids, num_segments, name=None): + data = ivy.array(data) + segment_ids = ivy.array(segment_ids) + + ivy.utils.assertions.check_equal( + list(segment_ids.shape), [list(data.shape)[0]], as_array=False + ) + ivy.utils.assertions.check_greater(int(num_segments), int(ivy.max(segment_ids))) + + shape = list(ivy.shape(data)) + shape[0] = int(num_segments) + x = ivy.ones(shape, dtype=data.dtype) + for i in range((segment_ids).shape[0]): + x[segment_ids[i]] = ivy.multiply(x[segment_ids[i]], data[i]) + return x + + @to_ivy_arrays_and_back def Xdivy(*, x, y, name="Xdivy"): if (x == 0).all(): diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index 44be3315bf271..cb35f859a3cbe 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -265,6 +265,40 @@ def _reshape_helper(draw): return x, dtype, reshape_shape +@st.composite +def _segment_ops_helper(draw): + shape_x = draw(st.integers(min_value=3, max_value=100)) + shape_y = draw(st.integers(min_value=3, max_value=100)) + max_val = draw(st.integers(min_value=3, max_value=9)) + s_dtype = draw( + st.sampled_from( + [ + "int32", + "int64", + ] + ) + ) + data_dtype, data = draw( + helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=1, + shape=(shape_x, shape_y), + min_value=-max_val, + max_value=max_val, + ) + ) + seg_dtype, segment_ids = draw( + helpers.dtype_and_values( + available_dtypes=[s_dtype], + num_arrays=1, + shape=(shape_x,), + min_value=0, + max_value=max_val, + ) + ) + return data_dtype + seg_dtype, data, segment_ids, max_val + + @st.composite def _squeeze_helper(draw): shape = draw(st.shared(helpers.get_shape(), key="value_shape")) @@ -4427,6 +4461,34 @@ def test_tensorflow_Unpack( # NOQA ) +@handle_frontend_test( + fn_tree="tensorflow.raw_ops.UnsortedSegmentProd", + params=_segment_ops_helper(), + test_with_out=st.just(False), +) +def test_tensorflow_UnsortedSegmentProd( + *, + params, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + dtypes, data, segment_ids, max_val = params + helpers.test_frontend_function( + input_dtypes=dtypes, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + data=data[0], + segment_ids=segment_ids[0], + num_segments=max_val + 1, + ) + + @handle_frontend_test( fn_tree="tensorflow.raw_ops.Xdivy", dtype_and_x=helpers.dtype_and_values( From 8959bc8bcdba7ab93fdd5f194747a998c833847e Mon Sep 17 00:00:00 2001 From: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> Date: Mon, 25 Dec 2023 15:05:04 +0530 Subject: [PATCH 421/978] Added flatten method to the Paddle frontend (#22587) --- .../frontends/paddle/tensor/tensor.py | 22 +++++++++ .../test_paddle/test_tensor/test_tensor.py | 47 +++++++++++++++++++ 2 files changed, 69 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 09d662d5b3dc6..8dbd7be953cff 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -939,6 +939,28 @@ def trace(self, offset=0, axis1=0, axis2=1, name=None): ivy.trace(self._ivy_array, offset=offset, axis1=axis1, axis2=axis2) ) + @with_supported_dtypes( + { + "2.5.2 and below": ( + "bfloat16", + "float32", + "float64", + "int8", + "int16", + "int32", + "int64", + "uint8", + ) + }, + "paddle", + ) + def flatten(self, start_axis=0, stop_axis=-1, name=None): + if len(self.shape) == 0: + return self.unsqueeze(axis=0) + return paddle_frontend.Tensor( + ivy.flatten(self.ivy_array, start_dim=start_axis, end_dim=stop_axis) + ) + @with_supported_dtypes( { "2.5.2 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 87a9e59d7889b..87fe048bbc231 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -5574,6 +5574,53 @@ def test_paddle_tensor_expand( ) +# flatten +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="flatten", + dtype_value=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + shape=st.shared(helpers.get_shape(), key="shape"), + ), + axes=helpers.get_axis( + shape=st.shared(helpers.get_shape(), key="shape"), + min_size=2, + max_size=2, + unique=False, + force_tuple=True, + ), +) +def test_paddle_tensor_flatten( + dtype_value, + axes, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_value + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "start_axis": axes[0], + "stop_axis": axes[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # floor_mod @handle_frontend_method( class_tree=CLASS_TREE, From 77a370e123393c940e3ee2013ba811f5e571b7c8 Mon Sep 17 00:00:00 2001 From: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> Date: Mon, 25 Dec 2023 15:07:18 +0530 Subject: [PATCH 422/978] Added reshape_ method to the Paddle frontend (#22493) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 24 ++++++++++++ .../test_paddle/test_tensor/test_tensor.py | 37 +++++++++++++++++++ 2 files changed, 61 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 8dbd7be953cff..2d1008bca3196 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -274,6 +274,30 @@ def reshape(self, *args, shape=None): else: raise ValueError("reshape() got no values for argument 'shape'") + def reshape_(self, *args, shape=None): + if args and shape: + raise TypeError("reshape() got multiple values for argument 'shape'") + if shape is not None: + self.ivy_array = paddle_frontend.reshape( + self._ivy_array, shape=shape + ).ivy_array + return self + if args: + if isinstance(args[0], (tuple, list)): + shape = args[0] + self.ivy_array = paddle_frontend.reshape( + self._ivy_array, shape=shape + ).ivy_array + return self + else: + self.ivy_array = paddle_frontend.reshape( + self._ivy_array, args + ).ivy_array + return self + + self.ivy_array = paddle_frontend.reshape(self._ivy_array).ivy_array + return self + def dim(self): return self.ivy_array.ndim diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 87fe048bbc231..b714f7a936744 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -1103,6 +1103,43 @@ def test_paddle__reshape( ) +# reshape_ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="reshape_", + dtype_x_shape=_reshape_helper(), +) +def test_paddle__reshape_( + dtype_x_shape, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x, shape = dtype_x_shape + assume(len(shape) != 0) + shape = { + "shape": shape, + } + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np=shape, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __rmul__ @handle_frontend_method( class_tree=CLASS_TREE, From 6ef51dff08a113c1968d878d1ec31375bf5e180e Mon Sep 17 00:00:00 2001 From: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> Date: Mon, 25 Dec 2023 15:08:10 +0530 Subject: [PATCH 423/978] Added squeeze method to the Paddle frontend (#22460) Co-authored-by: NripeshN --- .../frontends/paddle/tensor/tensor.py | 11 +++++ .../test_paddle/test_tensor/test_tensor.py | 44 +++++++++++++++++++ 2 files changed, 55 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 2d1008bca3196..22759dcda4b0d 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -518,6 +518,17 @@ def remainder_(self, y, name=None): def cholesky(self, upper=False, name=None): return paddle_frontend.cholesky(self, upper=upper) + @with_unsupported_dtypes( + {"2.5.2 and below": ("float16", "uint16", "int16")}, "paddle" + ) + def squeeze(self, axis=None, name=None): + if isinstance(axis, int) and self.ndim > 0: + if self.shape[axis] > 1: + return self + if len(self.shape) == 0: + return self + return paddle_frontend.squeeze(self, axis=axis) + @with_unsupported_dtypes( {"2.5.2 and below": ("float16", "uint16", "int16")}, "paddle" ) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index b714f7a936744..1c10000a75def 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -5736,6 +5736,50 @@ def test_paddle_tensor_heaviside( ) +# squeeze +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="squeeze", + dtype_value=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + shape=st.shared(helpers.get_shape(), key="shape"), + ), + axis=helpers.get_axis( + shape=st.shared(helpers.get_shape(), key="shape"), + allow_neg=True, + force_int=True, + ), +) +def test_paddle_tensor_squeeze( + dtype_value, + axis, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_value + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "axis": axis, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # tile @handle_frontend_method( class_tree=CLASS_TREE, From eb864fe1f3ea2c7cb95c17e4716f0ee45aa117c3 Mon Sep 17 00:00:00 2001 From: Aaryan562 <82304628+Aaryan562@users.noreply.github.com> Date: Mon, 25 Dec 2023 17:02:16 +0530 Subject: [PATCH 424/978] feat: Add extra arguments to min (#27152) Co-authored-by: Nripesh Niketan --- ivy/data_classes/array/statistical.py | 16 ++- ivy/data_classes/container/statistical.py | 115 ++++++++++++++++-- ivy/functional/backends/jax/statistical.py | 6 +- ivy/functional/backends/numpy/statistical.py | 8 +- ivy/functional/backends/paddle/statistical.py | 17 +++ .../backends/tensorflow/statistical.py | 14 ++- ivy/functional/backends/torch/statistical.py | 19 ++- ivy/functional/ivy/statistical.py | 11 +- .../test_core/test_statistical.py | 27 +++- 9 files changed, 210 insertions(+), 23 deletions(-) diff --git a/ivy/data_classes/array/statistical.py b/ivy/data_classes/array/statistical.py index 53b309c0a78e6..b07294c52696e 100644 --- a/ivy/data_classes/array/statistical.py +++ b/ivy/data_classes/array/statistical.py @@ -15,6 +15,8 @@ def min( *, axis: Optional[Union[int, Sequence[int]]] = None, keepdims: bool = False, + initial: Optional[Union[int, float, complex]] = None, + where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: """Calculate the minimum value of the input array ``x``. @@ -36,6 +38,11 @@ def min( array (see :ref:`broadcasting`). Otherwise, if ``False``, the reduced axes (dimensions) must not be included in the result. Default: ``False``. + initial + The maximum value of an output element. + Must be present to allow computation on empty slice. + where + Elements to compare for minimum out optional output array, for writing the result to. @@ -68,7 +75,14 @@ def min( >>> print(y) ivy.array(0.1) """ - return ivy.min(self._data, axis=axis, keepdims=keepdims, out=out) + return ivy.min( + self._data, + axis=axis, + keepdims=keepdims, + initial=initial, + where=where, + out=out, + ) def max( self: ivy.Array, diff --git a/ivy/data_classes/container/statistical.py b/ivy/data_classes/container/statistical.py index 77ccb6ac0fd23..4e0bb92faf900 100644 --- a/ivy/data_classes/container/statistical.py +++ b/ivy/data_classes/container/statistical.py @@ -9,12 +9,100 @@ class _ContainerWithStatistical(ContainerBase): + @staticmethod + def _static_min( + x: ivy.Container, + /, + *, + axis: Optional[Union[int, Sequence[int], ivy.Container]] = None, + keepdims: Union[bool, ivy.Container] = False, + initial: Optional[Union[int, float, complex, ivy.Container]] = None, + where: Optional[Union[ivy.Array, ivy.Container]] = None, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + out: Optional[ivy.Container] = None, + ): + """ + ivy.Container static method variant of ivy.min. This method simply wraps the + function, and so the docstring for ivy.min also applies to this method with + minimal changes. + + Parameters + ---------- + self + Input container. Should have a real-valued data type. + axis + axis or axes along which minimum values must be computed. + By default, the minimum value must be computed over the + entire array. If a tuple of integers, minimum values must + be computed over multiple axes. Default: ``None``. + keepdims + optional boolean, if ``True``, the reduced axes + (dimensions) must be included in the result as + singleton dimensions, and, accordingly, the result + must be compatible with the input array + (see :ref:`broadcasting`). Otherwise, if ``False``, the + reduced axes (dimensions) must not be included in the + result. Default: ``False``. + initial + The maximum value of an output element. + Must be present to allow computation on empty slice. + where + Elements to compare for minimum + out + optional output array, for writing the result to. + Returns + ------- + ret + if the minimum value was computed over the entire array, + a zero-dimensional array containing the minimum value; + otherwise, a non-zero-dimensional array containing the + minimum values. The returned array must have the same data type + as ``x``. + Examples + -------- + With :class:`ivy.Container` input: + >> > x = ivy.Container(a=ivy.array([1, 2, 3]), \ + b=ivy.array([2, 3, 4])) + >> > z = x.min() + >> > print(z) + { + a: ivy.array(1), + b: ivy.array(2) + } + >>> x = ivy.Container(a=ivy.array([[1, 2, 3],[-1,0,2]]), + ... b=ivy.array([[2, 3, 4], [0, 1, 2]])) + >>> z = x.min(axis=1) + >>> print(z) + { + a:ivy.array([1,-1]), + b:ivy.array([2,0]) + } + """ + return ContainerBase.cont_multi_map_in_function( + "min", + x, + axis=axis, + keepdims=keepdims, + initial=initial, + where=where, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + out=out, + ) + def min( self: ivy.Container, /, *, axis: Optional[Union[int, Sequence[int], ivy.Container]] = None, keepdims: Union[bool, ivy.Container] = False, + initial: Optional[Union[int, float, complex, ivy.Container]] = None, + where: Optional[Union[ivy.Array, ivy.Container]] = None, key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, to_apply: Union[bool, ivy.Container] = True, prune_unapplied: Union[bool, ivy.Container] = False, @@ -42,6 +130,11 @@ def min( (see :ref:`broadcasting`). Otherwise, if ``False``, the reduced axes (dimensions) must not be included in the result. Default: ``False``. + initial + The maximum value of an output element. + Must be present to allow computation on empty slice. + where + Elements to compare for minimum out optional output array, for writing the result to. @@ -76,18 +169,16 @@ def min( b:ivy.array([2,0]) } """ - return self.cont_handle_inplace( - self.cont_map( - lambda x_, _: ( - ivy.min(x_, axis=axis, keepdims=keepdims) - if ivy.is_array(x_) - else x_ - ), - key_chains=key_chains, - to_apply=to_apply, - prune_unapplied=prune_unapplied, - map_sequences=map_sequences, - ), + return self._static_min( + self, + axis=axis, + keepdims=keepdims, + initial=initial, + where=where, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, out=out, ) diff --git a/ivy/functional/backends/jax/statistical.py b/ivy/functional/backends/jax/statistical.py index 3ea7390120149..a0b31da7eca77 100644 --- a/ivy/functional/backends/jax/statistical.py +++ b/ivy/functional/backends/jax/statistical.py @@ -19,10 +19,14 @@ def min( *, axis: Optional[Union[int, Sequence[int]]] = None, keepdims: bool = False, + initial: Optional[Union[int, float, complex]] = None, + where: Optional[JaxArray] = None, out: Optional[JaxArray] = None, ) -> JaxArray: axis = tuple(axis) if isinstance(axis, list) else axis - return jnp.min(a=jnp.asarray(x), axis=axis, keepdims=keepdims) + return jnp.min( + a=jnp.asarray(x), axis=axis, keepdims=keepdims, initial=initial, where=where + ) def max( diff --git a/ivy/functional/backends/numpy/statistical.py b/ivy/functional/backends/numpy/statistical.py index e2028c726d2b5..d4c0f015e7a7d 100644 --- a/ivy/functional/backends/numpy/statistical.py +++ b/ivy/functional/backends/numpy/statistical.py @@ -20,10 +20,16 @@ def min( *, axis: Optional[Union[int, Sequence[int]]] = None, keepdims: bool = False, + initial: Optional[Union[int, float, complex]] = None, + where: Optional[np.ndarray] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: axis = tuple(axis) if isinstance(axis, list) else axis - return np.asarray(np.amin(a=x, axis=axis, keepdims=keepdims, out=out)) + return np.asarray( + np.amin( + a=x, axis=axis, keepdims=keepdims, initial=initial, where=where, out=out + ) + ) min.support_native_out = True diff --git a/ivy/functional/backends/paddle/statistical.py b/ivy/functional/backends/paddle/statistical.py index 9cc49c2733942..3875bdbc2c946 100644 --- a/ivy/functional/backends/paddle/statistical.py +++ b/ivy/functional/backends/paddle/statistical.py @@ -31,6 +31,8 @@ def min( *, axis: Optional[Union[int, Sequence[int]]] = None, keepdims: bool = False, + initial: Optional[Union[int, float, complex]] = None, + where: Optional[paddle.Tensor] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: ret_dtype = x.dtype @@ -39,6 +41,18 @@ def min( imag = paddle.amin(x.imag(), axis=axis, keepdim=keepdims) ret = paddle.complex(real, imag) else: + if where is not None: + max_val = ( + ivy.iinfo(x.dtype).max + if ivy.is_int_dtype(x.dtype) + else ivy.finfo(x.dtype).max + ) + max_val = max_val / 10 + # max_val becomes negative after multiplying with paddle.ones_like(x) + # therefore reduced it + val = paddle.ones_like(x) * max_val + val = val.astype(ret_dtype) + x = paddle.where(where, x, val) ret = paddle.amin(x, axis=axis, keepdim=keepdims) # The following code is to simulate other frameworks # output shapes behaviour since min output dim is 1 in paddle @@ -47,6 +61,9 @@ def min( axis = None if (x.ndim == 1 or axis is None) and not keepdims: ret = ret.squeeze() + if initial is not None: + initial = paddle.to_tensor(initial, dtype=ret_dtype) + ret = paddle.minimum(ret, initial) return ret.astype(ret_dtype) diff --git a/ivy/functional/backends/tensorflow/statistical.py b/ivy/functional/backends/tensorflow/statistical.py index 5fe0d43121805..54c8ad1bcf251 100644 --- a/ivy/functional/backends/tensorflow/statistical.py +++ b/ivy/functional/backends/tensorflow/statistical.py @@ -19,10 +19,22 @@ def min( *, axis: Optional[Union[int, Sequence[int]]] = None, keepdims: bool = False, + initial: Optional[Union[int, float, complex]] = None, + where: Optional[Union[tf.Tensor, tf.Variable]] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: axis = tuple(axis) if isinstance(axis, list) else axis - return tf.math.reduce_min(x, axis=axis, keepdims=keepdims) + if where is not None: + max_val = ( + ivy.iinfo(x.dtype).max + if ivy.is_int_dtype(x.dtype) + else ivy.finfo(x.dtype).max + ) + x = tf.where(where, x, tf.ones_like(x) * max_val) + result = tf.math.reduce_min(x, axis=axis, keepdims=keepdims) + if initial is not None: + result = tf.minimum(result, initial) + return result def max( diff --git a/ivy/functional/backends/torch/statistical.py b/ivy/functional/backends/torch/statistical.py index dfb1b501bdd61..7ec801d192d5d 100644 --- a/ivy/functional/backends/torch/statistical.py +++ b/ivy/functional/backends/torch/statistical.py @@ -21,6 +21,8 @@ def min( *, axis: Optional[Union[int, Sequence[int]]] = None, keepdims: bool = False, + initial: Optional[Union[int, float, complex]] = None, + where: Optional[torch.Tensor] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if axis == (): @@ -28,9 +30,22 @@ def min( return ivy.inplace_update(out, x) else: return x + if where is not None: + max_val = ( + ivy.iinfo(x.dtype).max + if ivy.is_int_dtype(x.dtype) + else ivy.finfo(x.dtype).max + ) + val = torch.ones_like(x) * max_val + val = val.type(x.dtype) + x = torch.where(where, x, val) if not keepdims and not axis and axis != 0: - return torch.amin(input=x, out=out) - return torch.amin(input=x, dim=axis, keepdim=keepdims, out=out) + result = torch.amin(input=x, out=out) + result = torch.amin(input=x, dim=axis, keepdim=keepdims, out=out) + if initial is not None: + initial = torch.tensor(initial, dtype=x.dtype) + result = torch.minimum(result, initial) + return result min.support_native_out = True diff --git a/ivy/functional/ivy/statistical.py b/ivy/functional/ivy/statistical.py index 59c0cc0ccc303..e6d80c8809c49 100644 --- a/ivy/functional/ivy/statistical.py +++ b/ivy/functional/ivy/statistical.py @@ -48,6 +48,8 @@ def min( *, axis: Optional[Union[int, Sequence[int]]] = None, keepdims: bool = False, + initial: Optional[Union[int, float, complex]] = None, + where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: """Calculate the minimum value of the input array ``x``. @@ -82,6 +84,11 @@ def min( compatible with the input array (see :ref:`broadcasting`). Otherwise, if ``False``, the reduced axes (dimensions) must not be included in the result. Default: ``False``. + initial + The maximum value of an output element. + Must be present to allow computation on empty slice. + where + Elements to compare for minimum out optional output array, for writing the result to. @@ -139,7 +146,9 @@ def min( b: ivy.array(2) } """ - return current_backend(x).min(x, axis=axis, keepdims=keepdims, out=out) + return current_backend(x).min( + x, axis=axis, keepdims=keepdims, initial=initial, where=where, out=out + ) @handle_exceptions diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py index 87b230fdf9649..54fbf5f232ec9 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py @@ -82,7 +82,20 @@ def _statistical_dtype_values(draw, *, function, min_value=None, max_value=None) | helpers.floats(min_value=0, max_value=max_correction - 1) ) return dtype, values, axis, correction - return dtype, values, axis + + if isinstance(axis, tuple): + axis = axis[0] + + where_shape = draw( + helpers.mutually_broadcastable_shapes( + num_shapes=1, base_shape=shape, min_dims=0, max_dims=axis + ) + ) + dtype3, where = draw( + helpers.dtype_and_values(available_dtypes=["bool"], shape=where_shape[0]) + ) + + return dtype, values, axis, dtype3, where # --- Main --- # @@ -259,11 +272,15 @@ def test_mean(*, dtype_and_x, keep_dims, test_flags, backend_fw, fn_name, on_dev fn_tree="functional.ivy.min", dtype_and_x=_statistical_dtype_values(function="min"), keep_dims=st.booleans(), + test_gradients=st.just(False), + initial=st.integers(min_value=-5, max_value=5), ) -def test_min(*, dtype_and_x, keep_dims, test_flags, backend_fw, fn_name, on_device): - input_dtype, x, axis = dtype_and_x +def test_min( + *, dtype_and_x, keep_dims, initial, test_flags, backend_fw, fn_name, on_device +): + input_dtype, x, axis, dtype3, where = dtype_and_x helpers.test_function( - input_dtypes=input_dtype, + input_dtypes=[input_dtype[0], dtype3[0]], test_flags=test_flags, backend_to_test=backend_fw, fn_name=fn_name, @@ -271,6 +288,8 @@ def test_min(*, dtype_and_x, keep_dims, test_flags, backend_fw, fn_name, on_devi x=x[0], axis=axis, keepdims=keep_dims, + initial=initial, + where=where[0], ) From 867eb2b4fd2e717469c368df2f2ab7818e2120dc Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 25 Dec 2023 11:33:50 +0000 Subject: [PATCH 425/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/data_classes/container/statistical.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/ivy/data_classes/container/statistical.py b/ivy/data_classes/container/statistical.py index 4e0bb92faf900..26db9e83fab4b 100644 --- a/ivy/data_classes/container/statistical.py +++ b/ivy/data_classes/container/statistical.py @@ -24,10 +24,9 @@ def _static_min( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.min. This method simply wraps the - function, and so the docstring for ivy.min also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.min. This method simply + wraps the function, and so the docstring for ivy.min also applies to + this method with minimal changes. Parameters ---------- @@ -53,6 +52,7 @@ def _static_min( Elements to compare for minimum out optional output array, for writing the result to. + Returns ------- ret @@ -61,6 +61,7 @@ def _static_min( otherwise, a non-zero-dimensional array containing the minimum values. The returned array must have the same data type as ``x``. + Examples -------- With :class:`ivy.Container` input: From 29ee1620899ea497f338ebb66e62ee22120aac3a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 25 Dec 2023 20:26:23 +0530 Subject: [PATCH 426/978] feat: Replaced `flake8` with `ruff` and removed `setup.cfg` by merging the configurations into `pyproject.toml` (#27779) --- .pre-commit-config.yaml | 17 +++------ ivy/__init__.py | 2 +- .../array/experimental/linear_algebra.py | 8 ++-- ivy/data_classes/container/base.py | 8 ++-- .../factorized_tensor/cp_tensor.py | 6 +-- .../factorized_tensor/parafac2_tensor.py | 2 +- .../factorized_tensor/tt_tensor.py | 10 ++--- ivy/functional/backends/numpy/manipulation.py | 2 +- .../backends/tensorflow/manipulation.py | 2 +- .../frontends/jax/numpy/manipulations.py | 2 +- .../transpose_like_operations.py | 2 +- ivy/functional/ivy/elementwise.py | 4 +- ivy/functional/ivy/experimental/layers.py | 4 +- .../ivy/experimental/linear_algebra.py | 4 +- ivy/functional/ivy/losses.py | 4 +- ivy/utils/backend/handler.py | 4 +- .../test_frontends/test_paddle/test_linalg.py | 4 +- .../test_frontends/test_torch/test_linalg.py | 2 +- .../test_functional/test_core/test_device.py | 2 +- pyproject.toml | 38 +++++++++++++++++-- setup.cfg | 25 ------------ 21 files changed, 76 insertions(+), 76 deletions(-) delete mode 100644 setup.cfg diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 2e231afb1f7a7..2e7f83aff2726 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -6,6 +6,12 @@ repos: - id: trailing-whitespace - id: check-toml - id: end-of-file-fixer + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.1.8 + hooks: + # Run the linter. + - id: ruff + args: [ --fix ] - repo: https://github.com/psf/black-pre-commit-mirror rev: 23.12.0 hooks: @@ -23,21 +29,10 @@ repos: rev: v2.2.1 hooks: - id: autoflake - - repo: https://github.com/pycqa/flake8 - rev: 6.1.0 - hooks: - - id: flake8 - exclude: ^.*__init__.py$ - repo: https://github.com/PyCQA/docformatter rev: v1.7.5 hooks: - id: docformatter - - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.1.8 - hooks: - # Run the linter. - - id: ruff - args: [ --fix ] - repo: https://github.com/unifyai/lint-hook rev: a72ffb17562d919311653d7f593cb537d1245c19 hooks: diff --git a/ivy/__init__.py b/ivy/__init__.py index 54a493d5f7e6e..b7b3ac0a4261a 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -800,7 +800,7 @@ class Node(str): pass # Added for the finally statement try: from .compiler.replace_with import replace_with, transform_function -except: +except: # noqa: E722 pass finally: # Skip framework imports done by Ivy compiler for now diff --git a/ivy/data_classes/array/experimental/linear_algebra.py b/ivy/data_classes/array/experimental/linear_algebra.py index 6156d43f33ee0..09ff0484e31ea 100644 --- a/ivy/data_classes/array/experimental/linear_algebra.py +++ b/ivy/data_classes/array/experimental/linear_algebra.py @@ -323,8 +323,8 @@ def multi_mode_dot( If True, the matrices or vectors in in the list are transposed. For complex tensors, the conjugate transpose is used. out - optional output array, for writing the result to. It must have a shape that the - result can broadcast to. + optional output array, for writing the result to. + It must have a shape that the result can broadcast to. Returns ------- @@ -334,8 +334,8 @@ def multi_mode_dot( Notes ----- If no modes are specified, just assumes there is one matrix or vector per mode and returns: - :math:`\\text{x }\\times_0 \\text{ matrix or vec list[0] }\\times_1 \\cdots \\times_n \\text{ matrix or vec list[n] }` # noqa - """ + :math:`\\text{x }\\times_0 \\text{ matrix or vec list[0] }\\times_1 \\cdots \\times_n \\text{ matrix or vec list[n] }` + """ # noqa: E501 return ivy.multi_mode_dot( self._data, mat_or_vec_list, modes, skip, transpose, out=out ) diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index a265766f69aa2..b782245f53dae 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -1155,7 +1155,7 @@ def cont_from_disk_as_hdf5( ), ) container_dict = {} - if type(h5_obj_or_filepath) is str: + if isinstance(h5_obj_or_filepath, str): h5_obj = h5py.File(h5_obj_or_filepath, "r") else: h5_obj = h5_obj_or_filepath @@ -1238,7 +1238,7 @@ def h5_file_size(h5_obj_or_filepath): "the size of hdf5 files." ), ) - if type(h5_obj_or_filepath) is str: + if isinstance(h5_obj_or_filepath, str): h5_obj = h5py.File(h5_obj_or_filepath, "r") else: h5_obj = h5_obj_or_filepath @@ -1280,7 +1280,7 @@ def shuffle_h5_file(h5_obj_or_filepath, seed_value=0): ) if seed_value is None: seed_value = random.randint(0, 1000) - if type(h5_obj_or_filepath) is str: + if isinstance(h5_obj_or_filepath, str): h5_obj = h5py.File(h5_obj_or_filepath, "a") else: h5_obj = h5_obj_or_filepath @@ -1997,7 +1997,7 @@ def cont_to_disk_as_hdf5( "containers to disk as hdf5 files." ), ) - if type(h5_obj_or_filepath) is str: + if isinstance(h5_obj_or_filepath, str): h5_obj = h5py.File(h5_obj_or_filepath, mode) else: h5_obj = h5_obj_or_filepath diff --git a/ivy/data_classes/factorized_tensor/cp_tensor.py b/ivy/data_classes/factorized_tensor/cp_tensor.py index 7798966181f95..e81c18f929f6e 100644 --- a/ivy/data_classes/factorized_tensor/cp_tensor.py +++ b/ivy/data_classes/factorized_tensor/cp_tensor.py @@ -408,11 +408,11 @@ def cp_lstsq_grad(cp_tensor, tensor, return_loss=False, mask=None): .. math:: - \nabla 0.5 ||\\mathcal{X} - [\\mathbf{w}; \\mathbf{A}, \\mathbf{B}, \\mathbf{C}]||^2 # noqa + \nabla 0.5 ||\\mathcal{X} - [\\mathbf{w}; \\mathbf{A}, \\mathbf{B}, \\mathbf{C}]||^2 where :math:`[\\mathbf{w}; \\mathbf{A}, \\mathbf{B}, \\mathbf{C}]` is the CP decomposition with weights - :math:`\\mathbf{w}` and factor matrices :math:`\\mathbf{A}`, :math:`\\mathbf{B}` and :math:`\\mathbf{C}`. # noqa + :math:`\\mathbf{w}` and factor matrices :math:`\\mathbf{A}`, :math:`\\mathbf{B}` and :math:`\\mathbf{C}`. Note that this does not return the gradient with respect to the weights even if CP is normalized. @@ -444,7 +444,7 @@ def cp_lstsq_grad(cp_tensor, tensor, return_loss=False, mask=None): loss : float Scalar quantity of the loss function corresponding to cp_gradient. Only returned if return_loss = True. - """ + """ # noqa: E501 ivy.CPTensor.validate_cp_tensor(cp_tensor) _, factors = cp_tensor diff --git a/ivy/data_classes/factorized_tensor/parafac2_tensor.py b/ivy/data_classes/factorized_tensor/parafac2_tensor.py index 391467f6fb15f..78d07a91ff6ce 100644 --- a/ivy/data_classes/factorized_tensor/parafac2_tensor.py +++ b/ivy/data_classes/factorized_tensor/parafac2_tensor.py @@ -419,7 +419,7 @@ def parafac2_to_slices(parafac2_tensor, validate=True): weights = None decomposition = weights, (A, B, C), projections - I, _ = A.shape + I, _ = A.shape # noqa: E741 return [ ivy.Parafac2Tensor.parafac2_to_slice(decomposition, i, validate=False) for i in range(I) diff --git a/ivy/data_classes/factorized_tensor/tt_tensor.py b/ivy/data_classes/factorized_tensor/tt_tensor.py index 783fa8e6d6f15..c226155527441 100644 --- a/ivy/data_classes/factorized_tensor/tt_tensor.py +++ b/ivy/data_classes/factorized_tensor/tt_tensor.py @@ -108,7 +108,7 @@ def validate_tt_tensor(tt_tensor): def tt_to_tensor(factors): """Return the full tensor whose TT decomposition is given by 'factors'. - Re-assembles 'factors', which represent a tensor in TT/Matrix-Product-State format # noqa: E501 + Re-assembles 'factors', which represent a tensor in TT/Matrix-Product-State format into the corresponding full tensor Parameters @@ -120,7 +120,7 @@ def tt_to_tensor(factors): ------- output_tensor tensor whose TT/MPS decomposition was given by 'factors' - """ + """ # noqa: E501 if isinstance(factors, (float, int)): return factors @@ -213,8 +213,8 @@ def validate_tt_rank( shape of the tensor to decompose rank way to determine the rank, by default 'same' - if 'same': rank is computed to keep the number of parameters (at most) the same # noqa: E501 - if float, computes a rank so as to keep rank percent of the original number of parameters # noqa: E501 + if 'same': rank is computed to keep the number of parameters (at most) the same + if float, computes a rank so as to keep rank percent of the original number of parameters if int or tuple, just returns rank constant_rank if True, the *same* rank will be chosen for each modes @@ -233,7 +233,7 @@ def validate_tt_rank( ------- rank rank of the decomposition - """ + """ # noqa: E501 if rounding == "ceil": rounding_fn = ivy.ceil elif rounding == "floor": diff --git a/ivy/functional/backends/numpy/manipulation.py b/ivy/functional/backends/numpy/manipulation.py index 0f59794f34ad9..9845a2d2061e5 100644 --- a/ivy/functional/backends/numpy/manipulation.py +++ b/ivy/functional/backends/numpy/manipulation.py @@ -70,7 +70,7 @@ def flip( return x if axis is None: axis = list(range(num_dims)) - if type(axis) is int: + if isinstance(axis, int): axis = [axis] axis = [item + num_dims if item < 0 else item for item in axis] return np.flip(x, axis) diff --git a/ivy/functional/backends/tensorflow/manipulation.py b/ivy/functional/backends/tensorflow/manipulation.py index 9ef86b5bc16bb..e2d6f8f13a2be 100644 --- a/ivy/functional/backends/tensorflow/manipulation.py +++ b/ivy/functional/backends/tensorflow/manipulation.py @@ -85,7 +85,7 @@ def flip( new_axis = list(range(num_dims)) else: new_axis = axis - if type(new_axis) is int: + if isinstance(new_axis, int): new_axis = [new_axis] else: new_axis = new_axis diff --git a/ivy/functional/frontends/jax/numpy/manipulations.py b/ivy/functional/frontends/jax/numpy/manipulations.py index f3f3c1721c546..61fe0fe6279ff 100644 --- a/ivy/functional/frontends/jax/numpy/manipulations.py +++ b/ivy/functional/frontends/jax/numpy/manipulations.py @@ -331,7 +331,7 @@ def transpose(a, axes=None): return a if not axes: axes = list(range(len(a.shape)))[::-1] - if type(axes) is int: + if isinstance(axes, int): axes = [axes] if (len(a.shape) == 0 and not axes) or (len(a.shape) == 1 and axes[0] == 0): return a diff --git a/ivy/functional/frontends/numpy/manipulation_routines/transpose_like_operations.py b/ivy/functional/frontends/numpy/manipulation_routines/transpose_like_operations.py index 696e7bb89c673..ca35eba5eeb30 100644 --- a/ivy/functional/frontends/numpy/manipulation_routines/transpose_like_operations.py +++ b/ivy/functional/frontends/numpy/manipulation_routines/transpose_like_operations.py @@ -32,7 +32,7 @@ def swapaxes(a, axis1, axis2): def transpose(array, /, *, axes=None): if not axes: axes = list(range(len(array.shape)))[::-1] - if type(axes) is int: + if isinstance(axes, int): axes = [axes] if (len(array.shape) == 0 and not axes) or (len(array.shape) == 1 and axes[0] == 0): return array diff --git a/ivy/functional/ivy/elementwise.py b/ivy/functional/ivy/elementwise.py index b4bbe720a143d..7997380dec22b 100644 --- a/ivy/functional/ivy/elementwise.py +++ b/ivy/functional/ivy/elementwise.py @@ -121,7 +121,7 @@ def abs( a: ivy.array([0., 2.6, 3.5]), b: ivy.array([4.5, 5.3, 0., 2.3]) } - """ + """ # noqa: E501 return ivy.current_backend(x).abs(x, out=out) @@ -6109,7 +6109,7 @@ def sqrt( b: ivy.array([[7., 1.], [0., 4.47]]) } - """ + """ # noqa: E501 return ivy.current_backend(x).sqrt(x, out=out) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index f860e166c8d75..c356149a01f3e 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -92,7 +92,7 @@ def max_pool1d( [[16., 17., 18., 19.]]]) >>> x = ivy.arange(0, 24.).reshape((2, 3, 4)) - >>> print(ivy.max_pool1d(x, 2, 2, [(1,0)], data_format="NCW", dilation=2, ceil_mode=True)) # noqa + >>> print(ivy.max_pool1d(x, 2, 2, [(1,0)], data_format="NCW", dilation=2, ceil_mode=True)) ivy.array([[[ 1., 3.], [ 5., 7.], [ 9., 11.]], @@ -100,7 +100,7 @@ def max_pool1d( [[13., 15.], [17., 19.], [21., 23.]]]) - """ + """ # noqa: E501 return ivy.current_backend(x).max_pool1d( x, kernel, diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index 92e92992e53af..dd0685bead55b 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -922,8 +922,8 @@ def multi_mode_dot( Notes ----- If no modes are specified, just assumes there is one matrix or vector per mode and returns: - :math:`\\text{x }\\times_0 \\text{ matrix or vec list[0] }\\times_1 \\cdots \\times_n \\text{ matrix or vec list[n] }` # noqa - """ + :math:`\\text{x }\\times_0 \\text{ matrix or vec list[0] }\\times_1 \\cdots \\times_n \\text{ matrix or vec list[n] }` + """ # noqa: E501 if modes is None: modes = range(len(mat_or_vec_list)) diff --git a/ivy/functional/ivy/losses.py b/ivy/functional/ivy/losses.py index 56bce17a0e5cc..8310df572f06c 100644 --- a/ivy/functional/ivy/losses.py +++ b/ivy/functional/ivy/losses.py @@ -159,7 +159,7 @@ def binary_cross_entropy( >>> x = ivy.array([[0, 1, 1, 0]]) >>> y = ivy.array([[2.6, 6.2, 3.7, 5.3]]) >>> pos_weight = ivy.array([1, 2, 3, 4]) - >>> z = ivy.binary_cross_entropy(x, y, pos_weight=pos_weight, from_logits=True, reduction='sum', axis=1) # noqa: E501 + >>> z = ivy.binary_cross_entropy(x, y, pos_weight=pos_weight, from_logits=True, reduction='sum', axis=1) ivy.array([8.05393649]) >>> x = ivy.array([[0, 1, 1, 0]]) @@ -216,7 +216,7 @@ def binary_cross_entropy( >>> z = ivy.binary_cross_entropy(x, y) >>> print(z) ivy.array([0.223, 0.223, 0.223, 0.223]) - """ + """ # noqa: E501 ivy.utils.assertions.check_elem_in_list(reduction, ["none", "sum", "mean"]) if not (0.0 <= epsilon <= 1.0): diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 702766db6cb79..282d5beb047dc 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -96,7 +96,7 @@ def _determine_backend_from_args(args): >>> x = jnp.array([1]) >>> print(_determine_backend_from_args(x)) # noqa - """ + """ # noqa: E501 arg_type = type(args) if isinstance(args, ivy.Array): args = args.data @@ -175,7 +175,7 @@ def current_backend(*args, **kwargs): >>> x = np.array([2.0]) >>> print(ivy.current_backend(x)) # noqa - """ + """ # noqa: E501 global implicit_backend # if a global backend has been set with # set_backend then this will be returned diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py index 26547bb45a8f6..019bc40ada839 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py @@ -569,7 +569,7 @@ def test_paddle_eig( ret = [ivy.to_numpy(x).astype("float64") for x in ret] frontend_ret = [np.asarray(x, dtype=np.float64) for x in frontend_ret] - l, v = ret + l, v = ret # noqa: E741 front_l, front_v = frontend_ret assert_all_close( @@ -619,7 +619,7 @@ def test_paddle_eigh( ret = [ivy.to_numpy(x).astype("float64") for x in ret] frontend_ret = [np.asarray(x, dtype=np.float64) for x in frontend_ret] - l, v = ret + l, v = ret # noqa: E741 front_l, front_v = frontend_ret assert_all_close( diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 4923c2051c28b..3c8a75dbe9702 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -458,7 +458,7 @@ def test_torch_eig( ret = [ivy.to_numpy(x).astype("float64") for x in ret] frontend_ret = [np.asarray(x, dtype=np.float64) for x in frontend_ret] - l, v = ret + l, v = ret # noqa: E741 front_l, front_v = frontend_ret assert_all_close( diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_device.py b/ivy_tests/test_ivy/test_functional/test_core/test_device.py index 8145e909d85ad..05300aa6cd446 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_device.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_device.py @@ -372,7 +372,7 @@ def test_num_cpu_cores(backend_fw): # using multiprocessing module too because ivy uses psutil as basis. p_cpu_cores = psutil.cpu_count() m_cpu_cores = multiprocessing.cpu_count() - assert type(ivy_backend.num_cpu_cores()) == int + assert isinstance(ivy_backend.num_cpu_cores(), int) assert ivy_backend.num_cpu_cores() == p_cpu_cores assert ivy_backend.num_cpu_cores() == m_cpu_cores diff --git a/pyproject.toml b/pyproject.toml index 23f6dc2c85e4a..deb45218b37d4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,12 +6,41 @@ requires = [ ] build-backend = "setuptools.build_meta" + +[tool.docformatter] +wrap-summaries = 88 +pre-summary-newline = true + + +[tool.autoflake] +in-place = true +remove-all-unused-imports = true +ignore-init-module-imports = true +remove-duplicate-keys = true +remove-unused-variables = true +quiet = true +ignore-pass-after-docstring = true +exclude = ["__init__.py"] + + [tool.ruff] +line-length = 88 target-version = "py38" -select = ["D"] # Enabling Only pydocstyle checks as of now (https://docs.astral.sh/ruff/rules/#pydocstyle-d) +select = [ + # pyflakes + "F", + # pycodestyle + "E", "W", + # pydocstyle + "D" +] + ignore = [ + "E203", # Whitespace-before-punctuation. + "E402", # Module-import-not-at-top-of-file. + "E731", # Do not assign a lambda expression, use a def. "D100", # Missing docstring in public module. "D101", # Missing docstring in public class. "D102", # Missing docstring in public method. @@ -32,6 +61,7 @@ ignore = [ "D417", # Missing argument description in the docstring for argument "X". ] -exclude = [ -'ivy/functional/(frontends|backends)/(?!.*/func_wrapper\.py$).*(?!__init__\.py$)', -] +[tool.ruff.per-file-ignores] +'ivy/functional/(frontends|backends)/(?!.*/func_wrapper\.py$).*(?!__init__\.py$)' = ["D"] +"**/__init__.py" = ["F401","F403","F405","F811","F821", "E501"] +"ivy/functional/frontends/paddle/**" = ["F401", "F403", "F405"] diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index 5f868b342a912..0000000000000 --- a/setup.cfg +++ /dev/null @@ -1,25 +0,0 @@ -[flake8] -max-line-length = 88 -ignore = E203, E402, E731, E704, W503, W504, W291, W293 - -per-file-ignores = - **/__init__.py: F401,F403,F405,F811,F821 - ivy/functional/frontends/paddle/**: F401,F403,F405 - -[autoflake] -in-place = true -remove-all-unused-imports = true -ignore-init-module-imports = true -remove-duplicate-keys = true -remove-unused-variables = true -quiet = true -ignore-pass-after-docstring = true -exclude = __init__.py - -[pydocstyle] -convention = numpy -add-ignore = D100,D101,D102,D103,D104,D105,D106,D107,D400,D205 - -[docformatter] -wrap-summaries = 88 -pre-summary-newline = true From 580db065768266c1bf412c423d6bfbd0f498e13a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 25 Dec 2023 20:42:16 +0530 Subject: [PATCH 427/978] refactor: Replaced `lambda` expressions with `def` functions (#27738) --- ivy/__init__.py | 5 +- ivy/func_wrapper.py | 10 ++-- .../frontends/jax/numpy/statistical.py | 4 +- .../frontends/numpy/func_wrapper.py | 33 ++++++++---- ivy/functional/ivy/experimental/layers.py | 15 ++++-- ivy/utils/assertions.py | 53 +++++++++++++------ 6 files changed, 87 insertions(+), 33 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index b7b3ac0a4261a..14b89bbe65615 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -1213,7 +1213,10 @@ def dynamic_backend_as(value): downcast_dtypes = False upcast_dtypes = False crosscast_dtypes = False -cast_dtypes = lambda: downcast_dtypes and upcast_dtypes and crosscast_dtypes + + +def cast_dtypes(): + return downcast_dtypes and upcast_dtypes and crosscast_dtypes def downcast_data_types(val=True): diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index f008c017fd784..006bd4e8a7e41 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -174,9 +174,13 @@ def try_array_function_override(func, overloaded_args, types, args, kwargs): def _get_first_array(*args, **kwargs): # ToDo: make this more efficient, with function ivy.nested_nth_index_where - array_fn = lambda x: ( - ivy.is_array(x) if not hasattr(x, "_ivy_array") else ivy.is_array(x.ivy_array) - ) + def array_fn(x): + return ( + ivy.is_array(x) + if not hasattr(x, "_ivy_array") + else ivy.is_array(x.ivy_array) + ) + array_fn = array_fn if "array_fn" not in kwargs else kwargs["array_fn"] arr = None if args: diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py index 8c26ec22e3c75..cc2a966b8a9f2 100644 --- a/ivy/functional/frontends/jax/numpy/statistical.py +++ b/ivy/functional/frontends/jax/numpy/statistical.py @@ -404,7 +404,9 @@ def apply_along_axis(func1d, axis, arr, *args, **kwargs): if axis < 0: axis = axis + ndim - func = lambda elem: func1d(elem, *args, **kwargs) + def func(elem): + return func1d(elem, *args, **kwargs) + for i in range(1, ndim - axis): func = ivy.vmap(func, in_axes=i, out_axes=-1) for i in range(axis): diff --git a/ivy/functional/frontends/numpy/func_wrapper.py b/ivy/functional/frontends/numpy/func_wrapper.py index cdfc6aaae6137..91df6184aa626 100644 --- a/ivy/functional/frontends/numpy/func_wrapper.py +++ b/ivy/functional/frontends/numpy/func_wrapper.py @@ -30,7 +30,10 @@ def _assert_array(args, dtype, scalar_check=False, casting="safe"): if ivy.is_bool_dtype(dtype): assert_fn = ivy.is_bool_dtype if ivy.is_int_dtype(dtype): - assert_fn = lambda x: not ivy.is_float_dtype(x) + + def assert_fn(x): # noqa F811 + return not ivy.is_float_dtype(x) + if assert_fn: ivy.utils.assertions.check_all_or_any_fn( *args, @@ -51,13 +54,19 @@ def _assert_no_array(args, dtype, scalar_check=False, none=False): if args: first_arg = args[0] fn_func = ivy.as_ivy_dtype(dtype) if ivy.exists(dtype) else ivy.dtype(first_arg) - assert_fn = lambda x: ivy.dtype(x) == fn_func + + def assert_fn(x): + return ivy.dtype(x) == fn_func + if scalar_check: - assert_fn = lambda x: ( - ivy.dtype(x) == fn_func - if ivy.shape(x) != () - else _casting_no_special_case(ivy.dtype(x), fn_func, none) - ) + + def assert_fn(x): # noqa F811 + return ( + ivy.dtype(x) == fn_func + if ivy.shape(x) != () + else _casting_no_special_case(ivy.dtype(x), fn_func, none) + ) + ivy.utils.assertions.check_all_or_any_fn( *args, fn=assert_fn, @@ -105,9 +114,15 @@ def _assert_scalar(args, dtype): if args and dtype: assert_fn = None if ivy.is_int_dtype(dtype): - assert_fn = lambda x: not isinstance(x, float) + + def assert_fn(x): # noqa F811 + return not isinstance(x, float) + elif ivy.is_bool_dtype(dtype): - assert_fn = lambda x: isinstance(x, bool) + + def assert_fn(x): + return isinstance(x, bool) + if assert_fn: ivy.utils.assertions.check_all_or_any_fn( *args, diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index c356149a01f3e..4feb56a7c788f 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1689,11 +1689,20 @@ def area_interpolate(x, dims, size, scale): def get_interpolate_kernel(mode): kernel_func = _triangle_kernel if mode == "tf_bicubic": - kernel_func = lambda inputs: _cubic_kernel(inputs) + + def kernel_func(inputs): # noqa F811 + return _cubic_kernel(inputs) + elif mode == "lanczos3": - kernel_func = lambda inputs: _lanczos_kernel(3, inputs) + + def kernel_func(inputs): + return _lanczos_kernel(3, inputs) + elif mode == "lanczos5": - kernel_func = lambda inputs: _lanczos_kernel(5, inputs) + + def kernel_func(inputs): + return _lanczos_kernel(5, inputs) + return kernel_func diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index 2d5e5a87960cd..952d2be8f8303 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -22,13 +22,19 @@ def _broadcast_inputs(x1, x2): def check_less(x1, x2, allow_equal=False, message="", as_array=True): - comp_fn = lambda x1, x2: (ivy.any(x1 > x2), ivy.any(x1 >= x2)) + def comp_fn(x1, x2): + return ivy.any(x1 > x2), ivy.any(x1 >= x2) + if not as_array: - iter_comp_fn = lambda x1_, x2_: ( - any(x1 > x2 for x1, x2 in zip(x1_, x2_)), - any(x1 >= x2 for x1, x2 in zip(x1_, x2_)), - ) - comp_fn = lambda x1, x2: iter_comp_fn(*_broadcast_inputs(x1, x2)) + + def iter_comp_fn(x1_, x2_): + return any(x1 > x2 for x1, x2 in zip(x1_, x2_)), any( + x1 >= x2 for x1, x2 in zip(x1_, x2_) + ) + + def comp_fn(x1, x2): # noqa F811 + return iter_comp_fn(*_broadcast_inputs(x1, x2)) + gt, gt_eq = comp_fn(x1, x2) # less_equal if allow_equal and gt: @@ -42,13 +48,19 @@ def check_less(x1, x2, allow_equal=False, message="", as_array=True): def check_greater(x1, x2, allow_equal=False, message="", as_array=True): - comp_fn = lambda x1, x2: (ivy.any(x1 < x2), ivy.any(x1 <= x2)) + def comp_fn(x1, x2): + return ivy.any(x1 < x2), ivy.any(x1 <= x2) + if not as_array: - iter_comp_fn = lambda x1_, x2_: ( - any(x1 < x2 for x1, x2 in zip(x1_, x2_)), - any(x1 <= x2 for x1, x2 in zip(x1_, x2_)), - ) - comp_fn = lambda x1, x2: iter_comp_fn(*_broadcast_inputs(x1, x2)) + + def iter_comp_fn(x1_, x2_): + return any(x1 < x2 for x1, x2 in zip(x1_, x2_)), any( + x1 <= x2 for x1, x2 in zip(x1_, x2_) + ) + + def comp_fn(x1, x2): # noqa F811 + return iter_comp_fn(*_broadcast_inputs(x1, x2)) + lt, lt_eq = comp_fn(x1, x2) # greater_equal if allow_equal and lt: @@ -63,11 +75,20 @@ def check_greater(x1, x2, allow_equal=False, message="", as_array=True): def check_equal(x1, x2, inverse=False, message="", as_array=True): # not_equal - eq_fn = lambda x1, x2: (x1 == x2 if inverse else x1 != x2) - comp_fn = lambda x1, x2: ivy.any(eq_fn(x1, x2)) + def eq_fn(x1, x2): + return x1 == x2 if inverse else x1 != x2 + + def comp_fn(x1, x2): + return ivy.any(eq_fn(x1, x2)) + if not as_array: - iter_comp_fn = lambda x1_, x2_: any(eq_fn(x1, x2) for x1, x2 in zip(x1_, x2_)) - comp_fn = lambda x1, x2: iter_comp_fn(*_broadcast_inputs(x1, x2)) + + def iter_comp_fn(x1_, x2_): + return any(eq_fn(x1, x2) for x1, x2 in zip(x1_, x2_)) + + def comp_fn(x1, x2): # noqa F811 + return iter_comp_fn(*_broadcast_inputs(x1, x2)) + eq = comp_fn(x1, x2) if inverse and eq: raise ivy.utils.exceptions.IvyException( From 4d12a86844bfbebb91b21bcd7049a1be4447b1fd Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Tue, 26 Dec 2023 07:09:24 +0400 Subject: [PATCH 428/978] feat: Unify X Vaunt (#27422) Co-authored-by: Jeff Simpson --- .gitignore | 1 - .vaunt/badges/badge_01-00.png | Bin 0 -> 133298 bytes .vaunt/badges/badge_01-01.png | Bin 0 -> 157547 bytes .vaunt/badges/badge_01-02.png | Bin 0 -> 160563 bytes .vaunt/badges/badge_01-03.png | Bin 0 -> 120372 bytes .vaunt/badges/badge_01-04.png | Bin 0 -> 153618 bytes .vaunt/badges/badge_02-00.png | Bin 0 -> 136502 bytes .vaunt/badges/badge_02-01.png | Bin 0 -> 167817 bytes .vaunt/badges/badge_02-02.png | Bin 0 -> 147829 bytes .vaunt/badges/badge_02-03.png | Bin 0 -> 99890 bytes .vaunt/badges/badge_02-04.png | Bin 0 -> 159437 bytes .vaunt/badges/badge_03-00.png | Bin 0 -> 146647 bytes .vaunt/badges/badge_03-01.png | Bin 0 -> 168043 bytes .vaunt/badges/badge_03-02.png | Bin 0 -> 157176 bytes .vaunt/badges/badge_03-03.png | Bin 0 -> 126985 bytes .vaunt/badges/badge_03-04.png | Bin 0 -> 165908 bytes .vaunt/badges/badge_04-00.png | Bin 0 -> 161435 bytes .vaunt/badges/badge_04-01.png | Bin 0 -> 209744 bytes .vaunt/badges/badge_04-02.png | Bin 0 -> 170297 bytes .vaunt/badges/badge_04-03.png | Bin 0 -> 131450 bytes .vaunt/badges/badge_04-04.png | Bin 0 -> 182599 bytes .vaunt/badges/badge_05-00.png | Bin 0 -> 131948 bytes .vaunt/badges/badge_05-01.png | Bin 0 -> 159935 bytes .vaunt/badges/badge_05-02.png | Bin 0 -> 137138 bytes .vaunt/badges/badge_05-03.png | Bin 0 -> 112041 bytes .vaunt/badges/badge_05-04.png | Bin 0 -> 155769 bytes .vaunt/badges/badge_06-00.png | Bin 0 -> 147454 bytes .vaunt/badges/badge_06-01.png | Bin 0 -> 169523 bytes .vaunt/badges/badge_06-02.png | Bin 0 -> 148525 bytes .vaunt/badges/badge_06-03.png | Bin 0 -> 123277 bytes .vaunt/badges/badge_06-04.png | Bin 0 -> 167564 bytes .vaunt/config.yaml | 202 ++++++++++++++++++++++++++++++++++ 32 files changed, 202 insertions(+), 1 deletion(-) create mode 100644 .vaunt/badges/badge_01-00.png create mode 100644 .vaunt/badges/badge_01-01.png create mode 100644 .vaunt/badges/badge_01-02.png create mode 100644 .vaunt/badges/badge_01-03.png create mode 100644 .vaunt/badges/badge_01-04.png create mode 100644 .vaunt/badges/badge_02-00.png create mode 100644 .vaunt/badges/badge_02-01.png create mode 100644 .vaunt/badges/badge_02-02.png create mode 100644 .vaunt/badges/badge_02-03.png create mode 100644 .vaunt/badges/badge_02-04.png create mode 100644 .vaunt/badges/badge_03-00.png create mode 100644 .vaunt/badges/badge_03-01.png create mode 100644 .vaunt/badges/badge_03-02.png create mode 100644 .vaunt/badges/badge_03-03.png create mode 100644 .vaunt/badges/badge_03-04.png create mode 100644 .vaunt/badges/badge_04-00.png create mode 100644 .vaunt/badges/badge_04-01.png create mode 100644 .vaunt/badges/badge_04-02.png create mode 100644 .vaunt/badges/badge_04-03.png create mode 100644 .vaunt/badges/badge_04-04.png create mode 100644 .vaunt/badges/badge_05-00.png create mode 100644 .vaunt/badges/badge_05-01.png create mode 100644 .vaunt/badges/badge_05-02.png create mode 100644 .vaunt/badges/badge_05-03.png create mode 100644 .vaunt/badges/badge_05-04.png create mode 100644 .vaunt/badges/badge_06-00.png create mode 100644 .vaunt/badges/badge_06-01.png create mode 100644 .vaunt/badges/badge_06-02.png create mode 100644 .vaunt/badges/badge_06-03.png create mode 100644 .vaunt/badges/badge_06-04.png create mode 100644 .vaunt/config.yaml diff --git a/.gitignore b/.gitignore index fef9e99694c8c..44004a0156e8c 100644 --- a/.gitignore +++ b/.gitignore @@ -20,7 +20,6 @@ with_time_logs/ *.ods *.jpg *.jpeg -*.png *.gif .hypothesis .array_api_tests_k_flag* diff --git a/.vaunt/badges/badge_01-00.png b/.vaunt/badges/badge_01-00.png new file mode 100644 index 0000000000000000000000000000000000000000..510aac570e088d5700049abbed44190977b72f4c GIT binary patch literal 133298 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

KRG@<1c-V4h~emz)&w- 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¬e;7d^#^q{V%H-H{uH~dePuWCu(?X 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 z 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ℑD z6MdW~mSkZ`4p6Pl7&ryEF8oPl#iZ_^k9<003$qxYLMLc%c?w@Xj)NTa!)D%BRZj5-+2^^Q_nv6Vd1t#`Eq>g+Z~L$w7#~?DRl7t z!HkrqMwyc8R2_Kbp6C)4rL>cpZZxOu2*Y6vim#O^F3wr}sD{g(xsB%bws#w+x0i+$ zLS)6)Hj2=;o{9&%O1-rK^NlySFp$qUH`5OnvfJq7Euew{KefrZcukjegn33>QMB`R zwD77N!bC+&EMasE4IZA1ZjGmvH=ACz=)8>Yqp!2?y^ADy*wQ`9LoV%P>qln$0%0DA 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

{9W+)P^T%di(e^`{SS? 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%0A4Q$w% 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

UPKM1__WTGC#gPfOK{;45Q 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ξ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

  • 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%0D2(4a$?U<2AZ1ce%aL? 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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_01-03.png b/.vaunt/badges/badge_01-03.png new file mode 100644 index 0000000000000000000000000000000000000000..0738e81cafe421ad6a48309fea348d7e05ad3f53 GIT binary patch literal 120372 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

    i)@M+Qypi%X+2zc8+9vBJ^50D?A{ho6> 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�=Z zaxB|3hHv{JOEZl?xUo+}C3{z?PfEB*b*USgYzaTDqz_vz+$Zhq-%H)Q>fEP>XzRK%z2wftigM3dzh}%>G*W?RE_au3#+=xCK1I5g=|Q}4iR75WfSQti z!`GvIrp-@e7meUsGyk`OKTW5eo^_|m-P0!zpNv1<^SomvVa{D|iBlyi65BYrZYU}$ z^4Whp_Ysf}DYtdo+KdFDa7gfbC+ze0+0Q}aD zI0+PGt(_v6+*$&@k_sf)_OiOG!bHE&KryU~bYcf17DRkTk+Blffu=19&gkD{*9$nO z5~V91(GI(wTq?}F2_MkVtT5e53oB2lc6O|65^-cH2+CFHLM^aNps+K(!QT=|#6ma2 z8+-#Bnvs2$#G`)(4v^`3gBM0CprOmtSopMq$d0bo zfg_{#*wbvy5SehlQsDT$dw>7%^r(ah%K3o?!o0mZ$x@={5rbd7ZlP{$On^87t+I!8ZUn0I;z3TF*+SAZ6=ngr9 zq^V@EDX{j_MegmmWFJafJBb&fLIqRWIL#TsJ4MhHjVQ-2sqMG{A{XaXAq5P5XnI8n|+AtJrD z719%yOo|&>Vf>bQu)d)A$_x2;xx<$BJ9sifY)j1+|D-)bkMskjv-S&+@|Fdn!E=i6 z{OE|-=7zG((Xmz!>=#uu=#jvUe6Kz?pJGgygs$|z0AuBicfi|&2H#yZq!GE6*Xf&8nl6ye z+nCIB2yx`=&$VtS{{=fX-34 z?b?*!8|G{O5@~gIj=z$AcH2b2ByCqcD=?6JRg$A!cvusW#2Z5gD)*EeoSxytJvQ>BDnwgO+OGZ7x4f@_G<++(^(J4EJNetg*Bx-hid@MhGjT zWr*pf3xmlw8C8p6%k9eU9r|o(wUl2=wUvSS(`|_}5#Q*de6`z-x>VDd#dsG3?EYOkt6+pt9|kv)`zR zYvSg?>`qHz&Pz4*hWH{*`%%nH3Wb_LX9jy;jzO$&;ZM%f$KTnF&p*;vB-0T$r5IbU zWui*}A4_qrX_{$szC{%REN7^K%q4(G@(10qBlE6-vba zZSbq_Q{z!8%joFri%^VBsL%KcCv*=~q{gxIpLs&oJm7;{%~hG!yvEb#HYse(rvLve zKx}4NrY4v);Nib36d5%QX=4|wT;C0xz`LbQpnV71+3&L&-1B@lb~9bwi&vp|(d>sE zct;|1x6x?E--Tw>0nn2O0XjDFCaqhjz?`o7kXq?b6|23XUpBihD+X51=K@6aN3zq_Q3$NQ(PhJXH9>tzQF%a@$bw^V97(Cb|T9_2wo)G`6sW7bE z0Q6+(#}+IE@rGA^#9wgnt?znLAnVMJOc*~ePgGO+XYoc_WmALiQEme92FyurtoSY` zKfe!O{4C<8Q82W(zZt2tmS82t(fO9j@;r`-B#x1mu)h190_DO26-|(2&<=9{`JW$h zV5DuQKo&}6ax1Pp+>SmQ`254K!6@q7G27aMWSSJQ=?JYTb@(k+;DKv5({mYH(?zw$ z4Wdy!GRV`#oJq{bH>Ky0X$QQL<7}0)3|oryfj)eRx&LP2IhBt z(Xo20^ht_F>_X>N6yO&aNXWh(=hKoQl&z37{O+{a26j9lydT%}Rob0sreCf78^4=& zPsUCNooj8MnDtRy(tAnO=o1@1RJWxk(DjM%Pw82jYBrJc8!&Edqdm~7`PyiOO>y=a zMkL$utMAq3D9RjXtcW-`A((FP$1P6D+pU_j*UzD2@;cb}-w*Kfe(soXB@h3;XJ1@a zdu`lG%c*yd0)!>nd`$zDHR+l^YxL^atUEm$XWIa2w)EY;WmN8xh$jYK-$-VB71{7T z)|c$M6(xMGkKN4ide2FjI3tIm6# zsqL+9tg^r%C~z(!5Be1n6MDK|k?71R)F%Z&eR6K$?l7Rcwd*<-4SYE2LcudpP?e}` z-QQ(+7$%zZsCYYV>U`GI!?8uW zg)L@MFVFg(#ok$#9HW~JE`nXLi;AP2gg*bo%8}<3i%#9vu*ezbz!#jt3>WQieUsBi zgy1&mXmH1%_dS-~hj%l)`g&1o4@0P85|Bd;6UyHx$OZXrc~NhMG1k6Tu+mi6)ZD84 z!}VoGB-!UTwcGaVPY>ipu-tV^ttnQZ%hDUowkwJxUT^w=Y5Dvw2J;tQSA9+Ob##j6 zC7r_*qDCPYyx`wt7eUB6NtEx0IVMJ2l38O`d+~`iOIqx@78b!-$4_c&&B3d+VDVLx z2gOMnlaR4HR&o6q!tKz~;wgvyHc^Cxq#i+ZsxP<(&B}a^x_xZoR3X*_dy@gllC} zl&PiVc%YVFDao*D4xm?QX)hdlfB#F|Dz=7fwDvYp@C`F)+IeZHkj-3%2NQRso|sp^ zIR_(dp|L^1MOM4Huy*_Y`_X-9>e#T)MmKD_CIW_z(&;9cH;zt~*roQ%P``6*I zs5|{A7hS85GBTn1y0C0r4gI@O;odSC>sa`V_uj#O-DntJet)bvNCjpQQ?u-NfhW)` zTr?b*0Q#Wgl!DQBL!`d&#-p!zjh@)ZCTHuTu1=`16cI{Gqr;gkt^eIbNyP0zGdvh3 z`;Z?)|1X*KUA>FT`85tF=fAC>$$3d!@%%9fbWW$_&C_Ld`!kmt6R2W|GA@4E*2$f} z3Ny4rmTA&T!F#Yl9XAOGRldNHR5`$%Y{FUvnca*1lz#xXgBdiVNItU{C zLRvCHtQy2K=MKzkL~|$$dWt>ei2}afuQ#DoBY$C|`svlEF2GJN2tikWPD2>u-uw4A zfFc9Gw-I6>{Gvb1=8fjQJRTZA8#aFM_koKGN%B04oL@z0!*gN_Dws>=3+U~gUeNpE z?hZWowGf);=u{S#dmWu|v-REV!P_*?mBu5b@PG{Qn7l&~!pj4AGSFRK+5kf!aI;9Y zkPs<2sl4pH`vp$>>9)n2E1;jC>psvsKo;dKx#BC|6WM?{G~-ZS(hB?x1zDWb|s6lxy9j zVLc8~LZnK{Y~b&&>XZmS%+R()M_^Z^#bJ7$+=m+jeqN1IkNY3WhV45UqLMuR$?XFJ3N9?u|ef|Rq&~hEGT>E4IR;P;@b~ZRx*dX zu~Aa<*iR1+3}mKi%r-&hf03w>m?izAzg@xHY_hQuWS0m0CWX|V&-2tm?Inpj$t#UN z9va(JC-*ZLP@suj6VFnlQ^4-PzK@g_(R0%va=8Jk{bkZ-tlCHZk8+V*>_%0@r$;_*V7`)ZLdt!M>Du}}vhQCRUyVsK56*xDVk!AVy?UukH|@97V$I0aIm?4tzwU<~+J;+~{|-CFKqt0* z1}C-bMkZIG5hFYu%EU(EnUB&4v=6w`ZtLob0i=l! z)Lhc^K=`)y%!lR!F2YCpoF6d5p2_8)(9UIV<0daZl^2XE4{ZM1(l9_wi6RtvfODP% z<30?QSQF*|O~Xx^3Gavw8FV$egMZ(-Z6*q5Hct21hx@-u?b}qBSRZv}hlpX_0$dx9 z({js6A5*+&@p{K<6GF?UKRq)#b6sk?XE5uK+w0s*mOhr*u!XFg6Keb{1#5TuCdX!% z^<{c##51q}VBA%+1>63Gd||s6y9>B?*iyE^Bk&}Y{pS2>*}Ub6nsI>SYSCYA$@dSh1RH=&y;d>yi4Mug%QAve)=!71Y&{q?!4bhRD7A zMCO>48JR}f@H5eOb)0yjSjR-3^J`ta|D^x#x=vdbAPXJS*4|cgb>p082wUsyh&`c; zay4$>PRZRIDW^(53lZDQB_X?tc`XzVjbkF^%XK zH0Z0M<&!WnL-vPFj2D4@ZDMxz)v#dNp@y}kEJxl@81U^S2Jz^Rh9nn_7nGG;&ic@9 zeDT%AxXVlLRi_YkMrme}|MKS7?6999=YYO8oG0HOX_(foP%WY=c$xl60xeLl5S7cK z_}g6aPgAg&Cn=kK3<~@!Q7mrQgiAxVXm99J(c;42Od#88^Bejg2F9G#;q%3_MFwuD z4Sl^vo~x&paiaFKWKf&{l`h78=pf$(&;V3rSOFA8XKuuvUhYQ>B6M%?1=-8e1Ot7k z|FzJ-dsa1~1`6$)G~l&Eb`bml5ssX-fm?Eld-Hr(1G`=T=MCBVyMe3*o#>wt4ah)6 zG(oE(Z7`DL*MKD0(IoU5Q0sBy6i`omX-^b7SXEZ)VlDm}Jv2DRwv|D(i*$aHeoEdu zKx|wAh{t|VFwJs;Rh(p>+jwq<+@b)Wm)$NxCaM|;rf#OIBd zN__wBAO6`be1#9{JuPi)o`m4V!UJZi&upzi<$ZQ%MyH}bTy?V_efq8`0OJ+lU6-lK z?m`7O^jx7DiTw_c$oKz>+}BeQxG}0m_D18nKV>PzNg`6#(p6mj`k*AlQ;UFv6tnm! zK%G0zG@!;;UVp)xNxMRwFH*@;&nTQNV*bw-Ch+Pi*@D)QP0b!YQc=5qjLJMfjpq|p zz)ZG3m#jS)Obfp|rZG^#`bmmphaSe$ZoU9%4`pClIADK9S?qd*GE)3*l+B^ZxzX+Rmd!Oe zxCpHwEZfybpYg9alU9rsA6AwtL`j_+9G)Y*#wQb-rAqBPHIRbL5>%?D~-IYQjK6n@rUVA98@L>#!Fi zH~zB}k^5$DyXoRcxKA(I1&XOrQyMt(SP&|&!~E5y7~z4!H(b|A1)lmb>rQ-HCunjc*zF=DG0M}TSk;vxR?cm_ zEOX~-f>Y7dG+(G^*voVY^Lm6TR!-AU3kI7ybt)!UKRbxpjrCUlqLJ}4*P(Q%&DY44 z6C^K=k|N)`?oB%Mm9#GtT&kKrolnNDB?ox@nEPhE^8MAfX+cG?o3S>pVtqi+%~Rp} z)PPA!sB3H zfV;&e3^-dH3F!Xp@gRV=>DNg+ZXqG2O&E^#Z4l;ri7&9Xbc)GV;3e+L>Pk`q&4z|r zd3jR;0q3P6fmJF6WN60no0+Ek1w*B$VB<#m#j>UlzN3>MJKmEQ$jFPM*x}3T0dz0?|K+!&BJ=|FZ<%_`k29%VNtC}82b9(`V=e9@L zvZF5pKX3y6{Ku;CLq57aoDCl03G)b;(Ov3aV#Q0a0cMJPW61wmYc&wri;$UM}HH~Nq(S_lzkfj0gDwN{UQ4GHTVV?Eddt+xQGZP z3`{FPv{JttY8WQkcQqo12-hJm(yI7FWj1mfVu#fqYU2p;3=L;L@+aP~GJ>j7grob@R{Plc;rvtJqZd;M+kJWB%QWR;+ z1~$!xZCIuV&KJF0(%smagSTquPvU9yrAefwE3xbNB0 zhQ}~y7U&Y#tx6l&RCD-H%vFQsZY;Si>W@b~W1woLk2s4h0McBOFHtd z6%{JRMf6?neS?HXOGo4G=>Ld*1OFb)6T(+4baaauxIcq~Fs0g#=;hi<6>~~ubN`jj zb&au?u@OM#Q78OKz5Wgh1uB1_M}b0c-UZvASy`m1+y4pkyNI&>jT7NNIz^qY?o_2a zvvoT~AFMBJIvi2gF2_a#?1k{bdDy)kBOrfMSqjRaOB55XeOSbUtFMA!B3$7cX&MfhOYH!OVyo)1PKg%EH-{b<2&0+us zV*+XAbdDsMar-CP%pbFy7?l(9`66`pKU3%wfB0Tnff#b{BD&f%-+^crcDlN{M6W(T z*`lveXY|iZu3!9gIJ){~ZdkHh-2s+{y|JabwV3r0P&LY`9VmsfyG*c!V&uNx@01CC zFVM{_r2@}{QLeQfNCVL@AHm(4nnWMY%yJy(%D2&CC5eKBaJi=M@`b%^=N!>o#)3G- zB7u3-7>P%MBx|ce&Rz3R`k659w%a^yvLJqJ_h0A|A|evMz*LwRzfcUY!2+(&BES`) zI{GwWmvY+|{quANBQf0{qo}Dw84n+O&&u()S#`TUWSKKq-%t|fU#QY}rs~fY-? zi5m-Fu9}VeRUzE}tGYO8qVCyhdx*u*{pAQ1tmcl}2IyZYudhA_JdM7%v1HxN1UrAS zXG9AdusG1J1y(~SGgY1pQ*tZViwru4soaZ&{r11-JHVv*XR-N5gKvH>V}Qh~1?03j z%nM)1D`j8QXR|>YNc$}DJ6hVg`)i$JCm{@vnNhRr(R!j{p+7p@MwNq6(b|kMj~8V_ z;18)7c+Xd%Qj7@jx430nD5T1bobhX7g*G!#yi0rgRT(0j1%NBwSpZEm*VaCMRls>n zfsHivft6nq$k@DlnJf#%@(3Tf=&Cg5z{DgM3dLdzl>8P$gaM^6r8qjd$o##+3vY5) zZS%cV5zZf$#!g@Mdi%Rj=X24A*c6a|kTnJ6%Zn@5ry<|S_eyiQcm^`VIcPKO&MOIp zn-9DgMbU6a??`3z)LMU2>4xcl--WsPduKVh!k;B!OIq#paf-B3Usso!Fuu6CS(fdS zG~8#XpHzOkD{##IE8H!|a|#F$Ry=~r%9`OX7-Vq%Gn;h}SJs|18V1CbRKgzcnWo+( zxUq6lq~G)_3RE-l^$|S|F^XJ;e(aBoTj!KxT zN$DCI7524nHnia(S!$acSo5|J#UvjK+wJ<#jz{TT>Ixcrn6Y|2us9(|7?F`5+@!t~ zEhLU01gzoUmOeX>ZTKwn%ZK?Z>NBbXU-$fPXMF%cHp1#Dfr>7eVe-@wd5x)Ct(->iPZ) zQsUXFw7|{(E*svZQIWJ(RBz_#HJ`?uibMMW@I&#RmfKKz=j&|!=mKs8KhYx`SeJ&gy~c?~;bzIyq%HbTVytVQFf#wEGew&nJO z1488GgaDO-I29VmK%{d>mmZ-5kX-w?t{H~0EvR+E|3pOe4+AC!z1CE440*89`38h` z;HMYM~iGo2sjQ|t_qNkeL3kWsE`&Q98DsLP~qr> z2W)s8oE@b2ND<2Lk3So!+k6a2P$~Qz4(A;TkqL}x4aGba7hhlUbz?m+5h1cxav3bz zSes4wKB-6}VyuGOq9TBtZn}wz);0uAY_Xy zHP%ngc0$AbevChmk(lfL)_eCPcZ2}v&ld?bs@JB2vGV>c^qbKmdwl3s_Q~Di4TjBk zF}xWO3a~ER$j9*du{0_$=?k>u01IQfbmihI$JxqIk+}+2Ko8x%!7m+~_#Crb*rbmN zdkgr9t7dV*09$Mv_lM6=C`Vk=)s-;73wfFZej9?#?n8z=qEL0|Mg2^DjH*z9K{458 z15bZmPn>F_W=}hH(}?UtH`3kMO_)6!s0gpU<0rE}TB`4?xk$J5#iy<3tMw2yPw73MveGR*|U?AxibS5^M{CCw6nv^R>?ee4L@!S+46h`Z zK!E}pqJg%v)tQxr(JK_5v}=aX?ASZKWUt-`BmDhA@Qj%hI|gjC1ZYRM7#Id!&w|8< zVSX`87V0q;haZt)ZyMGf>2Gdt2@sB`;rG1=RIv(b3e#T0xg}y}HU4#8z1|pvW{udt z4Ipo|_eLU`4fXX3BKZpD=7q3pvJoODq5#|jg)paOW`6H0?%OK@#uILrh0i^Y&>AkI zd?HB1fJsO_m!_ou4HF@oL8#I@+N+!SaO{0bEmu<=bDwkZ|MEShLae7Ba}U%zk5pvK zc!90*g2?Lc^>uc6D9iN$crBpy%V*M`e+dwHyp;8Riy?TKnz)a2yQ!VVX?sNwZWM`L zp4ewTG7!fb{6xI10-n@~S0R3o&|Vu4ToKCE2}Dhy-`#?U(hsU-)7%CacMmY)fM9)L z;Qs4*U&z_zYZPp3{}pi+@Pg84I2m=Z^u>!G>p}gKupCW*O0z5elgP6t0m$C~bbUxk z6*`BHw@UBAHH8v@ohN*3)g(gVEH?M=SfMgbn>TFN;_n;w>C<-2OZ_2|84ZC1NV!aYot`kl#FuU9ix-01@(6JZJOv#bOc{^5?wwWn$3U$g+eJ=;)|-wMO-DbUu;LK z9GkrfYZmKA6PV|;Or3n&DCsr-C7=S2%hk0ZF!~F~%gjfoBKT;A=AV<>c$3YzbT42A zl(cVkcfQVLL~)PbsI>9C=P4WU2>9s%fw92xl+wIr^2y4&(O@?W4yi3cbZm8LO1Ow| zcl(FrE1R2cz3b{D_X#YY@^E2E+;d&?+cJ>*Z7LizO*nX zJ>CFuf zI6}=O~);@kvw|9Mm*r8!tK9Pf_WJdZoVAg#d;brITd6a zw7@(H-B?_We!EzGi|O0wD*;guYA$O=xxFKIxMvLg)uVV5yyNKSW`aZ};40@=i>_84 zeR7QeNxvvp58CVt%HsB9uxfM|mwwq|PkxpigXr=Uh|Z1NC1;sGaUD~+fut%!?s0clOW&uu zt!5Puu3hqN0PF0{GxIM%au&*miLi7%<^jR(owqzw*1G|WtSWfg$ zKn<9ELa+I8T{5vcPnxU|@RcHIKJVET#W50*^ix#-V~eSc{x)5Yu}YGa$;9S=r{}x3 zKgQ+#EEM@3*)r1NlKtZh$)l#_F`bJ0&V6jj39hmncJkPMhd`Vzk(F?ULmx4>pcauv z@4a!YuU8aesc;y92YG|d8Snpb0W^*BF7D7cd$563Aoj&qZBd;2C!01Y#{h=Z!FbNT zm_c1sOfTj0rJ9QeT~vv$N2A9F+OJWZp3YOjds7l5 zO*rK6r<*8!^WomR^?(JbAb=nMNFqbu7Rf0q3nhX`S@r89RUCod%WBd$a0jpO&!S3I zE{QS%6bXxRcrXGfeJ6%9F$XJC2_$72^x^~bg#03y?@^Ht(PtLV*6-uHe&sZo+{(>C(3g$3LO`FI!lc%NG*cp z$iSIcH?ld|OEAyG`QH)ye>vito{*Tg%bL5A&d%i;j;QZpyoFgkukQC;aTO2LIA#_N1d;0QiU?K<^LDNL@CBxiPxmn^ZlX^4b4E_i($2VH_~ZTWLdvIey@11{32ss0`+;mjoshW zXYuFh&QZ~=RBD8qgr?8q5>+Z1G2k zs6j6S0U0EeA(L{G@DPU^c-febeGi7A5#8^)P%>EESaK~2Cz`yS_ z90bu~gFRyxqTvpz?|TvI?txqV@hKaj8BZ^B#}<=T8fbCx#sC^Cy6gWh7v%tDyrxvs!-4SHuV9vydx)vG&%N3I-i~J z9nh+uz1izDm_Jjt6#b^hgb-C!lj~N6gOgD;^>_E*RfNm@xHm=cs^d^tOImEFX{{T! zcs(*r$fhebY>tkJ!d5ct?IckrmkbNIc=h{zTO3)^Q?H$JPn_x}CFzKZ%ezrHyI2vO zgS89XWGUB%76mFb&HnqHcpS`Vd6#&ETOb&rq^{0ISIRVQ<7GIIPb%Ns=ksR^AVt=% zK>rNC=vF64_T|vX*mxR6MUpYJ@6*Mo`Mce5x0&8Ri-KZ9fIvIjehY^90Q5wZE3*yZ ztS;jF71+?kbs#?GyCZ&EWxh1gx!(?8*83ex65ZOy@-@A;!23(>%;^jJk)vGB=;DqCLr!g}0v{=va;X1pvA>W&GkI(m zuz8h!FZEJYQGnaVSO)LK;m-(jQTnDF%Lxnd!+9PDij<|B8<$Xon8+bX24s;&if*K?V;9HY+~{1DW#uv9sQukIiY*mBU=^c?J#DxvoTzA%0)2yx$_<&1&xZrBuMv z%1~zsC%c&v@$>V0$k25inGIPDOt`9216ex`E>5yf$8$j9D~_ruf@gY_r)GOI8^%vf zXifWy&OI$}0@-hOYC;HDdncUCBo zY?5Emdi}x_+(6cc({JaUB`15haaSUaH8oyn9Uo;CG^w(lh?HqJ48U>wnYfFYP)T4f zWM-BW&(Wn+9DyFWh zoGL{b|J}mJDZ1`V#K!C5fu8ukJHU>al6P^McM)StsG~csnWW*wlgleVTXsT_9CH`% zT0s#KJXWkIrXTH5&4LKrN2AF81VGAy=mrfErOJ{;AcAvC8y_!*M$$`X^HUE9iWWMz z2t^F~&t?2F`k4~*0n3hFL-WIjgJV>`MGPuP>Nxz)Wk;n7P>+HAqS(w|UN608V7I6p z5%Hf5Pk7bSa+|X#SBttSWFdDZV&uZVTaF61_tu$$jEzOWg~+?l%!tc8@C^6gAxcZ4 z!sFzP`!`{$v@-w6kuxtB?(G?ClR~RkW*=vGXQPe2Iw;hq6?5FK-~UoN=$FP9ZJDpd zCKnb|eQ$-ElB`7%!O!>KLjS2d|1nIoyqTq6$l8NsV>W_ruS}UQ5kkAx5)T%u8jM;| zDJVR^hjUdm50O8&eV?-b?s!Sae`!WN3R&s%KVM@e3YtlvLIqw-*=hBNY*z4)JxCGZ z+Pim`6VQEDqJaj%G&=_-pK%xx!z+U@*1t%;9BU}6x)%il0p0f|BZ=}P16q5Co|Myb z@Zp^nDITJ!n3@}C&Y@k4Trgc9{rMAx{a{cd^adDk6T^KUKZZi%;bs2CZeMxW`s{H@ zi5q_S0$m}U>_~tmCMK8j@o7)4s!3RPr+|S1sGw4rcFw)HCRid;-SmX$Z|H1Aa5=}5 zW-J{!h*}bk?aHtK|5z1KG{bdhYXLXn;X4?_At!@uOw+h&5-O4Bk{k zbY}_JzqQgaTt1ezm>@FIe{FK9o2R98C2<+Q7}PAF@HWD2!)=wZuEFf9ObQ~)8*+& zHB?mw4bMMs)*6j6#BAe97D%Rji_DCTS!Xd3pu99&zn%b* zSnvOAbLTmwO$*CymKi>&8y$A@4!9E z29{6n*O+gyOL#E5Eqio-3Rw&OAoa2n oNm;PI#mjd(!{?@+0PXSC&27fypxTljP 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ⅈb$#NY0!r>R%fbbSg6Ew92viJDpWS4S`At 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

    &< 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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_02-02.png b/.vaunt/badges/badge_02-02.png new file mode 100644 index 0000000000000000000000000000000000000000..623667665d7fae656225f44a86d9d8cf65c57b3b GIT binary patch literal 147829 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

    LzVMB+PjyX}Bi09CCGHA3qjJO-=1| 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 L>rR=HdFcNEc}|ti literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_01-04.png b/.vaunt/badges/badge_01-04.png new file mode 100644 index 0000000000000000000000000000000000000000..000014f6304ddeb8a5f6580c2aef1ada19e39d3d GIT binary patch literal 153618 zcmeFYcQl-B*Ec+)_Yy5SL9}4B=$#MGW zgs3Bk9woe|T)D3My6)%s*7Lq=ee3}5D2_?@k2xaTp660yAJ|gv$MBVHM{ujiuAApF0%o@9qh%tY(dl@st6FM0wkU5 zjr;2YKqdd1O7jmYkAG4jec-Z4q>Fu>7=Q*na9eLYkhJndi{H(Y#Rj_!fp z4lYhEzP9d0o=6{im~o&NEZ~N-udkP^h={$Pu#1|pDAK@JMOILlL4 zSb)7d5^%Yurt?dq|2+%xmNkmLqSd_!|!m8F6Ru_Q? zO9@}+xcDgKg8)`ylEPxX|F(~{3*6B&vh$ZRz5notzisK{2lKfwfWyVs=Pn2rC%COI z(gzm6h=92}a{W@i!Y>c|>z3=koH(l39_iyA!29pC|Dq82_3Uq-{cW-JD#v-(=)w@2 zyfvBqvk5Mhs4^?THxDmS-PpV0Fe2FX$EN)M)24qp)bDNW5BY90u{w4sIND!D=vE2o zBp+RR6q8-|IP3PrW_=<7~sD}_I|eR<`j~UC<;*sE)Ez3eBdJ>7Kqb|J0u4a;-I1^7=cT4 zIAB~+N(eatu}z#77>0|71I7nIA|nY%e^U}uf$>m2cwP`V4jB9gRoqW^LNG-1-yXu_ zK*)Zwul;73)69PE|BiMzp(fLg2M(^5l)5XUBdHnDhC_A3&oH}`PTit8xB(ioDJ*oE zQVb#{E-EG_3Xu_$k`TLtL&QFn9+=gfPlJjgZHGkR6GEbJworilI5<@JYz1kPY-uEI ziwc$-BeS0_1o$l_m=uuOUX&CpIm=ISLgr|4y*{vho^Tw53{H)tm*V(DI z<#J`a=)yJx(sO!7`%9W}_BrQ2oq~dS3*qCkYjH^`WOFhZdmra+z9Z-xJ9aOL0w+SE z!0`|YKqOX5F!&q~4;P0p0z!7Nrny+-KtK@sixtnsiVQ+RKqN>2#>XebC4z8VT<5@J zgfKve2nd`a$-n?P>EC^Y{eprE?=plwg0_|ZlZRfc2!h`)M+Eu6l_RC#ttW)_f`9^# z9*?$Gvf_3(XL;iA*o&8m^gO2dTN3k-I~TXv@r)q1AO0Tl*jf$5X3(S|4&8o{WrhHjRK-KK=6TTUkp`@S$b4I-AU%_J<`$s z$j1E|9oWXe`29&&Z9(Hq`b z_~La-j5Y#Up4hYPZ>UZk9w7fUI`R3A_8P;wvcyWN^U&>+%dk5=?WEO}{ zQG1;x-74>G&+wJrhxO)Hgr4m9f5?th4O1}k!nKw87F!?csQzjqZSHhR2yl-KEoidFCbhf0kFd%!MTW=-Z)7D z?fNbSAMINveLT2tcG9HEvu+hlj7EPb&@J{r)ec1;-8rBxQm0e3esXWu`8aepFM%{X zpS^%moE=I-dKHoB@xv626Z%uFA!dqt8}Yn;Q!pat{*}vf>r)DE7{V(V1r=3ioRYD( z6uwW~#;ouOt&cr#M6R$Cz>?DW$3A^?nfsI)e*+Xet*(+V6XI$b^j#{j(5h;1HO8UA zaK}&c&^DTJ*1Ex%l+zh5#o4A@WnK6AX6W#~%q6ESil_GOi={oR@2-^*d})flADzinuk5SgC?-t~ zwXbUS5y40}FHdT=tTc7~!9l^YoW-}u&sS(aMG5ph>_mP3s#uITUSYrEp1xz4K`m(J ztISu4P#d1RS;XQd-NU~-P?3pHbuMhWQJ*hcGLHMD^Lw%Ufa=U;t#De2_oKR%Te%8n z6fYbEj*)!aDjTYu_<4@nhS0rRyVte#5;;b%nMwuZlI# zRCjVM`=*)V81B8Z`joM|I)0aKJ?eizCTDT~3cBkm(Ge}xCEQSJt~Q6S_Fqcp6%Stf z)+w z;F}eIZ|0Co7dY|@&xjxd0FYgjMgM}H{}!444qe|SzebIETRG^?2|FpRv}QkJp)~j> zW`g5>MH(y5zd@w`pI8B4j2pz|e-mL;{(K686DRq9fG`&kswn}Wn=eG|;>7HD@(`fr zM_orr#EJd6&;Nv+e{JIazX9<7ti*mHR;YRMt4B?q+2!h2z+sLPA30U$YcC5^>CwE0 z7!7w`KIwy6E$Hx{c-<$j;CDH7>3YvfxTa|H_9N+%rNyL2{BaBikA$exyQWK-o^PPK zcC2JXQE2-1^4ss}5J})GJi{3-N}B#BKEAY*=amNcuLV`czEiW_uxY9=NOLT>R`BJ1 z)zZ%gFCDJNyFYBt4;k?y3E4uwL>jc-IV`8DvsydnGfwzEe&5>pUK zv&X#5mE3GsyP7`>tRECS4}2V1ayzb)M5BN1O%iG)`{blF->2qHUsso__orT(2;w(Q zh413yx!Vj%v|Icg)3$x`)^u@lllP;KzG4c9~N0{XuhR5auUf-oU zvq5tl^ai{qHcs?Kj;*sMuVne-YO_&-8yPCivg35wq78P$lqBtupJ>iHpM2Og{qz#= zIO?<59A3hA&^xQwMx4s4y`2oW8 zSI5; zcM(xO$W;h81b8rNYCAn6_<9VEM#?xZ$mPtgkM{O)0cl+258hQH4&F}}mH4k-0I1mU zG$9%|oS;M7ECduy;r_vLUM60_eP^>TJn7@R(`myrv?@p3z8Ve(cTEskZrg0Za1}2) zfVBsCSlRN3=4jXYX0Pd^T#l(NrvOQNXJEDxWlkUtR30Kg<-zc~@?f?gm7A(vwA$Gv zFEIWvHTrk-y=cOa|ExT?Ae4mBT`1Mu6$)*T^A1EKyUI~mCz ze1A2Mzjq-dBQmmubKLYq!2YBoA|p|=b$0;~_w(>)9tpciYw|-7>hOK>fv{4OzNzCW1bpvORUUln>#27Jb{6!jb+}Aj5S0)d{ul zKkl5&JW7axv8OsZtX&D~v#z#*kKwZ!8u#7+`;7A8%o*Wt616_opVeJ>c5)aN;-F76J`JE?#S=H>0u$_b`ZeO zvOnPz7Y`Ddd_lm07a0fn)${#Dg@X%0K)nB?#KD2U$n4EMksQDflLHPEzFsgN4;SBy zS%I%72ND6}@O5@UaOeV#3I`S!QwA4D7kgkP#{mozVP3u*wurwyV;2a}!#Lc3liND^ zz+k{k(N`E^bs-Ns-ff66#1I8V>HpPIdbzm>0ez}4BGAJY>FfNf$+fq&ma>(!7q^Aj zONon$N=ZPj+d4Ri$^iMw&R*2cUQFCkL>G_&;j3n-`>V^9`tw9U0U`+Dhw%Qn23lO^ z-zC8Xr(bRE-&p->1O9B?P5Fbw^oGtBCG}sib0dZkMwN4}{}%thpx-q4R?Zv;$*FTm zVfi`txB}hdwvXM%?ZcMCjRl87G(T?CwlL2>QB?O6GRhAWe7bc_OzTpTXud~E9TU^b zVQ8kx(!0rn%o3lUciZ7o^h!l{bP9Dc&5!1IU#1=4JUtg63%k67R1_ND?@Qd}3}c$m zHr6Z;O`kKtXIA<=Jx4jEbJl@IJc;ESe{q(4bpy3CBua=QBX{%Oqet=grA)56bb;Qe zUt2via$s0kag@KDRrY2{{oX^$Rg(Kxt!YzAABefj&ZrmKWwdE~sR!)t^hT3y{Tv>) zomwr7UZDm_=x|~`UeV$IoMMj zT1fGro-Xc25tR1Jms;b{H$JSVL3X}lXN9Sd{F-|5-80^g4M|l!BF@x|es)+g4ktOi zeD^!crQ~aR@9@iMr7w4$?qq+E(D!^gXA(wVvskIB)*DkcJS< zy+PBhfH`dJ{N^!EPx#mug%#Q(Z=;~Ap9U<2$Zz{6U0-Jnd1f4^X-@DIK#d{*H4=WK z1{u1^I5=T>lpq25E-^P@;orOl;{MNk`TquL{BCY>X{i3l-oM&bH5Cp`u?w&ey)G&$ zCi53qNQeSU=|92Z|04|hpL*G5cH#DR;(ALh_cOBSXYOF^tpJ`U5sC?A&+G0vOdTZn zMIIfo?q-|@WG7`OzhB&BF;OH(-0>fNehEz%0MpIfA!OWo!}>b1cN^F0laVDGfWquq z2BS=2{n)+9@7+Egd&P%YspM*p_kX;0tx3T%8(qr!eBFKFoI6bHmBfQ$w0Xs-I;RFL zlQA8BAr8)t<+tau$PpRR{1h7dHMa(9Rq$l^J$9?xUS;&uu%QJ-u6VT0pr@+8H=nV` zYERGIysmJnx42W|U;CnsJ;YTee<=KT6C_2U8&}|PMn2W>K@|70M=Pkqz&H9PZ4A%J z^@`PE4V4XRUt5{ijrB$ek&5n9@4cCY!`tXwyl|KV?TX1VCgxc5c98FL^z^hXI&+z= zU2}fu?#B9_~Oh3_u?>9#9270fJWa_pl0= zhRn!ZPfh4z7!SOs`dgp=-@?$}`}9(lc@JZ5U37|;Pba+m!T91gQOv((oL@NQJ-kHt zpmauP=Is|b*j>=W$c*(2pf)aak+$j&*?uwgR1XA`~?cyfNnI4J6T^RwSpydtUN> zC+$?0ot-^yp?-{LK3U_zUAt!A3DYafblxw^SY9T`K@{6zQnjIvM#VSi3wor&Z#eqD zu<>9r?ssBi){LjmGUluKMCYveKvH#jfRzLhvYV@!|2nJVijd$9W5bkJS3YV8n5p0G z$L<^c47vT~<(8D=v9W5h&yJ&%&wLs6tt`LG?>zHghX}#vC)Vs>IZ|`(Esf%rdYEpt zFQMw^OisIHv#$?MA8smJ4W0_$ZEt8?mNTk;o^tpq>K*iEfN_%%O^85l;Au?%>x}GT z!KYLeD5s~r+k%U2>3h$HQ z8_!Kn?NNl;YCqsMFXH$9Q`k5R* z6FkK}vDUxA-y`n*rmBX&g^62MRC9XcPHpqOsS*Ei&o@G2cc<%7e%My0ipW<2f%~xs zn^pM~RD0$O@75D=>ftwc-^PLLZ-3-q*Oln-T*~IYd{5-#q-_By!xuZl!`ZfrSFz@# z9e=!t{m=jZ(ZGK+@E;BQM+5)Sz<)IG9}WCR1OL&$e>Cv_e+?X%gF$|E6FBm%OM(L`Wv)8+0!iBKJ%kZun(;dkg`<`PD7-U4uyS@f$@(gGl!rmfh zd;OjrC!@BWi?NO#AM+a4qfXNYWUo*9h8|=+ju-z_bvLc22<)mSx4lJK5ed18N6BTa z8*5P!|IvubPax^OR(~$(gEH?gWuLlxTC+_nhmcN$@pWs-=KB%?w!CV9rHH+>%z-cR z5;9)=fHREWEP_BBAZ>LO zv-1^IkWiseFW|(=U@DL@q`84F+q!_1Dq=ub^3s@;KsuMp01tsIO@j0Lh!^f0qt9_c zd_=bleGINlohyRS_kF%S+3nb#wq<$7Yfx~*>gIx)CydXY$!7vwWa}!3IoIhxoV~3QTxRUv3tSS~7mz{YDN~S(V zKr535b&#Q6Pho)?_7?%wh+Sz{XVQIPUj=95weTz_=E4+bW5a&>cz7<`7pB)2VcZSW-{1u;lL>+e^j zm1p5gH1pxq$GwR+>^L6ks&nD~oSmQTSO4a9Gt*y4`kZ+VAwj zRPfG|wYLY>&-(jCT7-FPPSa;jD;~FKjOo1NQFj~1UNXQ%PNF0eS&BU4T3JUk{am2_ z!cHRVXT_Y#v(H85z}TkNyrN;O5$m)%hbU>`&KB)Amdn^Jmz3V)R=MKPG=&dmkt_6J z3v!))GDHRirRf06oI2Uo^~W`f%URZG))E^HQKNy#14Rd3^O6C=NZF+?h8yc|>?ATu z+4EHLTM7Ejr$kpt)qz9mr_%E%&o<`aV~yo0DWGK}dszt*(B{pWvU-`(Io8kOBa?@t z{S4vj2@**Mi!P%BxUFUUCCdt(fsh*1&cf*eW7#78Fdxn2tz4Z?di?R@(Jgf{5AuqH zH>b(5YqrAfp_ZRPWnydgtBe6hqHXOBW_MnNCKSDySqzMVv@0ET6`0eYFy}A^G~~3 z9|SRN636gMyd~~bv(WL?vZykyj2ky7)P5`hot*B)J+eY=1}QdpxQi%-bULDqT%XNN zh>efJtCbBj5l?E$f;~O`7a0;oIuASZnb-Qq-eeN`8a%o|*nAe?7(g6u*?j*H^Aw9xu_vh#`hvmeZy>7^``kpp%P;0pq34>gqXbYQF93%-Nnf^qF z?FZP_vSPEU!cv_`VjMZ*neOqL5VRRdXU4QPRR)i2rQ%z`Lw*qRk8K^W9^f{z`kChS zvaQ4;*z?JG)~}=IB@a9*OW?TBcwX}6@pxk_&)Am0HS5}IsYd3nvWzBeBzgP&K(eZ{ zoH?^}SYb$m*pS2HHs#Qf4lnqu>k<*A0D`}uKT*F|+w+_G%Fw8d4vp6V-@Q=mM1&L} zdOh?A!-%bDpKaozv%bcHqEH1%#s)M<(ZQ9PI(b=+x)uzAybdLv1Ib}520GYrzI7H= z>@rDvJFo8T${?lLq!F)j8;))S><+pt!LeB-lc7Fbx}oySGX_WxG*@} z_NYIZYNdD$2BSh zWyNZmswaM*@LL+=giEARk!VM>rqu4lK;Gy;I&dS@(a(iI37{A%DjeD@TGW#&sHc;O z2fvR`G)D}oqLj9agVgBlV`Q@zYG#MNuiWCU8R+sCzsS}zLyiJdFt!y|Ang2}rF@GB z+0M3}WD{b*^Hl;fG0NgfsT6?CI8^%Dp=MCfYrr<50Lx&yE+2Ahyg|Iv0_wL=hx(%L zPeT_ywHG^Km}w)~cmItD;{jJR$@hhfkMj?|1u^2z@2`^V7t3K1H@(AziHicDggq?E6 ze+S?H>_dk=AiO3Zd{P^Q$N8rRuSbvj?hi18iAi-nyE3++3qMdPD$rIoi(87R^5}*0 zw^Ga`dO3--s!_AJJKvC~_~NBAgJ+M^O(7{%s1D7#H-F%S)S6O^9H_XoxJYnIuH;gz zMj#)baAf#Y_0$9tMi1^sh_1{T*F(!;2)ApgUR{0Cx)qE}sFmgJcQ&{6W+O@5g&J8$)(u?2 zyT9CR8kq1IZdGv^x{9-}du6|zjKHbsITxl};M+7lHpH5is8KTZb-va6{E)Tw^XyV^ zfqYU901Zq=l0ZZcL_Iv-qBXtNq4faDE<2Ruxxg-mNugW@WclFxg!rAN+z96K>)}vb z(B&t(xRuwumUd7DG8kg;J#`N14ssP_sLX)C{ac22BTjdYQU!$Lj;>gs3bg&?#u@=1 z6yFw%t=7u^!0E-CDa`ytUYy| zmI&`BUp1eqo)zPOYgxBx7&TRugT!sIxA2t!gX|*xG#pWKE8hs&C7NZkg{wc_f`w2u z^^HQbo8N-Y(g(MG-bX~s2QtZASjbg&Z`;6$HghL4_+Fn zV1ZUbA#$ajGX>4(Zl=6UxnG+EkX}L1_e^M-YF5Pr5Ch&oJXvmo77=`2`lvdIE8FFkgaX22DG!*OjoV2gEiQUb`W9_BKCnRO?W`F^g0Fc*j z=n9>L2Wz_QKRnq4f_Ul*o2gkU+&C)XF;fG>3&wH2^CPWdKkhH!y%Zt~G+IHzd1WIX|?kd<9|96lF787O9*N5R0-lHHqvH z|H(p8WMGw2_I0HBv)Q-cmz}0ELFhGu(Dv=%tnh;mKff=!+`DjaE!Uady}j2DKb_yY z(~f@YNon_#74 zO3WCO{@VJ4p94D7M0N6p6*W9|lp|7&i>cmin8rEy@y$2lq3-B%Z>dnxa0jzOZ7|b) z;KT!3Nx=myT-m!OxMquo809iD5dJ5!Z=2wRzoTQCv5l5x&gq@cC%{tFcRfbw(`|qP*ySu9J$%$~q&1c~3@|ed zusKYR1i0N4xn>qa&2{SOK33w&=*BwsQvi5;~;ui`PKVOZu;hhIc1 z_7Y#;Q_Xjz>+0yrkY^yE7kP}*)4bChr}|T>>O~iB8*dwMfI9w}<6csI4#GU3;>X)h zKXPNb_4Z!uc?4_jc~qA5=lFx+n5TYNmD#!^!u{v*vYZjz+Hd(6HY`R=6IXw0U{Y%9QPJG%ABxW(;TF$+1LI5HS&AH8bJ z=F2OB=lEplM97+C3x39iO-_nSg}HN7NU*sE&o2sg1}n%1MgjFA=nm!CyiUfL$PZhH z*{#Lfj$YXaVoHgP%9bk!n#o(egyBE0e-1g}OODN!6t?vWgf@GARS7*U(pOH+WmgYG zisI~>f;vLNutU(YIxjj_6dY^hAJKaDav2(8x*I5}yP4hO%w{u-*)T#IyC}sXAc23gHiwDs zRO%DlG#Inhb-5`gOri;thS=AvS5&P?-*A0*5hO?BD!<^GnZtYxJRFszJm;0y(+*TF zjFN3VeC)zwLTb&&Z@v7GaBL*i_L-;i-Q8_M>o-%)2X-d~il9?!_5Axm(B`K1(Z?|{ zvS29mVah^9Q0o2NnDrG9(xR{xAFEm@TiMNsh0-;!c(}Q^Bw5z(^!B}c)xv+3a@9!J z%ER-l{E2H1ouYM^S8ZK)T+3CNCPMbp{po_5hA_A*)WY_kBG1wcrtBU;g13Ba;ng z#&~?iSfTW3s@Mjhtv_Bx)YTL%ec+i?IOUMn3j#E>==%9^o$l$l&RJWn!-xLIaB<6Q z&F;=Vo%af{laozuI&TPHKs%ojP-5fc(FS4Y-TkLa8gI+3$uIFmb75FdFo4BL((Bb& zC1MYnhBuc>-zGWDd|!3@F5v=L`%>ll$K3F1<(A&CtDDGY^RMKY&J^wjo$<4OeS&8;hy%B(m1EmjN3wCMQHam)Q9!kjTz~%B-&Wyox?vRsOk1vtuSxJ@PFODf@*_Qd4DRnc$X@>9a{X)_a`vI?7k@X6Ns6 z)8xQ-8Be~fJZ*nU3L1Z}=H@o!D=UvqVFN0n`!`AFYh-D-%_vOK>$UWrhG6WS9md=f zD|F?)vzwcd&SI2_l)`h$f~&FeD1%FlQfF%xKx78L<;55Gt3kj>cAY2LzmFo6y4`Tz z&VE=`QJ_Ijn&3fA7?m|NzypH!RfxJ~j>bR`J_gKe@y3l0Y@-78Lwha?Fz_;ewIzvs z3*}Q1WxBn1DOG)LaB-JjxH&}G0jKJ~e6;gKnMlLmN#tQa?LBp`DjqzXsI$*}$0x;? zSCfir3=UAqU*l!LD!0rzL&lvVeJQj>F;e(z#7kv(({Ug4;$p$ zf8@k(MwAhYP_EKg>ID}*zJ0g(bU*50PnnIDFrrk~M!3)KOUn7rlz@$V`{Z>6bXojy z-dZ5KoY-z^$ko`Gw&Z0UUJqR&^|khN4+EoK;|ACJCQnM0ZIziTUKhNRz#rl6=E-PW z*R<7LH=`i-+9-;;XTIHpeE#am8Qi}B1d zT@moLo@Z2-d#rKLZ<<#2(Ik9&MItY0`eUlp+~kXf1#H(r_%VycWkBFXuWczo(U)CQinCTED#C%h+vJ<%;$)XgMk*K`m_&Pl#jEI#Fma6ckZ_OqO0EgT1HPdWtIlqbf{;to{+c#> zq`S?*M&!|(_Qh)LwXfoNNE5vWiXWTRe)px-4>xlLraRR{c2e1L=F7c4-C`>ucta1x zEDrB*RGV&k^E3&Cwtr8Iit{AI!mP24RMHqbS-fLH*y)i>hTF94teo zEM99}{V0=D0p)!dWAltX5?c={ME2T)vBvo48Pck=i*XEDMh(sTdn_*B%-771DuowJ{-anLWM0Etgi1p1SNJ;61ROTD{@&qr_ zE{C*(VK{c!lhP>W{I-emhr=fC%Zep&W_)WR1mIb;FY!rEC_2xgsEIcsStgH1cp(^K zYt5)swQ!YS9l5C-Rq3D?3YA5hyDlq6mHymC6riK0CLBCEAZ?aKRaBoTk=kcn=;Vqc z@AAeAW5(xTa}Vi}?bXqB_Ha-^-5s`(ddsw7q-VNuKJvNCJWs8Rus`6E{1^8+W!5)kHHpn<6q=N*-5+p0R=1L1bQqxir5++i zwe!deWXgi@qAuaU00${^o3!@r0j3ZpHm9yEsAqGD0z@IwAr1bAd5PzNobs@0d6ZN6 z9g0)GK-kZtn#Dzf8nNoj;B4{34$jV-GJpz@kAdMSfFee&-2b8a_^ z1L}yQ-0+tq@6U?5?s`2`4c#B`$$O4fzh-s-ISpidZ@~5KBk^*vNj~wA%nM?&!5N|m zar4cEGmhx*d7sm9ps{riVc`qkn_}SoyJ7nUP_Bmw>3;As0?a2Tc8>TF#20^O*_mW6 z!l_;s?9w<78Z8i40o^;i@qrbK50MSUf}&dub~vH(G*6ttLxzoSBnaMkK>aV54c`_; z^FH!!4G;ej8#^iQ!zvHU01S|p!&LD2_MP@c0}a^V?T@#y%5N>N3|TO5_NEks5N_mq zACg}s#+cUdb>A0fu<5Fck0bOBjaQ46X}*_lL!r!U0e|tS(fjMdh`5DB+o~!Mu4K|7cz*)*JQGrZmRSdJxgDA>9`MECXLVRsqcN4*zO(dLIb z(CNib@9&h5Bg0=&8rD&9m)&_`+JNg9)mqS}e7ZyoHT^Wm4IaT@W+!Io70z`HGnO!VydRN=?ipr*LnTfErgg!-NB@=AlA zC~>w3C4aouqd0s-wh(MHvn*oXvH75!w_yX_GewW(qPlx2AWoWk=kRi|Pn*xvc53`@#Sk8%5+lx!_#`MvICJyNPBs@=1_0`O{ zq1&R-vT58ucHLA+R&XBrDdwT{%WGeQFY4y_peMWnTS}PSadCLaY1Vg%&7Ft>d>`a< zT>5Op(|Fl4qHpr%GP;z!PN_-NiG+SyK#(}mY=>@D;Ky(VlUedcK+tx`7ygl>JaOopuZ+~9i3 z|8_fNdnh~ve_avF64qUJ8JlHgmV^+I#g*I*S6uCgt9sD;m=XuUd6XzV6sw3difR24 z7XKpuBLzj^_^5RaEd8qpn{gFa!ZRr0rI3#~gh*+Xd@6Qj94*Q7OPYS3-CgbPy5oXo zAKcWgAZ&WKKum6_X2z6ZOW|1UGv>m zge#V3Bk}=EQi00sysRDpj(6TYFmU(weU3|@Jc=_KWthX%VN&qy_*z7e6;c>}JmX^K z)f@eNg-x?FK$e_w`3iIc?l(ZwBmFvWl9R%S2KUR4Gs7xoD}$AaJJ*hB_mt%l$KUJo ztZP#G`?=oQBnVJIx2dtBP(Hjte&+*1k}*=|pBxX$MZvm_a;k6~5j+?oB21 zL!X!+&-Wl%i#CpqhGa%e=p|??-uIPUA>{YqE~lBc+lOs**mSHL*X*sp$+Ne`^@`^T zHP)dli{Ma}UlB1e+=@*}7WPw)XzAe4^Y~Vl{=lP4@O+p2<#)rcZzV=8f4)%pIZEp4 z)x}fdkd*89m~FY#xH@yyXZavAW+$Coo6AN;{q~^MoIVS@x0>T~*)xrXU9|l>F{y_b zw2jfzJG^k}6ImDm4Kb0w7-_ym9venHTGl$tHIP8BZL*}~DJc&u_F`UrS4H@~;5rB0 zwFu)dFj@@s2#fk9|%Uu(~!P)EliB!~- ziY{?!`$=7&%c@tvNNt3i&5JpWO7`!M>&8?vsIlKv4F{JtRTOa1CnPE%_z~%(SC)v@ z@jlQ-zZfN~PzOsYx}z&e@J;w1YBPo^+{(mru0pZBCA?1$%m6lCy>a$0l*8yLd5U9H z`299FL%csAQ><_e?13)X9^J9|E?iK+qG`1873%BI#w2!M>288kc;_7W0SzTq(nRLP z8lud08@m!e**otH%}x~F@r5uHe+;zB>A7~JFt={7Tx|Mw<@0+OG@Vv#8?S@XjEyY*7O4%wt?>sL9%y&aKZf*F5?a3?2B{- z($kI5UTyo2`%J56tYK$cN~3k{GLf{|d{FDwT3V?Y--*?>@oJ{)L-<*3#LEk**TEQB z=cF_EbESe8NkWq|TkgeloKdrx>-i~ClUKby%>ESku_cFLydlZ$f}G9+Dr+N?S`4vjQRHez z_fMVo$FDmBequ|mQLdI$HGCax5sQ-<>!`MVO?m!PjZD2~<0=~fZ&hzHOsg*kr{eYz zBe)*r&O0(hR_bZ+znDmxcLdq=e-BQ3(Nw|#mN*9weF(s8dWF-`k?!F8WGhoTDHHD5Fm z&*rz^>$}uMY}G3Z)sJsgVt<=YftP3--HJV^8XXp8_g3Mi!EmKzzubbJn`X`J#Z1;H z-rtE(yw4=@gZ#4CkoAvu8b8K#;M#Uq2{0mUwe*D@^M$F_XP?qMOiOQ)B3u*br8Mi? zx>>GPPG5hJ)HY%A!D`qF%g>dQU8>9(oqgOTnK;MvbJ(bB2NonpHkfBfBJKDnt1$t1sHkO70Cgqw!0pZ%~7)u+~u1!z|z^3Y6FqZonQ- zRHElVv#$r#ajn8%bt;~PvPh3gY4v}LmBl@p{YvQbYGGo+a{l_DJh7v#g^h63#|bBR zYzst}Tpx@)V8A5^4qlYQl}iaDteQ}8zGQ5otX$+e!h>Rp;dd~4pm1h^ERctJ`^V)$!>b4Fefx{(47s zcnbU32_Zd0uq=$>mq|>Mq~1o7*={a6n&OR+q)K(=5jJjX`3~F#HFS6wVOp{u^cES+ zo~qhB@xxDYJK1KQP|#ZoJtRX5@ZCFO1U>BM4hkk1I_#z@(&rzKW66yiZYqIFX0O{! zPNAaNN34m6z&=r7z+1PpN4e2?GoYxj^YqA|F-;|n>06n5{9{L$K00h_#LLIZDCJIe zU1%B0ge5&XF%-*$Ib?m{UUm*zITe$FEWC&6smx>? zH5?518ZB?%k*Z#ip<%~PDDIn)PAHwPqG(zjSTW@!ixapqbjR&o#~8Z#He3wS;E_Xg zkP%|;Ib)WhC7}TqkWjgvl#svItwdXG-%;r=-V={@$R3ttoQ`By@@8(@+Eh%wokV%j zOY|g36(&s`DY1U~NoHEw;aSl0&c#yNMjh=|pV1}TDGie3$GG{G(MWe$lKFjIhf!(e zAUD1YNQKhJ6|Mc;u6uq@v)+iP%Pa0gfoD*5BoY|dIe4@klvh^iok}B1tWNdcO{3#9 zC@bp5o=INGrcn-4VY`2S7iyMHxFDGO9U7lb+PEIdab#y40HwSQ3fzC)zKUD4 z0L*NI)ti7SN5EN*enSS6XBK$C(7C1YDkVZ5l@dXq_jMqHe%TUlw)*hvw&vLbd#$yn_lm-H8axV=~XiomTuI zAGVDt<=o41D*g}~WE;ue90KPYe);V^m*L#K{wXK@DhNYwYT~D98#YS#mbjE=o48v} zsNWD7;bZg7*71$#)jQ4lJ+9bjhPxbQ?XOd>hvvyNqZ&gi?>y;n+!qj_THCC*IxkYT zY8Xn&B9t4E!SpE094aD9tUnVi*n3=MIm--1G%JE=>6S`fyd@Gk#OtuCw~*d zx)%jm)VNDCCzyAUelOVz421&8Q>vsiri{L_5V1w%u_z4)Cf+i!NVb_jt%{c2&Z<@P ztyWaUxr!chkZYBiNr>Cfyh@Kj2z-2jB*%`(tE&$(IYrCrxg2%?ktS9&>Jc2=`EsE& zd^@g@+=y)?zC0}^P^^Qs^SIx%cC#co&9xx$1_icE=vudjzh&G*7Xudm${Uu+q04Xx z!^~$YpxFxJz4M)^`AH+E$1_OtUMP*SZ&CMxs#MuSI^2~vS^>AS<~MKeGvE+NAlMt7 zRd$!!XG4!mkkU{o^Doaru~Uh$AZLYRtD0`m3!}xCpDDLS%HRhiL~OV>RT_8F>xz7q z=z4&D_{ObwJ`VVp9$kbmln}(TN5G`?gH6_=^(qA>nnxLxJv$u|gTwOcwM=xYYV*e0 z$0i#bw0+}e)rJEJ2cWVKc_lvPAC(EspWnG@+NuMAfzu4WQ7x1~tz zaYxpxH6)X-<_IAMYsIz?EQpY=p8!nk5}+>T4CPe({^;^?mLmC}&yuFk`5watBRS#E}xCvYFR!3cHeV z%i`AT<)vdk3E^wuAWH>PJ$w;qi>@g=+fw6|bU$TsE{~ptL(vA)40B^}=ifU2y%K5q zbZtAJx4h}s^#Wvkhvl`92_Qxz6GaH;2_Wf?Dr2ihUBRX!q^NrxCXArGSIML>jRe(qtFYcUu?^Agfo&<*D=N*uOx|&MAPv9)A6?D3=VaV< z_uD}*-eZ9A=X@x*ocndkxu9=eAM!<(*}4dHN~SI!>y9xO_55iOQAwg9J{Yh?It7s0 zRHlh4&L>%{^G>KZW553T*W$3NtOPQiZ$N7)gLYQyDT;P=QoQ`{hEav;RRX_{U+EcS z#-)KjgNz!{w5xa=atZiE9&#HQRDMQV-)De8vu0mS@27y=CpsRTp;@>|9|t?0C@IaK zrFctCB9Og)t}+RNp~F)u;Pm3^yWNZ%hZM3|L1{vikh=bXRL0nsA{%2%9-~E$1Al}c zGJb{V;LQM#6B2X>;2X)F9@iKHX>qq2h6=RWqv_u>NcN#Vq;-q{+zoM#$k_=H zk#$&!?G|2|57mA5#?y#!-w^~GrMgFD| zWABvBJ~S@}m%E_cKC^}DK?VI>EMC(1pHqaHl%&8Tuobd!1pq|e8;D~l- zqMGbTcycJvHloVYNvXd4VR4?;yOTf;;~{P^F)7llVyVWIth3(04Ra>vEP2WTT>TU9 zVQ9rcD2?Imz&_?tqb|YQd6XAw_nDQ~1>!=8O*QpSX;1HeKe%sPs}=vM>{<#RUgI&U`fPmY# z)+@?3&8$wepLMe@bJZ!XCCHJ@U0_Io3$6zZ{LvZu3Oq~-5MT6-e_uoS<$H*@ab@|Y zP61AGb4iKn9~@n!@DlCR!S6bVH2qsXq5O6Y*=_U#|2?0$76foyHW!r^Aq~NQs%jJM za_70-Ubw@7OW9Mqm&znTK-)7uHwK!X3d<>|sz55M2_?<%s8i%G5WncQ8;WbO-Jj%5h%g1p4VuKl-s@Q*tHuj)g|GqXCCzDnnaX#-t)ywcMQ7OjvXdNGt zcEh{yZbz@2Una2Q_vPb4P(A|a2he!G<}oK}&&h~|>+%cTh(d;aP}|xxO;MZCqSZ{# zZBDL*IP2(89}Z-(>_=&8Pw9=e&XIv?cdEN1RTI}g*TKt*LVSa;6{^b+|VtH(qQ zk{@~x)8AQJ%lWNWKmngnz#U7!#!Pl}BJI+^YU#a3wQaeEhdoVh`N*FpG-2|!(4*pQ zuCv1=)dYv0`i!VzDsC0Y7&@;*8&TJpysS`4D-s<$$khJ z71Ah=OIwjCWF$g*FI;cnm3-EXdh%Taoj=q^Vd3B`$az9FMu4I74I<59WV+UMn%e>C zM&W*>g@xCFVcZ!;fG7%@_p2^#yN(t6RX}|a%4nWx1e)pDn zLsC0VjN&bvKFHDmd}K^QLw(bcfCKrun0vEKMg&bM-8*;XPWB033f!$DhZ2TN+F?(|`~!3c08A zi%MT98s&x}0z}N{NkW9!N81Vy$AmF5UNyckTrAlM7(+vnR67AhWrR{pxO^jK#pgvL zOeFt4kxT@mZB(P(`C3t&oTV^ckuPMPghk2P-U}%$J8btA4=h9yv}-SlQI?q(q=24*`VPezs?&DEocS@T2p0Ob>M( zbc7mZ@_Om&t-mix5l+TNj#^`g&Z{l+yGR->koP{31p(l#Y?4I|scCge z0e`V*EbRj7@|5i;xM5hHg>6dz6g!hyYhsAZPZC|N75T}>(;%E0BG3z*A%TocjKh&s?1cZz^U8q#7z00tqjY#(u$ZHKIsMosI$NH!_VKc ze>*)aq(q@qqbI8Pa%C8u&HIb3=j(J4BM7?Rq+n|AOMvh4i23iQ0!voVMK{=DMIXHYdBCS}f-Uoz+n;!`oZpBx;AW}X)KPcF$FUg!` zp^bB6t!s*0V)xiiX*6)dz@`_751gi9&BO;bW@DkNH$FHeDt)X#j?uP(xIa~J!;F43 zE{f~cU*@LOw5?R#M}mFPDfQR&P+DA;G>hJu*PK(gZv9sLE%L+{VR!LSuj(n4_9QPk z`k0&+wi^3|yF^z@Ua4xf_DtR6U2laF>CPru&MVEzahQo!fQsBHsm*V>m`(lX@gavz z__Hkl_w44ey?`RJc$BD%zO5|GyCT7B_%O_3xBd=vJbU)>OP4RLug z)|#(Lvd2{irBYI$xo#iYTKo~~q&Y5>eJi}a*|{7VLqmW|_?8vRK1W>^vrJatS?CJ9 zrB`G*+T&Yy7D7Xp-d|?(LunKn;U~fHUe1$m>6nX#*5xPOcvD09RyVH!A_xc!SQ}7e zF4;23Dsy}MiH8FwxcDUhn@l7erok4R$F_5{r(g`mn&@cqG~=@W$o}4cuWwyC{K&o0 zgmm5K9A0?m=w@+whZ>OCu%S4`eJ?yfy7$YU@Z)NP$oC&fUx1L0kmgWxBG1?h^fGnz z5&uCOlRH<_0oG3>_U};ITdfYCll5`}O&8=zsSuieF8J^E85oWW*Tx4MEtl_GiK9!C zBY$4Xu}e}p$wE<^EyRFq+}LZ$l@FBffzFbu+*YZzZo3FO=zY9!$(V74`Wo{n)vH)B zWO`Sl;55Ae70buE(UZGKo81ow?*wQPf&n|CGb0h@U#hY{f>_ZQe}wJG;+4l_VL_GS z-xXYd%V~Bua1(@P+lC4u_1Wg_GW3aYj#CZ#5YBAF8(D9?Hy^SaiMn5yzYrAbID*z3bYKHD$m_vP<|i;*;E>tmm$l)Dkq#vi}0*Fp(np)>=!|Ko4+j!4bl8QX>Q z_#GWEOP=OGE6L5@jK)(O-l5JsUGC2{T(W6@z3C~Iil z35hZ^Nv!5EUVn3l<4!B64$-wbDSE^T+UWW`4iRewI|ZfcN2zMihw`|6{|c8is_0*Pf6Y66*cVxk5;!bL&~JTdFb$Qd#MNE?CE>a zYBn>KvcI-h-?Umj>@`1XwXFI&+|nVtfIwD_mE(4TPCNq9OSiMT*O;YqShr6hZm#m4 z*KsD5sG~iA*nbW>OD8;vrS7>PZt|2}LE?n50?n&J z$W*GZFeg>xrna3m?Berr=$lp!zw8*B8yqdm?iI~I%5}ptz@`0;QqhM*9QGHOB}doe zW0^HRJDT!hHO41IOuEcKj3#=t=|u-%pWkY802@|gua#EsEQSbt-J$RwTa+iN_!EP^^K`<#}_K~v19ag@x3GHWq5@v27Lv92+al?cz@t-k;3Yfo;#))!G7zqUuhTZE9|~W_ zeY`Gou{tkQuo-p-!D>5|b6To3GJDf`H!qPRv?@JclWMD7=gUvf_q+Z!@4dCq9j0<0 z8YD+8&X4B$QX4GB z3n$e`U;Hc!B|d>2VL-Yt#prw1{kiSz_XLCB+#YJKMW0$aHf-}cEq1%1$vaS~4QP5+Jfb6w~84m*0{s&_2eo4*yCAp zMPl`h+m_IM;*sY+a}U5F`;jg~Y^>QbwbstKUj+=WxpYjJEiaOMKn%2di~&D44n?aP zUpT2}-H9P|D!*RyA;sUb&g4wj64NFpl2Ng(tIaByWW^a;Uy}5n=zdO4Q#t$>9_OC- zkaL#o^XQPk3bz=GVDV0~2+lA$)8A~AIF~A%`m6eUKNH>ng?59bcTVc?ES?U=MhEv@ z8e>1z#;R@NgI~>uwHtTFlxGmw=X)JIMqrG`U}n;c3l;9}>#hp`Yk%wKh%lU|tQ48@ zZlHkONXXrq=GXXaZ|CZRgpr=kQ*!BIxKsPKzW0Hh90nhh08>SYEynCXPbGnfu4WcY z!`OR}Em}FZ7UdvEL8Ma&L&N*Qdo_a<7{j!O7XCZ*c*?@!t_eBeveL!EMn? zhEUmfMlbXo!4Q&49qEFugix(Xwj&wImK#^%40#+-{oZG-yy8qz%r+3dCh5l&Sl29ynAt+*b3qxWM|} zOa?+O(9H62$>}}+bs9~wx3L3NwH>WQLp>vfzH1o^P$@TRfE=r==8KFYdx5w?{i{3H zoW%h?ScQw`yc!_-9fEjhpo0ya`H{VEgCjOPO}~(Z3-t#B>KpXPjQeG%a8#k*w$+C$ zhA{0+abCh#O43}}=21Nxl3a$uyqqu%n0##gdRO*qL6HUl81Cbm4Pnx`-=5921OvvO zCjs|yon;3h-vFs(|2ts((ykQ_gaewpTbZNeqABQ*t8sC-HG{ki<-tSmoDGo9TCVc(M&gfz+n20%T&R0^;{((L zkWu=#WxZYtX)pqS`XI>;7ONXqro3k7*H~A$({_HvZhdpA4ry1j8g8{+023lh5Eb&5 z6B#WT<$ivQnd@+4kUu0oQT42i{2FZN_r1P#^;bidYy0It`K21JXMfr?x!h&_7qgmcxqc_V`v_tEZ1$Msj;Ipmy#!|!& z=){Gmm1Z{?A_~RVu)q$C#vT@ca_+3TmRmL>BP%S3Ky)&BRkr2lkd}AsFF!U)DR!OP zqyk;ss&V(rj)5eW2jkhzsxNixJYKr~6pBE2zF2O5+xWRwS>UsK)kU94Ce(*GnKvic zn{|vz2l>jzDHlThC1{AnXRJ;^U#_w0#`2Kpc7xDe7RV~ic?8wq@ylOOA=)|kvyq&-bt3f?tjWDx`FDA zh-6~v7NXiEVi|>rW{;gFMhK`V#JbK2sIn<19yI_?A(T$o=poHO6Ss57$?P)9H@6&d zfZ|Fk1yXoei@7Iey%19=mvuvHBeIU{`5N3Q9M;4 zR4jOzU!-~TaMwg>*pznibH(&Vgo1 zUL`GT+yff*;!<}k73wRC<13bs`(^q^=ZjinlZz?GU;B-MdT#4U!&=S%7ExeQ#rq&u zF)rS)e8FNh>4x&P02y~SKi8`*LO9LYm){@NIbcQjA;SQ~yzq=)n??3F=l)2Sl{i=1 z%608Azz#fmNAUf~17I^}Ox%}VL;SGx1k?5t0k{k0V{JxOdLeK9H-X3|I(0&DJHd;k zl4G36YTH?2zosWDaq-R2Y?Tq2@5EF6tGTUe%X8T$fs#Qnss6W_*Z`uV@74Dw00N;` zd_*bXpSe2y8&$erdMTQKov|yVJJC|ieXok;=>XcO_f_7@W?>7yXr)Vz<-Hg8M9atW zuuL2x9C*5ZH2Lf^7NFZ}D`0zw<3EyY3Fpx9b}4tXsN9;Big`+AW#Vb-mjivX)o)g2 zH6i<;Y++Ip3_i@DoaZ&#vioAIpBchjF_dr?r|b1c=nM;Sih44%P!?iOC=AZ6 zd9;lIZtQ!7wU*#~AcRP!N1dkHe^VOoqMtT@6%w_dEb)d5;#6nlW-rZi{{RhIGNc;2 zol-)Ivyqf%6bCvFMx5~b!<#Ghy9a6kP7|B-86*|nnS$hk8ZM0r>;Zjr!pKmBb zZ*$24FiN9rpkm~)JI)IPwMX84fBy@i9*KL=J);iF>Z~JrK1RF{z5Y>@=3ER4}u&u6XR(I+?Xg;3m$&gs>KG>jHx1=U_bYOIKMzc1Jg=nw@P$ zOl@}4FR^}PkjX;T=@XdXwd{HRk`@)eo#r}@oN1jTG4$#IMwsHhJD&(VdYOyJQlTGT zjduKFx_S5uV~zZSg-HI#D{I3SN!nHZAHj2Khm|36)K^+5k|(oAJ3f$9n6X$*JKdlu zK}hk2{^*W5W8buNP(}9TRTYbL7b~$KL$uZQ6V(;nQElx4s*lk~1^&jm#GY$^I#?N* zyaM`K8a{5`w~mwAEPH>vXk8BwG2SbxGzx0A4TuRgsvHY#VVMFu)H%9SPhAFyMvuLh z{7|yDm7Xr|B*4?+(!-jSb|MQs6d5Bz%#%$>)AMN#2(RZu>E%SpfB>5D%gz$Zw@56q zzaMDgek;cI>y|ZDyF{Lr9>J%_&X1IF4QS4`F~opPu}&No5zz@l2ME`!KKK&q-DNBHr@-ZfqE=b~ct-5dV14-%Y-vF)Rs- zPB*3LV}Z_WeigEf!WhtF*PRKMXpq8$)Gd3kN`~0=v!P~657xv*!UO8p<_Ii8UD+d4FTtPmf7E2 z2A^9W2iS4X4gOiT-7jdytNy<0wRVL`;A?_0?$~kns}C~o*9kSiLCtge+%_(MlUuuK zYcME@5y^>_s*PrH%rjp*JKE^?g~Q@isb{>zhZm`vFzkAV!mK|OOQ4q;URyzC&o}yP z0hzWQEIk-bhi+x7D{&2@sa*&rK$g(>8QoEOQ`{FO2Ms#Z`y_`^48Ai^9K`=y%<-Y3 zelcaxX~qV9y2W^$rvIsiYBLz$0u`x|4fc7$JEUs5H*LCo^+vr6eeWgaTf@S|1|fg< z{%v}O)nA-(3Z&FKv6~|TVPb%XwN}p4)1#yB&NJ~s^n8RO{-paWi*_jd@$BQku4Y;Q z8VU(dhu^Cb8$Zk-8;C>?av0(zICXzG%VH#dzI@-%KayIyhcj?K=24}Ote_WMM6<=c zXk6xNHNSSxMBjnKdGq;an-5Y*^-ByQ_pp<*z0szbDZK$= zeMyNa{ERNqK+D(uGF02-J7R~>5T-ILJ-s@ZhZqFL;}PyuIcc)< zUH5%1Ygr?{LAf+~k?XRQc%tN5s}PZm>kmpT5;V}kOg*Q>023|WLCyR3UFejWSnW{~ zbf&}zb!&KPQv{Yyk*@p0K9ps=)B&g+=*QN1zlfsxQqR$astaK%88NrOxE%3Hc< zDb^N|H=M5L{@AgL)1{6%ZM=bL+;m~)-i)@foV=b}AVt76AmWf{t#|#4Bq*Z%DmXHhK0_AU|rkmn0+Kj$xb9 zYer=VY@#sD#p1bx&%R&FwgVmeo$Jhhf8Agwy~YWEc9Oci7AAl^-oRas6>%&UXA}r? z8W0nh5q>BGhNJ{LDm2L15t;20sV57i?;WmKd}GP)U9F@hzA`sjZY~5W>Nm}zoNuCw zgA9}6z`PyU-Ua&j|51+E2-;B&T3h+r?o4wTLxJ}%;9EDuZD-rpCs+4$AiYRmNvq_gdTn!QZ6VC+Jw`Pp48uO-475sO)X^xtLDtP2FZ9u;~5rk#i(#k*-78 zm#~@{cg|}no(B@qPWikT$2Zlxc%;%l$*N4ZXDE=1`x5qvNy4_w+NPM4yG550nsEz! zM;tdWeaIk^)3%5BB9!RV1N3LC0ox)KgyDA~OkK19`ZnA7Cfg7i-c%^`5(h;80>&%a zOkb3BN#qyYf@e9Jf_omFF_3m1#`{rx_NN3K2ucs3UCg2Xm&XNy)|5c7GLm07ds_ao znl7U)Rly;;L33C-=$ZA*(@q%n-+l`4t1BXWYv_j2@P`9x;9`0-WkR^qJ9D|6vi9fL zJS4B@p)As8QRR9gbhcsr=c`(`J)zEYaZt)x@CG{3U^3C)i;~^t<3p$Q?1kxP6XBns z47TcQutt&go00Sv`hl9}e2S^I3Z34TasZitz5X|$-fh?Tj&~&qq!-BV$(hK(6Z zGKBYsv$3)FVMlAA$;!!TN##>a3w+L%M`zG3`n*qYEEyE6Dsx=iRRLi@1;idmhS?p< zrbm2=8^ZCw8L?tre^5)d=AKeu2qbjrtOHW>yG{O>H}IH;GHvDX?SWjpo<9H79=eg2 zGWf&18V(Shp&bTjKek0r9Fs}NIQxA*ttZq>ovI?m*lA$bio`m1+!5jB!dm-sTrOw- zxM@|>>2*wF(0TRtWxb_63;M;^A(Tw;x^2Aq)r+}8nh`3*ILexCYRDoZLQj8&apPOfdznIb6u!MC+xP` za$M}R9LG=OUN5SW(HS+vDk4VK!6 zGA=B}u}BbF9k1LLb;&mL_70lU zdmbohL9f8$Y1z6msqwm|dT9RA`DKh-NQ*%nuk0GGofb6R+NJ)kpV)Du=2GIWD*rp= z3lelhcKFGa!}^tdFSfY`caa}^Ti(!jWi^7ke$Q2MW3~Xj- zs&Yux7hmhVIzMb>WntR1^)CC2iS9)ddmtCX7?6t;fU=huv-31Vzh6S~uU&&2;u+ z-d&{qb(=`a={lR{bX#HN4SJ`?hCBhtlBM(0@MvIDGpX=Q+kfY85mY{}lY`G(YYS zG@^;zpQ1`pU92zR>gSd{nE{;nFyY8^K!W1wSv|=vbnF)pryiH*d;bHwC@dB68~@?^ z!ScuDJda_sswuk9{ImJfOt;v6VtrmffDpdrrel&xHl-8O3l~RhrtCb==*&P&_%IM` zXz(l!SpG0@Bk4cm;kPlQ<~E}4z!!Lm!loN8pHvpv?8bKRY-dhpY`z>+Ug<;yZ3^5U zc(-)DtQm_tWuN!LMe5qhqh2MDWw+zZmz8cM8`A)%)-K=qp43D+oCpvVj>Y zqx3F$7om=+X#~;nY+b3P-)Si|9YaZOZZSF0|(25f(xY%m0T5m|K#%@a3loeF9QPoE;$JxXku zF2qBkSbZvMgw$h35w4c)7!bYC3ej~;m!2nt=*r@Y2%L|NzXt(3IqkO?WzD-jnQo&v z7;bE&6o>&!YFG2?2cx#roItszU!*KdfzANr%0s4G|0pQF1&rlUHEn;4b3ik|mHq2G z9KH{rqCZw%`^`DbODnyycH&~2gqKIqO69+~SEu1Vx4Vw?5Y=&RWOI}e8za}=UY_52 zb>Q-;eqX9IxT1C8*W7iMp>IMp_syux^4F_TyrtUwpVhS46!yME#=_1dg-%{U)+2agu7BcN#Fcz3Npx|ywoKpxo~F^AXA&qH(u z;B#9LNH>T~?=>B~JjH4C&h+Nww%*`c#$lO9*C+{I(N&iO1__pvi4}PN<{nXTHk8&i zlsk{atiHb;QN4P6KFIRUB6YM1Olu0+w|DAc0 zE$BF!0{9P2;lNF9Tz~LkmKA|x@WH}fM3oQwQhry>C5FG^ zig6(ABCXx^%MrhwvOiSoFUTn>WVxXdu;yhUEJ&2M_{jHkiS*z52I@0V--palds7EV z+a8(t-M6j|Kt#-VH#8rf(J`{&nsB!!><;a||Yh^QB_%?8JrNiyiz>N977R$F%~nc=UnvPMBNSI4DY z)epZyeU7{sq5OTGy#UAtzocqi(wpubVs%r}UbDd=-R&JWX5S-sdD8jT(7r@23R<7AHPX7(>o?huozg57~WP#V-e9=i4Z(zg=u+7t8 z4=teP9L)Dz6W+9jP+LE18u$ANbevmajpRc^PkQC*llhTGK58z8`B-4jMKhaHM<1>* zJSvXXikUx&qr~>1(xr!dn*#PpvEv4$RsF0wD@}}v_492KfT&0I7W7I3z}5FwYs&TX z^dqS8*_w6P?jKCjdd-(3 z)9y?tR?FhZO}x^??e)f8=OMar8&V%A-%S3~zvW?S88kr(Lii2CbfuYns-l-2;{&3v zqfrqIpC&>B99 zr5paKl5}RFfO+zp_xUHDmIOKI`Pi2t-+g9vG9c@ui{fDU3C-Zc-&b$m8)W)+8&Zip zy4l%Us?j5A@@XhZ5so`l**A}Wy^cdM?Cz_}VpJ5*JK5fb(jfGdqnggr{wiD?LrLOD zhqc>Uix@hhOpf~gR`H^34#o{02R{2sp0%p**_bqAY&@s&&3+x;?5P9WSgwBs6JKDC zd(=sD#Ilaz4(!I)8Sg%+88LqkB2do0O6uBm%RS4p7p?i6vMXd=tjT^bST}E_LvXp! zE3vkJu}}Z>_r>0O&sSgDVs;!Q*$Z;KizS$|Cbdho=c7nV+Is+ytyDJeaBpu+8NZls z>CJx8FIcS}Xh4rd347^gbjA+LCv&JOF$StW0< zuMTf&=@DI37S*42)7WUP9exrZg2d6(vq$wL1Y>%GO-oPqSKA^-v#Wmi%VVLDrt2*G z7RsB(sF7fZ2(`5a&GCq}=TWv^8GT0cH7O!n69w*H<9AU`-MIg581=dyQq+oi6&@ab zbJ^S3gUegd2WN|Uc=0VXDD)ih4GpoUC&W$;NTykD!zb(d1 z?CHKjHMIKaqbI@W0h&c-8GWALV@7+_ZU|l{a^X<-1>o}R)5OA3$nN=JjvQHPqwZ=n zrMb8TJtrzCM>j3y`}E(Q&>V~BSQ({WT2-7K=SI?D9>d_giRb7GWbY+f46Z$oLL;=C z9!l~$9HGXF;Bn@DML?vcl5_+?BDDk{oT{=Qd`ygS zQk*?pCH%mVmn)l}MFWP_8`lm+R(pP&kD{wI>kyn5ZX%Zq*(pICM0|`|$Nx^oWY0L? z{P%4E-P}Q>#=Um!B8oHEngp@1|7m;M;tyn)&-n^%>Zn|qkqY2d(i8W)YNCf02VOr| z^UfVqyRHi7EF#@YbW+qec6pa8y_A<^^*lN3p2Mu9J;PY znY-8GEpRD~>6=}4m%_|7vp4L6#XF0NtWiB# zmGjn{k^Br|tc8r`v4doL^N-QB@5e;;_c30Uo19sQe3XMQ^M_^p3ufYnvkTK+DM zn-q4`XjMy1JtbdTlGxy-TyYNSZQR=C3^s4`099_kb+?rkpi0q6PtpAvSnDFf@PAzM z1_qdSDwEF65KhNPgNS&P*vhGbRoOzcNL5%GMHz09nr07#V8PmMP&3zk<3YFWzKrs8 z?k3jsT`&v~IgDL2i*1`sQ$Z`TBu3wKF6p}Mv;OD0$21<@rGqlN$IC$H zF#qw^Pboaw%Ct(d@X0i6tE`Di2YjOW;hhS;vFlARcr+^i^>+DvSzcOrsrhcuL%-8E zTTlAU#5(t_rW@^8?(X189B?*{ zU2%oV;r9gOMGUSSj&$Wi196l)vQ7)s2XVt?e%4!_306E+NEdX7JcC)z-kl-WhJMX^ z^D5PCh4#~ybrBi@7zkkKr~@vpK2b@TN(Ds&oKese%XQYgPKcvyJP(zzq7=fh-1s(J zFi|(EiqcTJW&_Nk{c8ultQ_}YW6`p)NVT3_Q@e$XV*wgJ0o^%{8KX!OBV-vBvQP`U zQg=D4$l_r{$cvXZK@YN7CIUb zg(`@+3kzUL6&27TNlWCWeis)+HX59lMT((YEvi}_g|YW-hkM_nS+&1uQXh~hZ1q=@ z2EV;L;L<67(EL7g`Nrsfk>&o_oHt@oS_ZN;I`!UF#d8HM@Hsxulu$(hDo$tM^QUor zw)2}dXWJV9qA-`K3EUR2S{z6Zwd^{NiwcAidch4ZKH zz&d=q-FgQBd{eQ)x8oeK$_l)2-maFw&e-!YV;qgONtAQoGl1Y=F0!SB`bONBh#(?y zTZKyoogD3ru`YT`Nm?m{^~hleQo4KvrT)9@KU*l&T*#!$hKz8lvqyO*PA|)~)NKmt9%g;Syu{1h$++gGIhy zYfe|72b#y3qfAb}W~L}j`EZklb5t`5=@(c=Ut*5yQLz7;!Tv{K zh4F8tgU_N(+c&%j)BE8_M{>at_XR)}KJ?D?XhTxMtsY5%F$7-YWqBfF{20XJjP?I% z0W$Qy`35%I&h7RkAU0Q(z&fo2qkmAAcRkjSb;%GFTq0w&o2By>tDA^{6j9U1U&M+T z0Opfu2W-X*fqzX1#2ZKB_M22{en?q8oCao|;HS!F8fDB`H@pBkqg<4B)}e6bc+-2| z-m*tFuO1Hu)7_67%tj$vl$UGKMrzSyr_w*Ae$IY#nf?1z(42XpX`nH2AhP)lmxK%r z%j<6g-_Ex!;8WFFr*&U+0Qak_;nRejQP~a7Zn8C@im2_OdUYNE3)*k=dtye#zT_}p zoEpHp)A{@_hUU+_a*uiB(V&_&5&KY|zY;0Ev-5E}KuFOrw#}5awnkmn6?O5j26+p; zA4YCBP}*UpQ3KcE+J2oZC5k1J7?ELS9(ogJd5T9%I_yAUc`&| z!@eC01ub7P(H>8HtKvgAiLS<>dF^!MZ2ppY#CMKkwdUJqk89Zzcl0@z@@v_(n#w5) z?HpsM{irSzrrv_Hkv0!m$3|AFb9~Vqv1Yn~0eI6n45*Y}VHTf=P3RACj5au&H2wDp z=WZ^Hu?R5w+TJOQbrF#t5ljT*DTF-v=zgBFwiWHy(s<%Nx-V&6ldwG6a(;y@3o85% zn~u~-*G|R1zf);`s7YhvIZ)~S)cw4-eYucSdnyyiy>=+=I|@UDaK`r3`!G3|FxeqRv643TjSQyUrP8QAhW_V||zn=z@9UxNN*l@}&47n7vG|FcN$^XJ+Hk2;bB|x2ewXa|nFj_2iTxq5!eJ^hgmoGHbX#TT& zyjaiDY4^0@g(Zx<08cmLB(#zXl=qSux2kpY9ms<8!&04CE|?@K{#lB4;W0COSMp6l z>)+k3A6u))SIppN@v6mtM&s*lSTmP0rfOtH*ZNGu)ax&)cIoc)-wwb3Z0eTj+Z-vO zuO>9LH4-@(MnD9>E%sDOTXXNqj4#CzBiR`wso=!HtMZ(W&)KL{7leTHZLGu)N;Jm3 z7yPO71#N#;4s>f;_j`o=cQ(u)-$!VnPS-WQl1nx2KeXSIKg=fO=)=~sy{qGI_N8L% zLX9Ez&qMPWgZ`3PPTCJ<9gEH-kP#;^2y9#U-de#mVAa{m%w1YnF!_+JpBgiKbjO)m zcB&eAyZpSX4+58Ag) z_K7+rxs5XwEqNXnO3(QbsS3+@i0S*z(E7?ja|$84bf4D)87e3eZjP%0KO&2o=cdO^ zd03N8Zs@$uc@DhZuy)2g&lv@)?Dr3b`%r#Ws-Ik zoRQU;L5-z8-CFAD3w25UB>r5n@EidK3F#ZM&B0g(VYv6u`rLObFQ;jTVks?DVcJ-Z z9R4ME-Kdp4V&+saoWno8+0Z0=%k^M0bf+uPQZ`$GHkzKV%{RnHub>_I z-{loR4+bZJ5l!ZrZABum^359vqUo=ZPF$F%+qb)(%3rfedxDU$rhVeFK=NE!(am&m zURPHicUhBLX86{C@>|g4RMH>2e?BN@IOpfrE=J4zK8UmSH@K%BS$_nexGLiwnQaLUcXvBtdw2Pv7}p)N|QqA_AmX zMK6;P>tCxwXevjSanWB?e99Tq= z0dlmH%3^@Fn*ePBGCWxpz}B>|wqe5@@SVbt1Sf(0CUS%$g&Smv5mTU8+fn%h(N4ig z7E_g*Se}Rs-FGHcV6Su`6dY!CxMokHaOAiD8^a&4>kmUoBBMs}R?T=2J(=ua#M&Ew z8#VJ<@vvKf^G?TOCCbb?c1IvXIsN=x6lu;PmV9% zaVmFhx#j+B!_%P{>8i=#?L`+c`DW_k_qqAET1}0;F=vO{h+@<7Xr0~OuXL@7qIQOS zoLDB`i&v`kg`=M|6~F8Yc)U9&{iLl!>4ii20`P~vROUNTKU!r2{Q@=9@1YSW!$M8O zx6BU5XzTS!Hsk~xveN0JEiB|hSjHo>O4EJCzoPMaW20K1KYc{?E6Mjr+K#7$P#{hE zLV#jKVInm$-Z@p~e%t)xb+B^*o(qYz#QGX*;2G6OZ_0IT}3pBz0enV0c!B8ndDW z_hjt%r~V>m!~+)OePH>_7IOE1HL$G)5FDdp3x^#lq&R<@|Ht1_!CW$dCM2RwX;T;W z5*wT?WG_-D+qk2U1D!~_*(2--{-IS+I1BnaDI+(cLUS?)>8z@M>A>v1jE?U0^ox8$ zM3wq(>e}ywwj@rFiQIp0cEuYv)5@7xL1(FGi{`Uxb#7 zeDRlej7egmqJ6ewO}B}7RuZpXUsoWY0XcX`Np>3R(?@8Dh0fa#I%6Yl>qp1WY`3_J z$Wx_8{$WPZ%W?tAF--|LOE;?5S#{)l%ZlYOK{&Po9-n@k5-a(mBGyz@6Yj)w>}ba~7woU;(Wg3VDJ-@AbkaDCHqs=J%`|D|bO}!`ga=((Gs1J5|m0+edh` z%V46Rl^#BMI$;^w$no(5m^`fO?a$r^>8qZ>HCHjsFSl9y4`|}ik&f)&Ib>(^?Cz#& z-NCejv(KN^;UNWYHL%BVhbfk=AzT#y2Q@*;zRX*z@5RAmy#QibYvM{WP`~NMS;#KF zA^D5Okw|bi>Q20slC&mI9gD)z4ad zV9SgDE43e~g*uZv2Q$u`CRvm+3-xf21r0RnVPgh$-RyB`8ca3GC(kK}Ry087i zwW4-zV*HE&a{&1BpFYz4&J@(=%__!{%go2Sr$Pk27tPgAgG-`OGRnBhQ5ZMl&&UMK zwZqcvYti<@W5L{PRx%mp@l5@IIn>R%|Bae@+Wa8bQEc2Nz%{*?Ox#hJ}5A)*kQr!Q>BlyzY*GkR4{eM^d_{o~yUN zN4oYy)Y3H{@LH%dPP0!{WaZ{K>OT5?`lk>zNJfF)c>KBYg3`rTsv%mZn%FPpflt4Q z&YtLT&FO}EZjLkUruMGJhcP%{VTOkP-&2i0zJ2I{1efusgbxaXF~_@>_4nOcG3y;YgbH4tEqjc=Q(t? z4S(26K|wC&o%1`S6Xu=G>+t>WJ)2g|T=Km#iD!KwLI6h=NebrCaaFh()7a4-L|FT* z#x<+Qe!2?t3$gOg&m|4>zJWd*>#oMc<u<+aS zZR$xI)V(F=dR^cY^QTnsTT!xpOdO_Ba5@IMf53RRAA`4(h}qz5`Kx z>X7>T2%Ih_DJ{!?HP*dNwPXzFqIQ0E)BtX)p=ny#y5Z*-3UVwh z6Sg6(jh_xX4VTM_8S`%i;}ktI(*<+m81rh9KGr;u^^rK;@1uP>rLT6vU6mu^-Gdgd&p-FmauWg6F+iwm} zLZZ%)Ar}>9l6tx{a{#E`c|759=3lx0CfxMsU7{y{j4d1pW6$~>IR5Ej(W^R%+kE|l zw_yHd3ll%lLi&ezJn+b;pp>Ky>iOjt;`~dcQ-TW6yg#@bSMtz_wRDOz1jV zx%Kh8F?LpE(&rmx?UsJ*-F`H!P#-h>3QV3^A;kldg?d+eA5LuiURt0&@xq@f&q5}l zKIH2J_y|OAc6l7CTzm=Y#1ZxMI$ds3IwJ2Ci`$xV$q3NRv~xQ!2Y@vze~6)=K5izU z{^b?pQ8?z2RNN&CUW_<6Cdy<5CEw+EQ19gXM(9_r@W?I%TDaFLIrs$wfOtp2Qp@3N^s0lgwoo999qYE?ohM(%fM!Cc z!`t>_!&B=Lx}GdqdD*!2k9VhZINOasJ^)Jjv_k#Ni*LoKiV`UvkSx^q?K}at{&y*d zx})?GOrBMdaj0{g0HO1JO->9@XVhV9#;3SqLgg8|R%b>_&&W)1Jm*`PlQ&sep2sfC z1HCWfi6_@v9=B?Ml*xmV5CYK=?!SNhQreeA)ru$gJQSCW$3X91u&llMDX$oTF_XoQ zj&wP|{p7wi;7&7`1AxOzz_>J8VVvv5pXA2ObWFht1RwYKAy9FW6=j3rud+|{#|-ZBVrLSQ8X+ z5e}iDAo9x!4V4oAKIkkNazS-<9m`Cwy;N+N2l|I_a_6y_GZ7l)hDYwe;%m+WWQPco zZP4e(rsv*4!{J)fH2OMw(bL?G$!AToeO+1d%L-92q7eHx?n?MvGZ_d7@B}(=_L2z@ zCpn?g^F~uTqult3W6)520ug!TxFlzkYp(Cal(Vmw!l>BqoPrtUyrY++)Xk;Bl0VD2^L9KR*{^r`-o2eK3FUft6A7vfJr8 zP6Xz*wKwg@u#3RqQp4?BPpjD*MbHK6X}#CSf{o*}XuKu5TYp-Oo|Z1lbSMRC_gCZNRmqv(&$;e`l=i1T@^TkC zTYJ;0sT0p=TzJJo(eoWZGMai`K{hVE?kXvLno>=jxJP2nx#vO<_{^K%J3rRn5X}dK zDjH2)f_=q=@fp$5(++fP-+3Z1AM*VRA8Zv@Fv=v<=glg@yz^EieqxG*aTH&xZvYSd-~r5;IVW)kxc)wD|8zTofqH2n>eP3iYhgC0M*vUGqE< zsLxqA1()CPFq|X5tVut$P^3B9qRTrm2ZL(A|%Q12wkK z9X+K2w?A=DOy{@SeJ8ME-8OJBy0*-++imt4IV6=&TGIP-PpZ}9|a zF7_0e-}6hyp!vuqKr*Rk%KYx)+TbXhV|s6ttIKoNYf{V2&l$b<{a06&&$`fOc4jIh zts1&Fr|bs~N47grm=F10RkU-hq+3(JcEz}iIKtT#clKgTUGO-@j;~O{##NRhxAeBO zz?@PRfBW;RI+(}rL$waGj++F`iMZHGLg(0wr+w+<-~rB!nvjWSd%Qjei^I=9_H5#l z#_$|=Zr_Qa!6Ea6H9>4RCLnQNbOr^`$73$lJ4`|b`;(hBsV z5sU9k6y^Z%=IR$LW26h}xj9aJ@w&goj&uryVRA8Q;-i=~|56kc=V8p`N74rKXaD?5 z96g~92|8_H4#}gPF+UbBZ^rO=S)c$84MY$H(RgNci)Zt}?>&H7(`F_Fb6((a=)fWL zbam^Jw*nz3McauM1bPP{2m*MXicl8>WEJFK+3lCcF0@8^n!6F`8$b{_ai66 zINlV(nwLebKV48~JY#Y0B@5L4bU+7nm)nVRme0ZBs~-UIRETYkl3x0uUbN_GxIM0n zL!E2?!2HG-EDwPG`58ND;@X#5K<{jN>km#>f#r&7(IVcYA>S*e+PPNJ0rhKE zOgbfwa506lkY~}$DgHX9F8E8@V7__76WDXGN4@lE1arnkTAN$Y+N9S6#dcI{^3)vw0Mza}0WK7Vz;WWn@(?%< zBgT)w+)K}h&Z33Iq5Wj5<;z4t4TcKy{`G`mu1RyCyFZ~JYL|TbN|aQTfel4Wx1Q!M ze6sq(VZmG$e|I0&Kb82}4q18Gxc;GA5jsb~k}KaUv_Hz)|)7Z&t^@ zyU9t~fL>U7=AHIqt6yBPv~#Vb66zz%ylI~iE@9EYJl*S=@7VebUR|s9Q)UY04hKPQ zjthCYF68F8ke%&>%f-Oq(DZFFsuP?Q#O>zIE?^E18oa5K)XV|k5BL8zVVL*({Ww{5 zQc7AihpX__53SQ?BN7aw?RX1#mIuf3;8_kl%YkEg%v?SXBPNcP(zBY%R16CZhR|8x z5p^_i&D>5miT?aVP3^OnFTjlR<{}b|m~Mgo0Cun6jz}nCnTB1M%Xw|9ZNaB&Hrvjl zEazNz0j8dl8pUD9p&)`Gii6eN*s_JE{Y1> z$jx!W>tWz_G4OgE@Om9^yBWA#1nz8NnXXm1K+WzyHT*Siup@#4Ct0l%kRgIi%^U!h zE;=7yxajhPV9p5~stzAVMC%A?bVM=~Njpm`Ap|{*T?q6JK#*Y0vpo2SxWDk4C2(gM zmQyfXM|L3UuJ15F(B6X}-*5f;F!s#sfM^}CYiiFgEx`FVUW7<6Y`N`P|0x0k)?V_7 z!d#YpAMQrm$;A89ul(V437=yo97nO^NC1=qyN|S@v9?3XXL_K%_>zk-s-gs6`0^4= zTl{q?o~Erjg;1ZqaItb9GX?d&o&iv{S3ljW8Pp}sol5`b7LRrvdgtMv+rH5W2uZ~I z)UE{lN9wb3CykFEQ{TV7>gh}I;m7UDZ@XEGHP=L}_LmCcFts24BIB#vSxW|C&W4WS z``>#O9H)Vtq0&}Bi%L)ibcyJs=gcWCEVp#zkPr>sPyg)%*6mSr591q^+ z5M<-CAiM8G<;&vyLjw#Bg?wT{0`z|=Vuw*FVd?meH@0EMwCT2C&O<=W(UWLyYy!{o z;CUV_&w&@jefh5-@ZfkJ0?&gN1PFrkmlwozcpmO755~@)0MR2}^^6ClXgSt|&tBc4 z^s&p1bd*x%FO`PAW#wjJ+_XyNH+2F%K_3F400#U62nRx70}-)bu_p`~62!(&`F;|w zO-h^~ZU;aqvPb5Ef}*IX2w9$N zS(wX`SDcUQ@4FdUd0D2%t>mdY{*aOhXL7O_{P@;V0Dyxbxb>#ZCs0Hjsb7^gI>${_-WI6)u)#4UQl%jRS07{G%NFVwZarSp||F3D3JN*dZ@>b?Vn zaY1yycWBZl;`zh{fGWobaT)TV-zUT+YG}lXldoNb&NiR&A;|z>7>8nsVi*F#5OI!v zh~DlD!zl3`(mum5U>NZ$nSg*{#Epm-l+qB77nSD2GvNj?&n6$+Vto;4b!P&gx3g`q zc;4*^bV=Kjln+~LI`QJ7l2Pa18$YHV=0m<$@VBSl(}mg9)Q2;q?fXBt7(! zONL?o-~%fW2y&(#&+2bO7KZ`zC5y^XTzEHsa4)UM_YAleP001BWNkl%1!S1B~$+zKUTEo`}VDCO=G6h{624H5k^mW!rlcEl%byI zP`&Rqga@|RJ0XKG2Y?rzSqooZSV}{ml~_H#47oyKmzq^NN#p|n|lx*3X6_m!3fw8D>;dUG5g{L zaC%&(MG?Rw%!Lt*3?UQ@pr@e|fo4AhA8Vr;Na7Dkm?BaiK=1Aj40R6JIwhwt7t_z1 zjle*_bnEZwNBt4=>0E)-z+9FipB_YeO=70^(u%T_4P)DND5!kYg?Rz%*X>l^hjh>V zPIV^nQ)_;AmfwOAV~V5?UNKrm%@6=hIkuIp;c4vB4Qxo`J)Sujfz)%Rs4?K(Js(ZjitQ(h1 z!+i6GC$RTWkCcW)Kd!N0 zuKtbU+4Ims0fsb%%yB)La=9QDohhHMy zfAcOm3v4KYK;NM0)^ef|f<-?~Dq$|m2QR&664P9yJD0M)^xBpPdIxyOfNJ-%*z(@q z|467$y5L6=q%#L~UuQok7k~nFV(e3ohB{%KC@CLXzW22U6Ep3^k(2^GJ8$&E4u_S; z4PXXy0Qh*r&!SdTGfJwVe(CbjC>Zlgdx<6}-A%tjC>R09@!&Wf9c^7W^7#YkZ+plj zQ<;T%XY)Jw_iHs$8YbDX=@gd;)X!O53XjJHuh$(P>TU)uCj*y*L_uBb%hIQB2j;QL zA;Ww~aG+BdiiUR*VEUi${3s!q3oHj;dk=^P-^8GO%X!z;v8J6M0)UVJ4Di5!02<^0 z9tgA#Ak-g3BqTYB1;V2DcOZn3lSd9dt3@gu zHv-;VFNS&tOt+raE`)<2({s}Sa|#MyTQ?4V6n|=1qWQlhm0J1{d0e~*s6!{a(Nx>{ z9|v_u$)%V$y*#5(XITzH``c3W%YEkB?gZsOFcDXzxzbN-9dw1BLq!j4+#q+*m zebgG*A8l^3m3}Ire)U)X%U)s$N+hro^)(HOQlty&k?ZVvp{OGW}Tqh<@8V!%vZ42ryHv^ZGz~L~5y3@%h4R9hbH_IbcEnsNm z9MKP05-|Vbg_mQ@=+X9JPI)w+XavWyO1X5GC1O)z+U+3#hzP(C4-E1^m`cuhRF}#? zQy;>EL4*f_2n_}h8VsPLyA#_!`4~M7U7(x*6Q=2_BH6x{L`Cx3f`gdXKLMNtZuEEe zVW7t!wfTGes-?pq>4Lc|+u#0JnG4@cv@n%e$*P~2S2$3A8l>0-FBwJQSP$kqjAR4$8BCQF*$kg0R)CZ$^&KGLZJxS zTlRy7HzT)j0SJ?WOu!tJ!=HZl6uNw2@gp(H*)8=jr<7vC_&m&+GbYOMjzSPMPZ+dO zMode*f66FqfMu!Fc{IYwh_Fxdz2`}-fo=+UEX!#wB@ zz}MOXju#sm*%?ld_T{;Ls2{S~?Jpgu(C(!hx`| z!9~EBbj_q2<^aI6JOp0A_*oMyiWl8@<(C!W#EzrrX|`VR&5p1f#q^0@WP4R-E`d@s zRJUTzd@(;_IK`=UlpAdP7v6s1DbyTq#lT<~S&kNzPFR{UM>*mi3D>|z-5m7kc9i2e z0lA(&kQ}WAT|EzgZq0Q0ugmRaj(@UxMA_u?hwmYY6l&$9>01 zz~TWMJ7z2vow3k1%moPOZSg_SIKt^JquVE9n-~;;fB+gX6v84;a=oy=Fly>+aAfm- z1djWyUm_wWr#1hZM@@;uOWOg!Ljbp=vAe_*1fEBCTPJF&Pok@<1N|L7M8aV>T+yDB znSi+*@5pBdqqKA@n9GtXv-{_VgP;u2mA7Yz#g>hGL{0M)YwBF@2l(KnpJL66n=#NI zRBG^(j}C+PeV9`7`>4e~f&4+6DNWtq*=V>U8ckgpa;HVEsHvBXD7ilV-L)qv0eaJk z7Z>Fg%$yN@BsR?3PW&$p9@8&?k#4A8wtO_Qi*K-bmBi%O!HrR-_E=ju9KrrQ2XN%` z?414h^9HP0SEqxynZz@zCJJ)^aJwAvdcAR>?sAAuadx0?xLU$6SI-oso{Ke1 z%0A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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_02-00.png b/.vaunt/badges/badge_02-00.png new file mode 100644 index 0000000000000000000000000000000000000000..7def394f4a7e6e8a06faac0bb81099a4b227e071 GIT binary patch literal 136502 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

  • P7qpfL@PU$jMcM7y?Kjz>FWOANsadv@f;Ex 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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_02-04.png b/.vaunt/badges/badge_02-04.png new file mode 100644 index 0000000000000000000000000000000000000000..b0abc6880e3c9e9dea8550310a11f4e6d57359d6 GIT binary patch literal 159437 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

    igx{5xk;W9zZm-Gc(iJGk6Zzdgs!C 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 pi|iP)2&z%X<-q9P(8jY>&_fV2n*i1bhr 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

    GONSV}dz+&C9f!y-3D$pcV;6v1L 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

    ?yogUfgxZczj0YIR$xi5yI_M&%eV-sU}r{CF? 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�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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_03-03.png b/.vaunt/badges/badge_03-03.png new file mode 100644 index 0000000000000000000000000000000000000000..13d327fcaa5df92a65a5980edd84e0d923ca4df0 GIT binary patch literal 126985 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�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

    SRh_1Ls7SOVxOJRS!1fB*ion3>Oj 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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_04-00.png b/.vaunt/badges/badge_04-00.png new file mode 100644 index 0000000000000000000000000000000000000000..6e1e908ca00adcff653b34b0cebd78000ace4392 GIT binary patch literal 161435 zcmeFXXH-8XL`8yRP?BUxk_ALSBEPyrfd<^^8kv0o0x_GI8cS&3{8}PxOn}=Iz%RsKl2ZZkn0=)f=9e>I@0rG54aATM) z6e4bIZU=`sS=hi#6@hk*fsqva8p-4T?~zy-J6fLnpz_qZ`9$J z1$A^XhC7i^n^{9`&7CanGuuLJjcuT|H#M74*%;fx%m5KnV{3CWM+;*PZXU=@joMUU zxmPoq-&F5J#H4>1Lh<#8kiu=41`ElY!bo;l_ZXspM>o&7m;hftelL#@Go4yD78T z+nQU#Y=ME;nnLBIT$x>M>;+(e1#$43nm|oCxLLTMT&65syiijX6Fx3}7Kn){m>0rh z3K$o}?q{n;z{K4&VF!2R`8j@CBgRd-Cs8QYsS_K&E_ow(mkK2tnwdTjnIhu z=Nd45esvdL`rsj?kE!{ON*VsUO8+#dU)6fg-gZ+b1mBS(Lq)_I8VF9(Jm0w;gD<9# zAhc$&uy^|}rUL>!7W-uee^@Ms>AzX5e~uV1g~#|erZ5mFm5Idn=&c#>NZrvX6XxXT zq;6*g1?)G|)Y;ft2bUM@kIM;0K}G@r7mR4P8G~hmk8zODku&^p$$(qL$Ve#ccwii~ z+s}h#k)SB3$Vj(9U_XB}tY4D1@sUt798n#>cF0Ibe@F#iTB9R@+5hnpDpk7NTPJl{ z)CU1w1d{taO2R8qZ#t#8F5Z;v@dx)ARKode9v!O6|f&94jA{vUP%3}*eK6ZC&};*ZrJF0QWdvsGZ-+SpU6 zLLKda^#Fx~b-?$~(1G#x2qPn*Vf?&6K|)870HG=}7pt72Tvsmd-%8LdUB`@XY$HKT;-4~2~Q@(doMh1hxL^mbcn-Vq{6Agn24e8b`bQBCQ)y;h>)cas! zFa{c$xgRzXAddA{W1+l}pg|=86ZsO<5{=s^2C+FZI47|oA}pz*(>mz&hZE6irEYW0gLQ8nQ=+PYRlrIaiW&03a=)PhZq3PhgAAs?^s<`T z*|7cA=C2u*;rcb7e@y3JXH!y~)f8?G_KW#F6eJ{6zW}hGFZj{#J7A<>l3y*^nL674 zttGJbpHj%d3cvefeA5xfzX|^DcFE}EMHfq2#NMU{6Ov3{+)#9@ht~f1D$@A zhb6Syoir++-LPd$*09R^pm(2R4|&HVG3;E~jXhYs;$-T@CHNjMP!xVl)4WQgs{4J; zUWJ3e7m**{w(FuQb;rk5XdxiHY)@{LcwLNZImY6f<~a#ex2*xIXz|_?x5bh?DxqOK zqyEfuNQ&TnH3TY_U;H8>eD|$A!|Jz&Vmgz^2hYs%qB`8R^fz09OOjl7(_m|z=^V`~_Nn75HM zVG7ribtwogCxXnSK0SpwgUX#Hn(!oIID2$>Uq5PAK^}kIo|+ew!J8sVhLQH#`!&xy ztscZ<`|QSG#!IRbk_S$HRm_f^{W3pFmVV@*Julep@Y|%0{N#(9*y>+YK1YtVKqiKw zCd5(6K4{@!*WmQs;b~r1$uftUguzAtW`Y{c)iHaY=v0&WONR?oqQa#Xy|h%V@)LVy zxrA@+?-`bYC0|vhnoZg@Q0O+gvQX2*AjGO$-NbUVO{YVZD?;zgvtCN3;U?txp1azX z&c6_ApN$@ruvPW7HfEguFmKXn9V7N!ER93p2!l+vn&|89-T!)TX-GVAFUYdj~f5W6{7R-RzFhr9Fr-$d~C*O zsP_+(0h|2Y3lRdYuVKJUHc%}-Ft92p4cPgBUU$te96aH@NBCsT@0!suP-zQvi>eo7dYPby^^ z9w(*pJuEuMc$*WgJY=s+$%?>tpq|URQH@^ zj*SEEPa9RJV^Le!@>17{6&ih*dFs`3$bZ*-8#mk3dNHSsyqgC{fA|MkUNgi=EcX+< zt@asZS*5n3+tp~aV{9Qa|MzU!k)2ZZd-+-n@${^RAvw{{oC!7P>=WsHGDu~pBo`!2 zeLWDi^t3UF0(^JMkB-uQ2)s!)_Ad=;HwoIvO{d!L|?hcc-li1?| zN6DVqr0Hjd$We>a2T_XK z&Km^=(unWR-)i4RdJMu1RNv}ZHRvz|-))dis~mK$8NjuAgFV1m(Org&f&@YW@XY|g zHy!ZZ8yxwGXBc2K0LX6QqJKfpzeT3MLf6LVg8zVn0YqVz)m(JBHnI2tp3>hj6Dj!T zN+YNJ2SmF3#tHyqtiZ7UA;O6NehZ8o%>BQCFgGhyh6_M9C$Qwrh$&Hpzye^t44w?G zV2DE1AzZ~B=!@rymX>I#a7uR=1V<9@-`b8qn4O2C1J%^yw?j>>uDl6 zZ&x<>F3)go{{rVd1MC9U+)IwWD)PKz3~NbWZ`3B_ERc$pi`~4t>TbNF$ zJfent&0a#sNTi3fJ#jEm8JBao6T#?pfzk_R_ky5qNu$l@RqvHvnx!$P&AljGx{RoY z(1lpPYDo3$v&Zz@&Z|c#)#@JS<9{$%y?(47wln;~!5KR7Z3q6A=Ij%_zf|!Xda{B? z6m-qiGmPs;X=QG2{N8E?7hpc=oc$b`v7C5*o|6hM`P|;zZ0Rum<(}{D&sFK&At8_I zl-|nKxR|}%g{Q2_Bdg}}ddI323X)^U;l1wWcb~qdHGMnP+QTG(NtH5Gf(Gr)#t5G_uMLx%Z93-U%Q9;)tg`)G%aUPqPMx6X1;;!y|t10u- zG?(O$2is3qb`y=xnZ~^Lq*D>h6!gq=lXiq26!*hKSJDRS-|z7ueGCgSY{ zX8TuFsO%3>sf;H`GmE)(8)=I(!iYGZ&+0vstEy#EB1Z8Q4mXKX#sTyGwRSf4$6z|} zBQWry|HSU=I1ipccwqdq?(%KRpl-jNJd@u`=8af-rUZQ-Df_^A|7U0C?%|XoQ0c3>1GyBYv6ecffcz zt)O6Im>R=a?14&dCh=#(*!LvuY@L846_q3$3ITp$#@3GP_rQ04_8lAZk9L2u$6vLe zV`Hcp+fqHXbAJ{21l z2&IfMgRDOEZZ|4=Zaa93LRI~XG!lH^G4iY$Dw1CBsM|xFcrxh?N*}%TYXUj9j)%`~ zq37D%A~-v8q+mc_+75ecl@}LZ?y11 zL#0KMR$BRjmP+I`go2%N!P<<$ddo(S&FUzKp*^&g5xRu=O0!)Ra$=Ua4xzXC7*3R& zcqDZAwWRE;>Rd9Ew)qCkZvkK)0ca%jALR6()Rh95IRJ)lk^p}s3D}U3uz%wz3M$wy z>PCPH)h`(Qll1*5g^U7r1UvkeL`DWfu}yXC5L7@Klgbu|eC?rd8<^8gvcSoX3gHN) za2PU|W8wzLL#eEPi5r{4p->>J=)?*( zxakiiswP++teT;m@$64dX>SE%0f;KAqnnK}!pY(%%QZDN;x*fa8+=iV1F7`pI+u z($r5L@SD49F}QOme!E)ae)fs-kzW!f>zy%Xuu8nXF!B2vyQYN>8a+1tzYS6)&L7%0VSB}*n#NU_A zgh&!{KQBpzzQS9 zWRj+6%#*90786$2GYw?C+3CIcs7B0P(G8=j!J`&jJs_OmMIsGlR6u|jC5Ir#qs3odq`$oCs8 z{x4zJe@AAkDOnpDZkOxJT3=xY6k8*$skqX<^A!opE&C7(nK%k__B%Z#-;cX+O^i&8 z>RsG=pdo_esO!>Gb~lgE6{--whkk$iGkJ^Omt7QtaW#Dk0EHJJ$|IcUs{# z2U*7nF*uTM4o_MvOQKP=2bL0Mc&xu)Kl0}I#1)a1r}KV5iuwrwsXF1UbY$c`{f#mK zL?1s^YVp;fpQ%4B1M zo`B@Y8#mpGj8fxJ39pWY_uWp0?^4WM;QSqthYT0Vp2zNaO`4y7e1KS@69znaA4Mt5 zgP(+oN7zZ`l65NG@i3L!;5D1`@{i*uW&DEg^Yf3)-t`&{)M$)-4mo2hsej^_REbCu zkt>FO|2)ju<9anPG$Z%SPolh=c1$?1niOCE`OAftCI{|2%iKO*c$rQCn{Z~#H)|V5viBXXIyyo zq;=2#CbL`s{(=83ndSZiL|DPhV8)Ec8Fayq{zdm#{|q$PeqO-=mT1oL6CC~qo=9k5 zf zDH{MVY&UV2k)yLIuxDiN$ZFwaV-2uj0Q&Br0#V>QV9~Pw%2uJ=!&cK#lw`Td#&LrJ-sV$x?w(}#aCeS3_S?iig&bw`-Dh*2+<+B)r2T~Vl=X^UKVa>FR-!YSFnY3(Y|*$?~yLkxG>E?Pn0~deIA&A zk-d_EcPdl*NW1h$O{tcpl&n3q$qzXz#pbc9X=P9 zFw~Gf5@45^+|(_t4xQ+88Mgb(GH5tip5eS!YyRHv6QkQ<(9u?5DlYzk4srK-7;?Go z)BTQMkg4Vv6{P}Kquo;CBa%?Iu~FkREaEv6)#K^9o6T4qtolE;V*m5~9}WCR1OL&$ ze>CtP4g5y~|IxsIH1Hn{{6_=-uWR5)2MOfWF;E*({s1Ssl}=mm$|b=wc*h4Gm->#Q*X=d?0laAe? z37nkSu{e(nl-!B+uMqPZ)p=>_;hL!JUPUS*&4jSgjW2s;^(ntfdWAR!ne=W6#U|B$ z0+ktg#FfXLnl2Pr>NyYM>dr!U&vV6Zxnd`jP+*>J+soTt`Lt+Vqv8C}Zwu|VFRJ(*swWr(t}n8fUk(wbk+^*!V^=LSac)RU z-Ep_+b)~oFH(^%lSe9M4*JjeyrR0K^P>mlXay?2Wcrx%>c75)aKk}28-;w-LL*H)O z9@M>`DVPxb@L{j;*pL!bOLl1LYanAb!dAYvMDNp7AMyA_j2zt?$SdH>+PaLb0vWgt zW88GELz}D3O>=*LwpLK0S#3QIhvlm`I>Gl8ye%zjL7>)FNkQ^LD@Y)9YoMj&LIp%ZPHqzs5y2He#pkg$ zw3^_&HC1CjjX3W?c5T#V?nzI7)$u4+0gaHRypOYU@gi*dJVEqyG4}jfimQi5nf92+ z!3tUB?rxb&YY8-~9`jsA@L+K^m@t_?mY8I1i19}UzB1|{yY`$Uo_=iEQDX*=n>I<8rOfLL2!Y+4o9 zoCU#aJgqfu#RICrX1)(}2NJn7tYviBF{mW!Na%Zc=zh6pR_*{R7@ql1pxP~8`M#3X~hHD@0@#uBpj=tNhOXy)OdZl?UP|>Hw8af>2FAVwiD$%IeYaZ+0LB{ z8!6?@XSoQo&^befp)l@gytT!Yi*Fv12Dd7(5&cO@0RkTJiCQ|mt)MSoz9d)KG#Mv- zQL3_?J~I(X_p$6v6P_(nXM7_s8mkb`a5K1f(Wv6~r?Xd^4U~c&&bwxV6~*c4=}jAv zyfZr>G#fNo-|gz0KdX0_)vRYuv1wY}6>yjHZrN;E;>MUU>s)k;@&dxyTG@Je)UepE(h$+nfc9iZ(4A ztPZkLAuFTa>%&^(!i^i2Oug=2%Vf=sLqk+X8=xapuDSBUi!Tk8wR)j>`={Ayk(QMc z%mkP+EM4xFPEH4P=SQ38&PAGn!3rFmsA6ab3aoIq`5bgW}0zV$HVP1Hv_k7y|te^%kNJm6ux&f(0CNbHxo5C4&VRwAh7HbA69SwHV{f%CtR!HR)~M9z~9RyfGe& zBoeF01PpXsePGks3Qy#uJDO6^dBZ0yDQU`OV=P$%^s4f)&;ENWJ#@sOJ{}?|ej=SE z;NHL?Fb)Y4@}bqRhnUH7NqGPmRP_7due`w_A=mELSC=JJu?jq;H)@vr+8ltst*xtjmR&s~ z;N2e1)~LO(tpWx$WU~64uPR4>1j~M3?;VEea}2rR7ZI(Qq!=nkn|wS97AUc@%OjH` zY4HBw;kl$tKmCBK5O?iN8UtvPrbRN9t)RcZKmTd=S?R)<&)L;+({&x-0CDJU)C}J1 zy}lT0I_*^Q-rFy!-&;ecqo?lz;ZdoaiKpU9#ZGUpWq{paL&FlO!JFua_XTrJTMMi= zD_@gz=+w{53JKBRp&uxKs66(sy|BK&reN35$b~%^7o^dIr8&}O;$Q}WEWRw#tG-%j z^g3?@R?ax+#`z#vu6OXzxB1-m7E2oUzA{lJCM7Y3ySU+lV`yDG#8S~E1%^D@%zG0S z`ag0EjlX6-vnE_C(!??zy9KJ46setN#YS0imgGuip>As2roj++btR3xC2Q}ZHnuta$j8%j3yVXd7W zwYUq~7=K96*)`V11i)u9+V zJ?5CS%>97efE^MZ8ZO-)ZjL#;ML=N3A#Skl8=(LAj#p z!Rb89SMeZ;SHgOiT_Lg6x|^dQ{OKdhw*lHmw2S)``lFIXngI)Aj}u@Xks$(JcsWFC z^;(&{Lv1efk_HB!rGo^#i0)6b@!$idUiLJ5uhQ%M=yE=uMejrZ-Wz@UPT#c7TX6yC zO;=cexqW53I%#LywBkvA9>ikng2gO^H`|q_c2m6vMc7 z!10ixE8O!g5kENx9ufI2Jdue7Gh}PY{tmjMTUk{(FKMCY>OfNWn zE5MO@D((Bxnkl^9$vEQ$0dK=pOr{$_bJ3u|F#BesP)ww7^s4zJ(bpvo%Svi>M(FFO z*(7^wCfq_prxhJ#xNFS%0z<=yRkytI;QN71K@!I9*47)DfY$3qjeNX#a9CsaZ(xJp z4!$!t>H|Pk)WumrNn>L{e_jC2m`UBs)$@F$#_w9<*}(}#DvU7Y+!1&+*+UG^3SAc9 z|HNC6;`x_WPQ`(<{3q1{LGc?|MEgue=1jf$tZ?pPOhv?8%2q9(JzGOlT26DXp3?e< znB}weI*QL9Vq|(yd~F0tNZ)6wGa6f1khHe8c6#0E$r5=u)ON9&(Zlx zgbZEtLX1N-3nHECf}HCjsdl&n2Bloev6bDQ74i%af4eSr8sRBPuJ<5KZ?w$rVuh!6 zrPR)za!G}!RI4Hkh++8gt+YxJ=w)Fux5b#x4@BI~D2AnxaSH6HUUxyU@$fP=3xIBs z)aXZf#A6`DE~=cAqqAho?W3p<>bg*t7Mr*z59)P`p2a=QzAm$yZJd2TM%Hx(48Z*7 z03HIcdEr6fu~F7bE^={kP8u0(uM||vH%i(knd%2y0xHAUA92s@n`VRQ6yF{Y}{dMxl{mT5l1hbs|qo zss^>?Lf}#~o@AG#=qp2<0z-2Lsc6|6{pOt=`wKgas8|$HL%(L72sWQsfxP{gX8{88 zqXaD|XmEaXU{>&KC#yEAOB#+QtOGsitXKhi(NS|dnGf-~?4(b>2wF}T{Se;7s`ZV@ zPk>lgPBO68qW_k747Q_;q&^ z4c|ZW6dC8AEmfwLAL!FLvL<(Rj^=rKQfj^F>Xwl_)%|Jxp*!*`k~?}njiVk5GUc(3 zZuS02RfV&CefZMS(xuQYlCMi}#v!+^6ihsX1H?;Us4X}K6X7l*B;*MM(i>aJwzaFQ zK!ikk;|MibR0xK*8jfd-_?=dEN*b=t*5fMdm(kb6NThc`Rdl*VM77iS)~jmBn3jlw zx8GoCkZ^9*;@xA{j)SeH5zzoUg1i|}yy$yDQ#?GMnmeBYq$qBckP))+Vo0%}`XvZ; zD2=3!V#Or*409(QXu6i1H)ODS&};KeRdEV*REvrgaAm{6vz^( zmam=zM0Qu_X~G_jLLwq*H4B_NaW~-7cK3$&oVS!BCc@GWNt`b3dus7Zm%HD)X z)|pg3Ki&X678G1B6@=L;Q#(^8Fa*@<-~I}OZhf}r7FRv0pJB;0Td$o@|U(0u*c#RE@UZsmF=2d1*uwTtiFj*fd+7VJh zfeH_;*3=^#xO?vEJGa*rPd=ca==qe^`Qj0ZI~__FO|%fadvS4SnbPNC7f(@9F*|VW z7NVbVi#(q7k|B82Nx-7glPfurF!LX;?$#b1C*`@U><^o-quu#>_B9d>V-zu} zuH?%)`##%-0eI|*`pm+e7GgOm~xj3Jy>F_HB4v9U4n-hJ;gg zDRnK=@;<>mmkL3+)>hS%_y*Zw-bv=tcN3RjQ1wyeygoPA^*LJI{WIwo)@5B?rSIcK zg_oyiFZPNbLK4$F`Eoo;u57MSMC6^<*K<W*a8rLtDrj7L3lqn*R`>fyboZ$ z#bxBCHW!G$tUu^UeVe95KCnXQll*p4LMtaz^0pwo*G^6h+HF(WWzX6yTaM2|jW(4j z(48EeqqTCFq14>Y=#!3sF1+%g!z}-&Xq*kjy~#bVwk{)A&yEk3wG!Zp@?8!OtS75* zCaY{DD|O|!*vy~skKfhG#9bN#V}ArJoRqY78OWqu9ndD|zw#5lCl0LAR~WZW)s%!U zcWd~)OOqKd8HKknUD!5jAPFDL%7dQK_vwDHyv15O-G*dgIm;7t2hXvxH`S%Lyk=l^ z3qBG0eC{Q$nK5i#e{c0+-6A6LacU4lkZj9Kt~XJzNRDy17CN&87UHVm;6sH*UUODy+OeB^6!N_H(My2BgFv_sPS)&%kEiC1JT4DMRhM6O4PdRoQ0h+}PqU7j zz1Cf*&!*Q6HAcSE|DB*&fl(eAsjA~ey+D$-%6jfAB!QFn#cqY7haW_S^hlT(B5VG&3))JlBHXoGBFeaK?R8P zr=v~5ir%LI0@oW$V&ovkxUcLWV_$TrV60HOfkRb$xidO_p!(J zikA3ctat{llm$;G+GFD}jY0zxmXOK(JB>TQ%3? z{jCuMD+uWcM5VXJDQsT#1i;Dhua#1d2^>P}BopGHOid;pexrlkD zvlZ=-x+3Gatlpq&Y-?=faTj@{oskX}YV((Pju&iM3%?#T&a>0rIUYKIPLCZfi5nb( z-$@$u3D8nT#kQWD@EvW8M@nSoiKQO%boeBoASOOKJU}0|JS^DuTo&{>1(H48XQONn zJAJ+Hbo!y7d#|6*UN`4PQ;NPEoHmlrLl>tXA66J;W6{kb_))(TLm*yw#GlK3cZhJx z)kWYCwa;;wlt`Sa_JanVq55njm;9U6x79pyq#PG*d#XhS4wy+8(@q&{=iksnYHKfm!*s(=PRno|o7qO3$?EM- z@hoqj8XopO{IrFRFrf6zRJOpz!MQXWY4YBcMLP%=qi|ozOusy;ro0{ivKM?acw<1w zXr$vJU{Ik8K_aQmlzYI4%cRS9@rjExDyRJ#+WV?WYd6KE^1a%GHi<~n1}PTXmU&NW z@-{uu;L_mWD${Y-SFg2$q>u8+nD-mc#dx(NnnU9%SCU4Wj4Iiwr-D}a=gA&#)Cy6l zGRt3n=VWH9XB8kHTv+dt6nf^^yT0GG*AX&|2x2B)6ASF`SJ{|pAbb1vtrZAC6g=uT z!?bowW-WrJ5?B^T9!MmEn+q#^`Gdck`wM^yf<`P8?}CIYqZTgl7cXh zqhc^Ked{Wrb&ZrdK+>R|M?k=Ty3WP4E1u;ki5oZtcWrMUlBWjPP@BoF-OORJ%Vj!% z4P8?^$?6;#cB=gLbD!+Iwmn2o4t5vX)uz@9Lfi?;P8W>F;?y!SK~iP%smPI9l@zw}WThd3 zK`}sQ?Hf+df%)6{CG!{V2Qz+(sRLh7w1aEMI`I9_-?50$990)QSD#hfmPV4lm$YD* zhQnQ7IJlNkT=#5G^)W%I$Fc3kn8P?n2J8Ae34=x>W+F04Ny(lSHdIVN=&+%DXZIthyu5*`{ZLw-;1n=@RZ0wx(c zj6cZydy#Um3q~ zjaIxzDe8bpN*c5&Mq#Zs=8+W{F+4iq`{oZBX@Ct>bRK%n1Q;hiCJ;)@!Rg|dt92uh zMjfn(>0PctyPaPL`K@oWH+Z=&6N}_N*-Z4~=^K%k2j^K7 z(1_r@ADBPdQq-iNw3p4-QZRQ#wj~IV zsuZVYi`QEm;5$ORe%08F@wiCuE(9Tt;V_aUVzem3=LG4Jemy7)Qxd77bldGx)nr-Y zh4dMAJY=2mAKxE-LtF0zJhGM7Ti>AN>kn|PE?JS0&D=C1O>~4tb(}aksLF0OYP#+? zLz@|6w#rsAfh(`zc)Z4Dl7y1-+S9Da&Kj^s@h9eS>yYf5R74R`zAH3u?K#Elty_7P zx5H_go>W)x4Tsrrh1x2Ot8R0*g)eGV%s^As6GV;X_n;4td+$|$43Wsh80~IG2=hgC zBWT~T+{0oezg)A#9@`T*0Fl!w?RR|*41p0yMhDTdx`=!W@)JlWBF6&qj$EWTK=PKE zl{L$-R1FB41XX(1Sl&{M=bh`ZfKNARe%D!AvyAS2ZyF>1^oqt9r_HPjrOR zatOA{xa21xbQli)-LxO+hnXc>d4pWc;qPW`&-px#m`Nkih=_?xD~3owYwu}`B@8Iz zo9I~6XhOE}5Qu4zE-rI=fnV(c-&my;F@XOxLg{uNJNnQDmh-!o-&8g_(4w57y$Yf9 zUQCjq^g1Z>)~tDk=I35LDgL$}70)DtxPHmeEtbGJI?VQpKe9C^=jBPEF_qrhdp#o? zsZh63o4uBGwy4shdLbaoEyNb$*$A4firc$eN3i&HP`TxW+e`7!g_dR4330TueBU!! zon3Z_$kqXJOFG5Li#Fs2MhF-%GcyBrWom4E2MY^}$yZ?b2_;bsnJ$xG?L`CN0A%g} ziYfKE_69NpkMT#5$Yj%Vi_15$PWN}Ulr-~v1@BT{67132I$PBNL>`W>#Z?+P8{bQ^-E&(nk$ZyWFEIkBRj&D z;jDXZctH|Kr=Ao!Fox%Sb+b>1McFP^T=)wy(E9JSFhad?+(kr+QkFOfij*x`r0=|W zMaSdGLowvmP&bVWOvb&BT{Dc8&GBfOrww1@FW?!)tUmICeWHMICFF`lMMaqa+b+9R zMXOuR_t%`5CD^)V98$iVoSZD%)@@eJ_CuIs5x~~SXw%TuNwny7Z?wqS%GEHPlyUQ% z^cmag7Y2@c4PRUycLN2(Iw&h?7oL0a$E zrGo_`t&->_Y$$;#NlZ)o($a#=+xN`Iel>&j>(dO@+4Z;|Uo(s46XIvLrt8YAM&mk` zw3E}FYdVyb9IJC{zRSqSG&wHCXM`pygAVq z2Wx`xo6Ue1ZLhLW1eK!RonsG}nEI6zE=i*YV(K-@B$_=kz}eeJP`zaG(UJ1%bSNK3 zMWHEa|KTU_oKB$kn}Vr#8mMvF_BQOphqvx4q()@-)__?DBH_x92Ltka22y#073jjb z?P<%3iV6xBCA_nq`@Dl(or^6`f!;G3oef-j%mMqYCgu*1>blQeJ+!HOKYT;dd!P)M6td?CLRG5i?t(KQvORp|M0lu~Nw2ZFB z1-)awjTPHFt#(UCmW8ZebvfY(qBh}5723<&XW1VFWu?d)tmh(?=kq$_qNC3>`Iy@@ z2q5>U__KWpz}Esh{G~42h6Lele5sXwwKkJ^>WnU4E0UCFO0Xmdd>$Z#0lXR-3V zDQ`T#@60b3Ylk14jFO=uc{Zgo?=%NJMQC&pMqoQ0J(%Ix#B&@c6#1B49Kz2Q4+RqF zS=!942uFRPUAF+q)M?`L#U+h-?R4J$=v79&EjUfEPgROJImse}jY(_h8ij+HonOf3 zHZ+90Vace&*#U!sqT<_eYccdr@ys3}$z`Io)%jtkQy1e&p5n$c%Z-UjrhX_tenRhQ z(-QpDZIDZJuRq$`i9<12p{EHVW+bz>#CAPQpYFbv?=jNShFkiA8oSjsb*p$TXXKD= z-C#8O%mABdjVjoH960Q7wqsfQf!44{vkdS~>IK6ZlBr6w`}M$P!s+MD>e;Jk*aQUb z4R~0Amu%j<@@3%-;|uKqANxj0QAK!H6t_7-xO`tkm$alB(2TZ;ILxSOoG-1OQpML| zI!=!iw3*y)GeHWH5ZA*k2&uI#uJ(L}kS?UeyO#CiYU<(FV~F+{$%w>k%z{QTQhes3 zD3|6045ah~EhmSLotrx-mR<=y4`gm!G6c1hqXYMc0k-{9*)t7#41#BhI08yQcdKlG zj@OBtG~=1Eo*<|I?p;45az5TGa{2k*tQWeE1GjSY!x={UWZ1h_q3)vM8FNhr9AddS zX!`{nb&8o+T1j!4wqZvv@b$6o@u(%tR95aeB=vDp%~89x~{TTxtCC9!LVj< zXp+R00!u>vwpwf&_f#V>zO`#YEOm;elz_!_<0?UHgxJwf3Pb&dzLwP``wq3FG01&BxB{~c+T51 zG}Bs{J?n)`R#Z=0mfPk3t%m2D!*4tL?6bSgNP?+PES)_+4%~ z+%fGkdx>{E>$5Yvvi*MB6hANa&W4EjAuHvNZ$Zqp$y&&cBBEyp5P5@ofM5Yx@;Ns* z8}DA6p+TyzK`~AVgE34>WxdHYZEmZTSr1lCm&ph>F2mF&PS8;0Lw+Pgb$4Vma^wwu znV6b-07S&WoaQ|kOARWSwv#+Z8#Sa_hBfkjwRv?Ih-st7b1UGCOv(1gg{XA-!N;+V zH23>@ONK-)S7+U~`ZAZDk!vXtXLYgx0uH%V{hQ9;9bY}0FyfB55-HbQbsQ|R_Db3i zvXQDHiT=2Sd5gn*s>%k5>x@H3c<9gohhyk7`TPpE2p+tRC3v(!OY&pxpq5?Ry5{S9 z!XVFUey@-s&E!Fr00ATKuAo{NsRfT7pYsMz3g0e|e@5)oGL&E0e0%FclANlmeFn%A zbu7Udynd{>^+=|EVT*g(Yvgq}Ty5mgMyS(t=JpDEWmyiFT)=4^NI>o%zLklN+#4Oo zdw1;-lR2~M)NflY?m{sb;C>1=KkL{!UTW3f5b4uf3pUQuXU)`SZ3drwP15jPMqXP@ zZptg(;nTdEcC|z%v^E7#G8%W!F<$%{$L6z3p{Mf9Fi~boB$l%2(?Ixln2r!60q;;P zw*$kz>%$x$E;dTX5d$MuKt z-rjC_Tkit7=gvhuML$txjMUAvfj1gSq$>>(;O$ga9D2RA3ZHuA$G9=el_9ls6?e6) z`*yaUii$leVs1MjxPrT~dreSMJj90a4+bNZU95f=%Ni~;(oASGchkQ;q?9JqhJ-tZ zF8rbY2#vW*iglSPp{x0W^&*^~FRC@tZ%kh~*Lc?Z+y*!bz_c3`lwu~F(Q_^8qK+Ce#Qk>a*zTa5e}K-<2F%X4q@@JKVU#!M z?6)Ek(aKLwYnD9W-)O`cWorBI?tdns4Y>dI@sOBrNhl7jO%BZ?<(H-d;Lz760TRO4 zG$|rp(z5AF;fBk8EufBruS@zLi^KIt;J& z>(iqE_iA~Ajam_lc(Vy^B0KxUTyDOB?=e7JqZc3aG}|9IMAAsH3lv-5D0quSK1BRUJrCayLmy%nIDocY%`PaI zyz&*)PRfD$y1uvpP4y1dT`Ljd>;1V}T;{H)-)+_NP(DrCrGH{7srPqpXl`IiO4Hr` zUsRoCSXJK_tq+Yff`F2Ogwi41DUFD9BOu+~4I(Yw4I&`jUBaQHySw4g8g!d(FAVc*k62Tt$455x|@$)2g%n+zCzKd&^u!JCRG*IWwcqseVKPS~Ul%ni20y zhkxhS>x#`>0->!7<5?SbaQ?paGoO7cVUF#6rXTAqlg4d-Dd&562Xrh{TB^L;{E~~B zFpZAjPEyvEPM_<+Oao%Ed*`FJ|?F<Xrrl67?RX`8P3zu}8t5M2!5~g3zg>M2XOe3}dfG^N@V`G}7gsxyku(02x|Z0s0}2 zVy`XsHrP6VSIsTlqnC__{|V=yj(xLXz(l4&2xw2!*t@4_tmby7Pu-;%_Mlnq=I*9c z6JgrAxED=Ncu`IpP6(Hk>u83QCrC(v@H~J*xNbg7L}B2^1$9*$#*U}=&A=$cX&y#F zy}Ro-+!yb(KE91&({IL%@{c4d_(y`a zH@V(S$d9*&;nAJ|Rk_d_jjEMUb@=vdvQI!wsa&RMVah`zYjzQkCIs>TaL7-fGYlxcuW9g<+rxN^(XQq_=#K2UEQNE83J-59$f)6ij7&QE zGAp@^2E~y_0KqV`hAHzQd+E@*!8E^5G2nJ=?0G^$!kf_W8-p8sVhT3bl%^^5YC~n}82^A1fAuwRpSj^GLX?K-{nJ<)o5^AZr<6g7V931&N?Q zWb^qR1xw+oMh~rEi4t9oa`9IblZ#jfB&X9m6JFR0YHWu_L3bR-HEKsbRDVuFJw545 ze_m`y*)W7*$D0Ebr@2Ydjw3zfEBWzS_e}I6!*BOIJVvUCDD@pNE}be_qJJa@!OC_#vp?nxh%R z>0QS5`&z5{OFv@k`q!ybwa7sGz}#5!_;)ni2SAgK8vlmlJMg)GK&ip1bmy{f<8B!r z?Mf?v{!7w%0=FXW_&zr%DHT#)#?e-ExDW!8ZtjrNzdfojC`@V1PoX^QMGD!TJ@v10 z%WM^Iw(GY^s_;&0_S@Ml{6!-}LsY1qOkMyT_2k6Pm|D&A#K^Dc>k95(AJ5+G83@E| z#v@iKklyO})DFARi&8@IHL3D@!bZ6PEP6jyf90QNd1FENd=K<7eHYVudj_3F?9^0EXVq#r1G`L-RQ^eOCs3xvgKH9J8atSlK&8}1U zFaF424$k&ff$KOk(V#iI;s4g7e2}2m2Huyxi3x#JBuU5Gn&^Osu`%^l@?N?4`dM!x zOn(){kM~fGHXJQ1frnhN6*=_i>bjX#Q1B7`*yrCJcAi;+v=2~C(A-x1P=uUD1g^ld zjpSjW8#MEAOW`B&e=pr7>=E(kj9j-h*<(7vEeGJ6aX6di{OXLXvc`F;{{(89lp(;g z_>QX~vX;zH1jhI=3VyP2V@FTO?^qicN$|ruIkHU1AX1DR2|>YO#{A`Pqf|69IM@r@ zGM*t;)-*H<&5WhR_Rrm)fMSxTm`?d-+fkNzZuoGZcpCW%PjWE2W`rA7AogW@9qnU- z4rgWOZ>}oNUs0nPC z)61we`}UV`t8p7^Pt~*}<|5clFjJ~VQ{FBeo{(T~Pj>~Zd9bg69}%1n@h`Bo1W8d} z;A55`aQf)9NJbi?7Dlitl`0fa=~+U9+zatOOedmT^!FFz(}iy1kKr%nsEMU@cDI+3 zlk~MSm(kI}hsb3bWk61uTNItD4@qS5;kBm&jFb1DKW!R9_p7)7&`wRc8d!q!ITRK1 z0&)=e#Vy`VNV_G^Sv1eori*yJ0N)kTSrD`5>J>ml!u~aKvK)8I*2i+UApiVJ{!u8Y z3K=4-=1iOyl}55(&=%t`@2pg+8V%hILDP0Es*;zT8PjZOJ!mXQFyoS=#Nb3fEqMDk>hWWWN%9V8n%Fk4ypON`?Es3_xrh{ zE-)?*=UrBA_pi`bjeoNp+TP{h5NE!0p%U2 zQVd=Q5Bg=}h2(>~PVQ+?o}x+f;@oK``&Q7)BNj~)f8``TJ%Fh8p9Iug?>{W=C>?!b z`Hkds-Scsx+DSOEoSih;`=@aiLR3#Ka4wRAm~?6T0<`u%27W2gjV*|ABy{2>MLK{8 zMP)G4maA~XCaxl~S^BJT+(Wf_-sC+zIcHth7WWgle^Ft{Uv z9;oBvpB6lDmv7wtZo9ixwS6AEJK_oh8X0(twqZBR*U6bT$ryVGpp}9%W;9r`u8Ui& zRE39iNLIn7;Tk8mK(X>le-bMwg&s_8dB~M)YBT{v{;dvq6B>X**lyE5u+O2MPop_) zIR)2Js8w0RHQM9wH-Ato&a>6bSdlPmwJ<^=25xF8XT@m!HH3-{Q@gxQKt26p}IlYaI%jgad{5BMqVVTo*|4_Vb@ zp!aPDU14ORuKTmr<8q54wUW=xS1rdu`;DSAx(R#~T-Fg7dr+`JAbj{Iuj(tJPZo^p zxvWQ(rrNqE9K-qw{C^znJrS+SEes_D4 zt5qfRlNu|}7FWmW#W>f7I$6(MR3YfM@HnLJ9-PL)b69pw3M|g z{GvIP6bhTnVh?rEgD8P7un)JFXY-&Tr>ID~N#9y>fpB47^KO@VOMvm|4FFji|E80$ z_2h2(eyi@$;#lbc8hJF}WNk1k*>)AsFsuWhyXlE{)BX0@OP002>+5};n}(Ldj-dhO zj!cJ+YBl^yk>7YDei4rLgJx2Ho|6F@xwwttZi!fa&7ec|y?j(%NMIS8iL-iRKy_g^ z(nSm}TNq`EYvLu&P`Cfp1E;?)rn5?-_xnJ5wc|puie+IQ4Ig()4QI=WZD#HXxD~)q zcA+zqNDruas_i4}0mGP)sp)`Cn)##JDc|#DILuEala+6+-p0b|P+8P`{a&w+5#~^) zKb&PvXZB}z6g2pt$i$JB4A)@5U#OM@_4G(oYaVh(M#Cp2e6`x|l9+Sd$n^H~<&Th4 zn76aHB|%TvY`3$_`{%9x%916idGpuIi9ROVt3)3?{_Aef7{}u2pnT~w(a2Q!R)cE0 ztl>o2!tt=_x$RPyzifrOP$d&zoC~~cnE~10cSt1|FMSPzUNx0#aZYUhJ)T`--vxg}Yy<|3gVf2)U6(9gMuX35LtEz6M8EfZ zILJnL?qmoT#v7E|Vx$@JYZjN>hS^qF;en$Wv~rajOHFssy#QgP2+Q7wE7Lh;^omj~ z($n3rtpdj%otE>BT%7vxkcn(q)8DLNq4M!(IEdZugm*e`xqBwJzfgp`<&KhBW|44D z^H0Xqul1ujavY+=T~MH&bfQb0fMlD@v9p(G`bfFwuwGpD5jWOTWDN>He-HK|hgi7u zxVxjKe}rw9HRWDrMqSNU?neb?S<1z4USN+Bb8L%V%QR1#1HX(lSv4PCEVO^o$Y+=C zwAz-pXds@~XBj+q9m0k*JnXNzQ_Pvcs1B5sQoblGO?^w4_Xr$2H=THqx00h8zbnJl?;ib;`Id~?G>hceyf8d}^y6vmp*9ORgYS+P zo*q<`E9$5jcY~r17Hwxz;Oc8pxD056c28eGLIE-L z?v4SIZ27n7T}gU*lf`kDw|nisK7MK#J|pxiOOecsUWN8sNsRVao$Rl!6@ z=F9P~@{S}7D*)8@V?SoX=bVWSz&|w5xI_wY2b*}D;v)nG+Z(IcC*9+vClyw9`MY0W z##w7Q8*A0_N*37>5`snAcmXm=%&jeR4};Tqz*ZOh=Igm6)}XEW&Ovt=1(bu%g9G5a z@?H&2!lkRyn8~(`S$y%3az1Kg;%7$b>+j%j^4fDJ_&_BUxiVA1mG4q>nl&t<&3(mRUIEfA*q~@%jO3X)SNxH{KL5|n1uN+I z#3YbMSnyURA7cb+gu|nzgx!S`9v%*C<6mp$1oYmzgt{*qVsVDKLqn-%+44J6HY}o|qGEpumT}dbQZU;?LC801(RMD|cE0yFw@-3Bz*0LYwIEEh^wrfi zrovuL@GYocFc=I7kpod0-US$>I_jULTGyyw@RAQ#GPvrJWo+9g)bI7utV*cWc3uR^i9$!+m)&p-aW-iW3YY(XI!y%nlloWkISB34Q*7}HVQ_f(O+rjc85YSwBi2rE zb~( z+0jzPDpPx&f}p8>y|umlfLYO`tNC~?mW zDN92p)I@mX$i{>xP#v_GYv-GKLBYjRL!}f#3(9n}$Gl(D9s~W8~0nlwlz|y6Zi5oEeP!9yRiSGO_`4?BUyr z1iI|!E00?*=cr>Nt{>IA?-$RxW`EKc3~n^4Bje808TpE&ZmQ`TCiK#J?QFa}6L9ye z5KR}PLWSo@wG#hG*DfB&4^r`7N1nIZ(qFR`+UD&W;Gt|hUc=ZEQRF`8ib4+2=aGD~8jYUYK~q78Y$xvWv-on7Ya5>{mw)So<6@R_VBz~^ zXTRRCXF`st2?p(3$HvANehEqEXV_Sdx?BzR(>=`i--=XA=;CE;NoZTk9E`D%9SX$q zHpHCT3cct#hF7j;uP72;6rU75-q%s><;2nD7({$=snS*29wF`P-PuWS<@Cqe;~;JQ z{sjnN{1?e=7+;ED)0EE;9k={{Wu^&@eR#h9Y4o?LdIHikbvSB}0j+duLiWtg=q8fP z?V3OVF_H!dY+*F@bLQ?Iha_0JYh1z?9?edg15jM&8y;4dS)ZbT6&xPR(@ za{+kndS@@j3rDh){uEm8Xx9gC^neBN4^||N| zK*4@=b`O1I!S15dO-=7<7-cDhL9OOHvMNbN>%&CNmuXA-!9r+EHNX5 zPZ{`0^B@EsibVR4RQP52L7U~{^(urH-kRDeF6m_VP17A|@x+HCiR0_zIqqYNuCoHC zO{;B+7xUqHwr^N#KP7v&HWhvPBOs)b!MM+KWPyWb#-?+_()@U!Gv*>zM`dCrHO7M@ zp(7sC(G!Ie%)tLoyRYISlbRA;=p8YRPO&b2q@3buQ)ui}=XLN>Ac=g$+4-qkO9KoNkyta4e-B&*dR9hA34_P)_ z(YP;(LCqg^ej>;T#hr=*l~8kj2^V#KQYCQidQMOX;NUKoRS%8W9ZOTH82T*TH_{}f6?Z%_OfZ5ZT zK3-^W7?1L7qw{^-Rs1*gS1crBzPN2(=pU&2^M`pCb!7TW7H{rkz9<#B@REWf1+_(a zUqya()&d?qsu#b8+_-qLxG+;0d|^UvO2HERrjrKN;A}%OngjAj@01kn+MJ_mo1`AX z3)+!=8gze0ULD7#JfY@!%)h(WE6~4JUb~A*C&k7a+|K;@Q9ZOC4XHDg#^@je_Pe?| zaCTOM8%rZ}+c2cjEakN5x)!4IN@3Sq&Bmr<3I;>H^z z$KL_NAo7)y=OJRH6z7}o1oft;8P!b82>9ef+#u(wE}C7wHlBGG6621k@@El9eo@w3 z-?ydf@XD2NaBSmFi8r(`{3EONJR33Q^c_f0GPc)1`z+a@En2dH9)Ym90Fe^Q%&5f-%pbDsaMWBLud}~8ovo) zhyj)*Ten>H1-o!59xLXmTs>1k`IA(irCEwf{D%c++)QWUn}SRFcue{3m7n*KODuBM zo$9UDjeVEDO41=`GHlRyQD#d7FT5%4;I2hkLxJ!cLxGv0r6mT}q9YYUxJoeSL3@FD z5@_4qcxCuI^|uvDLt237YwYQvKB``aQxmRKygl(8*OqH0b%Zjm2?rixAixBRjQ3|T zY0Lj7<1}vz)S<2#6MCk|W@P9&&lSw4O|Iu8!%lqdV?zAMV1}+)59-W8m}fW5l)*O=);;a zvc1nXr1@ck?ERd-2wwsH{B(}E8qEo6pRpJoZ`5frr z|9L+Rrl7u<(!Zg8!MrGY-PzTwO8oqGez@jDC@DX`YC$d4vJ$!D;$)Km7l-! zy~>zDnc$~`l7!{bTeJOz@5b46(n zhj-an0v9l5f;dl0Jjh*8&v$z>*755CP#SM;c=#W$@%EATJg$y<;?;ED3TrvHT~#jV zOs6*3-@PmhAp;#n`%8%z`1wczKlbCvFM_q~FM{^W05;d&cgXF=Evd(he4nk_!_BKh^tn z85z`$AnNT0UtKzUut1+ZY(V{ZS~8GvNq>7R=Eeu@c_(%eojh>vUGVN*An#pJS8JBm zpB)*#w`W={^%#Dkb|7A?61cw=GvbkD4Hd~247>Oo55@k0JIUU4P)3Q{bn#f^7_ zd*z80x!#T0!Ui&kY-m2YVBIk~@_tFt!k1u?2O2PVx6k-rPHdh82&c=LdgwL7ede9m zd~3zf_5|V|->#qtU1yF}&xTeO`#%21vyr>5_#s?0E^zUvljVk58pd>J)?l9xyDx+5#0+Ml!QpWtgiO zr9p^;Bk=UpPEPK7p{SR&HCA6#TTon~!bK2QLk0<>tWXz=Vg3A{?f&Ok`N}-HA-+Mg zs7ff5)tZ8G;~y@?)H>osbg+czCV)v1MUm)Ge})HDRhz25XMlE|oSgJow>@0?$c>xi z_7}k2>bN}g=RZO9f5Etr3VP=0;E9ZY6 z^TQ=yp35}x-hIQi8|Ji=i}wZj;le#V zwQ@#}^HsBP7-S+b!S?=oz8-v-v9>~wr%^zxWrT!y#GVvRSKaAF1$Gw`W`PQASu+as zzv^nlzW!|WK_d|HuX(lWQOGx2v5X&NnI!xUgDQzegY3t9hE1KD9mgIf2s$K!{51v` z@ziEj23NZ!=$4V@OytZ{B(>w*|IMTMwZxesipFz+54^%eDZj1g73jr@QtZfb@@z78 z#E2`!^3?2Mi_T;dqc8dO6BW!a74kFo) z+o89XciT}BUq|$p6fpu+Lc!vD!CafGxpVq5IM}>MbvCQc0nXu6H|0(zazsr9ggubK zfAAX|sNGuxM}2G2;cOb~(d9#y9PGacry8e(>bHl&%y~BW*dQ~t2(+eD-&cv8sKl$~ zD6@#2aGg8z#yo-I7hsn1mE)D`QNwl-XPV(pZ!>pnM}eUro1&|mGuuVrzC8!;kd>pm z{J71H;X->j$V#iSAcP&wQi);GTU{-0H=?4>;X4fqS|8@uDX?Ij(e}Dp+T1c`{rd;9=k^_Jc2yd zHFN5kyy2k71{nk61{Iz*`uI)ALM1~|!LxZ9ghK6UBn*meoW3~YRAFs64ZD8~Hm^&L zOtZ9^a+S-vS7-Tta=qeia#Y=sWPwnWUH3`#foWd9f7gfZCYy<$G6fjmciP;AcA_pa zX$2F!S{Z13<8I!$-#IWn#*ctZx1jSq!s=-q8&-r4!8-vtv(Y+-9f=P!P9$Bs33NI@ z!_BY!fzsQrL>s_J+SdX6eD7O;(chY+&=8Ao@{U^kTNS#OGHY!R6l(O8#3e;c?C@+b zBtkYZH3cv0j}C%)&8wfE8>3h=?MSt6@YS##bg|RH7#9$y0Fs6w*mj0Y;RMJ3XsW@%!p9Zv zp36jI{EDayGdFs~$UWivYYHyPpGc6kS<13`CVyw&tZ@%nKw`bW* zMCS$1riZfC>GVMWAE3`H@*aR&Y~0+vN(EztV()A#`7Kk7htDj~c0Dq=M7)@wxBI6guC@jXK(fo0Z*Yjuo*rK!&~eW9)1j`5q zD)m^AL7xO#1Ch}l0F0QJm;fa|n&Hg8mBD7d)<8p*jWIlulGZCXaPA{M&8KC#IF)

    HxFM_Nc=9PA6!$^d{Wr={=;(Y>*Wa90SH5%$P(a3nzBi1@0(6ujUKYsIrE3nZSJUw)v|Jzj9zPOmF8t62JfqJw(O{loI|RR|zB z|NTQ8jmq}v3j9apDHM8_%XB_>FqxM#>-xL{_Jjfc{mZDGD~`QZW7h^&It%U9pHA8; zZo4%^g>>GC{QUgx&kZC=uosIIc5j=}gWv}?pMUESZPu5Gte<3z6XsReKbWoh%9(;{ zRFdE=bnaGQMnM?GTS$;huytg@@C(0_^hW1y&tHJSS*mX!-DGNZ7gnvweoUyQ%0d zu@)TKp}?I)%&GzD`VO$i$;!hzAx-R47=cr#>HzWhT z{>6cQ2y!R2G!L*#O`! zqHd%0W-A-x`8W}jm9ujB${kuZE%|{ufQT~|8!09`bS4(T0rM^RvC7NTV!W+EYo!Z> zL>v%oeK_S{oT{??fc~%=Lf){|?uRe}_z3QUpBST#+4P<|u1T5m5voOwyrh8!gbfRt zWeDXCh2hiVkfF{@;v_DRU}9hZ5D2oYtgJwv(w{N(DKv2-R(ZV0bvlB2BIa5Q9+STT z$;B_9{Jb~TuH$crGt_HIn^rJYO5Tfq3SFypy|R{wWa^^=N9B7YufOux}Y8$8lfg=UFRnHImN=mm(OTIrU|)YJZV~o!=)s` zSr&*<5a!H2ofq`yoK2$n?hbj&L?6KHvpT9&c52JAChnk%RilZi)mN9J@<>D8px9(YO-k_dp2z{A6{Fexri#MA*qDS_o;3e&_eZCfI! zhS1y*2Yp$PT7rSS(-&1;U0b|F9{CE%8!}%}QLPeUtd&HR>ia^?{K5o*ot+(Y`#n=( zr7Rc}nO7`aioGx8(vwBA)hQB;QN>f1g1ULd5N-LE{}vnILSxD}^!Yd$=Kc3$kR@n$ zC{7UIT{AISsWN|HfY?;8uY39n4a*37nLBy%xKims=0T$()vl>iStSO1u8AMDz!Pxh zli?Q>7mao%tC`5H-|s~f$}b(?&6>5OUXq@7uHP>8mYFwB)WL#)B0mEY$UmGl&Fldc zE=)8V$3-^q*~Fc^8M=QK3lGl?j;{_cCRmHyiFY7q*s@*GN7f|oQ>O-vM4g{c(+Jxp z-U<>W3lgoU%dwznJvIVQxY`irCA8Eww?|kLk|&mGL%rV#yV~*4M1NYDK-5^hK3xX^ zB5CK~xF9!^#BF<8yJy|78_!DQ#{I_rKaR78NG>v^Vg(57Fk%ahV4KviR%cz zvAeVt92QgsLQ5&V#h+-`NyoHhtjuj`$95fUomUx#nV34Grpux_QEQDrHxUrZX|j_F z-=`x6sWMBowa031M&UZ{tVrkf*1qZeCov(4r+x0JiH!4dOiN#fgoAz2_rRH}jwRf^ z(`H8t?x6=ku;&97 zt)bz@!Mqp>W`cE5u)~4%SK+X&AZ@DSTH_f&L6nl2S$+tb5iPSL&LuV@o;%lpwc4Jbh4<3l-AIzS1je?xGUdk{gu#*bLldzWo-g5eNS-?|0aH zkzxH5nhF)n_7w)@$CsRSi!_WOe?nJK1p5ggea<+N*}oaA^0hlQ&fhG!ljc)C@m8q3 zB4aiRPKSA=!F@G;0Sdm;y515Rk5hJO^&OuihoK$NIOHf&57r&AKc3W?W-+q8>{6?q1>plYtc|xQUhx zh-Ins6bZbu;@><|30#%p>?32jL3!P-E?H#x!{i#KW{k;r0iZ-&$Vo48A5&7kpirAH z@XPd45EECLV+ybK?@YBS^Dl`^&)PG#dI1t2j$!?T@`ot zAdAZi&NBV|{l-@@*zit``qE6>G>oq4eCc{Y47d>z377YD6>JT6l0SrXez8Qj`Zx(a zCLoB1uGHOsIVFR#eboEeWpfAeXB4#ylo->&e-DGd)_ED)CDVXkJA&>zORF(Sx&j0N zIe}pRPmd1UNBq}2j{54z3;~QvVv~n830`&ce#^+6)~J0I2J@t#XP$q(j;P-a8C zXNwunVl5y}fzUqaNoM_8bS7-2ZtiQ{9BR|+YnML*FAm%hPnz~6V`6qjni1`EwFDK& zgu;r8-&)RAA|>inl0rB!CN$JiaK+Mn3W)kxLOn7DKd>5Fcps|$Xad7K0PY-ea}$J) zd;zEe(nM|hXHTB$LauRt(}LTdaTwUCp5|B{F12`Yec$)$s$akc16K3|FK3L7iTRQ5 zP;)}h%lCxkx-zhnurVj`6Gt@B{chl02@~!KDVRP@4`CLKWP!)sL#}?z?S93F4%O4s z*6yw_>a)E)-~DVI9ZS-)4eEnPg?iw&TmPPRfmzRsbdp3jf}Jdi?D^Ej2~4Wq@SQ34 zdZSm(^Se2Cj-%hX0*a^izZfN%;Pn{drYjJF6RY~q>A&W+D|KFA_#7A|gg0GckVAU> zxOL}U`3E_bQi{xRYtW2=i6Q5|nR2Kf#V?zMfW%{fpQFM=B^sz&6=Bj6W|He?QWaKv zO!c+S52r|l9!#OKPBrLu*e9LgBqsWRa*cZ&oV+6q^@ZnpDOhM``tg96Mt_^69*MBl zh_>_;HAdwUN3sb$cO4T8>wt16tLZmhPOD1a!~%vKRGd{$MSC=QiF(TKF5UM>!%~>U z@Gp7D>DUy8rXvL{y>Sh_dCk!klxf~?yihTB()_K#NaEeYM*k-;yQFYza)z%wkHK?! zS*h#_6Yd;{(oGi`9!EEEn>LXmx^(F_3U4qMg124;!s0s@I3hmRH=rbfjVmZfVizUr zPF8bMWEAYgURkZ4NuRPy&pOtL2Hw9ao3&i&4#VU2zUNLEdPG=qq>TJZ{f_|}xZg;J zk0wq2lUpJ}ft3BTMZbPl!L~Hh^?)CW@cn1CdzE(*GfT_|K1h)cHQF*06y9lx<0jj`Q_#@zC`v5|`ui6*joVIJeeuW> z;i1E;FH^lnW7$Zy6=HK6 z@%~AYIXS6i=JLF6jEedF=DY8EqB{g$9Mt3<3WBNq_e235zSA@N>!#(bo`{tl2kssE z(U1VEFT|d&3D$dJ;Zi@TKmR`b_dAEF%ZMELg+oe4HRz7g1a+je~kJ-zwjg0Zh`^|M z^@;}>e_MzrlVHY==XrkL2VUXaz{k&=*Us{wuYba;cRiMD4{qnN1nY}5WG1F8E z5BA<+i(58vuAyV$&!13kcgL#qk%|5H3m(U9q5Koo#LxB~h$2Bs5e;mLVaR*GA_MBG zBO)Wo+fz{e&fV@=$ekE&X^_j z5mkn&rz_Pmq+SzniZYjG&bs`J`3FT)AT0@CpzPyf)4dQ=&C-+&ZaKrD?PQt7G!i&E zyo6hWD%YPM^l5Azb{W2lf>XNV94P~{+7o@IPzYxG;oTwX%lRG7{AQFoJ?Y7(&hg`A z=cIrAjndIW=WTWX>V*?PvJNR3)C2X+&CzZ=BTMU01ciyB6&2*xnp?IF9KUcNTXt5H zEixI&F~H0EHmFGS{UNL4LuSw46&1sEA+A`XGNdeci5h_OI$}*t0j_mPjw;()YLGuv z-Ufal;z}BBz*g)v)1P}Vk?y+Gx5KNjx24} zsPh#)k4|{a!^qM)SNb0ilb}42?_eaj!$IfwoVv;*+vs$OQmkAqZ0`>x{TnsZyxW?a zzk`!L5NN+yx5QT$z4y08Z;eM1yCI z_&+5jd~^wr7lqR|#b#h+G{4voR;RO_@&z+}$TjX1?`|6AM|7+_o=QCZWG`?}7qS29gU)um>7 zI8)x?TxzDSt8Owang5f>YHC$;~GO6ZZed0(AZ`F9a5-JNW~v-H%G^UlGNxPeJk*dQl;ec;NW1^{GqVSFAFM~MP6GHuF2DI zH|Bj48Cv^bQ)}6m8{jds3$O1ly?y>|f9tvL@MUV#shOi?&UzffxcJvl|1-LBK8fsT z!cl_ULdcwTUAUN{VAx_)5^uV+={p)}vu+qafW@;X%`5Cfm#lTXhJC&yyW3QVh8AHn z%f8iOL65XTiiU?Ch?3--YJ)Ia}bsvM?#^NtT;Q`1-i!GUYr(9r#P_TQ1f-|w~O zE5uW~eBn~_Yy9Y5!5@k)^+n`Ecq6dLgs!=rkLH3}nl8Jw&_=NKUH;OrE=$O$|F{;M zKjf5@lKTC5yZ9*)S~RH&+D*D%O2wwxsbdKHPcY35VW#dFjZxRf*Fi&Izm`!Em3%v|0dGC9}vUdfZOhW??Sd3vVaai>MVX_+wm==5PKUYS_ z>%F~n#34JMhTreCx5vxp@IwX1 z>-TJI<1xzh+;nSil5~-maVtvP6n!zY8aPkk;AYmh2~A^Th0;fXI6%DGR?|DrA@t%d znP8VTrOx^!L%Z~N=`xtfZD;toFyW-Yk@ryja8}Vc19`$M)`QnH6=^FF2YlF;KXJ92 z7QeNyz!AgkfNv2DB_HqLmwzae-Rx)YS3}qf#Hnx^Ac#~~If-$*KyvK#i)oL<7C+@D zPgjt#9N$A9lypNFe_j*x?OQ4f`6&nj3R_Ab`%pf*7A9pULdvq%# zu)_f_?{y;dnW={M4q1$07HcZY|;RAA|lv8{>aocXMiH#W8h`Ebbzb9n zLyAIrG$x0#xilS)pMUUccM-bb2i3a89j8B7?73rp+SqY;_{JXnjKqkiAEOb8GKmnV z@de5WZBWMFi@c+IWh3*0wlnNZ7k=3GqX7yiSqG))RAONqzZ=mAZ=}%fREIO3d4Sfk?s4gCx%w& z`&fn;;q}&bEw1u!ZRqo}UfbGV;wO|qXIxG<>0Zd1ia(S^@?1vrb5^k$b~xQ6eBSzs zuD@A5&scxtdXJHL%&GVwC@2^S25BP$T0!{Unp5gQp<6u`tDKIyV(;PE!F-*fG<1G( z`O2ek{4FWB?TS&8%kkrE^{WhN-u+(-ZMT!dQz`WxfTkc zpLU9&-$Y)F{p^1V&Z^Veb1MB{fUp+3r#YSgbk6N^lQT%`0W7$zP12MvtHhFZAH zB_(Cx$CZ9HUziTW!AV8I#eo`1x@o_1v79LzQg?1O{>(ya=Y$$Fb%%J?oK#XFZnuAc}tl$G({>2zb&SjzyK2Q=Ej7w=O}I?urlkq`K#lnrOy^U-z>58 zehdsNvLQD;(iulqiB)0Px!_Jp9di_-NLY3Ee(0EQb|FF8JllHNanl;o)6*j-?Ofwn z(4IDi>fqqO?Rkyr-jczZEv?+~F|oiXi()V*QC=qDGP`nnvN`sqWF2~iP(5!|t;J{{ zS6r|fqE&PuQ&N)h{*zED9&73~qv7ks5pW*L;b#r*-<6h=Q`C2~#P6ZxJ2wU}%4SSO z{oPtcn7T{>#s;{Qfkl(VPs}pnH4=qyMq;UsGW++h{WFg?j1`ue2PD1rR_Z(^`9}l} zzhPLv(nw407$Xa168}8v6TR&=wsjWw>7&g45xqtN>K@}6CO>(hsp31R(Y@U}``n5- zYVpA6;H+#*!hBp|)HG47pug~G&0R?-rDp>~!El-?!uSyXKPX#UTPHJdQQ;0$c`XX4 zGGRH$rm>|9A9LrgN7a*GPj}+VcKuB7r^IML>>oRE7ftvt;7$r2k&YS;~v-gAp1w#<65u)-RnIg&{si!zynU0$HJ zAU5qbnn@rI{IuOi27FdFwj834(+kfQOzlob2PR;C&a2t*{We6mYi&^|VV(5;;ho)l zV_uW5`EvI-050;!S5&xh3ho1J&-5hI0+rAZ^wRJ#Rm!!C3q>YIFqL?f1r6f9NY>le zYrx03;qvpB$GgLP{k@53Wk`%5)-%7uN*iu8F&xAFhm5xmZ})rbQ0{cFVNe)dBJ@v# z+h+36kBQ_KDV#SosXu=VQD1QMr?TVbv~g)DgHGgW950v*`Tk^qPFlc%X?3+F1DvP9 z02r$u^gazWO<*jtTim31jq~Hp_HyFqrqY6{Ub;wS-qT*L$9vKI%Ct&IDSW`QneP^s zb@Q)i`M#^953d>rxUtz>^0BhEifn(Uefy0P*dy&%4^9X?uZ0`5r&Q#$khbXQKa&V~ z!)Fw_dr--|8tykm;9Z`3Lw!~qrJji~=_>v$*BhBMuH2o4}|%X-BxSFaT2nISRhwfY}M* zASI{pl_4(6`mGmDCUxM;KLW>YBlA^&V6W;FKKk{s;fcm+peG%KgHfmQhw`uUKdZmD z;bs|8$SwGE9NyDe;K$SMYkMJhFup72>xM7E?PiaqDB#3hi$gn*`DXcQ)RJ@58dl1{ z7KyX<_Zx9b@(7K|!w(CYw<$x&3h60ekhJs#zZ9xrxbq0afv31Q<<;j`v;-pA>g_Y# zL#tVa3OvAHs1d{}%H{nu*2>qWoA_EJn0Ka}`mP zriDpQ1?{muTcHiJ%ghK-j_h>&^jDXq-JSs_q}`se-9+xk4R5h}-qxS~M=Dk-2!ykO zRh6uZI#D+m#$1oXSrNa1=nWOKs`w^ZgH=u#>d7G~ZblHMmDSir4dC`-$h4h7&(z%; z6LC69L<2})E%@k?PG5;MPbnCuQm$+)kdX16*DD27aaxz%>ip~~4kga>R-4?_D)n9l z$=G3`f1Zq%rF$*{at~$S3j=Q#`ns@%Vt+bs4;CG;-!O1RgUcHF1QR}2fyE9#dfc$R zMBfJP$7;**`FS0OMyd>BTcWVtf_c^YtsDl!K60xX^n=0 z7Ti|G_UfOQ+@w^#h=X!i@Y!Z98zCxd(o6_p?`4+vFc*(4j?6YZwkJp`L9ioYFIX*R{RZ8q7l@bItz!eErgWlpxWl3!~)n>P5lyW4WzMF>!7$@9`3 zJlu$^=1^bS?Z_6>hzg2C&s#GZcky;oeA!EUhyIav8Y<%6Ny?Lju?XP>I?zYHxs98L zc-QddpLhlZ*w~6UFHCK`QJ7nZgmS;T45o2aSbzlHmME5`O|qye&_<$u>8XPmf1O;4 z_Y~oalg9ikK;L1_6vvku&L{bXdtHHC05nT~Pe436PxypRc)P?uJf%i)t2fWrlOjFU z_Tp+D=fK&zb&%GRpmp4@{7!bGUyTl&=t3`2<07$qQv=mwyTb_wT!HYJ<|7UW)d)!8 zmpxoAS~gJDufS{$IDh|Vu@z$ko)hKBf{(q;$>tj1qJ1$Ty_ZEgRsN#9P}Wjz%#;7d zEvkV}>)RbE+rXHFH&00uK$hT$DLP|kKz+?O&SvA{$6t;@2@{tRkG%mg2Qh%zR-0=^ z27cE|5L8T3A6)x3$s}a;w_=(pqeItm;rv-E{g;`4}EYP)D{Kr;un&#VKQ4+;>GrwjMN%%jws>WXiHA4X@w?*{Wd6u96@jbJO(w zA0f&#skR8ymYVm*J1Ew81D6k1J>n!CM2IlLbx5}7heuMvFe_R;CHh(D0WwcpUo8;i zDCu3BVpAF!7^oz1R<(SB-X{qT?-ZD>@xW3Ecc|Al?Bx^>Q$k5`8a8BUF8Wa;1wouz318BrAkE~W@*@f{s(aD($; zA^ZF9+V^6ZQzT##BeQf~(iR0xMZkb9+vWahH>HAodDLx^AIv)TwWm*V8X{ks(%DuBL%<{3r zH~z?iBsmwa%0NqNRq42anR_DAEWGFK)V%xL!x z){!K@f>r7;hBhqX8I$wxDqF-{?&2*2Kp zl+oZY9)O-Uv2Q^apDveV%JwKx|Kh(MA?iOxUZ!3=rj7^+=x;T5-AxI}{bpRXoMHiw zzk2o;=tE_|L-8t??8>#O22)u<1wzZc;mt&vP~yb&;ZN4z8T0ytM&C0Uv!R{n2XSDc z;ZSL@!rs%UwDYL)h%)Q`+zmlvA8b9nkgPlwe5YtS5JKBpCUIjKa-Gh)vpyj3eoR&k zJ0d|5@%ruYUiStO?pD7gLJpG@8~uzssq_5eSoE%A;8?$phglip>P#xnwcj=~HtcfH^u^Tvj=a2zXCi&Q~~D*lt<|mTqBm8=wx9Q@*J= zcqu8-R*V*&co&|4WTU8)$>g&y{}RNK=)b045@Guxn)gw`C#POxCv1mLw+{P3Jm~v) zi{GOOT`MSt{u!OUBc8KqQ#bm&Ig?3&u2#WTR6{h!2(Fc^6lHCE`}9*aq$8jv+*xh8 zS1LJi>4`bU4v$JY2t>KtFB23semv}zQ`4rIBCGTvpG1!BGDMtARf!=OLx}_QEMfdb zo2luGEHp>tWBuJA+Rl+tf6EW{qutKdIkIvA6&_*TM@qhX=tmJ@*DKEEy~7GC@!X{f zJr*MlZ&-1lqR zT=Dau#)VU+{wgJ>p@JLEQhHJq4UE%4~;DEIjtk#{J~sAMn}6;&FvjW5Ca7YaK^v z7t~G1c-rC7rays+UZ9xui!sZ=wA~O_QQkO(;GbXU5Vx$YVKCUmcY-`n<(XZfzCphv zZNH=NmJmw5^8pCUTEk5o9??qE%!qh0Ay|yzs&Mc;K@UC5K2SZb()uU_02)0m2o58p zm5suVz>$|WRS&3-d-hyJ*%&`|o`&XyiunHPpB5y^lwj>=Jov%hz7}UIw4FNt5oZ<_ zK7haf3sSx~^H$>ndU=zOk?T0Ez;TXSv(JR8H@8GCGNVyVpEv8i#WsKTwA+6PTz6$( zJ89izLAk*F<>m72=}ekd2L{q(%>PIDLF0fZxmR=%YwA$^)3&5pr6^ima! z2jGLM!NiJMwb0MV$XL#3Y5{s!Y-Nl~EBS5FVw(3U3(<0D7zX^90iRKjLymY|J+|RfX)p)eF(J3Nml5T> zXIVH!&i_}>hfAe(mZ0VyRv^Ue6)@2ip{+0Ww+3L{{W2;HNX z6GN|CmPH9V3^7m7wurGHhF;b!Ye0ia+}4CvBG(oS;8eGH#KZz+i~n-No_yPIIhL!^ z-i)5&0IM*@(_f#b(~G82_8aDwKL!hefWw1H&J}Zc#!MU-5CHY8Pdob44+|W?qN8BC z_LZY6b~KT^D~qjK|gwD!V7aEs^ly7C2nExEY?T#FhFFn84bax(la0tj#yLn#>Y7#aO1VK!4{S|-rTG1`o0U@gJ3N zY&*}brg#l_mD$pVen$QEpSig-(ao$491IVCSQMGBDgm;$+S&4@7c-_|pwx2ryG)@2 z2DEH~Zh;WRPeaK zT7^p{tT9K({V;yGtDiFxPp&0WJO;d*iU-CbBd+h1Ox!rU)R~iKYRY1Z(`*LGJ0{yN zNxUYQOG28XGCY#YcQ|uF;n+QN&%^|0n}g|z6Ygp&c#`_Zaq*vBr|?fM=U`nC2n6}* zs|b!~yJ2I>4yb$$TV+^sGIIS97gL{rxQ`D&_{73iuF4sb$0kvp(L-+n91^DW%8!55 z9W&%IzX+4(+eqfb0Jd$wXvz$2;wQCZHo;`l{DW$*?%DuVQR@8U&;@kr;(TpiAEV^c z`FFL|TH#-EZs&mM7GUlPs)2KJ%={PyRGljasqm&3DqTls2i2lCx$-TYhM}t5K5#4Q z;Qe>|AF@e8_y28IDDa-L6Y}ruw&$5^NuJs5yA&2lQxRsfNFFtZO^lm2_2+2zlmvBN z_mq>MXzP!kRh95(Qb(Bjh$?0UfZ3qDV{CPy8swssk(Ax#k^LO4O7d&wKd(k${*7(w ztTZ$j5PhV4AsRh|LU2);tqOk3hU(#qmki{T5X~~aP$Ya0gYDE{jsJPcR2HW6c_Mi8&%QwT7Xy>2CW@Dyy^r7bDk zn@is*{9ueKFkr$FLf&z6&j$JUnXsfeUyl$lTL8g(@Ai!Y5kYxgd(qN@bmiHznu_Wb zS^<9mcf*QCdc6Va2|z8M%dPp%k+vZO1met_bR9%^F_CU4OLds_8}{n`JMP2;#&<}| zo~hs&6*YrC=!Y>EPR@a5A>i&Jmq4bS(@isw?SHT3n-|!wFvLq!tL+?1g$nfdWLC34 z@q%hWB%qsc;nLDFH5QlY@L(py3e(!(MzNCt0xlIWYUGTtK$`R8p=3WT#-TJ z3w^4-d&=qe4dr0VD5rLgUNcGCAj;UH7yNiNif^$j;vW`$md>xlxz2C+)IWI{F7j8B zJ%HcFDG1pz?CRfWyQ)Mm@(!I_H&27MN)_hP)6deM@1gaq+3~7uc~we0Oyy$~s!`$Z znz%Cp5f@=VKmheZa|!T>nHQ@f-DYMI0{ICsk3V~LpT^EVTGs1VXuUF&BxTDQApXxa zFZJo}GVs@xs=V6e=(_t<`d1)ALWGSp> zuHei@ISP=x(UDlW^DSShwC1s0+fkAKMMNthiY{fwE)nHWth_xq8oc2`5~mthB&>t~ z^wVR>nW&v^!0_J~WWX>~=$#kt2ztan3gmhXBY;gN`PTV$&Ti{ksQc*R%|?0l_d4z( z3rwI*`N1iSdRto$ro~+~sPS3WtNFjst*yZRS{gLDeHxP0# zKJAhJ1k3Jz(=x78ilk^65*&>ro2LajsCL)VtOY{;nd*h@fPUV1kT&G@QizN z;Di;-R{K45ll&g{5$HqwO0xbao%k|%=-;3x&6aMUO&n=M+=igX?y%m<>e)~p;YgR^ zCMUW&OpnpqGUakE9r!nShOq=W1oYg@4cg0bJ@RJ*qR{8x#~`Gj@5^Y8j2|hAD%~Nu z)kHNnK81L%?c+swr=@+*xQ(v>5^`4cvJ*m^jFYb+y6deuhfIMFMVQ?x582_7MN7qr3TAfQ`admzlN4_Mcvrcu4t5xfA~kI* z&)3h$=7DI{EU*lab_C*B$?tlIxsoq-jK{+E$UUu=|5bj^Ybg6XzI9-u<`uu?r-D=v2MR ztQb>=%ZhQ%BJmUPrZ<4eGKRq?j8x~y45KLaE5n7L4v9_u5?l%9Yj(s zJf}9%*Z$Q6QRa#w5*`MLIJFxzpO?XPHo2#Wcay_NI@jiv%Xj*sx!^;d)sT$ z+96nppuP@ZVN3aH%yc%VzE^~ub&hsRiX*j{7H`A4HbOZ#eJ zXA?g$BE-eA(o#T<`ThJtlaPl?WANnUXKAQ+*}_P}7X^;Xwq@XP#Y074?b#Q|^dHa1 z7?Mw(QU;P=9a1Lu8SoT8P2wuuL}N@uJR1Gp|J@l$5wqD;bt?JIhvEMf2lF6o_J$bWU1!H~8kF99&yt z(`0=F3ppo5w z0R|}UUEW@>y4iXW`#-jdLDX$Ky)61{O!MfX>FE>P6*i}qJ&eqFd&!6_m3y>^2DW<6 zzvi3$^l$?bakkw#ta?`ysE`LgU8xi?#Qc~g*cEW4jl^acn}R*^Jx&sgUEX(>67uwl zwcx~~Obc(g=ERE;f*a8PMLuP*ZnF(<1G#iRji-vE^6Eum|BE9{xz>Xz)Psoz^_MpL zsWk#8o*P+w#0pbzEfXdU=C8Pmzplp73^HxYGVFgT-TAe6y%q%E5gZw*h=SFY{9VvZ z6*r3*hIge@Z7klc!|oz=sg3ZmE%EYplfqAZIV>nrZP@p?{)=!62!ycr_rK`BUHw(q zQ^GmQ5nw5w{0l^#l*6pOh>PIf0=t#d8Y<&vz@_hYR|Nv#TcQ`c1sqz><*VK=;<+0A zP@kAi5kZ_RQ^y1FVTl+u!SDO5$Sm30)>dQSw}?Us7()>#b^LT%9&?1h|7v6b%m`>$ zT5)_xQ&{ApaVl0GPx~E1?@E2FT9H~Enr_GSaCaT{P60R2hX|q{R-9NHS!AYpTN7Ut zc)R7R^mQ$Mpkhith_P-JQy^o{W5b~AsFSB!zP|v6s;o$jT^8Q3|%x#|(`PA7p+y%~zE za#hmWEj(B~%y@Z7(E_1Ig`h_z9j5EJ0FW!M{{akdg}~OlWF5@($6tcc^twUZg0x(n zQAPv8dE~QtGz($(3%njjYrd&45v$g(h}l&~X!58^&SVC=P9N>fhVopc!BH?q zXOp~(6TTP0F@t;s!X$JYfK508#v>?Kwdc#2%7N>t=(h}d0ba-b0pS=bl8>IBbgPI` zv^vgAF~vU$vZ9e@6i_dThPh*>lcO{sPkcEX*7vp*d9n`rR9`yrW^ zvhnRdgJmt9n)Nx%XdIIgDg`7Fa^^{19vz6(@w($TwL0GV#_o`bc`p28f(8vEiMFBQ z2MXjw?6&s`xk|s)0+xDJQWr65l(1z^e2n1LyS3Azr}p$y;5w!;D59*9B{OXer?X*^ zg*)62j|}6K8Xw9#W3jZwwdw4)$N4yu{Q{wU|=*S=rbeD^q$aa37Dw-om#5+c}csNm-?~ zMDATQfNQ?(RLpQZr>h{(C=1qY#UT;r6cOox@Lrf%>!|_qgQB8ybhpx6)1c2R_#**s zve|G)V+r}gCTTWu>#Ck(FnaV9Fod{qD$n=+;?l~BV(QlpIXgv-f| zruXRJhy**<)W?VDQq6Uw)FY67Xicav9hF-eEhLYmcF(qrbo}Zj_;gieK zi$!^PqXB9S{hq~B)D3!^P;vS%lMt)4vxS8Pa~mCKWTFc>ny4c-Jlb)7;H&=%&6<|@ zTWsI`Mmq2Z70=R_!VT;YR_NM9{1}NZ59c=SAlYGpkwI^@o|ve@wF0OzvAw3dK z(D-{qt!zdfHV9jm(hs-L!b80!+qz4{J$lR&X@Eh0+>$j26V!V=XtNu0 z2wS8sQl$+r@YA*l;`XMpJo#$U`!64 zylCgh|Yl=WfLuVSnTQ8%xN>a!5{3vyAq_%B*Z`n0sui;Ggen2MmdU& zRq|K$+b0jniOTp|>vSgX+IIA$0?ccUvcJ+Go1GmF5n)WERcsh5W|U)vM}mynA{A?c zJ-0%gko-g!Z&s|uk%EldA|)Gw9J^w5h6F-9<;BV2k4Bf1H8^GY`wr+(AXOlDY%pB5m%U4EoE$L5Pfu?`LEOkAO<+=~9jtAzSK z6{3seBCp3QN$?kg1}W0r4X{O~ zVNb!4KP9;N~P7@UoxAn%^7ejsfJ z9Z?QR-BfKJ8JUtHHO83~$#`}_h2%``GyWe)md}T9U>DFr z&8u`or~Rw zLKkcyc?okS`2@qaYF*2tuKt8*OSC-t%B@2b^XtSiLfJ)0h{gI`F}2HP>((;*)+D4b z*kJ`+Wt#Am;mQYh$)zG%vFJDq z2&kMN8(HZsz>72tOD?{ux^CM*lPZnig8&@ah(mPTbKx-5)?|8iwofqgX>_g>^!WPn zWCHLKh6vzOB;>V>I{M$&K;zj<$2K^l)&u*IPqzz5p&8nA=y-)N=0BRlqDdYJO&>@;R^W@(Rs; z;~7H?R|41J>5`orMfP>=8I$p$UMCO-0rdEWAC4eG1|MijAS@hMHc?p%gU_u(I-|2W z`u^0XEpP)lcadw%O!bppATzr1z=Kw?LFVlni1t!EdK;6gY{hR!(*kXYrgh03B*gNw zeW`4IbhR?|D3!WU4n)zhUu|8k-|m>?fU5ArIt%+aPlmp{WY7=9dZWl-A&W{+vtP3d z&{+B2x6rY?#r{)ZZI1JNYwO!SW0XVdWF4y3RO0V&FQbhBJ5}MPBkkbQHcdI)$&lB)c24H`?c;x37o=U5*v?eS{Sck^9_obnNs?^%#tEQMB z;3`t_G_wo`0jN3;&sV;yD4b_>f10m&ZlAzbjf3fFX~3j6qeI8Bmt2whKH$gW>-=`b z>Zp4W|L?oF&xE9;@tIWtFVn`=4h9+snXpGVB_~2;DhW$-#8@L0c9ueg-!R0@|&vdt9 z3^~iXcueRyIr^xJh$6mL7y{BMB!5)Yd_+lq`}s(xC+dxx*gAc=>84ZKx=ymdyNj;t z-dTU_w+AD!$jRDHk_Qbl4(|Hk#jETLCzis6i|FJJw@uWbAuD#Y!s<%~s%Bq@uHK1Z#cC(VyTl?8nbbA#RbZm4~wtO zFh6AIRi-G=4~fhR)cOUFbBZ4LRFCqj-MD7ZRr&AF-q4>uV3G;*EMC_bI?Nzd5;+>* z?T5fbwMf<4sCB$XN4o&f?dt+AH1$fO>_A}q60GEB`DtJ z?<+r~UXb_0+P7}9z{lW^@FcNy!Si0U+M~lrD=~IN2~`Z3MbC;Tu?(>;(HLs5Od2UPP+JiZk=GL`>8u3wi@Jh^sz(12-sStZ|@=6@lnV?AOjyQ&%cGxV+ZpR(T> z`5Q))oK=4~eYjORsSWZH5A7$ozBmqIzEafv207W0@lV39w=T8m$_!BQ#HL#}w6FgA zyv`PF00TisscA3KwhHcnA9bQyo|Y);R2L|Jrc|zlj}w8z)^V`6!tj}Fgz3V{%ik-{ z_94yksdy9!xA`v@R!w1A$=5~gX=D-p%FBbiim{^U35ZQ4NjLJeDZD7v(fCJ+)&&HV zZr}e0nxAcuXf6nP1p>=2DNHN z`7Gv%VGMw!nDg59SKG_oYYTcT-b7vg)?L%H2a2fNr&=M9V2sto9+WGOpy$;2~%rSG>plNbaX(@{J4aMHlHp6$fM zvJrTQC4;x@`J4d`;e9VT_docD?pWqJKb_~P(cu3om6kBHvtpBwbHS+`T%=&13aw!v zU?|_(cWt9Q%^aWYGH4LK)HA<&j(e;Atv`DZF`XDN%eX(SO$+wl=27V?u&nI z`vtRGNbtfY_Q+svj<+x`FgbWKP_4H3d1inUHatOG{*Yvj8ll(Cd7xL4bdHfB;8vvX zd!65-V@)1Y(3%MB-j^#5YQ|0RApYk-r%~U4!!~ucv{a$V8%BnsG}Zk#zq|aarCEPM ztmm`4C2t+iN#GsfqGqpT%%~1FSV-HqWO{8la%?h1FfWLXrNSd$(S9&H`$XN1L|xb z1Lnak51J!Y5nh|bXOHm$Ku#`?O)*a}X0Smp^-_ApT1@#0=~I-i$OZaD9hqV%M?uX2 zK(zC=NG7yRV#O}8WR9f(kzY?w zuOIw5EwC9N+fT4u9MN{Z%dY9%LCr6SVV<~?o$?`0$tYHw-~ZP)ufucZ_dl_wYT z=#DQaaW^BS*WnwAr>Gs4=<94?1X3@QLiBc>d<)J>7 zZ{`!9dk=}J>1!rBoB&92lWBnXx+hNc>^&?j!FQahgiN+uuI0tIW#2dKIxnSvSw07~ zQsUtL{J@`C|-ZOGSz&IK|V|67oY10Zf#(!FFH_xW95_-uLe< zS18o5q+%#`AOtfHStQtK$^HW-e9d0{=NyDHe+cgc`S{XSBU*xdu>Xtg`C%XMNUpkl z>i!@40uTXSNO6o|Q~HRvF6N1F!r7}$Pfy#vE_%NtS5n3Reo9O33wM^R4<|QXTBJXd zA$)|bZpWAn&;3R=wfKvS1=a^2%g>G8ba=ST_e-3*39$m6B>e8!-!S;k{U~K~aABo^ z#uYqoe-6xv@7)`F_v_kQ)Y>md=Y(p}a<3alMz%QSiK%E*61Y|~-6w0YeE!XE7Rd!_ zV4O)L=MYp%{y~68TSeCy3N?wz4_sz1{B?R+UTXMZq$=x+rL zNIt6q(Zgyzzt{3rh{)BTdCG^wWa#YKGF3aq<)f0uF~td4bA1nW>m;@WVoJKc-{(_`RqDQ_C_mI0OHe@QH09RmqGiK#am@Si8+YLNpoVmL^; zNq`NLxK(gx7N5bFZ2XzQv^1s$)(m?)p>j96A1DPt)FAsLgZ)x7Wl+G~ristl)RZBc zvi2{m#gDnIA6TB_tT9(X2J_(5 z0SN#LghxlCAWZ3ELGbz&JK_(aLVG(YE!cz}SEcLQ5kqf}@S-oI0oCz};2n=|sQW)#%{`+)u!kNNK>8zEqv4VDpdt(|>Ti zh?Gyd%EYiI0Ll1~Hjk8(mHP)KBxQa@GXwQ!HTB~61y(GNdUF!(&PS=RsNkp%Q%w@| zpSNGHC9uIAin{5BHOk1z&PKYMO^(0UtL22O&;0460BbZ;YH@)vex|{NV#zOQ6OQj$ z-s!}{G|16HI>E{+DkVV=S71z7mV_3y?H;~w6(I2&eB-BVvDnNy(!nR=$Mt$vVo{7Q z99Df2=e69$Lgiu`0%7@`hleX~Wp^dqkh9_eQ_SM`!pKu+xj@L!U+&*-&Zf5#B8ZSv z^fU6_J1k(}2QssP6DJifTO9y^iJza3$X~H|xYvHjioI5o4~h9*J3b%wy|Dg!iM)mL zm6v3>pYqbp&U$!G8njfe7i2q_w#i)G-kH#>oyFZ878 z8Iw9$Kp<$My4_;IObGywn4Hv}n$Fb%!Z{zXU;)Gspu=t6ov~u;zM`V-b5~Q%?gF0q zk9QNWPY(~?@WJ^o5J-~{5Z^rMq@ZPv(fmi1Ev7Jfj9kna1ME3xs&;uRd|^SM^Ra;- z`PDwFm}%LmiPl4LwbKcRH-Xdx<)ID|2~Oq<52)2bN#EEqxTO~_F;3U%Yc7zgdVX$S z3W?%=Z^(=b57TK>!8UOWRosU753p`~=MXwYyhlZ7cVt6!^qmG9GxDo%H_39eq5Knm zg3Wn-RDT|~dj;V)>@0vpG0d^CaE9e9B6wmf+$${KHl{Ycptp5$7eB8|TbnljPYZxP zZ)*)q&NMXgi!^%{0N`^s9{<+;{HI%w@9p(mrLd@o5VMHHexz-v#KvE=Q!rTyL*cGJ zi^V&HKaV?BS0Tr}AS}_;p4L3sWkdJ(uSb_}WI(NG(ryMyykRPd8#a#Bmtdv}amnX<7!`ZWBvyLqQ&IUM=jPnDB6f`(ApG0fJM<*7R#3gW@^A zt{7~S*vfChiuYA>^hzE@eHqa)xpeFbK5BSI4D5gd;Aij)VQhE}#S1*InBjQ-y&m#9jpw%r@d2I<&A!zE@aw?#6Ug`xt*uxm zYE7I&5(ob@D_E-nS@edPd~mw%k&&l!sA@;h$m3U&^X0d`;QY6tHcH*8x(d{S_vWH{ zDj%{+Jum`QDH+y!TIIhgLP{;?@8GZ_ymWoJH9)4&5 z_}A*iv+VyYD*MhPy3B68;NE7f==8sQn2YQk2e>_0;5!fe@@%`K@#6(TAjUb^$A}2O zicg2Ge3B!^r{|ShkG=+N4p5ApARu9pZB$sSAT4@RyGwDr$9Cs94mC7aEIv$TtvDkE zlH{Mf>V3d{x`d0sCJS~JIvk|=RKCoO z<+vMR1If?qJ6Bq79o}W`X6rG=;^wBuhJT#{Z-qwge@xfGI>H?261_I?x)Qk?lnP=? z{~7+3jHX{$tG}Cw=Q_gV@w4BV|6R465)q1Z>Gg(X$O8sqhMUmiz1fDl6uAPaBg=J3 zs?x8*%};7?{g*GIj?WL-+|2lgpujk)iJB1TG+3^;iF~$aPwqN&2&?Aw!KCxH=6>BN z5GB3uYJ!)OuwaD7!*+#0O==qT=Qa5}@`W*h#-63W;y|To*UgiGvGHDE%xmI1I4=g~ zWQ|G=&_s6zEF=u%2Bm*bv8ks9urYJsqp;8bvxvEkjf)hPJ0m_Cz-*7y=*3)Y46xmX zydDCFn5FP!Ykh?`793>B_BP~}tg4eu{6DNq0GvGRXQJ||)XUq>tOJM73KiMklAZ+? zJ*fS$Z@i2NT#j5w_=VQC8~t0ry^Tq&o}$my^$zQN)nrr2$)@_xdwYcfX?PskyQh_& zDmhJ--kQ@8JX5l5WJ+g}KlW0(bydqH^HKl43qAw{0qRS=N|sUEPJ1<{yEOs6-g?{o z^RJ7eB5!|5p9h)(NJZ{Xeu>K;LWV=71}kk=y$0aIxM*%yA3Bs_ZUMHwc|*IUnu&fT14TP0 zH~@%j8Ma8$QcJsCAS~rkTRuK+<;bnf(iCbFC_*KbXGuxTu7@ zoIBRhbCy=}xBC1OHV#?Jd|Pg2KREJqy_K%}=0v&e}PpVW0gTlbz1Bwt_zA<&!P$ z#>=}BBIt0{)mr>`i}ZAK2+0FSr4r!U$ngphjQk`p;QI&Qi!HWlby{h^Tj>3#gI-72 zxBNE&rJFfB>nfOSC__oy61}XHtE{4U!f@7rH$@Yv-~l${(Wq7%ODa?%_epYgN+LNd znMaiEtcj09_pEYkc4lVukKTeG%2^!J-GZY=fhn8n)vI<7jY8`CH)pTU4}LJM4ul>{ zl{MP+glaKHL56w^tm)Q1e%y;^sthX^_?FMyi8o#@? zj3atVn`>L+=kEo^!XN%`mYRg+n&J(djjU+&Dx?J0K(!0dwN_@U5f)YR^9YuKlyz5D z{~E9(8wT`o((e6YW=h`Cz~YoaYl(54)6?&^-dn2b#NX&A^s0G&1YkZc(nal{I4Wz1 zsd&r%zFA1_C;1&Ff#?re|G4zFzJDoDW5DcbonB8wfM^Jj(~OrzCd8$Lx%Y~4EboJk z%1bx@eEqGg_-~3Ku`iOx$+2XfK~{ExF_Q2~I75a>bA0l3;?S_YHd#ZrWM&w>K%b|7 z!;#GdP`hvXEspvJwvmhNIZCA~j(5}d3yTL8a~i@Eg+Aas-&6&VZOs$0u2T0yzSgC~ zWuqOjcf3Ao2Md+~`haYc9~cn9J#f(99xFV&c+sTCr@%W;!?%b5u!;l4hlGq@8$u_; z!C$-%mD_f-JVbf(g8GXj=;}@C?bt;h`142p_#fBSnxd71aRR@df*pzaVc%XP_fLwdNY@hJ zKi*`OOO^6nIN*R8!S$AhZ!O^3Z`F&kC)YQhTNi#3fNKr9tU`UdHUp4;%iAITEs{&v z8m@~(@UXNVp;dY}b*R(Qtg?4HPwT-;p2puFzk9wYbXx{&cxkbQxlYk%&3y-3_Kdks zco|AREJ`yOEOF8%L>nz6(3yZ+s#Df4T3uNV1e>hbS>oX^0okn&UZ!^mhFFo_Y(!Nlj<0pRcWr?9Q50 zXLd?vdoWdVg|dh)afy}JWD-iS)(m`JQMb6oK)r*nDxYISan| zUI@gMAw((Hf4NgJ^cyM3$jAw~5URJ2?fBe^Qn>Oe6ZKE)-3E@V`n=>8NT&j&B*Vm5 z-phX-S&bcE2@pp_H%21d+IoCe>M~XXxU)b+y>8x8i5=8P!LMMnXSm}asWd=LOpJYS z`quT`qIVxFJNtGN?|hbM?tj6dP5`LB_+NMxIFGO5o#b%lF%vd0e@Jla;+K!jkzo{dk9#?qVyj4%sE#$*p|^ zcuSJN(CwJ6gDtsz^|2#0E8;HH7CxDVO|qQw)bx)!Ia-(QuKz6MeQrV@(yYt30x1!9 zbC52r8{$#JJ3=DVzg{s)5}0|BxK^E`g5aAw>Ux%_;TB<*K3Yk;l`plbKgEHcf3G)%_4|sTlt!^ioevp4z>qme0@n zc@O#^JX$)+!6z6Y=?$+k5T84JG9@f7!2?{&6K9;OJboRmePB>!%UQ!y%g;H`c!Wsw ztlFal(h6VrNW64IXH*B?yJhmnQ!YHIY}eXz*vHTW0A|thOGe_w=yJQR%{=3(HGk!x z*CFyhff!ZojN!N?q3)<5fF0MGglb#27L!AiLMv51i-s+}Hpv%;5y6l@(ojX;p^jiN zd%Bb>iWURbV~YS7NY6c4eCY=?j#^Cbk?+d=qvn6=-TW-)q?}N%5c<*|`$IMe9zb!M zR0!+R(g1)CF!%dv$lvCCuOW>49#SW%NTs7iIrg-bDH7HLn}Vd|YV5@MRP(3Zo%5M$FKVP}X|RwQos8F&dVE#|)4fJP*xlBHL_2jA zM@mz${^EBh>l?UI`4kz(9RyK72RW1_@vx;#s=}0tRn|P&L*nv~Z2KpIXn5a5Yf5b~ zCD_F*4{7!GU9d3=e&Q?;?^ulpB&(#Qyy}USr%zhM#iwGZ9alGzm7>KhM)5x-FB_59 z-})E{Hig}#qCkRrw^Wy_Jx$($$%XzN#6Gl~>Wygixj{TdIA)ICj{o%Rvob=u-&8&F z{r+rxOf-w&;EtjSMP-S&#d*ItQZG*y65^u#VE_l-ePC1O+a|cm9CW*?%~>r!6BScf zwI>=&g)T98@bTNxXtL1qWdZ~e0~u~OfdJN${*&@kc}pj-D1W*WIz3-n!&`hD%Y<;<_^tL?oaoqy;LH7e`-jhy z3-9?-ed~@D*kwhzhUa-chorBof_gO=kEdFyZpY(X9{YvCl%+ZZ{PK3^eaPQ(UURj$ zuyz(W3`)~j)s+fn(05m=y;B}--p<+IZ~{9Yb_XBE59y3haYcJLW_>@ksa^~-Cj`*u zd0Fq8&PeSb2)r%c?RT1N*^A7A9Zh&8B{-$JI@}=XM$e2SPicJ&=%>YsI4p!)rfesV zE6!8nE4(6RIm`nx$%{BtqdX3u+hRqW4`17NCMFRfwCg39gH!*Hrn3x-virLD5Yhqy z(kUPv(%p@8H>iMg4&5zCNF$AOcXui+4AL!w49zffy!Z27*Z(`8=5Wrv_g-tS-%_f| zjL+SM$%d#364%)`2DfqX!8-j7k}%!eye>j|d7`m@UVdkt;yyjppGm{t!d#6HREr%1 zPc2baBctw?mXg`03p4?z$}iIeP9g}Nm}`7;#trA4O}5CoZsHII^j)$Dq-Z>FXD>C< zm<*PZk|JBNj*fN*sBX`dz|1x>T|im=KBQ(ET zlm`gvq)}v<9a!sbl&KTesVXJ9BjyS<`r(J2bE%=#H?NOvojE_&;q?{JOd`=5s)yPS zQ0Tn586~NUvhB|abk9VeTl0OdlSw~7McCKBp0UQ)K2JIholu5IuFSuHtF2OxU@y`{ zGSToe&b+`T!hu~wWqYLU>z&YKrQfAAzuKFuct(t5Y%jGDM~i?%E$za5e(pI*FOG={ zbia10bI7SG{K~3=VfU3~rSXLQI+>&!qt3Ukf!8yLR%%P(Vl_v3YA5M7cdE?4Ak}HM zs+ZNiqev)pSLBTv){S&XuBg}6xgzz*(IsD}8D1#Kn=_eN=IK0-5>v7JOUs$V0ga4C zP6mjgq9OwgNw_Q^O=>p}BTMDpB5A=1HuWet7dVywFw5RM!^y`8RvJDkLKn??^z-!f z3pWltGuHi2dr+$WJER0EQOP$X#9M+gP8eh`H%e=D6ZKAygFLpPx$p~ z9WXZzUtTgmp*CA3ROC8kqON9wkv^EfPTEw4K~);gS&8ZRFzJh(BmH>rAdy#p3_u_fd)2={VQW>iJVS+3zs8txB*WxSYPS)Ms{2m)xswc&PS-U~d3KZ=E3iErz=ei` zf)Z$B1Klev>9}zU?>wy%{j|q{m&Ab^=~=sP)z=_KC6ih9MmX4n84FN!O3Z$~_b#*P zgmuGzD(SHDs>=Qm!@-7|*JU`bv*K_0=54R573VIJjUTIKYW%C_WZ?CiXG8!AY(MM; z;SC!S9H?m+q#QRw37t15+0WwP9ZUl`RV!H$d4pp7A-m3Il5nn!H%sEQQ_oxjVqDyr zeeTSe8Kxvt3LaaBQlaq_5-}9+3}6ym;%}Wm_zZKY9fj6(&K(oiokRD|(IO5iqFvz? zyDC~|RP^TBgKEI@2@UxeX2>^Btk9}W1Ypv4{k6!&wPBJT!rf9d6W%!qKLUXyO`yXf z-qS3&VCrNBB+4*`g!3{*8hO%xr{X5KV{`aUP<-EK&sQ0xFJPWspTWl1xQK7xO5dIl zMf;JW0mP3X8JXOUvb5a^tQydJ^tPtM9>FQMum@p<3>gJWOUm}y9vQH;L2slUKNw`UkDEF1@A+Lknl!)a;p238tNG#UCVP+%;?q zdrrkf99eRFx0lO>`Amx54vD2&;jSC_f6X2XPGE8gZgw^AUX!=%-F~!{aN?G<;j#?+ z=aCmTl;{6%R`dB^6yEk~ThNT(N@%#&+|M*f*=IHqSpLlo)A>b{g*bkJ-It231AGd^ z!;t7Rn#PgOxX=b|i(^>_C*pT_hx}>NBIQ?pE}@@7c_cQbg*%Id&MKZTJT6|-1tfI3 zp77f+fYYI6*&DDYVc2`B!fxJ*8sC7XvOu89h{U{YQbE81wtA_-vV|YJuG6)g^&&!q z4wsmVnzwknNONENPDVQL_Tu%yIAzv5`{m1^8Ca>g5~V3o$37Mxywk5|5Ug zA!%{tzbeu7Ns64+MZ4XaMz2E^mFSyENY?hd zPqr@hEim%YV!w;0O!CHgIb&pe;!d;+J2iWdFSuDM6q=k7C)|9vuX~x~n*K141xL9S z1*K}sS*6OXJDc!W&^<$Q^ZR`>oSXB!wk_Gwfq|RmjNN6N-?NJZzsLoYGOf)TRad0l1%$(UB(l-!xri832%n&<9TD zMQ7{5yDSn|5A|w{RBA4NSW@RVB;z&1Z1Qkc?H@^R_JsP2ok~@&6}ob{PN1w^aD?1#rK7`zB92EM20l2ie70!Q2u0)!GQA zd?OtHg*S7;;}Wz=u;4gBnYo{zuC9d|k6Qlv@OPrvlRSv-y+~OFoOCJ_C)_uADr>Al z@1EbpMf&jksn#C>%u+s4XXan^@}48gq^?C2)RUYmIiFbdrr8N4i2VUnt6Kw`lYaJcywEFNa^ z4CmbSiBD~6WGcukDdmc=rSakZ(`{+i@RgDlvW8YUbo-=M?V*E61gKW2Zp~`+@}Qb}tihOEEtP47+vT{9?)% zTjG0wp@RjUzkTY$E5Xz59ARmCPZDo4ozY}TKKDhbalF%%)7oL?8W+a?2!uz=zi@iO zbP9bE6d8~IJS-KNp;MU!?2wGS+DD?xZSo?q)?fHr?O5qW7yOhjoZ!}U2;uY1U9v~j zS=c~_!aZlZRS(#?+LwK@w#1oo(G%~^l8~wB9wtL^1S3=#KDIOHbZlN!oZ@_1P#44E zN!;0L_L%8ke12jZAxxV;^>D7UJZUF&;zaKEn#2ynm)-(k?GaWn2!AAmNnPhFnx09{ zz0Tngg1P1sNP5Tz4W4Lj#mAt5G0xG6X$c!{<#nX)l2>aIX!WgU9dHRJN)IU_k~WT& zCiU0dCu=%b`}1yr|4tRP$_Z6oq4qL7YK083$FrS|)O#+we`5OU`Qnw)17v{m2h9}w zeaCOJWOFK1q!lMCje1Q@68r0cLJ4v46ecs-st@sJb^4!Ydx__(a^8iS{o5?C5F0aX)wl91P^Bu$ z5uD@=RmVbkgRYaye_CM?b811le;SfXt7C#BGn`9DXJ%iuFZB)F#qkeQE|u!Ssq$dX z&vJ)fR0k5@j+(StY!`p|9+0ChYbBZsAVeyZghPkKN-VhpQ3jH~h- zCVA;6ZndOC?{wNl-=0#v7fB?Yy^oxq7Dq8Kd)nKvBgXMZ@yHM=H#h_-l?GzUqJaUp zrgGq86W++&h$>WVhS>S>E`BK!1spA8_+FtJXuOwXZC`13-8~M*lk5if+-8OrQgal# z=I#LXf99wQb?1!G1|$bMspV0znlE|E$Serg_bx9~9NE}c$tpP&D2KzCl)rMv>XyTm zj71#DD5ClA2?I#BCQL_>K~}_PJGp8vYA+Y_I+SH!OiDyY`_<^HUi*_$0xC&yR6jO4 z@KWj1N@j)`KIL=>rMG?c|L}oiP!ofznte?+$8mzTfI5nfI^e7@<&H=jGcxoEh(7L7 z=J@-dY3uK#qiV{;QE%*K#$QubHTv6v2s~|^>fu_hqcVHk8ow)`Y#O3F?8FDN%Z2~5 zp~%{=0;Fga*!QsUBBxCNHPaRAa6g|AaNoMAytt_d z@mqxBqi%=E<~ndihXT$>z8%9f=W8_B{Yh6HWJBO!71c+wJe&9&7B2Fp8ux!*05N`k zmY1^;49?*qGr{)uFdQPB$k1N@>*4LrY#j>7h;TB;^@rDBBFzf>m%hrO4a6tsXL|BGACrqJ+SCM zn*+Po(Na`Jh4?>D zXXll_n2FHth)cL)IPgfd*<`fI?bVtIPZBaHF^|v-J{7u36f52j0)2LVXx-y+Ml4CU zrO$sKkGr$y$bO1|6jEG|MetlgSjY1xZIS!kWRZNG>qiheRXZ_TROFqY%U~9Ty5cJD zel`{U+X@pP4r%1%6R|WdM6&aI*XJPHT#FKhxS2*U-2#_X&@!M%ecD;ETB z)7T~;GIFtkLWRy6pTjb>*F@o)7);p4zvrJSuXJX_sVwdxBylDDQa>$ENZ8AWRBGeC z*$~#U-Q(j^eFuq}xDEDmN78f_RU3BgP$5luJuMC)*KuLx6dy$KRXSf-5nmOe8-mFVFl5 zSflSHeIZjgc99qyaOO!?Do|ea`Ypx~cME=5lDCx3!qLS;V@j!fb^JuIXo8uxt+re6 z7}uljvHPxfmpPiUidx7uAr*Oil=bwQSJRZoPJ2aAeqP?MW^^0hyNqAN7)X?3CmVWC zQw;tj7uYuGi$eB9V`v_r&w{baKhW!f1(=gMz%R?WL$K-m!&MiK_@r@SQ8B4$g6r!$ zb8jH}Y9Jh_MPR38(C`_zg_sDCrBP_FZiw6 zTLm@oI$%`DFc5d+C#|<7iqbJ08cw5s^OP?|%us_uW)pc%`G}4Ng%Wh)yfG=4DOl}P z39)3DOKr;-`q^>gAkMhR<#W{#1JPKr7C8nv!m zD{6fO%*MHG((6zyXE<~!68alkJe`oREAcnur(01vqS`7ihP?ey{NC0CjfWz3i2$9W}@iMyR&-yG0aZ0?a+9m9gnuUi+r)@sVB-Y`JUQS zF`L0PFLg*phE9&{kGU%`_>E&9(4uM`=7`MXKfhD*h)4M)^2B$2L|*HJe?4Qq(Jj(I z?z>?Z_W9t(-4<_m)q2}dVTj&h!OW&@t+=t$mH{&H1%sJ}6 z`z@b%P&c-?T?DcXTih*ls~nArx<_iNp@cARB(Ol)bm6qb;&C7GM06^oO`@C3MdIMS zXSF7Jy6DGplPg`|YoGSsWFO+tB4XaxP%n-z@|xz`_B#$qR5K6m3IMx_Mp1>w+G^n^ z1?I|H7DV{;S@0qDzsc?BVyTXS>o<|^*%n8&V*25)B46=%FWZf34etMC!RP%tA#v1% zB0#vg}{Zd%adt2n<^nRj&Ui9d=~^Qn$h!6+O7TD!)<1ER{p@uXNz` z3Fclmb7E%HpF$w)D)AuOh#U)13h)v{Qf1pVm1e00_1@PEumk?jq7EXI#uuv=#3J4&|7^Bk^Nfeo< zY6JZt5L)-)(ARfu85l;55;` zC06^(?Y8Z8+~+IS>eTApnAftxz7o05RL##Kl%D-7g|Mdo?$3Q{)9mr`sy`-~v}^-| z#-^m^k%|qzA^CH0pHNGE>PZIuLacw@+0Q_{*Q$#J3`261W3nnlMZYsUV}u&IlRirmaS=bWfqp@aaW`` zu%;%D@!OuryGHAY;v4O8a)@3LGe1kUZ!W=nI;t3%Dh1G z;wOFGDq!lmBqmT3F<1zwonSq>H^;I|9xy`SGu7_mrA&R$)Fl}A_N_1AG+@I8u(7WtsSDAkw!QnBevsnI=IQEq$FV?54%WE%T0@^2VX>)U?0q%w9e_wTYXv(}?45 zrCvMtXFT6oz|~PQ`|?`r?YJyAKJ&T$^T3m?(U&e66r5-Iq3gcgi43!`(^Jkh>Qf|} z97+o0wCE1-DR)`<+N2>q(P_;BVs{gQ+;YdfjA71H6c&d#fGMxWhvKZwkqBh4QF?gI z0(fb~tA&f&DGY%z9Qby*=s^63QX{I*rcq_OTfg*Sz27lXIX^}D!XdMsimM7IhMV@T zrZBpV8)r}>U&UHL@+{vw`YT2Y=JKXM&c9d8xCng*_2jwb+n!Jn6B@2N-E77#9I(l3 zmwc1O{^Kp*AUE<~e^q(^l>!M-QG?B9yZLVTKREKE0l*K*Dv}cWH>$%5k#$aES(np` zB@)f}lAstUH4;!Oyw549Tk+R;t!Ek!%()lW_%5w!fA4f`O3=JPdL68~LLB;#^SMgQ zbv5DK3n2L6PmlqT1GB`MBebJ=c)z}`UHXsCzz4n`iloEc{q8188F(fCqFHUlgrnHA z;lFubv%;7;F9b&;(L%e(#5%k}#Z2$}fBylFaw^`{z0z*tTmeYurSL zFBBnsQ=wl~t~<^GQ9V$J)V4oR$1x!Z5jRkNBZkxnhRGO{Xj(*tUs;IiKDIiogy~qg zA?HzUI*RuV8%2n)(ppmCFS-r$h1!0LvVcQ(<3IWq>ednU3I}_c(uvaFG`Ev)lDp?2 zZVPJrWKmJ2VG1V0NrAo$%xM$l0*B0ktjq@Ej)5Y|Zi7}i+S%Gz#KJ8r&jgbMA63vrhJ0AAPJS}{q~0I zs!PAhNVGOcGlN2v`tzk9@Q$1&Qcxd^Su66`OW2q!?`GoR^%r}<{dl?0be0(0Z$1%gdQ-@!BnWZAnyKGMa)aivthj@( z?b>$;y)v;;Uz)d6opzwv_P{QI7;=!n%eh0u*{m$ykXz1s8LkXA=Ctv0-B0DBb6s@a zx=ITtUgf-X?sVxK=CR=W8nVh9>9H}BL{V&wlV;h#ilGNT`2JKV3OZ`ui#+rb52@{n ztakF#h0koQ<&RE5>*!clixIiwk)0y0HpVz_k3Y>(MIxJ-8;876DS8ht3}<1(ec^#O zv7PrspUT5_^S<-LY`z`#$L7c|zov>>6Dm|#0RJ2?Pjqx_NUa+uyKOfn={bVkcK65U z5bphMl+DH0|8sCq@#8}06Yw0l08836lzL94qL5p6{skYkU<}WC7(D36w5Uh*!|)J+ zEnb8fxmJnctshmn;~8D6@-fZL1!qS$qO()2QjOg9Sc?+smeYS7IVwfEm4y-?Fcsz( zJie!WXQsD4ao&#TB4^(!h02O@RdF0^GjO-newgxA8Zm~))CtZI9kW0NaDo)_#X};@ zt+=1(m?Uk*r?fbiQQ2A!#*+X0%}<4&sKW6+&uuB$UjnNqYT2ZaD!o#_Iv@d#`dS3C z5Ne)Rd~$EqnKK3OHVu1y$o|w&Q^Q<>kF(EHU%*gN!P=p+N@yO@_-tYsUteE;-k;iY zSh{q*Y^dW)koU(v?dHaZEW}*E(dq{>ag>7`Zs}^16ET~ZEFWt>nIx(F+rmhk^4(=u z(Wi`ER>ubP9dr_8V6}SvNES<`XTjdqjsq2v!9@~;^U3NxHBQ_BVOr3>tVIpF23}?! z)Y&qnS2JS*AT~pD{bAUb=+r)2Gh<_8X}2CN^+%a&w@k`KlX#g=%OzQg6;{3|6|5M( z5pwa_m7RuD(IU~U=3Z2trcIUxE>*!YkJDZ>DKC+oxNXOrVBWx5S|5Cm>_hL`iD)m- zhK`+!X^Z{3;uf6OL}?4jIE|!sq}LIl`CX1Ud}tg79C9!L==IK30u(pU{L7nap)i;{ywk| zJJJ39V=oapjq9w`iJmV;r^Lq7N>hVxK%84`7*D%aAxbhQ8HIVbS3sB$dwW_QikQo~ z-){XBhf_tlA1#+_g%52xJV^yQ-v5mwxTv5&E)c6JULQj~=cNAaoJJ}ikLze^#UA0i zldXN;U*c3f8q?~k){9HL2zc=$A_q_{W(~sMciPG>iO8!$I&OK7EDZ`d}*0!;fbo_Ux%wg>;N+? z>So8x;HoB!TaVy*1|9Cr#Xac@9%L*quFqg^XV(s%PN6=#7 zGtkKlmnSSl*&Iut*Y?MbK*_zau+ULCDcgr5u}Mk>1VVIWd~1D>3~E;KroMMb$GbGB zaG5;J;Sqc;P&R?f~jYl44rpLrLa58*@rWol{2-G!1%j@Tl$}DR-3-3dz=$Ni-6X50rbXq`} zOrAc}v~`Qzrgq2&VhOL!#+I*-4-nlMO~{8HO}Co+tRLj(+t^hSA z7xhaDEeq1O?0Obl0{Vhiozi%Ck`GFo`|r4pp4U*$ryP32qh92_D$-p)>5mL2pw#_U zke$<{3BwmcS*p!#Jb%AysPvJ{+sKvu+HzhTk7(vAa!gccCr5HWPc%u1Qoc8uwUT9m z-K75_d##f!DfyUde+cbNnXQYqz0+|t60npOCSyj*kB19H1AQ#+5!9ripx|9u-`LOE zhZk@@r)xC%dM@*Ghj%VXEE#omf_h7(u-poMxE|y-DdTZIdw(DL7o2YM zxdmG9f6WQ-0V(npBTuo*SBpKieH0;DX-{8@6AZ%dLdb0IpC-eFC%(~+<+i=b^LYrJ z1aTIbPE8}#hM7hR-+K>d)v;B3DaxIP#!2$HG?!68!%Y_teSsKSCf;&`sy(8UJxA`0 z8Xa%SBm$)I1B)*e;E(mK5#Xu+!eWHoZY1(Q$rlz+Q3(Kqu4L#_v!`$-6122LZ z>DLDS%L?ZC@lN>Is<8L-@A3gU^S5-V7ao;hQCcBJS#!>|0P%e7w8H7k45j0rbNfz0 zf`ZqkmzW*@rI{S3bC`@8z742z6ou?*DU(Khk2M2j$`igOX2pJDxv<^e%SdIVrk@t#=D|D z6Q3ASV4DOxRQzRKT-Ck4vQ{suetXn%McYmPPUDapJ%oS-@TA#~4nh5C)UE|GtZJX< zi?NjRf)I@vMU9mr8k}z)&U+=dE@+-o5IMD6jghAt@E^|(-1`G?F|pgfHnc4nmfUrp zvQJa(8HM;s)EAIggjHT(&=p|Hzt6hMRlr2%>c7b|8yX0BB!9T)H!!iH{!Lm_jGm#o zKP-*OIqte`+*zy^d>6QR#XKW~a$M|v6t!4jBsj6qa9nG1?u-sf5xp`@JRDFnGY;3L zZ4Tj&-jFYtHqGGiXS7z&!D`q3ZhWG8Aa8|QH!oYaF8{BI>KzbCt3&%Ldsq_-8W1(d zE;)icNVO8Rb*YoFI^gl&&!Q2MQ&uC}du zNr2OG+?d3ftz2LoU*KVlXC04YWnQeBT#h*m6B_pM!jQ%S+boIj3i9$z_B{@rLi@#} z>3?mp zh127C))h`)O@M;8zA;?L5vtP0ei&Ac=r}NP47yN0T55gSQ=4JN_JLQnGsZu40_{a| zZyb;7bjv<55vX>}KSd*j%; zJ1@b)X_)u(<26lOPSR?R(?<7g+FSN}+1yYq-R}k=+ExS8*rUbL9d7cB3jqiuP~4D$ zXQi=G>ex31->$zbs+E&;agWCbw#;Kt#s%@gJus~3q3FoI=f+L%apNTOsa~%mDG(43 z5PpOU_Ef%4tEweDl?&e+_B)J8<}JrJvd#or`g0N`i+yAyh{rB9^Ep0Ci=nJZo}0+> zB!V*?8au>xA6sp6!=WB%OLb|;H21R#V%@t9gBjfX_sR^CK+99U&k4F21JmM*8(p~VoZXN1F9u0yXwS_u6x4zz+UC!7fCs;Tfx zM9j}|Vt1*>H-n#Rk)F8)U9$y6=<4gDWj-U@*Ij`F$`EK}dZfkXeca%6#_$SA@-P0v zU1aZ^#gp6HLbn`@WX$5OFL#z$bsiR*@>krUhfkye=3_iyxbk! zVXDxxk#rJ|VTzc(md%(?LFd2dFQ%ECuZll-6|{Dgb$6)`8gJ?-`+Bye_MAmF_>Rlf zF}DNDLrPwR_Q&H=pD0DMX-=z0lZVh#Dq;Ocn}Ch>p~_`UI>YAAp7n81%-++F_fRUS zW%(9kt7Jbk1dqy|r*igC|8)M8kjmDr_%N{@xYxD+j=%j*aZ`2(8BY4nxEZ}wjw4do zD$3P5S+e|ow5-=MElOEVGmi=fnx^nN!_1yj`F&D>qT0JYIaBLkPwJ<`6^qvsNyyIC z2nWomfbzI8hFn5U<_hfD`hEtd?M^)g^;dUvUQU~KYKwFX$263~%E`E>1>FYShN)Q3 zCqzUZ>-y=7GC-{50bm<5>Wq81B8L6=F{sfun+ofy+{3o-4#;7F(#oy%d3B|wYk}YX za9(;-t3ePelwc8-lZ1Vlm6e5JG%8Ro`scLwv@9tpzw*J_xRh^tp2%%)GohV@ zHXUC`!Juhvkl|6#-5`u7%&5|j)m|axyy0}bY2$Sk|2*SY?(Xy%7w81w$!Y6GK z){!07joQXF>GHV8vGfqlG)0K1ndOe=dW;l}Nc&C{yuP#Pq-VBDSf232a5m1S@TltIeqWF1T!+ zx8G-LGh8YN&HHB~0-8PW^bjPdM;6B!YU%RAjOJm57!|?LIB>Jez7WRLXzvYX!G~GP zM`Ff2Lkgi20IaD>X@0TGuLjq5y+IWpl^_67;t9(aD?1T#?)-(B3WUb~owAc#c{{n> zvJOy9U1sj-BMMfhHl@GfCp&%nMeX=q7*A_{=Uh)MPM@AW(CAIu%b$(|e>Ai}oNn(r zySDNc#l!M9AL*T@bArQTJy})%+2`#)jC5(4m^JMsQBdF1p}X#^Y7CgpMBH5m2XSop z54v)1wx1)L`tD^QfxOpz+5S+1&n&-85{A_#eqr(oNvG1Se4SeLI+aZ?mGwXb(TKh1 z77_sj#Jog@5B=HlUwn*yoz63Po8v1P=S2-HcORu*U;z>gTEE5kHOL2re6c8<|`x9bqg@Ah7KZ z9A~#$>iOw9*for~*cfT=117Ao)2t>0$APN3Xl|LSdL{`7my$r{vg&Osq zky0^Dru9E+av87!BR>$5@%pr@{ngN)9rVRVe0qND$!`T}S=aJ`J-(REC-hBDivp&u zcj(ny)$fIAUu1|}Xgd9IUFdsuIqV>A!TYMHM3u0&-nmB;tShwXN1Nxc+w+BB?;8+` z)_ppD$i}kgFvmim@^wFt;5+$aNuTfoz##e_I4h(a*gcV4^~XT#`}B|b7vUlv5xO{l zI0zs(8yuJ2kJ>h$4xH`YZ1zNoWGgN%%QfBiqohnnM(Lmnl9b>0W?Pw=G$?8w=Ak11 zpYC-_Ju2Jm>hT}d%VU|273ttnVV}XInfutmiO7P37_E#^M2X#lhJo6|OOu*E3^k!S z=`kNUX>=Bz62c)1C6!MEnll*^SyfY&XtF)jejCu{@C}8$#guy4uLB^ilt2Ui*V6&w zjpBJXP0Pe*LVop$nB}@DL5oUU@x%iND$CY_PfK*|*H<*sS}i8sLtio~`l|lt1u!i? zmjnUQ@PymazWKYP1yPXL+3MzQgm-?FeqAKZ!;W$H>F~DYQw>c3g^SPnA!N6}(AfN| z|4A>pYNDaAVG%r{p2X6AfF&~=Y!3@wBEc^X6p@)If9ghpC$T*+GHolb9+1{r zzc?-Vtf1q!P6;1hP?C{CY5Q&a?tQ-+vY)I%WIvJdr*2s`$ge-mZ$1*$tUo@=exgIp zSqfEaWI!!=r)|se=C5>axUxiWMN3eI+)J!xW2XZ_z#W5!FrR7a3~BMQjSx}NuV^+1trspzel?7&0iX&@m}-*yBL zy5UaUKR(X0=5amq&g(`3C8Ne7#*faXP3>K|0oi1m)21+FuKB+s!gFaK6|v2um5%nK ztshvMqIz^%ZlT)G4d5JX6}IG`GVmiR@1tjDy2U>d_)UJD?KVJ*1Q42Q$|7oWu-|Wu}JmDoh+1XReGhw zn()JcY^scf(!xcYRN4dOm~@BfG`WUgyN;r)jUZP(UKp({l_1xT+9=!LwWe3z#09PL zy?5&nrL!xmd@E9$+wtJW;_3a-h0g5FNE1`D6@7Gc_uEtg)oXk6OxwjJG?1`(LHcLk zFp&AcMx(6jwcry~r*KYxS6_>yw69!l&G@D_?wIa4zT=+7sBMTNo zS!4OJ)X1$@%SrfIO^bn56KC`J4@5trvn6J)-^!UsTumEY65u6DTr6pFOS(Q9n|kcF z=x6F^dRF8QtSvx}e2-heivl^p7yhrjh;gBZ7I$I+upb#lGgH4g-{&Cn>uN^Z&7bey z2ZeR4k7RuMdh_~45RXq2ez;MO!{T=oO+BTgP2N9c7)ltV#r?Y8rqZNi_I~a`jkKc% zs$UTH6$0!F@g?LT`fW9rZT{E@Kn6`?Gxz|sM`IUz6Ahn#W3Z+r>w25F-PlEnth%Z$ z`D8}96eZlba4sDr>FXgF;#Qs8np%^0R|}_uuKhNeCg%)8sH3)bnDTro-+KS83{R_8 z!iq5*a@C{_r((kiZ^0#ASIf&OtHvTeD_zlkr(`Xco_^3~7L+-B%N*MuV#h0^bI7vT zW6EiJ@Qa{M4W?h89Dnhieux%lX{gjTKP@!(=jL0zShXdAipEjt7rhV5c+fZE98tdU zx_^SsFSIL?2#B4yBr+r(C&X`VTf40H(%xpNUUzGJNlzO)Gsu4+t-QyzVL%7DBCXIy z7N}zk^abq4`AlHi7Rmen`wf!V;}JRhbn~Ygv>NEx2g7=}8T0;ld5evWaIT6|47xs> z<$nGhzi6~@LImR z=T40-azAqtgPt`fKCY=1WZ9;3|r*iH=e< znZYxDO4Q;MIQSUKlHe)16dWk6WBt}Gbr`oXcR7mV=9i-T3dvke7lEv65xqD^ESbBU zj!A|APPd-Q+v1pAA#m0P4XnF{8Ca~$EN@#q9+?e8y0mzN8H}AF{~UCnh9DKMmc(K; z`rL_ljKvJir{s$p`FT?U*%VR?hq7k5C1pPVzE8LyLv+jG$~Bn*qvsU?X1Gujrx;h) zomp>(j0X}o+f+`NErLFxD`EkuCdk`N5X|tyD?(;3PckiO(d!Px@J#;h21at}i~+Lu zH|^(Ia)?5G-akDVelLWM>$EYDa<)Y$6@yO~|H>G067Xd)Xd%#bOydNY!=PJ*P!WnYsXHaPZr!!CUzHwK!+%pk ziTHGyYzagfoLmM6)6GoIw+S~|3b^a|DsN!deO6SSsCA&Nbg^1zxQiA%i-|ps=dXP3 z+qh($_6B8g@xwG8f%4#ysSm~fA3O9jx)W?bmGKhv4&K61t8|T~QK*iguXjB#CD}n0 zXI}4k)~HN}Bm4CaejDMJGc22qb2bJ6|Gg#N^2GME8e$uPixCZH$+uEj*j5`XdwD5uX zor_Evw+V@eP#NYiFlVJbdk7wscDO&bNAQG{!EZ5NcpRmMHLW{11WIV^1`9wAlfxNw z8ugvO2rQ^J@)>oY4t@2~7`kj;vNezH+(_@P>0Hm-wj8BhA_SPT0fm*;`Eco6u1B75 z){61jG#3WiW~7|~d^=a~N}PXw(RH;40yXnr+PQ3^^&Z3K~*dG+E3- zkxJwVHw<-0&cIima&Fy+o^$v-Q*3_2_OQjs3wI&#TL*Dhbn>3OSzrXp(2Ms$mwPU6IpM-kPB^)%5%`q2-1A3=bD)?QXD) z$YPst2_I5h49RN8_r*ge0p`g)_dSU|1^lFmaA7?0ox&b=(7{U(1l8we?s+(P#%bJA z!r~vvZVrmZplY2&pmf30Hk(93qRS0!>s$Z&=;;pti6!s`Q0D8tv9U<8 zm3v`$7mvyU0sqQj-E=2-hlXpvpYPZI_tkuF#v5rOg{22bN+u~y^rhM~cJSS7{y&e9T=^zArfN3D+Ylv0NS~y6 zrNCLoKSPBv(_z2xuM={j{r>GcuYL`0{}daMufjf{@6wbODI2OzNSSn|HTo$hX3ywc z7AvRd@Y~v!lH#f#QPaYdze)M@m zXEn?C!x&Z53m*SbixD69`|!m7Dvl&RE>aBi!N}?~)9#3liA;Z^(WF zv1`(177l%-iuIZ)mj3;edJ|#{C5j(-vf>3dm(Za|%$WxK(Z$^8(H)PsKK21@8}JMl z6W7e=d47xGUy3v?;_D@O;C|hxIIRzhA_4bTr(22M8y4L-M23GCn*6Hz8|4hPq?UsY zR00;BhQ5;@*9DQ(G5Z%KIU~zc(#C#tT<;{)V!jU7y)6c@I?D^IGu9N{065r1cP+6(4O?*9eNs)jQqTF*Y{n_o@XfQ-h#wIHRVyL`(M(dY7-RFKt#t zRcQ^E!LF3xgx%oxeTV(LJ8m@TB)<|Bcylu#BE=LbW$!a3t07^(7invY<{)aY+~4D? zJI-(2pxb-N)0vQ%71(`b$M9;a84YE24W+65T-2iNuehnuv+(KgD}#I?K8QbLi0ky> z#kAz9nBz+(ZduWPns{d9{Xbq6dHynf|Ivn2kqojYWvGn2K=8cYV2PjP@bz$NZ`1?}p0Iqai?Veze(E~Yz=N_kS zLC+H4bZb>Ww)9m@i8W^GLmB3}j*G|rW#*fuxA6;h!R$$o`FLQcWz=VKlKG!%lb?P~ zU@QpTdC=jZV$hL6vQ(Gl;;Lk*3V{8eLD!!}pvQ(WYX2Is%8y^N=c+1CTB;^GP-|xj zGT{o{jLHr8Q!_UcwXn{Nd*-X za>Dx1xpYF|W#0CBv*)@>|5pHMe=uwoZ#(8RPmBoS-y6-;>N0v|ArTsUw^g$ATHVHB zMmFMzx5X8&M0{fb09r-29~e8MA%GU;Jkq51%iZ?q_-l}5wyh^LD(Y6PZNo8bk_CkK zo__z+9(^o-S4~ToISIgc631Xy|F|}N#{Hb(P}k4G<^KcW8N!SXog~b0(zcwqAvS%Q zRz(BwUs4rnjFJQ(%PXxwloBa9ps=LV0nL2>?v==Emqb9@!<1DzhQy5V)+_dEZbzCsF2f>i0`nyeX^V`bbEfG03ee zBDKE9`5*Bq{QR8C$i$%PH6J;`QCw_Mu3qEaPRdZgoF`}IeZSc0idbe@LsR-;r-Y6E zcR=~fdXIK!NVruI9E2e#26oDy!zJdFyrlQpzSbbag5{lBO-ytAd+;K#2-@7s#CW?+ zZ&`We`O=S}Vog?#45Gux(!X#bg{4Mfy;FcgQdM=omG9g;9^#iX{Cy~K$LiP$eH&`x zGEnrL3L39bF^Z|M~WN*ZD-xZ zhpp(ul3rOt57oAo zSOOf8BEpO%Y-$94sb@H2*lBtrSP0rAnjr9TN8qYv5nmogtF?Nir&-M(I&*?b;rvkD zlOWXB8DN@MLuMUKcMB28vg30d7$m8A>4k zV`RsC<8%$2dlZB)c#i8lWIcbwJ(J*C6UmY1hH1sUDM$kaN$m{ionl}JXt7$`0Adn|0~Y zlf5&Ft+2DaHnPJFoKONRROpQ9(}(=W9|U!kWRo1ZaDt@t*iMEbuyf`A6pb1sgr1`( zj$3$$iw*jvxs@{L179s@sgaO--jG%^N|k!6b?o2u_KIp%6nHCFI+kgx^{tmJJv?0+ zU-RR!XaT136Dz+c1o_)k5sPMHxj2cglorV!SwOkRFDVdCWOJrd?s2`5+d#M%zC zP;j}(*^Qsm%`pGD8&CdzcG9@u0L%5k1_I&f%s=|Va;81Hr_a!J7Yvrxrk`*_w?B?l z*6ydQ3MzU=J4NLN-mZl}ws=fCOeh#g={54+9uIPxe>F1Y@p7qR>b#gD$Po2wK_f&Z z5 z?P@T;zkY;X?!EnigW%vOOI$QrTTx!Wd0vjRn?`L85+ab(f0LFb(e66N$OPp`#=2z_ zq${BlY0Fa)QEHmTHg4RX|FL^<^nBS$2AD@1pLZ-_07Hfl|Zses=#lsMut{M1Xkr~$4-PbyYoM8{I{Z7Zbd+9X3awP>^xl-pTZ;n zIVD69h8xIPHM$;LJWppt=-V-ZVK6chyRW&g@{iw<% zd>AD+K`=45RBttco3uPrl)jCat8uP8ym1$wMkd^tYtZ2%ZD{$i@0O9G6r!IuUv#z$ zH%k}>sEs8qm%#~-Y*KoJoz=1?)7PXI0q#!C#ax=UvP7UvID2R1O7Mr@CXOgbeRE87 z{MeE7^;qyBwE^-Z7D&7QX&Lb|S9FX9o*W(Q@8zn2GkLJ+k)#F|ZyY{f?i_cwtU_$g zILa(mc#ounW@!GrW|aZXxpGbhb1G8}|@H*R)o-L_8=N4RpC0&HItF6W)p zX)qvCq!v~l2-mNiug9kv78-y^WDO_9UqbpEEgy_KSM`gN zvHg^c9NfO?PC;x~znU_bKa+*Y=TDP;*X45(C9n=dAEZ9?o88%b5nSWUQQ(cTyF@q~ z8f13(WVr=vX(tY@L-+I|sGKlkhJmqnN6wmAPjwr#p^TVh?4B_*s5hQ3Lgtmz6Q+#= zpw&WBEz*)rh`ld7r@LXJk^`73aV`(Uo--?h#tct6)S~5u_c9aZSHG+|Zto1Kt9up+ zMGr7zG=3Xr@N7N9m-|S&Qm`_07yfdj@`Hw6A$AEY8tfIX5pJ-g#M(KhKiT2 z9ihcgJumw-W`qFRr?^d)OA)pk$;6cpT)Kt~{MxGiTb+8fpA#DL$I|SUyV((tjR@z= z_{n!1zDm5mgG31K!t1f)MaE#S9h12_*!D%f=X7oNKlWusMTKPW_Q-*q%g+djF|0lN z)OxvgrDIj%)Ri(3=F$k(aZ)?1ad->RQmg_Q%lbgNClW#X&jenKF?-F(g%W5%E>B}qwb74KpRR|=Q-Ax_3 zeqxSG22)w*CxL9V)=)+d`0Rd_G@W0xeL?W%Ua;rqLDkjqzb)olmp+RAf?kL9Zs-e- zBy$WsO6Kpfz;Pyr-KSnc-Wiy;>AEKL5ncUAx`OJyhP4o?#C~pjW``5=iR>UW6az*u zNe|5AEB59&A#W08$Au_n)s3OJ_E=7KFn%6!ZCc31l2Qocm8;f`!eEsXoxIXjkoFMu zq5}446mvP~=S+vE*v-Ch!TtuiGdZGUo=HSiJFdUSu4mz7=XAltVvFAGYqu;(DBPQ0AWb%X zR1qe$iwfM!IW2yJ6)(|aeX$oI*}3#abr?ERO>pqi=KTuy=ZcS2sz7nB+#3Uz;`VaIxzB}hfvT^(8IjkEi3^cqdBPI6r zJ&a*QcOQsJl7BBA|K!gwEcg#2bC~eBGEEsW>12Y;>E*8@xO=f;>A2zs=s#%?xw6D* zdkj;2>tN~-&2IOn>UmgFk<#BW?EO_!4dw5Wk zj=3GhKUr*Bfwp>EFQfM0Athn+17Hw8P`rvs*Jw@#O)|uz97`IFyi|>S+b%Mfn#epg z#y4$((7)Q<01Pu(Q)X6bru{0vmxBPZjITHPKH)TTGnmLau(n%|*{2%L&M%y{e*m*% zb}U&xYd9EfW`e?;Rc?0c;8=e;YaZgpoKN(P$nB41;IX1!;;n=6J}*V|P=?fseU4_O ztngcNeD&zs3m}xsRbFpF$vXM%jIsD!{^_S}`shieHzOZaWV+!5FLjhW0he3ZM@6RY)A{AsjwNdHJ1&;^>k4m}V z$it;Khq2F}c&JZYsOxA0hqfEHV+^+MmrIJNN4dK;IeR1~_ril8_~TLiwOPcZ(i_xP z5O-O<_pCP7!v%VF__8-z?RI)rD1YF1Z-ML@P&?qhkSj)Y=2aURQi`?o;%s@2=lr=% zUhRXehFoTEd|!MXECAj+#Y&F)|D`J5_v)B5__JHK!OC*es~Fd~|KBGR9MEOMn9Tx< znoVS7ECjx|kO3X-6Vv#=(r_5^0iy!6;oYw%cu~w(B|xrPUiie%}+J z>U#}%9J~*~5@p45EJ3ZF`k^0mHDPC0E45`&r1nL@_&kA~Lr-`bui zvR2S-6LyYLg&Repg`{9mO#FIZsO;vA=T+GT;OnRLlpY~h#)3SjajKC$n7Wp3Ez#l$ zXgDpOIUHs{ggEukP?_PK;M-z+1!yf2Nam&pQJs2S7XXa)z*Gl!N)-ZSV=fcu`y-ZU zL`kc#ac+X2{zzExUuiYR#fH>t_l))i)> zeRaDfX!i7MfQt?74)Um6f=jFbL^I@w;F&>AHJHO644H}waiQ=q83#DDi*ky-s0H)F zM%zOj1mz&NSq42P!}VUAY0+ce(}2%U10&T`e+C4CuLC#ycR2+A?vWg_usov77+@dx z(Ac0MamTN?f2vxDI5A`%FXxfZoh-q*11Ly-w;B=u^y4!+M6E3~3L&-DVm!0u9fn(0 zSvophKtk7SD!wP;zlE0^L{J}Hc87s9t<7m_JkgKGcW3Q_xJQU^b1+i04d@6LlyVER z1-{*1vFi=)HS-V6uZFSVG{_)YKeu(87)|td*T7YJH(c;EBS+W`<};!#$AIOMh8n~v zHT`?aC`4dECtLNp&4gD8SYN7Yiyf4>M%jw4mk={dBm6IS4h0mLXFzQSBQRQ9$8qzw zk;V}xl&n(1Xt;iF_XD*OlPtw|gvvR1<={^l7H&*LC@qg|Ju}~70*d7*Sn>-bi%SR0P`pGho`+sgOkFKoBRC{ z8B#a(IaKv^8kP6=JaPWJ(J!YvD`Qyb^BD*)B@N5%`unGuUBgp(0!hcy`ko|}T_is= zjbsY!3>(M^6#dHBf7g7$`O=yNrrw*pIbo+-l}vDL%`N8?3bqvZWaMGl5v#X!{=+$h zWu(?M&5e5Y{8yY)n(Pg!YzzOPRNZ?(_+z zyUw5dFSVdd7U*V2&1b32#kbh2qsf}yXj1h?a-Akp_1cjqfUJfbIlgxeK)~lfkqCb$ zWtKhJI<3kLK8H1-uY8vQI|_J?wS|SSeR9P~*?K*z?4VPa#D-{l>M&jVGh6PXOo8ng zI^24jv-!`3-(5pQY`4DDv@+A2)f1X_-2qL&_c}yTRzUApyP6>6s%rOmJd9EIa+Ky! zovQRs2G*;TR@99c4bt_T?i!)_8`+2H@ltTTO8t+y2qO*g9m^tpTzBFsD2EOdk(+Y* z$mzq9HP7PNe24HFua&(K@ogt9;O#=I;~dm(3pgKu5wkT>fEAhQ-&=UU&h$QD#21KC zE^@sMJp5@6(R|y0a{fGVeXA`g!GQzfo({4!zN(yFFyYb5r%DF`T}2WDU)f-*pf@b? zaSYiqDU-28$#6Q&u7a1kUjk=wpi(avh|DO!I9IP|yhVSLDEoQ?3DRYOnz%`YZW@ZfFJ<7vb99^R60 zp8gx1b01M5L-dvG9W@S@P@dAsK3z@$hM*t&L(J1Cpw1oy$V4WGSiX50C>*Ad+X#W& z^lVcK79QFqOi=&snd_<3PhEJI@t24|YO>Uz)+ReNsqo$#=I~V&k*q3x==g3oL9H?r z!vhrTZV05yDqwa0+jEfjTOv)c$tweNaUSLNhldtDpSr|@6~S7<23%Zf zX?Bw=lYT9|oa!RG=_Y(n-vMt|2?o3I2KisasOZPo-wt;0Q2G8?Zovk#hX{hEg*`8? zK27u0flAjGo~^c1pNQjtK-q_8g^zQ8OH}?1!jn*OyFG@4bm_emGIN#s?e=Ig&HKV2 zuXqu3U1kP?Tq%o>edm_8Uc@j%1f`!@^&gbCcta6B`ilAKd*W1LNzYKi2*V$*gG@q< zTT4?7X~T_8w``3uM&tMX!fJL(Lpk*F@)9Gd2o!2b%4btW94YKdXvSiwR*#w|*I}Y% z+I2u{>omJGj<;toPDJ0c{^}LKyF* zyl!M>H7Y}jqL|9Oo?WiXO16OY{-~hIh&YccfUi&pPjj55RjKmS(s2qlEvvZwj()?s zqZ(a2#R7|WUF<5Q`lh>>rFJTp_gI(vtRB4+d>hgzz3!naewD-w4*VAlAY(5pdv(uu zTiKEdg!GSIKJIUYM2l!(VM7sd4daSlVF_6#F`R)lk)<==k~8jD?-Lmfvcp2N?7VXX zm=Tw5UAZ%C8oT}l151-;pDzqNvhm0KQX?~3DUglDb&a7OhtHvFh@w!WDJDy1^#r*YuBTQIaEmyyt)%q|Kaq9MsFUF zFz;j1M5wx`Rdwsz_IT4p$ezWdq>YXAcdo%6T^dbv#(=?{Kg#bbj=F_s%!D9=Xc*XJ~?7dJ%!4}}UV8-vtIV`#!8(-leRKD|;+JY$T zcd8ihH&tU;?2BMk@Ln&?Kp}F(<6%)Sx_Zw^uRroleZN0~!ueY&47``$dcQgo#6vqd zM+1gk5x&+m*?9=p&vfArEXxbrRYYJMG)Lxj%dL~0p8|dFM5tknsx^@OexN=$8n;o9 z011iO#&~O7Py=fb9@qQ|^VE9|v(90f#IGqDFjrjoX{!sy)vgX*<=T21F+9YNvScmR z@#!0Vq}^ja#>`aSDI-*p&3IL2Q6Cz}RNO%+6w)++Z`FC@G@h-Rha! zWCU)bhlO=}++ckB{hoGWsn!Qss)y46o=DbBN;d*C>=bGBvl>E#Bt8N@+Sun*!BWF) zMRQ1Z*!076&}0bqC(nngN%C>U=_L$N%#KFo%mo8gm(C@&9<10qTs<`_fsXXp!1h8I zS9UtA6RGSUue@meDt$@l8eF0TSg^-3+_zM4GT7^B#@&M=JFj~t_A{0Z*tmp8lVX5d zfkqDxtoQt6-X99AC_q3dPL%)VxUzJ%5q3=qA&GytSl)>9(TaHSn5{1KLy$zr+Jq>U zObC!$GO=SZeb~~fnJC9>!6o&a@W&OaQahHd;9N@4+nVP2Y26U-mx`k5^>3{u4#5=cp3eu+-N7|KmDWlN9`{YlgORiWLiHJZ2BdHMV}dgfXDlY_-e=E&lyaX}MX zq41H*q7Ok}02<YTB504d7|td8N5TkSP!`2wG1w7&z9HpcaLV$aTFx zv@k=ebMvI()rZ8i5o{!C&xYs0nAd$H${uhp6+e+ac|ci>17+VAkd(aYC_Mvs%OgY0 z!BL$H#Ncp2KSIFUsVT{R&v6kP;xJxr71N9*7O*hVgUGD!{@rAsMI}G?4;c=gV$MVL zshH(=UcW8{LCk~LOLs@o$)|U}`K)(lGZPW$j@j74?j64JMeM|U@a)ylU3prG6fT3a zloU2KXebcSJ9^X*Mktj(VAsPnBmv^|&Q+D_*Qy~A4tgUqGs}IKF-6MDXfvZ@nSwnQ zgw)d*j4mS5>unKc{+Rcu4w*`*P3|culPc4qjO?zdji{*UekNF1F8Km9uU#=cm=HoV z6(9A5%|$G5kzH3kpOu%Dd;cX5h6&wid;sa0HP`tS``V0_(vJ@TibySMxz4{<;&x(! zwqh*JMrmD(6K(4p4g4ceWA+Szro!K-*ic8;!1DPIturOBcR}A7cdjp_HP8LM5T_;1 zcRA0rsTXh#26pykzw2&^6jbvBys$lX<0D&2RWj zcGEe)hz-u1thK6D%;5kdBAU08hYq*L%H5EWU)fWiHOa_jl(79WFXowx#ebgI8+yf0 zMEJe8chh6F{Tcens>17y&{cyJrDkOZuJrr|iqO&^daRi^7bQ-dn88F}l6y;-{)Tt2 zcky)UFRh0YFI_Ozx9|^S63+YOd(19aSXd4Ze~Q)5)dE}$Xi*;1G{l9Zf(Y-HaFRp!&z!al5&0`d5hJp2NWtA4lXPSLHj ziB-kt>kQ`0YYzN1qBO*-4$3M|Q@8oDe8%&;*KbO)701tTYM}MJMeNMIGvwh}Yv8%K z+iI*QQxV+y6OA)UhNnymbfYce)v?A{NE*|*#J8^Y!If^h;bD3~M-5RtE$;N1B1f9i-xEq4 zy~+SA>b;bv3c>h+)YAtor~ZgAfsY(}FVH8IY9oxSkiW4(1gab3eAkklB@G%Pn2hl6Et3CPgqHM16nSR-J7Ut`r1rTy>8>2gm2$HbjnkT1ubuN zx2W27I;*VxeHe5kIB92vgDSmi6SpQ24ID6y%{86QTS+}|aLA79y!x%%#`NLb1(t-v zKRBfuAs^ZrTl>9&l$@hlUGzoY4`_+c+AqC<>Zm?z%tfM>!?hfl`1K~z^TLZZbT)33#2OoUj`p9Qmt9#iOqRms zso1j9vsPAI*|Gh?v+)QDJN`~v!x{-gur5e#>1;?QKZoXn+48XR`XDLZC(o$Z@sHGJ zOD7=hMo-fb4{y{Y-1Ooa-n;Y{#nF<*mMoQ3 zeP@_&Ofs8XWjGF?M4$AFf~zlceAc1QAAsvCY+Yh|XW{Sgc!DShi7A~A zPfS5Vjj8YpnHey`iWB!0=zG2j-lOWHGpiu}6|O9tO!#4nfH;8|QeOuOp)_JrCbK@4 zDPNIdF&BH|7DVb&P_&r*FqJIaQ!r~KzlmTDm*m9R|I`<>rcgj7NdY-0j3` z1beBLyh2U;6LhGBfQ$dDe93dWSq9g^+wMcM@sC^h>h6l1vg(|Z3qZz&^wV-{#Hyh!a1PJRdO5>Dd~jB;Bs7EHrm?im&B?HaXtePnS|5Gtwyj3cL&hI&T1h2m-J zn_6^XqDj8#y)gDzry6R{j!HV2mmiqLU2DI%gcY4vxHDpE0)~nwBM&<-MA1EQ4?K_$ zJjlwm$(9_6U@3w94m{8c51I5&`M1woI9o(p)E^NC-i`Y*#}Q7_#_#>)bW%iKV4mf7 z<3a2VTEh(qO8SzU1ZzN>>x2;x4kG)<*#9C|TX4OM}gDc3)|7<;!2h4?_8{>RyhI$PCC9aHXJ!*WD$IAPEj+Z0ce9?`yzpHf{1yWz#s-JCghydk~ zh)fx5{CVJo?Y@jksQ_BwZ^I3AHi1_Ds)>&BRE>t}1_i`Gd(fD%M5a1h5SD)4(N-Jj z|v(_XAT zF_i3s`B=3JcmOY`OsqX+2**us1n+O(KTk1u+3Ai zt$-FH6W)OC-dPeSekX~FDta4V(d|(_F<`%{cK8uO?zv@lz(JuovV;on0P4VoI3`=* zP+vFbDM2=TOqbFX{4`5PVajD&PMX-tnX*L#J*Bar_2sXF&nhCjIf3WD@EWb@X;j(Q zB6E9F>Morbp&5^R#k|v@qkcuhe3ik7K4P2h*d(GW!?(?CzZmR9x7x=NBTIrHOcGI` z`lhr+1;iV{GhR%j?D<6UvS{30(-Gd9Iy*THjUq(U7we7 z1b}y_{YTs$QBgI+fs5y8*O3R6#`q%nr6n(Fbt7f3yfpPOd8n){rV_sQLz2&XMZ0Y4|!$JgY0BUA53< zBUONc3dg8X*dkOcWBM5eY=(n*d>(1GH~JGN(6Y+y*9xw>X(h;0$Zisf)z`IXj)|x* zd+>E5e|rsaKf=x7I9jQ2!jkLL)n1uc!!Sn4C!3^>cbR;@F@Q4&qH?z5bHuA`P@0%x zKQK6RST@c3cy4dC$&YLq^r-FwmI)rlbNvZ0NcB|{KHWh8gN1<Al?^OG}2i*E@u(=HaB587!6A)h}7zpv)nvr$dPfADGkvyZ5^mxjl{Q4UG#My(L z7vTK#j7~N?6E%xrY-G6Tq*9%wKF#-5j#V-6*#*9SLP(U1RF)3JDf8%Z^}LK2`0u3` z5w=q}#?)h$88u6_@`dxHmpW8&3&h>YRw91eEfII$i{J>!o-Ws})*;d!!iCAXx3IOP zrWKBVDa93zR=2FcC`t0Xeg?(%*Ve}IcCkc$6(qdc>yWuJKty9%n%Lg!N`#l*B*Q6~ z0o1?fiMO!V1bE;LcIM+)ENgt^fP)SD9`*XQu_bi7UqT+;Nb;7C4$6S1HDX_EGA=tW z^DMtN|5v^#P1?*Ns)>NNmV%2Gbf`U=%>1_k0pv+31|YRf%_=O^{G3BvGt6kv*_)1Rr}&qdyFbnYOfqUEJ$yh-$hQEL|Ch}V5K5Z`q1FV&<)#S5!^Goo`D`hU7*U&~bNF82$=zUP1CHqGJe zuIfeyjbZEQ=ZWP^YMjQZpHfAI`VqQ!G^``rpERmgRg|bxOjHPKmg3~7Cn{e*m&?|o z+6F)lbrD$vYw~0igiP3qjI?QkRc<=S)wrYnJdxKoPEOR7I_mmS2@lLFPajpzQrdH+ z5O0dxsiO)e+NLK*HJJr{{-tNL+$c0V$BYH#cncgw0#kg0w?raY0z}C7h^h^m)cpC# zv9^yd(dYiIK?J%!aH1ZR-EN{9FFZIf=h!yu*oL%tqQ;wtosLK&GP6|zSd_R-N&7_! zVIpY>GQYlu3VID*b{4;msPx6J2iu1Fexd}g5QhlCb>yJ9g$w?jmBAPemHPE;5kcGUKopWW{ags*T0a}Se7x{aWi zgg9_m*w~#FBP~=ALdHdo8u9ljlPTC){P7?4M!>!`uNgrb$G)h?QlYtT8jTC#x5nO= zHPh?5*MwJ(;Uy47*P3`0J%gIl_qYmedF0XyYjKZh)mSrZmh)vSJNYn`e(Z}YjhbLp z|ERj+Ec2gKNA?zHUdR^WABHl`|G>`#98qIk3iHb%#(ox$5jHH8hZQR$MMF06nfus< z&pGsd$$$%4pD4t4LCQcg6fp{b=fY_`MQntPe52nStNdwbI?u%%3lit=Hm*eTYYqIk z;m|z9<=snIDSEZ!O$Dhm^@ySZ&mCE8xlHFDM);aL!xXsv+~^PmVYTc3OZ9#OIhWEN zzWH8P^$Q3*9Vdr{OXE(^_c-JYtfb<6etpgZ?4LSg!m5}?w!luNpt`Xd4NSL6<1;@} zO^L=JnR4kP%CjI3ADbpPBI8f<+=vU(b}B8((i9kMSTVIr%oh-VCeAS0lpZgDP$4(D zxp?Ny;DR5l7W|9I7xSszW-PXZM$rOOA}_|(A5@2V`1HkD&#T$Y`0Sm>tK1Go{4in~U|jXtW8FxFzzD zgi92$-Oys1r|{5nxXQxC+jPU=WK=4eF!~`KT?Y>y&4@#GN>Z`_vDq<=n~oXf<_Y(O zsPB2GymJAE#6|GUPgTO{#7dJ3`&$NGwa%AHnhyky+-Q0p*k5N$zc!9N+BXyhB}o^U zNyOPL0ytGPmnv(jf#iC9%uU|kr3xz7ba+I|Jv3wr+C#hgwrfQh+3Go&_uqpOUzf8Q zSD{M^0!=?_rT)nI`Gq(*fUNOwUIsJBk<}q8C7gWlj$b7|GR%>$<=f&N8eL{)S4YbJ zwW}p61OIX8g-4kwg*94o+)WG4mv6IpbVJ6*xI|f#cbNbh#mq|VU!0~+CO)A~-!kex z;?~g`-0j3B#JMjRa3XT?*ll^vF4YZyOt`&&N22}!V7)`33xnCJkQIL@p`NKV7{d1| z?C!Po6r7)Jw-*!d+3Dbpd|c`dK(u?_r-0278_^n)MaYo1pk1<#Ge^ux-~xlvCp0kD znPt$?6ss3RWEtKgpBo5E{SUy17RZMzj4>`P{UL)T~nW< zAhSA(q{V)tM>9(*<``$6&}6Z_?mr(XGhdJvD+eU9Y>=OZuHge)S<#AVca6rXA~=~WB_BL2IkBX!t)W3N+jC4C@po$J#BPliSP?abKi_4FfZS~@)Hq(hmR>%+ zph>Zf@aynYsY3qG-gevQg5M5=?EkR<{;wRN5Aqm5Uah!5D*<0D;KV$yDd(Y&$G+9` zKenvU{uCO3*}}-ZKB~z#aXX8hcM9o}V$!5Cy{nETEP59SjI5za1z)8DFa6jBU$eRO z`pw%mg#=HkT}i?pt!JzU6*Lx$Un4PR2AmDvxQVia9@dQ*kQ#dTA1y5kIYkgBHvCNo z18n~73A$-=7{H+*Sw=8p&1)tN*MUE)qKSBzhs$Ak{|n~m`+lGIUopQvIY|s&H@ald zK*VP~c}#wezw*51faBG)1!UbP_A9aRu>e36+HdSWu9BPAq%~!3bTQf-)vVp)1{^$! zuJw)!x3GI{|3owEfWehWfgGaS+aR-vvdJE^zGAZgtf{;W2*V)Wc+1>1D%6}Wn(U; z^XX1HCjlRZh>O;#XHHodpwwHg12DlrzS*xYR;W!nE6finwX2~_{v^BJc4k^w;Lzx? z9?ZVON-R_|8H5{VtaokiBP>IT=ah?KqR6xMyjtjiryZ+ak;Plx_F{=b|9-=YxxHPC z;7}}(?5q7S2}b}irnn#eqvOl{bELUn7EE=SmyrT|>vX&F=)NIL3bG%S=ag>8hQ~7aijk7M5!Ae=uH02*B`znV^{1Py!d}$G??*hS!b$%Z0ry zSfy1kxvtN-p2{x_r**>({TM_MPOf0KpjkQ_pjNfO&)td!4rh{3<4~Kxgeo2C(0_4f zjqFUGgh@i6bpEg>d0n;6h9;jDR>bcdearqYzToCQb1d-2u&OI7YdHqxiqdVo227I? zfg1ggT#HZzf)AOh_%ux%tUrwJmEG=aSw-Xi)AG|gsYsRikE!F1`YkIKQC} zaJd}mTrh%$12Q=Vhudd5@jp&avQ$4wTC8p`qEn*D>=BrGIk{&|mKP(S;sAGeNDB9d zKpUT{>&OW{{o@SvlO~ui=oKhw=ox`eH&C7}O|dG;|dk-{NmGIHU^Zv>IVaOSUgQI`$IqN?&7mdxf`F&ic+oL_wcOaih*YUZdG z|5mVHX<)<6&-)RMMeUE>9Q1s3Tx52j7xvM*SrYK%E^#6MU^7*+0BqS*JyG%#cSfek zY8q~MY>BFV*LHvEZv#TIeEQ%&;IYT+RcQ(Uf6) zu&WT-{z%ye-AGC)sdl08TOm_-BmMb{p)}-yg{-@xRpk#37-oMWVHW(*x-sIO9nooG zL|+K?g4wo6p3n-!GLl3+PWivNEoyr2v7nJ~2KbPU*4*E&ZV$&d{!L#zTOVN>jHp>A zg1gAU+`b{WU|7=z!27Ozpz5|6sEECaarR}9nWSPj)q)C|uQ7Eu+?R&M?0kU_(_@32&rmSFqBQ^8ubRIc5e{m5T&#hbVZLTN`DOo0l?n=c z6Ips)c2B5wIeY!n-&8(6<=wySNF)n9`lST!TP7bX8SH$iYT7g%jOvMv>Z3BvmQ}cL z=?^2n=5zL)ACYExPV=zMNn-rI(!fHJ6$(YPkN9Txuww-5-52GB;3>e4r#UB-;L4 zIgAa6E24qIG4HiAw)LUoY=ef@C}W$wwst<2ipe#hn5=jeFOff2eu^G0=KcJZs^n(u z&oQ{2nEK)pmCPlWZN`@-Dl?NlLapSj%5Kvm|4vj?8V_3Po;#^YPK_DEkN)@LnMKm0 z-*EDKC#pLWkkba>%&c_jbJ@<^0F@ZbUlYG%<60EG+>TN-){PsI!b6qI-=nw~ZI8k+ zib$g3NF%{*5C=BG%|KJVoe22JEF@`8T|Aq^B7~`tgF2z@z?D#LlwV{f;DJMzA7!m^ zdhQ3S5mDp7LM-(>ruy|L zD2dBnenNjGC2^RKg5E2`={s9fWK6J_tZGc`d-}HdR8Rq_1RZdrsf&TF_>h*=AKH8E zNZ~=&_ELoQ*B#g0F4YQyjcBgTn8LcUEHOqbQv0Yp6chGCheUKFt{@x%R(M z+(P-y)x9$k>559SsT``>A!wqB+9L|pCeqa=QRY{>57Z_zdi1~v94XN~Gvqwdfx6jK?Z;_o&C$`fL8Gtz!mN2NBopOirs7d9j#Fk})o;_B5#-=3lT57gR2ayuJ+Z zF{F8eH>cVKEB12gW%evPgP)P$C33m=Y)(fh2WnXO5LjBAM7U(@jzuriP=0Oddyq+$hF zn>hMr?S!aeO>pP36rS0mj<+aTfJ#QU;{yjztmdbPg6})y%{!A5Nw>6Em(O`Bv!3tM zS;e1!aJBVtJX{3OG#n1PXN<@5ho27oT#WxTPb?2_lpq=I*E}byp!>@U+RjoHbUxUJ zdLGS}@b6wxDmT@YCJ)G4X!at?s9u!L7Wd{2$Wn+(gXQ2v&f=d?Hm?Kz^AB9`SB}he zX;bwTWSBEN-kk`c1ug>o4d0Oz7tN$8@wA}$<55nB%VA2RM$)#CqEj#lPC!T1fI>zF zcOj^_2zQrFLKv~O(MZ@zO_}97Rs1K4k=D*VJxXLUN2F&C<;Pdq0Mo0ZD&76QiLL(l zvfm>mF3XcBpiS4nngF9<^dlg|7F$qg8b5RFb&0*UFsW0lwc1h-lzDg~yjr4u!a7bn zjfZZUrN5wgIOaPiRI}ZJ@8$G`VEWqV(G}XGHOZa4Sg;sg=HD>!Rpd4mM)yhoIW8Dy zp6c^=qAK4S zHuXRU+}kx*uAT*$UW~}(fzA&@8{$HvN5YEf>}7t;t;>IdqEzy5(7;;`EU4Pyj9j%* z)VaT#nCoB7BqZ7)K)eL<;*+LKBWyfm61~mX0FbygrcR1=#CmRxv6B7;?hFl zWMhKuW2c;#9eYuOlYJKguo^yrEu;B|Yy+zRjA zf08WVb`YwbuWZE}51}`%p%GgQ{GmdQY7msXpO+c$m*D?xZ}!$Y_sN)CBVg@3P4s+V z@H$vOh3WeZ&Q_NtGH38rUezV6;C7KYLxm1M`;vDy9OPkjYy2T&db@BMDS7=B$GsQ` zbL}pPs?_uz2@sB>k*zmDf($*V#@NbCHuF=c!RT6ZvZ##~Tlt+2!s~+9TxWxYPiJC7 zAc!GgW%zoYkUhwk`&UByDdR7=tz*KdhgNShi3-5E^Uc1@6A^6Drkvbz;2bX?^7&w1 zXK#-RGM=M73`1Uw-VpX1#cgx7P}#v5b;r~g>aA^G9?eCMfSG~-! zwtXi(ehgzF5Tk)q&TRQgo0Mr*+s)&N%9^K=5sD6h^5MunDRF3~l^bG{!S#EXw*Jbd7&qL3tOm7W6B8QRaO>My<_TvZ#<}&n_8tnU>B)x?l^b*GhO% zw{RR{y1gPwWnRXOJuHt4>MFsUYTwN7>H`O{7jx2)lowINs52u(ANqguXK?NgdJ&e@ zf{Df;!Nq*jRDmh7@^-j!pJcEmyV?+cN{Zv_H;XKia3_*J=8vlM=35!Q=v|^F@cP9R zWws0G9W6KS#V+;Chi5>1BW`^uZ7WjzWlcobyn^b;$|^<+XGTB3#VytDGY@RXLQY&&#R z!r11Y_2cbA!V!`w4mt4I)A{HU1pKPj89+~6l7@v%S&OlLA6}CPLX*~*f4@1k(#fWL z5~f?3$<0i%?fp`tpp*7~K|c(?f~y|(LMqa46nR4PRI-Ml*C)#|7V!6f=^3dE^09QU zYV<<~Eq^^+4CHP!yV~uf7Tu2A?;_Jo%4!*zw)-X-(#yX%0O51R%$~qQs4Fge{e{?Q z^@dCH^`<^y8S1r6dd?J*TzhrevXIzu6a0oHKFEOt^=OTMD)hlq2--=$|Exbds_V5bWwJ{PV@mD7#4x{l{`C8;V#&%|Z7o7N zTH~+dW|>kL4ulncBT?a9WaJ6*+Lo+?%5EpXb!|WJ&*exQ)~d(N^i=0ir!U%Ot4E3{ zj^b0>d%1o^Dl54ysC6y-0@8Pb|3bp883g{tZ?Zh_B$W%p~&>90o+^;#$Ms=iv0dV-Ka8;{Yqa=bx zl6WkY^6cyabzD}WDXa1^4L`8b+}^P|!*1OFH5&9q>wBI7neQL#ATNM89{G;|S#;8tH%~RFnY#mNI0_oI2K{|}u!nhE zpQ=`%t2x*7({$vH%j-}&>j%;Mr0Axz(}&K5w(y77O6rC|(T5^;r1D!_@&&u>REz(k z=_?W7(hV~(bPOHeJnwaVzwZBg zopYZZYp)gB4sEl6cSwOxDXg_`2*!NGSyj!Q5l{a1hq&%- zI-T<_E9}0`N?qyn6wbMf#P)HD!%e~O!Uia&B>5T@Wp0BvA|n5i{Z;&gqov_t0tw}0 z9QUYHWIZbq*$EOsm^|gSrA*!~Ab=rr<3Uq+kyDOxT98|wR;ASU@scpb*ZOYyj<$Ry zG&x2YS>4TT?(F0UP6_3QJij(O$&L(SWhq1d@84FoSZC9}&~2A^sukwOY2u3Mm6ejy zekosJSY|OHj`SJ5DK3+wO^T$MOd8vd+c8;gBz2}3sc)*tQ5)tPK4{cpoCw7+47E^T z#)2DH_t(BW7w+0h)4OpUakvosU5^kGCxQpq2eFxrC9_|j$%}p`%nw+|XBG4_G%w_J zw`oGb0i(TDx;x9>}uJG_JZfyR@Pe^sI~$-FGc5Y1EIy8ZIK zUtr|rB?G+^Td4af6TLe=D@qvucJ#Zt?Ru-|zD`Z)@D!7+l;Za?W=NaojnqZo@;O}% ziPcM$(9Ojgmbk$XT1RG_zu2q~005!sZ6+=N`I8X1S`$KZ(z8N3HtP0vS#A^3RQOp0 zx}l_)b6c%^uSz~RA)4BpG;6lMz=@7sVN_utI39+iP_;V1P6AF7Tgqp>cn=-htKUO& zR*Y7jLf%i&fEhEXW^Cq*v)}<%xP!v{Q{f$?@u`MW+Ec##WuNe=`HN=Adyyi3oakDk z#WFbH&0S!l%sEsFV0;&|=L91B>|OHQ{>0kIBLslEPa-s1UAE#i0`BVnM2LJkiJp4e z6$|q27~_Za7|uxy}DYYtGMBxAT0dtB_&?P#Pv;s z143?Gw>?$KwD-kdZF+o&zzvT{kchxQ1A9EubNhjt*f!2SmzqD);uv;3(jCN^@c_Z>HUXs!E z_i2UX%DiWaN{|*f&h;Kf<;JCX+dSQMM2X{m!vOP4tJv_zhui+_7O0kF4}7WqwAs@v z#%C-^pm4BifhYNuf8Q7T&tu1s$vWu)yRy3%_dE6&lSln#OslJaoRg zKSW?J6(3eor`@2d&6P-z;bI_k=sCAiR{oDKKV7)Gyy>u6CS{t4xnaMX!Sd;fS7noE zPm{@KNz*q+9(;eCS97uP$8^B1m;G>>5KQ=Ig3?L>%5_CslG0w@&AV_|yft7Z#jbt< z!Uw2J^5xqL4FgHaE8635!6Mo^f9&whQlmLoJuf6nl=TSIZaNQ6W`uKw9w+m$O1>~7 z!GB3U1t0^(c!juO+yW#INM8Ou7S}SiNJ{akBzwer%=}e4QE5_+L8emR&1r{N8 z>^!y|qyvZehyq7Ur@F2sPczqmqINPTjZ-hjj1+Dcm?Y7#f0rl_rmO3l?VkuX^ZLk% z6ZU0i(*`2o8(HjWeYvWAt5c`HpV*r*4^ylAdhbP@b5TV@)mi&44X(7v7h6YF0)W00 z9ghcIeh6`Ox3t&O)QUWTtT~ma-JTRicPC;OR%5|Rj*;F37W`#N&BfDu6j41GZPhLf z^8{xm+d7GiX*a*uWh;IW8VhT;#5vvc_Hznf_^KCe400PLG6e9l4J`?V<&8m*bZohKfbQyaztoV zN}Dax12|~vY$)va6mE(svZX8(e2ZzowZ@24=U$>aY#@xWIO?`m{sloXGuC}(^3m)1 z`a~tQ_RbCA%KIMtw*GM?{kUz)sP*Qg17Tj0>rbU_sWg#2qV6dY@%mG4m<$*kCo2>A z$s~X!^?gvA@s};9_|-@U%O%qq-WgKwzu0bM-{&fC_oRCI%(d4ey`kM~3jm96^l$>C z+^u6Z6958V18?fMpVhqm|7f%3VGybfg^K zVW_5ku-Dz@vnGoUh}(@))r6eO3Zr=VE87t<7Gm$PyxWF235XYAEGrt8tP5qHL? zN&)e1LT9^N$|ke1qivTySGD*%Me*6OG`y=(v1x5BJ;agmD3BYLPEU|&w=xwlskZn) z)8J{k)@2$jf{YYze5Gw4u>LX%@F)G(Q%@AS_M~HYFg!f@ESY#0*CT{N>~Og!xv&sA zTOqx<2)!t*I}&dVfRRq{*yqCLbSp7$LZ;5+aMn~uC43{A6Z!|a@mir2kBKfl=(;yL3d0lIQzaz zsRaXzxA!0mz=sk`N1Sk z-L}L4=xUoq3%vdva3~l#21JaC7Ha#O@D0-0w%AQ=ZD?y+k8CxrnXurRBtIjzd0-6u ztOLt^jt+)5-v)B1m$7fwy***KpjmF=E0ClDkb}cB2Y=OtI!*w>e}#W#H{$!?>#|rH zKa^;3XDS+S;q`dD<@*O-^`#n0w|{v_hv{F9d~~@ab!IC8eA&%6-pXV2wJt>nayr_( z^r5?^NJYSFYlb%OQ4-sx>YfxMHy<68*xU_8J|p=2zQzIXjh-jp-8IOW; zGyUwsBs(c){`wLMX(=l`DzfG~Q7 z6(TOqhi`*c5hcAK<>9$L(NvW*cp-FmpidyIl;3=^vQ*Zg@8BWe!o-Tad$hU0!9miH zTD5eXu~rPL?517Ecg?O9g6Im~zYnCXxnJigJ2J$9)v_7~m%RJ%gQ9ZXTk2AiefH0Y zs0VPIy+;uJMi?MAteE>-=v0qsQ*~e{kTUZ&g+I z0588c-zX`jx;P(s-@Wy^n+;+2WZD)}~Iv$j?p)O`oZycxqmb_69@Ng4Lb{$k(tWcVUj z9{11kSSi0>ZNx%a1{JVXEvsBRMSgg<1Obl_z!++akh4%t;ta?uz&x&b0~F{r@^Ng*r~8!K+=rUKY0g0Qq1>O;ey7mz|Fob| zYYpNon2j0HF8y!%pI(?v)@wS}>g<>w;psj3b{Q6^DW?6IPTf%=o*URsRnMRBo{s8t z>W{)#y<>AZsREx5jX6!J&M+u!=FNmYv>=$_{?{AC%*F0h$T)MQs2=8(M_ET4`ta=d`h}Dsg;Ns>?sPJBBR;NF%|xMZh9w<2ERhZTMmbVY zie&6cL0-P}GoYq?BRRq6?ia7pc4_$fR-S0!vsRb*>g$vGan`4A9}fX34U{k(NBbe` z3aH}dcR54qD4=0@1xX6{;I2-k=Mbr-Z#CJdn74l}4zaU=w7sXg-Ad*XO{eyB;?3Hd zsEv)_>#LXit>zpWV34V`VI+^JkS(5(%{|Do`(n>#hzL9*bF_s28i4sc$(L;^?T=xO z3GhU@Kfb1uY7ZX}?0YBJm7lLC0X&U*a4KYXV%z8rT)n;>=khFYgSDSe4_vzsP2)JD^{liax3z@$H4m)Lj32 zrxMr$UvvHQ0H#IxWX@5Zp>(p0{(a2N3i$w0pn-#Has09J5aA~ z^S!L(cJ+U6zh=A8J{?3#&4*?-8v3gRkQj``dfvEcQ_D7(zV zc_LMEIp=Yz!a2F7Kj%4${6VTtdSeioOzXO8x{=0vktcSKf8T-i^)%qXHUvrZrrrD)P zAdl%ECGYaL25uSOIgcL)4*uh6`IAH3u~0hBvX;EuKg(y_x889QZrPO}2t}*oWqAi7 z^n2K%HaAAOOlVw5l&50CgKOdx=eQesMVV*X-3*mB-~Xt2+$Sp2HEkKk8<{O&mn97l z7(j}XVsWC3DpFc1bou-}>6=W{c4<25(^Hr8=HOF&yFALiAlPKpX~AWCo@ZO!sBCU- zR-H0sa7fUdEBk(j!ujuY^|jqn2;O%rxKEeFMbaNlc)oupxTb``&251@A+3B%3pF7@ z9u`{%4F;}eXJ?a-@6{vo3V{hRj^7krzHXdFVfi+TD3?4DPEb2z{Dqvdgmt5BH<~^hD7p7Z9C>0>hH?SMmzNhJ=j?lCoClvjfekI3m!wC!t9#kBdJqRcM?_JCH=ZmQ2G!xeHKsyME)C9hq$CG|08k$TCIbwI zKbQ^&>nYFW&x(rLz=|_k6>Uc&MPTXWu8K-2AXUG%;x^jFVD86ZM*^Zc_+E^)al?o5 zhT>O;ZyS=vzLkCQ*=qQ}y=yaKSZ4ZV~A`{o6xm(fGf* zP@hq@AvVj-K&Kz+16S@g;_XqzYKoPF^xn%GLcV4DXFSEGR9e?-A0|7}=)CiH^iK@WzxMINr-2y5XwM-m{-iU1XATbHdWSD`D@l z{tzwkq=>#}gx)z=H?Mp>9P&j8l#tOGm=RmEk*V63m9iy3wfPshS$aIbUFJhMRHa8~ zG=~V2fCp)|BSGt6EC%*O{w3+Jb|-qyX;U!d8=@X%NgD@pS>Zt@Rw&#cpgvGK7l*^L zyFvyxrlH}E3ad5^^pIiK!s@Hl?2$@~9Tr#=RzVpeE_$=QzEb-8n4puu70_IMc#xTF z;oaIGk$s85Wi_b~_sP@Bx~y5xKo}RWc4VX>Ua^{T*m33IT(45n)a<{MQT02OBG#o* zPjN?wqb!rom`8H939n>K_nAt*ObF9LS|EL3aQuip2y?+B2Riin&9PSP!pz)Us7zNJ z4MtLCt!JSLtVG+a`&NG_Dm8*n^to@q zK9G#+{`_fw*;g$;d&K^KKONM-_w3rX9?`CXATm)3Zg2d@XX?NRuD+|X*T|OwuT4b( zD30B5OM4zSx5GOk;s%JN$s1HUeG*1cQYSt5gGs=;l(xw!B1l%s6LgY zzoTf}vYAAUdp*9%C^*gQd4G+R5R^><39?)qW$;JFg^b=Mh-Z&T;nQwbl5FWM}p*;DlT*+!JD5mX~ ze7HMmiV3k-t*WLS4-2#^rFY+&(B=jA?}Yvd4`abnzNdht0PoeXtlsFi2)ble8E^ao z9Infu@o_7+DGPS7YTgx%n_Uw$`nAhQ=b{(T$v#)O?}3wt(DPQqZ1Y-_#9( z?c32trAJUypoSVX1IW<0Z}ljGq?fd%-ykAE+%SDU(Mt1PN;zvROz+WEPF$MR0+k;~ zN5A#ceHW4)T)%KLUZzzE}ng&_>rn8K7W}cS?nnP@#MSSnDRrTve3-i5#cF$-k@(j_oQ4Ue2Qn&AP1FG7;ILf z#pW;U7rjJv(C??B=+^CwCOtYA&x(;zbby|co8O*``ku97SRw|C@v3|mlo(X z!BO%Hu(o~!*PCc1(kzyh(dQoxEr40sN+_6=-KR5AcRkubxi37e3S&nru_T`|2wRV8 zoGeF>6XP_Fn7??`Tzm#?6^0NPk?6&}Q{pG^oLt zM&Y9e$Zx*2!v;jYJ*H2i(MENP!*~lwsVGNI{P9EkdrmTAooM_^l&FGLWD}@-jxMrY zF)#1;yFLx5I>Mj&;#wum(U=jOa#c;8G}{dOG!gvu$78DB*16GD#Sw4Wp}!cr@Ac7- z1iuT6YU7QDpIR8-^kp*<+Ib5F!sGBD#h>1*G+J1N;30xmm>=VZsyyWfID8q4Yle_rGFS-9Yc^#$|aMmLC+E zSFD%+4rM2u^8<1peUQs;I&|D7u>5XnoQkH9quSL&R;^h5K586UKni0CDyqT&eQ18$ zNAbZu0zSY%lb*Hn>4}@cH)-SwYMLF2+Z4|Q|DjOR(A(LRu8#pJp5%1AA2{V?xJ1*_ z8eK)+?Cb7W`Y$IE?Km;SfSB~Iwz;V=YHzj}bY2~FobOolP`O-mbWrz+zTDD7vKs6z zTJ{Kiw~B_Www9jLlDwvj{ls`XOwt}z@F_d}!8@&hrE1+FC6FK=x_Nw zdX9c>v&S>IO?Z93W+=&`V}OHZT^m=n()yy1l~gJ5znTZLB(~f9+7nb5VzqNOG4U=T zS&IN(a~xch_N`LExZ^z%JzUCSOt4r=j#Fy(lKrjpn4Ho|>pe=<`(}9+**fq5|E;fg zUrsI$&S}gZB39S!*G7tBr_m5P1Fx}UD$dKlW~MH}l^=v(Rd@YF3=2mQ+shRS&BfLi zmW(3;+<_wrZ==ZzUg!l6U*fS^Ziu zLCj~W77SImyqjmWR8f7hd~ui{;^&#F-8C&3(Tp zIsvO2E)B?lVlz*(pD{L+HkDg_(t~tI{zIza3+ZXX1(xXEo)nJZ-UMu~0VUFn60GTD zzr(gDf}U%z3u{%x$?nC0oC^R$E`d?y$F`az`~3p#K|BE0L$Gk9YVDNjh5f>9TJF8GZsCbhe z2U9r{@Y-ycYpW(uSt!jkcKzp!grRqKgKksh<3SVL%N!k^s7>VS%!Q=HlFh~VE1LZ1 zH*t>vQ_Q7|YQH#O(Wd8)w*KlV=U?jLKbcvdML{f?$xOD2+x3~x#F6(?sXO|CT{=d= zWx|vn(g(t){F2Rp+Gap%?`zflz#mWhrrkYZZMVdFMVD8JO$d}Ox7lBI90G?^kHJSo zzz*ll0kc^2&AoYq1EXkUL2W6Yr#C&Q4ILaJsCCsvh0l*H=6t?7`VzyOW@M+>K2=M! z8ND_&vY7}UFtVIb9CvY0x=N{@1I?FTrSpeZ z>gRDBc^aJPKJG}gxN!F}d^|kX1e?DU_p$R?@~C{?5<*}B;@MoNx1NPUl#=`Pf#K58 zA$ZR-)vxq!{*Xs+wO<7)JhnP#m?o;}gK!s|#2xi2jBJPczB#Q!mB}SZTz8qT%U}Mz zE_!~0LGd=tp@fRJ_zP4z^C{lMD%=}L$XU@isR~kV&KWZm1tp? z&c0DV1F95#K1;I)E_h>qi3tt5W)CEcJQey5e799a1g>-4#Knav=lYR%-^|YI&8|&~ zA~8>m(`4xssujYvP zQlN;c^|a2#F+1^V(|cy{Ny5+9MO8oF)5O)`a3mB*{h*w+ur&y5))dTHyqa#68@%mG zB051bnOk29s5F1+5jRX5*00vG{jQeQ3HQyHzb_e+w#t12Y@JcgM5TeRpuv|KtX|Y} zluxcbRvcQsim$j27D#0`lf#K*nN6AnFR_E zb6}Azm#3q14gE!9@PAl5>%M`B8OFt&@QbCUZVMn(uRcORcBZJZS-$l5)F-3}uJ8sW zwo^O0DN9OZRIF%wxb00%APygepC%bZKMoDj@}pwOt~06^#jTCDmngM50D*z0jwuj* zrxneO6lRKAyRfcs?RJAg9G`pj$?u^!7YQk@?Ql-#A#?8_j1Gs*A0nD{cM*t;l+%f5 z)cTw#wdo#);~9xPBOCNQ;+t?x?&iR=Dg8=Tm}$lshj1MFWl8fW7yI+bD%bRf-}}#IO6Q$yX6Leww6)}7=eB*8>gxG<`3RXb)TK>rWdm(ku@ksk>U6FmkbLsnxY7Po&;L z;Ttg!(uMvo^jSS)s}e8)Y9W?N&lzE*}_%XmT*9-=*?gk(SgE0GF( zZQK;5m>Tn3qF)icQy7VOp4xT~l}Xbq;;UCl2a?O@xTTU1eBg+;K)*Ihm)KHn%6o2v zTcgW*b0q!v4QERCocuq~-3KgyPt9lWQc!41;62u4>yrY4DUZ%vhyVxsa1q-1RCk^L zFwe8xz{Pd~o8};iXi3Z#3luoslez2vX2(Z&2l7EXHs?{;PtVRf#GXEoL;7E_0#?mg z$3We@xBopvU}V`mC;wcyA40z)uR#Q4VSV;-9cM!ok)&1K-WDQI!klR0$?}-A89fa* z?m=ysWJH6fiTM!+)IZ9E34eXfz&+ic@N)UK^M0)~W?vlu`>WLai5YtDgdWHJk^(uKcbm@Xo7Xl^GW)-3Ak&DZdrIOTcdIz5VMUi!{_*ckA?Xd4g&M5-D-p63zbvK7 zd(;Z0+f;)V{{%J5XN9tO3%7Do(+DEXp_?C=q=AtU$#`o!33%giRL$@Dnk^3pAO0uU ze@YAqHE;ui2!c+BOU>`h$I>a$D=hvKDL+U6$^pUzCtdT%KvVs=OuGSyy7M}o&pbwv zw;_jG5>+tAD$<7q#}c@6f0lX1NcBwL;}iNxglvsAJH9!g?_U6*<71{B>{~}{4(6o; zf~W-69Cms+^R*YHLxpt45h=?d)o|M+&-J9jX8JogKpTg<%xAq7d- zA1ngcZuJ;wSW9+zZ+)-sy+hQyVY@2D2BqRCg46E9_R+i`C6Sr8Nf(vD^bQqSQ5_C zA}$q!5oEv9dl4&dSpQxs56y7w&rJ8EK@&P|iNja2<<(nIh@h-&WmuFGVWztAd8jmr z*AE<%fL=$ht9D<4a>NDtEz1Gg>l7FgDC^IrDC9vs(S5mH?DsPu<$Jy^X=Zm?1|R*^ zYUsK6hehGJKZ9t!k&hb(kUGh%wIZnby}7^Z=B+ZPe|))e*}FEY%3C+k9~eo?Dy4i_ zc^%mQ(aIs092U!U)&n=~%;kNgWW9aHFvY_-ysqN>#v_#G^y5Jg2>78!`$nvBm*7g` zO&Mycyz}JN{kbbo+g984F7w}%@7=Fc4>%81w1b~(Y;q8)d4fXoG;UWa&_RzFTY~q{ zqUG#s-wSnIBqaTp&$S=o52rw9DpolAM@I(Il(s6F%E0iC z?D@qU(0_BkiCuQBZ5k2Upfc@TsYjfDy&W3-hf!dAY62b{j4P=LvND74?>QnOI%el& zuYy}SqimZ|=Q$TAE78~Se1*UhEmB=)9{Y3=|8?|3?G@$AYb^IY{xQcYU*b#WLd4W4x}|`slMrqq z37}O9+*fPexftN*hA@p_!Q_=Y(Cx_9mg|IATS>XP+Z`OsPGtW#5is2OP`BDt7BC1JO#`$d4ZoH zzuR;mq8SdtLI`qAYyRUM{YP?3Qu{Hy>WsBw`+!&Hqt$FEx_Wg^^H1%-ZYRg=6)M>I zNW)de@=oKL$4Xb~`ipSfw>(znJ$}65_*^7pgZVc3pOrJ%noAj!BGo3ms{*o}vTX8W z>hED@rJTj_HpEcr&~{)6CXZ<^)9nxAxyu*LID1C*94PFeNfaPf!GA~C5z@B$lVdz37K`Gh zIuPg6saF-6+X>3VarD4r1i8~7(cE$39a3#!0`etOgZxBoXA_F-QJ~HT;8X@8=4q@$ zE2{YG5Rt{d=3F?1B`bqy0JI4FfTzv3&=thNF2!M_L~;~) zxdD3o;|t(G~wXr-K|yqX!Hl+4CS`N zwz{uQV)z&n1qLosHOc2|KZlT)F%hCBmcx{+-!Rv>lM!4~txCCGmb=o~OqAcrV}SoO zqFm+3*TNKRn=9uLf{6je`AXyMD~=sqlH=7PO8Sm%dm`;u){%nQbft%QjDB-T&tP^X z91PH9FZ1IaZCxfRXbw!!~=*^Fq%sWDcq~g?~ntVO<=T23#S6M4kqckV*Yo-Am`O z;x*E3e}8)R%PZ1paM)VK8r=)~gJfsmY#je{cWpmue$k|4uN<*)7FV9=%Us9yLaE^| zSgZ>j>*>Xd7s%%kAG-dt+<1+N4@?O$nM~Hrn0wE)8zEq#*Ey@ZP3=BGYgTJbsmmA;AwYi zY1?I1#T?lrkYBLQcel}&Tfb_dNa=0G!~I?@F@-K6FJ$xzR^YNP+zygQk8e{locFcQ zH)2fN>nI|c64Jst;3Z!cRDD?J&Ymo*{c*xz zQeRxpdVd@fkoPyOs9dpHe9f(^^&F6$kiLPL0GW~4Zgb~&`mn6I+&nLSR^{#F!g^@R zBh-KJ(Jv|4AODv__{eKmr06Nef56*CaA-H~!C7y^qh;_*+9$B6!b|r|cVYrFC2x z!`y~H(?;&(Iz}bF#gPbOj2PXN#HpOVau*kWT2l7sMcTwYR2n(^Q0bcX6tcoLE_?&` zH2T%oam4#3{_SAHh=eR;UE!5Td^+LBy< zC5*pZJo=Qb_dZysXoqTl?OQFGPvHzZ)dCb;_${*io{czHcJDo7K5tkJup$%{p|F;? z5jK3J9w@am>k!iZITFF>^pX3k&B~akp9)}`5*HWg!ZVBzjPWS3^;@N{%$U~<`XjvC zQOYCgZR`}3w`4HOv`CH^15A$Gb#bXkn(PCQ&lKK+JL24{AAQTl~h zGqR_J{GG;ln_||iuFJ(YmHA@3ZP|H0omOHRkTQ@_v7N|xGx*&bjUxLEDHoGc7zF} zv8Z#%(WVatUKn^k5=+l^2Xjmv!jb=oHm3&-dKB&1j_#RFW2+ElEZN{+d00B=W=v?+ zFxY)$OlwF}y+#3SX!~m@l(;fRhFM))m1JpU?ffS4Ze11(1oX-@U7M?T8r}qS<&+!w z+uP3@gHe9d>k@(Onkvvxj3fY8X1ulU_Q>EJ&Lo@tkePY!W23yuG`k{Ci5>6qP~3UB zcorcrcDNa*XN`tZy>)9&WpZec2(VfUJ75kSmu@kP21l~_snDV?k?MW=7Ro*>lr@ky zRJ*Aim<3bVfD6w;b!GMtXviX?1=iN={f1HpXV$jH+3aC#&WX>0ypc#b+*rAlE(^E= zcD3K}?aW7J+lI9{BE%JpCI;q>@0kA8>X-|QNfF1gvo(g_4cwLzcNXyhYgZ_5*8K5@ z4_Jl^b=CFOmRb$`%TuE5&7Q=s^2b~HDN~1)S#JgJ1e6vwa&B2698X*ewfJvQ8jBw*9(F|BXJ~c|)XiC5uc~;`ONU&exw$Ae8Jl`b2J^{(>VhJn zh`oWDnb2!>{}x$Dop=x29WA{V>cb<985(3`G!(srvLMXB4zoT>**39=Vb=(FhP3PT zYRO;oy9J+5UigB=?pVq*2Zgehpa4++{RJk`SHZr?k`ZmFjk%v!+W z)72i_zO#5{5HEt~x_4)Q4gADN%`r7KWqw(rxY!Km;LeoC7+@#GRr3$F>f~0=VXG%V zr&iaeQ%WO*X>#Cx1E7O9y4T37@OQ(KQSqgOzW*WS`ggVad-)`^^^Ozml1Q@A4EVtL z*Cx)}ZRiT`(RLf(Yt58RUlh0?VgTQ}W;ZUd`RwbgIvR9`xc<3!~Al~E&gp!Md*0%Pv6t|m7Q^=_*y!hp|0`zRYD80NuC?+HH$FZe`*3z z01i)F?$;Y!T+44g7A|RIG8CI(rl@t~2|6$_wiD;4&#jwGo-%|+sK~eZ`)vOV*2TQ3 zurA#;D>M!o_K49rGmC893u>q85UEA@5PL0YYejQ|gRc>eJ5}Y&tyTN`|178;40URy z1*sh7tLiQ#RNMUyyxq^M5wrT{&kArLIiKTWb!+;5YeSwAqi2iu-1zG;ER%v-t~BP1 z2w@?jhz~@>nf_AQzou_d%TiUp#0bJ@zw)NAv4PV|tvk^S1A8!$8IbBQn(a+#ltUzo z!T|40N$S6;5WPug^d9(*4U4C+}N5V4P1F|qnR?z-QL?Den7YQTp7j~@NPYTM_S z$hnvE-Cd!``|>INwh7G&zr#8^*J9s|J>n2Y5H-z6Jxi4iN1{!NZDsk&D;fgO+n)0^ zQcUi*lwHzrQ$`Jk?C5>x^OVs~$hIB|*9HsF-Mc27eb+~qOV<=`@C4zBrc~O*@j<|M zXPKw8Qf(m;svd;d;Leqq&v&)GY2CO66A4PnX)=+|v_0#+KVl5b#7w;<{W};2k3+mb^KZNiTPzb>vX8{He5W-7rhQ9!$8Qvd3Q87%6q%|fPcTsGD`JaHO;tfqq!MqvVCvj&Iuqi20f=(_om+Br2G1#C##eZWof|i zg!TMIZMHo(*(gLK2+xgGFZ1o6y&_#Vh`(gENR?iIhO#uFTgSn_sJpdh`XIZ)5HB@E zwnDF?*`s2N$d;A{y0j|k)^7eH=7n0agfL;rES23>l>RtQhpf*dt;1i~n0M5N>p2&Pvl3L=|NYU);H-;x{KdXIumdSQ??|y#}^qSv@ooB0*O+3s{GOvGg2DR&6hH>Yp z?9SE(Pz^TBNCtiUB|(M$d+QRy37U8r_5Uzb`{_BzEzU2z4|H;kbIIK8#q-ay-*4U8 z(h2`kk^e4NNz$(S0f6wf#yku=?YML7yk!_MwX-A6g4vmZZJmv;4e)fiRfhpE-{gErFf_mP}$r;!&=#f-wH$ME4ZGbzzF^GC|Ggy4_o zc`Hb6QWrH0i3kHScXIu#&&6h94x$(;o5P|j&F_@2NM&Bvy^-AhmOtyiUDVE~KV@7* zxM5}KV;qP$;_7cssbB@5>eT1w;s-IrjO9e=_35ke*~u*y5j*__fI4clk_t5m$!gUC z-d`la;u(ZVhI`q&0v|bjqD)z<@LhI3yFi<=7>OW()>t1A@jtDtML~7iWe=h^?r9&Y zPGmm%7E}gXry8rHV?>7+2)KenZBfcB@*^nFolp*WiWkJF6}nB< z;ktS2T%XeiPvr|0$H#MBQL^66+NC!XsWBF6nJf9|PUb6o7Dw9Nbq_kMGom+BNmSfM z**)@oF9UgOGOs!GV2O}sd5?8ap6i&$y5Sel&FAJ@tQHLQ{z<#$Qsr58>GcUB;8b9} z;}`k8jcx8JRA(IpB5d3o(UVN3^3x845Ysx-Qr9O5HeyM2L`LEQzpk>#n?HmXq12a5 zPT(IfnAM-n#Q7NTTKuJa-rlAy_`FXJv(FEBp9zMSu-6U{t2C=SOtXP8KYS*78|aPy5A4sQ>2M}KoQIK!(6cMiYXM+xpTHTfy~ zUV2q=`Ngy;Kd*_F@PPR-6o_3H9%&!BdrKAN*SJMDm&Xckmd)LH+#ppOoKH;HS{ zt1aIZ?69QOb*$%N6L{S21b#1+zq^wS!C)Hrca~I>hqxp!CQLnV_ow_ITmdzx3cZP+ zUtIGvD>ciqyYUV@RFs{trm&qjt&q4~a`q7x%PZ;#lk167Tkkz;*?HISD|EPPc`|?H zC?GYhQ8#X)nM;9l;V}+VN*H%HeTu(;0@35`0>W~FLTGAQ5`7@wJFnm8TE_RB=SwL#;dTJhJ3U1 z+ikjk{<>u}`zf1nwT{J{Vdl7SGBC$=Y*4SQnsLSP$d4@eHS!P-*3i(!ru}Y=zQ-w0 zMR_V0`E{9?^(?VtU4_FuDukF61s!`7n!9GMkxP4}44&zFuu&#W@nq^GI z%F=@}8U;3Fri#f*Ghkpe`%g(-o9AKovqo8ic|(Jn47&$5T%4-zyV#o^(ea0D=#WKQ zo)U&>FmrNnq((bGcFW(wVY%gCZk-=)fVbB4-VP(svM(1F5L(Rv_RPL~x#cl4K}Xlr zox;_|pP{Bv5Hu@q3tVc^gEi}Z?bNbxHKg>P_14ZB%ZFK+AKH{A^ z6pj}1FWyN59dq-x*xhB+v%Q~FMQ7CXm0gEIQ;rxMs$L}}F}~ESs?{#!EeyVbyOX&E z_&sL{nKn#q`^?+3=Azfruqw-qQT%bxcV$AT^Mq(t4reqwIB}+k%mua@u!;;~f6mlU zR4GlST!1El`!n-u1Sd!DinF)Ml8soL5T{yVlR1MQwPBg1qL4yv@=!m46&;KzVedg4 zo>sV*;KkJI;*dbR(5Y@ogPokY_964JxA&{!-am%pD>~7`LUk_iP)ssD?EQQ7Jq_Tt zLfh_!Xe83xxv^pfTM3HStVQ5IUziALJ(jxb3VDKCo_Fk02_eR}M|%z?qA{;CB3u)^ ztQ!%oX{GR2Zj#827kyddN0jfpZse@YJ5wSAk%O_xan<@nR!)WqW&Nu@0c!)s$owv{ zsZZ_&gCy2C?7Q?t*kAlwS$zYq?l6x1@LUlSv!zoN`?ouZ5ej$*zq7uw&qjsln)2@t zEXJ-X34IFdt;YpKjbK&XzG`+TRN3!D%}$giFH=^8qh0m&NidcSUx;Tr%~eMLGzs}# zgw+=FggQt4v+T<@Q&rh?$^M2;xrg|K$(WnSw}TZpeO*Uf93h2?9xBP6s^k#Flj92{yz>;?HCsPg6=7ZXK-e*^&I zacP3|IP-IL>Z&Bv@<1{v5N#gf+4x74I@?`QrlM_(Qt*^|FIC&ak)3~%^yY6lP0Ih# zbk#voeQ$s1l9G}x1*DPgR2r5L=~B8`mhKMeZV;uryF(i3UK#-jS*fMo`~A(lJ3F)g z-8=i-bI*C=6CWys+=nFlOa5j-Q2Q%#$JCrPtv`WJC3VWFtFUq&W_JnI$ot!_G2zpG z2dhQSJRz#Wpa&h^gxHrj-C`)a< zq{OWV?r7eK8jnL@{y91`J0lhMz0W!?SR5u)OB>BSdJAG>aMl-R7yg-05>JEf?b#hM z12@#JAh+Ig+ zcstrlFRq}ks~dW5W#6+Tz5LK-n+iT3KWC1UPt0Sw3uTEmj}Yo()bmO_oW66>y2x~c zeR!>EBs4S1vksT(0$)6(*hcEUgZ)|Tk3EQP zeVOnBgGUdl9)kxxwLcd5`1#YcmYmUxhj_`8FM%Kqg)Fb|Pd?v4hSW{x_OZM3T55yy z4x-6LkNpn~>HbJ|AKZEK@*^$l0{K#u2W3OFUwi`LJHY^_On2{TZj-Ki{glpkI<&3L zf~7EtDEyqu4_{k~r9iE<8q5~!ZC7}{+okxxYeBFDfwfWH|LOkp$;zTAT#>ix%v5nR#wO-rlw5&9n;WMk&qOd z2QByA#PI_q=1E9pz=2@46_3t}9V;n6-%dd*p}_1lq{g6jkf&8C?`e+IWPGZgMdZ{6 z4Q4z?dRD5Z-1T~+>D?chl2Js^@8hJI(^ATpkYOn&#@WL9VrQemV(W` z9Eyr7^#VHyuSvrk1yZVzWs>E?FCd6>Ydn^eE^WLFjsw&*<%>9?&99^xjD}LXTRaYC zj>aDT2N6@6X2x%uv#3tsPi8q@OzKZ4nW56%_TO% z?Jqq0o+l_RP5T8Ty0yMKHK|-19VPFO?4^7sHlIUv`14n~jB84$?6xht*+FSo$A!hQ zl;@w{K^vad>Kr`tA~ee)ZJV&Cp=N~2`>n%nOVF)$#~X_Xmf}AwOBHQhhMYxI7`sZM zePuR9k;6>qfA|8qTS`)e@pL|Fkrga3>EOFrA$bvXk0Gp&vW$S_PsE~-d@VP_AeIuHkY!w;)Xj*3mh2j z=$X~im$F^DEP$@}>mZ9S4e@SOyCQ$kQsQN?X_W(iguP*(mE95qM0&gRU43y}u&1|?ST;Nx`;lxYslZUi#m zvY*p70sob|wi16_H=D|=Gv=Xt}6iSlC}q}?B3A3ky> ziv@y(%kiRT!AtypN{p2TE$$-Y^mxAsv>~RZTbr*7o6T_8v?-1+nc#X%Q1at?-f&i% z-eWq4rY!3w{c&WdMFaA_zI!er*XDTQ-UQX3XQAj*sXl zbEv{QxQ$GRKs;8q2hiH+D29^sPz zseIdIOSZt%L&H>d!_R*7J~0VKg9AMufZ$(arR>qyU+m8F;}`F|)~@mPLUs0N#R7%x z6*}tzE4D8qfxa2EZhJlXL+P*#6*zmB zzQc2Wy(AL5r$QhlS@G^Hjq_vJIpfr!#2dQvf9RkvmF7%xlxRsIQ*^TP<1VoNWBe3% z5jO3u_ySJ1vdp^zGYoE9-Zeb?oFl!w@|LHfVxlYP%Ws?9`nN-uk7! z9_1wN?ohoacW*zG{3#-iDpH5uL@ZS4$3&jP$U1&whgXZ~YY+jpK`W?@^-mj_QnG`n zvpv}$L!?YJ9p=_OM_Mp;V5o*QUmF?DP)ajwc$I4``xkL?a_(oUj6rzkm*`LHvIh~B zE9Gd!2PX=`q^SMtG(#E!UMn9Rasvsxc1eYAzpjp8@rpiA-D@OOzEqGE?-E3x?$IoJ zP|vmm<^~%cu*V3h`Fe-}={%CDr>@Dp&FZL%c%Jb$rU1aF(d+34ZD~XyzJxqyj18U< zXa4bHcPH3`iZaz)ulvP1N~+T7o@d;@f~ZD1g&k)cI4;Q{QlKVShJ24YSi4s&!(WvA z*pfq{gVzrKDlHqr`0r(3_~o(ZSx!)nQ};KYrWo&Wo`%2{ziS7~lHDI-LrH5_Csnav zz7|fQa;G9HC^~SpolGq7|5yM(TcN@|S>^D~!ql|4)B&gJ)o)a&yMh>aV%>4J(?XZ% zi1&WmP1UePB(bcAoB)rt>A$_{PU@F-r*lPufJR1GemiOhK2TG+QNR%dS%I`=A>n2!(lJKE3pYAarEDD79= z|3rNLsfB3ZpiGVSLPPHfC_#$aB$ky8S*|t1r}F+y5B$b|S^bs_AT3y-+#8HWG}Ia8 zA4B9LlQVnyp%Q*St47MvIcIThvy?ax;z0XsI_zyh-i!Ypm>rGh7E+n`jK$G%7(YcU zhNYz?-s@1L$d3Dp&7(?&&VJxF8M(QMA9xh1dBTvsjM!Y(UVe7P6z8AC+d;P+DJdzL zv3~Kon0Nz{mzr%rkx}x^LPIVQZQHl^0KDvI}nzDQl&dHjmy( z1qx|rkz8_(8DcP83a15^IV3#Hb`m@Gy@!-VovyW*$wWsPR(;f{;g=(4yhbL9@oKpb zntm4rq9Mo$X`Z3uN^; zwBC_#`xp|qLwQbEeC<3TGf#(@UeQ=@kHC>|;nBgbQp$~ysuRzW!9lXe1uUa_!IT;K zcUeo<0#;|D7mtmoQ)vqpw)BEmCoP8D*upjULW+Q3#&G`ERXXxu(36B&r_z@G=(!Y@6oHqwqs6hZ#i321zs!GH?|$w1)cV}0nK=TY;j}Tsb=J$%oifp{n1C$c z4s*)a!HJtI6fNZx*`AH2a+H6nuuNW+w(-4&bF^-k$?E+EHX_2SgL+xhD*a1 zQP!a=D>i)Ds_Yyb=4NJiiS(s7^r&eL4Q=jYy!za-MK4$-T~bMjHRz} zapo|;n;|5OKk;>SJSj^3gig-R1x1RvsnXr@KB`>{mxVRI6>s)g_ZEDP#`4C{KbFx) zw;6G@cYnw$A*VE0aDSru`OB}`pyjNh608SK_jvPp1s5Melp5GRvpF9=72GJah;^*( z`t=0=IAvHgWt6MKHDFFQ3%3Rs?OD_a3BWqha%DY;A%AEgv?PqMQz7nBy6YgbT+xIR%6H@^Sc^`J{jUgBl|6ZuGGGMb9Y+uI36Nr6me-&I}ViEQ{EM0!45-Sekp`arvDa!HUA+n3AmUSW1~I?J0~a8(hbTL9VV_$q34e`=!pf;dDrrArs3T0-UX+A{`|_IO^K(4Q2^~1CT2eYJ?_F%TImLs z3w!TklUl`FzA1}@g7+A6Drm0$K`~Xt~{?f25qq7ly+HS8)&NaA%I8jmS z2IZD#UJ++P!*N$%H*tY?!o>S*{NhU8WCQ7dDYWb|Pq3?^;xA3UWcm=SJrwr!8Ot}S zNEOqbJELPT+^VhYq5cQNz#_A#fjYPk%ea@+O$*a+ic@N`^_4%p)pMcpBd7TIWH|CsWz&1ry?z}` z1^}#AuWu$CVU`V<^#Wr`Q5npi;F>prWH#?t+|a^Z3cz5DNUs735fN{ER|U?3CEF%S zP}{bsbgnr-y`b1yhKf|GZfQ&&uYl77zL%A~y%3+ed-M(xfyChuk6>u|S8}!&S9?cu zGS9~hA&(8c3|I&CSDlH$Jo!$A6#YXJ233ludm7>!FDhxUNyV|gg(HSz#E#LcU=!<)o)%PP z0-Vmj%r~zp$af<;S)6g8bffwp`mr0wzwUEA>C{~I#NU*xofeO9L^KJTBeyooo3_Ai z@2g{4>?&P;@$ZFG#>w7Y=u02vo7+dfQO_@&%&vC$as@uJ#Kb6%19ni@S~i|WA0fW0 z5BA6#u0THQFh7>G5`!EX5;J_H@TbxWCqiPa&TItFv3Z~6bR?~Pg`n6y>7mX+f5mE? z$zB|Fd-Hj{l6grAqeVEp!*}!FOCNs;xMeFb>-b#K8{1BM#j-CsTB!IXU6v3<(8J+A ztT*=NY09%5IF_4MMb$H}#R7)?)kk`aZwvDld(@{VOxFeldc(+%LmxLuo1_?!DdYmx zS70yE^y$A@f>xsm?(EacxL?#ZHqO&daNW7ar63>Zx%S7X%h~bts3R3-@#Zk$c&I24 zESaiR4o;j6K6}@06JjjdORx>~_kSa=KOM`lB2W(ciH~N_doU&aRz~uR7OOtRQ|>7f zDaJ3Qe;~cN6gqN^nV&8qe5O4aJM6 z)k_oBo9wJQ3zY)E=>xskRuUwwmxpc{x=jz`NKhG2%~qiy%P8)sD+96bC^?da@;PRP z4sL-?O_45ZpSyzqidvGPS@JRo3*Lru5=>L%1N$PF6X^|WWP{ko`;H%dobkF>`RxSz zYaDh@xu=_>}WSw<(1;pc&-uhfFr-0r4LGyz0c4I*mbyPBU3jkkIwa z;f@IxLg5??yL`pHiJFPC-OS!95wuosiiYZL+J_AiWuT)sqnTA4>Dw%0!6tl9*q`ui z#n#-Hwd>rA#_On!Ye3MoF9#-kza(FUUf2f*HOtsHm%(TUt`^&S_QB&QS zyd?WTZ*A@Vtsyc@zl!O~X&mY5+AE`=`d;N|R($@wzMkmP;W(7HlMh)59b|iL(|e-C z9*>v)k)3FMsm4U|zZNbuM-s!8>m_pe!dO1Y%TX^(gst<1QgABUCnlRY>VOvTbhHpN z-RJ-&FcvCe;Va&TYAs>cL&MW723#utRV$B*FI;9Fuiza6$CNg^QjxbMC-Yx<35=<< z`4u`-!Yy{TJOk#@kBWNsx{5voF+(+KD(5Z<)Y$~fX_M?toEj77h|+oXBk5dUwK|Hu zn0l;$&5=hO1HR9qbU-pY+1A)xHjYqe*;Y2_T}U^MqkJ|G_s&hJ4bCW}nIX`cx2G36 zn>pNiB=aNwZFV!A>5RAgS7JXDRDIG1b!e>~m+=!(6MO7m>K}uWg7IZ&Au;d`GSEgJ z6#+$&;*|e6<=-NW*ejX?@g@(C15;m3rf2_ zS7w$MHZF0W^;g^Qb?{abr~OZm%ZyDPv^OO@yA6HFA??{xxww4f^Bm)G{5T}XX2j;d z&K;I29L+Y>fPj15N~d!()71`4#p+PKW#&GlYl$SWJDAYlCqROv3tc=iWrqccsa~X^ere!X>JhztFDI3o zy|zpIFa<{DrLQV0xrchu^_o>RB<@eT>n6{USG;VYA2$V(B^Y0clCopLc?-;6GG$<4 z6l{e?`g}QEePZgSEktPHBU{ls8r=Mrwyh3}ez^@|HLLI_Wi%0>yZXq|pYS;3l%(z9 z!nOHf92Ytb2XlNxN)j{1_DqgX!(B@pQ~PnBaLZ<~-(ZH61Pu-h_?WM-8*`Ih4`(7*T0dLw-ngZRYo4~ZY$j)bv(4vr7%FWt(QB~yNHgp z44C48r(^Jxd0(vt4yg0u;&2Bg-M^k0e&2i`Wcko07Xs#oHb>z%aITnY5a}tSnMGO> z14Cl+{U3*U&Gy`qCmT+`DGoqMkpa2i>)&mzlK=Jj*#uuEoQmTIqV2q0fJqjw=EN%t zu%%+c3)H;ExO#Z&`IQC3MwsljAEK78ab~!K-?M91Kmo(e>rMyJQf;=03M0?nH??Wv zYnkospK)K5OMR7j1>iodkbr%w%RS=zFa_ zjsX5^qQkx?b-H`F23Tk?oFsd3#Zf6uTR=midGJklEnVL4%0x?vQXH2^w7q{Jt8S-$ ze~G`@y2)e1HJ?uA>PkmnhBXM6RGE+hkK^0)Hlkw^DaZDEBw+1?h1_ z9IK_fGGdx(eSYc*d+>c?YwKNf{sHIsgZ&MYN3xFE&M)ufub)&E=sty(&wQ)X)M8E5 zsNgqU>%WT@1-d_IYt7Q^%9Ib~Ix`=N60xPn<^YC4uBeA8{9v+mH%_z;da~F`dus3R zgn!kkygC7PYFfT$z8SgngR-T8b!RQT(&9C-RUuY|L33C9(nenz0sT@8j`1uRwNYF* zQ0Wro((k;$(*i)`LLN}cuhOMBKB)S*VE6BX6=Ppn*{DU3$PfBpI++TR!2|L+s&OKG z=rlx6NLNXk#YwT5AXc>^=AA1MTTfobnQSH*N0hn4o1k`U%Hm9eS_h0~ji94F z6RO3`UARMn!J2Hac9=6$?-K2!*@4$w1>|ybBt-v6ZE%Ci-N_qx9d2jC@&{_pyMKAM zD@DJW3Pill9r8t=H*vd#{Edrw`oTQoXh1ch5;MJ^<(UU;Kac(|j#EIB&nVoI@C~P4 z{Az^S(h?B1mwV^^!)mK+JPt(M0fYxDG(Igv*N21{XsxvjIN8-s9gl7d5C|ml(h-eJ zxi~@;>6^|n>0ZB#%AlH26k6U@ZrV^KHF{NFOokJ zNfVf!EIPD4UW?Xx!AbeDCnXN&0ibVFWBFazf~}33bESH6On;F5V*4F5;mK`3?8o*J zW<;wRP(*yHF@}HsjK=$&tpFbv*Iza~e^dAbe7JV{H$pa-R}d*{-)gl^`T2!&YcZU# zZsR^g36amB`YOI6)7URl->g3wN>D(m?}t2PKXc2SuI=R0C!h)n~c*m1joFHL!D zpEk^%5Hvv3p-BeKEWznC;EP61^9@!KQO?ZFkSl-l*?LF}vWv@H8mx#v-O1S3yuHJ( zYpq`_k{~Qmf>Vd)Vvymz#j8?v$$;Yl?yuCa?{-8C(UKG)c{YcqzY1i^#1l%2i&Knf z+rGxf?^bu54L{z%;xjWdo4qm+Ui2HX8#i7cmgEqw^Pago%%2rDd$h`D<83knIa*<( zlc-QF+BVC{<7(r^>OlWxvxp7Bckk+n2oiXtjbKLhSH}yZ9!gN9Lq?aL6A*$eJ zacUGVG2|vpgJVlQQp1t3`3?}8HTaW!bLZD1DB@d=p&<<2Rlk?E%Z2DHH{g}4)6!^U z3&P_5OCIDt5V3z4fW8E~qTIDXhe875My>I1!ugLu&QIBrL5Dr{f~8I-|E>0HnBoga zv%Z-?&a)&44)F=U13Q2qymzYWvEmUI|N25Q4=6rwpa&6&_6rXtiLDu>Y;7|;-Rqn^ zFqc3K-UA`$X&Q;=73_f|=1OL+}*7PQUFRjkOA4myyf3&m|n zi>8l#n<%pyZ+19Mf1I3{*y+AM8!__O2s7%a|3uvQ+50-jn%~jCP*eCYQ3Kl zde;U-W+bUXJeCo?jX@Kkrfpdmzu%L!C-r)H+7ZlPg!_lF74vQ(nS@BfKn7z5FtF@*O#NgnU zPQJnU+Kw4(G9a^DLA$UcbOT9n8Yk!twedw8AaozXrt-|HVI9)-t9h`w{ z3c0&OUl42p^lPq$v6~XBgU*De(sj*L!RhbPXs|8am#!HW3#xq-PHX^GOn7xx-jF-l zf1%xgi)piw6u;L3r3BM$UWqa27Br`Q{mDPocDtZ}(;+10y5ggN^499?;}UozHk2Qxw%Vo`O!q$(jGo6+ zr(yW%;k+myey>s^Zgp3F18$Skv}siglg&jjylF81d+G3+bnvUNTURAOzjys?v8u2n zC5iZ56kx#lX&8y*7`gEs=KJf8^KKtju9eQhEY?{YU6H23RcSwee;OQ|n9(|B#(5%+ zuAhQxbeFGaE=emwL33Jj8CfdX=r~~voxvFWC7ujp6aQYnm3}B$OeGKyRPLMjtGL?^ zq9Qpy?o3jgulMeb{i-@X`>C1zVeOuCGF>R`lksg@v%UzZ^(L&=;~(agx-Uh~M2;5M z7a6~-siMrfzVSP!``5-7==Hj`F85IIm|9D7YQrF~c4;yAcUGRc?>nDGO)l<`U z?jrx@`jD0*;7;W(YB3#mga|?$O1KmHdmY9O&sk^=no^cx%>R*d-d>Z8BFp(jIq#FW zA9{DP2~{)Uz9BO(LiyI{gG(!UY$PN4iE5j@HT1OfU?@Q2)y@uCfRM)%Zv!vpx9d2s zTvI$yUsAriwz6EMC^M<_Z(imWmM_29jUpVfb3%RN;01KG)D;b`YCHblbz~*+)9|hw z)|vr)Z0ef-V*NqGrZys~|sRyseNj~y=M=jsZWFNqx$ z8kcE<*_M_W2TjUv<3Wn0H+_lHm9Scj#nU>B>y=in51*>PsA-NuzRTpkPe^VaBJr@? zV5|e_UKnDe4K+KY7OFXXFQ`65{S9$8cQe#?a}^z-M?UkKt8tlr7!c+Hb^rTSVYVd7 zb$ty)SDvdM>X9{hZlT#52p~SuhERcvYTU)Z{3YVNkPD_5dLLT=9pequr?f-R04^bOx?W2g}m)<~7HB2dz34AinZ6UV{PY zO8YJ(0+j`}sKVr5P<{T?83+9k%b5snf06B22&lum|5+wKeBKLd->s!i)O{_f5W1I( z+|X^%99x)Z_Vp{{gjLu7V*y?i=@MFcFHq3HFo-p%{IF3KDICL@$DB+Hby*amzB4R? zut`m^8q!|%$snq+=>t_Av=1-sj(!=2s(1YrZ<~wvmKC~NJB0Fep*%`IHqds1mNv{5 z=h?moO0%7QR6$aiZBr=?Ku{m0=8i1u7BQwAk z^`5;oZ@j;ESo%lnO~;XBv3;rrd-;8CiwV=BB4Ta|CrsvDuPGdU3Y&I6@E||#K43vY>>E5m~bK0(v!ajCY*!uA$@S^C-@hZBw*<+nAe`7Udg#QJ+L=KPQi?sZmM3 zuglm*YlPg)$NZtSao>NF%K0Z1;{g>qUG;k27%s2;&mU;aH-;jhiFM&9L8Hgv^&?o* zjh^oF0SY9j&I;}W@;#6}+$C#yUiEBO!G1+&Qz~EJQ0PA@$~9P5JHzB!gMTv@!&cW>+C?dl1aEa3iB`Ff&4b}-J?cN$)H_ZGl)$GD2F zz1Ik(-WBDYJ`57ZeG9j>f@wP#p8R8^Ftd^FU5AS6rsdk#zC<^3je5UKXY%F!Tv3Rw z{rFT)#Tm(QaBoP{mXq&g&f84y96X-;U%bM;x3JPDN(*!$O_J@R_>kmMiW1obx!PCe^T(W%ptsMYz&XruIpNH&;C@jDFutu1>;K_g(OnR} zw;2)mWfgOd82?hwf?e8R(OzsL+pMknZ|Ufbt+(DiZwrba=<#<^{F6i1<}zAFfg17c zDA=UIGB!y~VpQf5T<76a>9>T*6N z3k&H18Mh#BOyuPhojGOeMe{u)oqID_Y1+fS&d9d<{Y-!Jpq z-~}dO9DoSe5d|6;2_yO)7J8UJf^cC^DJ5H6s;@*x>$bp5?MUpJtdQ!zhGYQ#MNg3I z{W3_D47zmIE=mkFhqe@t-P&(Qb(4g*z4x!T`yt<3)XiHBR%QG{{8}%od#ev47 zOp%6s8;b*>(w>G$EdNPsMI_7KL>=Av3Dtnew?u6jl+s-{RH;5TZf0Qt zFRR}K=B1*?=Wi|EV4($t1+AEi!tzoQ0=MG1o@peU)w}!7l$>6r`<;x}R@}ME0c(}4 z=Q;Uy2sj7Q6_B7s#ds>e!hkLHT(T#g|Gx61TdXd}ZR+jqm}}odZr8v%6RGu#YzJ}y zsq?}qY>+S(MJuZG0$ z$&qunol16_op!8zO`Sy&whs;13Dq)qpoz_gID|VgXtJY9NJ1=XO_Mc3HBhtgHDIw^bW9~G;r71gW9uE_tmXzP5ohm9(K_$b;4XiD@{$acRTn}s zBFrMKXs%zVK(XLQndIyg*W%MS@ELqUM6on^{%PE&)DbZEK1KL}g{xX;p=O5*SG?Gg z^}Gfv^iBdAh`2r#-C;@Y!ZKOSv68%UESU26NOUq*q#ZCZHEznJV1WBk?QgflX{)LR zJL!*3YsXSrw;5?Nk5XNOBb?v&r!6oJAfd?K8`}>;952{?#bupsnBI^P$CXNaj-wVO z2>(R{c%Mf-!Z41nyr~ylGh-Lu5)v}p<%p0}ZQ9=5o`~O=yULs{W111hDRh1&3JOcm zTu!r}YPj7<)U9F%5ZR__$XLfzPlha*k+Ps^b27S9=cMmHh!=h^{24l<(R)d-?zZZ2 z5#)1;mgn_!A-Rm}igYo4?gv#`$9LsOuHEewKY-FzwA5F;T>JXG%WX ziUmAC12Y{)O6JTU@P4sNS=1OrXGi;Ar^_IPpf;8*5eC_911>JqB0^5HT@ zl3d*}aDx^JCR}bB$aDYX8%-@$I`g|MrveQfI&GfcM5gM0hH*G1)s5RcNR1qv zZG7#Jb2aI^c|J|)FXI1i&Q3#;pH>vmgz2DgKXu&=~#)(H;jK1kKO;apWt{}BZd zh+QuiVFq8gM6{o`fXlR>s=+{=2MF!6kVNkc6%)5Jd;QP}I%#(nCp%fJ8p-oH4^yh@ z@BHHRr0If1UqBz`FuET_>&$wk_;MZxjr!O-Lh9uy4O+I%>F^y}Z+L8Brt2s85hw%^ zLi=oza~+iaxdgT{A##kn%PiSW+L3#m!u~@p(Z9g|$wx9g|5140VH5qh!Huvuyp)u! z^`K*^F${ramHU-V(narPpI5(v(QBuoOKj6fr^rY7HKol=AYR;TBt0a%9X5j zuonecf|RAUTlmPB z>UYoAT<%`}vwxjS1f8W`zlHwk5P+829A9dGFfL73deezmu=4%xU;$BpNtx7{56y3F z^`3*s!!O0^$&cAS#l79kdhmYq@hQy~-QKbRNQp| z?}i~Oj~3H8$!mycF9Z2$z<(t4KostG?F?rsbi^08A|!Pn20W<0_T2pY1+a4t>ak1= zncf=|JY%D!==7G%!m|&Y6udvG3-Pe+@26xvhj>PI5u*koOte?wF1uF#ab1##M#DZU zL@>ffA~^risrjz!gHqWp)iIN5r9SKK2#i-M7c`RZ^|Jf6u19hL$5^^<%Z<@TEP&DR z>Gb?><8aU@51#8rhxj)_Q{^O@wKK`m{qOq=;6sm(+V{T$kB5D;? z=_dWu4>RiQKyuQ*wPm_<^B$mm; zGFdxUzBD4ps}3yJwEkAdL!SjH4{|ixdWs=v_LGF>*SemT_2HkNj16nf7sIm78y*2! zpGURyEy)gQw<>wy-N-YNpSXlX*EJReu6S&4mLK$#HqMs8B$e zIxICdb9KcnQ_njHI9k_!&2k_cDOBl95;k-RmNo>++0e3)AB++uPo$2IEQl2;=oqu8 zWVIi9Ve`t}tpaeVe81~E^EK>)6bmE-Z{FXpPQ)=kjNT0*u@o^7&EKq8(Y_H+R|BWh zwmTMX+Beri4)Hk7_alHwxg7C(U?jiqN*=&xd8E@P*0Y7wm+YQoQh3 zIW$cVze~D^8%sK~3H4@28wopUr5lv#G3gnsj7%yqj_s z7kz@XNLE|GcWF)kNK7EZ%{?RaBPs5Kb=m{Cr6Fx$KLya5XgmB1m(Kn1_mOmdLl|kZ zX3Vd84BN%HuNwj2QKY9?8>ol>5^*uI{V5fRnegRK5M7Q|wc3ac6NS45$t+UC4L- zNKIfPk3drfX1b4hD&D_qcSKnO`jY4v@T%3B^EE|4Y^HBGmQth4&B=kBfzY3zsr2nS_;O%X`0>+WAm&I#y8L5xw?m4i*j1VOqs5vMlztrj zpLf@j%Mz5Y_In{GMGF6F7QdaAlyW!W9L^X2vi2ZgrS}7QC9Ov(Mo|95O6oYta&yiz zfY(}U1~9W%Q1MEV^vs`ZcrG81VX;^7Qo$9ZJmdg_$)VB@%3a({7$bd-mvnu1Uh7{>+}&16f^mL zg8wjev(6x6?$rU4gW;#|`%(t=0@V-E50}dgMiZHt@I7dLxe4!_~RI}Y2H zA=Bb@01R-QqQhZL@s+c?q_D5;{k^+u3f#}c03VizYjgIcgogpE@&TdA@4}fYpy51b zQEAk1jdEbvk#2#4*p8s}H>uL;Ae!l8kj+&()D3R3TLP@LJwipCi0|}`+Jg{j9NF~Q zN^))KWXCGXR#(*v$4c2^iGV8&e(VS8RL!u-Rf5+WFJk4hLvI*}F@0%YzogDQQ<1~e zXxE|mCBz;1s?W6wi_RV%$*tty9(>a8Vjrs59nPs`@~;16m!LpF>UI8@Em+R48$(`L zvA>O=CEpD{pQN2%$bsEm6ZKdwWZT5I)$`b_#$Aj?$;~(MoE~ohuAvefW zDSd^UPqabiQ3ttm-`^&**mVQjO_dH0-+XSGQ2qHU|L*+{zW1+a(qZ2-Q37&dp=5df zVtMUr^vlghb$JJ4Z4+D^rf;pUk>E_$uPp3#vxKUP_PEGblTpSDg`!|(cptyJtZr{7 zzD9k^_1XBSnH)fM)Sh=!0!fO(NF$q0W#D0%+OKgmXm@73Fsq>t*vcVs4B_5pSYGV7 zrnZ)GYiodA!wTFTEAoZ6b*1GfiBpZw6-JTLFbu#`~PnWEelFDa{K=VB_)9#!A zd}uP*^r#N)VW+ibCxH>Kf9(uG+$=a*d|TI#>DY1E;(4M<>rhc8iXTxs;uENX>ARN? zi+Fz8g$~c5?G%Ix8S@QZyhVQBz&H<;6;&LNO9CQavB3Q<$4ONZwEPBR#P>XP`QOO> z#YE76=HcD0^W40H=TjNipyZ!x?e)t!ScCYG53$nQgKRjaHR$T^Dc*s`3y2GHroF59 zC;jjbsh>3N6MXsfI2LAjqDW{{mC#~8Fy=nFgtl9(0J`CVf0~wzGbt(#y{s_J*VfcT3|vNjVc-#7Ey9Ai+snVKYSyXol^&_d@mo@;(tzxKf% zgKr{-+mt#j*V5BeiPwPx_7XW1CE}Uq)6+-+)o=Eg0x-)ru=B2)y4d`uYQrGSI?N>( z^7%V7?J-ez_o9?<`+{Z~I1ApmK7ZPf;tm6a?B9ad-zieMPJ1{KqO$bU$wBH;Zx>u* zKrwDZ2f0dlof8B9vR{6O@gLo|We($ET$IN24PmqQOv{U+-#3l;qD`+p+jwq&EZM$Z z>7hvW{{m~-I#a#bO2ElW7H-)jn}=OXJnY3=s%|6~OoidLvgq^uHuXPjn3C$4YM{*k zD!{J?U&+<5hRP2edt>n*@nE8hR9%itIRhjCk4yqowSsX5_f+c$xa7Ydi6|4wzHfD9 z2YnI@4I68oOhAA!~9xO$n&V}Zv3zD{*R_>aLel70?OMyW{kCkM=Xb7i`UBqU>3*L3%MaY@7MPP}FPjeO$HO$3XBqtPwE~tA4$~!+ z7~PwLX`>MWf!509FceckE3XRK1b8D*fCJA+M*Qtc8bzZTgbo=RiAJUZB6T#2ryDLN z$>jQs94mbTbUf3;YYy*}?+-6MBi(5Ns$~J4H?TRc@0vz;m)5Uis#62i6MWBE`a2k* zWLe5FeY(ljhJstBQ0pjwz#>mG#v=9=$OAyoicCX7pnoP=T1QxYl}WrdzL^6+2Os%e zTnV%PTEWl(=ngN<>kZBozq@{`NY_(U+A`VM^2ZI;)n*M7V zdSLotz^r~GqlGxA z=KaYAmjH(ght61EezH&7*`Ke!U53BYs0-~w+RnAfVWvf+( zsWy4%@}Y8L?#~&^?b(ts%jRt7!f%Ht2(6;Eaqi4X)SfeJ*Owi9SAy?;S9&D^6$HRKRee9IG)`jdRM(T}} z2JU(?hq*7iMlMV9eUL5$t|?k;+-ZKN?omB9rQ{FRbe&LK66j@O5!a$ACcU-~^4uAM zj02UnGXhREuM$XnQ%THaLz}(|%~Ham1-)R@!at;#Q!y*r_3vr-`+P?Cpa0g5RuBaX zjY{FU^zk~y>1(~ZKTiqF;L%3V3uz^>!XgW~+i<7IA1Qm^dLA@h4+%&{g82|LmTN`o zh&e992tJTM&bb0ere6Crr>kzDl)c#ycQw=AM}3kRy{$eIlO1AUvrj?v@qa3uw;CrM z#M|2nGAlCy9Hs!QjlO{_KY#pylWpS~(T^7Gl3;R#o%=&-OLGV+hPr>ais45P#`>Mb zzohlDCt!7#Dl3b1foLlAG+??VsqQsAxlhum_YYCpPI5XIlMMp4_ zGS+T?7~*I|^&!(pA%gb#pZ%LI#rIE99aDH@pqbwMF>4rP94Fn6*xwvTw*}}E2%6<^`W6W88c45 z))Q)QVg-oL{oN%cc}~WESzjh89tRx!a6ayR-aW?KRXwj)1BMblW)%0{TLfdF*x@eE zHM=lB?pod%VQ!R_2}j`3g0z>pGhfIw15cq2lgSKgi3sAE`gG5{RT-J^V4iv($12Im z@CXP79v>Y!-v`*;2AsjKE#Ir~4F!dzW6kga`FGdb^!1%B){kBsG-Vh8-T6bpZIoHs zuOo5+C;fFMBk#uZhA6fW5h$Ro=fxIc-}@Dde2D!(oTb3_i@t%uH((V4cuE9BkQM6Mln@J2)KF5t1TF)f3dA_CVqL1P|F z)R3ceL!R{h3d~}DPN>)Fgd2;gem4O?hQ@YDvP~sehdF5I`gpPU5xO8{-DD-7sVDB+ z2_h@`DFs35I~v6}Ax!MhF)RewGK$_IS}Y=Y7|8-FbDcemkE9!J>qe1yNXYk6{_zg= z<5TzR$yAvgbf9BTn5W9oypQwoZWiPR*ux)r>tp)CijWruh6-AgDJHm|8XD*K{ytlb zEIPb&8c{{7Cikt!$G?}$6UEmNqa!BHYPm82+l23m6RpyLCTs@9PrYb_vcq99(EB4`$MVEfxROAZ9>E zeZ4bFK}b6^Il3y`U0MD+eYHVPP!)`ufKZ^3zdyuC{6-Swg+_4uvKa1_P8D@9=`y-f z!XCWERGvh`f+!m7c4!2||6>6#Mv}jYB1;jo4{f&*mz#v(S8mvs#iUI2fX3>Tsuq>5 z|CYz9D-l&v`TfOE(!BhVyOwz$$W}n$z9S{lFF$O^Q=`6MdkzN%iJ^&G)}uiFgz1I} z%##XrR(7zJo81v4numjQg#hP2Ze1pjcymA<)3YKZ@xi%f4epQZl#ayE2fkyHc(Dk+ zMSW26tDs1*v$JzM8VVKC(nGuE!$$6+6^miabbO|fnT!8CjgMC@EAlC|4i>^?Cqv+a z-vwW)gcWJ#r18;Rrvh509Cr6xO_~Mc%LYz5oImBSJ?`b6fFAPa4fq0!mljPy-fiUX z`Z%uaY>2amFVYnv_*b@;$SZ=#(nT;`yaj0TN6+KK z)WF4GF-93|)P?WZhW+@k5I-T^7kC*~??1t9uQ2~@=4N7!@L|<>9nVoS#0c8c%5?md zN%~c(*=#^aj4_@a!2R4iL$|jFNw`73zWM~f23(KlAHZVvKa9dCAq4rbz_gNl{PDRu z`M426Ho$dE`7;oKdKYIAf#qJyw{%;UWJJDkgC*y+@* zBjiSaPkJ^NE=l{Nz~Xx6FSpdC`aJ7pzlRMz71gh4&9;(0|0z8sTwPt+Tq8(-<%xgr(`V$oDD@52Sg4n$Wg39<{$_@9|iu z&V)lLKEr{T4BbsScD1yy5J49&o;x2e&FO!vuaD*>I6YeDrA3u@|3U(S&_(jm3n zvEk&1Z=NQYtIxY4S8Gfl=5H;?``Rudz4A zoC|w_hDwd;SQNsjz}GTm@^)qY5GaA4ff7t=IbVKLQiwJxus)kQD#4LC+QFrqa}WPp zjfd>;Gs4Vy7J9*d-KBY#Nce{2l<*el5wQREINtL#HIRWUShvy~=iSx)^R|e37_Z!7 zprXA1WnzN?mjgZ%&W^;tA=_P##a>tbBAs6g;2YGt7-jaUAnHEpyfv+EO;0Cp(pwqroW5o+JV*@x~JN<*Pl9cfeoi%)fy7Gee;BRGzjP{U`($1;}mX z=;^8asq1l9nyID=(k<|!W;A1B;P1f~+qD&RB@&YSZ}B?vlgt*@A2R5g(LHPfKQa_- z49~rp508$FRXS8+u+0!Wk1&KrVqgoQ>bl z1nHU+X$>=oTEC)dkdVSXhw#MU^WG`^dR@dFOuN;ufR34M+><@{A_IGT{Y3gCiHAnR zOWj$UBh-M`uc(B1UMwY#%c4IBm{w#>P%Gs5q60^HT2b7BS+J?z{J;r$_?%NLbP99$ zAK`AFP?_>+!Fnw4?d9R=!uNbQfgW2YjZhj>}>ut|HRX;LZ?JK;FTAnQUSfxWVFV?Gd>u+$4#5YuSSopR{0e` z)l%wLM|YOKfQO^PFOSUh21-KOn=KYnW?&*<9+ax05g+M+8eNLZo{a#Q1W> zT2;)Fioz3G7a3=?O1hIMaT#^umO~LP+l>s1mxM>n;{Dn@^c`>rmEmGktLYfX7z-47 z3lZvz2)MI=Rk+Sec&8M683pd`Y5Q<7tZuinm6(@ZIO9^Vs@sl+fKmhsN6{VB4Q=Ff z#SK$QP!J)gi56I<_4~<6mVB?GTV%>19D$`u4Qcy@v{LgPnq4+AiQ^NzhP2V?g_*&u zH=U=~?g~++kSp4u*J-(iSME>{3<@R{CzKjqN8JzdQmBBj%5{YlDW3V zr+#HD3V2t|2y^{cP3N(vWP~mu>!#1XJ&0SVXp%M}7u=jsaE97dP;ZNvcQiWG)qM{GT5e`?lP*ttRS6Ywz~oLD9vNv$ z`5V~Dwr=xNhj7#0!|{B53_kduHYitt0Landr`~^^DxRK@YM6vP^&r~J=nh-{t+ULX zXifX{3H0| zaSPb<1O!6ujgi1z(Y)JU)aAy;O*e6>x+Bw2?ds)6p>SQ~^E(^6`Qv`JzcDJ|hpyes zPp|&1XFeq1IqAp?D%ZRjJ-QGc&~pBgHDNyGX)&2I{DYn4t}bPZ_lnQLn9@^*eea)c zrrBZi{n!GBoGe8zAxNgg*DuVqr8rPEU^@uzeXHtlGRSUw8e+1*pCN3x-nThM?DGjw#_J2v{~=TmoG18lh6h6jy>>9yd?SiZ2_@i>rd2^k}B zIS`YQ;-V28%+r-*X5vXzF6@4PQif+u%8QhD;7P=kNMnU>J!`N#$!}C4#Jp2}sHV+# zbfZd?(Bu+N$TJ9P#PRmr$q`Ma`m{rsw#R+Rj|-53uWVUCPOU){ zDwu_-)Sr@`2kj+NUBD%@EimNz9+P?JbGD8Ihcw6*?E> zKgK041%(}Z!u-IVcEd{`}-V!LqD?=y$ZYd-FTYj$=+mN~OuD^I*#( zGr;cIzJGaVE$D7;&TB3D`Vb_A2u}SK?K8_Lmd1Nr`q`*(gANCB4Fpz3auX@7&fec2 zs0n5TQQRyU_DpmX5-T z=Zb<4kP0<%rl8WM-0x5qK>62}|MVVFcF$T5roL%tV+|qT1_^|17 zaRF#ZL#}>NbfSK{Gx)fxW4D;>B)vDkzW>|$NBb^%cp%^Z*-E#^U(buV|FI@ZADK%! zZfZ#H$sq6fb^50mx8rsJ^&+}i!r!7C-CS@^>+gtdUF~|&xa7;TD**CGrtf`%^tp<< zoyg#X0rPJXBnyPtC_^8e7uxFS*inYlLBAQOH%Kgkm5m)@tuD^xw->At+DQso%7uK! z_hV@j9126SLM=Eo_2hzkPGrXbmCC0RBRtQ82b;%!QtA)=kFV zx28&+RNl<77qw_rC4clX{bCqJx+Sw@Z>Trv;wlZB$A^#i4?#J29zMri`RQi-O~K1v zC>8}dIp4{3b}mg*Z9X^kJt6^v)NbdgJ;4JPzp&B~&HQ`;ADjtucFi32UjlBzkhE}` zM2`zFP(qq|sSN_ucFlHsmpc^Y>c1}eBc|SC`f}bgX8tn;|JCRe zQa;X8ju)@Sb+7K5#4HI8S{<7I@jyb`sivf{65j~64IA|lnsW5NT&2#Vg1sW03nZk& ziiV8hIQ>zv3bkE7rCzjsfnDMW(YH+XJC+Fe9UK;IRuUpNULxIg*R}uvbTKvaser{D zmgdbb`kj5CK}9+j{{-fc+~BR-_>tnUX9yb$e4IWtJ2?)H+0s3a} z^FuWVV4wSOVWy^Jpx)yR{>Q&kNloVT$S?FdJ zy5Byu*)9)Ek#6+ijOT8A(&rz+i!k3fU(#uHlZM zgn51$+l{c}<4KNqZ?u>q1OU0+4@kL=n2l9|@7p1$-L18?mlxOEHvo+7qN|2&*JAG1 zl@tQFva*spz~2k#!=bphtPQhpI;!QcLSD2oVE$p1YgRUizv!JvZSt=KL_d_U!cSXs zunBSog+!qA729M~?~Wsuwdu$e<6rTvXn2d_;F8hQ8)6r$C2=OBayZe+8ugW+*lK;- z${7Cf01K7OF%G?BJo1(DC=Y+gmT+ERw_x?26MA|eQS)jW=j;dKIgQ^E%n!T*LA1=H z;tixBnviGGoqC%vkDV)*VE04nJ9;1iPa!3Z=mo1 znjOG#o-220XFv+E%_WWV6Cfr)A8~gJ=i;;#qso= z2L#bhYcK@mXvX)@jw`HcQ}%Vzpv$qoI(^!+BsFitzHm5P99z3OBQ<`p{!bzS)MFD< z5`o^3hiyYhsNmgAGEVwjWJfSmvgZAEs_y>v+%RwXMfaU~pckf<_V_ke$MNqL^ssQ) zwh9(w$GzZk3FQiPm6S%>Xr-E(pZW%S7Wl!imP;2|+>}~dF z^AmKVR4BhTW?aDfDm<>mq&cdI=D`AUmn&7oNEmtISSQFHYH_XzV0WgEen9E^b}ax(u)7i*+1U?WLP9-(Pfua{_7pF| zZ&3`&>}J&%WN&@C>)C&2-*7<~sB-L0A|h{na4jR}>%~Moak~Js{JDIO`>asF6;o^I z)2JH}p};de(|B-P;SQp||&^ zyi@8YDm$`ZsY6!ghh?u-_p&fnc&E!=Bf_?U)OL_Rjj&Bq5bdX*0pp#M={7;y)<-h< z74~J!#A9%xgo^lKhym}M*a4d%Nh86*N0pl2sAEHWZkoJr4o2Llc}z_mc1-pf&! zi$)ycjd>~y}2pbmV)Y?^bu;^)rHhFT;H zKYX1!9p2-OkLm1NLY)U#_#qG74+12N_A84s@u26;E+2MXZ^6tl6x@*4$16VN3bmKO z+r^;gl?IlgB+vd;q;kZ`9JEc&^UM4WkCORdI~_+tJ_yS~M=U35ArU^Og0Uc|2v#mG zxG5)0lyE#e>+0V;Fx?5}4N-Mq?)aWV;@BxU%N@q(8LMXWXQRUD(j$`YPWnwZSaVkCrexNJDLDF(=! z9A2DMiA;MQ!|1&h$a(E?v_@ao#nn$z`qTM-f9`bEY}A+2k>Lf9DPsorR~gd2ykj$t z$w&trO6+uR%tjLPybx^yZO1gN%5z1hOx%1v1et4M@W125r!f!t#h}Y52375%);R64gVHY*6E`Ke6pO-#70AiEV zuKz9ENfiVjNp|&m!%{p21jgnGJME_^^;g%gsxP@C4Te-SDbiOyoWRLJfMsQ0951&; zTH`5*?C^Y!dH2R^c3F30iXx4ioLKG|#|OxNwQ%%HWav53=e}Q|JIZ?+V+MXB)>9LP zOiV4g}rNSB}#4aB(Lh3mvYS?5(t3pKq&o={`h>}CguJ$Cf;L#|nvmX*np(4vm zG(N+13iVzbz*RIm*M+I7uHKm~nIX(;@VMyClWLBKoF7PxS#7vTDt6I$HU+U}Jejrx zjq@a-`KP)W*hCU433=bDpYjdmLh->L`#hZM<>ur(YVHam$~^(LFn$02F`8Rg)T$P2 z+HyMH|693T(a3JpPERBJOHKnLYDq1$;<5X5AM|{Civ(cgV5gY+exe*Lw%!U@k)zK( z4q8R&a<*jKHJ;j~c6}+uHQ!FtD_^T;G&dB1#(*LnPNV`kF>2+(&>DNfLJm@5-`V^f z6W>zBoa)81lrxgRv9zVzHE!CF(>{pl4&Gmu8mg%L!^HP}NRFw(hNnFIVDK=2wJ@|$ z>>R$L&r;fz6GX1$=lpzWF}!cYI1&df0gQE~lVSIyKlw|5=OGP>uMY zFp_Gs=^L0?1G~@SMS*{dIKerVt?|2jj-cP?Gj|#%E30&>J!@bsrCDC`<#&A;ZS+n{ zJBVyFI6PPdad7usPkTIxLE{=|gP*4pk}=m!`$UZt)5|()BsO0lpu~_QAtcQNbLP9r ze%${+mDBnY%Pa4jf17X>Tl4K%o)w9VoMQk5&_V^x7xCZ+!qaw8EziR?fs8P@*VTGs zyZ>mLoBl?qcbh1kio#_J-9Sqc>U`2{uFhFcWVrpNI}XAMMG3Egld+@I_9zrVdi&T3uO>4(o=gy}(}uC@8;h z>Wp-lQprwF8)Hj zEw=s*Zr2K;v{PTIC$~|bYe5CArS?;gk~A5rLXI_G2l)&X=z|Wen%{T`+`eKyp}&?U zOj;B8k4X`tI6SA(oHP(3Hbs5@wP5WG>lH|_R4v^D$4^E3Gpi!28Znvhc=p8h4<#~) zntIsja=VY|t1J|EX1-8>zu4+MbzFkt_VG+#&dB~uLBS-^pUjxO_wDL0ej&kak(H|z zsxsU6N=Ro5@m$?k9SVZie<C&7S84X>P@i zjRHU!$_*HSNch|nDIJ}lk_g5YNudt72q=wxIT}`jo`mMgG3133s;io@1%g=Mm*ST_ zy1ksnv1VPR!e%lEYV@T-QYu7o27@2vVTin?Vdm9|(bXwXa-tx;z(*uXa;y2c5O0*r zs0T~q(&z4H5GzDM<GdlhA3`qSk z98PO|`lNB@Hy64aq`2Jj8D??41EkjcVNM4mnEnz9HfF5D2Kb6a17x9 z^pWe16j*BkG6;DA?@zHY{TtBWbp=k)16)s60iZc?nYGmUd2UYCk&(v5Si97=v=e4n zekm)Cnm3N~H9jBY(^shIXMQN#r}%hnixvU(v-Fmh8Z9U|wuCiPW((8KFO9>=51v&B zww*0=DlpP%`T`L=4zK=~Y{h?({RFiaI!9IWRF}}pr64bZG1??lulnbvz8wu|b%z9z zxFjvuiIcWakc1hPR%6#w;_ZM470mot_uQPc` zElKXk1uRTVRSJrVACQTtyDJ7(8UOwKYwIm)H?Z}yoOc4xSLiCOTPeZ82M4Y>Bg)^O z!2*HH@!v8VA-`v$jizc$MsGn#asT)1f+G(D1t+fUxbS@6E!x?`cfY2*5xf~w4eJZn4MMO6icS=1RNz3#6Xvho-%PCSA(XMaZ z)+40Ac{!^Ob0#X({k8!L+gswJUfF^>>ZaR)n}WBJF`wgKtNCU^8I$OmG`;pJw~rTM zmUocMYNc9f2+$ibk_x(3AN(50OtgHegi@G$Q2#^!@xScK-_bLsmH;>qah6<|uxd2Nh6~qPW zq2IdUMq@T(0Q|UN&)k~&>@$kq^!oZb+z?os_$R%lz8AF}`R1v<2jox)1gk-8*2DJI z!41E{+x}>ZB}Z0Auqs?)Yav!7-B_90qV&84AGaH*eBoCsKs&E(ZH15dUP}w1TBcK& z*#Pm&q~(?+nxZkw4)}~i&p@LHOr*Zj`ORdXAZtlse>&%6rqD{)rt(5x(i&n;1Rxt= zIv&plB7qB;e^6qBq^ZzGp-#vc5fCAuk({_B=cCcSLJgjQeiM-2Q`EA`;Lxo2A2>)R z(H0{;8|Jh>SHtei_qBR7b4Q}NLOxd6lM6chRCS=Re1_*U>JLJtu2!7D!5^yx>@#L08?BN5>dIR*V&^QWCqGxjtteYg3Cj)Us|0^;-p4)uIsbW(Gbjs&?s*EL3Vf zOA#jG;M^Nu08TImn&QS=IjRnhV2Kl-5FVx9@S1}aF~tYYFfVY>c;WCxN)Y0zQ``ZfX0b6zc5C6P?!rV_ zfBi!2K|L!Xfb50NJsO!L9&Ej!xTDKDy#US|-73LQj*a3W5j9#Coe6Zkz;)Z^;<_Ru zlfiw}iUL#a7j*QP>=-uK2|i*}SsYV8Znr+O5s{q9AV%|7)KLel8}1}Rf&qElC*Ysm z6Mpw8O$8QXv>CF|+CT2|)4LaJ`|1HrnCzX&xm|p*mNf~ia4P{gHYs3}MOUJwt1Dim z!LCy@&%n|W=W-0FAxZ#BN9j-*PbdRFrzR#$fT|oSqvwaCeFsbbH$_&>io(MYN3oA`i(R4uJ%nQ*Os7l-&Bq1hsZZq%T_V0T$q5IlOM4 zxEwb3X&Bl3|K^nnV(r^A|hL12_@7u)Wqq{rYCb z*GYLvTcF7y^w{*G(Or_}W+j(34Rr5~aYhYSV_}LnhV~D1FABRUo1%_zzw|X`3#y~k z3=ZwVF}6|WDVdFh2o2N%*&-I32Bq7fML1t|K@0}#EM?`*f30c}5lzt?(8CP0>*nj{6yAyGFH+TcC#6H^#`Zj<*EMest(@pWFO?+|bt;vij%*kq8ub z$NQ?l^)bi-YOeKG_6fWivTxZCX;|Ut?eti?2Fue8&CX)npXsdP3~>c61$aG)_Wwu- zH@7%KV%_51l_~@qqWpo;6JkAbf;-q>XynyEGInA9WBRxIw8K4vJV$16FF~k#&h1Z0 z2pp>a8G!#6nznDjm1puu8F##@w_k6K2U7c2g`%0jz2(eIr36^@)4!VWyKQn)vCa$L zqa1|u2Y=b)@xga@gKHT1hN1WcSRG?ws0PB{CiVWYRg%*W4}v*$KAd=-dy(8}K?kfO{XpPVQ<~qMxH*Y%OPIP|9 zvU~nL?9iJH85Rtb??C0bjgwXM1JQVLMZepZN8NdY@ajE3FAq5M*>60Tg^tzGxC~b} zhpU^0_Ft$ElZKxRnXA3tt4|NLc#uS)9lYnV6}m6{E?!7D6Fqe-DXLaEv$C?hkHBE? zmZY-UA*e6}mozY}4+)Sn(c~5|cXDCCV-WZ_b2fWC?z@KfGegIx#Ahoc_k-I!|2=IHKfXIxn zjXdUsN?;(!1@~_vn*lf^P81WR)87hz2=?Y3HamYrt}F;RtA{G8DCD|afV z2}J7@QhRc9cza72Wo6f0OBbvm-OaR3(_#sPFImy!BxilxprQV8ymJmw`SmT?`Xd`Z%889&L;O1 z{5cL502X|i4I2QUF|da^qdyS^@bOtl#ur}5k=?!q@EoC0@RN)K*6tay1pWp>uLDA_ za2K8c8NBJ|;F@@c3f*KeAe*@BS~SC*ykMX3)qX@R&jbm;GhuZGRJzI>u5geI>-8Dn{b*5UO_u@t78L& zH`o4q{+U{;YQ={A-uRCUpuz}=Im@)VO9bX#!ugbbGjWi*9iI5A?5deRa$&A)A4N!S z$bt!Q9rM0XBo{VDk?nMr&Ng$=hXJm80#Qph zDa67RaR(P++2RNgB{+;R2_)(eDc`Zg31P)bCPmsU*|_EFhK;w|(PD>c)iiUYuZ-|^ z`=4$cb#WUSd{oYfM+=#No|bO|xx;GW1Q`fDfa6pNip?x!-1E_c-6r=0>QYofRW_F< z23=8XcFnQ5KJG|vW@hhZ7q3NkS|D@I2-2s+V71&la#q}{HrC|g2QQ@bqqbo_!kqKA zqdbP5_tT!{O54dBOHG&KVBXxxfDW&lL&eM#8T2ydfv36vz)=CfD}n1i%jKK?CB`lT z`dkeSdt-n9O{D^Sa2`KLnmcu(}HN;r~KXq!kWad&oUhYw_NdyRqck&2B)V?WwE z;!U^Hyvr^5AEaSuqcL8F@r)Y<=<5>N+618T;yHO01mf|l^}7ml(Ahp`WoF9d49B9> z#tgJ&`cW9#%it{d-tai3s4g8Dj@5Je>e@AZAM)9}$!j^^=Bi z$nq(7-fuhnXI6JHQ&4w9LlQXv`of9ug0|cRRgGzUVgmn;kO=TijU$D}GQ=@tl3yJB zs~Omh)+c-BgK(d2Murp;3bny zWLV916#v5E{Ya2>l^Oh&K>ehH&#RyN72vbK7c@@{qB6zW?6Ao@49BjKk! zmw$<67QVDmvvyLP1J0v@0&&gGHF(Q1Kg0EhyBd+4F&os!2JH-2Vn%wie{J3fq5 ziEiVmewujDfm`w?33~*D?}0fSmG-xUcy0^koMBsm0x9KAI#%2z@t5J->jfWt&3qp& z2J4TXB+oy$d~Ro2-tWUP9N0H7$UQ{zU)GOQT52WSkAuf8aG7-n4c->mWw>iqcOQVm z1!}W06-9xBiRi5kJ(4O7f>aE#SB1GZXPLH%-zeA6r5oO5bCP9yGzb4;Z}8KgAF#tA zfOHyqaDZ5$`Zqs$I0xJ~o3dqdMl_*hxaASmaN{o)7 zVwlQisAEL$IbwvAp5+pSPzzV3CZAUV;U{L;*!mrbarJ=go=Mc2N`moK9cx z9k2anXT_jJ*wR4cx`nwp=8&$44&t#g)`MvQY}-;_yHKVDF2rlMF0y zO`5L!a^x8v# z_zRSSr5LbZ6DF*CeDV-Q1Km4{!m>%k7n`bobCE%B*yDCzgs4!i{u3?oe`(r+QI`bjG1e1Af^dA=PYG%SU;gRi&aB7XlJf8z;RXUt9vK33>agf zW0j0SCxwlH-dFKChB*5ZS7$L`YX|LWgk2Ua_$g#QoSpT!m?jx~R% zo&%$*8K)}nOI}WnTT6BCwC8IM{7U%x2QtcfF8m_DijaY zbjf?%1h6-NPNzrrP435AIK~Cq|9-8&j1|{my_Idnl7o0rY*3a{Gp?O(?e&$PS+70y z*?Lp@>SZFkvRv(N`GU1%*Ftl7!?xqD2N?=>3<<(!Fw~Uup)=L^*L8r_vxoxGZ2iPX z<&T?EXQrK*mDRhu3kmy+F>7<(>@-0N!1y6Lin#ShwfMGV&fGZ(y!Hv6w#23EC#({h`4B>WJ|Oc6j?;+ zJ}r#)V_r)~u({0a?2+4bMq}%F35c(dq?dlW-JS?l-V98Y z-zy7s4`qCs_j=uJwVH?0X5mGU!ZX9@mhz3u7n$EIwVu>8iW61g8XHTycubHgx=3~q zKV`*!4L9wiVU|=4cw9yGc$U10uE7IFo2pD*z(@D|pgkW*k2`*amv!pn>kWEOnhcMbR(Oey z{5aOzo{t)nC zrH^2~!c5aKc*NohPDW~Ydy~7;jfyqt5vD=8-eW1jqH3Ja>Lt6Nk zdnO~VC&=^+7E*X_58SA(Lx{E;ascsk=8kyAS(9(aQ-Bk8#!c6%!+E6O*5U5hOF1mI z^PUFE)!>4;VLWi$qiZErtoAIMXXNm~$Um}>p`O#ti~!Eo+#Gvbp<6}o zS9oM*|EX-$U2Y)NE@3xJ&m`?F1KW*@=G;fv%Wi_M%#F^A{Dg0s^j^`aiB?W8GvniO zmwzY{e5ZO5+|f5wfRqw7fZw5C^C5O6hs#r0X;&BqoL-d%CVM^hpW820-aP`l57@wB zuHTJFtn>GxUM^NRW)G$)Hy1u4DE%pG_42h5`TZ)vF``^mi*u1-(8RH=WdfP3yw>@)dj<`g^Z zO~h4gFwiunsbruNv2_;wiM5QQjvd$icr=(zU?SlnsKIos7g#BMCu-EO1JZKi+Sz_> z{QK^0ob$il4@ZOFGH101%w8xO(=ztkiBSl-K_fF=Kkb+z zCQ}`3Z2EK)%BD)l$DMLwyV|tfS-fA?w%*77tK>g!gp)k*H-c}z>YEs8sS4ob(B9`=GC{P0$8u9t4t=WMIQ;M8e6)^LpZ zKQvuuG@Rep9Y#r_C3^HUQnV1gM}+7h(d&=sB|4)ML_`TuM~xoQ`{+bOmly_v(FdcC zUf-MlTJL9TSj*=(48MF#z-P}}9^{#snSJ~v?_ zvIeR_Z|*`nzdULUibH-03DR`~<$DP(bWe>C-nRx}^7aWh#6#W3*~kzJbTKQeFNf>h zi>ET&iXTUEA2NBf`_baHK*9%T8lc(a+iGo+$;SCWJ~eGQk9i;cBZN=+$F zwz7dI%gJ0>zFUn95*b68aMyn?VmMwj)5F4vuO@*hHfEkpECI4fXNsNbX`Nr>|HYs4q>%BCO4En zZm2#@jSP6YQsn;qost;dL5lHP5ROr_3@&Ic=sqPql;QJeRG45j6T2&QvBUwU6>f3D z$QHbAGA*-M>eGWT2Ix&xJuaWOtGvUk2*nGVd)ppnTwg!+1F%p1uU# zbxL~rn?4Lo7W>~}2Gq@^RN1tDS()m(igO@gRFp4s*7;J~WUMhPeu~3g1qz0a@dJXG z`sU{IJjn8FcIMl!hQ`L-+8R=cy+@v;2cjzh7_q{kn?&Z~6Cz~mpAS3-5zMm2Bg_4| z?@#vV0P8%XM|s@|CX7>PX_tsyvLg9AG_N?}>XaPB{z%2)hQzH(nw#y)KR^FReeZhF z6R`yHIVG1?t@Iy`9Y@1=+3M;LG3`gAHFXwTH=OU&B~sZd*U`DDm+F9umX?!~Q{e7_ zpC&ueNHBL1kc4K%J$0JalPeq*UZIVTY`Z1Pp#I)Y$VX4rq(zZp^|QHdP~$){@H{=3 zP=AWc)&_*m*sJ5%tGV3R)`L;v+tbwU{b0d<^JJ#Ss3%XJun&yd4KGd)djA_@$@D** zRBf%7C?d;m6phio$w~~23O{n}(0JA8q|N@gav}h~Me9zvQDaDdGGFc=8_Qpx^r^J3AUnf z|G(U`7DKT%@5~5b+X)Q%Y<&xS6s+X@HDyT$E*2KtC5`+7K{hSoTqf&;@7@1=XY6QX zbj<~3+*Ag)S@$(;RxFFy7Um~yV0hK@==tJ!q$D zNS`c;09$u^wTi94AhN3q@I=MnvDIZT)9cw~D{cCk*h8Fgk=Z6feLZyutdh{2emQOtm2NA0^EfT`WRq}z=Gsb(MWNz1D>{cL z8QNP1muDL3C&xX3CpP9k4L>@)s;-s%_O-S4&Epp2n!A>^u+z&sFAUF7`y5=)TuiS{ zQ5OFGtoHWy2Cd%@>tJnToQ`rg7nm{L!o&xq{I-kByY_D_jDrw!vtg;XHF$?jhhbQY z$iEqV!8=m+J(USkYSotlvw-5YYna-W_EM;)WbC`B=LTa8YZLTe)a&cJF+Q$S*=mBF zOXv1mI+q~aA=w*;eLIDDQ}MTDv>V1@eZUoy1!wfQVaGd(2g3qw>CB&8HoL#_$%MA& zDO0pKkUMe1>Bb3$8)Oiqq^3^l3_FJ$XEvS}5N+O1F{B?G5Z$Zl@2gsi&%>ley1zI*=zg?f(R20{s_%MN<(zB=VqXMpC_ZbfgH}WeBXq$zB}qHi0+60%`bb##S@-?iR<3 zmHz&v18Nr^#{Bb#@?(OiQbN$N14Df!CHDUY!@vqh>}qS8MM;M(_oCwnSI`F;TSz~S z7i+Z!6hI+w9+7egmq{}J$x4E}y}$ixSaCQj;RXjleO3nHy%VU>e#9ZEd#-1yDCnhu zS%SyPrs(UdO*8{4`SGq+u)3{_`;TL#4(nvj+ev2w`?ujG?q~vW$oWau)k!s=&>uk+ zvYj6H5m4*>2PPV>4@=@zg)KH%ilBzuoSwPaLyYqEIIj81@xsp?a}(WPJ`vSz-lsV# zy}tgTqQ-I1iUzs@Z$4r@uflvy ztz$2OW28nqYf{7}`F~X)5Z}3%V4J~F&X4#8e#rFxOifGs_48-L>(EUCcej9%#ckRY zykp9_yzYSKa_DInmCU{u``HBFY%;Sq*{I|7Rlb(}ze_;X?&#b0nQu^soH23rXraa; z9CL2vbcrGGU`2vzgOOw{@4?{s8+GHagIYAtg96`!2{@M@HJ9~|i=sq7yX>A%O+5zt z@WKC{O&M4X}a43g3r*?;~*Qa_Mj9cHR+m-A*}OU;=9u#=9RZywv!9!uNj z{*kRmj~P*66I)(StvSQ&?5N9d`R!7GqF^_kV4s8*SQmUci6s#Ke0+k@3v~ zcFXv9x@;dwLx0$45JIX?V1oGAtVg8_3r&4@=9Z4>DL zPk%U;f@-BIfQbFL{VedXvS;=X2Yt{$yjDlz4msXSZaa4_2Lg#2d+jW%&V^fN(wPCL zYoCX`1 z1ctHe(P7(Ow|dAA5VSKQOfA8I_wLjFZHNgCQx1#z^(1oJa~S{k)!4by-bGf)DXm=~ z{h-9kHv?&1p$;`!29MuMR-c^(quF9@w~NQ@a{mfUJ8Uftn^W% z^E0Msqe8)jOC90^14r_I15J*k2M<5R3zk@vwk_q||2R_i0%T&7U1`(v!*81-}F)ZqFRDdbSxC> zSog=UBgd+u+9D<23-!1PXPRJ|y#bpRUHai31Eu^nRPpmIEx~0Q6 z`xpwbP=txPa3)hGD=E+&}a_lrq z;%hoO&VPTAM+KhM2cA(*hbzD5Jg9GNqgVyAR3&Fe+gD$-iji6xE4Kpo*d8+dNJvQV z20%-Ty=Kd`)VEW=4kXXFL9SA!U1DR?m-<79Q zQe#JchowJAzw%U|Zw*kfOl)6G#9mBL&Cx+t+Mf`C5Ci(~fyO0c0Y9s__enh%kDAz# zp&UQ!TMu}^aEdcCK*tkP(#0yc^6aWK7WRvYXdDGka*eD!!=WJ+d(is zO?LO^+=QAmNPGdsh15av`Evaenvys-R_^TuKOYuzk2nu#lSj7n)2A_EVPQ+tTjqOg zj#7C)mk){X;Ejl24>;~|(v3cpgmnY?qvmBE=aU3r$Vf#-%mxM;qQs6OBd<5F2$ert z;`XFQ63i|2YX74RV1xlYe}AelANfa~{_ETLW$TWa^k)4%Ib0OcFGj=+FG%42IMj{0 z)we;{yMkcb8iBw}Qz=jrh5q}5jaYytP=<*dXr1wfpH$UpSU?kW(6ro zWo@-Y2Mfo07B6ixN{Dmd89H#y(-kLvO+QxV@>m^ZZny>-v%^L$u!Hy2lYXVwAG!uv z%gN<~Zv{daMxY&C|2YHlzutU15Z?M%xAp(+o}(txJ2fh>=9dx3NJvtaWSJi0-@!K* zhdsOzEwF!HZJypRp|SMni22dmBi4hRhc`g5oZEvFO|Kk0cP)hjNz z>PUO?4wpp?I(*f$RnmYxj^maE*LFq3}4nR?K+MAh$j+x-KCclwHMCxJ zu>19}x8RJg_AlfgAShPpa%htk0}rhO4|_l&gyG|Sp#6&S_v4||!woQx*9GXo(a+T_ zx#*T5Ws~RsNSS~gjQ;kJtHxz9h25QosFU@_nl!d!;(s)n>iA0Z*7Dy5HS=PK~OoCHfuJig9SUPY10w7?y*~q_aEe@(1GK zK$jxxtTD@fQ8Uts2G$KY_1EqMPB{n%7LBf{J{cYmg}4tH)1kIKK}X60?B#WU*7zA6 zhs+v)PI4Ymonu#(13$eyn+4e_jV@dL6S1*?=`XZ6Wv94GM!C7%nJtb_$4k!ob$`Nj z=?jO%+zpEphEj1SCGXO2+kRbd6Vd zd@4amOSsEb=1Zr zPBJ6z0xw^iS_1%D1&@u5Efw|a^`f}7$Bj3;3=LmXiY=#@$wjw56FZPJi*pIf4^1u9 z$IO1^qk{z5)y9weSa3Ra?}oV=1-=S_@i?>e{6n0;V9>meiF)6q5Ay?x>AL^6OpU#x z8YH))r?;*6WkB&3cz$eL-u;AeAXry4f_D|n6r4f zkwx778kn}Kk*veX0$)@u-GZusmCS~R8Z!B6t_u3RYDk4rd(S|V!BF2Ex0$Q97B{N+ z5^<_?ucos@`_6O$C%F?h$efx?Ak%)0r7lFtfo~{eQ^0#6hRWhMt!bKg-k-TbQA|A36wnI|bMXsOP@O+70>^6k=w)u0V&$598J9 z)?_Fc|1uZ2&L6!J26_V(BHqtUWZO|_5P_K+X|ed`%<6Zo6lic-XUu@tx- z8oGX8OxLGbn$f|D!q`cp*>>hqC;d_L$$@gj30CInc!pv0@L94Ek_nLncWyn&&&kPY ziF^?v`fDZ4M`ZBg`3RCZnuJ9PMr-1K5HVtdlyDgiD_|qC3)bOH4imB;mt_opI`!Z} zcBfTabHQ=hFnB>)=N8h=Lr*Uy0>tMOxVF0e4%2m>5_xS>`r(>TXQ~DIhpq5nvMW6= zH|f!+l}CfcB23XSSw1v%euh&dq^Rr?Zw0PI<&KdNeuvrS+ax4=l`f6@CGrQeb=eth zYy+hMDb@n1zX0169~99TALaR)CAl8}O2&pSHiGY!F;FdR6USnD-yWm&O8JMeZactx z?7WjpdUv;N`^o%cdMfw(z*tiT02ry!g`m1vO&>dDQxtv$N zIkFk!8HWV1Pp}vn(Fea@lj-vLjMx*0(1P9iFKL^-2=W)Nai8#Ea({;XL91C>n^GNTU(PqsA206Opo)QLhF^!9pV(fX0LlEOa!E8UM1wTk!8c#G`6 z92GOGSv_EH>04BMP1M!ZRpEQ&%aPolsapgs8m*vbPyy{B^t@j;qP3^Pp>y*sx`5l_ zI)4dfFu>t0pSJVr&s-=0-UQsAYhCyAwALGRm(93r>JyU!%d#nNx*IM0MWDBrZLl>Jr)uW@3I25T%B?YY$N9No{ae6}kB zJ7UNRD|I1mVlSv~Le^zzaO}MGk+wi;kfi|enmZHNqBDNDJJ--;IPC71)q$K*x$9e0 z6=nHeH;w=j_`!&mD*x|)*cMOdjCw43`jXhY1v;ddwH{H(f1J5*P)ZpU)vbO}OdO8n z^qgxyGf;m5HNGg&+@@QF{PNo-LD+McEhx1MpP0U)oM(fi?0b6E+`KWO zbt7Cnh=LLVsiub8M?p@h8gxoJ@WV1~3pp{m_Y`lnudY%~AP%Yy+3aYJ{A7()N_9eA z8_Acep7y{mM^-$^E9uSR=EdAtvJRhw2}CqpW^3^z5Z<6-65V&nf)_I-XmBQMA|Jp9 z-Pf~82p+XNMt&=@Aa2*xojv{9YkX2)xS2bwWol7`HYiRr(Ub*%fhIToD?`gU^WR@I z_a#*kmRiotNNK8UsE6MhhkUJYgHrXs3$7>6ppG)7&@y|L5g(WY@1~&b%`V(^v!KXA z8gIR`PevtPuV=P@uD;fmG2|b%tdde?b!VW$&vrvws5;!%Ax0%n7X*d@u24!sO2zge zflK4la=LTTC{8Wh?7r9)=QJp?(rq|fzI|6S)R?6J^LcbPf_QLwm+@A zJt!M*rk}J6>-TIs-x&G1vII4c46$vbo>;Qhhpo2{UWo=u2Ia(ouC;5UUE!;nfnIXs4Ig~dRJ?QsM`Y` zKnE8qIx4BQ{Yeq?)&~+i>L&W!up}n5@ek4$&V};%yO%_@0)zE-oli$$>c%5BW?Rlq zL@<8U(>Biz2~%FzpsVRKaHHS>oUiKV4F%GLK)zZ>tW4&mwC)OTb@K5_!1RAC4zq90 z#>xJTm&nW8qYG0qE_fWD@swsGRAt38!i{**E{8eIbAPBxd&#g2!6jSb(UWJhjp*X2 zXB@(YjGN6iFj(pR=O}`vUl(1AQ^V?ktJ=l1z;n`TYo5pTQ25#R+uyD4VzYWJ(PWpj zHq6oCZe}+1+LsNZ(qp6CJR^mNLhw?+IJpU6x{n@2^0>P)n60%Tqtltc1-UqaxFu5z zvB_z=WeU8lvKoqiqg+b03t||EG==|LFAbMEEpzlQ|5BYOZ|bg2Df?G(n5uVVAIz@- zX`H$~u`Ermj z?&dz^&KITU0;w;Cg53jmy_A_iMf5aK0%q`nZ_mDV2Opg*7=b{>1bm?SjkxYV>=Ni6 z+H}g&XzsM&(O(^y0$!+VT{j)p%D4AUSf+iq6$7?a{&lp^lvlgq)5C87Tkz^tE6711h;YX)4jkT2KyCU-w}b6E=k3mMe0C&|O1?4ONF(epG4crOmxdYhw|J?; zc|rn+ogkS2&*Uq%zt5iVF;4N7`KV1KfP;AsIaQfpG=F4fTX zyg@9!!v9S850Uy&M7^x=t;J$uq4Esn2VkXyS!kV;XXx33>|A4%-NBF)nuRB|bJzc} zEzMLTUu#n#{%t(_7S&n{)+g=k{GuRK+?Tj@zkcO$Y)^jZ%}dsmv=$fI(Cxi5v$n#Q`x`#bHk#%9Y4_YPq1dXc} z$=b#~O+g=7<5=S64epO4b7PWh=}$dSm%ILk+OeUrn=uoK`jh+lR zZ|*208W$t8P0GE@O3Xg;+%C9yxl!tK=xbYc(B82Tj7^iFFVi0l=swC1b9MF4w{Ma} zpPH@PQa;dH2x)BH($(JP$-E6gFE@^IC6py@6l}F9b0*mOt!u{y>{_s&t+j1D$ziz5 zw%X4D+Cu}ZAm&_^YZWi8dGg&}Eql9ndIied_T%G*w?ljK8TLN?(1SORuP2)z=<1wW zXsIKAehNo8Ww{z@hbiX+zD8|JdsN!uZUmce#A3F9)nO40!_k9-`;1=>*Uu@=>B!Ys zOeh1(M5!qD2_{PTK+cbQv;Ue|Z~HLo?34;%GuxIFa5P^_FH*wu{717ah@YVW^t z@jm5O{W7{zv`>oPMAwh~<2RGC1st0OHkE%c;og-sk1u=+r)nlwth$nh z!_a4cqeq#vt;HYm%Z?lHp)T_~LWrb^_c!ydPFTu_3>lCI-vb@BP~b}Aeh)ew!90}d zXGLy*c4a%K;gp{tHp$4kXjQ?yJd%~C>^a&wv(?C%BNG`I++H3*=DXf~LOHD4_-rcx zX3AIPe^xj3zw+}^62E+lYX99=prL|TdGw zi?XHxm5*h${zRQ4v%}Q0&h^HsoU+ch`Zu;}>u3_}tX&CW!?7cQmd41{xk4`vQam+nRg~VI?TQl zs>1Nvy0rz@vo9GEid;vVzN_*_GxbM`{txySXu+in^%irSvE3jF***pWwh6v%t@ltlrw>l06-rM)>nWw)?TlRR=Pv{z^O;l7_1 zzSwMp;b+KmL65NF^d~)B^Amuvz&+;dbv6`o*O!eHKl{uhQ<{2f@fq!JQOt|G*C&72 zw@$00)ts6(>k`^7&}}|Kkl(z5E$Lspv$KeO@Pi@|81KdCD`1UzmH@esHztem0z=oL zu>FURumjmcqv?i4innBi;c`q(uRukZv4UA|_~s}K2ZhC->n@C+3N)U6aGBxXSA)r} zCD!GiL9=AJq$KilVyn(=WZ=z9M<1onu2t|QTM9rt!doJ{N}qX~b>{F47o(ws=}D+T ziUayr)?0>8UrpAivaltqhv7S&}}~CIKh1J!EMJ z=Y<7(=5;yj>4x0Q&@izFM5w3rT~wNdMt(elB+^CdU>nvlo*7#%2XfVyxg=wDtV{lD zZ|p^QZ96`N4lXy$Sl!964Se*0`osTo0i9|9LoWbo4$4| zJNX>cc-jSdwRN$)h3M(+kv`PEI&K{H-zq#+Udp%Lm6hq=+o&GCTmT43*27~P&EJ}Z z*@SZ=(cgf?5q0zNLe$T94kAT3zZrJqau9+f)KGr3&BZuG_9S2yWHp~Ze+EgJiHBx= za1njn7>>f`**XXTpiY0@VgmKZ^rBm~Fm&9I%i6LK=PM(HG)~K+lbZrwHk7}gxlbcQ zEEag!ckV>*{i{nPAm}Ek$68DL`r2u_OOY2Tf(3PH^3u`SW9kc~*9n?=U>8&L2dSpN z%a1xD^c*I(Yw}~``l3{$wo&D4ky!@^udMfKPDB7sI}5fibCCX91+x$wK)JLATpN1- zt2`b9Qqx{?8CT<)B7v*>is(JcWLyGSV+k5%P-E#b!6u3c$&=JhvCi9_14zK5^# z4)JjO_`9MeS*IhRHMWYvJJYhLlisXn;y2eRR$YxQq$dkJ@-NaJ5gj!*vdp#>@TLwm zbxr4WL+x1=1uD_$tE?*kF)5h|INOZ%Kdinw+=i(yEr0$AyrHC6?k73srcU; zV+}M*OtNYJR-d%yd7JMYN$bQLKK+k2=v^rT8A_8I-3D|!;!1;tG@0h>FdJ=^bcjG9p*)7C9re%PTuy@31V zkcCO|bo%$veTL30LXyJ5hpLr&&0nCgX_&>Fn5*(JyPbt7zRsm3%QNZr#t_7$V)=7e z7{ZvL(E;M|4F$*{=9ZRuZbS7k*qm8rBu(Utv+Oi_A05$_aPiE9WDJ?lm$Z^nEwqRK zqUw|@X0%3NBwx~o<@Wlntg|rO(OQ1`Cj|%m&q>qBu${YMLjjw0CpHacBqq+Cs`|^@ zzw6*5RnK1Q(WVdXiRnp()SPZrmLRwcRD1iQ8drnhGFUIS z=v-6?D`VtoFvy+{H~|l1RX-CAm>PzmNm9bugFRURzw9&N;!uQ^MfKFK=NdYGF|H&` zX&o~pKMV6oFPLRr(VDSLA(b1Ee!w#Z{c+%~=4Ex_oHXHVx z7P$&ycn3Mb%U$3FzZhlpihuzp!+SBrRs>8j{p*KS!>185;d8lbO; z0&T}R$+0U=o}_>r-mpKXymaeMYC-mUI8=Fr8eF(@WTYYj0R=CAp4J@#vhmjFRH*>| zUNvOZB%Jc*8yIWW_$Y->8arw0n#36PP}gey2%@%ZFZsb%nsvz4U%L?HD z@HN7ttHQkNrCyUK1;o1uPUSMP+rsK~DON^9+Tg?Y%AsRpkd#AF zt}e8`O$@~`aUo1)jytGWE^1BB#thrR_v?b>@Xp>a@W%=i77;nJte(8D*+bf3OjD8&M}9hz`V|i$2nEdcA;KT*=!FtacgioeU!)d)3A`Xp zE<154D^{68-01On@lZOfv6$4oZ;rnkYWc5@X#^m_X!jy>(zStGO-{X7xA#Er>1u{X z5VT}Y32HD zQulMV#+)rC4$bJdV+vtwZ!emi2Cc}LD3*UJ%1sN$G7mC$NwK9MWMH9U?(0f&Jmqo8 zW=>lQ3(gD!wd|fK&l=Ilt}ft@Y*#XXv{D!uPP!Unan zDIxz9VSvwx+m@lont0oXvkO_)9vAtHp?ip&nEu82z2{PP-JpQvfA$REu{aQA2>$al z8r0Odzw_8@bo=lG+sx)y2JcF&2}ja&VSeTh3$U$g8QHC@c%Yv2!w0Vc334QkLQ{HW z)9ZKX9e7=LNBRnboHIYlb`bNyo|i?$G!4v3BZUUWZXA;5jo#r_xc_2f(rpx60_V#) zAZXDkq0%?qU-j=NPyAmC{@w=_F7A;txq;%`1W-mpf#s8&jtXr3t)%))H8!CEg!e2o&PhPTnKIrSvI{~HVs$+!X{U_2Bl60 zkCAIv5TMvd$s+Bi_x{dzVt6~qr!t0!J#5?C7rjEoovSZ-Y%fGV|I#f9K!IFOxwr7_`&+14a&t#+S1lWdp&DOG}^sVs<_U%xq*tlibWf+tl7K zIVecIfOJ?c(9*s|hWPaZC4nr~IPxxPsvTaMVy^G#vv_vUmf%WZaL+hmuTFc(|S^f$uzP16zpSte? z%HT~v+v`4QG|A@WQF4>Z2-WLD3t?kweGQVG44UX3Pm4I_I9}r*?-HKI#|^H4sAR;i zNeWToly{GnZvw`e>z(s_R2(iReo-u&ZmmL}l2A6!vL_vC2uvcZv=d8(%*h2QY-lJS zP6w1Xyi<~LLwzYQ(5|oby1w#DL%NJgC<{H+P+IKPAAB(jKL<#nWp!hWkH1*k8nduN z5pY}#4LseA4ct)aPbyBX=44xCh-=>etD^f)huqEF+`N$D2?aIO!>1okKrwDV4|CVQd^jdjo;%mFu7oigv37 zh};7kwC&iW^weZGfSNF5O9CCRKtI55D6GMFIvpZSiuuV!k(EgyIUsg{qxO%mjkL29 z@)Id)+V%(#TiiL*qII%M#xG1ordtPUQYkh0zLEilt@sVo-!)ota&n+-6Q}%OSP&T+ zQ|@$TJl|f6A*+AzJMWLj$nw0kv(AXUBJaVFIoCRCb)mPzQ%+Y`2HOoIZB*#ZM|{&V z-j{HA$-8J7Gw?)XnS@zW=H!BxZiXAM<%z;LGJEsxB=m;xs6@b|vm*S@4lj-r+5ML) z1^e3jeQ2om$=(39Lcjjq#hx}qMMVWoP(YEf(|?Pq6XyWvCIK&BaIWH5Doy}-mP&?V zpGl&NSV8p%1&@z;ur-}1H9fmbJQ!a-P7HAumn7As z;vgS<>{V90$X!A2XpbQop8%?7#U!-?sUkU(Z_>QLxH6^T0sJ{RRe`GSBkp&bdWJV2 zzF8B@c{iEH=bvn;r?TBl?)JDWIQ)t8B-Dtp0JNv$JSSXNG}~6v>~B!XobPC~ZTtH+ z1CU%(a)j^wWLw}BdzQGz`lC&A%BcP$-*l4j4t9lGUzHy)GD{Ewu!nrzd)7@Xdv<2I z};EXO|O-`5o`@fMu8(8yQX8!cn_-Sgh1r*o#1a5^x5= z3AE=I3L7@oJ^3Zi8fx0Js2Q6jSeT~&Q+h;_LT_y`dx!!5r})|p-zLZXTt4`jSoY_) z9UfXKsa=I+1rU(YjJYg+j~bn7ErW*1kx@t9zfb)NjG41m3vFLnRTI=2MCX;Dn3pQ3 z1+hP-EKfffD7`s*@4JcZKO6hnKMHpz@$z2WASX?9=-wxTy92fo zj->`6Vs+#X68ie#H587G*;}=HWB1rrOO*bJ=g9Ei?dof?S&Lx9?~wKez-OZ8u56ZD^F6a<91cF-y}cT&%4QP0_$ zB8$nn+w=5Y?vs)X>WLZr&aEb{)K0M-!aEsF4&v|TZY(+qd*qK3o;9dy^E%Qv#}fJ6 zFil7@ym#NN-k&G2wARb;UcPUOZOc;Kh_KRJ-o=Od>dDQnG;uza;YPfqv4_W?@8Xd< zmAZ`)Vl|eE8bS{809s3d$(U__2wI3YSupsNRC*^^1ZWE5<4ikR5g;8)>;pncS!tP> zmor+$=_qyvN)HI7Bc;cITz&oH+l=SOJ&QY2_KLvR6ndeTdOqm9`cxg;_xJH`#3)G# zx|ZANp0oo=5T&$3^h8eTr+%zL{61qvqQIlctSdub)Iy+^6Ja2!(6pzu%nNuO3Ra8yC%}ygA`B zFZaQRO%B^Qp+hKG(Y38`Q`R@wl0@M4$+Mb#Syrm)I!Cll6Ru364G4k8o~t{AoA4@u z6rp<$_z+OWMn_+C4-9PF8!RxW$jgbzXj0Nded`FxQ5TXp=zyoB1ffhM2!XAVj#S<` zqG!!WpNTrWw3iAl^lsBcAXkM`|HtOS)kzO4CV3HkpnF00@#N2G-`PsziW7;w-<_0c zdgk?Jsat)cK~ckrcx!VG^z+>fn!RZ#i?(i~AKJidZyXz~;#=o&F(4b6X;{`@MM~h3 zhPa_pQ|mX1+LBy?n*Ft1c9SA+V$XKv)I_~oarJ3fj6q+m6&Gg0Xq)Tn-#!5^P;fIa z0HC71QFzs?_r`GA2wRL^@qo?P*-{L&Pv_~T{asq3ZN5CU=NA)uwH{QdE-i2=Zsh2F?PERb7p3`3Gk>}k;1?>ZTUR) zxp7G2E9WvUE-o-1&Z3?!Dz|P{qj!D%O>Ul*-tD{C>(5RIaLxC zCQiaN*4!kglgPyo+VLE1<97;uOa?iUV7sOSWyAYz$Wasj2ri=3M(Ksd)-#UCeU{SG z^vE|H-wA?JS*@~2#Q8QDA&8?3|M)xzf|}Z|PrG)SXR1fUsauQ31mtzti2xT3x$FTP zQ22@vDK~uqKKM&-Zvt0@ssF)P8xULYf6+9tK?h{qFL^GUrA2RX^YV7um$#6FJghP_(f_&JdyQ+A(LhpI|5ev;Vv5bh>Y`NsDb8Ex&m;AGobT@&80 zwi`;ig_mF=6v>xa*uq5VqH-J}Gf>=IIX^F|Wx8l;-l zA`$71L&>_;_`0mh^6r4dud}~P`K3_3 zh4kUox>v&~KqnJZ`7!Jj^q!M3KlF}cYwRdMvF?Me;?kliy`X4Rv{fY0LDLojA1&qU z1hd&TX@gz-2l@d~M#yv6{4f@a^;-93T#pxIVu>)pVT6$`(~CW^T_AA*dKi6T5iC>( zL1BO1_p*HMxF=_*Y_VR}_mkb&j-mqZX?rX#v(~z1&*rqw2_G1|(!(bWZI8c8y?VN_ z=4@*qHx**_lTEY;_8aqLbjA?Mna=YLgZeJY)aV9i|2m zULB%cmz0Vze4IFUfHIBHE>xETQh>D`XN_!@h&qore5Yz_dT56 zkBF5%Ez06LS_t0i{tf!r;oy8LngVKFz>hyROL_RQM=6OGRG_ETbG<7A{*&Nt(b&4? z!}JiqWgr7?l#oD8M{fcZ=e{vp2gg1Wh&8sqze-5Ap58fhB;~c(Dq7c}1RgBuED>Jx zN4An!0o%n8Gzn!h5;&vqBHuN9HI!!u|{9Pl5$~c8a#%?z*dPSTfJaD)pOxuyO%t^1trRzAlhe7EISU|tv?>S zm|qiLfD?#-zkgLh3@Pm4HFXK73uh`UUEB|jV;?uV=UUoL4%rbJG8H!;_yG5@^N40` zd5?d#>8u^N@jGm2a#VV5$XZD)uAmJ2Jz8fN_kxt+FsS`&2SfXO2i@3D4_3n8R@MJ1 zK)?{n-wEhCsLNsFa?v!cck;ieLpxne4PS0BWbShub#_B%qO@;>b?$(Ga##o+r7Rt? z$%4OuRg-kpV;z5^;`16NG8kv&B+s$r-H^K;u8BmOi48@c4`-z39crhaqiSfKf zv9_~F`?_&eAs^rD;F%&%!x{A>J9HXC^5FuM!i|cG$(!W|g+;W9p+H3!gG0ENFK%(g zcZS}WO*ji}9dGd)er5+5vBL;bn&&AvKI1cv1t}s$D*3^R6_xrs{l`efmoMiow%ab) zrOzgZrB~#(x*xEunjrcB(bR7Y)Z^^HxcK6U6lxQ|n5;uNF*2v1K+C@K39|0-ESLRfE|A_ilKD&cxGek!W{ULb|7BLSiJM=IE5i)MFAxQR9APh z*lpyEq)+SFi|}iqqLJUOk&uwg0nlJNu!};(uj9=4=&zdONXtGqDJ4t8cdg>{fE-Ql z-wslOnmtbz2u>pq^u1oq@t_SP0AAj?46oTW7V^-+4r=}ZXD83vV7n=~{uQQ-ewN`5 z$8J|-Y&iixr!8W%-Q)$anSB$<9+HU1eqn{leq!R>VJcL2VH5zg-_1)R5Y z0*0l$WF!Qt)*iJH52}=d`avkJLt&YU27I0(@ z%K?Vco5!|tsi%F;2NWK*gCF)=fBgIIejbs)O)%=-oOSQ$Z#}rHViteQfNnDE-z_!L zM4=2skq1(2$ytl)N44<%(xfRuk*6+91%=jAZd2GTPXz% z9trv2AWbDtzD_`FO zgy$xc$KF@8M!Bt&J7#wbX9rIepXVM87iHCRiGuh$!y*vRj_0<=P7iRn`f1lF(#GTm zk)(*^2mL>P{@nR;Pf=O|Wc&7bJRZJ(F`GSmoi1nS%1dr0Wt#wuT7%(v`5eul$jHdL zetjC<9xt)b%I@Q0Y*djd!W%0fYJbB6@ldU&@ZgJ(?b=7}1YR?jP2pG8?e@_rT@x*7 zGZz;lQ42oX zH8;pU;laP-?YW8g@3H`Xcs|c1bF!1=8|SP49sJPxIzB*DB8!{$Mix9Xv(<#>e7!C| zI&Bmvj|?6OBX|ADJ=|nM!or9j(yDg>g=-*@QZHY5B37~Yw{zZZxElVxnV+l&o0f;5 zB7eSz$x&e*^C{wYAlCF~4`uz{+cb#v4hrUh#uxPV3y0G7(yI%(IM7`u98GSPS^cKq zrj?f0J1WdLD4o#zoRj7`XMzG3ypdz5-1cnw*hSMT^^(A;VLsfV9ush8I^%_zmAQG( zd)Ji&ob2Tvzb7UpNz z&i{3E?eR>ne|(Z#8m9|&LO30DQYaH`%VpL{xvq}OuQsDPE*TSA%{5KPZy^rth-Ev) z<_O7UZJ1lN3PY~BB$Jl8#c1w+&wl&+yVvvmKF|C6dA`r*^M1cSBUXy4i>IbgnF>+y zq9T|uRr}MGuyOO|V|Q;{3NZuqk6uW#-^J@_I_s|{Ble)f+}Ch;Kk(d%&|iLQ?ZY2U z(!qZ=`7ZJ+`v3jD2X(XWM?fOD23SAk17{&Z?$|_a)mG9w+^l)C)8-#in?%G$eJ8td zVZp-Lt-WDr=xA%Z*$s*B-AA~?PeVp#EmF5{+g@-I+Q0DE^pD=7aTOk5PA{M2-8m*Vwnxj&cc^XqXK)@+NG z7w&jHp-)%_q+(+}3;ratfImRQ%Y#LZChoDZK5=4k78DOkf!&`0%A0yz;DixS>%c$t zBO;@5VlO0rn^)oT&%bH!@%8uD23hpwzjfGM(U36dtIXa>img?%K+qN2INZSVOddm} zrX-Xo_HSztcNAQYw1({0eN`4GW)$`+(JeF1+8z9hh$O$Wx6GaB)+4<2kKdI+cwF!5 zG;5|Mk$8bb(vh+u($vai*%f{Y;Lxh6oI8zjUrmswud+Q9%Wr(062G ztmu!#bWh{))b63Qs%v|?U1D@3Z%!RS4?p#gA(&ew#&tZeqO8l8nX0cvTUv!e`|_8n zsb}+6y>of0f9WPniVNn7>wiZgL47LziZ`^cXSY0ZvR&YxG{XCK83Nn{Ku zQZ@5|D@)F)?+2XvKh1m6QoR;)%_mmWbU~M!u{h7UsKltPG+g+*rm8;tYPy#n)ds-`H)-X`{wXI2H_yTOj9NS`Gc=5toZOl*V41&bf z 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 wPx?e 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 z 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 FV1l|q(gpwk literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_04-02.png b/.vaunt/badges/badge_04-02.png new file mode 100644 index 0000000000000000000000000000000000000000..5f00f0979da6d3c7bb3f39261fc9c4d693fa6242 GIT binary patch literal 170297 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%0A&J!jTw4;RwQ! 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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_04-03.png b/.vaunt/badges/badge_04-03.png new file mode 100644 index 0000000000000000000000000000000000000000..185b14db61888a3fe89751f86f8959a23868209a GIT binary patch literal 131450 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

  • fsdVZpy)US!_{kQq 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

    Ld+e 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 f9+@?{xB(uR0Hlrgh;2 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

    paX`%`}FD{osliyh0*q-mId1o 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�_fJLY)h#3Cz{Xr7w#l7FKEy8zG4a_ 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 z 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μ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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_05-03.png b/.vaunt/badges/badge_05-03.png new file mode 100644 index 0000000000000000000000000000000000000000..559ff5b4c70e5cf73585afac7274b9dfe292021c GIT binary patch literal 112041 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

    ;_Q22Uiax$9|7lmL>va{W| z9MWr9VdXZ8!=$VKN(sa39S7#T9yW&Q@TC7`k~9XTPt2jFTjx}&{;w}<;@}m#;!y4N zEW%VIJ;dj3;igUsQP|ypPYR_O?`AR2jOYctzMj-S`gBRPCv5tlL2U9VV|#-`mQilq zvXM^0xh)ev^RkQGHJ2~0rhLx((bsx!w{Rj>2=5#A>e?RKWo+59yFQDj$Pcu77PjV{L>N>6NVtRF?RQc0u~eM27s>z!pqeWh2{!S?oe+e0*Z2QL_*bp zqPl?_G|S*<=V${+IVfNg5gsTg9Qn6*to=cI1k~ksbGW@10s%-x6feviJs)OlLzq5H zH(xtn^RJZB!`YDsh-1QUVV+VYD7e`RgM zZ*3zWXve1x=72;g=&JwBaz+2F2mlZ+*fkjYpL>wvGW>=F=#hS=xqln#XBzM)bvL>e zAfPdD_EA`~lbIDcgw!jacltN`{~7v??&)OBLkUkE9_N*wvyMwsXSPmtAGZ&g4K?H* z@K7EqRW~y%K9N!M;nB}|>Wn1$z@#36J$-ZDJnd%f|yEFtt0s`|>M!4KvQa2T$Cct1}zbMx$Z z3Gzua$N00edu*TccLw2m~iwNhJsde9+B&jd}SXtFQgdRQIPZ7bi3t2%mWN zT_JWv&26jO8w)!jzkjl9N%%lse>GXM6W@ zsv}Rm0JiBjW;`T@z6l~*mx3zwW0Z|?3qjN<08u0Echn#*Y19vlTYZNc=RFvo9k=vv zS_5q)$Y!u~$~x5i9_L0s_E}c6jEZhQ zgf!2Yf!SbBi>#GL^vT!!u$82RsKpC1m#>{>2OR{IbQr!|t+jQ+qmH~$c8^(FgggtI zjJl7(_tBBk>&rR9<`4LM)>aR0)QC%#m6qE*cKkl)$6u@9=6;qrBZSEr<-n&`>Rtdf^sba)D1SQ8EnCM!Ti);&sKrwKW+d3DLx zQSzKwjH59JOn z{>f#9K>UOKx4EqFuOPw;LFCR_U|LZvjm)Bv^e}V}n1`R)YL?o!n;6an|Jc5FM%hUhc zF!c94y@+wqRi9P8BvHky!>#o0_{UHDWB=xHe#R-!p%uKlMYBA!uNNc{7LfblsavT~ z)~Y;5G4sBlZ_j25H6RGdt6g+vxzCN8W*KlLjU%rf3$|X~(Q0nFZHjn`xD-{AVWfiUGsQ&C;3!@nVC6escsa1@!pNQ z7S>Iu38Txa)Shj{jBRm}Fqw9QXmxPPJHgL1xjmwxN_M`_tX%2!`|Oz*lw)bq^*O4h zsU4K>3d_HLbBPccw41G*^CJEEWgadieci;)%TqTvZz)>zZSLv*2r^t~+ZMGu)|bEM zwPPphwOD*XC*6l`&^_lx5Rcp9#D+B@OLX3)xj~SkhhC?BCBJUo;IvyJL!|%x!53Nc z{!?Cy_WFiZNxh1i#DmU=L2WfZ{YE{?AkJ+6)2O}|sTq&B*yL~49#X1Cq_&0NP~Bzr zO?_Ol(EdgE$4(P9mYD1nmHWw0Kiyj9<14M_i|fBy=6N!tRAX>zlaH67aOh?gm5yJy zo=&-R7H`gy#~`E?Dax%(bFxvBpI0zbdi+`S~9S{6_-+k-&c> z@E-~MM*{zmz<(t09|`&kw-W>a3#9%YvH>o0FiDQc>wSIZsv z&gL(Fo-k~C&U;!}Q8iA>p6MJa=F7tIX|#C$09fJOson^P7wL~ zrzHk&w6~m;AHFa0lWRsX@jb@fj;6$@V$aFOU(Z1a-;4ZSyQUe46g{UgZ z>H9tW)b8lP*qeE9R8_w1CiEo|`WB*cCkdN^oF^{UHst|N|NV-^{1mIo`^%UC0!g7O@9&FI+T6Tylcpq|>P8%-2kVIS-+p`j4w+LxqAu|JzNgXBo`=~#gl#RKDM>T%g{HF#$%dFi7;Jn zbTQB@)#p^iCtx93DrlI)n|K}x@riRxICD3_-?iSMSD-nBz-srU?|dSQRPC6*?zsLE zjLK;&GU7U2d#hA`6Y>Q^lJ(^KEds;G8&1$F1_&D>PY2Q;(h>Sn+YU4pU}XTKP#2&i zcrXJU2A7yjPJ|pT)ycsvILzscI}?|fJ}F~`hs`~4?@v>mmTf|mhrQcC;U9zrLj*jG zu-+++jyqW>y}KZ(!IJ_{5{k;l+wMN8@cqMD#Rjm1^SykZr>YJPQ>C2F=a zYme0GNoi@{eo<3{n=RIy;avRM5qa(4dMrjz|A3%*f09U6rQxo?{mK_GqxZoS#?SH` zoSd?R^yy3+o%Dg^#|!;(nK3=6jBnpGd`7Z6^SWQ9g+8oVV35RiF{G`zdD<-OJsqcdi+eNTdJ2R=g}H*_Fj4nlWQQ&S%Xzo`x~%~bkKmp6=;H=JHqRa#2G z*oy&SB*g=AD)fNS2?ghPLy(0pqLP*&_nPYKr_x$0vQoib2(!zP$KbOl>p+$sZQ`t6 ze%iCG!W!WqR7U9BUTyf$KwC6L>D0}|1-sYtYd|}=Jj56s92}CKuk2YV3S%P?^rglh zVp=OqQqY~T$dO09Hd#_8U}+^}P1kpZZ?XIq4Omo$DBHup9&( z6N*eNER@qGJr#M~G6CIexh)&`yg5#*R(DL5Aj+}J7%TR=zC)5ZfsLrbfJ*%>)G zsoZYDx5_^^6;zUWugKh6CdbDfnVr2W3x#ydlco1Z%a>6MtWacsv~+WI&EfXDY}&~E z0EmEkG)wr5BFz2TvJ=i~pDl%;px`tAUACg4BCiD!I;^^h5Qfdw{7R`9gt3sYaM$+1 zrzV37=qVaj>?L$Wxzx3kMVbo3b5&Sj!opXB?dTo*xAsiOc$1ynb|d7Zge%Nyf5bXIJ_mO6^OgbihOWz5a`H= zF16H_7N*#T47UUXTE}}(qHJ+RT+arVAix~G+Le(W3wopCC8(gPvQn{W5>^aHd ziRg%oO|p;mxTYcAzIzu@RKy0(Yj;lsW}d9NL&R_w6axcW=NR3~S<#}YpO6J&PRC~{ z>%Z^BXurxB^Nxp)Zy9u!k(KoVOig%nT6=y3c##f`>$owjR!<&o3YrxL>`L zm19YKOmFnzw(yMJk7SfpXm~i2mY(jpw`p)UApve@hbs%WVoHdQFVW^4gF?6c(eO*R8*2H(`k)MUgq*m&2n7NLYI>F+I+a1OUe)XcFGORcTx8U0|(EE!fbMKa#C=}sv8P`M@uW3$eOT>c{5U{)`^xN9Rovm zDwoldU?o{swh9t&hRx`F-Vo5ilaK>>&XmV<#R>UEruKzdtRTJF&f%uckVlYA%Pm4A(4yOueTL;gxFBk|rnYZOW!IUyog zTi~W(?rJHV&+7&@4?9v$NNCpiV_6vG99>vC=s}4v_w__eD(In1czAEQWQ3|BP7$+M zEAQ3%I>(E}>iT)&qy}4sxtNxj=T7oDk2u5_NgdzPWfc{$b7gH#zRSV(K#dk@q{NU` zH&ohU1xGqo zN2|jS#`pD(DRUjq!$A*N=pGObVr`{QKo>*%A3w4xDJ%1fh}fmxL0Ff6L4Zyi(49b9)fs_tU6T?Qk4sLzF#F82Taloy zw!lKHf@JSFR^kSN{pnl!eYP^ijQ-_bNZZ)loU}EEf~hwb!}``OyX;9sZ>FXx;p>&( zuk2xX-+8p)(`wM=#xk&yeI3i=X>03yw;0Rf+VJO^h(>>NpNFOOj~_p#yLhqB6UAj9 zGDcL~Q1Cn?UsGo~WdGGGrNf}-UR`GTbjHp}0mm9q` zS+)E!jxsI6jF(|^(=j_c8<}>D0+Ghe4L2$D9G@khgD{HxiS9Mlls>8T*Si+R#&T>a z$&I5MLXX~-knCZ;H1D;#K)b?Q|b8)O=_4>_9kmI*sTq>IG4a(V7}9y7<~`K%~z)G?a|-9c|s;2 z6HhmBHo>$%fBx*??5qHzQ#3Wr#&+k*H+$oGd87isNdrw9;>$jFwF!t0^$jpd9mEmjJ@^B)JE$KN;F z#27Y>{d`fV{NiFfFy4I}3r!B%z=tL&t$qoqF)b!$QcUR!&#SAG@cirMx2QKE3kN5Q zyGJ{AxpgC6%vc_%{xqJ(28&p*oILb$Ajo?zUK^L#Bczg59EzqLw71vSWjUzsLqCj+ zXzQT6wn%A}GIK5ATBeA@rlFw$*rU*$VRPCw2EMR+1TL>!G9K!S?xtJb91QDwh2&wB zx3ZzHoHDe4atw;jzuc*2N!U>_|fwI!5Mql$aXeg|7R2Vyooo9NAK^+ zT)&-`RJjgHT=Ylteq>uxrJNyyya@o^X zAhT8$xV*z48Q{IOsSNJf9fsn0)E5``<{~O%5LoSv-jHcFA4juh0~jd!^#Y|rJo9f) z+Qird2mlKU3kVAg9J{!@d1+NCdv;|J05hqegD>U-!^6u%Ig+<~mkpv@=C@-7@vaZQ+%920gS{{^budAbsBL6Ct2;4Eb{2M~= ztfEB^v4y<=o`V?6o4bhx+UvKvq8d2?%4{fx)*2o)eUz*SYo2PWTx+)|bHdmxls6j- z2p3Os^%9lPdnnark9ZKS1G%mkR>!j%yc}d^+@g%lz_k zMtoNagfv#3rIp}$j4cou3UY_dCm)qD-yTQ{HlOXwhjvrzZ+A=SwcTA@>amv|O;8T3 z&`4;Xj8y2K0b3Jwo9zV4S^D-2wOtVv;O@@H!6{jK4~nl+sC&!IY)tBvQwdg5*5b{~ z2TE5o=!{DesidY1Z-AkEP{hB6>Nr0;xhmOC{a8&d*w2p+Y)sMdOCrbiE=I`e>Zy`udc6;vK1)x&-DWOP;hK26mq?BN*PnYc1=gQz_tbLno8 zDVa82m^xeJ#)f0ikG;uv+G2Iu_Qo{XqV7sCx(86+*Z{Vat`{#b{caS@4vbX&B1Qt$4w$tRR60UmBjMnrm!P zubOCl+3}E;YtlW6?S`XA11iodMm)6q4N6D+2&6?_Rxq+9Cv8g;lQ-GD&ndKNjgX_e zQM3s1)kkhnBJaSNDb7ByHWXE7zqava{ZycUw6wW57_CrNnvQsBq(A{t^J>Lp7=~B> zOS9ds?$B23_owr9ukD6E;s8J~0$~g+30%N-$d{bn_u1;2gruz<-H``2_H6Epl$M_k z8=RMuc%cvg+9O5E ztB{UNUO`n1<-zG-#8)tMNCK1!TCmc4=XJc2+)2M0FEK`-eeceRSg<3YD%xr3ma|oDY@Qu6ji+>S zYj8A>J!0NQfKhw-m=-hUsNx z)Af)%LZ8!M=iv|Q+?}?SujD7$JB;R+`Mvq8fWV-<_*6BCvU&qGAmK(+-;3DPm0UKi+X5nCp zE!pb{5@!ICHH+)m@=d>-_7pfeY3DtB_;O(2t{YPW1nu!q62k2ZE5k8yKqn3k-Vb>p z?ti8-V!}y|K1yt$$cXlr7Ok1Yd>x)Zfb^eH<4Wm+=4jp=ExUuDz!XJm%mEqzo+bHIok8|;k-Bi_Ab{iqLbqI}uwW zLIsR6N?x1RT*fYGMY_5+l+&H<{@ggAl=Eru$^PO(SEMk8S7(ek1b|h=$8Ya%)!dgg zdQXZQ`SmCWP#oemJs{=->$zu_sg9e@YyP6ad2*9G&OQ6ki~WE;E0?I1L*n;p5?x}8hu1?bHt9?8O5!J4PA^_#%@Kk_l$+e<0v=hhH3|XGEp#b*hz{8)Hn3IE zF}vcm2;AsYtFL=Q{C#$Y)uY8dyMitAy2-5@%F1{qrly4(>fxL6<{uO*yon)Ztv)2n z%gZXoqu%H|L`ZremGe8VS^RllqwD*73~xpZb6xUjs~%V5ukMLF4+4Qs>-rDW;P;e% zM7NoAVgfems1fvRWJEhNGsF7Kh-g#k1tdwc_}falCC&Gks;edOltdfS*8_B4f^1D! zWF&r6=N9&^Ua{t4Mbn4ce3ccW3X!V#T6krSvKS+8tzmMCdpm~t^EtqlR95oVH#ObV z%bwsI3wIGbO}7k*Q(@Je)D|T`0x}~Wke#~{gz;7ud_(R_u=+?mGQ(DmEYMY+ayyAB z7v9Lq`?GaOMRB26}#cot(8}Ve}@(e^JUMzudjmjMwEu+eOnxmuq5FnoN~K zV>UH(0CvR!q}mc55C@}O4y^^sy4*tGstT0MOc{P*V5=*oJuTcOoFdp6Hgg z(KZCF2M;v+7L0Xw9MmU5=bnGhh$Q z{$}kE^HV=5CSqb@E0ELz&nAqwcZ)mb?OPpgZtjmO#$><6N&>(K{8BVdn!hyh&2qf* zATKWpV227ER4+zGl1Pw|{$(uV1<)4Kbg!Gp2dp=&As4RFF(w;hrAY zu%`_ndz<5JEN%_h-Vkxh5h?;Czh$dddzef9))t2d{($owCmP>wj282YixbG#j)pxy zT#6SNAX#N`_rfb%o+GiP8o8Di`XQz{ zyxs|ooP-N1)zej2$rF1)u16l<<3zZ=W}R)%&{xU_-IXX5Hd0Py&DF$ zSkjitH5gVF<#p|VXj_aVlS#4@8O6*f={U;nkb}|H!!4js$3OCtO;P}IPafa8h7MeY zhK5OMg-)33*3T*`NE8$l?)O-@mK2XVnzi{|0KTJ)sDu`5$QO3gCO7FyQx*nwkrAXf zT^Mil)}>XD-6-EY3_>fbbTnhkdr> z2}&18V{2MkOuX~s(K<{_LQ+sySGTE+R~sT}V`CFDVOB*mb~CEE1E|P`b(!1wwRAte_eD)QuG_j4m{^Pv$;r7{=Z4kR%GPa`Z?d?g(Ov}AX z;+b>TF2pHS{*j@PfCSsSWn=wZI~GWRYgUU%y@V|VeHGHI7JpQV`$0;E}5 z+MNpAksfqtssYGbEN7^8LW`vkNU#NUt(d@KO9~)>6c{aa5yz%1Ko&8vEhH!?wiVSD z6YNGRz$T@u9@xyd(Swvu9MYf6!#g*ED zf6(0A-1hcDDy9SrHe)Z`!-G6BG7>PW29Xkw*%ogi5YOH{B(s>UWE+bIv5XcM1|Yz7 z#}fI8QW1%f$k!&Tt@RXRf&-CV(2(zsna87O0|hc)PS@Fg1B*<@h8;CYoel^NTX}d? zTjerbSd|S)k*t1Rz#F4iN(Crueo4uA#mhQ6`SI|);n=xWUz^^0mkgoSWP*doPX%=W}X(7yALs~?vW;t933TGqY6nr#Xw&*Vm6tO-&s( z+OcivGt~6`;6Sn6D>cdhL96ZS3nGJUz7Fp#nzOBrGa^7eh4~;6HL@w8@o+%Rfel|? zjAaHXcs0C|qS0w8>+R}%Kz}F#fupCV_bm9N(at<=`8mqldl6(%icpZhhTP?(h+7!d zx^7^8&tMjm@LH3ZDRB1BpHx+CKU;ir3vb3j_Bv!CxI*QMw@y4!#n=m~N+5&nwq4Rn z^H#fcgagh9RybsTdp^%Jep@Xe&h-;D0=k!eNW(F>6oaF`NUqPKw>hPL#uJPF&T_KN=4R^Y@|Z*48TV; zN3gdwnXFmdPY9HBX66oiUJ!+=t1I=-lp4e>XPV6$FBorS`xSu!74GWHbI4BaIaC>C zkdcusgQ#F2843)rb^CdITwENZb~@3zT9Oe%S_A&BpVYnS>FKsZz@0b}*V0Xnjj<*q z;%<_)q`tnM(q{!iE+r+UE|GF`UV(JrzSaEmVCq58V+6s2dv&0hQqA4jU zS!<<2W7qBo%$`zxY2MsAR28TWg@$#Kvc@i!BK!f)zCJ@ z`7R3$11O4myxxKjmY18W1e_>v-XN}3x3t{xlOmNPSBpUL!$gt98l#{F2`*3?b8vT8 z1{^-9?u6|T06YtH1|Yt0z#rW7)~&SfTl7H7^6-`Da~;o;dEiqmLyihp{mTgUE?e<# z+5<9#FSG2n#ApECv5tdZJwy8!Bgv&@}GAryqs z_p-tK-UZ;c6j45W>m0J2APSQ(VR%k8Zn6LU({vs1oljXjfNEd(NE)j!Q=C>g0ha+1 zko5hs04lHO>^ln(EQzp5wJpHb9h|%c&iDCq8342=rNK7I12Ioc(E$eQ4K7N)c1|;N z&nOh3dNk+&s&+tFS3!ELp)dy>2p48=*5=S>;PZ)Zun1>T^yx}vLPWjYk_I&Chkz}f z_;`bdW#X@-Qq>keH_gBL{=J^Fz5=sl%AO7%n>*aArk6VV09e;IkmADw0_e-j%l#cw zXH;N-^?z0cs+|BDtZ!`r)LCW<2>599{AZhy;s+np@~`iW>CrJV);~S9ql#1XSRKgB z3YP$R^ytg1u;vm5NQ`{JNDK15X_YK<_#L#ADhlIl$_RD=L)NxCBzfOHR6Oj0z>G+wSSPfd)sQvY{x(mi0q7zx;KvJ1u?wt`o^7cR$TT9nA+ySt)=44J%bE!KzTsXU6(U z_9jQEsxB?27^snD&^H{J^HU_`b$F_QtgjfO-+Do8wf%4|AT@5eS~kE#ejIzFC*%8N z7F1&Tu=M9TAL2fdzWa#|aw}UcJ6|?;$1fKW!Og=m9SnimE`PVGY@7$m4XFHQfR}tb zIca31o!Db7=KF=w?L%9pZ-QOk9I&X4!}yM{{uR!fM}s93`CmN52rVKFPiM|TKW%J? z+m%r`nQf7*K;J#e);%yW8-F z;PHr~mHu?kZ%a1@1_xI*J359#@j-Pn3W|R}B@>GOj@us;S5o?9$+2w(E`F6F z%Uxr^m)E>Ct7)eTRSbiY+hQ|eF3RD{#e9WAus3sy+vyh?_PO|S!ou(|JF9N&K=5S+ zF!A|RuH)8khQa9o>b3^(=wLoH)ErHwqt6w5-xvkjeeL+@$J@k^sK&;|+O(hhp;@d~ z_Y?o64G!DmRPJA3;XOAzA(!8I?r+;c(C))0C%Z13F{(eYG#S~f7JU0i zMU7Gx3cZN=6`S>nEE7*`AV{Zi@$kMaM3PNNje#m$rCD=CO-)VUr0ds^K(W-Li z0azZvrjW)>(t59pQQ}G7_lfqte}5W(_I(fg`vs2U!9g?A3cq?IqE!&T55IPk85FxW zV6KB)V5-hO@ypURP>ROc1zI0;`mGlo-|MxbDQ2Bcp2mo?U<2gow-Am8{O8rA_^)Z9 z51>Z!=8l9O6GOl`NvlfEf(<~5 z+*~F`DL-56t|3=w@KzlY|w@ z)==RqAQr2V3@_bTNZ*h5&?1`NZukL;<7C%QVIVuhN$gFL_D+xkss?KLsxgrhbpxJ^ zxuIwNH%|sZ4N3gos9AxAdU0XHvtI=}J!p-rN%A6hAI1V9&iCS)DP|AZ$4s1lSTH(&> z`M#eN;JUJoAf4e@c;v*m$gJs9xOD$)iGf8)sX58!o4^Vq(KppkggYtI-h}Ak!Yd8! zH-tOcaX|f&4i~T%U0soQHK4AY71c6DUte9Fe|#zh94cDR+wN{%+64BZb|oF)3yEjo ztlb5$5}PvL{IvwI6VeS!*hV}V9l(j|Qs$@1u8EP(pY1mlrt4O8p4JV^bVn1>R@c^E z9*?AkX%&wGQt937rjz%T5JBQd5K&HpIBc^^9Ie){BG;$udmbQoCAu?lTJT*SYkUfr zWIH#UNUfv`gF)cek{Z%RBVb0zca)GP*wD;|1yHiC2|REEWOmbPKB=wgE0Bt&BT3Ls z37|*IMuAHE5<%jWx~ZgRmNz*)MIprCxL%>#$>`Rlb#};U+%x#TiBlIrB|Qw3CSJUL zefwju^VN~Sz`$=WDYZThd^gm{=(Xm5D2~KU=d&EjuBZTFzwaDfZro_Hf(zyG!X$)J zLDJrMa<^8wOCARv-*Ix9+!Ez`CBY{-kopMn0uvJt|1LpB|7f_%k1r|&9&a^+mKo+d zZ4#x^1aVw>WP=?YRlO8l-P~T~oo(cqWSuKTO7z#>Uu#v(h(A8yF>PcN@%|?KBmnpL zCghCSv-^{G+unpJC^SE`a;`M1QRICTU<>>WD}ZK8_x1C{n7fH$YJ@*s&T#2CoO?TS&m2qg zYNC&LC(&Md_BRL7Er`*2F2`1-txi}cCZ;lUgw3jQO5^b9_|TJUQuWSsCkNZgAjKM# zmCn&z29bEG(Uk!tPu#;Dy4vXDO0~Ul1t7=g!Mm%2eAz9B;NJ;i zN=Lcq1!7s9t#}^oAWlL4QNC9wP^!jPF95*FXt5RpX7j~-aB^+|aF^g%LZ!q&Pk}Eu z-IZ0%kA?IZ}?Yo!1eS84$*Np_%4{iRh$D$|0GC-nk&`NCQP28D>)zdBo_igv^)Gx@XH(-{`Rnc{oCu4cQd33^>iOfDw} zmD1)JG1te}!yc>|25S<8cP|fUwc_R$z7|-eUAv&gwty0o!+tb#y|VswD$TPA9~K9O z_FT1YMu;qnb7}k<5AG_YQ}>oy)VIF1VwgVy6H5|TXmWM}E7I^Gwf}?r=ivNCq3|`o z+}^^Q>D7*-Y~TdZ=uvh!`t*$yld=%~xOAdPuG6FNtP zNYpwr+I9aKNW6g4fB?2>TuOMi?fdli`~DYCXBie% z_lEnSJ4L!h1*E%6KtX8`L^`B%q`Otppj%o>L8QB3=4Wv8ogkvalQ0hg;&hXI6knR)7F{Hced#@5adHVF#;0vRrd(+@_#tM{M#h8d# zsY~qUyPE@EY3a$`fVWlb8%>+@g*TCj)VX9jg| z39awuUl)oV70K2om=aoCjdm7Ul?IDKuo-J=J!u%yZ_wogLV%)E_h&q3gw@CosiTvG z)&e>o0KLQsS9ICF0*w(Jcp66y@bxd^$22#*jP#RBheZWe&oEJg0wz`Tp8tG$U*v9p zs{v4m|52pzOD*p=&+i4kEwz9Yeg#ue%ZIQaAMPeB247+|iKEc*4kMeS0B{DLBg+G# zfeg7GKY$Hm`;6M{0_Zq0g`!{s$4=_sJym^WZ^&y|Q-TYa#9O22VV#D*EodDJXz&$M zslUGed$80)6mQ!`OBUyji(x8NbA$3nxY|^d`pr$VZks`q8l<%Y#v*ljV*Ww!PflK` zU^TWNJ`zB_KrlxGAb|Hzvhn)5Iv!zRU7bQJzT}4Z8GO*v+j$eAqduy`8vnSR*XxJf zQftjO2Yz&b&XP0(C}*Es$*p>wg(=eNV05M=ViFICjh)D-3J zh~X~iC5suZ05gn@UHp5PY0{5;ML|@#^^17RBLUBqlbV)apKXi@S`4CyJg=<@1QN$# zj;G$XxbU9S^nx@h!z8Dz*{J68+dF1a(u`(rl!Bp5Sqs6GZOZ#@Mctbbn1Epu- zbrWU?9{_qd1zf!Y6*yJdkg`DY3uY2uU^R^r7266l1FyGy>e=4ZH$`7VfySxGuv;Of zTvlp-@L=5cixca-dCk}T%_WpD>GNeYt-Il{f6gL@Kq>?U7LAPMfBQqX^exFj^Ig*) z>nPSoJO!+{^s!iu)ieSssei3YgKNu2h^m*+Qt~5#H#ba1P(Eh*tkrD1*5h*XN7@ z$z|G$m^W1>MR!NB0Ugma!pCI_YVp7BsV-n*@d^s+9E$Z>7DXO~>A!RX*9 zVVlTl90tp;CCv)Mf)W|O6KH=!=X(P2uJ_iqn#Q}N{#9B}RN6`o;}~R4SE2~5^<5fo z<4n6<)v~wUlzBDRXzKU_Xb&DseiZk0M?Lu?upEIZ3DmBim~OJf0#{>rhIk4ZbR*V( z;Histbel|aJuZ-0$IsNvq05QQ*OodFg*vXDvqf43ziMi%-}=+h(Rpqc6|fMED7X3o zGr9Q|Sq?DA1T+?nFq3`vdO#r;&NeuXe}WZ0N;{snb#|^v7hM|&S~XFXS@!U19Vy{z zi9WgMKYP}1{0f2v$#}rXgO2(<4vsE!I;bw~b%tTf*`?sUG=Ynq-*HbDEggNHPQdZHwvh8%_$G`Qs+ z?B;q_mi;mbO{TJ(M4mBaZEzy6w2D(Yc7}mHK2SV6@J}k%5b0qQB;!dP*gWq}JBXH{ zJ_KrCc08_z=N8c@HrmWSkTkSx{44M%?f=B1nsEV9F+i)U6V@Tv26CO}LF1WrzxA8= zKyN#{XZKuOYDQ;#%~eh6 zm=EzWkJ|9KwL5ZdKz#+U_I%5Wg@C)8dn%psi%F zM+|;-e0)()O^YE5Q5XaF(?pa|A`^uK_bfHiES*+lV^&V^am#$K*z(FeM!#VcTG|MM ziuaUF9yUhqJeAh-v8Gxd>HPx+o&Coc;3iCk~!K%o+z~<|9ZfHVJNv;7Gh5z*$!^S|DHeqy3j6N>n zUXlg<=fkktQFh&Yt&Hc_?6YK*+|&H&vTJQ8O8_qIVwbe;zC)vY;w5PgvvU zc({enw{`tqU(m%)h8qJ^z(7=xim1*_2$SO^)J$TY$unRpV#FvPQ_eGNU`wi}RlQzr z8G{7b^4I&qrAw_)(6MW7tdZ4>8On?a+E}@>eg>bp&Huq7tXHXj*+8rRG?S`ZQDWZv zoPel=Te9k`hXZjARI6R-;vOs;I*o|$XaGL=&bI<<1-X%c)2o|_bZG+xL7WeeJG7Q+ z7%k&%NOV+`c2&{Mj8$go#|QJ%(@A+eOU(h&mseNMFcH9yeehIuxu3fk7UIE_1mJ2Q zw*y^#n~O=mKm(PZv!b19xCi5#7K)bd98l%E(`}YD0?=wd)Dja@WL;=W-L4w&Y6u+#9*Z@^YdP z>v7FOr@6lbQkg>^E}~@s<vE4RZB#4%JBdO z_?~BjLMuR6eo-L3fp8CrB(NX?0s@R=xIvaP!Tq25jF-bMdr(?dKD1O$mXwuflv0TH|JEa**_rIk z<+GC}EtE(?*w7avNOITMhVjv6TMILYdSae$u)aZHDKYIBR5jT^q=e==N{=N-eC*j4&4-GZ3jVu>hF<^KBIK08of?YuQ>3F91iPK#L@)5&ES&_F;r;$^Q%{x!rH#0^ zVt}snFsN39c5k-IZq`}DfP!hJ>3DI`2$*1nr;$GiUa_D2NZ@dd37I=UseUhuCwKcb ztMTLb3)zlfvgOB0y=An;0jpavaXMV&PP9gFJQ!W_DoCJKx1+qB~*!{spwk2 zVzWq{j&3m^!ypbvjb|qs!AJ?T8ZR{wOo~*_*GhVq(p~lLK@Goj^!{X7nv`3qBl#mk zelk|{bd=#NlA(^r1){a%wrhRq0vZ9H1}nzGi_ouR}J-ebVC*nz?#Ups_{xv(K;1FWh5XDAs#Wyp-to2-&ZAaiPCo3qXPb`!-S@_x-vs zf_w8M9z0^y`&1tM!}@XV&lxvV-DE>Z}_C{A17&;n4g;3hWvCJ~}*P_`Oss)IYMdYzg$Hey# zg8>NL6WW#Ucf(Ir(|Wupzq3Cb2XNoffRlfv{RP@gQwC5VSq`vX@%~S}0^9C=a~yEq z&d`ErFinb7l>%K029x8TTEjm*bc9%xF({oQGfym%B1B2BnGyZO=c^y{J(j>fbEX~` z;_zYOS9H}K-MT)8;q;!SKHx6ZCpS!rJi^Bii%-n8$P-0DE%oGj-C{7VZ2$1xR6-hO zm#F3i$(dHx@bX~@G2`IV52jqCzYs2a1Kl+PsB83DLtvf&<@vsj0E>n8F)N z7(DCbk?S1nS~jo1K1&W$dt8=J`wtKvp>f240fI?FRz4sm^ytwejM!&bTCUD3&awbEc?JDPYaDRB6P4Mu01j{p!^EX_>uNy{4iGAtVdJ zj;2ojx8VWqOY!sh9WGRG`sVW6;M>oXU8N-jHC8{D%AA=Co)YMcVV>okve`~Y2uxD&cBh#GU5B2r+HG}p4 zbBM8Eu}j^HPWbD~3!<+tSq@L{3Ca7l?zaFiZaBkId2YUe{PW= zk6a139lHAjJRmI|Cnu+FG$IK`f)^lWAWAIEH)wFXN`BSVv2N6=IWv?3);yJ(*~%d8 zR~MvPeren^emMqT&_6X_bM${^QlTZt^x|twL42r7vwwAt%~2Gj6*UPhuzQ^s!{s+u z6^9#;Sk!67=t>WHGaA6`#R+|?<}~{5rMsm&y5bQXw)Et?QnS^2*PBk#6qrX!Wk@nDRnW+Yv7~5UdBbK_HUTO*Piw7H!Ks zoiVk=NS&Ra4+jcbYDVz_d!h8r$(W_F?B4c7aYAXD5b(%Jl7I?C(|q2^9ru#ub?bH0 z)&95eK{nH}sqwNCGjiiD{PusZ4e{Iu#EidDB|Tlm;TYmz;;ZHuAl2o*iZ{7-QM|3oQZtX-4p4 zJ?yovo3l%bw#MsN=LlxuRI~``f z^>{(??WCfn#xM-7vT$1_BFI?CmZT`(RO3AXrqAvjk8*9JI;z}!gqhwOP2 z3y#8gIykTZJb|e2rPl(#J&+*t&|Oc@x3_&zX#t+l$*zQ8 z@DbrM=JXBGBCl;7D1Jh@_Y}pa&=rrAb&7Q%dP?1g(*74}A~#2DMb}7lsExF!BjNZ%v0-}rwlK=Wz@S|s6L49D4c z4^G!l>jT8}cS`{`qyfHXv7@)3BLJ52{D6iA@b!1fn`1mBjK~WC7!k5o^Havq0mnAP zeB1+YEoX&}ZG6SHsxBUh_CMKTLijDIM>+|mt`X=#|BY=cK_0ytT zB))!v$INoxFsSVgDdUzIdW=p+Adzb2Def5s$} z;lcG}ocp$toklDZ$9xg<&30W<+KZ&}o5ydT^X#;nb=U866_$~Y@#;Qi9IRdqE58tR zIU=j#>UI_HJCXoGFI&|K6#(T{K>x5Nm08Z-KK*lR{q_uUEB{RM!1A)#_y+e=s36i3 za~nu<_qrgbXn8_cR~J4vM~?0bNlD4+TBy~G>22!LH73CP`XUn(HEf2SUH|%8&K^=rt3zozQ?)Z|*geW$^e}j`y;Vhkk^_ycu|9YG89nv__?O|1KuaZHt z|H9!b`F=A1ZQg@KeYgm)v0m?cG=F=a!-on@usqt#iEUeVWr|l`KS?goETXj%$(tyf ziscG0t>nP#8Xyn#5=(Bg^~5NWXWzJtH!W7sAfu$f3O8>NNlI(-(<#dI}8ZrR73)CkHK}zwMCpG+>D2Ao`%{QB}_H*;)muTD-q_Ql3Q8WAT zsI`rBqo{{Foyp--$7KujgYCwHs!BV^-JEd) zqT`1ptSC0@8b8s64Z=?feXf>cR-MfHXq9D@IPzm3w;9!nqx9~o2Y z&~uCRvB#2(^;e?>L9YFq;etCYQm-|%3&G-A1xs%t;+FJtpclZ30PWPTnI+fU(ZOWA zJ_^i^|K#Zc0BY2G9B_%l0+7YV$-%Wt2i?Gy1Zh@8$*~;$o?_Zc2ZbYFJWMv86fObO zOQxvxna4I9UbUu!B6=b>T%IX@hkvn_4JtbZ+6?9kFiER?FfbWuflAOQ@Dk0O4OaS< z9(F^|@Yi8~$`>;&?SV=YBjsnVY4050H)Y(5?@HCZ_Vu2`l;>!H(qe$&#p>Vf#&=in zmLJi!=vYDrB6--@UHb-Y($~9pZMGkD&KAipWldQIHxMfT*Z>SPt4?{-rR`!5dF8t9 zH!v-sVKLroJH7j}6cRju4QCOBs2PU@J$z-WKSe-uBBt9oEysPI`t47doyc|j*0(nS z#s)aA_r-rjtcVcCN}eVOh{}nYatVb{g<12U;~g6>EKv5DAJMix4@FgyK^f&ZFjbGH&0`Q-5rX0mV2z+{F^n{r2`EFN3ZtIB77N)lLmvs_dDH$(FXe5=@vhmR zYk@xTv$|VD!kQ4H^I7U;2b>lv=MXoSeA7}IBGe#eVwsjPRL=y)HI^Pv$l|M@8a8ZI zTsilfMA~>fxI`*v#Idj9WA$yjzQ`+YF(I0i*Dq(%jCyh;2R5n)=j%@m1_}~*Qw`A7 zJjZw_6hh?i9){vwO#Yhnd;5}OqRV>ZCSEqZ=?6iEIeEV&& zJ$-L(0Bk_Up_R6$OshP!CMC?MFmt}=)w^4@G$ku=yIZXIep-%uUr;~XFCfT$O ztslV~+=C1Z*L@rRjtYe=i=x<25G^XTKv~3V@!Yth$!Ys7lkv!8XL}!Q4KlXlFg|G= zEUxK^+^``OYF+z4<4uoWy<8GzSn?_b`^niXLIGR$yK(0SS9&ET%S|fHVsUD+lp;*e zBA?1v+Y5=E9j={OP0$V1d2sFQx=yNq*8MFoP!g|x<|zRvfH7EQnmR?q?}xlAut?zf zWVcnlPiJ??X3*N_Ic81=@h2c!t!q_pfBM0CPrrjqj-@0~e+4*ro&pssa?l)nBOr8v zsqO=K%4L901B4SJbuM1zK%Y?6mN@Zljr!(=ZowO+q!W<+sES`yVF53 zjOs3h`zzY9Tp`g@u*3ryn93XQ<@`4kbNI_ylA)_}l*Du3nM$KRAdxWmN6B&!f4y4L`)^?q1DOhSd8>-|fbAp`(P zFk-bv)H%qnD9Weak;I-U$2%_6@B_;`|W0!3>SASU&-Ui-qyLzkm6Q? zaC4}MZM(tSn0Y@`g*a1m3q2Gv6xLx;!#(gvG?n%Jo_B0ZI_Pzal|y0R&V*^9+N(!2voHm@i}LDJZ0nq6jW}c03w$_(RCyGRadM5w;hL zwEK$d`Ds1GQr()m;@ojzms^#YtG^@q@Z8F$@BkwKB+?(0k|)E@@9RS7BtMdyn;4SR7w4@6m(V{#?9UdwWHJpZ!zV2Zod`D8Wh{xuA@OxvR53A zUom3+`_(_hEet|HBX%T@hdan%>s#o|CQNmq?;<@Iu_Yu3iLy{!9`_)9IrVrB`ROgN zV{@~tgLU^Tn|1$+d|htcI4Ms3g6&pyu@t}2Oq1UJ?_7Q+y9rPeuT@lvR2zS42Lwpp z?hf7J1DH4gxv>+Lnv&uSx*!Sjf_Zf{fM8iObK3COc)GbEGy5I#blc?ad>~7LcnC0< z#`pGOBYgB74pLdHjf&(yFC!e3aM#x$jn56zEB%-V;7257q)L+E0vp22(z25WrT{W9 zJox54Idl+O`lo49!jxEe5py^R=3kWm5k1x{#U^kcLO2d1R{GYvAGUp5OX(4dv1G+&!=lpTvNQBM(*xQSCCeE1NqOqyFbM6bXMm68Vj z6R77Am$mqGPAIVTK5PkcvsX#)-a-hdxh9L|#vRf32~$EM-5HfMmrd>I-Q}=DtE7e3 zVUfbjkH?YwI|F&*hY0!;ycLFwp}!?G1a~Z|7O6s;WQ5+8$~a zsoyQ0HR+BXy?KRW0MaL!L%QTiu^@E@qTXId#}%xmx1cowqnen(h?L~la>VGsXnkd_ zfQ(5zcz})qXm>FA;*-4Ggjj(nroi)!yO$7@_TPsB=f{KD58-LF)Z!`2INq`&-wB{- z|Nm>?g{|9=Zrx=z3ddHg)g6d8S2g%;on0b>F@qd;(OU?}T2#I&SXY{BjapN!i)6fp zCHGpaiuSV5Tb00)JsZ*=#8yX1X3&a$F@KjG`!vD+(^n2Q7KN}#Y<0$$934%>3)9|y z3rPtuL(|bNJ0assuQL47hghk!U#L_0$4(qJP za}H>`*Ij4DT4MsNpUv>c?1WMar*;b86nE*lNwIK${n$n_IF9~QDItrUT|fsB8qccq zGS(`N_7x2x_l^^G_r7I5t(^4X&H$-xy4b2FEUBiGXdk|oG=>hr>0rcV*8lSW8_MPI zA?~4OnFApy3aX|Vt;+0QJ*BD=FVpqC{|&)>Zo82NNcqPAHZh zGqM4HW5q%$%Rz3gm99(*f@i-614K7p<&lypxP+3q`Fttp()@+Rw(_;-$(Pi@M=2j` zLoS?5_h%LD#OGrl+TMwyLlNGFHp|L3^pQv%>y9mnty2k4Np2e!9=3n>kG2}iAEGGG z+^D@`m+J^k;%^)Cro)1W$+tR5pIsH|*v3GAXGTnkVy!FWX!vexWwvcd-+6(Eu-7K? zEXB$QxVz0H8+l-|4SBA_=VIw#V4ti2 zwV=s9rke(tY!SWp?~y(CWA87KUqd~`OqCLI`1s4M+z^*bZS(p@d0Dt9)b`mr1ciDO zb!EY2>@rFiefHUp^XiRsgX%EH1&3oWSr=Cf7RnUL*Bb_V>AdYvE1pg46tYhq7MVhv z%7mZD`=kgusDHvG0nbNvjFv9Vxo-2>Gr#A&uZ_ggh0iNKJNlj>k4>>N}>;tmXKu+qgKvxR{%K9yW`HYw4KgRH3OV zYnDcqN{|prsU7|@XWOXAv>+}qCEf(<9L1zSe_b2-ER#%RMOXmi2kd?=90&^W^5+JP z*7*iCozk4VsxM?~3wAa>*;n+5nlFjJkR^$xwQLQwDuf0$EK4`AMfIT4EG=dY66tfH zPDj{kIjqcvogI#wtDRal(JL&b|CCPbUjdz`I$38`+MIjR+WB72Pj-+`+o?H$oZ5rM zz68RIul&O}87rEcj7$?A?xT@abL83n@Onz3bJ^NY=!DRx(`Bh7}yR z>x2PXf<;=<|LWEMtb_p}xfo?K^&!*!2UM&?i;!-5P-5DS!#*fQEC{9UFWc!U#+ z?Nm7akn_?}y?FgG+`DYIo0!Q&vnMBteOt_WFCZ~3&cz`>`YZW2>ro-w+!Y)s*Hfp= z)>qsOp|N)z-E;?1h`&>ptjGKEHx(S__k=45WJ#X6%$+`Ke@N;hrB?9$hXL0WJDcN= zjXP+Rj245~Fop|>cHlt=-DBy^Z|5K26*tYd*^ zK8dIfGWpJ9tU2jiZ3#~8srk|*{d;!sMO05*+yg#8qIZa|N^G%0dwQrt)24&#wNtmK;vTy#F$>}c zY@0E4{`4VDGxm$Th0w5QyDiC+qPtx{5J_i(Su)$XoX>@8wUncI%IPo4wt&k1gEzJ; zHLC6UR!bVGHT}nCOa@u^>E}-oze@oqeAJlC*YzvVOhImbt$1Ixy}_t_jr(?$oAzez z)YVr!b>LnU7#0}dsZ5oeo!b*4Q{cTEs4X%~uv~lQ4%$;NXQYDmS!`cy;QS;G?^7567JkS;&BlZ8E(5O*5~y4ba5wbZ&2A{}nc;XRbxU7IH6 z*5`RgSbPhnwgN5#D`hUi#{X$3X!Ot47^hU9d@DcSAJ2(G-3-8u&9*fnQYxNkt8Tv8 zYhk+z$N6tl^M&)HO>8{AkGGGGezgny{-)RxMwBtM;giDVpq`|qd=y{q+bQ@Xl?DdV z{~4aEI4{3i;Hy-gr9zWZuV4d&4&OB;&X+@8=A}LNybP;jREog!> z%3iejVCoPq93dX@mu}a68QNkeV`Gknn1VBXV(#iLZIAI3H!v;x-Q=XNMFshE=62X1 zb%qPuTgMJ0v}9o8Y$P%!lL=dCO^YuWmQjC1&=LBPw^dnvZb3er%)nZPgprZ0OT&$~ z5ey4>_hWhVBJzA#i$i^~5giFO@B8%i{a`fkD7;6vp;El5H6R2TNp-UI7+FId9k9hj zHmj>Q*4e8)`SzTyO-LJ%Z&C!y0j~WBAD%_eHG+n-MW5^#UXH?8WpO6~Y7zhInj^Cl z{l0a+dw?#oGwLWRC;Z~xKLY9baKJ1}oKBmAU`fnxxCC`t?b19q`~20?oj+uSp3x^| zu8yU0)A{t2kOn?g^|(P@JUCi)MgdRQq4=*u@8eq zbgC0r_-RFG1y^WY7b8(%9c#-?%Y1`TfeJhj^8n{fTbti^W*kxrSrFY= zE1sLHUgVH1(VTBS^M`maY_Gdg8DGs#9bWE~(;!5^RFwff6(mm#U9@6!E$cq|I9pyE z3l4~aIK@)iT?H2mv+{Ze%kl5>rSRuMDITPl+w+5L9E z{y<-%`-WU)>^?hX_WPr~&<-W(>R)URKl9iV z9J$QguV^cslX&ygF^@3q)F`cej4~M>Ce8KRniyRWw3Q`upst$m2)_#XleJ~~?m!_4 z`U!`mTb|2kPdwm?ln^HQao&@@Wg*DBexVD5^$!8ry+FcKGGot79{JWc5>wKhE3v(; zEqLX~|7lhkD=u!BoQWjY1%I!_v6>$qlJWV@E>oyI+TkBb$xYe&b=9|C(Z0p_(woyM zK?CEyks?pe#nl#{5s*#l^UgstAPJ>LlSZD3J zCNpHN*7b|!OwwGk=4Wko8>%|5A#mKQLdJ2_pJutBy!WnMN>%r!8f?U3mx&GUI0Vki*vs94e6s48)9v42|01@qAkaPyw zRWs}E#cC&p7zXKm{U@-$##F*DYE=tDG>a@g9nn{)-E5itt|?V#gkiH=6l0H9c$I{Z`#=`w8voup%n~4I05Wh&njE-U zKm84#PhBu$b}xcXx1$yb$R*hcA1We3v1&#Hi&E*9B(8c?wou-CAT+rgm#Yr0DSS`5 zLD=%Gu4101Y~_qxp5{o<0-Y2kOQXn6Pel|6*S$>uu{7|65=SZ+t|3y(=jcLe8x6iy zG@TYgavu*DF4w9N!)gU=XmAa?zl#vI`X&0v<>$K0s|QE$O-*3l9`@hSHy^6`H(8mS z;!T3JJ!RxW0C-Y--xt;ToWS@-XSnEj5q>J$D!E7#9d4J*Gv{wPpXG?@%{@d*DUKH5 z9r48!_2w-?k#aae`7zKr^+pv5kQz1{;FolaYTmh^f^_?Sb0*S_-~k-uraC~6!qI(< zTF%kmWr5}XRHXj>AjLlRs?O6qvUugk&V(yQ@(=4wEu+^6P~bbc!PWX!Y5KM0FX}V6 zi5ca7BU^+F=P)XDk-@sTkrT=ED;zWi!8H|bJKr276T5Fh^4863cOsn;MnS>C)U{9!G#$8Ry zGrlqUT1YIb_&Qs8JIGRvGozEH{072sK8*DO*G)m=u#3iN8Nh*(jfqRX2o;IT&77VM z#Pg6k!&gMJ-41i*QFPl?`UIbUc&e7#E-pRE>}o{+us}7Kq{F$(FiQJykRvD9TY?_! zE&kW%M?rrOXN?DbkZ?SNcjJCdm;dqtSdF0ge1x0kS5oWM;Kf3ERQdqoxKJ0iwYAk$ z9&ISl>fXRapmHUsLGHB+VIu31;K8L1)U-i6@|@!v`t!E!{HrIDC>&|YQ@~#= zgV(uQ_a&h>_e*asAlTuypK2fR2p71qZl(~P^5VpGW|$5tgoW!=nBtsymw)=~{F{yy z9Idk2KuGsO&~h6R+)KYZ`|$P5A3gYz|GT6 z_G-xaf!zdTBabB1Vy*1U^f>(M)LA7CYRz9#z2P{sx=_|525S-ovPbx(Vf{a+j^8`= znf8GgnMRRzmW{q~|M|HHFhnD8p~`Gcr&Z-|8-{LL>Mi@pK^r*pBY93`&pioodexey z`8nrB?7evM<)xlK=;OgW&7=NAYXRHqOcN~XnaU`pfFN#=(n&96_2Un+TjIdR6?Sz^VX;($UG8)Nf!bcVd8|K z4URx9_J(@33dwRdr|GV&$*z58cJP`#8Rhl@z5q^N_dfO3}p(>Zek(i znS-835K;|l!&hvKc!VQ7)~Cix=^zLTIxt5HXgQqAJg@Yke@_;Ls7vC`#+fWWp=((5 z?Ow`BFYhOdy*pJ~U6uBy!_vCqaDd8&eo;iR_{Wm5fb^0$tW;ZFcWU}Lso#hPb#(P8 zdQSE@B4HoXF_4pXwlQ!PZ_$wfGni3-w9Ycny*}Et_H$Jgvp%O#JlE9x0VQl;?s5|X zkr}sw^HmFctIAVMjbmbB7g=-nQHpd||Di)(p_3Jd(Ti=u|500sPN6ik;td{$opdSk zJ&x8F)W3rcRT9SjL*~=26&!%uG&41262RMCPZ@Y}y0;^xd-G?cA-#Xyd2d#*``2vN z<^13FKS7$dtemoLGskB_sRK)3I_*k?Pi+s+<|)T84U8>M#C=zSsH8*k3P-# zZ;j?PZ8%~D0^A0Swjq27ch{#$qof^bpvKC4OhFt~^mR|EL z!_5f8if{lzINE>8KX68@gQ?T2tGIY+acO72sl5YvJ_JCWr@+( za%6M_$9LQgJzm!j)M;z$$X4lxFk%-@*rITAn-2&wm>5bSz3HAkE3SJhwc|MwO$Il> zo`$)opo%^DO?fQqR_|;0P>G5-=sU55t$Fl!^+$#gCE=67=p4IMjwFV_-p@ndN{(YNgDxX1n)*Mcc4%dljAU~TPP(4yq$1^j!&;Nls1Hmlgg z+0O^^I8ki1djUHdNlUuAx?hGiI4}Io`U1#XWP;v@qn;RiFhL{0LCDf@vTXGf^6jxnT44 z!2YEi_#NFsp4^X%1?E-DSolD_#D*qeX5{>qU4Y}K-86Nw5L}dqG~Sl=E2*viqncmq zo{L`dC%3QecJ5HJq)jg4eSpAqc#q>2oTjXUDS=%ZQfIXpEqjR|Jt758@tQ>^S!Aul zRs4#wYUPYP^OsEwcnfi$lsbbL(?3Yw$(LX27Z|^YbnqU9BrO30((YoFCc&V_xpk9& z%c>R(zlhGdZ4bTxn{%|1X|RculvE6Og+(M>YQp$RHS zIM?tC?u)jxSEX-&0$0&G&k@{j_RQ25@&Qr${?t+QG?@9LyoCjyIT&WtIzLYfDzSUe z))Y)2`Xt{r%IzfF>T$JKzmuZ)tEnkyXUfUUq14(%kD3iOu;mtwEcZxbSoP=G&}6Y3 zH(;(pISdu0Kn=#kvC=91idj}1`8-TC@!1ZZ=h?rl7LV7{9$&nCz*Il*e{B^FykGI# zGMyv&p7{C+FF*fUjZ?!ZQRSX)IB_r-TWe%W2#Ez(PxP-!^1rXt7!^D3GKCus(&J7p zw3LG5(igpIG3c917lR&``{HVOn&+D@q;X9=c|d=5Ufg{7tX-*{2wuUl=6B%303_De zpSCfe;yo7wuh_zVu>M~K+PZoUjG>Y#o^Wlz-$9BQd2c=buKXCl%nR6woB2lz1`T0Q zT`m&`^XU8UxFAbpt}Zy*eP$^~Qtoio$qy?v=Ydf*s*|8RBzTKKI_82sshWOZzdNAr zkl_2^WhyI8w3z$;d{~*HWB4z~sZI-%gE4xNtRvEVbKktYpcwf9ArLJ?hS6ch%kqs4 zbfGMyE;r9Z7NCZ|A`_ZCeU_TQ2c575kJ*=(9VB=@EIb=Fq3&0c$SeUi18Cyk&OIv*dh_;2>t z^IB>)49A2*^>xt1yqD@|e>g3CfAa``5ra3vP4n+b zvd=z47cE+TdMqg%qOL`Aep#IXnCaxZt{$3%3ov!Sd?-V*=~41^=vm%eci!1t7no~h z{*r45P0`9$9zhhrK2>~=(;m2N zfHBI#9d^<@+~kq>qy%dc1uh2275bc}&e5&F)T@W+t*RwX*zN4>SaprojN$EJ z=z*=tHY@nU_@@ia7-zOt{-hi-U-C)%m$K~yc_z596&d_E5@gupe|et9qQfOh6#@xS zy4K77(z`BE+x$>@_{zX-=mxn%mVamPdxCbTUMymKosr6^R?#P{Vxq;hU_$iB$;hv|8PS?aJ|b zf72EIgKgmT`J7$ayt(NGJt)@bAQ8QUi1xjl1-5p6vU@G-ba%#_Dg%z`Dy>yd({mLB z^5#DRcjfnEK>bJk*=b1>rE9-`^?~RCFTC+1Iu80iLy)-t5#!|TmDAOJbB!lWU?Av) zy&D~Onla@yDv+N%A~M~o%;3mH+bSldl8~$g$6(FB(vY4CbXj7iem*c7fSF`wIEAXC zK1E_`UO^);UtP2W@H>rIKyw^2genAKL7nJm+mw=*3`O)F{95 zD_EgaPn{)W(PkgOP=sogr3Q z*gNi9B!$19iOFogOJ|;OVJ3*7-Vf^_h&__cmg46}dz(P;>*Z zI4;LWUtoTyPQ4s`>>h&A>Zzx`1gw&m;XfO}2IA-Q*NTs7h`9Ww?f%s>h1%>vfHnuc zYp~`vWd>Y$alR~BOWAN>ukkY@?)~EY`uK%-&`4XFW*=&=XPE26Q~`a{Q2mW$3>&%c z>3KcFl|)P{!)AI+ux1guhQ+Tc@gK>p1EbR#wdT}gQKdK2?wgf2Gfkn^n;)>n(g`89 zCy_65NInc)?sMyCkjY?A>@YEgZZi-Y64YGzKX`43wIGoH+anI_o6(B2XS2g5j;h6l zf$XT}6)SwZSO|5uaDmEH1>CLj*KE$#OIL>-w;??R&@O(-chkX|RZ*SMmQzB`z}PCC z0)Ta&D0;5`96fisQZ#qcU) z9N9*Dt4PTGfRrxpVVv+q;8`!oJZA7tvB=_2yy|3!c4Er2b4qq=pHaarJBv=W1WMU@RPUEEc4l+mb|o zO}W>sgX~*B|4@^Yx}W3R=^rqj5}faw@6R&0$uAlHx=%lA-$4PDB}jYy&W$GBP8D)E zM)K|If)Tir!uNBCKpsI@JLzs2OL|z4RirN^0L7hu&PpB6H5jqOUp=)HX@NUaj|+vs z#%3J+p<}OY^&LdGjS1b#u^hEHdO|XALfFx~DE!|ON5)z9ZaxrxZuHfH?%xlT8?Ju} zl4?SXTuRL7vK5e~D<&q{1j~*!UU_B?IZFQW{%}D^VA)0c7e(x#pQJaQlThA(m(Dw= zd9WEx4ecQxM^<2Zs1N4}MG9DPi$h>+tbMs~8rtx{tlSH=p66_b57hkdi4J^+k7yCb z>dRkdZps{fy)v}Z&)1`WG7k2lO&>1*QQInxo5c`0KYM$85DW3Z-$r^%4l7NEK!;8} ziy$XXt{zCoGoM=M{TX5D&!EGYY?a}K>C}iMSIv}KfQHsQ&G0lU~E7{khkFE&Tc^qE7F z+EU+>gM6&sMNC~s=n=zI4;9Q*51ZAp`;$B~F*?fUAJkGP?^pDtJ${+rTrbFhYEUi5 zB;``R<0F?aD-1;@kNvYg6^0FLh4F=q^SifT+MM+K{0aHZqZckMY0~{?>+cVZY*9Kd z!=J)xeXlxRoln1z4*&3E&oh(I%zs1w5)5*Zh~0boB9^`rsOz^)bEZp+Rd$IR23t8i z&ES<9p6rQI%67(Jp#|-)FVLU3GIZ28G8D$PQN?JI7o341!HiOeK}5@7C>!WSliH7$ zpUl{kgBd~$)L?ggmrl{KH)ZGTJ*&%qpd)@j0sk$JzvTiz~H zN7axDNe3k@H-gHu(e7j91+n|-(v`7hg($7t#mca65P##Wl?+Ditd z*h|)CW_VF#O{jg?F+PYnw4;patMb^aejUjGqNTzXCH?ueU-#KMD7=|I^ZfCs$LEX= zl=XX!sUl|F1dhsA@#7=^ho-Xtin@)~_|l;?(y54`ba!`12}svR!_wWLbSVf+mvo6p zH%KT;cO%G>3n(RhU+&!Ntc){&IP3q7bI$L1p3ly|`yc-o))6WCIfA%cx_FhO2S%Vj zM3&DIi?Me@DIhr|`l89A!xZ;mSikINWZkW}K)f?dQ_}a?d`*h;lZx+lj!!%#E7p4v z0{_jXJaNgLx6maqXD_drCp#!)J1yGfo($>3XTOoFNs)I|;*2|6rX1;LR@e9>dr4w{ zhsJY$Er(u>%M$$R!J_{TSbMNs5&J#&KnDXV_XLH$FaGEcDG0!)7MSYG9HlskcJ3hS zOWjIeoiv|ITX6g!=6PQifQld`C6aFR{brMVioaCT7wuNGvKDi8 zY@6{Yv!v~I`n95OVR~qD(8ID`{W&d!6!g!1S}81M=&P0`U?w|9(^wQfp@jvhZ+G%PD*US*X4EG5lrgb z_LG2eI&_J?IidK92?@Dc&ii-pLk?_#(}nojHDP_Jhv<1B%!35%Cw`#Xuk z=;q@|`t3StV_{$9Fuv`Kws|5{M3 z`Z3-~AmPnR>#rN|)6!NX|NHWw$c^@(0@_orIm zop!L=L5+n^6UwB_@<|2IIS+XqT%w|)d@%Aj`SwdhR)Ganf*e}7Nzi)Pv+a?zv>&ff zL?}Oj?Xi^f`GiuAWVSV|4a)-(9nCY!Y4$bJuK~~M89QoVNoZfopxD@m1jPsvU$=mA zv86cS>b&bFCIq+e3hQMiaE6u0YkI6xU-QV{%pY~a?)&dDvYEk@`u7*rKH?+DN7qt2 zxp?m{`?`ey3ZlNx3Jm-h$>J!3mT7utztlec&p?hRLykFxJHeUUQ{99|0=Id9E=KMw z=D#v67toSeE@r5EW#1+lh3Ub;j{34k*lLLuc-$;=a4<3}5+!|?#`%-uAw3>Nt|zjp zQ}eg0-=QPA^qfvcWGaVp;%=4SC2B;KIR)4&3RKM0^qFzag=4tDR!~f#}*Okx; zkv74b^G6Tu!4umh3^S1Xs!R&H4??g-zcTbc#C)_u45oKLR@t!+XZ;&@{c>XPZ zXugJdU;c=#r)8H^6aDfd<|_F@7OIJ5h?LeFrH|<9R(e#JsL(?)wQKLO*kUg$Vx^DK z4+&@w)lSjG^ioe1ikh745(0uL#gY2HF6 zL#!5dctzLe6?PT0p6t@q z=o9H2TsyZ9TAz*f$<-Su*BV7pl=J@lEg@7p$dc0&=tWBKiC_Gwbg>z1X^PH&hp`WR zZ8+F;AN&G7$?gYMWRkF@v7{)JEeR}BFVy1>$_}}Y&p!{=CyE>iz}GH&mfji}%2!$J zDGHwDWOb~%(B}-^d;jqXknrKiOd9+v`pLuhx6-b-|Hk;?b!Ogk(sB;9C&Bl;U zEz3qG&qjt(yzDk{&}~=U*IsQe=aZ|QVDR_Nrvw6*hQ+Jt%Gv9ZYq-IYvWmscR}s-< zYs$?{zyInD#0k~sSjVaihQGc8cIAP=%X|S@eqtc2=oiN4DP`a<%s|ZTBYwQ&TX?5M zb#|IZi3@M3s&ukjG6`=nSaiTTG8RoBIXP-g)cnbaJ!zZ28M0@K2Q-%Yd^KAIyYuGC&i|ctM^Mf`zf3f2F2<$i_}H=5cTJ%x zDy-1uW}-zWZo6PG0|s`$io3@=Y_KHDt|QP#N(_P%lOYg%beZD>Kt3cJaU?&vNvZl) zfBmqx-LPVPNYy3Z)Ve??B>|@Vs`NEpj;0hw@cm#2PDlp=*^D?NzMu|9huoiGN#GRI zip@Tlvi(R-Jw?46WfbgtHBC$2h^)fV(&(k;I>d78-D80hMsE2S5 zwlp3Zrvs3VAAS{BMs1cPM=@W&z^(Iz=5YE2<#8fNK+DdazMgGcy=iAV@>VLI%&l9$ zo%Cl_)fbT(JniuyH-}2B&V2HFlf^&gI`WQ?w9ro}e5P*fj&95Ow!ZfMQmXs(r>N(S zrp8<^8>n({ybidKLpJqFOvGuY`L_p`9a1Z=jC~>7xg6=k1*N#i{@=mP`mm-Y=f0Dr zVKoW0lWQ(G@`49`d9%^?uEj|7VA2J)^dEDK5}Sj#DFN3}^vhXm@z3lSkI-ceq;qW! z{`)aESKwIgzhKi4_R5w+HiciHKCQF14E6hR5)`wY&Rn7V<-eocOUmrvTPB;rl$veT zUk8#GybY4)oD%UH2KP7y%@5gS_Vzz!yIy39{cIZxpW+^+*L0e>kskNDv0Nhk5FH;V zF;+vu0*&A0N3tTX&~X@8_Ck_NrvAa&n9guEU4`p%BeN-niNvU=_PkmqR*JGpkzMX@P7C_3Zlr7@=`Ro!~xG^!?QzB)4* zCc~HX$$Nqv0hyX~oXMO>mtZ@&2G|KmpSa%Z1ORmJ#ztX(xijI(HQ=^Dn$i_W7e7vt{GM2G;HQ8Z$3^|T@c8^USd=XVpyA5)Nh*}TIm_DgINR%H;ni+?Q z2n)jr$@X)Ei;2L$Z`pQPI#ITG!Y<#i`YFht{GbFzxsnm{kK$!MGJV!2nv$c^8}qXX z*8l;TMQ@GghCNaG3vx#i3ruSb*11Vx9*m)1D#Bm?tT`VAGiF>|c^%^sBqFKGO*pRM zTtuncRZ^OeZFACZF<%pax$~Vt0c*1JtHIaKfg2=w*j@+u0;9l28MGV{dCvC%kpomR zq_`NW;-;2A@A+gXBk1jPYA1L zyX9y&z_dFquIWq!F6~kU%xsDyLloyeL-A9efkPf74U=sAf&D<|WcZ{)u|D?SSA2S+ zwo?p`9Zn?v1npM%#YKuV=!Yu{TeQqVdkWC8DU#k+H=DX%^=#1>npPS~VEg)A`*Zq5 zz*c}DY+|bJ_9u`aQ@RlxScmU5f$LJ7wt!5GnVDqW7CnA|vkZ!f?o1~F;8ovvaLWjI zP`W$t!O-X7`re!YdEr^Vz(yBxBCCO9F!5_7o?x!7}uH+Ljigxg~2&!{*Dh13#E_$Y_bQ7G?1(;a958^yG5M zr;@PWf>!?iA7YpeNV1Y;PT`lIAW0sv!SYT!38#bPD~EnX7zilA`+b}j!jkCxsWc?7 zqyyIrUesBC6^&dbKm;y<-#@CztStVY1yH4o4!>SLLY!!q#gd!)_pk`EJp|75l6VqvZHGO9GlRS3OsE4TO=D$0okdlD_ zWm5T`Va^bOiVCXRrGtfo%3=CZdKkN&r3%L7(rxt&x*^Wo8p_J2_Xw-k3{A^$LL z2=cD5{;l_E{3^dq`t|2}Es8+$uT_;XcGA_i>{ATkkVbiFIn$q!BDMOX9TS4hw|_CU zdWFWLP`v1#y&GmJ0OXVd|Iu5B#EmEoqV+Mx4pi{V0_CV`B*s~A$I|WH`olB}WE@zW zo-C`wx5`~JQb3VR zr^Uwxuhd3+F<65M$uhhiOK{#p@kw{q@My(bMd^weSqY`SjlMAt>GMA1*CNFLbI!T2 zpX*M@zQc3=zvX(Dt^AGc*z#JMY+rrP1J%T9Wyf#H4a~%+y4x}X$qyiLs*(a}?^#r$ z`wL6D1*)9D{T=oeIVlMDTkt9_#R+1;Ag)8dTUfgmzR}kRLH+S|l4nk)bV}Md(L%(< z>$_*frLWjFSJTNp@*K+TxEs7ZGj8a++n-KzO@QllNHh1)A49Fyb7avJ3~2M9d_Fxl zyS(j;y}tU3YtGs{KVW4Z6nk8=ig;(iou}b4BWV$gdAgqgaR+)iC-4M zFCL1-3|?C{XP<}~w&4fYblcA?ovz#Y(&o^+1i7bxLj=S%c)=rdh-LafyRkmweT~gQ z#fJdt)n^G8FWT^mFf!)a?zTy3hz36vkm1n^ zR%Eb~vp;{rE4}Q^VLG>_1}C}3{f3>7PG~QjeL|OMM$ZbWS6pXJ`!-8b-go1Cf*+Bg zpiWv&UbOpOIUaR_$E)LSvxjk)JLuPUCL;Bq!2dW5@~||Iyx5w4IWpd);77GEhe_${ zo^ge8H;L6!x2-^pLh<9t_Q0g-gxxlsE93z5BB(eEREonl2a`6F?*AqI>E{e4deGed zQKaODgN#6D?g?MN`lIC*l0p_kDd_C<0#`o%?CdNU361d)jq>HWAyg+4IEIi^EwOap z+?)Hdx@p(RlKZeWt~gPi{=vTcix#rp931K~lxc(u5#v4MJG`Ffm}{q(|3#%(IV00x z2spLzBDjJ2u@rgL<5BqDe|dPXwMapU3#3ZBRN3Z!Lou|c| zzlP23cpgsaX9JgCz)8{YSpRQ0m}i2Sa&~3;%46T_gx~tLmrdJz++uJPbCW8ek$oGf z>+`&<##^yPc8FlK5g zwkqj%5{N4=XI=WuQAPWe&0?yAa`UbCE;Yiqf@=Ky<(i3P(Bbj+NL`B6$ zXPvsQ|Cr9am_UND<>MA#vdtKp^C#XGj{eN4-cT18x#SN-I*9_UIY%dJ*J*Y4U-C^^ zNUsuU24#Ej(H=V3JOfc{tYs(rGzzEgVX}jL@v@Rm8pjdB8i?`}6uI|GHM-M-q zOIjl7XmH>rQI*0;7Qc-KGWyDc2KmJP`sBTn>KV9|nF}h1lt0V&x4^4*NBiu&sEC1% z?_G1dpV?~e+q9okp9zsJjwIvQp%NuxDG9a|l?q$YkPKZ5UMCl~IDDQze^zjs;Th%W>ZSN!s($ z#>FPhCw-@V%PFgMGfe$9=%nOGm`B|pypV+q_N8+f6Wc;|j0NNEI8_gXwHQ?3G5|*Z zF4q&vZAO)V`9@b3XoZTkQ5aY1K!ug6VjZ7Q$Lg0MYeVB?NvQ|*&$QpDtbFA!WOVxy zCzJ{20b2mP0{d7`H`n&p8q_JGxW(UkH<$W%RQH=NLS|>Cp?OPUFBQJ{xTo)XK%-hZ zj+RviK9jyQoWtGm>P(-jp$xO}4IURd;_?GI9g+{3Flz$-KR`YoX6B2P_J>d!pr%)p zfGCvPz%OeM ztkZ8f5v}*o>RyNM@(x7UOOl^7Jfvb*W~|(e16B`QTe-Fq6>sKmtT(*bY3)mn@-?}z zvTfYkc4@n7#s1VX;G!}`Co{-IVk;9eN`>EOp%61+6Eet#|M&8R%)8H}G5)Nb?EBYB z$qbKVd}vp$dgB7@iNeP|mv>)(y>?@0BOkl#8w=YZe9kc5-Tm{0_k@&mzH|{O6<<+2 zCf+-376lws40NiQ{JrN-Dx@PYF{t=d@}=J6;^FEVP+>2=(U8T8H7$|VZ4c$dLN)ow z1iDfM6Lu6UvNX&z%dv$!9#nGUc6?Ih2Aek0c4Xw~ABL^9SV-A4^>s0dwJ9$H@wePD zQi(V3)R^X71qAeRMw)H-Cmz9IFsY|Rps9k&xSS*h9)WiZ(Lii5Fgf`&lo3=^7jE)s z?qc7*2GsQfJU-|S-FvNx*A?o)nY@H@SVHUHAj~*GL{emzl6Z9a@=gDTBE@51zTD2~ z>%WDEdJ2L7H-RY=@_HU|mXSdTbTi@FBJO2br8;LMS(d`EA13r6(9^uAFh78Q?^Src z9b*|evbY)x2-^VxF%!FTtlmIiSqBh|DLB*=zBzcy=K=NK zFuPtRb>Q4?to3NlJfWBk+_O|DeeHZpM_$`z@NV7FziZpt_6s@B{SJvd5t!stoORQ# z{yULoeb0n*^_hozvvb47R~i!Aj|Yr?bO^W|gSovM{(xO7CPo=Zrmes*2(({6L|3H? zjy+iuhrawI15D?|a=Yi>j>0VU2+{k>J<7oJDQh(%HslDYujMjL%W&cDenw?`Sn>%l zoT{cj|K)O~r)zXl{kz-aPcpj?{tb{^GM9_sC5&!&g66HZnI~_$#Pdq^D|P1%HR_v> zIlj<~E8&SdLElic1mF7Gg%aSNJ(yKF!Dr0Il1&-?HwWY<4xvn+8am}Apd9S%PTXAtT?=w{SgbIlh^SEk-P6r+qA7)80q&=%wjJ;-5(meC`4Q4>a1W+7~IxMc0v~ z!0qh+-kfXuT?r?#10Qx76!8N*HP(KR3Ls9+=TwGumUn?R4Zf|G6J}d)u=&d4e`PWQ zM2-jGo;$GV2FweM=-eeaeW1CgtqM1bnP%grRG~|qgpij&T-iN&gcP}3UbFaDqjId8 zyfrK`d(VuUfWu&b!o(W-9r9Fr^O?4;?qGdy-WmW(!P)gJJZoXfWQq?2JL2>|J-H@4 zwQx+;1}Eb8O&mZFeOqD&!hi=%?8M0j?dO+s037lI!7aR(d8cm=p6CxuQljOa_PrOL zkyLthw@87}zw5X?ZYK~Q>>;QVpg9f;1{R4=<*cxck^?v2yHK6sKiXTuqUfA;oEGX5 zt8Z$%^_kbaK=lv3pS9?M=L^EaOwIAplO*Yxr*A`73FH8As8u<0#nW^`?M?w$0Haq; z?Aw<2qMAR&cvrfS7tg_n%p$(WD?&KWxDQ!u;pP1_EeM6;7IccUwf7Dro1y|c6!}kA zujVsK=)xZVaiN&6+<)@T(YXv2Wh9!xkH{fR+BAXqn+W^ns^w%56o3>qHUf-!V+(3q z2UHKqBIii?AW7WAEz@c}K>VL2p`7~w!V655!%FNGSPT$vN~s2|fv?)B|2(&^5tDKw zy6IO{GcG}nj|e~dlkLJHZ`bny42|TAikyo@L_5vs(#_4}*7(uaFAt?Pr*SjaF&2i| z1y9@mKOSo%%EAx?A$oyiN?S$65=-&j%P-|0jIWTAM_7BNx7$Ior?c$O=H+XLAM_uX zCmt`xsOVZuxk^(l!BlaIX8W8Nz+I`@s-A)>8E8s;RPt;C%*{L7!+F{j1o|F#v=Dk2 zTC2_L4)sGx)Sw;d-Xn7&RLf){MN*=nWDJ~}wWJC@YCO&NGL{!7kTScj1zi}lFSp>_%~mfp2WF_d*#|!XtQ$zulq*_c;64*M zin8%&JTVtUB)J%*eHh+4y{hU1!VU^%=Iqr$v>qDsXKX4QB+c^*{Kl=fbX3(g`Q!mz zbjV<0lEUbi9tje!h8TLfTM+8JTD#CO<3Ks;6d|+XWPNr;OE&%LQ|y+Q3}}%fDrWWs zYI$-^4^t;KdnQKkI)Hz8Ws5^HUu`>R%*-jvV502x_R5T{A|W1o51N56;bKx-j%6v~m z5TLlf{_`)t6a5;MgI(rYl((eom?|aP2TSvoqN6*)B*{x5$ENioacH)g)GBB_Uga|X z0~`MXba_1=C<;)ntdTBehgcW92I@L2dscm+<4X(FTQ~=<9`-)sTMi7p2`Z=d9V}E%=JRsxG z0Vl!98nD4UP9WSy@#rqSr!hGRVA*}rFPWL>uwvsQsnD9o7+#cp)+f((>$28#kBFv$ z-{dh%l@TU?MAbx;F~>edSC&I__S8l%FMs?w+G(k03qsv;P+*6A^7u(FMMMEOs zojQG#2hFOSp(>n!{i5$h6(SZ$4D#>j;nYl zC?F{3V&^9G7Q+x{!QzXzOziLX6}t?LU2l_*jR<}Y|Hp%dkwN);9)Sed-dNJJCjaF< zToHjaQ!}%pCx}pjtlQAw`6C9XVEn?eghScV2r@#76aodrXp_%1VEeBn8iQ_c$~_pS zO&$r9Zn?KeowTNVL(Q65C5EPU2PMO$B|y6OTmM=o z1NJE2tC}`enq^Zva>(cRa{mxZa_=JrND=^4{y_Ku6sV~1M zH(CPB$K-B&AJf?NIdHKIXvHsJSY*z}tNihUE>LOa&GJk3_f#b|W-?8EvU1TwDm^I# ztZ(}3=;=Jf&l$|m_7w0w0-K?*!hwvYKG+KKta;{%r&B1N*$D{&867C7(jyPO`dm46 zx&|IU+Oxq6dN>=eXGi6=zNfJpMFRUUp@2U$0nO^^^T8y?sacWDx+}6@;26oS%ZTKj(=b!H? z-)}t3>9HJ97jXVydP6PsNikBj`KZ((Y=uR_y)<)IC=A3OKB$Sv=4s=`VFj=AW8-M4 zls_MB(`V|*+LB+BIMM3PRyD-EaJxXX4aQr6^YRvz76LM31;9D6E>5?y??YHd9=Eze zE%Eq3T~?pen%X}*xmdd#FoB{}+_+^~*JDvA9x4m2ZNb^Un)MI39$GmL3nC4(tlW<|V<;Jv12OO+B$#E2897KYcN zOip8+n&20u**c|Jw>Z*2xsA~ti(c6i2sgvF$do<)>^HTRAB4oAeYo!>&W+Ghv86qq zCjKYT9~l*cnpLPnI9}7>x_^Vmr{YC2&AM03%)(-6rOfawLS=i-K|yga%m{UNceev+ zDZAo?Dvw24S4bgQU4rq70TdoNYu>O<533arbjSopAxO@el$rdqI@xXE7EayYNyW!! zN6pS+H!c9UY7E1*0y8WkW#WvJES6AQ(n(nSA2pPj8Qi@YDqhF9r_mJ~v&C6u8r!aG zqwJ5TAtEYRS{ds7MkJL|st{*x&9PA^MlpJ2rQ;RLV{guynwnn#`@2%)j}K^Efy#dT zZ@7L2>H`vDBV%I1i3}c_Ti9YqOYvk(kL1l((t#vp7E&?(@?49WI8DZU*83oRs(p$S z-cI^u(@7?FCp+EgZn?Ic zXRkwri>KFqkCqDH5$54%2H>BDnrt@u5H{E9XnrdT_tNfj*8Z-p{rx3-k=mZ!c%uZy z@Cs4F7s-$L0qt>x*m4-Zo8qk;PEwycWHVsD?K1iPDJ5Ns&l1)x8XIoY7V{t553wGd zr)3hPlU3#Q3sW$%ptHRI1%3Lq+A?nCcor3gNDo%|Vr_+@iFYh2`K>l%F7lw+uGE}0 z2Z%UYl#JHFM`ZfX@&FallTjf&NEosvb;hA?A4 z$BH;h7hmZ86Vuhza-7aDi|ucT$0n`&!_;_?DKADB!SI! zYKrfhh%-|mjAvvCkw=ucfdDFgIMywb_F6*X@qQ(yvc*aaP&4P5NaX`x*pXSYkArsQjm2 z1ZzxWn`oCk+UCCbimeLDb^ML%w_IDi{9@kOY4}cMx;siB<%e(PwBoOcQF1d_Tl?GI z-t1o4S50cu8_iFuF5YWY=!cwi*ycCIVuoWP%@f{emUw+5q9F(*<;lsw(@k7^G2@R% zy+s^tU=;;nWwe5>36L@mppYCdB`}ZDiAMMrLvQ4<8ST6cmE<-dEWoiIJL2l#Ko6)h z9!>KntWTFuX#yNf_UzwbAf|xCLUJU?H3&ioI|nNW z^Q3RY8UHgo2_7vLewIuJ`^qKJcf*l}UXp1XxVp3@o~Yq?)v@nKpVlzvuoD=0KJc@?o^hg~H7qLlt+K}R z)J?`5)V!$}e7#<6>3rbYMh1Gc6W7cBbK}U>15u$O&#)BxFC7d{%cW_m{LmN#EXhQ8`I#Zy zD4^pyn21z>dufp}DnDIB;*VwvR|-Zs?o~G0V(HGDoBy5}aZ1fR>$7i7p~(}? z(Omg}Plezy;>ucG)LBtkau8n+**yCzl3C3xpaDhw4qZN7R(puz*5@$BEJlCBr1=D| zG%>eVRzob_Q^0vS;H556$}>Cf#e5#Ar>IQoyzIu79;q9Gieq17Y|8tj|L!T_%E zQ5hQ00SLcnM7NJ%0s7oxQ{XUc2`ZT@j{J+P9PpQXZ3o=~0z>c<`!${UhX4NM0m@I} z7`ZXz7Z)H*sj99v7!|CFFs@B>2b|)M&pw*;1lE_3P<=Q~jnokaB9!;{K1;#q_18!g zk2~%S#4$0G6LjmJCb;s*w@i4&=f4yBiR$EC@g=jxj7ccii4(azvJ8br6*-5qS7U+e zV|CD0J7c+W7We>{KHfM5j&j*m(s>huZcLTIup~o{y4LocvS@lpg_I^+ZS)Q z2Adm>9a1U&WxU^wLCH68Uaxkc?Sa=^f3e@TQTlM`SiAt;SVa0c<*df~rV1P4KsK!0 z4wjo9rH>kim)H}^p=1_r{QltMx?ZmM;pb-*+%mcM*hEBH3Q?XA14tq222L2kc`rvWk}6lO-o_hp)T4pxF_8kszivsT*GmJq1NRdaazR5!C?s; zYl8xsPmsV~19wYHD#+P+#KWD6-XoA}oV9qV{k-uL@9f;{Y&=>L)m{f|IpQy?^@q<_ zC?ZKK5|3fjeKX_lbAs}G#h_}hcDMhL*#!C}M?zhS^zU0f*u)af@xoD(Iz2plINtdw zzvpgPGb#+rmlqws8XpR|*rVUv=?Xw;>hj0=M7?_QlHlp5SNmngID!%;I&YT6x0!2!4Y&Ce%$L7)v` za}oa=*P}DUpxTm$=TIn7Mt53?M7KJT%pQyW)#rEbg}a|(?oq&0vr zcylIx!Hm4TL4g&WV8Swwl-pb3RAcNNLNPchPQJx@CEA zmj;8s)$`y`5Z@Ao3MdHetPue;uIwMraL1D|B?r%~e%Z>yyQ*fWU&~<_ZKFhN6HC@Fj+`BcbK& zMY7-hN4*FZ&%AyCWWKtHX4&FWos1GE5M&${^UmL|-{po#$bgvT>FIz@4*i6QUvrjRy+bP*&=v;K%_t-lnCdD2y|%+imGf z#F>A`YPxqKuxI2=O4(#Nx~py7&h0odQEqG1Q2oj@{E;)zd=o8i-IdCc0rM|&GGRF0 zJ8Bv1?}SP+-GtrvLYQcsUlLq|JL{~6XRTM-L;#%PQ*-Elzq6Zrm|JnUmz(?PU}wUX zZw2^C&4_oLA-Bs*bHhuxu|WC8%FJ8d+o&hdFw&N0O$i9@l$ab0d#xmIkLv>hdXiaf zEy4509--n#%TB=rHCMEB&i?Su*HA(UX*lnkxa_K zHc?+^MJ;SX}>V!(~6 z6CLMlanVoxw_3ixl04=hi*LdGN&3PG-mb(hsAuG zHWdl>v}(RNT6>*~z;AuOwk4#C(oUIq(^!lu)zkPy2%EoeiY>I^;Bp?JPEDHI5s}CD zE2#Us3WspqZe4%rgbFtTQ{EIV$sTKvcAt_0f*aSkuyFT>UcDfNXE|n$FK|8j;|l*6 z^urie^yAM3vkcODSANzmKY!OlxwYj@P2{R+Y;Npp)wHdpZ3e@bFN?|v@bL>%#NLAQ7HtBVU2jlN2oej~U>zel# z%wK+n`OC^iaOPi}+UW?&?|C~!9sUy{(e#OP>7H2Cz;JEqw8FYFK1m#kC<vEWc9mMPGTku}z&L!Orl zzaxBxn||qkFlVD)pHLqFN=GhxM2Yi>Z!1BUyyd00tpD+lzH|X@_e}|MZ9ro#gyhl_ zL$)n4y5v&Jfp#+gy|ei3=YMIQBJAj%9B>q8^@u85;)YSSiDGS=^V~bx9jEMm+R+q- z0twT&Fy-@Dk1L)piUR@SXj4eon%n8b#00Uc$jr#_i(#JLUtI1j#{C6{r0k^*( zeHg7f5mx7}wM^4q9s$W*+s>*V-+}I9jDQ@gJadY)Kozs@|IMQLoP6WG&Oj3;fz|cr)aM``HchjD&F!6^v{GicLVI7}L^j6T zCMUdEHpBOU5=k-BOn2K8YlWp347^>GQbAU?HGRJ7KQNicM;u!nQ0xS6w_H z-_zCAU3T;)4%*e>^g8*gtFLe6>pS0U2E52MWPK?0^Bh+#P)$IYs{JgoZD^$aC?KrW zAfko|p40g3Lv%q7mX`P0#Og=KCPz4E$~0w|c*2dFQ0Hr9$@O96kC!^l@m&W-e^Dd8 zTa2;tV~d-dSolCsURjB{&FrTCi~Vi$fr=7Fj)71h6n~yL>Osb^x*B>l;Fk-()GBIHVU26KNCGhDH(-uC|Qbur2I?i_KZ6Tp_1HETEfRz z>tvZr9ww#t{f06uY4Xu&hk<4&h+#_pka7hH2j!WuIa>4ax5brZ;WkkR30 zA=~8hXGdEdzBmuNDouw1hx+#Ek2n$Xjjz0%GWtd@{$7f?x6pu(z3$kywaY{3t+a9r zfuju}<#C@ns|c6Y#89Mtd<4^KSvb4n{kp2F6Z}@5PEJil)YNcjc-8;ijin`+_s`7D z`=t0g3&WEfhQ=Xv^cU45=x3&>+w%fw(jxB^SFPN_HU2@paXl>})j<~3RR4_!Pi@u( z3fIVfuKDZXcfy*jgmEjwD;UX6;(-XoQGSR})7jmfy06CemL`uiY+j!^wAd|QM`3@V z+RmtnN?*{#5@HbfIL7WvD&w=y)jlO*upK|9ceux&aHN%FD|d}`=q!iL=F=Vx!ndNL zjakZ*qm=rcRWIF94*H#6aHA~-c3H?a<=Wh_zv(lTDbRK}*yl8JV0<4gQ{aGtFoZ*J zpAc}gj@`Rp5O9@}4#@24HPKehG(^&T@N-t4qb=yABS*@tgZ@u0{lZ&6VC(-s8SjhuG?&&7hw- zI&vRnpSZap6=W+VSU-Jm&t=x&ntNV^>b9W8+jZVsS?78l2;3OZe%s`4pZJx5e3=NW zlP@%6dqxh0GfLaM#xNbtcr}0OHZoy7UEQrmJ5_F;lA7drD6c*aB8_~8$leL#S{-?i z#K;Mnql%nS_N^QdY^TlTmNvislZ6IWS$r{Hlnfnw1&(AhkMsTJsQNlhp|}DauE?`F zgs6vL5Elr2{P6BMLGd@wyOu4Z;av_x!6FyY?Z>9e7Qsa!uv%4AmvT&E9>SkicU!8* ziCgq66pb1`V_t%l2r&Oub?RIdt9hDZ0yG5De zKg|dg8D>39c{|8h8%*qeaIi z)17_T1sr;Dhzd-;IX(mNMRtVu-o&*b14~5u26{gpV!tz(s4-|)`3S>DF7(x2r~wg! zDiIVl&A0`HyutLazW7D4wj}{05{TNAO89C`Fe9pGO->_sTb~>nK8EA-Ez}*xb~Lkl1XL zu|#RuQmCMcbhY;HR2s|@EH18jv%LxEk2oH&W%**U?`=JSTWh%qD{CP=0X^x{sN~aB zt2+hw>!*&j{q`|ihugWSq5Zd%d_G^S!B#Z>4b}V2VIj?)XuR$ty|-#eAQ*@pEiO}? z-uS?t#iyE4Ui~O@+p@pvxr_>0G3g)8Z}YD);aU~V?`(TuNN86>*0y%9XIaBXGJMrA{Tpo+DcmUdQ%QKISCL;8{~h+j(jDrn+^y`4d5y z%gxNps>LcH>Rlm*9lkx+Sh>{Gq_eqBEJtEhV~wPbgoeuEHmd5Gioz3Oa2>vgXM6eP zaFIqiLIpf!29@4OPEi!xvz?{Z7j1q<)HKQ1(i3AH|1@q6+eXaBu^8=oQo_l!m3x|U zWS)|eeyr1A<)_)0B%Dgj{_F(X-!*s=eH``XoNjT9R^K9K|e`QG2l zi=Ua9`6a$rUXS%-ZnRr5Jxn?{N~MnR^8z~HjM<2eVl2*M%tnS*Jbi4L%?g%J&$Iqr zrsrHQAnbM}uMJyB){%J(7M;3_QPq2<)MfVNdeEpQ@zD67J7E&U8#(E}te;Na-FG9p z1`+#*7v7T_Fia1e#hYUq44Ic{9ggC!)!Dqo8X}oo_3SY8-ihEfb+e6FG`W*rrxsBZ z>qMrvnf-Vg#V8Ucl#p+#Qkcd>^sM##&A}|rW{BmmwJD>Emm#ZMKssEG*3L7us zflxgu4@u%reEBC}6A@P=u%tE7cQ@IR5+{!NXGrV=HifsxpJ~eW$t-KT$$nVfdGoZ0 zcHf8v^=ZlafPLQTYe!43ij+xG3Js~NqJl#5Yoj@%G^QWeRfQo@GK_>Wff?5;i-N+s zZ!HoEGIZ=@A4~gvQ~mhnuj^%)UnJrfcJovr6$c;AsxsJ1X)cJB%q{x84vv(eYHfr6 zW@_9QxEDVZLI$k9_IJc{^@`yCr>ZAE{JdJI^vpT2G?&&itiDfPClLHa4tJ2oSK>pm z{3V|-o*Vq;{`}gUlvPfNB0-zqL8w;$m=XyF68hy}7qT`S#@)hnOll zczk?cHleY8PVig%luASTxWbB}m&rjH^-TLo?|YG9dTboM1I-sT5zHG;l|ORJVW#4E zNCjXT|L(4Xew%4Zg)HH$iy^b;y5=wXKH7Y6i>2nu&1JKYYSH9;VM)^++;TiwBiG9( zTH34G6bFH4ymqS`!Sg2hkX$P*y|P^6Zc!r%W6N)gne)$H6wJwKq^aMY62;Qep*Ygf zLl+W-pD@F++Gp{QOYJg-F$OD*BU1x-(fjm!Mt+&Ql)D#rVqqF=SD{TQp0Iu9^D2ix zpWJ#1FP^q%ag6c%R^)~16`zkMQ6^_#~(v(FKzGceu#}q^|CD^&j*JTc_ z32oew?xuC9G3!XcQINu}A65$_6ghofd|3il@_Wl8TTAz8BE&mLN=xdip^mSN8J^tw zu5uTioEPuI`wLa1P0WT@vd5IM88O>b%a~C;q>Qjkek-7(JjAbbgWly?!+$UH?OUb0 zvnRu!;XkU$hp?Kqm9fI_CXUQn>K1s1e)-wAsq;qF>y7d>@eWS=X*LBt68mW5yVR89 zf%Qz07wz9M<&nawDta@4AliN*I2nLT_X1+m{XWr=|$-fir^+P9g!J1?Z@3x{p$Yhq(`S{YF{&x4+!C6;)n*>H%& z4_*t2n~4OJe0qFA_Yb3TN5%X3MOiIpGI{LPmH#7H*iY#dG1_JI13wu^@{j-a;7?j& z^rf&+&hpI<^+lV^0))BfDQOUWG+Zp7S#U{~q1RV0K!_;@sOxeGocp3hMp0UD;NEt! z7&1~Ty_j;AL<|I<@sk+6oV2sDIB>mif0a8PGBj9_ib3XL753xrs@D^?L6_cn)LB6Tw+Rj*hh2mwJDx{aWpEUo&~ z-TuWHT6;+_;tXFl&b$3p*EF1KBYD>vNEl@=xwbn}6NIMZ{e9x9^AZ+vZt&Ku4VULb zyzj<)yA9vwBUT#!V+@*`^y;C+|ElSbHe=ou&VzgZ5RD?1;@)EL7IKLIac{qj-184) z=0TILf%SpgEcq|XjOKrc-~K)Jhfu*?hQ%VKz1qLH;+h3_-s(NR-xQ!}b}ZE-85AIZ zKrrbfqMdzFeSXgiVt4wk5^r2OK>A6{_d?{%{y8>KG8a^W&@%;=(U9287U%<<{v|5|3<^A9g_X+=DT z?AnY(vlAC=aX>6MxYpOiO>%{XybM)myzUo?5zfmKIt(sY9UmvehM&1~G5egLacUDB zH6L1xy%R3R{M4S9o+at6C=}3kV1K@8@VoBQ0lS<(TF5~=N@esWTecusy(X~Ahl|21CgEHE#9@eOea397Mo_*uDAl6BHA8?24y)5oRhPH|s zZa{1Uzmh7w6srD3gSgz6d8GA1Hw^Mm9-;NP%qr1l-0Z01QQPVth{E|}-;Qs@lmYgT ztg$w7!FAJz_e>|`#yc>0*R0^#;%|Q_9j-QCf=~?AYY*P%&{5YzPISw~j}nP=6!580 zDiKC>t8#8WT|w8u38ZGzD=gEfKM)3HFi6lKU(7Gg0D?Z9DV^M_z^1^$Uz!Hm_yMQL zii!$i3Vqx?=)^|$H=kc~)~jegm$qq7JYH*Z&AI%?Li+dS4^Qx+_s#f+zCc)!xiuNz z`#%zhI**5Ut7?;TxGi~jTXkfYjHGRLezAey_kvS03M8fzn||ijj`|;(&N8UYuIs|M zyHhA$+@-h|DHL~iYYP;DySo*4cP;Kv+}+(ua1E~C{k$_DlgVWGLAWF5oW1v2*Lrt7 z+S+M5GZNR3shXgyE-lKrjlI}TR*^EzK1S26?l?vHS6}pFwLVCH4(jMdHw2cnF?Hi4 z`AX8D8p$U8`J#R*SIa`l0ore8oZjcA%6|7TsTlzV)E?Ez?MJut3X{^96MVmQ?{H(a z9!f$_&&eH%)_=bAEo}I2g?Cal5=fyWQt57xeMbGvt6;>Z;sLrhBIf=r!U5wnKgo<2MRm-{ApAdL(&?T>P1O7z)BB@v)XNEx zo%dCD?$4~j_Ud-Bu^$iEv+0E&dS*LY$HK$t)Sh4Hhf9D^3~nnDu4b=>1~(q7@((j! zUwty%)Abf)E%BNS@0`&@T>IDHlNd(b2x<%;WipNK`B>dvrmprDwtkH(iT@4^Kr)Am zHkskLrLf9B>B(^VlYviW#EzIsXu`W-c}=|J04nk0tc)dD-j{gq1?tnASoGu@$bS0P zS&s$aeX`(dDk$jVTb!Ra*OpJu$Y8l2uX!}Ud>`e^K(z6(f=|Kz6`z5cNX(#EQyQ-v z3uvVO>-bu)8v+9(`2Tv2oB(l?2)E_Z3Z)))0~0u9Ei1)dHeUC-@GVNg_+Srecl~_@MxdCtYUV{kI!ev`6)HSY6M#;!h4>szwEf(PQ`z4 zFuH>;{B04FfoUauH8$4epLY|n9~)rUJWbmGU^_i~5*H?^gDU69O2rsK9`>*EDRuR!aTccHuA=F888bJ3A#T<9pN_FA;L2 zaRYzdu!sF2yur35LlYmO*I|aoS@->>Tn>;(GYn|2zU7`tnu?F50g35fwM2(q0Gi`+ z0qKC^e%!RMYy80VPaw4v;@!1>X+Qni{?Rl|bQ+GCJsQF^4-~j4GzGB*p?g2O{jdeX z?TT_pxWU;OzK;4PcFA3ynA^wIsJ})Mc(+R`-e)N3SiTrwZfc)f$dNdVGO*JL;e->h z%__z?WcS~g4g~;Fb}L>OQ)fQd6@pq~0sn}QW8fVP$#)Y8ShOS7`Sz0F?H+H+e)#C@ z0i{~^tTOKs6P1Su?X(p6mqql_#9}fy;Qjn`;_sP6VVtdX{mBA~ecV@fb5@iQJGC8p zebdfUw_D(+0e|%Vj3Kqj?ROuqt4CFm>R5v?J~QX=fm!BCOqN0Kl>-j(xv2V$BKhy) zppgguif6Fvk)1ECV%+1YyD!VM9Mss}U!Kp1yzrW_E+H$z8J1fqCe8sQqqmrz7n1k9 zhS)!r(84*h`(A(egn_!+h+Q`xn8qWX?$z&@{5uwrqkt~g0Yu=a){7id`oQB;_x*=92wYUX>rdaN6h!p%<% zZS-eOrH0zs`DG}}aq#o&IL;&mcqp^85gr2PPSpq}5iR5$KvLENHu9dIhc0fr2axM>-gXjtS0qfV0%RzIT+lZ&lg5 z>T37p)#hxN2RG{9AbWbwUpF5dvjQ`s4IaPwbL?;S#L{=fUA&!Pr?1zjZexK~dy}G@ z(YHKIV~kAn$g4hPWRjSnuZY!kKw{YKYi4{O>a)>c#~{Da_+J+>o%}$?SB+kb{=<}EU#ARtj6e-qu{@ed2bbe#LoEyw zkPl|Do4ghQjd;E`iLRftsY?)~I4J|f7mhNTwej{W@B7cuMSN2ewSlw45r6a-;HKTc zw=Z>f9P=KIiO>_c{oZ)t-Mzi+DfmPW^By#M{!NRVj+Lyga|Vn>;Wu z@ISw0-OA4q38kH1M8FaOWOV?FkrDIw3gfWeb!Nm649bKl69-5~uQu=6{JAsHl)hEe zm)5f?yf`Je(xs&(5{w^7K~DgC74o(^aJRMuO`Fh8m?~({;4X+%dUA^ZuhPxoUs6&P zS*DH#hN5@Ax8_Z;VO@H|T4~NQ7Lhm`%kRa@PWnEhUm?L)f~1ptKDgNKx1@}?W5NeBRP619 zQ&}Y%##Vs=g`dO-lUVkkDRegEeZ58x9-r6gETU+|9ob@~7BAILl0JH{hf<9c-o*6X zcFv+$*6-&p_N)s35P3pZH zEWXV)P`)ZU6ByokPJ5-MS=GO%BoyTeb2%#o2FQSxi=kt) zn@~Q3fXF*s>rB67azP)dig-i2=fn`$i z{t3DKM1TauhH6YP50-1VnMdzqWi+>1e^?+F3_Pyo|ov$if?{(42fNDyZXrAAw7RR zLMSHO^GAjM&QhCFTH9~_bb&u&5luv4dpuV>lYqrx$4ur=yC-Jx+?;fqRx0djPonDBqi2M)0O+iz>_Fa|fad9%turM3?R z?3~JS4!?Y3QO8Y!d~RVu^=={j@Sd$|xXWgcmn!*FTA*o@O}nabaEotAbp03cU9U2( z4a@UXKZPASTz0a@qS$}4U@fRz&G3WE1n9QCx@S&FBpP+H8>-&4im%{JU4PAmqsw{Z zz~MrnySKW%nS%E>cDqP>Lx}%{6Abwe==j~mnin^M3!Mj-mmNOw*C1SEzb{b8vIm^Y zAan93X+*C+{R^chwLl_SbpG!LE)K_9H?Q>Je7&Sl05#bg=a>~h@fiGTzW=B_IMG3t z__(ni;|SCgGO+{)N2?H89ON;M=T2afeD|5yBEz`ap3gs1i#C^~^#ev|XP^GNrgL0i zYq7h}{EB;3d@omaM9U!X#~GB<=6db;Ur5k?3eqkPL)Kx>;#S$Mjbc7NHA3AL7;VC= z`-E#}v0iTrV{V^st!u>lm>-CfuDD}82xC=8P*Gp9UJbdfE~T?{S)TzGlG_yH`=M#lzw}w0VmOy`>D3% zB>ir&4%>j)_j&`qo1KHWwXt{f7S&HbXdfc`2`7ntx(MaF&rcUGHmQ$xUkP0!Re3L+ zVh=cj2MT|4bz1~Dd3<=jI}Oag3=PTz+Q)N`Xip`f`X;PnoX0089Iog3m4=-kNIw7k zo6hrt-F{Q3FMt6CWU%>Dx!EYiJHvIHX+GMM0SP2*6h2}A2L?;fTV$*Ta(2tdn^%(C z0Tyl&T+GS+x;dt4eH}fOvB6pzX`2VF<2rlcJ-RzGRH)Lsy@h&jmFf2;0~0J>Zx%OhFey`?$%C zVCP1x!OIHe4wM6Jy{6o5=HKX_tJ#EOQQ6+G$b?@HHcuR}f3Kh`&U(2Jw)wIU9WO<; z^ypKCAmmJb+nfF^nYzZ`Tu8*5dh*<<7Fde9B*thxb?5U5Cp@>f7y%FyX&X!bhop6w zUsy0%sk2ya{6TnkzA@&F%vlmDxti%IAsapmErhnV%?}L@vI_}~+pdwYWT_qlQ@zB*-b@XQ z3K6+7XeT!IrF&deQneL^7&TIOynrsrHFjSchUw6SuR@8Q#Dt+soEQEE*;CyyOV=C9 zxkOOSWAq9;jW5urv@(CbWd}auc>1`uQc3Q*sJa@w;W`bHiHT&Hk@0@o8D?4n6wI$ zDHUznA#B;7E_ygTb>)Z!oYPy6Zv>VP;dzD%9-az6^*2MRGnRHTHS7lli=CBABS^1@ zC3`kx$fT!!)a*=K8TBl`nN*}@737^f?Y2aQ`dDc*^2Nc zcAj=knLmTtF>cLxI|nPtp~yyU2jxe}&K<<&MlZ%if)60=aly;lwlR#$#W&j;!QB{c zt-X4;6~e1gJfhv|m2u>^&OZ)d@9$geI>^*TApXUUQYxG|n0yhW%^y2=&ef z2-zNBCT#>dX{Po++7Aq|K9YF3k1094oxEd4ldPfs4Jinzz99c76!Mc*uLZ#&^@KCE zb`X6UA4*CkDwh|a=>j)Es0Q5sPZNXyJO&;BA>gT^KdOsJHzSi@2gH?dNBZjBlBubj zuU3cG4s3ysD%cg5;0Fy`@G@iqZhkB3NRfSM&JDBvFt9MT#}kl6am$df{N5SIaA+$Q zX#x>tJU?LQbx#Tfi~f7-Cq>*UciKz7A$M3Vf!#21M$${NGdgJdx@3N1+RYMP48*D|LHW2i#E%{@m>_dC(=v!IVV_$P~e%7`Q=7nz3$ny#U*(=lH5;T zU~;I0tb_PRPU{CpjbRPRrEW}g(kpln6!6LXecB>rGQ95y*jy2&rE-0quIJ>AT@oC( z$$}D}sT`=pvxbOv!V5a&6eTu%1<1kdwvoczE;}|yc9@ry=BQii)xHP**`mI^wQnV$ zwW}dNRsy|*%wKwvHYLCBwvVd58&=Fo`*ZBosJVXgbLfa(3M zGPg?YufaK_ug_|px`9HcJd4ZxG#Gk)$lt@e5Ch~}Cthi55$3Ukb=W7O@Vs>nrwjLj z3PsxPDXRFqw}8Rl;c|KYml8@MNHp@^===qnO5-#ozTWT!%I z3v9Vk8L!QW@%O_xKXn%r+_c@XIsl4c8|9u4w5oG&aRIu`LzsjxP4Kk-8a*7S`-7WJ zy3wEKvaxm@5!q6~@C5!%*FruvKM~|x)t#PoFa3WLagCVT{;WXRha_*}M5Ctw6>5uS z@JzNQ5&!R=|eS!zK&?5|$rdV8m6i;JEk z8iFuu)4krAPx#sbqdKQ!*A9HKGh##x98Y&q-_dwbNr_t#c zA+@KrNoZc~$-gesCQ>#7^)TK;JlETgHqeFOu!ATZ+WHq3;4~M76K?kc=swCrUkJOGG z0m1yl!PTZ1;k;{-M;jOS?JM~+ZuaUMqTQ?EeoVIK)j+HdOpc-JN4t&}wo5iWpT83s zp%Ku>_WNvflu*rTfOG%+J=o2}Nca>*)ZGqdL^Pu)Z4LgZa@`uChPe&h)#nv)S*T&b zvGUPK3yJq^*x9$&$l!@#eg4(V$$Llr9`~Ds{hf`65!PJq0LtiAmS^CYn}wQ$_0^k-QQ zJVq9@3U|NOH@Y0vVsRUe!FKXeNb$@OyQswigS0OHFHDJ1j{6+?^tP~qOzLSV6j5a7 z_amW+OxgbUb3`zdC#k{Kfp8&U?W7}_NwhW==-27OkH|U@j!;A>mKk{J;Z%(Llvk|4HvfKhyNh{yT zr!7&E-x|9yW>C|Rs-;WqgZoRRk&~-H4c|cW`FEZ>gSW)XM>EfmUnl-s`5d~T-H)Mc zW(zshcr{+Wx_YStvHI$$`V&UmL(FBbdo2%y7dvEHw)SF%d6T2$)Yw5tTXK6+R6tj< zj4W~=gE`5nz~H-B6d$JGxV($$=G5mu!du~AL3Dq$Eqe)pSxj-FX{Fo8Q^UOMsT6^R zx{iidKec(dbD5X4=T05Dz>v1mrS=P1hoHCwWj5+8M9`~tEBn&G8^IX@$RN3q#dKUs z#vw;lK}wauB^!eDcDa!w;9&~+x46+gxMbxG=N;?96-)lG$@DN~aLRXFfYD<$ieG|p zU39-088Q%%CwFhCX&mO?Rt_I8p|))+-qEgN+{#8a5FSUoBHV?Of0zM;0nYCP08gOH1RSc~^0;pKK;v)LD@Q%q8Kw5_&>1UH*ow%=J!7z%9{WA9_apXJon&5{yB zjl4+nN>dXE@2tcOa#=Nkr=MOM!&vby3o&J%&eyG0jJ6sO2yLH(mPZ&Cx|1=WjIvpT zvfoyKF3e7;vC*g0d~c-VuRKfQvtP|+4-?Zlw7!cYafTr`KW+K8&--!pjj2TQHD~f0 z85tboSy>;h-Z#Ymw~eH#Hs<9j)0;#8p`R})E@9{6_*p*Y{?;}6wY9PyodL`DeVrJ1ueS@xu@Ow7)@PV+BfEFb7x9M>3+^y{^KIFNyQDMca$DF$`M1i`ghUdxrF znN&p_?zp>mWQw=2?fV;S^_l5NhdXHOdu+C)Pu?G+nmG}BpmrG-Q<;J2dJwR&H~*Li zDpB`n--6;HNvSDQf^n&><1fMYGRJVhJ~cvFY0!`k{VVm`c`OJ3M_oFV-( zbjbeaepE&0;Owf>tc*KZ6E^Yu)KB$U$BI>Y7_GFYAFM5PS-e*OsSs2lKKd?DeXw`_ zIN<+r42&%J_*@E=Ka+rY@))&Eqo&&F$GjsdN28=K1^jq;lH3TKvowA2|5{q5baI`2(Kw!)^MOP=S3 z-(G!6F_cp(dbK^);H^FH^C{8~<*OggjcmjmaC`n#e>!kuUz+khaO`;4^z2-MbuGp9 z*H^)jPEe0zEyJ%bk{*w5oFXkFmfv4VrRFJ!=#Pqz5~+PeOw$^h95Xp|HNU+4$?uy?;krr38Tri86+MH;hU=e;pz_lD#>k!*h!ee!+!p zWZ0M5W(nI-_JIu;9}xMr3nZG=6762K03j*!XKQw5;HO6)?rk~iqkN0@9v|9VvhXne z;??t4f?NrIi-4fE^CEAmo|g5SU$UN_&YbmYLplLCH9+xqFqIa{!=#y#zHTKJBeEsT zh5wisW6fpgY0LCM5j)2W9cpgtNcuSE-d~_nc+>5iH1n#WqV}PngmQ+gvQK|VW0JtH zo~>2)n>-;;mS>QA3u}a}Qg_ImH5V@?!y5U9j#C`r{h5HU5@IvB@y9{DpDjh#pLAG< zxh}&LnN-LVo=!4$N9~An0j+UVX$tQ*TrD=yt*R+zd>q>c~uA+dPF1 ze!9=p0sR6WSy7QiX3dY=&SKjRRZb`SV~_vQvjB z5(Rp{{lMJyohLoH?nK9DP>#C^0&ShVis>vsRueg&zZW@{g-Qw4bRCL`wvw_)P>r3a ztN_=&^(q5g($dggxU8M&Gr^b%yl`z1?wsaTs<}Jyw)(%OentjZaKF)ezJzlSKUBja zzLpN8qG;_|s@w3~z`&r|BC_M>pX95i1MCezaGSxWBlXY|3D3ysd2sX$wtY<%-sn0@ zwyc3fXWJ1hV# zpDwM3j+ZVxgtuLbc^_-C^v(U#sLuxhQrccS3}Is`{Y6B(j%dgXAwi^wswn3#qqfUe z>zYHHPVNU~7tRxNSJlycH)&cch|ZemV81s~QO)PBhR=ke`{%;w0Egkng=9;|qfn@R z3~tk3&%FjRh6yW0h7oz?!s4Aq!*nA=SB}HT)`|JuTM>o&^$H@N7b4MOL1?is`&3*B zto*uV!59TM%9OM2u&}!$x>zHIW?|+rh6+*FQM1hhTfuNWG6TtrCh}kH;f;-r((qh) zWf}X?*&^-U1W3+L;(zn=N1}wQV@}c5`$9n;J5=j&`(6K654<*jkpyNP zLJL`?a=Dy^t<69?S z*2x*l`?%42tN%E15)ApQ&r`u&n@jm2?#Kjc195!o{n+XkMD<`mvE#$)Mv%Svk}6>H z4^Yh0`Zy?3MCh4V01T3QPDUwjN?(ao>Ea|eonkg!@z;I?dpdY_k2d{_0@JcPSofmX zo366@35TQ>v4U?oOwO${o$=a3CZB|Hu7d1;U0?s3OV}2T z2?)l|jB|MH$-t9Yk^e*MAp=l05|HMtXvkBq^V0l0#bTV;Ne4#IKP-&%^Xkimi4LbP zdVdavfH2q9$l9~LSWgk((=xN=r+JR~YTJQRCW3<72E~5MAHIh}hNt4-Wtx~yH>|aD zj}g!c(?uJS{C6<5%;Th+WtoR3(`Des0HBewNQBv-8~1HJUW;)L2;$#jH%den2sUxX z!NWu8o6pQAjxs}u$j?ny&olV$r_Nsa!&y1H3k_- z<{+1@LDKf4Qw^7L(*!=6VE6?g!RR~8Yn&z%fIQuRz*H4EYzzSPI_(z{f?zd=11-j2 z?rs@Ez)0CYYfx_i86xXN1M3_k2JU)^@B!las> zSbjTqsTKYC>CDluRd~W71LpV(Sv=nOsOFIT7YfkYv2X83PjWHSu4c;c+)ta@!BfJQ z2Ji5P>8%*f2A+wiv(M z_LtM(nYZWpJ8LqV5xAgwmODGt`_uS^z%;iMFJ5D_2&|LE!|b|ZF?nW&U~Jt3{jO=j&i4!0CEGs?l3-FF(?(jQvf z!6QFqy5?4=m@&}h>8?hhmL- z`KNrvywYZ&3QZhP?UtW-GB^5TUz$W3kS6+j0*rYZNx&|6i04ARURO(>jn@cs2qxJW zC%XgYR04p$FdX+}QfPpPGv0=rC`PF_Uoi&t&?Oe{*hcIN-d;Pcd_hl|Q7Ou*dr-2( z3OW#}MDwDtxlYqZ1ZiGU!(~DcW0Ya~EMEl9t)JC)ACFx6LnB){Wcq>><5Iij$u-TN zps*4>S5kEptci2{G~v`1M=_U?o<6-kj$w_h-noFxl1YaNmVR>JY}fh#_Rw{aBZZ=C zv-YlfzPQ~E(YsvkIhgTj+y(%0vIm06yE(k?qzBwtlM{1dpBbD4c(zgeE1`_7oExMI#A3toq*1GPt+513=@?CEEH|@th`^09G zcU7Nhn>J+_7NYc#O?*E}l*9&(Rr7LhlE??PeOQ$q#}y}Dfe9&#TcX<)od6vOWKb#8 zsvnavbfjP7PG6*dw>;o4=CZZ^TN=E@a6 z1*?q^Z`YrF)fXK>?>g^OEyg=G59ihIjP2*1cN^ihIX*bUN4oqb+ENV{NXU7bjp=Jr zCS=qqTaYQ}iGOz037-tk7LkIi(}>jnUkk8redMwF*H1K;mzVdM^L}k@_}bCxE0!`L z_F5QHho+a;cJ%(o~DPzLDY|)%~Rf{H;Ik>`NaUy~fYMP0Mou0sMaP zJBhr3SXe=)Ojf`C|BTh{N8~5^lL)V z(qT&P9oF~OD5qa+aZ9zX`)Q74`L0YsY|?gJ|M^_K@&`f~FhoAyzg~nLCJ3RwR8|LkQ_Cb_{Vw+M!la5Al?AiKIti0Mq1;aW;w@f2vEqMYjUREJ3J1;-3iax$G z>Ti7xf&7_qN_=+@M>wP^drwb2#}=cZiX*+W}Jmr8lpw ztSIPe@=MWjCU<2@I)?qvHMAIOLf+fU~+fr zSQ|2V$S*QH@sl;#;DS-$86AJQaDR)ZpG2t=^ERpGhQDlcOwI6pc%%L~v5w|UnBe(3 z_*n?jUvCZ4{#nE+0i`$YocIN6I)*Xx`ED!pg5?S8GM5#)?2V!0Ax6+aVPYc{v@gN@ z1Oe63uLN@)FG4}N6t&fYzKgmD-{ZxscOlLN5?AYFX{0cJJsc-!1OYaEKg+c4yS6ZM z>qUIKYswJ4|( zRf`Gq7)moJ)xMSj=P;t%|D;J`HD5ZNM|2AZi(A-BJkWNrps#nkQJH2l3`0rgL9Lm4 zk6`X*ThG;Zp41a6aS1pa$6jqj#VVZ;^6Dp)Lq>c?`b3y&{BkK~wLA%iFKlWI_}P{V z%nQb5)(liM<`ieC0^{&c$vaiUWa+E|y}>Bt^)6(|el|X@wMx7(|gXy7$-KW#_NG>&_1QB{?=;=p>%r4exVgz*myy zZocucM#ME2|^zEc_#gDTkdnMk^5`~p}*hxZ$9ef0G7SlC#^m-O^B_Ao$y z=WcjP{!~Te{}KnvV$L+QxyL=4@i9UeiU4*hqzUbQuKJ+xD2;0&KwuCahCP%)ArEo; z+??RK*^~29vnU_*m$!LrTROO6YdK^n$L*NU8VrphADK+7>-6;lH2uu@5r2Nqx=kK_ zjEo@CbecWSw=+W%GD?&Aulv9?nW`;j3ay_#=hHr9XOkJ7DbNlGuV-EVdGTVj@VO@* z>YQhYQC&TAN$%v};o*tFYQ9K;bzW3J$EmJkE~u(PuVbdpnIcg(YI9<+oJhCe8-drk z2xwhx_yimkC`>riT4m8(Kx7&k0R8ayge7nbem`7q$~u1UMgmY}adBdJ*g@OQQA;%q zU!C3Ltv?Zro&_hGb}E6JOu`h|r$~UDq4%cO;J+NCsWLRiiB&6$w$=k?NLkI+$naLBEJ0 zS8}Oa?z{^%t$Lv?%wu8F1;8!NqSgF^1|O-kj0~cHfWUt$6@W~|XN`u2#vZsC)>LA4 z#|&tirUg_gI^!4;m8mgNi~Yd*)<%B8_rE6K#@}mTL;|pSktpRIW#=k?d~*|3RVrs! zvXc@nYhuBc_+5mOJ!&r%yE-KN{@b@5e>5oHe+>pSf^xf~s`hguL{sRxpH^l0N9O?dq^ z{h6UCq>kED^#J%j>pYHsXrmYhiiY-E+jcd5Oh4Aeua%Kj@V{&DfHrh73~`^P20jqt zLc|(pu`;dho`0Y~gCk3W6H>2FkGHFf@nsb^atJG_ZL_Brs5lZHiCh3RHq-s6Nezf54_T0srXr6No5*2(p(eI*z$_ z+%u3qH*fr`TCdEKrw?B-R!)MJE9l&@^J{tfJD@q0Qpu%9G1p;5J&va#&bxJL5sYRziI*#47Z8X5 zII^hyW8Ndy)por*GiEXDCAnfjeyRRsFs0wb_F=}6p|GYI;B#LP)#2*6kRk6U%7_h< z>;YI*G;lzBXP8nFB#XK&9KfEhN`(AHMPXMKulSQnMjwDO&W+jgE3Y~@Ygk?V<$@-- z>D`P#wAtcbc*$?=omaIs9f6qbHZR4Mf+fzLn}%)Dvs4jcxcf3VhB=>)lGUm?e0cyx zCoWN-AITWr?G~vu!uL&Q?!>O5?hWiCW~a1P8+fs`Lo1)cdTWb69n2G@!%+IHlL$`> z68wws)Ot6XRoK)-ASo#+0es0lgFT9htM?)9fNdUNj(;1N`;;)U4I~{5%FD;y!ieda zF=0fLIRlB5K}gm~aI#;xs<>7q#Qj^)1ayv*Y^L5V{oQK>A{;p3%W_v`DdLbgsG5%6 z<(iOBS~LR|Ydmt^m5ATfz#Jd}mK99#kZs(CcH>Jf|5UhJGkWJ`cdzo#jxd>mDEPysjZoWso~fpqlwqTbK0tp6*0QP_ZKHig~RJ&g0m z!#lGk)SD~-CB-sn50w1f-CNhm1Wui(gv@_)?z;3H*MV|fVxTUS9Z`&WS^x<@*~?xU zcs{m|;$h#-YITD?6LV6=QR4Tu$;P4Ds8XirKVaZb{-&f>cSDY&Bz&3P$Z9<8R-$|f zI`UnRRa3CC#+^YqO8oGQ(15Bot6qK)uAs*?C8<>!;6-T_!>A0W@F@D+d|`Z;S3o;K z`g1}^!tXqai&&xLuYw--NVcufCn$oIFJI+XUVJ}^J1Iz7aJPqQVCL<^Z^?J>9J}F`8 zwryQOEXLL+&Zul1Bg~1p=O<9JTf@sLS-?($(=xYmnf+cJU0s`Q4~*!}$&b|50Ey5P ziaB9K{a;Z}wjp`NfUIt0fx%~hhASsl0!_dB-$@dP?-HlUXE`bJ?5!w|n3+*A`;a5s zuGsq${RxxQ6J|>P7WEr>8e{s(#1`|J7X&Y^pmc3IU`yo9k9xc>PDMVRZuo|~BFxwj zg$o>;(RdNSMFK6JDUGd_?*}8#rwL2odT;BtvNF;;-r+C)1kQEo zvJUXg6pc4og0Ine8G)k@Wm}coSH_hGs3^xzXwba1NhUh#6EHW&$HxkQ%s3`^g>7BP zxoQ@8V=GWUwB21@%Sn1`stHPC#KOaZyhR!OWA>|Tq8uwKDrT0Kku)@-8EnC2w&mqi zIN|JD>Po;>u}H3{tlw4m4rNbuY70!QV?av33W_Gf$C#@$=fQXTy!bRoKSDAk<5ZN& zDe7Q0keMp49P396SjA!>vXCbs^&|;xJTM22RHwdy=1&*wv?dn1F~F7X^mzgU?;n&` zA1PE@n?Uff>yLzt(Dpfw8h~iDhmk0Po2P7@V3Ff6Nd#4VKGjBSN!OU>=K*AP8&aJT ze!z3mQCnt2zSUsTG(E}7>ggecS{M=mVQfMYb-$f318#z78&776oS;V%rEFp^B&=z8=rS$s7DnNnoXk$w#3k=h zK(Fv4$xFy!N*sy!eibHwh)3N##{G@UgAaH!7REGn?gIVVw~!pdzmP^pFCNS)z22qL zB!#pImqr;79V9Zx4#PYVEDLSiN?#TNqCwy-;expZP_2MuP($5pQOl)%>n~82n@utg zf04+pTUrP9`!CEGfLJzuE|gB<0CbcEwd&SPD7eU z9YJQ0^`yOSHxtQ^%p-RmE8a6}Syyjr`j+vp@JoC!op{7>LDp;JS+A@{XTrb#Ra5(Z zv3J1=R66Z>%P<-|?8%#z(oD@WP|$S`vflRijs_8JC+L3beJ7eL*T$iw1$X0O9TW+L$aQ-#YOa=2o8&-}_}98O%xJCrWXUb>KRh zu7~D2^EsW+f}=zW=2*lSV|j22T0FPixwlq(oIMmEQ~|R~04-BdI{5R>spiXL2*bn(%Zr*>PM0a;C)KxgYcwjr@lc7K! zRwtyehxzRGHr9iq10}fyW$5Y)oAkFWrwdmBLq8;7I2mt@x$ZbWeXWDaD#^o@h~m2! z?**(wz?UK_CWbRMClM-047QE~T+x@A_xpsM_s0QTT(iQCyq<4V^XHr+Z4Efe2KieG z59P!Nqjj_}XeY=Jg7aLkKriW^s4PH7p({rQs0-3tH_(CDCa2F+O@;8#_x}FkXc!nC zc3e}?VuY}3c2LM^YK-xKQ18f~YKOeZ)rjLlDp{`*RQ$@%c<|5yf zrP)PtY)>Ye$NLQO;7k)jzLEQiJg$NQ;+m)aj4oV}Usg=^-g?Hmgg<9W6Q!eCP?Iaf zMJ?pLAr*V@#i`!wCVt(RwP$*A0}wGUKudc<7;U~shuIJcpUtaj!XhF3Ydc*(@fX)YuGOKMil^$=S(Zl3c6FGP%gg%5*eTbn-7@^3RNd7C7G6tlY6f`P&o)oB9 zD>{NXfux9=%Wr3vscPl?(?=&|h=BLL(c-(39DM&zOI~9|IAg=<$stGW$Hsbxp{)Dd zk)B6%sN+H!uv`@#`*@YfJMs}4{9iEKmJ^sgLtCxJsM31Hka&gGY!~p!^mJ@ zj;;nO8_BXj$D5F37?{kedH#N%$q$N?rI8zTDUVzj{6^cSzI?jtv|e?=6}j<`6$&H< zcL)@D1&Omb7yKn51E#g{NlT2#&YNCN$qx!Zcx!1{nK%fc(JDuU9d4c}0;_6u2)~7YLdp=^w9ec@M~Cd8sY_S|_dGCP z`&1f5F+TJks7@#0Ucf-Yrvw37x8xM=k|J-CD>xB$$xSGxxR`c4TbLx0fTb6BiKdsA z!vLzPb&<==TwuUcNMniKo%`mg8SdWU$3reZyO37mE9&XWL3#W>-2r_|MyHb=G(D?2I?ei$= zYNm55u~aTlMBDHcJ*hK$k9od0oU5d!2OfBZJ_Qc%LdIiLT&e?1(=GJ@JIIMvHCNNC zUqX_VvGL#ghsXF&1Gmd#GqY!V2T4I~?l1a4EMVwN$1N(aKZo z-@amF0i$m`sNh78h71!{*z1M>DWi2iC8Hk`XZ6B1sW^EST3)4;xoi+Q_vBesQNLT`%( z;o%`ZW0>u~;OnOXr#5$flL;QzxoP+AMvR+W<7#r-X2o_WEmL|< zVhm8QIsd8z&uPClP;*NDK9g3-7zT_|F+b%-72D(`S3aJ(uJQ8oudt1aBOS?09%$Zi zGNmebGuFQOoH!eb56V^Xr-We}ND(N82w&sKcM?lifjN z;}e&k?IB|4h@iy-S(*Tsc46++dd{!$?7Y0802lVBon8LQ&wya+m@lVbpH6g3hNC-- zyLV{~jVek36OZJdlHL_F5>={mu=!3qvbjn;{b~-&By>Sy3+nXcC{A338qG|~f+;%| z{Xj5{aW#T4nK*3Np!wy+qC!QH=b+a+I;E0HHD)GaBg zX4J_0$blgcw(7b-JLO0E$>lR4+mCQVcjP=xp=Cv(=#L)%!WP!annVr97PPZWBsz^s zw$HD6`~ik=vRqO8C%DQbD9l6M44SVYnmpf2xpM34#Q!7PK99Qe1yxO8cp7>>YAhK> zm%N{^C6_w5q}JE%M{5-RD}?jTL&_&u$2HQ&8nv+EwjpkI@{Gdri)U%1=nGpI2 zZ5_j&>qpeC`xg5=DD_nZwAuEYd}h_UB9(h3;trk zGxwh7oW1widl|?e-)z?dE0Rz5cgb*`BMFv^VV6K?wjK+7^kj(#U$6P|;m~kO|Gc2u zSbjGB5UE<)z?R+yRS;#Fo8Uly!aSu8xwKF+r?hCkLRbfQyPA&H;MPcO%P8xhwiGXs ziZtkZAass0MkjB0`87Kj8hhZn!ji)FeNSMaNxxX9l2TrbWqw#!&J8ZSfD>BIf~h<& z{)(9CZ5|Q{fr{i8xa%nbNEyry4phZ)=saUaKj?g%J96s)j05?-AIWzLY!9-TB2vc` zjm=z0D!Lynt zzD{Kzpe|x`6lGP|2`OrZT5HHN=(4#&Avh4J5BnN(&1QOCY|A|GMsUFAdDSu2h5EC& zG)R_#6O6FWagkz$n;%O%{a^3GUAon?v6B?~u^FjnYip~=1SbbDL0CF&k;t9Y4LD&g zYSJqn=nQ_Hwb#U!qgx9ttV{c}HjG8nrgx@%AZ{|USqxuncK~ou)eE;fOf$E3aSaiv|T^%kHZYFd;6xkW*wTPj=tG z@EfA?eSAKg=Xx2Gk1{2dAob1MIyQbBy7={cx0Z*AE0(V4c7{o(0({vt&{ILe#q zuUa|vS9?!?qKki|?M-!h#gOc zqKxWG2oZxRi+O;i|Hib0RQ9hKb)77r57~ulFkxYQBWkA_n2;d4pPx)iZFH^wi3zJX z1z>-2x@^ba^)F(i`!efj_<6+xF@we>i$_o^N5nbxY0{u%`glgd6*)9w;`E|Vo&0<# zApVPgR+f|~4EKIE&AOgP^UXDmh6t@`)FpQo~YmyNOTgs;}^RD`>|F*nP z#oE>eI!ZdB9`Yv5220D!EY!rk*{{v`u_+%>=BER}xt#WFP%uqpaK%P9?)MwQ04%$Ttes6AnI0)N*jW@*(h*JepNM2%*T29&qgC?h{(wg<`fGE|xT$fn4 z`RVU)hu^AGjr$!L2@1?OEonmiOnlW|U5O zkWM}A(yIO9SbyIij0dqBYX>dhpu2CQyTyTky+T#4@83?P3-zkB9{HC#THYg`Xl9 zOOR%Y8q7jIRml{&&oYVad1^6(px&S0jX~C^$Z}@z@6JDA;4xKxRjY!)tiN(=D zUUnLY>)L&Bac{DRy8oeXfY{I*!04w)J$ZG|G ziy~U7u=(tE`|jCW2o9{mv$9R#L!7%9!w+)G^AaO~^I9|kG_T>fG?JB?((TZLKD{Fy z8dn@|7ngFMi3Q#zk(qqTm4?nDL{(LS1DTv-e>VeSXKpWQet#5Xm4*&samjeu5a3Jbo|eZLG|1wo)^i!jvl%Huwu8Yw zNNhZJo{B7bbR+m3I-IU``elw!5^KVmes~cpt|6y>XC@5qQD8v1rxw+mAQOHYRDHeW%%*QO7aHiqMpTQY*dXDFZ@v z&us~PscJ$jKS{N*WxAL?qk4OjK7_Zv!cRepeZh%d50IkHYcXS*eLi%VtZ;+1c41 zm3u~gHw}Lt5S}QSCtF6BmQqpn^TPyv@+nE@wDoT!%*dZw55}md&D>Lw0?SHSn#+*T zVy(()cqnmzh(ex>i5?EVANT{twci22LP7Ds1(IHrr}K^~U0^mV&14(~)AYze20MNu zhBlDLe5Tn`(ZB)j*rGAz#dPmvK@FsNo)KA!*>97K>9XW2LT$+i8Y+%X2g1qgEua-c znAg)ww0O8T5SsDjfL?dxZf*7&wy}^m{!U1Tq)bGmMe*^v+u}z`>L5>mJs^mp-}AM? zLUOsN)u;@L9;4Kp!#TDjnQ|)l{GfZSv5Atfd6|MAd~{<#q=R%*#+};w)Ye0Pvn3n9 z>)ijNEu$5R1PcuRL_Li*9ioq}E7+h5$SX&~5oRRvhVD8su64USp^Q>$?@ejJ%L4N7 zC^oQ{%bvMPWSDb7tanFDa#?tS9S`Nw@-jvT^Y7l7)i?TL(6Qj2$0)WcP)^2LS_8yx z&bsmaTxGU*XV}DqBL3fxK^f`Cu7W_PRY(1CY=T4Z2Yvyel_d$viVl{J_Dskiy14%f zGGXG|93e3!Me`TA*5Ja$b!oUN$@Jx&>$POA3Qkm+7EBK+_0;RA&(2Y-tbD9|v!1x% zChJo@X6-}tV)bOD-sG;w!-KbReI>kEm%1D0*C3ju#i z!ooR^Al`Nmkfx=;45YkLXV!NN=J7eMbbCFl#x@JprR~-B{l-IdRh*@MtATc)Bup^u z>rYzDH{}gzO$5~?zFUcZW{TIG?D{CF62s#o?^(xKlN)4x@18#s2tYVy6#B+5V$Mfz zs@Y4-Cj%$Dw4vtp2r9%sNifaDQ^rX~>V5+2{E*^L--)HA@;~UjYqC|Wp97Lr`X?uG z=TxcE%Os;!Emfkl7!U@~S8NoA{Q&+k<-NXS-EVR84`^>+QyfjbEsT(Q66sxkZlv3S z8$9GXbdJ9bHQ`S6v=!^RU4KNaqG(UhEyh8yV_7Y2c9EFb$RYR+v)47gGs}6qX7}hb6dw{MS<8n8DRmLqK zV3k(pdQ`0_m&bx@>Wp@E?tZ#ZYs+0P#Oba0T|*Dy- zSE8(8U8lUi*xl6?D_6J$sxER1nGnY_D^Ka?$DMxRs9UCHlKq=`$VyX^qNALW5uuD> z^57f++se`TCN$0SovWBQ#+%4yk0aN)7Wr>p=K$3m*YH&*o!Qg8S;sR+c7L(CXmG&u zUx(HOn`z!=AkU}kugojKvobY0`aUz zI4JYPLl?AitP9c!CfOKp)rT~fV6>G&dGhXig_(!X(!yznmDX=qV%e#iPUt|e3KX$g zn?3)%jt7_!!jFtM9zwXFu9qje+v|D7RF8H#@DqEdf)HMwA2)@RTJuykn(wbOGpG0( zl_^j7j@uG-LXuw`;h}J)H+}>zqHD9)Ud_`e*$@{&^Ux#=fc5WU`rw?23ix1x571_ki;f$yspL zQ)g*-W8+64uz9v~S`7QpJR097P9j?s2Uv*)1a@b?i)nC-LnU<<<0FgXGe$o}M06hI z9EZw%s#NX2Z*}A0_(Si9_$*v1jE&*TuJ!;RUMl zNgDs&@16&W@KN{sZk!I(`gnDCg6pAckW9sb7K=sH?ZmtZ(J0-KSr_FG+*b< zfB?;}c@A15W>5H_IA>14tX(){aOtD#wFqlT`-I<*(ES|q8;N(w*Z+vVRBn8DhE=Fl z=Ta=?clL(}*l-km%9PEY;p`Bnia`Yquc@g??^8D}7L0Gz5vl8Omt%WU=(K?;2gskf z9sAZ5%;A3?&F}S(N%gItw0OP>-$cGpu0HEkj=g?xkx+kR{BFcSS6U@Ca+(5Z>mSjQ z+Lq%ymf(g!%P*1)Lb2+CCg|Q({0bj?6xJq{URJ0x_!p8m6%EgfJG{CR&UT~o z4&6T-O}I@Awsi(>yMkqFnxNnf`(1YX=H(f-l6^;Ved}+M=%S9} zXlG#g^-tdqo;bZY(Y%)vq*y)s^c?z8U={X~AYx1&9+SwN&Pt=c$Bo_)e&1V8AZJd6 zowPRK#a|}jhYV9+BR=r`;k29XW<8)=<+=}xV*~i3Z~vuq+crRjXa-kSUMrVTOaf^( zN1suxnO2R4Kg8(IvJgfhUmq`O`Tk^R!z?hc83%mGzM^sUtwkiz4<-(tY zwaE&_Z0;Ac(?I*ETT}ar7k=t6G6f&hlPK`)V#j{icTXq)zC@-@N=9~f(~EX|U1wfD zN@L&&c21;s)6Q&d6#&{Ef1?wj09@qR=^*^^#lKb}jEnYGheAR^Rel)x6nJ&MF=?UU zrKQ;|eZ)e`Z-VtQTiz(tMv#HienyJxZFG@i>vD@ZZh(NqwlI_7Sb*SO`9-?$=OXjT zF8M!>u3V$z@!wk@!M*C>e*y0eQJI+uCa(j%bn#uCQ$rSN$e3gklvxxQGrxW!mPXpg zKFMP-c6LTg3`I2l#S$SY0in#XoF>M!BrdJxx&B_ez9+Wt$LtrQ@Q0>xQ=2En{lrQ6djG$?3)3&h)r=z^>_PcF&6Md9s$nl zxtb_N+dO0vYkGjsceI`QB~HoDb^+l{>Ac-CoY_3~!!fpRPVuTWAx^)4eDv++L_5_`tB@E|B^O`AW6r4*ZQmupp92kasW)kd(~$4AKr;t^hC2jMtv_Ek zOS~Ptz2%3&V2+QsPODDCG^_pyf&<;>F%BEc7TJSiV^Q0_c`OKq>F(9OZf+#$MF7L% zI$r6r2Z9$Fk>s+#Y;7xIQMF?w6HHm;iggXT*RfA#EU^cTsR40@I_r^6VBP_)D`t&@ zJzaVuvu1M2_v+IpCX?otFI|L4N4U(JRuGs2!REw~KV|E>uOI@f8FOT$)c#vY@8e;} zu%qWQ=A89MVEV_JrWjc+UMa~fY@o3da7g3>!_8<|f{flv_CyYDC;#Kr5v)FL-Rq(g z)Hr*w)nfM_dr`$A-Or0=wB~dzB8sH1ED_I!H9_BE_noF&cvL} zDGv7bTZ3c<1K+yuHGDU*48&XY+$|3c9#$65Mqb5jOg$e@Q3Ew&(ieP@X?1uEsM|;Y zX!%}4_2^G)QSa}bu+-oMvG!xuv?22@rC00GBNaaEu9jNVf9ea)#A;P$z16#G-|BCCz!|Qb62a`B+>kbYZAqAvQf^c` zq0Q_pU*q}XueJL*InC@Br)ZuO7xHB&ny}8uhZUB7$)D+=SO80+1IO4YE`i8d z=dqAl2sRzZ4F0fKX>PGt#D)Pu{%7Q0T}U?&|@Lj1YV>GNCWeBaY2mN!TlWXLb;98cLJ1|N5g%}>!z$a7+= zGK*HY3UpM6$E=Q*!JA8I6naj%5uVHkJ~Zy~Tg77kWCQyG1&{y32qxBuB)JGNsS1bY0L(8L)PZdKR(!a1eT{DI+23e#r*$u@ z|BdK5Mt>Sycl};-!(_Qf@~y;F!&eUDoDQ09;Fk zrU6GOmo4^jx~=4>L=L70s^+UCx!hTmww1Kt&`>XS_Tv!x8nU3QA%}(MtGGs}j8qs4 z=Dw>S)S}9xa^VQx*#K%214X|$bS)GXz7~FYyjXoZ7P%RvQ`AyFW#X5teOVjTDYYErD(Ff1CWKqAwdQ+5!I4)tXmuvPbWKbwN{UzE3 z-nuh~b1D1bRa-yUK8w$S)57Qv^xjI8PrhEK5T^v{BM2Cy7z%!j^kk$(U)6`$n{{8? zbVmVmc+rrDb|A>l>VT(gzHIQ1JxY@oRTF3XoMkoC z-UI;fgix3qQHib<>Bk8QX03q7!t{goz;>-YFTZ=h#G<4k9qOB>e6fdjmXy-%6AdCT z@e%r5@=@ERJGb#4B-B6f|A-vf#3O;I15WZ=njNE$p2-Zb-QByW72 z)#$eXsOt_43O8~i#$;;UektW#2Wb0KXPBMuzYyatNi|3ZChIu98NRa zV{}4?fK*QpN?>B7jeC`*K%XSX@GIg|a{l*OU%WLD&)zxa#z#B<-y5WQ}>}B$A_{9Dk!5p2XFWHiulF z0yIVj5e4!gV2nDCnGIQnhZ^FS1nhL7Ap#EtPg(BkmSW@vdA-C=quBS9$i|k3*WUSo zKp2&+ZO-h0p_SEJVlV=YeI5(BW0O$373JX25c6cFP&m*=hIrvE-1n5XnzrPV#&l|y z8@pW*CZ~K;sZ4jF*81q!nE|V*@7(zKD*{_PnPHq@#2NXQOhLO|RC=u0;)+eTg*9LF zJoS1z-@OwVhyKpmmv-NOQvvgC*`Q!qh9eBIp7n>PmwWI_u#C?2mF4M(h*%`Rbc*L80Hy9ACq|@Z^bA5;?kr*H8TxM#%MvJLXiP4@3SF zh%X*LO#Y92d(A)$$P0HDjXi0%A&WditrW|BSw}RijSwF3HoM#Y$gaXT)!(0#RyY2He+P z2vzT!@N)^J4qu+lX?gUF){?Y@W4Apxw$6@8l!flaFSnvOwsuntu5J6PyY0;YFh`j< zR0!wqsTY$hk8$_S;njv#^awJR8cPF?vaXPSMC7O|J&awCI}?jIW@Nvi`Dd%mTqxdN zX%k(kNmZ#yWHHI^bXuq##RngpI`Il@R|*V#%MczBE(>MXkN=a5#eaLtsQ(f-UE_m}4Z3In?G*k;6wwLXC5|w20}S?)sBTKhx%gyOGdk08q=K>9 z+uRwPUBDanZGt%Eqf@9X_J_O?BeZ#a^%fB4dUnQ__YR8ZR6DOlWYQolLy)gbge_MK zx{eUL=B?G%i`z+$=M^oV$;_y;nUM*zLe){3eBp?*)LmwYA|ie}6y9c}&A{gefWQL* zdlkQAa`daIb^%luZ~yp~Q`wS)CRl2e2py>&9!47vX~VDX)r-GD7OXiV@Wmb#a(>pUhGfbf9vJclLfmAdKD zg-k-#rn_KSd8m<@8OgaPcBmu*_D_+XbcAa1);VdFA4LZo=$-c!-)ZtPG9X$8>r(8b z|3xOUCN(fc99;D;qlUP*PbfSc7xvyK7)=mWryOu_PWqX%AwN`lj~){(wx5ju`hC>l zMSkaz{Xpn{Xmf*DW3$&8M>&%eZo82F#n>?QiwsL@z}da7lkH|nKgN4>@PsCv+*>Jh zmI!TSxm@MJ*_)mjK71+q+(>u&R4jbQy@@w5|7zlKk(~7@AXyoZXoK5OB{adIavEj@ zp;NRGd%}Vk<627vvGz!LDnEqIYD+wz=0xJQ_}cM-Pk}Md?~UyF$`^DB%lDZAjyT5V z%_+k~PJfoV$Yb zw3HUBp$;E_7abeJT=TuK>o_0M)za1m0@JyBsrS=hm0u0aTaduusj7M3PFRniZA@o9 z4X?(u?Y$3`SlcaUvtICi>LQIgEx8!RTZ(hH*u=W~j&o%rQ3?ct`;fcd&IhOU7!Q}l z^!Bvni7dE#H_k;dT`H3I=SIxKAmG^!e}hN=OM!fkJ6cz}+buYC5PFEcg3I7-d8%5v zv(nAEwHPK6`SZJ8)=YgcJ^R&c9R6lT$2z$unfYW_ldf{LI;&sEUz>G$@oyUQS_xbV zCF?#noe}7oiV|>gcFUGmDMBFgz8`7zLFKyaB`o5TFp)ztjCroL7Wz5r(F+K z7M+}Sn8ATs?3faUx%v~7>_|;fF)=t56?&58^Cx`<9uf6ZwSY|8yE90xFv`4sCex-k zEZpnVEQs>zDkX??VR7;Nr2X{2Vl#9wYvFkCm$Gc0l6cTodOv7QugD;g1R49^ak@8B z)$HG%u@EVl4vXN^Wl`Hy?oke6-<0YgJ^$3xv_HL5t2a*aTHkmb>`_}&N;A>^)l4r- zeB=bQ3tP!Vd}v_}&@z&pmKyrg=2%E82>RC|MdcIJrZs(-dnLsk_tL=`E$|J3Z)|fv zJlItGvoI|%lx(C!;E-#FHGxO)e}wOddA(mo1N2%&ZpOYjre)$u4)~lqc>B|r;R!O# zXGCvK24Bu^UYcjV1md}9>XT%Ut5t@)N0Cl!P#wM6z@Jv7y8NXPIsM zHpQIoJ7ZABw`QPu^YWq?HLYu3p#EM0sc$cZzBaWhu_ggr#Ov5SX#RO$9E#vj4XrD* zzfWOy0CgOVZR8jOwK#YvC50Vt$nZS2AJHf)&M;5 zkNJAxhy!668nLAla~j&|pqaGwPB2__&!=wv;s)pP{QNwHmyd4>F_kanLBtbSKrSzg z#XLNoNHuGuK%MKPUVSW>J;<52rl432L%Gs*=q3qx>fzveea;Q`5L=VyHt*@F;c1n z>r=ToIHxLO;iyENHRm@lMtJlyX6%hdo)hlOrCwbe23i{XWau0s5Z6(|nIjp#PkD}l z_=MtG0{~Iky|C}FC&5KqbBgXzY^=~nSL0wo1j>TYf;=C;Q$Xv#(S5%^^(vA4Q>Q-P z5Z%K+o;7b5z7i^qeTHWx7M8Jrbiz3-n2N+u4EFOZhzBc&=ssOXCknLSg#!tjU zdzgFn1#&E|MRH9R+xib#`5T`N79ie_s(t{nhEw8TXJ=$?K2*ZTGPjJ!QSp0xx5_2y zruE_7OWFhN;J55&?;0t#981g-O3P~6y(Rn3%D+t};?9;wKM=PG_ce!S$WMKN1mD^n z$7Z8RskqBzsr(tK{N5s+b4&`NW>Fa{fa9VwL`X4y zSIhu?Hs=$X-edvfEj|>}oePzqn)llEHa_+}=o#@5vLQ`h@(Qa1PCHz1p~;vZi?sHp zy*{v}2JGxS0XJzZKinQjSXzP?xzj&lX#$yaY5t!2fVxd6ivR!$+SxIZ#Jp(zvv(gO&FxyPCwI@|VtZHyau_quJ~dj5lW zD^#i*p@-dw5sS;n0WL8KRl3W~59i80s+_+JZuJWQaI8S@`jfIWDsi=s%4wi&0(lVS z+FimZ695vv!+YKhZf&(^CmmeU!c1V&0?)d;eAJa|?(B>)Pke`Vgfr)D?>2GHURJh3 za|`+W>}Jl`oPL@)>3!`7d#Z@*eAbcZ&B%8vioHtiUfX!HV9DSK4)HIj)#pY@4O08m zJdt~0s?NEtmO2#Kzo;EN+>*8&0?y#Zz`Ecip6iKA9S!kfNFIJhdT8Bn_rbVit?z&A zr+enSK3#WMo*V6z_fAD{7+x^wLV%Q@_?G-@b1 z!q97aX2&VAn9sE>E$F~t!b0qLw$Xco3{Kl$@un>C2mn-!dFuL+HRL=q(RLLhp9% zH?GV3k?h~6)cc}^Hb9ov9BAro?d-11jA&5j9NG?;r$k$2SX_kg^*^B%HaIwVkbbo1 z%k8SI-P|9}Q9gC;vtbZ^C!&yjybH{6E$5&ByE9HB|LxlCCAC!d`2irq>;JR>;N|tS z0rG^}s_r21OXXUtqd>MO#;UeMR`g&)Y-=JSB7Vn>KpVQpv2YBRdZ~Ps9cOK(woz8k z^fro$s6282fqDP)1-+XLyvI+xbC5GE!OLyHb zo$BvA_JwzOtVi?I)*Ot=({0bLLsukx;u=@IOz=6bPmTnq#F5$UzZn{rTG+rd#g7Qts)Iv2ffUXYLj&vD!AUr|Dxc z+9tafSY~2Uy&zEZuDqd}U>I+S56-o1b{J$FFMEL^V_+k ztl8ljBmcc~ytb(fh$tUj8^ToAJyJu`36Hc6avt)MYP?*5KwY=}$ z^sF6>q7pwee$6OJU{?K8Q(&|s_O$kbytr!({l|aH!O+EtN5C^w*X?s`BkzziYrj3v zd-QV^W}cctrP0yoM#&1dil8Yo)P0*@#LLNGjwJ1TNr=K)HgMp1jOvmm<+uoMb3Z|| z)2BGiYC%{Qe!iDzUvCPb1~9EpN-5q?FFvE2{oyf7a6j4?)Act;a+W!OlTAlMZLJe2 zLkARYGw=oH3J$lc^0=p0rW^1oS+>p7EO*ME!oj=>__sNHM)z_k3+fN@VyEoiykm2G z*m@@;wOyrB>B&6cDjcedyB?7;1t=4uy40COc*B-kt%!#)t0)VLtVZ@Olr@qvu8y30 zR@sjSd4P#Rr;;Mp#oy0x>UFz8h1hRGqB#uoO&oej4?0kd$)#Ye)+(ZBISSU06T7fo zHO)iw`@2WaoQJbehbQ^RgW>KzXmf5-F2RJy_clx%?>3_6z?*N7^}&Oe$D*vxp--Qb z+&Ti*V;|B|?!Pu{Ejb8X!*^#(_^4XEuUU9BxDD5=n`_hs9fDf#Zh7H`pP&*dBjF3^ zZ&{jT2lqWrsV8lWo%cRAquoPWVuU1`uE0SxrX5Gcnf{Zz8clU|TP3q`KY|1=>`yOR zreW@eoH#W5vk)4PYALal3J)sJLv4PbccYHm4zmRz>7hLwCF$zQtw6Q3Ym%nmaeAho z|M3RxY-mLY)YtF(a*RldXAn}3M}2W)dE*!_Kb+8V&~w#vXR0qrkcH6;8_syxhL32c6-z&`)*3h$B~Ge`W+2utRa?pCE`^S`LA}DRpRvX8Tw!lt;>4$ zbDL#qai;9;~-0U>iQ9}=5g9I$yY7s1r09Apc5 zvKi&{s$n9@>7ZarJIBOI+b()`pYP}nl_ zYw`92JK8V*93TkSX=mgYXS$!Iix6iIwfDCy(*R@&Vr?4IGnD-ak29F`>fu>e=L*7Q ztLq}2MfR@kI=xO?9t%s7+^3_&)<>eaXLhEDTtm^1DgzuM|EwM#L&U;uaP@bwY@5mF z^f%ly#&;*~V9o;I$;mc@ezV|K?Mt3s6Bbgeh+&iO;({ruX=0qA>45YG_>D_zYo7~M zCCcXy7mU(B_Rz2S6v3Zr5ZCXy#OS`B-59Px>Mf?&9}B)aY;ud;$W95e^2|+3MlRHR zVk?d?I?R~6DLVBhrgE^moy-JwfWIjoNJ0&18N`iTIW6)^Fq3(ww(qdS`o!2@ z&~+7co`27PEO zw^;RYnq8v~)Wl~mPU_Nk9|%**V*zm0Psy)9GB>NGC#MLUHU|nzWx+a?E0u3@G|MSU zMbhHJnWS@Ap4kMmTF+%4$Hed-XWY6;_G#}%|2ws;`+-vdMfm#_udXEC6Dl&8HinFl zOB7_+830m<|B6k^7ob{OkKw^WwP=T9X|T-n_w*CL{6{qVVU)83;|ELT21@4QTkfiK z?>Vz!Z7y}<-`-Yb{S&sg#(SM&Koc<88h zb_=upQAqs0cXHo!Wa!;xG;iv5pLa_jBLsmk5TzI|pHYL*2@q$xG0>SVpY^RAHcrHz zSoB}=_Yjg<=V{xaO(Kh_QeA0V{d$bv*vPFmgFblufAE7@7|Fj3)lMn07Q_l#rA=-^ z@dy~7NB!dNhHUVV)E?Z0X@^G>-w?!nZqJQyD@l=iEqnpy9{Rhk5=1?ny{=aL^{Vl@ z!(cNL;PUCP3xQon=O6JjFX<;A_NfIiL;G+89nP=4aF`An>=Q1zD=)_S(%0V>lI}$q zWweDv(4zxBV_I5Tjy=9hesWAip2wyf6NO{|CF5m>q7-ln3Cg80?OJ7X4AX60{E}>T z3~gVGh;-;ib%&pR1lCzTr1cC8@S9s$0Bk*dl5tk|B$+aw8p{;Z*pd8noBlANBz`0^ z-uC?p(bVRU$>LUN^y+4h8g0PUVy)vaLdSDBbE=Oe3_tKUrAIjMvPJ#6!2u(Pe;#Oz zbGOQc0w&)KVWpWEN}Cuq`h4=jw0yAm2@}-%1}H#&<5u6$@42_XZ?21piTTw>y`h^O zM=kKzL+D4m0}iH(A-eeKSmHHecaRi5a>1;K+OoX_G|S3@9Aw79><@^mxrBtGfj~(w zFz0yOx+miBUKLKmBsJ*yWVd^mO5VXK_r%=o?C)3zNHk&;DtrsHwMd7jWT_d__{dCz zPCw)JxcK;@fvscHdJ2by=jVq3{dgd;QlLI{+tARkV$Z1oW@E2^;=guc4qqJ~uwOHOYIrfIs;bJG&_7WCj{}WowygFR7<5X*T5|YH1{S3HgmhDY5BeFT@ zBQHI6iOfXBrO_}t)(D3*5H|M-vx2--_!>QSpAavcOz|-`{z^&IzE=Nv)&@vr@Qpn$ zPr?bJg(SAoWEXjfFz_Ygf6A!d+GIOjVxai~{k&7D0Uzc>OwPvD+i z1zSq=025LWx5XrXEKMQ4qG$TV^QskP9>_02#pWyg%y022pn?UF`2F+k(IAh>S4PyAdn z(N@z3u4k9CO5ukWgVAJ2H)dKN#Kh=OVLgF1QxhK)astv+$8b<=NFNNjd3nt{LgA!y zLYcT@yZ@$h-;dW3urvLVaWpZGqg=D!b$NiDCr00F9FTRJ{604X9$E{efTu_9+l`OS zE$OQv!I{Os>QCj`QRUte8vn#{ss3=y=VPU#tlxZYQJ#fDQtcq_ApUX zXQ{4qVU7DQ-vd_!zB2v_T4mM_<3+2GpR2fn9VU`H6#AG*NY3SVEqn4~roNG-7BIpN zw(3SC(QWvdY=zTG2L@=_7-Zx4cXoHOX>-%eayQhI&*x3mXjC=&bDJP9V^)C&TrZ(pXv#eOU%ul1zC zFS0l-{=x2=xzaLwy0(1RgG?S_V2||If2x6Sl*5-(L&A4G0DKBk@bK_3@bcuk0dLfVIm5U&YNIXh5vG0h2TAmyp&`eM3BFJG$bcsN zzvabwYwd*UO2j~w@HZWMbNWL~+H)L8hol>Q$i{dvP@I3FMb0&Quo#{$p*6@d4T|@Fup&HDS+0jqN)mjf|vh+asOJ>yPsSIh$xJj z*9QgJA5GQ&h%Yp{GO={o2h}t+UE>FK@4znvr>?Jg0Rl+4k$cTOUa-UA`Yma+UWv~Y z-%o81Ejyh24*l}&=I8zOydl|*E%!$xK0kDma~_Z94g(8*xwi{8y8OCbJt6@*a>mTO z7>IpO0UvLo(Y(a710X9ahc=U5TAVLEXrh7V=T2BZC~}tZ1lYmw-KUYouIrCza}PnS z+GX>slUYLL7FSyn85t7?tA6OHS0_!_7!THJG9@a?l0m=G6LtYhIKV5y7=)6Z4)^y2 zr;+`j-ujU}fivAXx!9PMSVu*j81X9PIcJgH?ze0uJ)N44vH*`Flw0F6Mzw=miLOW^M#$EUR<1eg$ zPLV$9S0auU2>4IGzD%o;*3kGP7O-{}y!x(0KH-Po!*vXGMZc{L`R?B2pTU%uN49;- zC=TFKPiFMo2*Z=04=zUfLpS}laKD76qwYERS4ptPGs`b7vTR<|C4a-oCJ3AtsCs%I z)w+F%3$ij^oBHZ0*(Z#e{OZ;lHiH=wv@w7o_?v zIykMQEb4-dOu6dYA7&3EaK{Ja5Fd~B=~2V7U$dVm-k@_b2TR>vOh_1t(oW>k?@cS~ z@-J##3orOSx#R`p#B10QVc!0t)7GXniD)$q+m@xmYznpiOA_~-){Mfs@l18n56+@k z^l!1l%a3J=0*Z+kfRd6OT1@`osu1qqkMnvcOws?>_!&pnxRzY>fl3 zSH(4`(p~9##wT|FUexp0939`c(UHTVB@=Llg#j5arJ_qGF^W{_ZLJ3WoM^5@kH^Oq zMo&(OM*Y-*M$fz%z3?eB-i*PW9VVbd4)hgWCj$cq44_LPfJ|{*&qSGm7#1jMc?xL{ zlj zcb&Mq*!%J~8<2udk=?4Kt%m@+8Um+@{U_rrJg%>t_3%@YZMZ)f&ZPsv@(WZ!d-MA#hy(s?LfSFnFWCgqZ#UWec$BKo8??(2dLFh|V znZXK-dJ#SdP>eE0l-P^#*Gxf@k$*jj zMm>M#xtdjM=4(|TQl;N_ZJ>IUt7W;-QsSs@6&f$%KVn2+(oRm1(<_a0uB0>6b zPUHry45Fl+DtK{mAyYg{%5j@w;NN=c9{fjFL!;yJuRLzCRu(qZVfM@8o=7J|WRlO( zl)pVfN%(w#6Y}Xpn(cyhqu*~;B|L=Tjd%O7Rdt$u-2i z{Ff4)7hzt1;7M?qpaS>_9bO6k_tH|?(?CRXnjX?1ZUyOQeO*=_Cj5(I53N)SMl0ce zx#5WOW)Od~kU2oRkt9c929SxdGMP_(tMF9d!9G4lw%D%8>1t`&KfvB|$|^=@2;lww zHFb*57KaA({(D;k`i6A#ll`78Z^ma|4^0O?9ydvJQc}_|+U=*OoYF-bw?`P=6P3D9 zud|n$vYv`B$4uD}b7StBkpS=IffE>6xDVVMk?L&)zXg&~JUD^?aD%SwGI`qxh zefkl|uDYsRZDjQRRd9Cesfpg378N!bdo%EtNUME|sVsmtr@C)d*BFfE=pvU9y0NJ@ z@OnHSuC1xTFM2vcXFxL3+#aow?A9sJV(&uU&|VX*M&Kfi*5)y*Klt@+2!g9R{H*x4 z5nTVwZ*>@HiuiJA(!E2j*Gd2IFLcq#$!C!JZw3S;$HGZLh386}KSjT!GS0uQ-^i5i zB(x@vEYSnhoony}W0otQ-wD71`dM$ZuRm2G!II>5{eZ1RU`^JFE0S22J`&Kb-DL40 zh^vB%UU|1HAQ*|#j&F`Vl8~mh`)REg7h;$W{LX)efEZ;gI^EHHmv$8_kYjU@!ICd! z{W+eTUKk8i=YGD`5YIkqGwNj26A%AplVgO^!z=IoXHS~?hK4ylaM1HGZaX_W`;XAO zdO#h;$(ZA@E9)Z>Pc`z_^n@3<0TXs}Z=HhgSG&A?uX_zRn?l5|8G#Evfc|Qj}-CgChFm^kR*sE@_ExzA_}#rK@qEfz$qLIn2xkwC0UeJyui{f{l66^WB82M*ZOo6Zy;ZK@yXK zAr$zTq86WpnhnH+?*^~WnEj6Q&NiNqR~Car6%X);Z`oT(4EnRtC+?-ZQ76vh{*q+W zsRcA$71hB)d@c*JSay%6`ttUpbD;rl2_)q11qk6C zsm=F1UI<5$Af0}x*4Oq&N;02!nOuc))3D{>PxxdFW4ka@@>H-=X&qF2+V&*AVLPzI zyijvVP34dr8O`Bk+qduglhh4Jc#?Vh5T8UaE`Fmce0Gfyey8<0hm$id>ch3!^;Xm| zBBAl>#hr=q;&fVsx_DSYJj2@p**uOoR{} z>#aXfarWSLDYi^8q37B^r%36KBM}5Jm=3%C^;Q~$^ifYMM!?;tRK`21giAV#4QUbL zQ^d{l+jwbrKULAC$_GavwR-7sdlBDhE!;>aTmjzcA?XGP^wAB{`FMyf<684yzJvHx z`6IR$Y51;jh<+QbY|dNpP%3MXOqjdu@3E$g2l*NW%XGiI2*ZU(PBFeS$I5-ixpYvK zllMFCZkg#Dcw4@tGYH`2W3yBhb&mE7OP3JOM| zydmhdxIZKi*I3khoh@*v4jnc9(edNSxR+9vLe5wDWw_E=5=V?KZKxOL~oTkxD$c2F50h9*&PQ z`<}@aA{?L)hTsDFywJeH_$vG^YmWG&<;s*^roC~|A(L~@`2R8W)lpS;Pq+sVP*Ra@ z5drD$E)|gO2I=nZ21x+{X^@uY(2X=m=b@4A2C2LGe)q0**E;f#aNc*<>}O`4d1mb0 zumTaXdnI!cx)>jq^yt=8-yu}a1Ag)$X?#Np+zd4DxgQ#eMatEhr9F^^Rn^`DD!_b^ z%w4@5JsIenWWiJoAm@fhyaSsxWKV8oU(2*Y6^cZ^`eXflu;hDAB0l_hrP#1-p5#+O ztXC{l`J?$HPG%L`&L-w#oV%I`?^#wGh-nI6zWg0bQ>BO!K$G?Eeby(qzK_B|+k@p0 zW?!mm6Q5=8tJSim!%h%o0|LAXfP+_E{ThF>hXbm~?eO>c_wV2Tu{P+bCifx=eAAMJ z?-2(Xa(Mrloq$e$Dv3%Vp%{c4#Ge~K;cRpvZ<%6YN5d8RHiwq*EFWKvN%p#Z3q?Q6 zY}|Utwpi&JPdhk}mwFX04kC;7xW6j48tqmCOxp`Zeji=gj|g1pTNLB*Fq4C{rt9-J zk8;-;H-jI)m!=pyJ9D7wzwmoo?Z4bGJXhU3WU5QWu@p0RgfH?EXvLVi5h3rKRSdYU z6N?P`-n%~H)N1mT_0A58Q>^K`kg~AM*X93tSW=)#Vf7u<$zN1yHH%_Ze<$F95BXCIZl+5hN7sPSzyu7MJfy03++Ov@q!2 z%a)RyEL<{$@+se@T}S%rmZg%5kF%g9^#^Yrc5$%-8}dE4ptzWpg0}ST zK1?QtzrO_JNEer}F~N zQ6H}c{9|`&A04loa{=hspusxOY_)58($vI6`^))5z1i-CCdp%$nh%lIFv+3MpuG;{ ztN8DSbKSQ_ma(4Jk0wj|&d`2=q|}eG%uI5(YH07b=1a`RIBA@JVA|H7atpf5h=sWP z*~A?7tv*7#CL4hB%978g&9A zU-s0f1Ve(uTarI+zG+W+9)|b3uPm;*Z4P>t!FIdc^oH+e1TKra2ka8r|EBlwhGs3C z+toLgGhlM=v$fDr17OnVx^LioNLL8ISpYO$H-J(|HsFl64RqaE9f15z&AB%O_tu{$ z>jM$1XU0)}{*oE{{~h@&o`6(5+fJe8Ykoqh3B1kyBgLl3goGfov!JyW^^~?KK|gYa zZQO5J8T$#ln}Ij#4!4|AZ-TPsOa&dOOp@D@IJSIX zFC5F%blu-MZLe2!{yQEO!z4(-x=kqPd*0c6YNW>Q1W^Yqv9c08Jg(|5j4dq(Uj=&B zv0s2vGi^rKxtfhd?hl~WLGN)aiT+2U!blg950$RCq*TL_>8<;|cXmRKh?e?+m0KAf z7nuul;|z3(ysFIVi`IKbK%~vQy*5?olU3KZnI0JSwfte?-;!_cX1Sr0#{2l=;wK8C zGVI=3NqDbCxxQ1Iirhr#W%#)+z6{pubLL+P6mQ>%zYz%%r?e`1XGNQr-Nm0dkPVbX zd<>Zs$A0cf$7sQ4`S8yVYNGR5bf4~je5vr#(Lb;UO>FmPFiH_7nqzsR$UM<^q}J3e zL)cR}0FaU)?mY_Ght*-m2tByrgP5bBXy15j)9*wb&m5q%{asa6H3R4lBvJF81WDp zbQx^qiQt859#nM@kItlr2Hhw%A%es2zm!M~8f0ZA3V$~SsfZfQ(n0tOkiVCalZ!!H zYIfi(wgfs&+A^Zf6Ej=Q^0Xd?(*#-|Mo@6YWLxH4qsm?A+Ffz)!ldP)x`Y;ec3KqBv zf8)}v=7O^gD8(D1`%GlkxsZzxJwfW-+kizIVF4iHnlYN7 z2xO`LtK>E8N9paPwfKP~8U}Z!aQgQ}Pvd0BzkVED&R!Da%dZn)V~Gmh;n`15>&^%_fBq6JEVUHZ zM$>(E!%QI7wIVM;LE&budFU$mQy{1RE4cIkL+L_ce?klM`7T%A-|%OHMgB*d4Q|e0 zuglZk^iUI}EI7~T7+~H9E>8aOUz{0*yN}wihooc$KF`Aj>Dv?;K#0-7Ewr_@1@$q6 zul6O;orOmPO?7L<-)}H}F(fxN)SG5SDHJ+c_IdRPdcFlH(UlW;SAW&XEiL4zF(YD& zga2JtR85x579LNt`F5hv9KGhD?Q%(=FKVy#?A~Sl9%<9x-Hrxh`RB*D1S17P779}@ z2IB^M`naZ4?f#_boMLARjWV-znmOO;{4}k)W|h<`ufaXH^;Ic*bM)DA zy(U&?KK`Mt&p|0Tbgc2~@3i!E=bsbzpAqKgDNU;!)}J-#$pRT{-*z#(t@L@TG|iW| zZ~gUV*J;dfX{d3juBQ2{qs7!N4HMo)csw2YGTY`!7Vtp&YGpjhiLrHIOL3S@jn5>5 z{^zUy-gcb71$EzjWfiBcUQDXCl;p#Sjwkn$-8y&QTSSjZjcAm!N;$Kp$Y?dqe~^^K zM##0KiNN*T54#W?-gvXwb%ymi|Tt@6J?LnvWKzNHBiE$Usdka6lFR z!lYV5TTXpg8s*HS?&8MxmRJ^Tp%i74GTkyix!cO5=-E$0lBihwN(`rz=HpcUANm+s z@SBRI8(hD=C9o^wl3Y&II-8kZipP{|DXCR0T-zlnxz`H=F;)ZFHtp0s_b{wzxdBw) z$L_8eL%C&}WR2?Q2NpVeQ2sNE4%>}#GsftKb1Ym|I_HiwxQT?UdhGZq#LbPXJd0XQ z*ahi_!`4|df>P^N=RH-W*L}+Ii#ENpv+6BVdM298pG&nFka;1;{Ew_b)XAC~Qndsj z{u4XcZTqTXKvy!!>AnVj*QA<&e$c{$qv^Avz@u$u*Vdt+mZ4GrkHRa7A=9K+{d?6F z0jd%x_7cemqPHe&(&_`H2Ji52TO1pf-;SJdd!M)dSSdzwDcX8p-~p_&iwj+HRmN)6 zIA`ps7Hq2d}bxDzjVDgru%PgWgoM54-x?r8%HkyWyL5w@PB0ehXvK z)?pT!_pErfxnaB)Y@XXYw&$Of;mE+qSPL!jHZl@t!Tf|SG4}hNVo4E$Fc~p%WL6I% z-J;pg#UwW z__7a`q8Ic^M)mI$WZq;~T=M!iELwCedPXZBSd?$1#9Jppv6!RUo8#1jpT>~~t2413 zbSWu08O@u~McohA#&TSspsLphs(yuiW2kXk)3wk&yK1!CsG$~y9D`03O&LGO|KY+V z!B&Xdi>!x~;DBbNf#4vHHbn*uW%20BHO&>H=EZiZ2f??C@w{T^T>GZQcR~@WqAksP z>9ZR@sVAqL>ZDuFRK>i{t8=ei@iGGw6C;;P)HxVbS1Mw4;?i{|=~d4DBpNdRq-aBc z)SE7|bnA0NJM?~|I&1tbpf(4$AGb!66)dsrlPrN?$#c-&SE5s;#j&&n=dUCAkLGc?mU5}S>agr?69F|mFJhN*TrVNfqSS$AF3Gs{cheIl*$3O}q5I4+#DL+` zv?c+Sns_d zmQ=!1@GV}4?j_kiR|37qAN1~A?NW7$lY|ld&@#J3ZJjC0%tR^nEa@;)JGty*j?$pC+Ux6{GyZQ4 z*kD8}oHMUR5jHt{B6K++LhGu|_s|4k6r%lUCrJio*D4pU)$FrbUwvPR6qA6ev2}I_ zMh<8EkdB1~ZD|K6ow=JEz9&&~e$Rg++ROf8XLpPPQR}ZIOn&{T<=o}z-clA%<3dfa z@V9wZcr?cq`M4LH#JqhN&rp6&f~O!3l;a#)JtXTTjlXOZK&KGSngYb^=7}Sg8s=}N z#??lrCYXoPsXRY*CU}Ih4Ml2z?wl3Gx<$uBdoM!he2q^DWV*NHXZJO2u{T|MLUcL( zbbBy~Cgm)Zu`o&ZWQd8IIA(NEhrDqyeaF0~S z;xSEYUC?$hmv7Hv4_nZUa$Ue@f!3!G9xU=1#zG+8A2G4@bK|dadAdOjV$Yma?T<&{ z;aWZ&+2-?GyRJ;d;mVfb_bR!KJG z$bM*5>R%|{N#|Jj-{>ye+>z=1oz*+<;m#LTR#tix6!{w@ z<2l(xn?Q~1zgwKT@v~K`TcNdAC=%qQ#?Dzua;7G>+*r(&)uD}`hU=vLnJ*&PgT_ym zTlmXv<|f4mK?!#ucFRS#EAP2acJ8dP-7ZjRk5^tXQO2!0+NJEPOvFsTW&0x9oQ(ZP zg&H{W$D?p=>7*KAMgENoPV~p{zbR6Z-E7QLEjpTevHU#QSY+QaQ%jw`$Hw-M!4L5t z*$7wFm-$Kv@Fy} z`LSeBSg15kgK}{<=||Simpttc)&3;zPk5AD{HEhC5Fd$tFydx#@X8!agA8L*;G9*+ltrm# z87bdj)!Kq515?Qqtx3#8(`U^C&#Qy(lkB(GTXH>d48^EkZ}r@xN8W0#=o>TO@bnVJ zC04fouIM`pjyUv&GMnNf`6S_aKj^F2S)NS3m`pQ4Hq^jq7#@*k81gpZ3i!@Aw^vvP z6X-99Tc-<*@7pru&|;o!K?N0e+3NVdLJvZf8MDHysiHw&4H>mG3 z4e~=&Zx<`|S4`5jO}y<`q9aru2o-SMt(fhNV(Ef4qAugCiN17ik=>~f^EimtSRxwJ z37B&9j@@blc$u7;`GL=QwG$By%}me3{mi2WQe(ZJ*7s8Q%A*CS1CT3t)W0fq`i}*4z#T@|eJF$cS#m|H6KV;*P`+69 zx>5TR_#r1*JYuB1f4-gd-$LQRFLa-HJllp57?VWvV{t|_J_}Y8-G3)tWt(`h*=};#T(x1DmnqHP{U$|rb+gmji<^h> zflR7p&x|%iTM)Tzv1Iq(L@?TT_kiO-|L=-pRvV{kA8!2A&1Yg$H5-Yxe;CRUHd`(k z?@C4l{0}n@zkB?dn*X`MU24YGYk&PWUe4%fwRAl0?T1~dlScQ?%W$LLHWV!TUxLK1 z8~=l#pDEldob{L8pL;s8rGC64sP8p&7?X+{E%tH0=209or4B!-yMs#Y|1{nM4Di+I zzkhQ;>k1QbNRcsCcIC^mfoh)g1-8L+{#l>MgH>G=dvCb6`h9!@$Bbt6OJc^x4V)qu zwgWl^2H*smVx$F4>=qJ?G2)@AEe&h8#=r&oO`+0RiZmv_>ID*0hU(8sb+%cMjjp(O z+uFh?uu{8TZ_JD^qoH)ePaD4Z{Y^_J&tds9ef&%Khj!%_pNuU7gQ2jE*IHxitZmfb zQAz!wko91ls^duAZyp;P*7B%lN=?!0cc#8LxFvZT8Ejq5*Zp!n0Y|=%Z7V}5q0$~N zwRR3>XyZq=PELBs26@R!zX7nMBqxx^6F#)bAr8k6m*tH|9%tZpc;PW|;^sxr4)po{ z_F+;c4XWI^_4zQsE)w2w9i5&yPh9>-CO?>N#1bXW@&fhCbSY757{zyoY%IUY zfQH`H9gA+CU`@?2yj*L8IQI2k5dJ<>(1Ld=6`cevk8>` zP-hOqeT_3ye%+!5R}#+AVQoJh`A**r$)x95S!^+P3^>fTr#Yb)U5a1aXFQaJU$KOU zrF|L@lrQveh=;Dv$Uf3WFM9v7&N##Lz1{)>q}ODi4_Lj&1ud!1wZTb;Ub$ltk8CL` zAO)-I>3!h4*v^ev16oW!c0ZP_Ye0_n7V|y2w@>8C3l0|=*f3Upjz3r&MD?y4GAAz# zD|npIFy$&2OuICc78D>e&P;cbTFjRvE$%pV9$h6-CIgZN2$QJncbK`PChUj1!IwX7 z=&jtRV5)RAd+9dCLvsiJ(!ps8plszn-wMu#aDa>EE9N8boviIAVQuKgD~qK@#X3(Y zo_q?N>`0kQ5mogWdRLkO{D$Ng_4NP{71oG9^}A%@E|3bNIjm^Ry?7V-E> zGIqqb!%mL%{R+qWlrL-a>rFQXuIE zuha!dI5M-aC@9n>?j9ZWI*tew6h;5lEQ9CHb4?|TGvIduYABcQgQjL_mG?41B}n*^ zSrh+-5$g-Eg;+Aml-1-s8I#0#(?b9X?_K&#^?JdEYwe_-qVUHY)w`xClWuS7BZ!S_BsgCN5@SEGz=Sd-`om?+Qn-TkK)L8l+j3X`tm-s(&rzOKlL?1_{3S5exf6*_Ch`u&JBs!zac9_@ zuD?<~#+v#z0WV^ReV(_mIv}ZP8T`MHa9BeB;5atm_!>ILX z$53IWOH~@`Th))s!Qga+^zL-n*>PcD90r;@5~>PjeyCK(ew==dR?y8yovBs=ypIz@ ztdg6GYmL57=tBe{B6R|Oi--QjC(ouxbeZcRJ?_IA(KhezXJwXy=P zlKi2}hn*{91IDSRHIK6O(m9_@-SMYO?B6=Oz8Uddnw~84W8Tu1ZoRCs{D*;UVggl? zL~JB$M}v@M3GATt+5_&gb#UXbiI}giua?N%@-k+*E1jt`Abp;mI%vU^haVn1kJb}? zz0e!hriB_clcn=;_jv?kc7{Y%l8<%?es{BFGJP`FWGL3L$!HN z1HIN=r1BH=Iz^+;2{2FI%u{myb?pO@6KX@%S$ zN`(8F(E!s$*ZU%r!$7vibc9s9_3k1fyF>L{AHF@5%m);?WfzwYf154?g9;PvOC7&7 zx7c9SPU0hf)(3iJG{XOdyxG+ud_En0==#k}%$&akM`sZ9|Y}@+by89 z4{Xqq+w|E`7fgfwhw9|av@Tk_GSp4KSRz5iu(!RyZVxlFo%Tzpo*Mj(RSV)7IdeO2 zW#KNxm|NlEI4hnKubF`-BF8*);8FovzuFNfMyNm; zE2e8@>fTgWR(|>;%%$P>q+G}qPOK@Ec7VOQq|u8nMP@B^`Rv9zbr*L)78Ty<#%W^eAYx*A^oOo8bNI@kF$hMvzR?IQRjsm z>d@!N7q|RP2Jl+1|N1!`iM7z$1n|Qf5EAlO2r$>N;_|!fR&$@NbXBM`yt|zeRq?; zd(*TK4utbU;Ud3O@9EHTWO%Zsh-b?ex=&cSTzTs0k?p&9YBkj$_(NO{<~7j_4GiD_ z@y7bdq}Eb%Khu!yWopZDinjVta4fy@=GP>bHX#SEXT68K z6sft|M`12lb2@`xtX0(bUa83#(xlHdS1ehhb~d`# z0*>TI@?dt>cX4}upr3%geW5EEDapO|)cPcEt*$ZPfu0Q8K4b!!h>aF7+sj7q8`=8$+mMCNPoYT1nv1`m zf?9>|KT90im7V;y9%spxHc^xw_qBj?(qJ$+3HX#VHgf6P8S7Uo=c~8OY&=mHPRg~> z%2Le8L170*EWuHt+A<}YJ~lhHd;2G$-H>{Rk7@|@ifW!v>v7q)9mFsB$JsMQNK+LK zIrtrux`Pq?4eA+W>xaMxBN;!wxYD6TUl-iKc46ev{3tm0yqX52PEPA5)tS8~O)*pa z(Yi}k&~>ll4&>{2p&OSjaQZ(|MgYno|K;qL&z6qB{$A|Obcfctgj2>UOiY#8`TmQ6 zER8nlcnpk^@{ZlzHFI<6FbstQ3N33&ByD+9N=9S1p$J%D_3zdtSC(}!AhM!+Vqglo z*BPk_^UeR9_F12I_IezCM3L>OrgBcumsQ5Fe&-oehl)q`a1rtG@_=}(>?cKp`cQfQ zrW5ry(54IKiiS2a>D5!u@*> zX`4iG%u%LQ8NXPPEsX#BDCrN{opt^G9dvzDQ}S7J|M430G3@cEg-aTe`{b}?tTx&I zTk-xJZgxbO{2E8$x8$2>^-9*PDz720wj)M2dYh@4&t-X}$$0X@SOk=DB5>c5Q;_s+ z3}v`mu5|g2Q;?NsW(-U45`6y^Ece1}AAjc9{O^rTh4}ItyrrxYisflmlG^T!VQ=T* z^g)bZg#S!t*g;Al6ml5Md}nD!&^VY5ZUBZ4xe7?eI!B5sO>oJ>CUZP7rH4M$>lH>M zt~}7r4A3$5Bjw83jXr1U>WLdDGe!=B7J~uZULJML-kZiPeq5JzdxhAV1%iVs{()DW z29;_$mrBF<4Vqyy0qzZ&_vC+sKbr5dHN=VOdL`3_@>IGr95yyPG+6WG#fc=yQ4HAi zQK(@tYcLIIRB&VQ`!Pj65Qc@xVSshD|&GzIq$XJ zgDy^SkU3{u2Rqqd@@?3xDpb*bz(T9KmSS*zHVW6ib*2+8nTrQGPdX}bM$pGMNSOk> z!~~mn48~P+zgC|-1A|I+pgE3)Z2KRI5$KIZ)z_0V;BCecfYA(bVZtX3zbKh2F4EG$ z*oS&JC-5tA9BDBiiDq1gv%CkiA{uPe?b;jZGP%PuNR33zR_upJyq=!;zO44XUlr=q zLorC0YbRqP>wVc>KXPWKAaX_Mn$hbH4J%i-C!mT(SzAxQq~HM~0JXWHaq!u=ZJ*Vu1_ zwdFTZlqm1Yn{L;%NP~^?F|U~N6-(BlA#~;Ui6^teUpV>^CPR)_#WcADn~>?(MDQ)7X4AsG+g+Sq*ONWqKri)b(ycEk67xV8e7KH39h{_m zKSXrWp13ezuTZ14f*b zq|cXAr$2u1@{Fij{~M@k?r$;Y4wKt-gPPxw?8wD(Wg%SInzvJ?wx5SrNJ~5b9v^$zD_f z(|mpP_<(5-S}o;6-GTf^rq}o^La44Hn?xznkRH69MlThI4hb^IzNe-VZMo~(OK?&& zSgyO1?l?8>-p!;xcZNJi3Irulv$L~iHw_oHjxR7kt&;6ZLERG5i;NPy&5hI9g>7fo zY#4#x#J+swwkm?-_=7AEiKoZw{CJjv!UtC}@weUPLmO?f={5bh7w#uP2H6+{_IBlW zL!b5Se;z?dABLW%mCX+l@6FK_m=Z*<+ufXUfnp>r1<6mc1+SOyHl=5qTK9Bk}<%o+hA;9_r9(G;M26nkNoa8A`(f0#Q(X(_eh75vPC z9QO>iu!tWX$R0@5Y?@KaV#jeJa(a6!j^~=~G>MPZb&l1wNl3=ZBprmAkoVrq*mYlQ z-oUd;z^(B7joqxSy0{2xNQbT+c641272WQ^H|QFlpI?e)zkFE1e2}LBIwt>*3oxa9 zzO|Pf zFo#deLZx(6)^*tC+dG&UXL7{6Mk8IuWKvv$)fcB55w6Gs$A8oVzr#~ZrG#T0bh z)}7KB^6+m~*=n?3{{jH3q69$^uwW;>zIWdkQ&tjoLB9X)Oz6=OrY856kbs~A5R-AP zW`J_q9jBj~la=D&WF?4r%+1YlLHHS=MgBYroT&^czMr#O@3S$UukSw|5tXlR?ix)Q zy_YIRblj;`rV7DS|*c!!xAQ$WT1Pgy(12@@9Xy09<@b@yG~iR zZ=70=;A%S3XyW_BVyTR2ChLSI;j;N2TCSG5iPyl%+~N3 za4Y)3caQX4om3j?JRGAK2_n4!}1TaD;vj4eBUbat7-yXWQh0>{&CCv8p zNS;iU3zmC&{)9;eHh|d1Q+)zB<8$}44@{eEE>pSI{n>x~b;YeiJ5o=pPp}F`x!;u5FyGy%Z)*Okz-(%0fCD6-!0vE0!04G_k})MI}SX(u;b!0F89=gI+xpSW0IebBp8X)mCr~eqxMo;(=UFH4~Dj*)vhI*m{@wd z6$z-&qubFjBmRv@3{M__>CCrob}js_z_&xR-yMBH%G+J*s{s*9M1>YpO8GWvqO`Hfeqw^+4}P+6M_8L8R3{%ZTv zKH+?xdhho7UvL@Pw%$a%#?U>P2YRnyHkaTFF#|Fu8oCdcas&=?`ybcf|FX zvb8`t-*CRlyl+7?8#&D7znHdyU112^>@{S!m-`d%0=1e3wcC71o}`pZHragv#pr~u z?TqiUtz0hVGsz%#C^ z%~0OUEZVqAP*LaVq-s7*L*#OOgxsc$!JAro_>9ixD#0#hiuTY(Npz4x@Z-K$tnjQLueima`z(aC)8Dp&O%hS)~>kUGr$Zlq_C z);ATc`M?P~KR?Imi!4Cc<#)~4>b}{L3}{?F;*$9>t9c6w+<@R0-E=n7NR|m}%IM-E zdT7_!rRC^^ptC2+I#&-%6MszNH6dqJB?-D?-Q0_|#jk?C70*_rE+R*}wdGP~bUo3Z zmWDgJgr@wbK6BWS_mQXJq-T>S?$25v2$6ZCSMWU~9`nkNfpad8qE;% zD0PM#eA{hPo0fs?mRO{MfzQL8dt_v!@+?QY7cPn5vi2t!);5G$K)@TNb2bdK&{jrg zS4Xk1q#8k#T%IDX5aP;_6@LW+4U3D5`Wn-AGt+3dlfNmsqr0Z$1VvfXe;XPRgj*@5 zq1q}ZqY@nb+IDg7uz?yZkLq&oV@&C6NuIUu3Cx_Iv;Vh*xiNypvjr-8kN;+#DE>2x zf&znpi32(e6}#kW(dUJ^pfksa9uM_iSSH%nSo>o@0Fgxw;oA11J*}@$-nBt{`|z-A z{=sGTYc~a0JsdphB19*LAz^aAj0{pS9j%fBI%zr(&Xfp{);Dy)f>e+$3sd6Y4F1aR zZ0zLMKMBWtMVd-P8hX4^PsjbdX&9qzq&!(s<kum)u~Zu>fT!mAWPsUchk8@YpRvX+layAW19GiK^uQC(puS*BH`P zP@^||K}4|YFWfG_WCh$?wW<=lZ6lZ!XD$fA3TEErct|#wf{cE0p2BnGzA^62<(8;fHr_l{8j!0A>$VC9BDQ7$-0%;DN;59|Zl+6U}^+1$xVO z*r(B|m%JBSN*y*izr3V)`Ml;}o_CQHBNP<-7JpYmaD5wPyQd=gnIwAs7$~vUUGKF$ z>_sfsXMmgC)@z-J+i_E-%X(UoDRX4K3sXp(pR~N7|8t@&^YV8QyA9SE#wv#MXF(@U z_BLU-$q10aDgfm5|4WiRj*gS5+;CRLojMpN>?+fV&37|D)tmz2&eJh0nJRXBZBq-X zHOUjdjrcDWg8u>`--@cL0C37cadgOhWBh@Iz_EiCUsE@1=fIIT6et~|3jG_4X}3=+ zTTvYcn(q0Wod0fsGSCySGJkA~>a(d^2NiEoop-dnZipNV^RGyGL5rf#;UW&228=4% z@-MH5`jtSgt)-=<0(M}1g2WRIV#KNk-j*k$gUj){FR;W$_bp)hi;cj^OF6y~M-g2QX>AzO*+hd?wYWVnYUp)V-S8NE-Uu_oZ4GMWS#ibmF zIXbs(O~g>`au?K*I&BPQk_0a~32^dDgK-~@ss z2Lb}Z^JnnPDKa5}g>n0!65KGUi7*zS2UEtf#~uhlJOI)!R@-$qlaa_0T2_-bqjsay zr^qE670m911!9}UMisTxREBhY46AAxJ7`TVxH047bc3^KT+^ zptDg!SP0b8>w29?oL^i(&;9$stBO066imULE%$Inn80Q5T9Z=A!t5t$6sv11aov``JU_? z56=yX-!cVE(?Hh9s4!KA>RF%&%k7VO%kjaC!3|L8Zd_2wfeMW9%$@`=!vFsL)ASgY zgi8CDA@}Vu;9fVl&?Sp3II3o6b_5xcb#HK*0w+(bVdD5q}2!WFRH_I8`mm2%aZEYKvGLDXp z_3mdT!<@BByd8J6LFDz;Nz*D(F7%^taJ&2?dj3YdS`Cw(y8mXvhu(GAIY)8Yp}P+ufPO~iHU6=90d0pS^VQ5>Tj*8QiOMU>+xrprW&;V$-Lh;bpx== zsO3Zz(o$ZInZ&5m`6WhR`V^V!8-4x~@mVQWaD(9d7_blF;o%0)l?Z9aC~^vL$8KkK0qreOoFG71 zL%d&qQLYT}pz~*BFaM}z_*9bs}efL@689!#*GWeA5YNlF)&fQNpEoZ7V-RPh-X$&&R zFyRvuV+)nIh-rRp@gnsoh>S0oFb6i)0F;jbC) zy$0$4Lm5o5hCT6HsSnAIoG$8X$(lLBNpZxJ(9X0%r7U10K>P@`dQMwWR(7}+A)ro# z+~^sYUvPrK-4!vn!)t)U%^G4;WADHN8yZ5(FDPIU5Qr)&D#}M_Ce0$_b3xO)TfG zde8Kw4kq1v;UY#dyBiVHyB>njm^KU^TvCGSFAM>cc6@w%vmH}4n9Ii9#;%-oxs&X5%)Z2%xr4;mxAu!CP!}K>$@$Xm=T}L>c+t4rS+kakuQdZ zoyQYnVKhTpbSO?Zw4ojX%+%iy5cFjV<5LMwrla7U^#@^EIywxW-dh@F(Io;N-mx1$ zFbw`cK~yd3%%kPlqovU+e|$qJoDj~H23r(l_<=AkfL5z5wY5~TF(pXDnzyi<-NVBk z+q)jymGhm6ckkn2Ea*`*aUWMef`Wui6$1heArSGS2zE!6@Gnz*wtLa3-B>P99&m#*+wl8RFp6?{GnK3RrmBf!_5e z5gB_=d;3@5t_F+^VvLf2>a@>;4=&ArG6cRpwfvZ^{PGTvWP1Bi|I^dpqY6kb1l9nA zt|RMx;9mv1I~tei1ff7MNO;c&z+r<6es8TQYzy4qL)Y)d-Kljo+W$XLvMGZO0C9S9 z;2hwisouqZ`{y7$Hds~@Gn999aDdorudb~v4yK1ODPBO5nl`>a;Ti4pSxW1_-4Yz; zcfM1t<(CyxMY}sY9dp&DPnu10?Cl4H)K5u{fW4V=*Wb+!MbX4O0f4-wm|Q1tZ?&K5Do%{P%pGLI`yfUB4CHne42B&v6JLd?O zi#^*#>oUt2SGA$mwJ8vJx)F&n-eQG=6gfz&CTM?Y%9b_yU(V)fXh6#L>(?i~gam6! zf)j;IlIrmD}Uo ztXmL_6dXTU5`MSiL?Esz+?Bxj4p7AOHEI! z*-VlnY%7e6LF{I1Xh;FSioA_b)1}=w0{X3YXs17O4tb^8`XfC(cx3CfnmrrEWcVU@ z7FZ|nrZhl_0c0$J83-|Br}fNmvA8;1T=PV6c2DQFhX);DpDO>x78k8)FtyFoyc`^` zz|`Q}7WaQ#E>NW8lgAs%g=8Sc3B_ zWdnIf&H&#ftlMxcfQf#P5O-Hxw_Gi)__sYVs3Clb5?oPHLGIb=BE5HEQaz{2UXr)F zyW8oHfNZz+`voz-n>_KU`FG^9q$FJ$Y*5vw#v)rLA?eqscuXYEHS|FwN!VH)dz*K= z-5+5c;N9F=Z8@DrkoOHAGO3uK;&8&AiieZ^3`nFzYYx*puHIYS7d&% zvBuzl0}ET+D3O|d+Abyxb1wb$i@nskbn;}q_o)pUF}EEAK&N-N^8!e^B~Q*7XmTY+ z&Lrg1l*L%rjslLkConkiKzdh5kcY<|MKo#bQq>gm)M3>snoras>32FB8Y0}p zk^tyROtU#?=Zff9fHVCBLm}iq#Msza!V794l}0=|2rKGY`cwrw0QW#U@HM1JD>UaA z%4Y1rbTM;qKXjx$-YbLM-3TbpJt_{Kyf00`aV7otQE1LIVu*V{U8&3 z4{jRZ?fu?&NJj!7M)vtEu=I58Hco}Ffl?M4I=aD3nNCg=J*((uOHzT_l(dJBq@*%% zH<6H#Mwgd?p3Ft_6sf}@|CM6RRLUbit9X5#7}%nerE5cdwiy1T;50My3M_q1O^`bM zwB3WX!`%VAbJg!(%SXM($IRgQ;_~>52x>|uAYB36T!vJEvHc@=Bco^FfR}stM0wzd zLWmRpfZZPeV(fTu$LEui%Fo)5UU`DMr%JOF_)&&{Qd8n@)q0CKTOTFLyK!;U-0E+0hK?5B?M0C<%g@G4iGlarI&7WBKK zKb1pf0r`j+0~wU(pahG45CiU?y^M#mvx+vCc6s5o$1eLI0M0Dj++iIZBFFqO$fRz< z3m?ekzH3DP?t&F}gP`p2bu1hkvFn9)nR*M;|o{8BA3dwY3!Xro@L%8Z5psI63Hm71kE zMP^z%Jir)9j({dCEF2ucd3kveybcx{-nC|OjQZ>|rd?n`qN-=du3ntOQs z!wxE#h|uRLWu|@#%K?1;8Q&FavL9&LNRq#N>1ZP@kzMu_nULPhCF)4;Un<^U2OfUVi32Y~DI%EiYybuCU-Dl#{#Iog3U|x+K$}Rb z@x{AI7|gXgJ?=AjIF?UQHEC%ylN$%mwqc8o)3@4yA(c7u#oYV_P#8h~@QVm%x2vnm zZMUcZJ9jo5e7*Ja44x<>+c=t0SQbEhNpN?%xy(rsP916pE?`Ib&5|sGEZ>q72))8) zK#Y;KhoHZSQ)yEv-COy0k4Y@$u=sfofd5&bv}=LIc^r<#}?Hb53&*bvJ*m z1S9-I|KSn`1rgNc{XM&}e&KvNV^ZC*b*AEWpr}xoG@mDIYpVZajQ`kyC`FS8)Ki0? zgu-_-KH;Y&2Tf&^Ww75SA|-!#<9CMx#VI_0jp#wd!Nw-WI(Ps_7}%f;aN~}Xhn86S z{@Lw4fLq{$lZhJq?|VYyLeyWJx@s93?9S6uR-h_GJMg|JK3fp5S}H49RGgn;hoX3V zBuuvPUh}(td%0b@BoT@Cx;sp7mc7;h)R3pU|X=IZ7a|+ zf&-=iAZ2+PN?D!>521bbLd%l@xX;W5>l;Wf5gSF=`S?5u+PMY}E<6s5e8C=nyXt>{ z4hC;n*}i@PFj~7!ol@Z!)a`V_@Si`?qO5u?3V@V=f@nvqwiayVTKJmilb7OQgS0XBHs=Hou2W#6k^N(GZtuWx z0YaMqM~i01?$TTwJiB;!@Og4M!50^X@TBY6Fe_vc$y8TYqdRw~!7}@eK%-;2tcFE^ z5-QbKoOrt8i#A7{cYF*`&fX%`SgZAXN(4*0RSi@khq{%&9b45zz5jgE-ZfT zQl#9O=28iI+H50DEi5b;o9zdbLo)&P`6^*Y9BRec^fsGuk?Otlq7BzCRZCblOok7x zF^=C(U_|0{127$ex>kSKEgZ@VJt3b=Aw3S~lC=MQr84-+Y4DXaK|5rgemx+@#hD5a zV$}5BvZd<}{R{B#(&p{d18x>nPF$*GizJjm;m-6`T+Q(sI?Zj1!j(ysDu@*DeIU z*Sq7^O^X%RJKd!b~pk?`-xlgPa@JR`6L_QTXUz&)-T#{6Ju}_ zM}Hd``*{4l+7_T=K=VwnOhhib&<3pF6q$&@Arn@D;Y@$sTj=+aI?z!hcERM`k8j$V)^f#^W3{N`CTRN~B-Ar8diy3e`vvUT(JV z5n}*iJ9wme=`>28bj+BICneSxJ7!DbQ?5qQ%br-xIo%EAg5l==Y2&~F%i&Dc)+4Y+ z8`NHx(kLf9r3l8A1;)jMa2=8X%*Hym9WixTu530VrgMXXVmn{DEEt!V)6DCvI=1JG zAQT5&3jp}RPe2dH{n}sKGVg6(AhrlFWp*g(ID3J%EEom*aVY|L|LjJ`t?11S^{IX8 zTVU<@N%4AV-%n17>DXlUt^;=}c-Z9iV=dMt=th+@*g~+lXB0<%O5vXb=GB4^{NfZf zdAVttb}{W0q;bI<`73-&mos3s4aUmYPOxE-`nj>m<|$(DqKoPjMRu+F%~>H0R)O>y zgnTo9%e~d`kC(eQ$5W7_g?x(}gMZ}fR|uS_t2>CU!ZFT-NJ79UxBvFX1FKi!`M;;^ zCc4(sjMn*w)%{_X39e&Qd8>0iXN3#iXE%pw1BSf|-AiaIH-5X+GI{94YrvUm9E19N z{T?t6ev45X_g!TSn{?kB=`kj~MtGN}*oc(JDz!l~X=yo2wqNws6h7pl<}yThNZt{Oo5buFYexfPy|?Ik($z^T9_{9A`>Dk_-K46N>nD>>e}F@hxmu0wo3 zBulM%&h8yHA=Rrm^WcAP7(LRvO=j)sqn}M)K^s_gB=k6 z8D-*GvR?2?qTbj>yK)E);y;Y>wY9Ygw612flq{YcNqt6!c-ewiF}<(8c0=R~rR%09 z-}}mCw+dwWoc{fk#_z7k(vFNPexi=+S$3w(!W6&a9IHakDzN(0FShF zEd-eoP;T-JJhg;3M%y%b;_!lm2IZWj7=Q_bk2$NUaE?W8x_zp+K$&z9toHlK5*sdy z2@ju^D+JLj81PF@0J&{?Xg~k$kooyP3|#Q8Gvnjq+a_GiR*HlI`ns)|zp^C0TO&UG zZ5`(1)&AUDm(r3rS?0C@W;7D&<<%VF0(b~eUK2vk{%V6+$$_w`2)eHabs2yzzu#)A zuy?U{J?3gM+LrErYTfV8RsR^T-i4fLK#~YT-1Ei|6r5XWMvKH5n3!(gJR574w|?MN zc*~r02rMh;dkQRTIqyMK7+71Kub=mBp!-LAdtEyd1@_m+2E(ZN?9Uy)Z5;fcDy}oA zsVoX7D8+yhq$pKDflvfSQ35EiY$&2cFo`TJB$U7a5$Q^C0SO|YqLe|((gadAfD6I` z8l!-r?g$dWAk~$oD2Tw~xUz?JW@q-z`|)OS-<{m=-h1Bp&N=rBOsCFcEff)`Xai+n z92t~rcDRRRQ+Xh=!Rp5Xg&I|E#V=Rg$HE(5bsDencs%x6 z-Y}wHzni6CpMtMux-|GYc;FHnVemFeSyX?2sKPJaUR|ZGHkXz)@g>-lj%%{!fBKla zZdjq)M&QK&c#%W^?$d$hfAiv|wi3Yt0|$oWgU+r{1S$p zyO2SUrfP^UOJKTLW*K6o&W)f~ZTM_-Y`Qh5(E|iOK&B~+Ftt5p!qMIh@WD&I6H#_D z)-8*I7j&~0mBcMcKqV~PcPnk3*1YfUgeM` zDw zr47NCcWZWBkyO;ojmLI#w+IhB73PU_5?1Ys7#|GI2{I?lic;4Ec>=9cynj-XI&{e* zvP1ala*X)5JfI~&&mb}kDvMI&`j(v&o?2tNg^zb3XNFa4LyBQwG8Lc#VUrfIUaQr3 zy!|$X?9!Q_XDHCgJ+)%rBwz7ijAj#S{ofEB z(BhW)(@i|y6_nU$8KR+10{r0Znz5)1jf9xw_^OH{=;A*>_Xr-=DUDR<8#I3>oD6 zv$poV9@?lV`r9IpX2rLPi;s3AXTlqdtOz4W7E=aXKQ_HO*lbbK6ovdym9sK|L`8AG zx7AsrA-z)&D~3jWL-Ww=;C5SXuvt7{)zjxlt>bzh?Q1SiR1o9Wo61BnVyg-CAOK+r z17{uxqn{?uR)nd?Rf!co^^V!ZBu9kBPwVDh7b^)7z_3CbL*G{>PsaXpjP+F zUA(oUQ0wCW?dT2b+R7me^kPuj74aH`8^2O}IJ8(Rir3RbCBDo-BR$I;? z9ww6+0{c6Y&2ZMu?LbfAlVzpG|3XX!?XU5xwy;o^nsrB_!@u;-POi9&Wq0}AbxU$J zFkq+SQtc6Di|0#v^hD#%n&UVrcA~tsRVxl(uP%&W#eo-h4#xG@W=fDrMv9pzMun`f4 zi9><8z=gku^*n9gpd%zJu2hgYA9XNk>u=Vi%Z#uyKlFotw68Vlc zzpjKAIQ;tLdZ~?oy`8gg)tr2MJf#H%VZH*+o<1-E4{t|7xV;|&=3!@#5d1BV_$luL$P4;- z+c?AR?UdXcJ-nTLoZOvZI>5X(fF>`0Yr_5itcjBi!b!l+#^+KTboWx17cTbxFgGOP z(j4K>>=8aT-aa%e4sP~vM;|9zKDZs+#@!x%IkE%9-3IRL0EobB+#DScPBy|~;&zuK z-hv1%oLdBXR`Bq!F|+OFVT4?$=i4SJPCJwxkynLWd-f9MX=A5xIp?nz2F~xLvj1GF zFwE`08Xe|lKC+r#a>Z2&_ly<)KAO{CKJ6lmGzbH(|j$hP9#ExGIDk08q0~L{U z5Vn&P6OnT8_&KW;uyL1DczFAZ|J*(+O*g@J7Ca7H*g!fkwz-uC{q z2zxgNwx7nA`{`kS-E#St6GuFQA-&!Fx&B@DUlM{p`~LRX-#hm0mBXA%WNwgk)~eLr z`3Rd*M3Dt=`(rXvwI8f@1H7%j2Icvm2K~#Seh+KV+5KR9cL0xKmdC7x;Hz23vEH2* zE~OkPD}~Tqei+x^Tn7Z=R{ZS-zdTkL_TL=VzcdD1ft&Qw6$bCA=7S~K3mkx3MhKsL zXCH)*k%y~2;J^7WUmG_wVhLyju?Q3s0}KK_T*Jn@7OfF|Km^9Y$crGR2QE=#fH8$g zphVbs*3lYZdrT}0@D&g=JOZ2Gw6&z>;#%3O%00z*VDd*8B(i7B)GCv7rz(l=8BHPfn}~gc=nf(D6Yu;V=Oq8K~6d z4NP+3KQ|yo-hfjB=SW=?VqmBw3Y8Lv7-}d1ry649>~3%9W8?1W40nX6C_$O1iG)R< zQcy|g&)02gA`wv`VW@<#h?ta^)NSak|II}}p#r}a!S&Z7ew_v-B_r*hvjXSV-4kM9 zkMIP}gS|J@3`&lT1L)f)hXKaM{rLeCjDx8R!qVX@y?KOrQN6r-CDr7WI5X+COr~@z zWyt!q)#!L7!WpTjKgMRXda*l)j@=3(zz?Aj;20<| zup~wjF!%xs3ljq;3`%&}CckWBKtWKd%NECFix7&BjmwJ-zH$Wz6Bi1(ybi≶GOt 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

    ^47!~IoX2fz~-r2hwEf}+i#ImmmYhpIh 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ϛJ^uq_Vfr3ha>G6iXaI+B|XXyv54H zWRQo$e*WualA~@y)Ey{^y4j5(B{dbV;AFjfW#z&sO2UGjiV!4ReD3MdW-b?6`}U-w z&Q%>HL$O(v&@eKeKiGv6uClX|k*C=`e^!r*z$T3wB#l!-wWg6J4w1#xqomh_X_RLY zbR9QlusB?5zFY=_lyvve{u zQEqs>*zQ8c650C(B{igp#sT%H)9;o70J)608>n74Vi1Ns>6~*hOYrz=DMVAAVT<++ zE>`x)vB>N7((qtDjEV?NH6ptQdzLxPevJc`Efc?da?ja$tM?k{)|vd+Zy)|THK3x| zx;(w`M3ZqwB2@?D@6hFRZOAq9*C!HoJV7@nKO?$)jE`H&d(WfpWcSLx`xF;@ZXPo_l(j^(fVkwxi=ShPEC3d zI}#e#lYaITL&z-pjO5|$PDwEY4wHU1XA~6dC~wAF9sGVbqNYMnTi7$CC!7RH&J|9`1W%Lx*#x70y!L}vv@4LKw>I-Ynt9rYbh$=i+f+1SXAyCEG3WJX zxhQ6sSx7l2F5@wW{XgmPBp0FD}rqiTPmvgy0WDj&5u24BcRP39gdE31Cr^&Q|L;HCvn zPcH|C;(vBSbIdM4cfQB+m4YSm*TArjV>106`81YOZ@jI~ydOgVfo9l?7~}+i+lvaO z9*}dg!>oZrQ)e=`YrKv&^smpdX3FKy9X$M+H!qx;Za7A>Vk+`tVzjpM}ZCH97hUbN~4 z5Ym`yh|TF4X@Bgi#wm~bA1GN~y(0V*>}B%xesfUP5~V*apm1EBiG8OPQQG#9u;O_s zY@w4^%iFrscqX+TTHF0lwSzmQ6=|0u<_d*k$h|{ zKk#*53HxTq5K?vPkD`c!9(>-XkhAO$=mO6HN9v$q;l{ zZ=UO2p6}6*X9xvL`yQ`;qJKQ_WkB9+wHn_4j&j~%@Ldb*u$3+}w@vy^TKUUwmO-S5 z>GB0#N_3Xf*fH5+&YE}dhfZ~GQJFzV7>38+`SkjORj*H!6NfpQd1zLFLTAT{br;pG z_4nO&dCKC}4JAJKbBq|#Ba#ffbDQDIg)a9wCrihq>kMxI>4tI+Y2C`icE&xl0MMdm zf>Rq2n*e}ZCS!nwpGS~%@7)|`Gycj4(C+8dWevaQvwULAvwRsfA1%)tx#iqIg}fNK zVCS?uaCxpY?XIbO($m>v83k7_>-CdzsaYU4C+FVUSwvBd^J*KdaELRi?8I|euKW9U zOf$39>S_pRs{Ym_myxgkH%bFo$W4t68Y-;gZV|1s^;!(9LfiAxpMKc`4@A??{fwCt z;~%GN{^)sy8Gw zF!jW;uFr5#*vtx)Vj5~*G>_{9d&!oXdeOG@zC@l$M*fDZUV)LZlEql;)1P6zVPe^X=JCO9Jk1OSXwJB;Z`K1 z)MXm&d9=h0fz(?+ylo_}c#e(R9{tQFUJ%A9Bb+=>|dR2Bl%>Zs~5MySp1vQi%bi zQ|azb=}xI3hVFRh`Cixi!~O@(KIiPU*Shb|ty>rqB=}jlN_J9IEivMFxqf9$E=tbO zkfN&fQ~-;Z1CY4G0Nz)n3b@iS2w2iAiNg_(abn+B>G=FP?QsiRcK_F<59Bn^iPYY5 zruEUkz4dWc-sncn4rymy|E?PUT;8TRBkbblZYx?iy@H$S0iOk;ES2_j&P0&DJbx>N1*2M1!S+EYJP6c z5>Pc901uqu3`S7ekd^cv-rDm@j9)&%iwz4de<*;ndB;>9ZI>WXl~VkPvlBR65!0h@LNP@km=^9x6e-lHH%pz) z{D_T6h8q32N+G^_1>m-N_j96Yu1hfiA7nF)5c8v=VRa&8i_aO&C2EKlXB#^F!H4GN!wZhoC#;}+?i z`LNf`#|#ce|4)yr{BGx~+>`mGYF?z@_0#C*?6k%B1Vi6Aynn%tjy4v}|e~Yr5 zRO+^N_xE@HTLXU9+weu%XTX_xzo;#S!19v2fC)F2{g}%TsHak#L3Bz&xf2P1e?;tt zjGt3gCg58#F#|Dr2p^&_qf~AKg_E<5-N5IC-lnadC$R`@Q~lE{q-Y*K;v`WmL*Wcx zF=SrvY7LsjXte7$*&7lD-l_O z(k#se;z_<*iyi@h$g@X@HeG7ge_T9(vvxuS(#UGGp-gf7u#N2HxV6lHJP*Bid%eqd zR)%K;?(Ze(^JxEuG`?J*u0M>D-K|<$Z`p~qbT&z1H#s%D2w_I~D&)@zez-DJ`Zw{T zVj3?rsJ#QZ!Mt~3xrTx)@r2sWT8skfsCm%!+rh#?pI=6JO3>N16Hoh_`rSHKT+ z-P7il@@%=x-e<)UiSYft#9WmgS((|b*)~mbtIm2$)hkUf4}djQ(c7S&KnlkxqX9;d zLw0;)+!iXry0((~EG7r3QCI$s^Mn&Rky6uzsM-2(@Y2x5m!M0cjg`by4NPpWM*!d( z9OW9>$rB`|3=!qBcKmz$Pe19Q-g*4n!Sn4Vb$fFu|C_y*r(3VU_=_?OgHM+uVc*zw z9RrV*?R9I>mF#$l{FM|GFdwdusu^^1rAsg)R5iKy!gu8yU%aFnF}{Db+x>H(N)$_5 zP2@vP;T*z7#DfMsHY0#Op(3tcNZ{f~RoNsH{uODlHK8M#HD@0uf$w%G{8 z8gh}!czstkO7OIj2el+}@rg)J*GBfV3WXT`t;XFcQu=1(4E-Y)aB#AuTxYfNm+a4% z@u;TPP(gx>qYF5H9t9~1yC?m$xudBM8=!of*RdVI2?LjTGhd7-gXxF!$GU|$?HvX-s$OA5NGLJSJU69trT-*F^Nur6q%8l zFAH@4LCs-R#*yta8W?IMD(57s^By?0+Jp`3I9KjI zU%@-^-o3vEa>#7KFV~Te##wPM586#TI>536p_2P_ zL1LEIvSG?M!qPYTBlS2>-L>bXL~N%8p2}JkI*DHEKEUd>3yhq=hc8cCI6+9~k>j{noKAEamb^g)+tYUdPpRIFgwY5Cm`EqQ$L&n6F0l!1v zs)V)Bp8{hclfl_ah2Io2Q4knZH4V{6>qJ~s_wn}eONs&Ce%Vj_u;eV!5S>N%7u6#8 zGdrLNwZro|-9_=l8`iCATku7j+kS-ZsDI}JpVNgdUqv7f)@bk?FCm&6tz$^TiZkv~ zThc3>$%l=t-)5t>exx$YnWtQ#3rj@)tG6(%o82fY*iFIU^PlLb`u_IYEeNcP@qK!P z%iw$y8>QdDahvdIToIdJy(&`(DVd1i}- z{rkDSa(XJ>Q8P2Czp(l$J1cR0E_J_|x=IXZf{Ww+g8-c^+f_5F!fYI(BzAcyjweog z2Q2Uej@g35+o@ZBdJ+(H(yE1L8UsCv;SVWP;QD2-ztSB2RNZSTp+}@Cwu~tw?LH>F z#bJd5O)alu<0i7b;-X3Lrw}sqk=uTd$H;bD*@_zr77!)IalJT9ykh-JTXa|v_oo-n zyHur~pG(RBV&wfCf5H)QjQZ>y7Z)n&&B_U!{0v z$YNSvB^*Js3aviW+kk&9HWpVWt*{SAk7>X!_^GM9Tmkz24wgsB+^m{75YLZA<$u;W zWeJC+mz0!r#n9)V0d#Jw=MH%5PyGt}U{a1@~n*Aiet zsRrp(3oeVlemxqz>GiV`?kZfBNV9rHcs3y|x^1xT2R{so6rEZ)P?MT!ngN2*-Mk1r z9q^GsSYb5k6f(ZXL?z?d|xJYq$vzuk@IW{pe-x2rNqv7%dq`s1% zRsROyh;+~#=SJ2N`v-&EYZcwwZ>H7WuvH3qtN`o4;T2#1F;dC1o`u;$)Qv78J};N+ z8b81@oW62xHjBB8>0h^C*T*`%!}zDh#(!t%GU1Wfl!PJ+o8K7}0&fL!a-VBMw?QOa z_{nIOOeM@N2I07J;ys@~s3}E(wJ_%L%wPFkSWb)eO0ho#n8p<0K8EKr@OYH{3+oRd zl-VlcWKB_(gkhylGj7;RS!awE!9 zf5Hn`$G=kw+?Trl1LX_uOFA_}mG{}pRZms&<-jyMBcoUbi(v~sJiZ2!LX)kyld#dA zm}dC+*UAercbF~b)cnh8u`7Q&T{De{ys@p#U~VMD@eA}D!ss)z7nWwbFkzg0kxgjF z^Ft38s|xpIVJTUW%hbnfMW)_5+p1D)?2MC7T{CgS(KoCJocDgLcA$#DXzVFvvYU0D zuS21p79sB~m;FY>gv`w@6Q%7JAM$Ya!ohlBj&OPb!vGFH;(M!}_zVv7v|yi@h^lM! zMONr)0t9wcQsBz&HU_+cBd@cz%3JtLl_RaYw2yM|Asf?53c+ltnyGoFgG!9+nEz(o zR8HhPTUZldPCafoPj#Dj@DB!UTHZ2QTlp|sg0P6$;fY=I1=`s=QEI;N5N;)-ko!8r zOFT0Ud)YDY`5F~AXJ=8{Ce#P9g&GwbQArTR?1c$HeDySx0D3nBix_wjvI=vva+}7& zLBbI&ITdXz;HVZ+%(bW%OWmOlaBtWZrItYEz&H4lwLJ3ugxRE8T3RkOKGl;Kc(GKB zpTk$3PbnU-yR5mM!HqX;hIFFjE(qug=pJDjdCML{fb0Q-iG>RkrYL>=p4YJ!IV`JB zJd2Hph!iOY<_6is_8g9c7LkAcVY#^W2bf*Trq#JBmttYHKPUmjk`~emeK~*OprwbQ%TTF7@%C^!ldHn?y|S~mRtxao`Pey@r3io)Z# zG+p_KPb&e9+Fl$UB=8uYbpv(W4h`J$nx6L8PGvIq51a9fP?!;5c!)mz<9HkON#QfN{BWyc*rw1}|3F8|pg1J5G@y+fUA^uVv-9xO0 z0>2Gx&AmVghgoMsee6)412Dg9c9?)NVsZ%j0>SVkO-%HG`<-~^=D+Q@wzBc7e zRHx_VC|PHU4CSrMiQRCQ;Gsi*2Nu3Fhe~>VG(Kp zon56EG|L`#=C|+Bxm(6Kj1p<+C`=E|8T|(WxaGdEjWA>CM|$oz!nz@*Tg+&naC@I1 zJj#{>5qH8G(ntj*C2V+n(-FlHWLhes{m%znOR56<-t@uJ z{$rPpW9G#e3>+`=Yn}M|a*{VYP7l7W&0Ve!FKsn#7o2`?RT9fXwJJ)9&aqT&TW_^t z1hYq6Se!*{`!cNGqgBxQO`|9hEk{GGi$3x4GB3abj-n21kNUjWUg%E!wziNuETMPb z>9?4Zf+$3vE(-EoM7)-Cn|w|w;Q3Z+MyDc@jrJFJ&7-U018@PgVGLf9pjcntgEhGD z6%pReQDcU-gX_akw+bkz-o>%7h-6T56^VHFsV;)tD0i9?ZOG-oWCktzDbY)%mkYXI{)ATdmzKL%Qa*m zEX?Q|cBux|2zx)&$l;EUVJf8WQPEaC8X-AJVe^TfKBsE8{NM{O&8b;Bk$Aunmt&cj zZ@>%15#a5Pl_8m3i*e@JF@e>R%>gS!Kh+$m2w%@;!TR$lC!CGjO3qRVX_d)Gv(Aqv z^DFYP2vP~)36w9x0ZR7)^e>i1MUvoj2BFt>W2VtXTd1we zRy_N5&rfznfpPc%IGS_#RHD7G@?#wWra%`%%IFC1F*D{5 z2HtK-&LGR2?K`L6q&*4xmfWw0Bn@1>wJoyDJP(o&CJR-Da3j*!Jmu0b`+-OTPLx^E zV?+?Msj@lWECoh64Qj!xWWyS23zy@^=Ig&}7yoa?cgFIH<|<*@@3~=6gBY^A~#j z$9`VCZ`21j3ANXJ+0Tj`b!sM+QF)2SVFRi+R4j$_69u%}WZ+PVAi@z)=VJJ(B=4vh zdNfNeo$vKNc2vBLYv8ldb%k>!lji(N@peL^tmZDFJM-I^tgqdDbU&BGB}RZe*uEWU z!|Qv_x5_ZqyYAf$kY*AySCzPk4tIKE!uPEu!xA#R7Vw*r<|7@)h&R)Ms#LH(9CT0rnTZ+?0#5Ala0r!&Q{Yp-l`L198bSMGsJmFoB0FGOzx`u@zhd2>7T+8y zlUD=-q@H?2;^}eSXNa1V*|zCGC@x(G|am5=tcRieKyZfeojD55TW}=OXCK{XkFV4XvDaK zO{F6bkWQ*S*XQ#t4_}-&z2xxjqgS9PgZYAMwX}P+4;dYkUcfdv^x-(bu*a(Nb|B-w zwtPk}2u_8*Uh`UMaLD1;MiuDF3w#wL(*Op)-I30#C_5uLG3B!T$B>62_m$B~F<`ev zv!{eDL|+)Pj!D4IoIHUSj5~`>HUc?K%)NAR4^R|dOAY-JU0)H|dNaq<|J!uL)W4m@ z7)Qb6vko=EX+uFU8Qb>F;R^7tH;;3^!Kc(4|4zJ_;NKglOAfVs;nk+Rra$ZxSbt;b z5UBN`rqBp9Atxhzh`wPC(Ikk_q>%Wff~B>=w^toN@F9TtFNZU68B^I3aVN5yI9lKe zTnbg|#$VBd!fn+ZuVdp=iXPK{%JuQv&dNI$(Muwhp?eV_I5pm9BlD0*agxNSWVrp; zpOlXSUv7-Z{l=`{%<`ui^TMzWoBj0IqLLBdb=~a&@lwA6MLX7mT8t{;B7HYv z{%ThtBmgR?LT(rnet=0xVurTp$=*xgu>E4`R_Og_H}@NcgzXWOW4Vvgj(Kgv5*e9H zihv9_@{hrj4L^G zWt#fuOw|lAUXfgvRafi8H!MW6mi66j!uV-4ngFxttC$`ro=k-b*03z$#_JK@-F2j> zslySS1vwc<@QotI=uJ>?)VxrPmnUl!$^Pgp*74I{yrJl+ zz_q;mk#ILJWqd?9W`~LsN|4~a?~4JCwXB4@;$N@K@5ysTzu`dp#{!8K9`ETT^mMYC zt*V%-1ti_~xju)q4Eb@u4WPh6z``PN(%{lW!a6ET4>|Qfb>^_{>9sRnt1nh5AkfW! z%7U}`+m%NI+?q}OE7#2IAn{)K=eV!JU{kXymBy_TelMAc{;;8nbKpF16hDTTXnNK;x?kGQP_? zZou%dY^ncy^g>z7X@;1-_LVtMRsX}B9Rh%)i9LvLS`qiW6)pxULzoNhrWoggBpzvL zay4rpQG;HU8L)a3x9zPp5ovoA&t#Xtt=JY6IH#7oy9aQ%*3HQZ)q(%OZ--ys@&9HB zsyTLITbpB8NMeCFO@0I`Q4sebf0%WPkx)vLc>^dKwrcu`T-5*4QNOjJ)8a$268TX) zI2r+tC8%8<&p;n6T71dYv@vdo(#(B)@l}zu>OD3PCzw#7hcmZbd(xoAhy3-t^I} zdYGQ$7ewh-jE>Vz`*X{t;Bs=k5Rx*Cvr?TdAwY8=jQt$WNPi1@_ z^R32%eRE{l&&IjzzNa57PH4zuvs=dJV|QOGeL>OEN-<;?i@sBAR%Y8d_Uc4*PN7v* zzswS}GFdKuPTt2KOVZmMfP)Py1-p5@1T9BIC1T;M6*41qYFyQi>Nnc+v;9B_?}Tkc zWQ+hh_?fvlZ$Gd2N6R|r_rck)i=x~krAxmt!}MW@$m-002?Dd2*y$6J^m|4^nDC3> z2np;v%{pI8p6yz{Ewp^TGV*Et{I8VDQ_yUHR~Cil((A2avxC#pkF{efUKHGL{8;?M z=(;yxNi>A;T>Mh8cZi77=t_*!=L8$tQj8t!^3_ZjG?4tS$RY2+0`DU1n^#WTx%Y1e zGr5b$#@75`j_XOV%i+C=u~IjyJ^#tetYR=f8{~bF9R{5LILkZR%T@W7|GEbp;<6v! z#i0nB+-Va&B@b^cv^W?ZAH{mrcBRJS6@#);??!yM=DTh<-+@brX!$)d_g@^!$x_KxvFJ-F4Ts3?&*BuNpof@ZnF=Hm6USvb zj^qETpw<8vZ9dNKgyCw^$M1KZJ!9Jg^1az7xv!5i^a^P^vDK_4Z^u>^z2ULJzYxj2 zzH%pR$A|5gMGMDjc-7mr)sd;^E;mfHN5!IfIlO?(8s2eMt}|t z2lQ{zV1y}N+2Es}y#V5OCAv5wzWi=NuEEM^u*P)K#p+`%Vg{R`%8tRqBfx7n;OsD; zX~gkXouC!7ijJFHh5!+)A$>L4;D>UJ0C_}?ispP z&kXG_F=GE-vp1@%ric7Q_|efx3A*zYtPgAP6%B5&*(Co+y^}rm7gL(=;H{=skHY(H zy_LU^i6eHxIG--0tDGG8{RdnU+R~9r5!Wx#bV7a0I>EdX?&J3)9eO>F3N`(P;7LAE z>g1qmeLKLo=K@_FgX_eUd?WIBrUZi{UV-2MXo`a-b@kg>k6V=Mvec9E0XkT&)KwyebYWt z#nb7}1LLda_x!XXC3r7c)B%|58M&UzU-(Y0X2f%af!D2p?(~FybSAst=aKSirbjm6 zYYR&g5MXKE_l@|}(sT$s1_5|Zw-w0W6vbBPO=Mi&b+1%d_grykuC*`^NlIrK+?6rb z!OLijcM3C&Ax4`E79a{Kzb{Qe#lkt-D!O+eE{U@%i#D#(Mjem`8ybEFFyS%N{ED%2 zZISO&S!e|DWfq}R3Rel0#9gxLw}>L(tGJkgWx-cTI`@Sbd@;)EqAE>y@8aDSfU$*w ziANzj2VlcWef@;=x1D6TTuB5a`b7j8v-X0K2Ij&dFL&SHN}Y0HU)}6Hn6o`L0#W(g0WY-D=XG)E1l<7%B!}~YT#tHSGv-^g&y7XxUTA8Klk)>dWRE>36!Q@uv($mn#oxpa505pb=9c6F#Ubl~ z23}*9O;BE5^Xbma{8hoAKr&d{3l4q*7CQC*h|2{h;C@MpaYXnwYXA2mkr$@!H89)_ z0;sSjC$`vamaK47C%TAhH>6{%@XyFMcuf=fvjdgtH*lIYai|&kVnh_M%jb#Bw)rMK z3#>RYm~_Lr4q01u?h-t>P4jc8Ncj zwF!W*$$ubnW;B3yc`U}!cPI_N3X7(7ngY(&{V;B}b9|TK^!k^_I~g)`sCAa7fUj?u z=YC86f$ZvizSnyHHb(#EQUj{0{O`+@%tgo66EOOw9)1z|gDwo`j^>*Q+}BhP-^g~b zktz7H#i_a7tvYXeXInbVE zt6#oN%=j3%Hh9Rwt;6aLiJaYy@mr}PbiN|%kq2SR4Q1~aS66w^?t<5a7z96WCB!CW zk1I2k_^qjm$Rn&W-Hn6|Xuos)!ISLAJJ_vd^f?|hyW4T$PBFXtAn6nEj!RD!Cun%- z4hw|yPB%T6qE?LspY{SJCgh>;fBSWDIMxcoP= zsAi*&XaKybqdSOln?Kv-BwDY>mTJSgxz^G(Rv2Qt)Ws@zSgxneVI?J zmHsyYtNJPk%xDtMl-<6g&G3>)k5Z!^NgAk(E0CvH_$+R`4BOD?ZSSN{TG`+D{4oOw z?6$%uH8v5`$^Ag^I+i;Vwyy>e;ot?I^XgJTdu!0G^zF3BtK3kt4M~and zJ4Wqm!|3f*vfWMuN}^bU8T9m5P`li)v978uGyCPiM9fE=W*Vg}U&-Dk9OhqwCxX58 z2`0-CwouUK*#e0Mzu|L+&xV+Hnzt6`D87HUQT;@1xL~;q)1d23v*%}i2ZAz7GX}z7 z!{+BlFcbKi{rs|bS=Bp!S&aw(i9c6)$7gBa2-2OQrWVWX0|?mzaLPq31FI|xne)!8 z-l3vg6e0k^V^R=wB4cjQPihq7o)f48Cxh03VZw~za=P3vzS z4?A?SOCFD#=cN_zw|R7a+eqA7d^W}SwI0rWj2plGH* zURKPc*PF(sz^xu?8Rgx5gtmu4ZI^Q?qH-Vc4nc7=$JU*O8tviYRA#O1^v*lWC84Zi z3#_FE-?1ea2hT?y8p5Q!l0G3dL9t&*Z2mz-vF#7Z2OG%}lehm|hP68rk~Z{>JeFK2 z95@_4@kYp&iy^$nLqCaiFAB>4EDR#*)ZR9co(oLsH_KC7M%JumAZpWC4@wLORkQ4@ zV23uB2->@Rm+dR`^&#tyc6HsjxbLVB9*nnNZ}X|#6cA4A*)g&Necqd`?1CyT`X7X}UsP7%CNgjUsY^qI2=e6u$1#!j`PDySOhy8!sp}))TMo7Rm!sBAfe) z?{QU0+46Y|LP=^aQSd zbJ1M)?(_57Jpc9mMvk!-Jjs^O$S+{YJ(HA<$J}<|6Q47$RY4&%*EZ@@4>H{jQL=`HQsBEp% zmPH)@_TH^Fqkcdv>rY*E3NbDVeaB0`|BSIxw%Fvdqv!1vI{dx(swTt?iJ7b;eP`BZ zKVnGIxspaSg^bYb4L?=F&}d);m-tCm3o&vsySEeCZ1Jf_JVh~Ot$Fg!5aV8mFKgCA z{h&c8fkN5NtOp!If?d9_^Q}6N>{<9eT0L~#=b6g;X)sC3`oQD!X{)sI^Y7wULFBeP zgXC&~B1|AC+NneOP14}h@;oZsjm+;c%4K?C+$$OA#*UdSAOB{;U~g48$(7WL&26@Y zu&t+AA*=0+enw62`#PtEVf(??Mm~=hHoq+2u?ClYL$56=*b`E-LHmRgN)Fh|ix(tv zU~+YJ^FXC(B7UtbNUz+Ns%=d2JOL3nB?l}QD|hiG3LrpI7&$)m|H_o8tKMvxEwvu} zDk%DINTPgXV__yvzrza&^fQn;(ECuyd$Y*zeCOwBe`Wf5Jgqfl=n7jqNq}&`$J?lo z`}_J3A3w6=CLtmdn_m{x#5(8myAn zD^V(zBLYxKqTpo1{LUS1qLg_9f^(+I>y{3q5O=aDZ*>y2_f4ralcUr7|!wI;;&4;BI9FQdJNfZp) zq#!sL2@z<8OGw=_HGyhfO!g{hSXlAsCF$}~ha!?4)Ne-n2F2Sy>8U0? z(h*E&$TiZ7Dz7wfx{Un#0e*%uf!kNh0{$MolK*}>noNSo&YmDQo&15E3esVPK41p< zle{pTCncdaOLa6FDRQ)XN&FYa6|t8#5GxkoZIafbvf_m)YS03WamfpK$&3@RG`2Sjf+=N1f^zHS>Qz^Fe zOY85hkeAbZuk*sS+pcd?Iql6^rY?hOt=?=Zm$BqUhk>f#(bMM7 zGF!y{tx8w&xytv(PAcp^gHs5W{gU%XQ;VD6Vy4!0KW~@NmgCCZnXBhMMqJ zxbB7KgN-*N(%}fEl|9US>U~NSX!utz08S+o3T@dr4$&Mjv)0-mX8 zwbk>%Dg+RaWaxtm)jf$qIvu7bad$Odtm8j~H>gmo9*(^78NBi&ENI~ z4))NVB>1h5eJ}X=usF9nFN$){ZSSR#S`_(EaK)+f*|}d++t)*K;;hN0TPpdBfJ5hu z`2st0tJG7(BlWcY$71V?f_qxB%i&XU*4{w3>tJnKG?` zn=u>o3#d?S3O7y>5`@`KSO2TPjhrYLJl@%`p@*aVr#vZ8`Tdl1Kcr)?_M`XFN#{Ez zjyNw!7N}Uk$k7T(8PI3u0yk%V20;@szh~fk z8(1Q#pkyqq#g4?%x~jP!?FbWp3KA_C`C%LR-dpy1BZGL#8I3wVwD91NW2wrvTo)5U$ZEijyhtO%fmtZ7d5e$9i0aOSJztf(m{J$^fF_${^#ljIV`vLPDJ6E|l_(b9gA{`BG^f2X%}HaBLS+$o?GWs&T5RJ)6#MOEhLo6C z2NNPOZ(*IvUFo%?oUI<}E^t!l7WM$4CAp8Zu;w;X^>+#B-2Qgy`VFYzd@5#rPy3}) zLHOH6^i5w{Xqf|hm~i1ALSfbNn^tJZgrBVI27~4_pYCts7CM!lG8L`QmCu25oJ3nK z8|$%*+zr^{mz5Eh=jY#c@BRrB+)e6vi&&ksyDdF5X6t4W3Vk9B`GTG|H}P>1o2jFK zqed#Aqy=^=jlM`^=p$l^Wprz;t+N2Nz<;5wiC1Tjz#J#SwVt)H&h~*z?6EpcCHXJ@BCr+UqwsGQeT*qHh6LB&t@g!LVfiBz<(>I6 zYGL#jBU$|PMY~mqCahU4M*<;0hKEAeJy#K7&j%f6XjwKLI?0bs?~5IvM?QQqC%4$r(q(D{v15P%t^*_ZhwyDYfQ%PqiwWb?1 zN%U6#YWMQ%ySCL?6@)AL$R&C);nO)weWr2Nahsv}q_NVUMKFvsmt7-&SIUU-xV|FW zPPcK-$(t-^M?HC310Q9)TCzVwh75D}20kQ$9&bVwKOM1ih4X|(x~|y%@K>T(I?bUp zxM^4T4eNL`J^%Ir+Q-y>D^P5dJGxc4(H^cVctU)izi_+<~~4TZIUG1 z`R{fG5TZsU(QUEXEN|-Z+b&7uN_NS!Ebqkn6kdA^4pwy7ep%Wsyqie2UI6X63b`Ey zJ*(2oXQHTl-s7m<sWXVxMt|u+%p+5Pm*yY{5lGf}>ySv>Dk8T<3+T zMhgO0p`7e^FX!0U*ghvo@JL&2idjrmZO4ZZl?^;nX4QSYj4W=PSUcH+chn&*hQcMr z_w}$elxsZp7dpql3uS}*I5O#fW0ns=8-fK~e;-@&0sCs950gR9m?yQjoznMX^y#Yh zoR5pnz7S;ve588>@_->V;su^6mXg{{mPo!&pA)=t95cEZ9LUEk@pzZy5>#_E`j7w6 zP@whYLvU4Z2a9l37rG3Qu1|9uS6xS07vW6<@68Zk+hCVSPBK_n+c=5HI1s(oGwZ`O zV-}&2m+;F|@j{B78YFN^47e2>*1=-%HI0D_TNnRN4m-A5NXclr2AW>2EjHzI|02S} zZ~DnfrdP+uQ#B8=87l`O-+=!%<0jcUfpQFqSme*IzJ_BA$s=0kkyIp)G(vX(o>5{l z7IZ5v{sLmefdA`AtPNv>o?hNiET-}amFuh3H6z48POQBSW?Q9lE3apmXZ_3*KX$=RL{Xjtm%Ys6LduJ}uz9%cc6V zt?sq__$@5Qn+O8xFPi*BrcvS(8-Y!^H(fjQuwy-{4!CdjcrTY>J5^X#OlsOyX!Q&S`}^( z**3k`E8pTKLy6ww<=X8UQl`Dtzj)je(fzKj`hChk(&Ce#?F{EVK#!QPzXJ;5X|J#j zUp!_Ks!O&zC^bC^aqH^@^KSWn(-d*22ERvU=z{mF+~yC^gd&1|dr??R3m?KK`^7uT z$)n!C;pi0KSX)5bTaXDYJh2Hb`;V*_Z%$Sx^L90pq9P-I-Pj>{_)Hpg5Vf=UU~DcZ z&IG^EB@xbkkNK67{vg_Yj!8zwekUswSrtW08a!CHJjtj)YS@O>1k9JmH5Yq1clp9 zfy(^5`0uCXh>LC!;K|!7KmMkZ&MTmJyEa2Ra*Tv-rqD$2%OGJ%LUnX5kHh-`wcBl% z6C#Y8A5WX3a(fc?4K+Mk;qX8akS7a`_zy(rmd%6=AAyQ3Cp8&rOEt! z8=`sZ-$JJS5tT(D4r7`o<(N-~J*vw5`U`0kkRaJ~my=`Gpf^H6~@1x880^#NWz2jgCi3T$p zFYZa*B%Al~8vS`s@8ss>7tJ9?rc-RHI?~)iMQrKP)|yLMWk9$# zaKlw?JD=CTTkwNzRr0R)8LxXIwF?U$KVS3sAv&7*2uFhsxZLIyg*J=d zsF;%%2dP1&yA8qe30Jn)edBM>IX$8K@{N>nuf7=L{?MPD#cf|EMV{~-OAyACRwT_8 zxD|hPUWOj3NB0D2wYX+xiM~}R>2LE&+DA_#ke|C~tK>4XCAl{+2_I=X_tCX}kAN2O znXy_nYyiT^?qZh5bgEnDVDn{H4*rwj?r(7T5`cTy5=!2g6cX~%-}WhJ&(_h=h?&TO z0t@KzNj0+Ag+WWAOuDR1T@B&89by?Z&d|&3HM?}i_1*v{^$)7Utxp*K~a)gTRyKL!Fn zyED_XJu(K!t()dHj7QWj_E(Um^wMqfZf;kbp9lM_4d?3aVd3{LZN zyXt3M(i#R;A~>&k{MO%{I;Gi>q+0UF1j3Oe@?C99T)#NvMGxHmnaKw;86p?VWV-3_ zwz_TW*17_`hQlWzEE2{*d_%!cT$eP6w$&DM$k!1n3!OzFfzm}F^>M3bEo!8 zZehTXah8*Gs*?5B zDg~rxACy`2ce1k|w$vw+c|!AOkt7jpR-4bvPymTIP-Nst1wa_k9f856J!$!D-I%Bk z!UBmK#)oY}SV}P8Si+7|wT)ud*F}QWo2o`bf1f#2=pnX%QLYU>#reTnaoiH$5aKM) zV(Hqitj&b|ZySYRu1|#^q-&&3e`=6$%83&FAI5IY7JQ}3@uB@lv6xwInnr~u=oW0_ z&C}H>@b3z@=jy!+J(Va_V50rW-+!k~<7`2DqbDkE1Bi0gAK=+bbi2e_W8;6bMgRM3 zwYz-&-7Wu2oRlhp?m0GvGot2vX*i0!QNUv_#_9`iebJLtA>_I4> z+Bi}y1%TLh83yy2P#fn{vjLWrs%%gJmtSX>mNaK_9^g~!;0@6Sam`(6iNQ$`Eg{Oa zHM>+lXaG`x_rD-Y*50?}*5s!^J#s93V6p<{;p8X0;w~PgzDi<6_FuLFKO-%Fj7g5; zlfsIAk<(K>zO18nR-KkIFT=j2wNXwYzwBm^@HXHwyZ}5@$ zzq}x9{BnSEwfuu}yfH_T{X3~d_MO{m4-CgLxn)RpOU_}ZhXco9IQ`pRMCHcnL*y=3 ze`R)x`-^|7vO)hxwOGUkq?Gog@$Ra$>7G^?ce)%sBI*fB%t<|VC-`V(1Uhcnn<7<5Ef4& zgO*cC@htA3)BFxSevjuo64a0#cqhewuK!^Is29j*-d##>=7I&nMo3W!`tt(j5G6-_ z;)w3#JxYp`14KPQj981;H&&9U0v-tg$iQ6H6%mt|VTf38U}wSzOfQf4%d4!UU5{!KauQGUB(?A0gzevenq zg(9CPOT9cjw{u!y1M7aUlYlMzBudF4;N90V_TR@*SvDOsIvm^7nK+{M z7?=NZ>s=4A)Ny8vP@r&7K*G93pWD_*A$xT-;8P$YKOUSeRCqpWHUN2eFv4jd7F_=a zltF90S)|h`PuE4~>H$L34=T8)uHUO1QX7H(aOp53o#WS?%INnKR1#CiaYfPPa!kvj)<)3o3?l8FeB#qt82!oglul;a|bsQoA5 zJx8=vEvT1D#lW7qn7c$AblEka7*rFKI%5jziFg78Jy5F{0o1`JRN@$bLE-XvxrPTA z;NtgAtX{pkDo_W2AAS2~5CR-DZ+2DXYN6u~I~K40A~znXJg6YC4w6V0-!#wwH06g+A(NsY6Q=eX~{`rMlpV3 zJMy^#SY&u_(XH_3@{zdy*Vo>{;}5CsXGcq?&;Qn#))z(panpVH$<6myU9M6vHw_cE z!Mw7?EE|b<9JU=pcfJRG1L5Xyl&Tu;<-M>0cHydOEg*bY$RsSA?*&#QGsgL)#7 z+$h(f0eWmLA=p6%OtFfPfm48bI-N#$H(w-#??>}a@{Xw>%eC0$^DwutOfjymt`1OK z(^e1aT+`igXrN7|GvI`B>ZWO+RC4`u@o;Jf^+Y_Oh$aP<19g535Ew8CfddB)C}1*2 zDF9$uv6?~sj`Nv9)4}r&uc}_ZO2%$c(wKaY5y ziR6F{+pv&Af|;UO7GP795Dc$rSr!uU1iIS0(AD1MUmqME#P9$1Ckz$_17#>YY<1u- z+yl>60(HtccAnRvFbxxqD}bH?Ad34+w)bsv(K>H00@T4d4*bY(S`k74@ut_e8!x#oG=Hu1rG59rm-gEW<)lGlLD!t~ z{fd0J>%_pkITXwZn7N}xOjw2`Z3D6GBY-`ZFoidn*#3DmP|FnLHq~dP19}+c^Lga+ zd2HUi*}vA@+>GhdcZdLWRhq0z62d^8&zpQM50d~z-KTu15>B0sZ*c6&fqE*HS}WJ2 z)EqlSw^F8&Q6B(Tf0C|BCi71%T>x4h;=@D;qtCjNZ5Md+H3x zW%C5J&%z8r?>ip{o=@CQ@V?;ZEw`s`+qUnFfn`_6ChU6%o224q47O>riCs$Pocc%~ zV;J3W{>^y#(dVl!S1lc}-(d*d8|RNwKL;thr+&i^ZiLUDd*7x*TojEGif#!7r-)*) zh*GKK|H{YwS6-BM_jTjrHJ{+^_x}k>U08O|UG2XN>ihu|ka zeGqTF^(N-doeSS@J=BFu;MmLd@GpObIkV@Ww^ul(0i^etFr}b5htI+O`|l^cAq1J0 z9O4F=D}tSQPQkAZA7D)p&bied8`FvntWIzw2R7$vfr4-N^ zOLb2g&=+93ojMb@b4HNoA{zeay%6{q%r8vf^gVSketKW{F%9%Tl}fFUTUKUyLX5Wo zd@HE&t*%D+HR|ng3DEUax3N^ou{7S~>M(B8g(YB<@*$D50FX+6G6ngvD%fi)PW|(mAIt_S9w3awT-f z`8R=J>vHOI_Bjkc`R&iJe&c76TI|(u>Yr}>4FC1e&vD8(PWIar* zk8{w8Z3xaO$ip)Z>6@MFCx8PW_+*55hqQeFX;}d5N0Z3#LNTh{0 z*E9@FnKc#bjnBO+VK5#}>sGDBFYf)Xh}7C>Le~Twck=NOlD4s-tIr-Cm~+mYb9W{& zVS7=CqQ*)lHisFC1V*N0JfY-OxzjMvE1!4EmMs*um9It$9e zh~rbxVVUe)EhrJFlv8Jb?tNQ+|D!l{pAlB#Rx5zM-FDMfeE8u9a9yf^7P}ewhWRxE zxm-Pfl~5M}!bVO7XB~*3r3d%aWn$jqWDdSIP-lDo38^k!ydJbuXNq$sc<8OM1oe0< z4xmpP3w4abKt1dusf(x3NBiKo4ydFDAS=pM3+lI@e-i+LLr&Owd+Ogh=2Tq&lbcoG z25JWNpZ)6R*n6+NFlq8+0N&H^xk;d8I_NR_(Q6N2+kx@O6jcz}(!B+}`Cb&Ak}r0Y zsQ~`*cxBv_WFf9|)W_9 z0IAw+u#8-Or0R=GF6t@2TtHZunm7#tPI^3C&%i$4ylR>LhTUNoCMo>IR{zh-oyO`t9f6 zhz+Yh#mSePURAkD>4?1#!=o?#506E|MDn&+isr&S3o_SQ}6BR#jQX5 zA%6V8kHz-`1U$-3o4Orl&6?#+W)O2A0g~AiGOcQu)opi}ioWbH3Ml&C;D}T#WR!hm z`PKcus3}ZoIoe^?bdNh9d+O`y#c7A1f~AW;sJd(vnA^mL2_pcal~BnkNw}w$<>t3R zP?z&n2I_r%)y0LEiHY3BJg&A^z4ki~%EBnfefufWA~MQ;ek4v^l!*p)nehdHZMNCw zMY+#`jn&rHaf6?IwjrtCFmFT`zcbr)RkR^Hp9vFP%iOvuZs&s*EYAn3SS-M{W1|9f z)<1QT0t6BUUYY;^AOJ~3K~%Nd1;`r!956TAeEJBMuNBl2i8yS_La|ij8GSKiD5z`C zOnn&%VwR0~JdR;!7z9+gr_q4=FMse~_-xgBTztM*G1<0yh1s6` zg((JCrHMomZkLH!u)XIIV=5nwmn|l-mZXF==xg$D6O!I#rOBF)`?wPQ}dfoO&!4 zlg1|;)MbWy^5jW=lr>I)8NoEoPk1L)1vlvaebZ0Pv zi1eWk4h{zT#QIyEqMYm-KD-=J&iSAVXF5bHBlktVpRjugD$1pj5|=KO3%>h=?YWxF zT+JKJ0H>Zx)B$GL$Hn$)CQPVJQSRkOpT`g9FRZ#;CA7z_G_3iwiHf5Np@0Veg$hR}ePo?z!h)*k`Z3nZ=6qa`Nw` zt|^OLTZ3qT08@6@7K!#WdQh!6mY}~kkE_qVyvlMT)0g($6MOEr*O=Ga*VBvBW}l1? z#}Ld-VkltFiBchL9f?Ykd9o~im-o-5nj_E4wMQw?*H_z?NH&`dZBtb)3$`yyG39c_ zVljlNl8FS4RSe_U$NK>-4`co)rHIAk1(EcfQB^7{pT}ac)q0NtPnZznL*A$WZG9!8 zf;v--)9cZ>Q-E{uYCh#mE3e-m@uRMZJhg#(sZ{bs7{R(!Q0L%F{CL(;{jD9;Q;C$w z7SO&|iu?AxE}*w!v>U_ zWQIrqrBVsqQ0;8HQ+X`6)=Hr6+2~53ZX1>d;wq>!fVG&`yARfS$W@`~u4}{-!Xm1v zpe}ofGe-n<5YAPX2lW7mmjQK=haJ83#+x|)_~S8m?p(b2=9{4&1@&bl4 zq5_Kq=gjiUV6L{$&xv$Rt;5pH31v{%pA83f%d(e2qX3|{w~v2M2PQe1OcLTW(X`HOal}578C$iW zPJ*DGALz$*3xkud{K*WN%#^K2gJSY6seUZ8)_9<9!!!&9)Gd>NeHf^l5~#}{u7_VW zD*$!&-Z6Kv%sg&nQ0MFFu?F>?-d_CX@yBt*oFj0;2`AvKx84eM6Wcbf4ZD8vi`ZqC zFQT!r(HDp7->_jAXqnQ6WG=0IDpPmdj)6JdQWnU=iQw5sp29P~s$M&MBs%UJ$7A}A zGsd*e4;HsGBDIkQGlU=DzV+buI*E~O~BZduNmTX^V1DM2!k0F^axmGo#3 z4{NTkulD&QlTkVJa_xmnCe-snL5b!Nu?W$}RiCff2Uwm{C$Q~!$Rb0O3rm|aWy)e` z6ae&iJpNZ616`Kkmjm_s`uflpiKpxPz(KLRT%UZdi|d)lJ**Gaf_kY`RPu+{rLOn+ zxnVF(+_408%d(M(@o=gDHG<=#gF2+ov_wl7E)FaGvbf!-zt^hT_j5(LapPKR0`*0I z`6s@6)VX60>I>$b&rFwU0d)^hbWs2JlaF!7kA4)+hj<@%sZ_$C8Hlq6pbV%R;h=7s z7AzgqBYeMC0_y&`59*%dj}buK=g`Lp)ZhQ$eO!L&W%$aM55%RHU4{=n{2<`_y{;~W zuC9sLeYf2(b?Q`P>eBoTmc9x2ABdfZp=H}PScw>zh?ByKS(v%!j!1T7uz_+DCh0p< zo=(X3L4c2zEXDQbTp9X2M?=|M7T1k2cmDgQU&c3QpM-pG^$KD2Ese<5X9Ej%PEi`| zE?g8)KmkQ*K*ND~a5!vVn;;&G!7w~~kD5STy-=${TrQV`Wtowjci8zzpe~$o5v7ct zZ*-hGJ5D4L5t0K{{4P@}m3mX_d{7Rv{r20x_Qo4;N}XhlGEoDMAKjQ>E}2MT$XgW>uKXoQGQ>C$5EsnVD}g^)MYo87!XR?C_Hi4Ky9Yva*R}-X z#d{)75x$#N_>>Rep+&<`-aYkXB@qbQR~exEUb5x^?-$D2>kZI1Mp`!@~G5ry+Vm4;&y%UBq z4z{>kqM3y<$IF*2!}&)9l_AH1zI(;R$kyllWzJ~nx4(QG-#`13n#$&y8W2m!CSw95 z0QO#ykiGLFig2a=^ZoUxJ@x#cuDih62=1TjfeGN(D+6Cx^e~`yKv%`>;acVbRAnr>~$e=E4`UKanx}^>4J98WBV5~vCKAXdq9?7ACK^QoQoJxHLCBl!px34ldJcM+j z4z?XrLER#r2|d-uUG#U{xN!h#0rh1#bN`cZ$5Z!V>dft`DjP*79CR%H_|Bj4j}QJi zrl9`dgAXEAm%;%D9-y^Iv3i?sxH2~p(ytz~A4_vC{f<=Lz=i<)R|3%N%pD-b%0`UaIj_%aZKDUFA`LV zO*v3!=_;t}uChg6i9dISEi`4Eiq?KtEe#BV1az5#iw+gkCr_R{Y+05Pm<0%(iGaGg z)JK~(VMb6fO@KNNL&|NVxleat1|ZDDqCi>LTf7>RF$F@67!)M0lDAJM!<|Obx0$|0$0AFy_Iat1U zX&`MZ=(=0SP8sylvo6LHzk0l;vh^*Eh$Z5I>pF1hm{ULru0J=k#3+}q{GC*}b5Wsf zS+KSE=Ym-XH&4@nN(S}b8nzoaWipvEAg-VDHdSec4C<==IsANjeKMyWE)@vp)MbvH znX9q3)%v4By`iCDMc6om0=nzEeTBZQ)%p&s4c-9DI)1k$qRI`611 zu9x%6;*G(a zd@=g-dAN=Xm%8lNrEpzGa0wpQK)|E`+_aACd~m5D=f*h~PCVe2m08(2yE`jxp{Z*e zQrS9BH^93dv$5SS+oNStE7m)kL%_frnJ8vmx_-~)cWgB<|LzqRkBK5&Z%;4IJ^oDm zwMHj5%^j@)r$RExz$L#^r7$pu5yHibdIk%Fa9lCJ$P{j_RvoB&R{#*?^RkyB} z6-lq&m*9C2)MfFz>Z3yj3Z-YjNcD1#VaWVgfP$&FC`JpnEJ~{19bxi z8XKGZef4VT-tXUmo6ozprm{Mnb>yj-*12s^Ic}7Sa{Yq?xcZ8#u=0~nD(FQtAOBgd z2Ork0VSKk?FvU1etKCn$MQFWS1`q7w1$p5Lazs*^Grb@#7ORgK zL;$a8!Lm$PwvCu&drn)3cMEKhlT4~i3)NKedR zowL#3*NwvNa`eOb3-Q7u&(u(IWSTx}Ixf1Rwta4y)~;NGZyY+WW-xDTZ7B=poPtD<`?hjLabm9S~k=7_xIsi8smED(0u zRJm5J54zHx>pCbFOM!V&9@FSWLNJX{82+)uSj_hGhA9??ncU@a+0Yj#^v&3N@4a6X zK*c+tf~F4Yx|TEta~-7R8`J?-{tY9MMv>1m&FayDI*;W}hzjcE>mng(V*~1$blMLY zDJ|^aYEjhW`eTNvg^wiIk{8=6zWW&tYNpzz+?M=&GMP-xp#H)m&*Jp`P8ySa%-hbr z5$ROjRsr>EuDAv(SF9Y>j%bhBk0lK&@wwXz%QRt|mgiJP26a;dbsnir19ch5BSGCW zWg|u?s0;0P*$$me1Wfy#1f#SWBH9|)lqZD6TqoXwmqlLVVD2frd2;~q`~diie*+)} zLAoh}_8F6q9pB)uEBQM=W!ARX?XW#P<+mtjBEk89gq+=a{tbBXk!MHo6r(Ad%i?GM z^U$d4d4JKraO9U}`8@2Rl62?g|AF1I3^%?+yHO~uC=0_urGT#M%#4$@&go!0QJx(Mv%1QYJa@hQ&-+01WZAWh@8>HK)toK ztxTS1TE1i%PTTJ!EE}Z=w7sbf7ajkda3CK8P`}m#b(P9Pyq;Pj4pugA!qWI!6lg&M zbyEU$OXJkdkkG3mgSus!Fs(A6?zx8bmEyb}D|YHc26gs68y+|A2Y(?1!~=B$9*7%; zFOm=E)PcID4BBUOp?Oj(i0NCO1B9TlwF!I7*&E|$bYfj;BL=DDEDGMc>;LIQyno^y zzU};*@X{mCm3>~Lq3dtG0i6>&M^(q;zx;2Ubm(04)v!;@VwtzVtkMY-12&2h9Jtig z=7(r=HcEkkA``Xy;&=%l34pp}c`%pjV!!20+Pb@YDylDxve`@sUN+myLog&)m zBn;FUP-ZgeKs|as`C6E`R~75CcEz!{&K(ep7Sx$Nx@w26gSwv1>tbz=J*a2uGD0anbktt6allUdY&B57?uu)JpiY&ail{F&gyqejVLjP|cr50Dx+Q^nnE2iFLAw%A zH;4!Brd1x)J!dp*USptc_}sbdQH}_3=bX9+(y|>qF(5c~!sDqEpHnw26ZP$lXrDe2 z&68ST$72k9y>vSs!}PspVV6U8M=|SSlhe&YwR#k_v?LMf{k{FTT@%!;YMd z<4+l#KFFOn+>Y;^_1&7myuP`~8^h|!rA*YWa+UBxr>b>wRh>a+2o7}xnEM$3ZUk9Q z+^$n4px)gbP}r`B8X6jWiRM^=I*YKzx#%#va@D?EPM0}#ovT+Bkl8QaKNnzL9@GIB z_4W0uLJ|O!0d&i<-xMng^^=l8op+iLprN4=VfzT-9B%lrx(Dy)Q2Is)-$!?qe6@f& zrA#3xm^UbXSMP&!G;06G0@O3nSUK^`%n(td0L4$*wEOAf8|!8-x&1vvMr5MS3#Y-k*x&OiR6f8WKd_55(jnP`3%uO z-H^oZq`df@aq93z@X2fnEtAKgbEhe&Z*PPhx7j<+zZVc}v(r@Ud&~jIO=-gV(k2X2 zU5mIn>hJBxWncXcUVilXQPoq9rq7yzyB@r!=JLHgy*O*`>A35LJ8CMQ%%srR+TzDD zuZ6^Ri@0LJ41zV7qnRORm~rzF%PUHmo6?cQ?a>qjslma)5UujcsG*@AZMXKkk|0I5w(AY_8?`@9$Qe)`T=i* zrmD8A0SMs0MbRx`s5FfJ!XSo<1%PNTH3xO7mM13hw8nJ`QYCf4Nt9RQwx ziK*= z0E|HOpe{S%ABj^B2X%}&sMlxeHDFfnQM(+V;5~kX}KGgACavRP?saJu_$gMgE|wr3(;fHO)SwkbrPy5XId80^=ULsY(dAY zF0@bYLUvp|>_iMOh%y)0aSI(&JF)+92V&~p(=n7PVzbi&$2YI6ob=at<$E9Df-j%B zRlytp7T$UzX6!h#rm}Co`UVc);}E>R_+K@Z&owt7m8lz3Fef00!3Lqi4YUgvC6q9X zA{-55%K>}Fb0$*@sD~-a)hcdJrBX)zz$QC3)WdE2zReC_6T5A=ix9;T`UB6 zT98xco;nkuz64}YCjn4D^w2{iSBa6VR(*Z_iiU=U&0Dr?X%e6-oW_WihInZ#%R(lT z@iZ3Ms)pYH-_Ky>X=u8B9G0K8%Z|IdyV2P>0b=ll3)yPy)VcBqOOxA#@9I_EV;0V5 zm_0u056>%0AZoQ!Pb3mZ#F7{)42l=eyE(tleBiz6s5XXtEPUxZn3pg;FNp!PK&3Za zejdC}qA|;|(A?Yt0KTzM?!K4p0J!1;DYuP1e|RCooL|OrYwr@Vl-zSrG!_1?V6E?7BE&i5Toe9I=GW zfSa&)h``G)NzMo%NTuu0K6L^nO`ih92nO6?6rA2r`BJq+0KD?pOSt>nKO9v(mC%{< z&&IqO_s#EEcpH9n!|gS<-O$ z)s!MA?q|ot!^0>P3KADyJEzX~<3)L0QBEH!SzBJzHI|%ueI^G`?UM>F2|X$!##9ao zLPhccEQyLP#1}dST3TAs(o&mQ8vs1^z{5CYpSd-O;4eAuJ2-0Z!?!A@{{DOK z&o^IF#P8mIxnZDfY6lu8v>@G-K`a$#+&+lVd8)kiZ7wj|l0Cem;33+P> z-A*40v>3ek8gPA}w;%U>=eGY9FrRnw3Ao|58>=qY+tZ70%{_HgVBR#oWvhWX^*C}D zt|YNxDUtPrJgjV;ZXyOm1#~G#y#39aYqLEE`2KlVz2!yg!Fi2ca2!X|%L655ah}+|yGqqqlERU<)1EoNF`}jb}RGG>GdMp-uHO!2Q9fyNDA7uHu;6~*R zlgMlOv3jm90%UFX(SUlXRFWL!AT)27_WRZZ^@d!%pHCYNZA>60S(&Ju?p+G3I6X2A zwx=G_4)2rx;t|3$;M?0f^p-28WlNUg)TYdWYK9;h3{5E2=W zL*SrJJaN7+UgwH(o^A;t@LanJr8t1q(K@LO+wVC82b^>WW*)RNvJ)GyrPPPKGY}er zmJWQ}VF5iBw;`Vqv9tf8z*IWKPT>G8HB9Y7J7^QOR za$4A)x>{Bzf_R*X+rvOz^jQVB8!NlK^b<^KV_kJa9cf#%0Jrgy95TvqcjGxkh>HF`9{Z2dxI~=$ZTDEJ$fHjOB zCyzmQI7HcPboAVVPvV+mF2RcTK4KRt$EvDn`m7mv>UYmntpxYr-T#5Z_BaS@SFNe3 z-DI{7^)1XSEeJBzQB8a9G~}C(80btg9U`gps;Lpw+uFvXu`x_^UY_df>&v!R38;HV z{xu_lq)pSrh7B80C=6?>oT!^-dE|kM2K8Wk^r4|4baZq``9+&@UGh1#OSb?3 zAOJ~3K~!FRFc0ziZuqw4VM-O@=h32WLgW=&a6!V-!~4S1O~XWYUk`jZ4qG^ffVx4M zd65AElNvB7fe8Z!HN127XMn(z#s-(P^Qr?FL1pDD*@0oYYLj$o6zxviI}|0R7~1=8#Ht^Bi@ii z(I{cqEucglf00PEapULG+w4Cxe&!z$@uUd|Hm}`?+fQ4F-~Hk_6o<8UX)AzwHkZXO zAO97)CUsR@rnkEX=bn5PetOSOYHzo(9?7~?z?G{$KUG4bQJ^ErbBnI0Dc9&P+Jnu7 zGbZ9%c>Yu>iH3#-w6?Y)l}e&mELCK}*4a5h3P2UYoG5@CjaQ;9K|Y_Cl)VvBhG=EP zy@qk|a@~4)+qRKTr>X@k8dA7>7*0Rju;XE<+N}-%H?v)dwY9l%Bu|d zCRGJD_S@Ll=qbkON?PRtutZ(sV65(O%L;QnJ>AIV>NVxE>J{aRMaTD(Ei1-}KB!U( zHA)++Qw8YJE6Szo>X3}bF)$>&X@STK3O=@Cm26M~6Z#&wnonHyq!xa^38-zt_4bp( zG+E_)m!F$q7-()Dhg7N`8#itUl&ge3UA+!x&p8eA&iMw;y6ik;bKzn&nZ7V#Dt`9e zd-2WN&O^T6K843`dl&<~ zdi-szvN0OsY%YtZe)lY9R1tLLy?2-3)Zu=FOW!m2P9P z80zcg{qyKP>0=pGlw)ay!f+t|IU_ansjMg`(!{x-AmhWErIh;OcF`Y}$U=InWqJGU z?c-O3-lW{hNMe##UU}u7_uqg2JXw`qF2mv^i!=b(u;DZO^Plf1*W_chO;tf7sMH|N zqihG8ni?^A@?=TuBfv&KXMN_gG*v`Jga9dz17d%!2Wr&+b6rj#F8JNSilzF;dAHUxqr%t4F@ijCyHX`L)&jdMh9n=Bf$Rm$< z@atdy`nLiJ5|tIX13-WOz^0WeSAHvO|C)2j{w;XN@pv4ccu}lGdQe;*q@XxlNezfg zSiO$p{(tt~JWi6Mx)c9KUUhXJLf%lClB8FxUxRd@{q@Eao9dM)N4SWIW~pQz4PPv?Em)_*)D*?;c3%v>>#(qOqQFy|zFlOQmN4wINLU@(J5q6H`5 ziD0h!GjtQCVIr5wqF5-x^E@=|W_&^z0d-B&P#qYIjcw}jN6d#R!;|>Kbm6;VnkM@D z`!O;y60EgXt5sw&86}=X)#LGYsV4x-%PYc|mOM#_f^!rr;>OKUK9U<;XsTMMC7=%v4!PEy-ODy3-}=H_NmtJQ;siH%k@P~ZqU zEG#3r(EvL!ty~_2X&P$=bwb#FdRg6`2IAql=1heiKG1mGy90GX2&hM~Qd^13Vp89R z`AOjC~DDM5X=`{`I@TJJ`K5o8n+Ua($gUi{an0Ner08^sQnYmhEF}gO%nqH1HLgCiF~?IJV^rdI9@r98%XCeV5|B$ zJzl-0E{>^yWo41i7g|h6WKbU)8*5yD{q?Eq=Rlht0Sbk}ecZZ{7Z6&%hZPY4WpHrN zuP~L;g&mM|01La1rip@FbbWYwdKzIJ-TbhIT{Qgt~%#yJki5jGy>?91j7L(@WGr(a}IG~`+pvZDqO?1WHK4w zm?L^%jhdejf^n+RCCmJuUUE+ewgC7P{nL#=~!-n#t%+ z1<@`c;6x^4M)DJdL%H(Y=4^O)xUDmHTT18vaQyhOU9+>ZSIPzf@qt`aubZZcqemwJ z1$af*YW-N@I!QerrjM5GIF7G&Cqnw@gHb)GsHDyToFCr8>ciDBvN4#v{w^Bv#b=3f z*_}%2x~`*X+o(0_L9ps&4~!HEjSK?Z_>BaX?}TWff>nIM2!%(OZ9sHgjt~OF&|z5_ z*tRVh3d$r;(hS2up-_P9x?QW_0pNij-;Zy8>FXHZx5t;(AxY>=q9GXSui(lHo{9Sp zKZxl?-+4unq%PjCK~m@OGpDC<_jiBrq?Fi+@P8~kQ9>t}JwAnRf8y)-+tW3O&!?OhV9vCdN!JF6Ah;c$93VjE`#)!MIJFcNkW&~oV4{>%ridbs+VZRYZkDwvLcM#VcH}~T;}6t%Y0FxPmJ&H@Ar>P zO~Oz4no{86i!b`ZzJ2>zIyz_z&}+5Y($S+wUoCfR5~#CZ%d#*raWt?h7dT?qvLqYN zD`{pchP$qdN@Wm+VXhg}2|*xDa&Q&*5Q>Ix@_s~lve9c$&t-F%o|}>KkSVgpPMKp6 zDU3*WKIk(bib~~__(v~-ZJ*Ob9r<42F<@++@ECYy}`Iss7auj1Ove+_p&{KE|gb%5Cb-2I)qaNmFY6qaS8 zIx+;)GVw&FP67ScBS-M%zxpS9{Et3_1OM?519H{pyw0G0;l7LT_3z$>Z9BH7X0b58 zfZu!Nf5%_{* zX@r12zcddoO_cSE9w`q8!cFoxE&^LZMgdZR~DdwpjbCV_lJkE7p)a&&a zF9-5Ch{u;XWu7=b%Gz8VrBW#c^VD^J=}WJB)5yq3%WV~H0s8Rp@bO0MkAk8 zX-2ZNw!FN8<>jS-SCn9dCir12eH!S7`3tF~&eBjW4+x;z9jH_4`F?go5+!wZFM>D; z;`myXT-V-!x~}W6?Ivo$7B21DsRx&OFf_wI@hb%N zY&PeA5c0E8**|bHO#^*>eP}itaNW)i?BI0Zf&IAoAHIO0(IJfQ+k+^e0|Z$!gKMw2 z28T~i;LxcfkSZCy7Vmom>Hxvw+yd_V;ZJeLZU2tNxdoKU11OcdJH_j4lL};5ID&qt zFRkLzXlr!>es&bT73S?Uufwx=JTKaC%pWHFT+DWf3SlB z<1{!{g_X@D3L7J_4NUC+hRYRVZ5e%5`tLLi;T z0Z0Y9(Xl49qG?U2H>eIu#+3qMGm1%srlC;igRbjcAI<;(%|;X7 z``7Q_M|a+X%ddJmN&_Vc&5Zo(K(8;Y;@+?S5MTSi7x9TVe*{1Kw|lWTHJ|j_tM7xb-huk> z|H13<(NFwcFo>$?=)_Un@UrXi_aFS*HA&@xioHu)5rgP36ktw4VZ(uk=y?9``8d%Kf8~ta-YX zl~u^g$Z>27!;Iw8RB-MfEu#TA$TW3=`vY8%j}rl!oP zsj2H!m5)|}Qznzep+kog*33oz_*t^z1Ci4wgSz857#u9aG|e@GI;Gs&oz;(1TvGRf zbkUjBdVsoRnpml=qUrGUuW$`KiZA|rHiWk}KpkKby8$*Rd0@r^#BaOpIk0pyILea{ zf=nihW|KKJiLOPd%M06=$z+hv7f`FMrWnAqrV~exokxL!qx`rrGXOO|KShdjcU4sQX02C|z=<6?arD6xznmLoqw zWR~N?^WRf5k|9sN4>uxNcSRW#`)q7RK&8vH0*w4WE9)Chb|nsm0(y$o|Y!wvvi*CT97-FVSBJWj|Sej zc->i?P($H{mG230(Kdx;x9fanWpx>kO&$s-6^b;Rh(}-uXCRAh3{p$?d;-K?CKn!> zo-Og}nvPPg==&4bK!^^_c{_gPMZYEi zI%^%l{>cM)?T6lkVCs9>KwT9>#$mJ&egmj)adewpQa`D8tjzM8gyjErzUZ+qdDLzWfF3 z+qX~tHiA2fyKcV=ulsMW#pKb+^vqh2ZtCc-l%aQdjsd{lNsGkS%+tU;NSgxcmTsbu z$qUY9bTpg>7M2wj`;jch21f#KW+H=H{hl^~_s0>}#lpe@DwRPgjoLSSdy@s#q(LQ( zC#_4buGY|K)FW|f$(zTgOX_0(h;?LP*=z>oa(LE>*tR54FBJ0l=tn zbO5;JmRlY;bLPy20AfIv1nP$mAHn|p`ym5IIw;52snbDSOsne#F1ze9h+loTpsr~e zOw)wtd2n49j^hMvj;G&PP=9RlF|4ev_*fu}s*y1il)~@~;WcRm>hb-S9w_QwBN$*Q z1+r!a#T-+aGavXm&YU^p`yPJ!SQ)%1cE#tfZaO%`4oIH6FhGAf6Xb8i@Lz0{Av9Lx&Fi ziFo{+Z1F9Fy65}8zWw&w{Tx(AWl5kO1s*l1hrZ#%u=CH~?fd#&JE$9m0mpHC7q8Jt z$k_w+dZUH|M}83`r9%2(4CNCO5a^!x5~YE9IKvFpVgxSrP>aWm)bx1?a$%QKL6K` zYf$&QOX8`FR8binLUpu?%2*Ykz}EA&BUjAJU@CQRyl*D=PoTE6iq*vxOdgm(ZE*#Y zk4(t?vERohsK4j`e-B>whp+des08Q>^9%UM-+UN<`L1^>3h12De6hDn{9Uw&Je^fo zoK3W)8+UhicXto&1b25r2<~pdg1ft0AhLQwcoY2 zAFLpZG*+(D`CdUG1`5GHbJ!Y=<$BVCG^&t1$+k^Rl29udPm50yyn0D-H@ zc?yv3?TyQZuD@TL+qP4kWADW=-Jy>j02k&3;COTv(-GmaM>+BQ=bj#@t2j38g&qc@ zgK1k9>XYRB2ngtB>+On=hQ@g9@#n!lNtX`|XU$M2$>p>ho$PqWcn}NW5WkCLEI~?; z?ie$A^!d`C)m9dQPrbhi!^zWmZU8Ax2O<^qLI1cM-HexwC-ssH?zn~1GETg*CEXDjGO2?9d=>S; zNP6t^CjM6BkGFj(dd+dx`AAuaNKp`YF`qwZuz7pHBM`a0fK*8=UcjLtf2h1tFrgwh z9s??~?weBzBi*(XH!(CyirdCE-AHFDm@|=wu_dqjqLSQncwo%|RQ`?cr5YF(78dll zF$};0$A|db==U%S)YsKLmUl3CAWAHXde5Q5c(Xo^xg+i>&5O4%z7$7=`WUWVpXl^H zhg8@1oS6NTC+SX2HwkzOwr>%HiOQRYA6nJdl@A=Lz;Ik`qDlJvb4MPH{STfoolt&e zR#wPqM`I>#y(^pWM7Vog*>VXSrE@h^6saz{j>&aE@(Yc=Gtq4~)_l$Mae?*Zh;59Na+AP+`S$y->%# ztI3G#y(p6Nd$(8;>_hjO$8M|VMl7GNk z%n1|9&1$a_ha`01LLFpcGKBNjGx3D(Pd6J}fL@zqlnjlZjmgdMU!?0`? z0F*Bo(ar30qmP?*w(XOD(|vI7uOFr^W*8qXqi7Hy=eCOnm$i=`0^inzkDK5Qd{kiN zHsyS965NzA2mZS_b%&&1?zbZ!HbS#E0zSu{|5>{nLdtvbdwsv`!A)jJGV4rXI#B<| z-DQm}5MgS{~zZrc9|7MD4L-K;MRBka1Dx$y@Es@-;qWpA;&!WnrFy*SpB&u^w-K&MR_B&n)AM2 z#O&>@8~TGK>|JA_`Ue#?D0M_Qe;}YG8tOYY&S!jF|HS0`I2kP`Ab4h`1wS8t-7Lcp zj;FE3Z*WGvQWMyTO| z0N!YokuL}77)-&C+uoG<^I}?HVM1{Ux%1@i(Yi> z)_Luq%Jbdj$?pdtAAp*jqBWAZHxQ&Hx|eDO_a`F|^iDqwiZ?D;c~@Cv5ws-z(Xw3Q zjVBX}w;25kxYWO7m&U^ZJfU!|;GN@h`qm6t*o-xlF*=aFrOX1{BuO3 zruiLDo+Ucc%mu-il_^WLO>4)J(iBRSRE>;;Fx*NHLyGW@u=OxMG8g&eY#AzCS!AU_ z{ee*Tn|9-h;eezCfnpra)H3c@YZpSgLzUgzSL`xe>xQ-t(3;DS=>v#dP#UesNy#D2 zk`B(uDcyZwqwc`U3axIMBgHxkiI@-a$LYgHl+AenVb3Fh$H86NiM8J=3fTbO=6%9S zr~m6U%!$0PI(huN2!w?H=J3l^t#cp}U*MCq<7STt{Kr|jXsAf%h%e%vHf!ianc3d+ z&CKma&et^Pb$!o4=e0fc@2Llf^`9s+JA#3EgF@T@Rk?F}{HN4a1#r3g`-j(^^aU&y zYyh>a1#+K|?8ZJ;#H9G2!TF^H3i$^=u|T?lfcK}vK$F!V+=WFVEqZKGVi9A_byfNh z!R$)gvHfrKsR|l?z77ZS+qDw@9v--Lr>`18&-abB44AF!VyG@y692+uVC{+|oPc{+ z>TS_;7;a#mmxQP~j<5{x;OpaFqG@-$y=X;w7Z41-#K`;?HOPs9nABRvwOefvilV`U zy@TlEaC#$VI2=aUVjAc1zSFt?#rWlmBf-Y&BgnnvN?2apf9>Asab;9A!uO&ZPRGa} z2V`m%KuY%97YVrN_>94wy^+Ntx>Sdnq?HBS{4*`T_;6?xw!@U`Nce3BWT1Ypm|*cb z@_&7^(49k`*3|svujPxFfrYO5%ruTnf~nJ6uO&!EOsuI;cfLqbqeud@922;HqN3{7T;PMefu;W7~o@NRf_pM;e4)A z(vv$vYisL;=#CQeK!oYQS@5;2b0Ami6DhoN&n|A)Lk!ta^DMZm`kg zNv+A?&H$v3JRo0feMy4HUwX=YZ1Nazo-)nU2pVtKsY zF>Jl8xQb&6aCa5?kt;okiHW5Ty&wKY1l(?KuxQ9By(H(h>KbT^cxD!|GBP+Qi5JwB zoPycWqR@Zv;*c&GRB{Cw!bI9>?pUa@-z-$L{HbCy12!9=$ZXX-RRm`k3BMSBwxy%O6Pr1l7LlNV{DbCD$^OBKvvkL#uV>^uCt14vTd z=nPI{TlYV>K@5VSd1`RV*Hr?HC=u-eIf8GME(!BX&q!dFs9h=6=!M@Y~g?v zt?3?2zOEaY^`p?oL@KPuEjZC2;5*~eJ!<4eZLo-Xd4Vg)?t!pLu& zAwo^kj~*ICvAcH}MQjzAin`6HOP4Zp>&9O#H=A)qY{rj`WS z14cYjsq+SDM-T~dVDmTce*?a_Vw{{e!SRF)XoT+c+mJq|qd#IpH4D5_O$R(h!h9xq<<83saq@!OAU zd#+;Q;Nwg9pZ$GXE*h7=`2pTTHGw+rh}Wphe?sTuv2I(n&}ZZ6gvDH&qpkEs2$mw@ z=N4WQs??PP%{Q=XlVC_$2-~5^eHQ~JuV(=>c;ZPA#ew$99

    `Drs*=2jZv;rq-s* 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 YkKNm`AVXW6lL>tOHnA|SGQ9KPe{GleTmS$7 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_06-01.png b/.vaunt/badges/badge_06-01.png new file mode 100644 index 0000000000000000000000000000000000000000..03696a1e1567a23fcad02e39eea1db70f56de38a GIT binary patch literal 169523 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℞C|7XIIO@CXj?nW>iyLA!|SL3h=9eTXUK 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 Lb(5rT`~3d^NASy~ literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_06-03.png b/.vaunt/badges/badge_06-03.png new file mode 100644 index 0000000000000000000000000000000000000000..1c366f4e0fdc79ab2fb099a33b197d5e3a963378 GIT binary patch literal 123277 zcmeFZ2T+t-(=IwgmZ;3(`i)J-i_B79nW2n0f;uBN05 zfj|$?|L}0You2Wz2M`FawGCXs82$UUr;9bX%?N(m+6cMBA(tQ*gCUUT5Q%gT%%3+v zE1BP|RDZQ{`DZIngsYUNr<1LexR9v0owcnXpS_@{B%g>q%#P1mNLZ3jLPAVf*jgM8 z6SuJkV?m$(?vDFccW~r?8I&K6MA{)xPHwJ9@Brlf?*}-3K49&J_-`Jt`Kxt?4QP?; z0RMF-B;Wqmr#tA?@Y~rsq3mp3kZ$%UZ#cs4nuDDy%H^7^o3$OYiW9=l-r3i~*2%#M z1$WkS^F-L#>HE6d`KUOeQ0`I!0ybX!PVOihem8`JfUBK1(#Fl!4k_@vJ@RLJ6lgDi zLcpC|?QE|(JGdd7P>wE6Hkx2uI9N%^@0D=_J zM2jON&kl)#BT&?r?Vash9Z-%mysoyca2GpQbkFw8E^t>Td(gxN?(ATXbc73uirJ!j zG-ftW7qdt!WU_$87UEwHeK;0!=dq8b+L>1ofkyXJuIqa??r>W*^q9Y17`VTu%Jy@r zLN?C-Rp>U(a3>eg96F7jW|5<Tui16)eQn#!g+yhu6o&UCIe)keHn{OdKX8&L=Di7vmEVv9;l|76dgO+&)WnXCNXVd2mZWNP=IG8IImnOZ2V_!1%@a#hB3_ z`4C8OB_zr(g!;FBES+5K-9lP^3e)44M*OWy2QNDWdIN0HUH@=GIytz)QJx4p9~z{c zvpwri;miKiu)n^#{VydB&9m`DIQww^d)t4t5cv7*Z=LG6#nhbr70fWFO(O2x~D?%7P4jvB<6dM~C6A#9WzR!$B1EYfB z;ovxg5JEw7g1;*Z6S@T}7B!4An7p2H%0)9=0Lkt3M8NamZRWVFcWy8SbOT~6N-Xk9 z(dUNkmy4tOM_xBZQ?eUn?usnHOwnI6Vd=qiVA?sFIX5EI|3C%8S(qP<3^rhU`EA@> z1pY|#_l~NH{NB%B+xhq1RJ_J-gK&n0Jo>W~C=@Fs3>Fd$WBYRl292QpJ(8OZ()}MJ z!HoZEg%P3gXFhQBM3Dbz_y)~ti}UU} zLgc}o#nGK#ymgf>1^LJm(4(k|tE&HO_ZrdtBH7g#f2Lt$>W`)ytRVu~E z5-l>`b@sEoeOztA!dI~8J(L=v5GbqXjtQ6C3a<{ZS85%PpF8^?FqI_GG-2z|N!@}k z+ep`=A-$RkaZqZ#?&Jlj_EKmeQFtWWZz7(^_C^O|DzPiGC_G0z<0>6qR$^eHSbZw>2(o?Y53d2v)V?93-9K1Ty;t=m~hDBMr+-8=QX;gjeep5ZA zx9d6ga)jdJ+D!Xtwx;uST>g+8iqqS=?1rB-fidn=dPlHc=Tq_qI z$al@fjVQS420O#A%)VH#?sk48ZzZ24Bz1^Kr}m2S8!6)D+Os>9m4>=}97->JZ<#FI z6_g{M+rJYZKdm`T-sKbLjW^qG^68cWfxn-;QrFE5 z1svs1PbdTv2Hx;5Pbdy9h5mTL|10h|6ocjOYX|5B%!LG?9R@xI+HT%Ph~lVMzmY|# z>lk#gV|MJtix;Qp@ASjb5i$s{| zCK&+-GTG(Ws0btAyJF3~50}0mtEzW+g6}QST$t@sQiomQLL28#Pdgd<#E8ttR_Kb}*rMd0wIVv} zwV0}EjWvDGC*qI^rM!}hg=*uUD+S4ljkuFJ`M*X!jnnd?FyL@c*>nL{wP&S;!^eDVb+SY*;dF$7V@dkD_xIUay~A};%{F?0BHL(;r>|tT6F~{$4b+taVoSsDcpO^`a_-Sbj z?EeOl-hZ$HV9Xtu)Bh&IT>JAB3?oAH{{Ugo7OE-&&eH^9 z7K=ByPu(97J?C~hb9yttfV(bd^=^`2+1zZxCGy)nW_A%lhrXAj$!;AtHLMv3@j{Cz zn~DtwD3CEw7WV!mr>m;orwA1J#E%l~2fThI;eCph+g2~1YscGX@n+3GC|&;ku+f$y z()n>yrvIQjzW;7fqo;Pg=~3~;7Z&S3xb&kwk3I14vis2c8IjNWt(7xWsXUF7u7r(| z6b6d z556K}>ziTlk@}QXwk+cDc!J~3CkbT9Q>b>+RcW6xjk42@q`TYrmco*e*L?gW)-x7n zS-&%IjdY!?eMz-E<(UlJQ_1w?W#r`Ln0BMM%SaO~_Bvs7WsfS&_| z`V8r_Xge8X4T2DS^1|Sl`fTT=@RU39f-28S5N$y?$ysXhp@BXRQ}DOeJz}2a@zY`f zC5r2-WW)^9;u5sEJcrxk{%3-r(AU7|YCzrq^ZvgQoB#J2!ru~`oRA?H?O!>=1x!Jr zf8;qZ`hR_gEl7e6^#7Kdz#e7Ms5k8V+^kA4_NqqW&+0h3E5u0GFm3&zHE6Yh%t~)UCzxOU6$OYqo zvBAKDp&z~^CfyaghoKxd#tCscx9%c0{FX%!QF6?=rpL@Vg^t93<^mvM$5MqUV_b%0 z5ntyb3*ROunVM<7ZW_al;GI#foN`(S|D5bF!rY3D!HgBmb&$Vsd6E3Vw=N~gEXRfu zcLCp>gqX5c!fL*-?C%afqBf3zTnRP75eAWm0Ej%Oen%d3W(3k7DnD85?Gt6`4}BQ^ zJNlxNFwcKR9;~p-=r{tOjP_S{qvs3qEEgm?{BT3KyZvM@1Q}p-=tcx&=0fcu15;8{B%Gd7NPm|^-YAEt)~s@uLjJj!oSlpA&{2-2}XoOVBqpkFcOk0cnL;= z9tD#S&j#+q=MFkS@8QpZ3CR@QTv33dVpc@h*@E9raA%|-8SK)}xfA058uw@N_`4Te zLOeaVEAw?Xq}`u(c!ccW|0xBqlmF5OC?$mh!krI22{(77JRHrRpi>uM zEdMo@fuds>D2QdCP{{5GN=l+f%msQcXv4j4OUVHa(q5h`MLT z^vK?Joh7i#vdqeL1e;M;|E&rXG0cTAr-ubK8<_BAAxfrG*E4lf9D-Amx|=n`q~bVumCC_KdYJXm7{t{JS~a0byqcNJSJs%mO_h zCM-jkK1?^~W{%chDW&@zCq9s;@*{m+;GQVQpGmF_+)^AaY9kDX*@z1Z3W|%s#Nf8J zf|9^rS=$I&+XxBU3uu5jAW@3C8b7mK@joj90SFI_8^-zP8l<>%ze57_NI%ouzYX;> z4fvC~8*%#yY4)Cf64h#DVng;L^-AV$|C{~)gnpw~ohNh5_-Bs!*~LHD#$+kd8YbJn zHT9eK*Jd5@ksYg4*3m5#$SHa8>1F!z6z=j0sgcGAX1c_^prvi>znOe(xo_eyIUn); zR+FnZ<<(r%8`(FKO-|-G8{-c#3V&Q745Z%kl;a!w+7-QjIgoZ-U0=00AaTwBo9^nz z={b@QH_n@jkOkpfW3SI+Ikt25dIfPYB&Dz4Pe_P-Aa20n^aj$Q#JhH+XG^uXYA-{b z@~mT7>HcGqHT(x0mgI3y9|}23%_wDCCpD;wxkl8_6Gt=30Gj zxde5~*od0zzOeHR zqcdn^UUrrI#6!=IW9q#*ACaMVjMyfFf4P2ystHaZK#g308d1MdgRtnO{@tjRVVo$> zzUcI*#edTpnDamV<^LO~@jJQ2B)j;_d;d&Z6|XU?3ZcP5P)txzNb)bR5D^5I5`Vzr z|04|hpK{q(O#Dqv7pl$GoX-iv%AKJbIzH?L!E#a0s$Sf;{csrN6>@UIu%C41lNys6 zJMd|T-aw8BY3kiyMOsARW2ce4hfA~D!O#}+_6w%Pl%6>wKw+j7?P1!$?u~t#?X zvSJsXV3AOC(|PBesJvsz6tzec@LF9tQm&GeeqLOBXkRd3Ib3Hj*%A3oprTP3`J~qK ziJW>lVzFaPxZme|c=V&XR)|7%AN!>2y;rms&8^~>+FCqBFRh9O1(4*T!m9IPI4J{9 zZQe3?J4ydwx<=N*{Uq{XHgS?gO09Vs*Zhc|`7A6_tD4r@x*pH!#RuUyDE z3+T`4Tlka9iU9nB{kOTS=r0iAhw;L$9 zv=IORBY=*(ERkL|pk(BZX~RN@}bFibY<#a zdHR0~Lx0cHpVBY5=(A}Q#i=1$T#Fx$ecBQn{Wp*E6Q?}-mvJ9Ho#C5#H!p2>3-UN5 zX)}qLts>h=!lK*%%j*w?nh-l__BYh#S6IQa!q#Pl>rIE!rPQto#H_%_TI0pTxj*X9T@3UBPmn# zxhke89918RDonp;z(@M;r>kbRr8Kkf@u=wQ#O%y*Ogw*(IG6FX}$G%r<{M*M;$QYr7}nbIx_O!la$FI!((t)pG`C?NX^?J<~@! z@)kX3{I{BFYFDK7%BtdyT0{G8UiZ;|sYm92CEfSzUUyqkY90@V!i^WlWa^Kw0)dWYvBtyg@%h9B;fW)fdKFrn((jKZjP zy}ti00%Bu0$;_l7((JaJ%0_)(U~&SUML;!gt$Q@vfUd=w5Hx{$+J9dEk-&c>@E-~M zM*{zmz<(t09|`8*(;jjyL=w^GHkVs8@o$i?(JoEKb{`LNh4E#!^B~W z@zQVi%D83SbI8fl>SjkG)rE=!`4_#muZ8n7R;G!#R0@}UuSC$t)Gv-@mtzSJwejRrGS%BhmlF$0@897b*_9F1oCAAx!ClP+9OT6%LH~oAD?X})K$s!w zO4sy#GPat0edvwSew>zlEHu31v|Ym29c{}O<>G5e%IUMnE6k=CjD?`d@_h{pnPY12 zm4Uen^qB9&!S>U8mxV62o8!T3F-ggoJ(#h&yy&M984@qI-o;W)eMs3cEE#+3S8*C? zp0u&?d_!*xymSMypJmH=emu&MGMKf<4jhp5e30iv8<8Bx^&n5EjHPE;eKTb*VML{N zBYr7+U2?SHlezxrfk6rXu-|AAE6=jiQd={xGEMgBa7zE>avcBK(y$Hz8>=4&&#v-K zRXb>V^HSzRTGvtKl~c}|=1l2*<3u^+5VgRrdo7+p67+IieQIo^!r-;qYcEU$i6mi? zJ4zeyw~yFT>qt+?&Fs(?@O)RSy8QxYCMBLQN5I1lZ{Ix3d;rW#ZFneO)ks8CR5VTF z>5II)JbnlmqygG$E0mO~@s$5<%E7B*mR`GwBsI2gq){D&5G9uQd3F? zk}Fe0Cz-^;v{zL}P|S>R+0iQbtBYTbW2|64hwtK9SLIHp2A*yX8{vO&hDedQ(_Lz~ zJZ1|Ch~mP0v?)kygm1&Xtv=na7)e}a-sI=`s%LrQ1&~kOd_Q)9`u77EXeSDKt8BUqOO2}* zDKGo%+qKF_2U>e+iD={d)(wsk%!uwj5YK5Av4zNL7YaXeV9lef?)ff!xh`&hbzn}{ z$mmr`PL5T|l=BYGAlvf5yI^0hvrpqlr2n}&7rCDe0iXuKuz+R6OzM6OA zmX0Lm)(Ib&LJ>WxVzvH`d2Enru(+7mM^5s9O`73?K)X(M$Ah)W z$;sWjetw@Iw}_3Cev*RHdgrl^%qCDTQUv-)>s$Jn3 ze{5Hhl|Fl*nud1^>oa0LeX|I?SyAsHevDk&EPKvgab&0GXRB8QP6i|8P-ad}>j8!( zo>a;@P7Q-!37vGWHjOJUKC_dJQnH58#x!5T!wL*q8_dm*llxXQ=T`H`(aExc#h#olOf&({VwK)n=833E1Y(khrg&lq2tdBGfbes;1$!DA@1=q|Cd zq_Tk1`&9?*b2+@)^~h7r0-N1}M}3FKGU}2B@2RaODnLgXv|bes zbf2#0@|n(k-JI}FN=f;_&b0WDFm*GZpY&?e8*{6z02n=Si-@?mHwu_U3l&eYefp@X zmM>}gOmsc;D?1D3nv_nKXITkDOiygbiRl$sc2<^(1ihBJD$Au~f4P^8Po4^ji$_|) z-Zh2uI9Z;#vC@5aU>FvU(DsdHZ2lW&c z6}4UFn!lGmy79zC(iai1JkH9V&m%Wr2eH5%##=EB&9Jr1lcVA{Uvs^E`#OP#$_WOt zWiC#QEp&a|Nr~kWKhyBy&4$!QwWrml`E&Wx0s;(2m3@T z{!APQCOW#)&XvA&b^Bfi(%MywEtQ(AE}`Ho#dY#eX{ZvO*tbDvOH3(p$Ma!v5}Ey~ zTn{!#_bxsDXti^6dMQRlP*O6=3UUQFsIz}v)*;SmB_5n*Mk7CA zEQM7!eBZokV4*$I=el;h{&{o zrKM%ug9rGO-_{ceQup_8+ZR6H0NZhVKI=WlhoYnBd(2Urkl4d!sev=OFOM@Qsvm1r zuB^n*N&6$T(|W2~d;@!B$dMf2!Dk;C@aAo#VdBRkN=W0rqcLtb3#S9JE|{uO;y5L%gYFJ?&R1JA~w3No_lnIA72E> z$;o9{#NP0wz~WT$(F6E3fuE^qX_qmop~x35x=h0_&irw9JUu;&Dk>spU8xRIp5KU# zdo1Pngpn{@LA&W}uV?N@8&xy2=y(=SrGuy`E@9;zcFZ-CWQ^21Q%&VH(=uh>+rkNE z`S|!Offi?zPvJtg;fygV3t#;f_D>!|`V$4MvaZ6YbbWm#>6(zxY@XD8iWrsb=D_dY zNW6Atx?8^UF}xlL$u5XRy)0GU#2KuOhaT{9_b^lK4IDNtC_Oszk%@b4Uaoqte(Yoz zeMzv;)Ow!wP*n>K-Mw)mdj6r`V?XsRM1XbGWK~^V z-Lvs>i&KKj;_)KI7F<`&E&)%%&<&}7{~mEvPkE#K%7$UkdF)T zm9Nh6f(<8Frn9na6ACWRLku=$^_6=LfBEu5$JqE78xk7FPN6Gi)m&K_+}*8C`HAiG ziW?m)MJvHM;oGBR&6MnZ4m&qjSCxPOSyNL}L}0o(OFZ5^h1}hifg8YH$NS`OHhxV@N8dv%--Vlxm)Gj{ZT$TFd^{|S7xR5{VpjZ_98(-$ zFY~4IU(Jl^=s(ui*UxEcV(9DZF)weXBW*GtZSPgX7~IG<6QTSBqt7 zW8}W~OYi!ho}ccv^b2r2Mvoo8q^fK9VG0s|1^APYWZ`$vZ7as;PMD}@cy8|H-v0il z*gzjKS8lgb8s9tRdo>ffva(WOw)lbwSx$m^h|B0RF9js4<-p3#Dy|JoNi-3P3V(b7 z$@liXaN1{%54Gp-SmVyp2g@8xTW6NOSUEcr>gnl~_665Lk!4o>M=q|e_6^IzWtQr6 zin)Vi0?o&ZKN2P1W)W}IKL7!m0|(}sP+@zKOo9g@PY}_pCq`l`(^@zPGQ=1+sH-ad~ppJYwZx)sLmC=lSDS6TGJ4t>qdxgLZ1Tuz}l0eo~Jx zr$W$5)V1{H^Jf@XkNk)TY1BRRGCRabrHkX}Edx^;DP0;*W`Az*kHc3j%VDw%sZR0! zmxG2KE#4ayXG1-)g@Uz;cs;8e2tJ){*E~A%Yl=%uPQLz8wfwLXMvf16cfZIO$LZ9B z!d$`WU7l3iDv-PGAJSRWR98onF7DR9!RL;#8UVY9=YMy$-c$P;{ae52al1@&%&kwL z=Ny@^I^IVl#Kb$#D=L2I)MLX(8>zLlw5+YIF#=nzVn4#^B}(n7il0;uNIb?bE-xnr zD|fteC&9phqbm)BnZP)jM@L4GiIy5{nf)r(+C~mimriKqIa8ph3w(Bum?ROloiAOc z0}IAT%c_hCZES2(Gcr2b+CrIqh*E*(+ptz8eB=6}X%yMBtYBtFSKrXU&P1#D!gAP4 zIe*B;t>ydSs@z_DoH^C=h@<`isu%H-BV%b=IFkmCp{PqvSV&R(iUcj6e8~Jyx7SW` z^(+XuJ^x$Ja~}#dQAf1H35kf_Y<^{7jH@0*@1pq?v=wM=^SG9p+p zzYD_E#aAug%Q9SjW>q(FMicBH48GtXmPiBNtGk);Gts#~&ELJlQ^>uT?$A1eHalNL zo%!1O`ZY5%GefKXZUQWf5CKmwuj`)eJTc>)v`VBy35jIhBJwz`5I?c{DI{$YldK=A zbG*zf%D!TseYN2t9u_zR5$rDUP>JPDvba^2MQTb?(i{8gDqpd5B0D>~$EUFLzSOKN z9LVRE9dhN6r%pG?!@=$t^S(`v>$CZCSBoP!CzZcZGvmLyu3VFWfN&@B-7nI zGL=8HR^|QCcNIwj0vn=taf4&`$79rF2~1zgPe48u_|j;imI{ikV8>&jp%_C39}ASe z$);vzYWkTML-%{(w{G1cE*ZmrHBAJ_K%8QZV>+wq6*?fMW zx0jhV#u|hw`}_O%l~}gwF%*QX__e|I0V!R=y8CoBdjFRvsIX`_oMw)GKNeB{a|64U z@oUmeljSEa^d_OI2-;dIDt41SH^;v}%Hvv8cQcRo$EALR%=WTx%^+L>q5%u!x^g9S zWL*hBuCo~3?c29)uccX5WE_AU5_~OO1#KN2CC?k;It#oS`i2?2K}2yWN~tvkigfz& zrkt|3?m8Q304648_H?zwfTS&B8Qsl+++>D9q{yvukt?gN(JISY&-Qt)U+qFI1AK~z zh?wLz!(3T}IkawjH7p?N=DixGip+?(9CTx$^@ca8_CP8JcIxfHfe0ARUyiBqRt59g z$*Qr&4VsmifO3llN?BQ18rf{w%z(ha^J(B^3Wn? z(C|3qAriVrlZaBgmcSWlak)mKRDrgJygUq$8M`;kf{ZnIWWD!FVp4Mc`Y6A*tLcp* zf+_0Pr~YyeV`9**fS#B&Gnt^bZewFZL0en<{d;6uTgE=!4jnc1@eG6a%w=&?@tkr@ zKDrzSNg*SlFPb_>QW83nIcF@a2Cn}8^a%+GAP&Rnb!%>zbsZfW%LP$&ZEYpg-_xnNYOiJPm_!0j8qj*E?LTlx}QvW$mR0oyY>I}3I^{@{jDTw(wm9uhSU6$-vX zg(ddcl*vA zlVGGna`d*ah3O_@rp7o$TD(lW2wr;m&&~Ty%ngM-1Sl1(-I#Po|59&~ad_~hL?4JGP3F-Gnq4-y?V zq2{a$y)@FABO$VmE5jHGoJvQB5@~7*W^bCwil(NfGnG_#U5{!i=6b_S-MW8>l(;PLUGedk%p1Ij z+S}W=6jal=n5_E8KwdpGJKLw#)@ys!|E>saz=?RvNuNW@L7_mOJasQy&!YTuedl0yKV-V zQUQDB^a8!bOu7A zL?YunQK&QRr+BYkD=}Wp>`(5u)aaqzx`Dq&tGayFs8K&T)%gAND8+w8INLY21yw=| z17SsKYO0mdsp)f=w^XL1v$H;-$9Y|kcPge8XZ$)vz3JFh5UdeU@z1|c;@QeJ%^fhm zVRt7Rs570otCEos)li_?hd0L^OJ8gR8b7ynwVW*rIDEj)7A~TbpQuX4=nb!*4C#e4 z;)lb8ghEeFe6PU-uzxNwHx~+)xb}##5&$p3eAh%dDemBA7=#DFW4Tr(>q3 zTh+kCUd?*Zz3=G}zKuH<`E)jqf zH2K;iKhI0;q<3K8&Jebne5SlF2`UE8FHXAp6np#hXjgz@!x~p8%$JM2ZEcN(ihL^mINUXq;5@L zDL)4N2rzIBvnhzYvlBr?R|#*As0n0)trp;-v1agN)7_Jvw~H$;sUHy)l@v5$*FT8& z6>FFbA0~$!`!{PRCnulNv41YoE6nb0Yr_Bu`6c}DWWrto0)nBjvG9lpoUwe5@?@c2 z=$BtsQKI}ExS-vZA95dkmWYnO2img8TDZ-+zWOv-PyZ({+MK8edeFW2J7;+Szl!fgIQ&HzL!E0uzknUre5>~^lPcohJ2ucY(;RE15EopSk9(BqxY3jX7+5%>KQv3 zMu*LJs;OqYl%)U{?~Ipr-+m=!*@L~(ifgeGjL1PJ<=_uVj6E10)&&s{pdTRe%F5VW z4-|ZT>s)hw3BReSX>EI(0{d>Wxs8h$o!mh#N$$&+hNG(dTVzp6b4ff#=Q}$MyK+6R z-DfZCclfKl!cKoOe%Vq^B6bgFO)9Lel>e~AsA9*})ip4glv)5c@%ua{2gm$ZKjqwX z5|{uluac@NE^s{Dr^mtua;-7|R2k#Ko;oSz>m0_JvBb->k*Z5RRbmNo6uIKl2tt1m zO$RIyoHg@?n>1kVj~|mJCMM=oR$gRhX9szxJ(ExMXik5@K$dJYt7%6sE0x5nIt(z6Y0Aum>-|i3@P+S6~2y z{0j2&tXqu3K4txI6nOw*TV7t?Pkd;Ft#X~M&j`+N!hGd|7`~lE5ZR6w*$(0{^jjq# zya7EA?u343{y|gl!1ra7u4AXQ;Mux%5UC5NW8O^?%tECft z>2$NACF@J?v3a+BHT-C2)``iM4fhbxtWo{_TDjc_U5jnq`Ee|un86kkzzQXq1%w8q zdXIMJEcd|bzs=DTcX4*mvK=*QYiYHu?ib370iad-#A8_c$g}r0Pdb`o!ovyseEJ

    @eIOv0w+k8eHT-^ADxUI(QO@j|m4vNm(=cu8#De%l|QkZ}57 z5=f7+mn;ek2NxH(r9I*mY;5d$h~x;ziUmPFl9=KBjY<&V%^(M4w`A~`t6h)L zVH3EV)x`5GcJ*S_T~$LnEXkbgcNrML`KobZ+mlsGlC@Th#F2s$68C*%vW#G_jCqY~ zZ&MhSnHH{>dI}apk#Sv^*#o%Q1CdixCLPv-%CLU+!8)5Y#2eJt4FgcRNLqV63T9AM-|^HLrrLHYm3Fo$_m(1$UFZ26FihX`?W$Vseo@H(!fpT>@R>sFcttI zzy=FN21vPOODq`O+Sys-i$iJcjH~!g^Qo(sxy1$G#-J4wr*$A)Yr^^>h{D`(Dj>)y zfgmntJHN@8)$)#$lqW{oH<~;0dC9iTSXbqgl@Wm$MycyrVSyEzl@bxT7ZL&mpsGx@ z;*TXI>=buEeeyDaQ=5gFkdz^XF}OcKlAbs*B?Yj?KxM*?UoU4cv5N)LLbNg@LO^wF zx$n3h=ni10H4m^lP!kGIZZ#SOfD(yzdvHAqAA8O!AKDweefxF~X9bi`);2bV`y?cd z6kyqznVs|V%;mS5o?v;%Pbo_>g~&-ur(g2Fb$45IacP)tu&yF6j|H6)m6j43mKdbm zBnelL@cGQ#pCOrlyg#lB0!E+_iH(+-SSt?+i+GH*LbUJ@Ru|f5c8{tP$`6S5fnz{< zd2N*6&AjxgY{8vc+;yfEpcPC|@G@Nv!hauo&ALk!!T7T_bs-07nUs`N^!&Mkx_Z=3 z4)G^T@iS1uKs)(Fe@U1F8`Kl;6V1(*Vt>fD$KfX+@RH^)c0fZbU~#PgTcgyKL?GzG zKuv9RjhGA9k;CpQ-hn)G4z+3SO*~L6C2m`Q4S6gR45p>DFUTt@VuGFQwXZJEAr8(Y z$|jlpTw++()}P5FqoE6uoOQwtC91FHin0#!0~oy{E(yVATycE>j=mMp!nD~)shOA@ z@;QKwp@Z3vekJ9A=%B#Ea$g^2Z~Sq7s!q@d!5O6K>+O9P`XH4L5LPzp8kr*_Blo+O zfIscIks~Y+-5L7+{dIjKqxJ>&HT(@=pt!{Jpq3fDxEpK;5`8ck=@H`Y_*S`#cm-kg z$+Nrlal=TA1DShux8r?5`ID)%i~z8#nt4 zN}tHDYAr6xm3*)jdSfdDRXhKfronNOJZW!=n24x5;sNRO%nbeF7YRTh00Ds{SJ!@W zwY>!FIViCMFgN^qW{cs;9K_LA2i&LUgoQd!j|V#^VuE_ZclK+!5TlLF?jVIYU^);yhK0c|(K1o?r+-5Lp+XXps@h)QM+IQgV zL1`%dAmhk6gQ-}=@`SVu`1q~KDolVz+?ML%GPoNMnvTM~<8{=_M2@FbtAra*Fl3qF z<%Z&SCFtJ*GS|9_+Dyd_?bz#M-eZP9zMYB07b@szyD@t+iO$k3JDg5gzp|3|E-GfK=>h(<$5ba=Ld_M69Ke_J=Y%bWnng;27 z7!b4OKwRqHWmAWotesn)#do-o#1dr7!3Q@7oQ_T(<48e!p-wrg?7d*MAU{SC?F0U4 zo&O3GBjeld1WxdOkul`I6Ff7u1AgiSJoulda9YOM3u)9BFUPR%a4u9b!kRX z6yL!(SSH+$ii%>pxOrg(lrMq#@JN4AC84FIZ9`8$Mkd3ch>On*KsY+GOis>w{aRv^ z*|3Bda52M618+}KHmTyeOkSUU51dun1#SpvD#)uPBflLVOAymbfgB{2U)M@w7jIx96>dME}Q@KRTtjjgQ`Su-T*cRjUZg<^nv-^sc4D-G{n1lcRS2A zK=^?!mBHu)9`Y8!o6waRJc}4)TFijrwiIa;mc70G{Qe1>QDqP1APtaHZeCufg{A!V zeu9?YZs@9_1#vIUkO%`<$@^J!T=yc<&oEdEf~-444M}*L8QKPdBMncdK@s9uH@vRX z`r6&Q(m>;e85PAS@Wb7|9XMsk1<)?I8y_m);0p$Unsw&`3iKj7t#ue)``weITJsAn zH~b1{9UmD+5QsX+-llpy<*Wj@F=-F2?R~{OVTb;Cp#1e)p$<7{TaN+E#`?&!SF&fH z+rz}G!61+<{c&a2bwZQ2G8!)jgcSW(_5~EbiVvC)$tP%e(sf4UwoGd7C zi(*Q#J{ySwMTNsUJX6I0Kyzwe{VsAU&n2twcqq-PJIF~I)x4T@cW0*}==-Mdpl?AI zUr`DE0e!pqMy9#|T`KUR&NHtCpIK~y^6c?Q_Bq=HvN|Wpmn$pwqd!a7a+|GV!o78u z>SixS#0bXelo zPL~COe2*rY4@EB*-GItiFwSwtmID$HTrMukNTe{`1wQXoWJs1anxFxH45VVB#ME1+ z7;xr*8lH5hx^ux3;C2DjptAc zR^Tb@-pI_h8}8ApSXfv{G6=Mw)=2}88s;vOMnP`kF3!}XmOXungC?Y$oQCL=r=FXE zzn()(yuybjF6`}b7~^oOjCnWZ9rS?<1!R)fa7OaYtH>2X;GdWq`liNX8Kf(3k6qDe zAn&CCh2E{*t*x`+K26=CXwRzXWrC^W$2FUzYgjPcf)IYH`I#E(#uGVmh=zuSjIM#f z*L%i_dlV~%B^2no;FM3@+-}!y;F0vqYY#=w`^b^AZG#d+P~6P4;QSC==WbdyJ&qu< z;M)K=^WaUnlItrv5DPxfV$zL?i(BHndJ?t6(GztI9mj$40n_&Sy6?sc2hloShKMz1 z)t5q=(OL{Y;0qw5Vl%8NWx;ZiZ zxa#a#4Rp_{AJBYjAJN9T)~5-S1V^8ca?3VIm9r35jLYi3Y%bgUsqOqF1)<=38P>Q=BU%AcIrBBs``k6M+ z-kcyCRJY6u$n5^Zt! z7D;6<6@c&CfI@5{N7Fh0NC0*}9&kxvUGaMF{K_&G4O}J4jzD1#x2IFci-oV_B2}W4 z@^+^jvirt+k5JPEFJ~|^Au9k;!XzPAz)3CVDq}Bv(a=xFAZ3n-jI64xY)$SK?KLXz z?bGlANz>ffiuh}fC7j?o0%tdAtE>RWX^7Id6vG$z|8q)Q|&&h1@hY#sfjngFFzC0BrCi0ovrih_5(OW1W+( z!BO+_2rtapWvs`KEp626I>jIUm86mA_WLnP>0?zN6n9yu_Nds!x6MNQqLVH96;D+vw z4W|JB7I0V8rGLs$Z``Lr3RQ1MQQZ<g3Gl44vQnO~4}@6Y zDCly*cSM1Bk+`Vn0yuR+UYkIlJ+~W#0z~#q+AiYbwNwFHvi%#Pw=WzJg3~KJA(9En z_v%L3B!+FW0N#x$I#YOpyaoP@WO)6! zd(59-X{jBglII$T+8&xBG*GDeiUVN-joby;r|F zLz-T{rf%@wwa<>p7=Rs}_@gUeAY^a6B><}Nx-{jW?sw9qH4+`~4=7VwIyxOo%YoSC zRq0Xg+aCV1AZhY%et3n42XH~j`-eU8A9oDq8hwRKs2e;1=cfQNT+`Dd1Mq`BA2@L{u4@UH{Qsiq zyyL0v|NnoG9SV`m3K?bZ>>|pFvbXH**jq?alo3MqC|kB{QaM)k4mtMT`}aK8=l8wc zx?TTVSFUs3@7H)fACLRvDIqmgRjeD@2pE97nDgHopY~cvSuK$hBRs-*F3^V7;{P&6 zw~Ej=@rTxCN#sl42^3`_brm%3&SEiPAh^^p>r!)`IF0x-2T&v!i7#esntY#PjxO;n zOr3;yfwwy}q`5l!4If~=4deAa@4o5j9{21gK}uCT!p=pvEL3O^Jd?W*K8e-ri;ysj zGziou;3LB2lCGmdw>ddE`$k4ygIv4M@DC~rIl!H?6_#JYDhh0!>3t4+Tve@V)UFyT zh)a%^bB|ZAv%hIMJv}vB87e&4?<#P8T0_};1hpq`y8;#Jq$6Ha65RQ#75Gx9#b*yV#m%vt-1HtL~_3P3= zVV3S3^!P12)<{TV55%^5gQpa+kSf%NkRy!0iV*o=aOLz@hjK7piUMLQ>4ym7Mw%I6 z@7ARgOX)=sI1%6kdRJjPYzkH$Vw-qbK-tXO`-a80#L%dzG44m+!N(nv`=wdqqt($b zMKhb5n|(Ysrn(FiRl4h<%ili>7Q5Qp-$eHw4^uRZs|Tu&$_~ zfx>rqs6`kBl<&knip3)rSiDZsX5Cx*@Q-;U@j+#!kifM5dpT}3)WI?4p?lO#R)e^p zv8`xKiV#r7_Xph4Ba23r`X#bfoR^U|eC#>+Jv~hM*x3*fYcZa(gR{N2-feZK!1w=)~wuq6#d2hSY(13@3BR*{cMYv8>1afY3&{Y zSvsfOE4|A4FH`ttfCeC^RTD16aOFW0g2i<3f1k|=Fzr7m57=05+D&EWmQFp`e-g*d zED(>jorcg81hNvkk{EM+{J6s<;=qNE1}Ow&KmlWwJUCUMbg5g#<~Nm|u0h@boBYFb zHqLt;Ss)!iJC0epMYTT;u6FicLRS+y@JlBl)J#iMCLfha^cZsu`QxqkwawmF&aADy z0Sg9m->c$@3~&Ha4E>pz~J4kdTldKC-%!GtY+x_J@U5>KFzdD5J$_@w1@tAmkyX4(;+4vM+jQyloFAb@J6(yFS2mtL0G4s)%J zRdBATX{vLZJ}Pu90dYkUVRD0|+jPRYgI@ca#XIAH z&l|mhX`eYjy@&$r_sy^`=vNOe&ZaNw&uFI)@jS#0V3i9PdEvSW){c$3iqQH0z!>+> zZsDVwW|^zi*j_Y=bZ}Zux5A&Gzi%-cWT|}TM zr8N+DpOLqbBya|bHqr~%q3Ky^D-Y~i;n6z6f0SrSs*biU>(k2#6ji)6 z^xwZ9nhrFipHWTJET{mE%7SAcAyePj$cQ=N3;0IWzzze@jnzgK|9EtCG+=#k(G&ZH znkv2{?`uwMu@xq4aTe(wFRc^Ci^Gl_h#oX3PJWkD=E6v=P=_H&k%bK9vj-=X8>Z*41du|0I+5D z->(?BVy}k2Li6C)SO1JiJVt2ap^!L8Lw}?j#rjx9JnsGXjhMA`7uFJxoJ`hiG0-yr zn0o~3*Bqk5AodW#=Ghx6uB)f-WuQ z*QJ$QrLVC zHl1tkbHx|O#aKUsMKh0%jylH1#@ZarpB!+-saQUVZ?uZV_LgiqMJ4hZfWEZCD@}v? zpXG@p+BrV<20xJ0+4Z@5)Cp624BNG5;%sOXWIy=X7$tf)f(3- z$JNx-r1f(@8#9DIbb{BldvK6@=rT=Xjg6$By6r-7q`L%92nXpfmDBz1aFhPvi+5ep z4L60+yHv!W8(tv|yBgK;yf`(Lbr2ZAX2}{pt=f%-6E!`(r0CRjZ7`VcQr!m$@B5j> z$Mtj-Y*$esb|>UcJ5a_J{YqMONM)s9@@W?imAfqyqA_-TBEMxcL-eiPZnhQ7%lwe^e%7{0{KB|9uW7x>UZT!v zVPC=v%MJ6|EhWHdrX-p{S4iYy+y&3=Uw4p1Zm_t(`ARrEcWscke%U{_zW!_+PHoD8 zBP03e>D^&p-p9IDS?VkU^cEiqCF&cBdDG`3%_F+B#4B9bmnOjtvq6 z@0Y#rOn!_(Ke?6$Rl0{BJ1S<3>Yedyuu_74{H0v1YB?K&QoxfcisIGxqsGE#Mc&HtGw0`4I4%MmSfkd)E zL(!u=YHI3lAJ~-pp-=;_z7KaGU^AHU%8BIzK$RY7X~kznjquJt8Lm_OErX+YcGb9U zEUv}Z!~_fIH-roRPEiq;va$c}V&85g_6>Uac38;q(Z%=)2mAZ8;L9fZ8%JI;<~Q!% zGa`i@%_&?oODlEQxRq-bK=mE(_1QW9mWF9kN{ZZFDx4C6T#R5$Ntsvc=>O>!;Fpw^WTf_B|`k)@@)u!~B^YhHo8O5nf$Ej7KWN=wM| z8y=FML>p%6G$n5taq%o1(~Ivv^0mD%yMFz9(UZJ8MJClT9^_&ET%AmYBQB*K&ikxw*O2a^1qRjV<^h&_uv@fiKcJ z(*&TyypX|1j3ctxdvkCZ!U3jXcrI8wupq^EQ2d?;lO7tUhYb@R@;X5^p|UN>$>vSI zUaiS1JI8vDHrFmT0!)mZq_^u-j+4~-VFQeYH@#(h^K#N5?AHr*`{`4GaLKK3)wJ^R z*byUp=ej9HlkT68A@hZwE5-g#<&f*+o$`AlciA(wLyEGBrTQ0>m7#OI@cESj?s#AZ zTb*`mXq)dB3@q?Y9*K7HC_b@h;TO!sz>d{=95xkaYiUWUH*A z@4)CO1!s_8gPD5HojJt zfkfjA0i~Cin3&uIBpukO8D(YaD*fixo}Sksqr&{kODs)TK)@K10IQAe_e><=zlOig z03NGx6!$pnQ@@k_W}AwfyGl65&MispA(ya{FDGz2CLsH9ZVPV?9eMONxZKm1lPi#b z-c&vlOgFd$SN9^k+UJ}fX7**RXfu<`FkNYavkE|8um~|pH%(3X34iiD02-U;T}m5e z3RwpBy4eg)lv!i^;G;xh)a(E>)tuJt_aAAqJI~FUHe7nj^Cb-C{5}Kdpon|OSX0qcA)e9Tof-cajA`NtbHeh&sJR&#M|3;8>pnVh- z(3&?ubX_G&taz%O-0YB}z9NVT0?hK8{7c%J(Yx5A|L*cHs=#2``(~VGKNZ0x^@jcl zGoXL~^bUm((C)75V=X^(^X%3A7^}16J?%z+i4TrKyP&vap}bY`kv|O8)HWBl<~lt1 zM)j%vuYT|-6;~(xcr#^Q1=~A1_^}o#gl(p8+EE1lV;ubXQ=!{<-KB=P&WUdjievw? z6{ByHe-gg}37L`-;elgAxC5{twV@~09hGDSn*oT)(;b2ph0?^Vw|wsMe59#E9zdwZpv;~sww?X)tTzP8XyFo?DgqZwDIL8bLFgRF z0uF<1cp#Z%L9N|Ojs_G0bMMADe3(1gI%xK@j3q=R{sdo=yBk@ew(2*Jhw=jd#=JGT zZ=P0bGw$MmHlwP_nq*J=ZjM#9kb`Sc*4ffOCy~u?RbOnk4uYKD%#>_6;ZxTve1`nZ2SEoeA&Ul+R=fh;3XU&lfKzqu!7VkYWu%;V zDU$_d{Rwjb|0d;E@&+qYl0&~3lhPqF={^MX>-*8VVuDG_*K36cm-{)em5r;$V}A4< zaic%MW(HXkTG|hLdSi5?VHR^svi6Aps(gK(Z(K#3`RMBzm=bmRT*H|CJ9D9Ti{`fK z=rtK#b)}Hcij4lOJeGT*+`coMlyX<^efe?m^c}FjX}vel&<^H(`Et{`^48f=Pr#3X zfmjYVd(Z_yfJc-EW9|XqMV){J()o)iMkvuBFJW$Nfg898@y(e=c^R1?Eac~ZEfWT4 zc`qF}m(nZy1^j&u%}+aeE-2ES*w*$Q-YtA}?}Nh6PtO51OXzDjvSzpD{mg}jhP4Ow zW+zAM2-_Qu^MPE+y=w|3%FL=^!~X1D-bW$(mk`P90=)*-l4C-$2{O1P}ztzF#dDxb6A1>{$9h_j^pKE}xSOR~UZefzQxA$i+_(T>=+`XY8Q3BK$X`@JT@u_(3wqGfB# z2|q1*jQdVu)&!>G1wgDU%K0D1I1d=#!Ce*)3=HU@815SwxCFV8{K4N1P>3g4xE?KE zJIwLhJpP_wq}}wZO2yRQ-@nu!2mKNb==FV-ku}m}u^pO&*3 z#lLTujkv6^QV~r^O;6aDy0Qwzcj6kCo)|1%i|QCH|4&TTG@m{#Pbk~ELLEK6h-jL3 znQ6vn4C%7C{Yo@b`>uPzmoH0(cl`wu$WoKgjyu!s+ikvw8CYAP<_PBmWEFp8H@87; zd45^hcB>vN{P2W-d z+y;q;QFGRs-$E!%^?R~bl?k*Nz+({ExI#xecg~i`@X@7;mc(t(D$fyt`}d499{dU8 zCb}=F#8qd4af56euCqUWrePt2_$K@wneisqcv7(@lz7i`blrB#?N=0k1shaNU%%jY zgW~PIjEwfF2niHS01o0SujFDTmFdD*5~pKCyP$joiUhLVcv&FB2{1MXS7 zX&wCrZyLi?Rq{)CsF%xzxCgxEs!WJaZ&G7pJ0HOgxxjjv*OC z#;uQbs3?`7aap#tvO3g4 zD5>(#DNQRqsn4YtR{i>Ru~p}f8c&9olY08>*)HLSA6Qo|ungg5Tar|TVcVtJ zCE#&p73o%B{L|HMJ-4n9yr4@2qrs#jl3sBwKIWqy7kPL|e#1Nw`m`34>iO1REh+wb z=Zv~nd-}EPRP^_=4WqWGfO87E`_7kJGjB&+g@cHO$0MV`VoS5h^Df@>Th)^P`lk4i zQi4j(C^&FQBFQp0wsGy&#$sJMZG~>ZOC|g^szjF#B{=Y}?%Gc~6)@38;1ZsG7bqZ4 z;0N+myUx9^;MjpQNYn4QKb2t&vLuYdZ64P+xZbm}$7i@o_vpHwkC;Wptxwh+vj$+^qmLQX2@qe6KJyxqa2-53Yj*`vf0xhST$dMoY%m znfM9)Y1CT&{P+C#pthN6^d+RXr?;a%d6zCDzSo&MYR;tbJ7S=#g4;3yr)lh?V9EGu zT8RkWQp)~K@^{yHRB@2GZD|M67RQ+34i&GCbjMY|^i;hp&65C#9v(w)Pv|9&~vk zbdgyPf5sU6j$r>3&c3A4-}E%~O!G^GfLQCCRpkCpfH{P5&2T%N2bnnWc^UCl~}=gn5!4pU!& zyt?`ihpNnyGz3eLdTe}cpW1j}?XsB2YGhKQmG{=WS{g#C__Xv&2EjPNJg4|phz3>X zU2i_B$(qg^fR$`Z2+V>2)dRx6G|OiIVqmR0;2D%vgNzSL0)SjAR9F{#iQ^%EQv%*bmZd~??D zG>wfyX<+vKt6${_IeAG!G3?gzYEBNM=YfpFVUAf7N04l-IJLYub}V%}n|-0V&gi~g zsjZ7b1GL7Mc!enRMO-Eu5ul$?7;ZJpmm4WS9o*C$jE`&ob|6IbHb^~>7`&L*4ESU# zAybwD*n-5X_TsBMCdBm-qkrZJ9gvo$d42KRxc-PHvnUBob$$KQJT-H5xIRluOOu;` zzZAFqHkRtQuM;ABGeIe<=hxLC2%eH89U1NuZm|^!S{{6=%-#N6)o(Eoiu)ZS$tnvA5M*1ps=;9G+`io#KS8_n%WU&9Yxk}$cVOx zVKn)2N5@{1GCs~&`9#-lq#CQ;yxoaXL^@GvQ^m*G?+`Del+BaTY^rs_rZTNf2b)69 z#M=SygB7#+w5&~IEOEFDDxY~q6`;V#NhSs zY6hW;?>N+M=fIc-{J=M2{}hj22)D=iV)UfhmsNI{Su9{FJN{E_6P@g`xGdr2+35G zJb9$(AArT+Ht@Xp zz}b1zudgz@iy}xAak_}hsy-e4OejV{f+FeT-cE5uc6RnigWr8pda>ANQB>Y5g;h=+ z^d3K7ik2Lrb}=+nco>7X)s;V2D_;zx{J6tzWMxA0XEC|%9^OHg7~JYR*Uq~Yi~+Ll zluUd0Bmp$L+=-~XSD-EcKbQD+g`JzbAsM8|_OJxx7L`Fmpz`kgb?KtgaUOImsX!o9?MbvMP`8Q`Q34 z!Pa>;>{*4xB(+7hrpU;9)#lId82Zk!ge1N;z)j#k?ju%xiC5AUi1~oQ=jZ+qtF^{M zB0Mk74*I61x+T36xxZ9GY-cYYaZbwU^qxuqDdk#3g6&T5@0&G$R%$pGp6eej5BHOH zY9swVm}F9}z>N`Pj1F zq;qQ!&;?54kN8OTD|v)SSe;K6xMv4S4U_$MC|}{>@viONosy{ZsS>LB7Q6dk5C^%(c&-cV4e`$7yDv49%rL_V67vSTs-9o!L;s2=v&fZv? zNO}3JhCCn+zwZs{y@?NH`Ov%2`R!6} zmEm`o%fjw1Ujua23V!B8j7m%SqoPyGd3i)JS8w7a6yUlyadF|R=T|MY zy3B7Vg~x5sF|c__$%3CQlr+IJAgAIboL?o(sFL=O3)GXKUv_-0)X6_k`qFL*{PU`f z2c(s*yD!`lwM8rSr6)~Gn@meFAL-|-He*Z(8uYJ>M;1FPFn@wLV8dtn{;OSyv84<4 z*C!g6d*|gBPVIj!o<3ka?v0_88wIQ)#~PC~@*5J3iMLOPkBv13W~glq^$VPQ*Q|G;b&3sH*bB-Ojn{mosH41#XD6o ze^6hYTuj!tJYhsc8avd)3*9L?@4DLuK>36CAQO2w!Bp5f2uxr*$J*;vniS>F>(kI$ z%GZ75X>?u_q8pe;Y-~hk|AXe5Fv*J3q@IsjBg{ zYB4W*YCLYD$|rUKSsm@qgX$4R7pq!oS{lR%#embAanmKck@5mYZMsN5(9>{x63IWf zX5utqh7gFza2e1y8*knR?J{a|B1@Eeb1HOO`aM2zo3-lLH71%AxDBK@sL=?BRA-2y zY;9~@u#t$7GIL^>Sl29B@wT{7ugZcR4e7h$hU2f2CJud6=nqbphKmh55~r$=H^Pez zzuhp;HfIBbo#~1+q(jp03kl_TzMKb=_|Gvsc_yle<{2mW=M2nvdb1xFei|d0Ec!3F zRVNVLt@*6D;M%SRG4xQuIg-`gKL=$+yk=tTFl!4HhTdu`z97C>xHvZ#p&JudHBjAy zbQmOgGN9i&J3D*1pc1J7`*JG2=*15o7zMa+F>iD}AMWToM>|2YK^finQHe#M+ zOs@1dSbyKyzyE1H^%>w7axyYlkn_gGbd(R)oWx4XGOr1CF`|StDbNVx$7)X9<0HPJ zAC8x3EqQ5)SS#RNt9xb5C)v<$6<%z)P0IfnEt-bfM(TV{>QWEmmw!#kePL3kGgzC( zX%Ug~UqYXkks*IL9=u99L_Lx$)LXQuJJ&Mw!iB>8ig?sg)+IDTO-m~bMn0wHkrqjO zP`EreFyJ~h@h@2K@+`9xKH?LxYqX3fZ*}fJAR2tja&lg=i7og)1x}7!yF3uk`etCC z%C@bZv6znicKD%4U*AAN5|rGW73j2^yo`3X1eAhj}xbJC8HskspoH1y}!}Kx_ogV#ceP4ht)bgl&_XOyF9l3#hXC8E7x9- zH3w0g=Dj9XQ=|JyE+cgqw3zvDVq@ z+j*AD+iAkj1lUpR68pWk6L{?GzJ(TXb_!p=jFBvqlRX}h6C)qTuqv0;edo}kzsyNr zLgr@cbieFRGydX!fm`<)1U`%)u{6&oc(<(KDF9IEgEmQ*(aegsSXnUxsv^Q{fZik9}Tz+b+8 z{kAFPzK7G?F-iR3T=u4{f?ajj^}6c`8qvcw&Ev*Lw^NCiS@t~A3kRnu5^xY$*gfLM z%*O|d!*|nHmbXMvq;HDLjN=QN{ z)nTJYg}*tW{~2*1-6JBRTJxOE)Y6CNdV`EU#K$Z|d#?+FRzq6qT>7)COHSVV)f~k` z1^UIX-VvufoU@ddqAUmA!k)AfGVfO>H~2h+tMjatfpLhIVSXE zv9`=NxH%9;f??n2FZ;RAjEiE|iOSw7ye%l`)(aiDhH_oB&QfF`*Ke`nyu6XswKa*Z zDO%IIr;d}gp|i8Itihs+H|8qBUcDN#wTa35V&cGay~MJIp;ox9_TB*mTmH(VeV7a4 zq(Ymsn2W@C-U#JN@E?+7zHY`EDd(yr5P9ZL*~oaRye)RFe1p%Gz}L^unPZ8vT-V2> zsQt@xZQ2l5(y;g_YCk15)ED1Niqf#Y^nz($Fk`((Ea3@M3ub6)hRMG_phL%EpX!02ukVkpj}5r=2+Kp-R_#E!Z~gzLSxY+n3DIV0zlsABX;V?bkj)Ex`Gby3tL zp@6PLb#hQmvvJdOZqLoFMZ#Z&+fU~n&Bd7)XCULd5B)o;4xM|*s+U@d<^v*J%8;1V zR!&OPlE<5wrkVdC{*HmFe0C0Y`)H_@omEI}T%#4NG=el4`HZQ0tO|#{Jh$RUDS8si z;duQNm0rL;e6{)Ne0zfm&pn_ip@WDEO|^nmx3N0r>rjwqp5^|`^6F< zL1CrAp})DaGiURajpfdrOl8{rnliguY91-b`Ad|WOn&qsMbh-LeG~t88THMVDJrGkl^#7#=wX zS2whNR(uJZltgbCB*vQOujUjK-1R-%8-{P$3Ix|x1_lS=i~2w>e}BpS^~rH@6VkN4 zluOrz8?+Nv+`N-TT=do7SCLsqX-)Z)7}T|!b-ucHXtLlD9d{;`C^#Sf#cGh_%KfU1 z*z)@g&#kVs)Vc@OO)TP{I);euoO)0<1pO@eX)!8c2$>1JDu;4p0ti#Jk4Qf2Byu;F{ zu%on*!bxzR=+z#>u~b5xnw0N>gpmD6NT@1z+p+S>Rq`9R6l>Z=J)C9^zOiw$oej6r zAta}2rdXG64}be$JATdDvgb2qoSoC*rpZ4v`my0T1mU`dJKJH=NvW)cDxoR7dSU^E4;~_(3gLut;XbZQpr-&l)fabYx zI~GhP`5L(9{?cz7xS$e&g(z&6YvymAKH+96dCoNCfBNM`vxjauiS&zNt1(^ta|52-0e0~l zomAg##4i~1mH`#OWJq_tB_<`~9*5!*Qz;l80CkzNK6!Q9O!~_+Q)uyDcEWH_sYwWC zmX=ifkkeUmC}CueJQz8GD_a&O1#0REk6cAXL_~m*Fz|xsjv_gj`Z2Dn-=VUY_CL9| zV50#*WVP=RA8f-bl$0;}sBVsTCwqWjmZUw=g~^yx<>!S59nJrHc6!voYqcTvxpG!v zO?J%esDpEBRBOfgzA%}pq$G71**R8l^WVdN7mDgMm+_ccK0h2A6!6_1y|Xx3Mb@2i zHonx8p=%VHfs*y)ytb*yaUKVnpSm*51cC6wFb{$F!8Wrg2onQ0b)8GU+L&Ue*_a2u zWd=xy(L*ryVC~s}Z2Ct(@a1A3XSeGz`TiJ~oS2aH-d!xU+?c8#YLqbwYz77fDz3Rmz^mbL?usww1lGu=OT&dnSNY_1baXUbQI{TsY~Q}U{KC@m zHX9p(q@*O(noIdT=Hfjsn0|7&CfsTLtcwWE*K++KUW-Xl|FYA+zb08miZK5-Sougc z>ltUM_uP$wGaHEkf1A4rd}K*dle<#+-)R)`2WLAr0voy_9qsuc4t91Km^!Z{>Jz3a5!3I~%oDgl(*0QirYF7FFj7$=t#p`t1LLOpTQ8%8%IxnyuJZT{7Y4|= z_r@j)j7fX_9?F`0cH{3C&|KH2u2au$d*aB|ykr|NSE{42IeL;h8>HgrB&4YCyLj=- z?eSwJ+0^xVECfwek;#wMM3s22s*=m`7vBjC!b?3Crs3pFUDc1e(f`=V_j8=-HgBrv z#pw>2|KSY2p=Oy%ZYz+6%wLjfBs@2br-s9#wc+^rOi*vgO#t^a-0U9{FT1ynnrI-N zr0s|W+27~qN8XjW!m*5)roAUDT%~9Nw@GA42@jUzXel{4`NK0JB}GMy+VMUnW{xi* zhB+Jpozl7ddI_>kPom`?)qefTvAE}LRiO*%&@t_n?&gV+L9R>a3OpQgQpS!CMr4^o zfAvR(uFlEN_SW3?JnCYpPKgQY^Lu1G`BgQAV<*6+Ub9d?G%W00+YYxxR3le%J3PB& zjvlq=!R1-cUgS=cDb`Jc_Q&GUx!K=$mJ#$zcpB=W5}yNyWT^l{HHGgW4*E$S(?*j^&QHX31)`gH7xYPfu zHpRqre~!Dby^{})jiv1S96L2NWi|LUuG856WZz!D)-}9HmB7=Sj|PG(y}iAGAVxr* zJp<;2LV%Y^k-VXy0j?S(DLiD>%TNbpD~R~gLFY-Q6_+{|THe}Wgk zz-WGguVq(V^#53Zw+FiPCmxj}T6w-;6U%RCEpdGC5FEdys$)p_+aX>+W+iKQe&E^e z#wc0mlov$+ozz={agW&wmSQo%hb{}6lCIe|Tvvx_J`)uO;G({)2AsN4`kDG<1Y2{^ zJ|{(vdmAY|lk&1gN&4iq(}lVuQbVp^dT z@^QO#=@JUzM35%s+ET8Z@{li5hq6<=gMMPRe^TZ9!IY1Us%j5!UipfCK)x5n>fTHea=ayoH6m2RwgQG5Y0| zmA(u)VncKFvcQ@;o&?xZ?MC6bI^)a_xw(93xEm@iT_VWJHf+x)j%PY^`P4sOtJ_>^ zVl^uH-rt^v&dS%GkxlVvxaUT3^B%voz$yF=!SiABz2DD8sy7go=hN{Db#XyZnwae1 z84^pBeSNGK-q{gzwU3|Z++J5VYZ8Xtl^=B!mmIgxZ*K2K(=F5AcW;9>UhU~kt{X7J zp0Czp!vX7oW%^XEDr53}k8TIm;-_I69vkp z-H#BPh!amyZp&&I2XdF_@@0LNfAY5#$$^BGhS8oeO>{g{cCmAzlz*%Q0Jo}N+<71? z%i~vDYWBbev&&%I$)BN`D+%~`cr6_r_~73HFoTJq!(jxxGI4OTvB?)e-QaMSEz~3q z6UBPZ5Ta}-lmOE(oy4{TigHD(hTKzS{I>drDy$gC7?=o7zazP)eD(|$-6lxyA3Ub4 z&OGsuKN;bHl{31f$fZ8IMn0j^*<8V|<$R{}>0R8kewKRvX5Uy8uUWTJvXXdsc7zeq zJA5qdXC*;+6vFAEHTh2-{wuSw1a=kWM{~bD=6;YQi!V7DaH;IAjZ?#sxG+g7Y2A2! z%()=$%x&cuX(6M5c`G!CZ8G~DIju;FL2S-wH2&4p^wrS1@_-`LoYQf5N|RQU<| ziccwSl1^#7Vnv+BpHox0iO}%32nY#fU>d>3LHh6t3~K(nzTVAsvUVmU zkEDB~6Mo3$p8YtSdP@IoO-~O#7PeR+=|*EEw$#QLXRXqgY_+2_vy1N6>x>Z&WCs@7 zlloByITVA$y>3~~@83>taKg*i zDryPa@MEe)-LE1_;~dO*Fn!&V<8Iy44H(_n#27&TV59p-k%x5hHB=lo2L}Qh8O7%wXVI zMOIeU;rsXRhu10-ZZ69%%+Jf@_6tJ6S78hDo5VKla~@a=+@KS23aqlM+iQIP{>o)K zkzN*9pI283Za>snFmK>1j@c7`9L>Cx6j{?1tHhcapE{3=d>^QfzJjLF>UUl}$js{v zH&V+!XlfX#47iUMMMs2S`}wQmH2m9pSEcXQZpKk^Fz$ZlK~NZa(IJPqWH$(LuJqj| zB8uy&clc!ROJbhjja|e@`s8NsOWsAvuVgR9%0r7DKJj@o{lq|}=B-%(UHj{&w|U%W zMcyWfkOril;kV1RXZ+6RA4nIdB51f5yZKBTFRV-x877)tj=KDI)zOee3FXRLnz zws*9%RBSeovr9^%9jkKO7$_IafkF!?n71%Js#`p=O;{?f2LQwwj?Y8pzh9JT-j;uR zXb*y^oPKVJo!)m{oXIie&w=!L0sEtt+{on+5{?+5Y>}%KMaLZYUTmo{-K@ST};{JEQxXPL!h~rg00GQr%BuJ z(=~LiYH|y7iK2p4r|$$EP1;{QS3CM56DaL%bAy2qVvJr#8J)4RI60TwLs&F;Hoh(N zp3O`VyeT(;Fitc_FWFUz3?5H3fjEyjn>3=$_5VfD-FK&nbnJ}&HoSd24=={7O2@c(}p=UJIPJ|JBRS$0Eog5!$l$5BI z#~G@t%ND<6zcvu}m_=PfL#LlkkqydkphXr(zvcerd(IIz^Q}iR6P-1_V`LVGQn^Jt zaqkZ$5iYlu4_aAASN9DBNmzq1RUZT~4+Uc4p#*{-B&W9k=y}lNY!^b5n;1Qe=D9Pd}_68>!N?}MEe7#~mly}o{Cejb;Mj0{f9mey7rml`@4zjtb)()9f$ z!tOs^;iAK@Iyw3G4n^s6*ZAwF+ru&_e+Nmw)dd3|-qMQ%A0b1AD-%Sj1qosAmd1G< z*N}_*P8&XdNVW3KPo$N+JV-TDM?>Vs4eN6^G;#+`jEk{G>dk}^#!L4d|Nbp~KtO74 z;P5iuh1>Gx%B-@$fR23V_f%t*!K#BpNh?>~?ge&a(#E&&F^?ZcUn(o9mX?-Yj+=1b z6A`&?Q&FpEtWy8qVldb3QuNR++~efm&1bR{(eOBV5@}Q3zz%|m9Cys}e+M|2mMzoM z(@*)mR^V5=z|0^jl3m3ZRvphu{&9{MNoynN55m%5gfX~SvvYIl&p31(MIL<=8=UXf zERs8O;E{i2#=tLO{P@XZ=gp2Ym3Q$yx&qWm4byL$hJtt`xq=3Z8^ctmj}%-JyYnOzA7%xFk3FoEgPpqB6r0XOfbHQxmDa5`{BKRf^{W%leJ(^uk5qD^x{8&tj`PPhw|_0VNnML0PDO7C z#fYn}y$r<>j8YQY5PBUdnhit29?HpW{q9uIilP(Uu7c}RZSKL#0$1BKq|7AVs&DOh zq2q5Tn6h$n`>l&!)r5uNdmpTm2n$=d>TSXGC-ihUgiT23W8||tf++Y!5zgnQUVU(Y znJuo3(bNTmN~bUp{Cr{YEeWK*Qsk9No}Svc&{ll^M{d_no{2u%e$KwNCA`9Oa^%IN z#Dq`qeQP)W(0`oaskvBYkj5*Mu{T}`B`-L}T&>3c?Fr*QO%0Nr4~D~v=f%FlPl@?z zKf&Bz&Hm>b0Z`!vmr`^zcXm=lsrXSgr{5HbOJL^kwM$7SHTP;)tJn^n=xn{U<{u=A zh0XFw{b41^gO$LckJjWelTQ`wxCV!YWWPMS#nUU!(yx#i~Atu*~5Qy4OYlyN0xg!eePrv;5dah>X58L14y2!ag>YQ4Op^Y9Y2f7<7@w_aUpW|Y)RsB!Zy>w zsnd$%tCEg`v)eDXsCmTt@i5g zufxNyN;o*A0P^q(1~XAok6#o(?HRYevC-2xo}%-)uFhu#Gy8>jlTO(3O&5El_k74P zI5t0yPEJ(kIAT{Yhj&$-WN|E}7l%4F7>?r9mA`5btT_bwqp!D@i3lC*woa4)j{S7C zTPIza`dt+Cw-E^m*CTEcJyL`GM;gwh(NIx@=TB773#DShu#2|ronOhrlOHVZetM_c zpo6c)=ChyVP>s#Xh zwXpTruKX_WQjV~9rYeeAT5D>OP7>^4cb<%ehtRvS2Lg4b|rgD=y|<&k7!PJX{WRun;9wc@ zI}tTB+R15muGb73&CIzy=Te*J63W3;eeJXE0r}L(iKN(`<=xZUgnbv2QpDfmh?KOq zMTU|m->zq78DRB&F3K`&t`7SlozGjO{bgUntiQ5r+#P+*xN5-K9qCmwZp)kNQCFV?zvm?Dm$6E8mhz&6r5olvF<3(_8LPL@A;>8x zmKbkzx6tw6$&J*yL8-~HDofAfp94&KqzP%DD}SqgasOOX)X7sPy$KF$`a0K^sDQQB z66e-?kt-EqC>lYW;ZFqUOe&S8ubC^nn_Kww=xY%c4GYgdE<6W82GoC-l&az z)=oZlPc7a;+|VnVt|Ih#-o1jB$qDrj_vUW2;=2yHXx&6ibo4CD zc}}&OL_89nhha*K&l~kgkkQP%Zp+VTdu&TEWr^xM$S)r+aWYSPq{SA)PIz|2CvBRa9 z&9P7BYG0o3#s}TtPrdKWT4d0D<$2MS&>!-D6Zg1pS0k@0B&>@jFsA)5D-o0Zwfy0+ zi-f7pHa43IcVKZHb|FN{>c5iIKJp0tGkJ8Km^o1P0dJ8-cBXg*)`Idme!dX zyV+%j+$i!8Wl3!5iiR5?elt9}ILXiR4&~sIB*l-UfBCz|DlvvBy*|HvwZn3@IA(T; zWOH->;ltF(O-Lm`g@{)+WDLACsWa$fAF77>&69c7%rRR3eeU2ShTKl-X1jq2u! zt$O+euedDO(AA8U$IOhlkVMRRav& zIhfDnYN*vJ&c_!WiGMc~!xl|U=s#Wf(bi_%_WEjcYcjJUCWiI7*xHX&gUhHVd5+F| zJO#1ju=_$)L7s0}ju|2b~`~%pu1x_{I6SyqZzraW*+11@4ELG77W-7iS*&H7@P*Jh=is z`*sm&2EM;xl;Xr6kXN&F9x%@_YFA=ix5Vw7LCm7gpz|(bA$Yle{uikMrgTO@K>-YQ zxW1r~KUhi1VVX5);|#;9`X<)^2o94?e@};optHi`$2R9Y_|ml$)gM0wnKja1oBy?* zuWs7kV`MsDX2uq)hd5ia{5Ttx>QA9xbOjf$>PMYavCKtyFqXD|QUdw@>&mzW?TE1g zBG>K99a%rGdNO4Q*M@n>&^8Vs2;#9)o_yvbyOckk@u-e#vHvTl7)MLmy+3IM8FUU) z6A^+gSSgaTh{d4hLLRGS9;*n!pY@+ux{_vkyHmWh@MDt~e$a z_oV0jJLbp8H#6y*fmLIb_}QXxGL;b{uQFaG4v=!_(B>tzfk!x8Y(%|xRtyv1q@@w3 zXJ=lbvs;R{39yHYwsxkSsnC~Xp#8ta#-^a=#p-x)55>GvFw`+BJ|U_)QRm_K8d^R4 zgu|&=5QO16fH~`z@FSuwnHK_WxpRKa@*al}m`QgOqaz6{VZn7_qc6SpW|!M7%cY;o zDD~~MaeWhIqHMHt%&|Is7LiwWWV1MMHR0Q~wP*f!>-^+s4TNxtU0$Ayc_meACjQMz zy*pQ!=vs6$`Mh|32@N%cIdtwT&udTq&RCf-`1#>R?-Vmth~pRr$=05&1%AHin2k*=>4U{f)@E{W ze_Sm)pHeN1$FFKfFYj!?^P+!{sv|W)f~3@-&UpJZVaAY7kD^dyY9)b?s)=0@e8)Ld z9Ao50>k5)Om?_yPDtYW<=RDLQGx~d|4}5%lSHK?v-^PBmHyvldMzCD>8yRj=Rv_3J z5Q_#c>)Nx=O02|F@ar#s?k@EsN6KE#Z<(D@jB^d(U%oDV5i;+C+2Q?top6pKtfm_z ziru%KDl5NRl*2>JjYM%8Lw+uByvlJrx%Jt%KvBh8GY_$gvLkk0Z19#)53P@0%GUk$ zsUhH?XQbXM4D+O?e0q#`TNHoThRS!`8Ht#N8n%LGrKj75X*33HEq(r`d~O`kF6XNTASuHUm4_#PA`_4@q?f$!e7cf9V3p0IAdua?vyKvjl;SY&1 zp|5+L6w?`KXxMKo>gee7F1f0GdFH-CMYIRg4V{MA;R?&F@{yAZ?b4-*{Jk<>wV{1o z%h(LJ+U+XeBbtQ!5D79vm^AW$?E(tzfb#87g=mlhghBk`{F-l&t)31OhLhJU#?eU! zplb>(@C@1+e`aDp&*iAL#fLS_gd81ZHE!+mJHF;fit-(3INUv?dTVg_`v1{%mSItL zZQG_px{*#1k&x~dq>++NX+dDkjAv_|S9gGo`zt#&x zzQsEUY~bnd>+1l$s|xc!&#--*$Ug>S zxzKKX7|jvQ$t9dfJ?bz}NrLL}&sx{DHW>RBA-@*EEA=0ZNI|~b zI~@4ko$u!Mwtzi!27rISL87_0u%u=)Xy)XI>==@7qNLIb*Gyki_Rv{#raqZFWyc8r z!9~3W84(%IX)_M(pb@LExe}EPndjIpp0fE3xmArI=SQMu%=vBlfJC(z&~8>|s`>KG z8v@{-E*W(shEG5m=>^#~du+YuzZU)Ig8ghayuiXLv%ngg;#F=qN`X4-$-kKaF1t0^ zzW$FB2fbDdoW0YSI$H%jkN5S+Sm^$m8$Q^?A&1 zP{UD}S4^bXd-LW%#@bg_Of5Ii8{C-=r#xHFpvallXqc>O9Eo_IfKP_vnqBA)QRs%U zGrj>jy|2<{#$d)Fm^S<3E9n2nM5JkM0XiqAx>}2P5Ma8Xb<80II|7&xlc}b| zZgAmok(8CL>bF&b6X*J3q$)9n7c|S+M30)QemHs;(V)?dY*z zmLa~;B^M(R6SGj~M4T-O8y_UWIvH&Iqng;uoCad?sG&+|&hTWv+VWHH*IEUVYiC5_ z_z>?%wm00Kih}uB?Q^xd2rjG>6`~k6Oht<0SXK=>UE#+4`sFi>5)v66OTPcyc1*9k z=C!$4Fp$78EolK4UYPZfNogw$AY}dA)>5I_>m@@P$8WLe! zUJ>Q|-b<`G(Mh5a%sn}B&HwN7q7<173JfQ?=h?s9Zl(x|3$B~XgK#4e_wSAZCJLyo z`PKUD{3R=2(#5>ZXM?(a-=`e%d#xjzbFtWQcTz57md#_kzbVU~tWN3Br0HaPyyW-Q z8XoDeo|u|s^W2vh5S%C&^hSETUwh0XCeVuv6khN?9qu&TvZu*5cU+jZ0QF<1UHw

    %Htwt$7bfywcjIJ4^e{Y#a6R@vqa?2G|Wm{TUNa0yz(;Q3z zfYdi}m>m>U+Js5WM;mGEv<2Vnjpc-Gf;T6}S_E#WcquX%6u7V&E@P5oL3Xs`kJ@nU zS$*ue*kEKMN_QGjN}v|eGeDV8nJeho8B^Q9>(QUp$lj}oY{l@Z`$FDI!<LytTtifrIR(V$dlQ~33N{%V;=9_I!g(u@g$M8*bUt1Fx2STkJo)V1igI%j2 z5)Tc20~TX8OzyE*(y=r(m8!(Bf-rh5TDQSG4|UdWi5NQW{F>&|7}<}S$etK#pOL35 zV<|%-Flv70I<#u%@Uc0Bjdd}+w%h$jS2Uz|R49F+<3A;klk-mIeQ9Xx$Lo+fl;Y

    xe!x>xNg&YH=QIPg}c1xy-oDKzkCGEjO2MV9;Qm$lXRv2qn~ z@Ksn$J1*!5V0MT|^>FFuX8;8Q&=|N{5J1TKiPqQ3Du3t5-A>Af6|^*MZEc50VZh*A z(xLQZ=kt4K>Wb@8epNMh1i^YA+H?vLGVORO$j`Lko4>XeC;dH^t5KiacmLzFG0N{w zHJhMgd2Jm8gKe50$mG0nzamdHKh1=VuhIvd_RXsitne)t)h@Bw*62Si5OpVGMb|Gj z@$O=r{4nJ&^O>eXv4=8S51BF>48Ipc)B|igAgLR>2&3Y>6chMMYB`sFti2(lx1C%C%k{ zCf${&o9b_C(R}Dw?Cq7;@(@`-HwItJr$HQNt zk92!QoB{&9^ng<@!!|eMUc$(=KZz#Y8JGbKym2kJXZ}9{&lC&KkR3S^`{~(9b=4#D zqPP1bdgqAX2bxSv8sR}W0zN6_R}zVU1HwWRm6re1mT&($(!}eB&_>=x^je8?)Zc~P zpl#-ToDUIp<7{kbpwBiU7nXOGKCY+PnaCqEXUHD=^_K2$j~u{)<|UUFCMcun33g^` z@Io)1M~ns0_Kda$d4cM1ijGZ>mA}S_^%9*Gb;+^-e{uu}b{@ZihzR66h7zW4%bC}T7i+qpG zdtCU~M9)U)5Sx%$+00(W`dr<~Az9N^mp8!IWkeh^t^6RDl_2isYzPB1EB!ypC zQr5X;pZNCcf^jlWRSf9P%FYZWjCf z^F$-QOXwHf`zgz{raXOD){F^3q5Tvn#MkEkeq)mM)=;n~v{Vuk$wkN*JEnKl1_y_l z?$>fgM|K~kPg>hB;mg-g1odeev&6~4gH_zQ6=Ip({ zN`0~q+Hfk*TE`1Q71n>@SWf%yq-D#By(Wpn>)sbQlT$Nul1u6a;VD9OPV2|9f^KV^ zxhwtcX)z31Gg>JF)yR;&t7W2|xT(CjwYw!lTKCj@Pti8R|xpB!|7ot4#I}x`YXbK#E66hELK^i;d%C|9or0-5 z4D|GfObX^ehB@P5-gSwM1(pB{G{)e7T$mRFGcC(bh;*ck9DXqs97l~ z(7cK)F_G^4MjLCO88nZ`%8a{*7L_Shr&j{R0j9;RB2?*8wacCRr7G^rhu45fK1c7vH%@7lU5Lg0{ zr!CWk5}`=>C@O+KoSik?Qo{zs1IRSf(}t74Nj`lI!2MeUd|KyCxHenG=?rI<`kP)o z>a#k7O~z=SHPROzlnxaXB$$K-0{&mk{6g1j`(AC|WdE9clZHDmLI_054(&hTLSAxbR2kIt$x?sWbSrv{4{6%CYE;jOk3PoQ70F zb}W{VgmcOpi#4|*1NPoy2S^)2b$o7)^EsWTB4OA-9%s=%- zP#_4PS9`GjvRo{a2mufQj_4;NvE)1<4)BBL6Vz;nu%FbhA6SL3w4fX2R%gy?PLPO%{n=fljV zzp<%X)O|`ZJr6OuxuC4~=Aq_62~5?{)g|XJZv3`^+3WlPLIxCL zU4T%I0NCgES0m}OM~EIC9@UOZ6sM=BJ5$AE^R*6a3U$7Aim$vccS2$#;@26P7dF-s zkPn3iDu(o}AN;(!G-SKyGGdtIIN5!_dMx)^iA4rkKYr2pb9mR6*Yu(g4sa)K2O$bd z3dtBI#pC3HXkifE38r}`)c#k*ofhH^ej(2mPX6~@IT}(+%TZV$^l%FMTJs@vO0dzX zpguS_m}Br1BF;R%YNnmS1Rr`G;%$AG%XG#j&GZ?#m^>01+;(HLyP4JAT zpbqkIbIW%579m5)V5Fwee1n)h65lf)K=#P^sw^jM5EP*ar|Qn3!XGRDyf2jtmzP)V zzHDmU_(Ud!PtN5@7c-pELwWoC@#Gw?=S485kHw%S|LeSFr;K z0*Zud^x5UGDZf%L3>9x*4``E5xWD}7Ek8mX2-nf83PAQ{zVKC3YWc66-@i{JVEan< zKVVio}PZq_!9CF3Q~LL z8+24iioWuIz6NN#QM62(nNr7_@kOfAS~)J@yzWX37zPJZCgp!Ckr`C)^qo@{j3@&g z@U{Hg=cPx+9isH~UvH5hf91Er^HP>Oc6K)e;aWE5o_;q2g`?WKFaDC( z<)En3N>~u~sHPzNOdu87XIDv{C_>i07LM5Ao@7{ApX*oYxyW(`+&P!Gs&1$lV*uWF^tp6!AQ%;jeeF%fO}Qdodw6aE@$(NQE?-S9`j zU}1%r!qVcmj0)NFtBX*fMAiJ%{DJsqd*)3`z|`cux;owSCyoFK3F%WARtjM4n0<7F zKU`;JWd#YUA$cTOgWDGcCUKTDc7RcoFEV)qx*au$_mqEB=3wsVOvzU1&3Njlt$4}oGN1< z4OgGp+?l=2}Bb;kP)jeO&*qxJLC&bwYrWaL50a^a5#bzjaAA zDuvS0#|SDX)F-GL_x_7n8v0niC?=uA!3~XOk8-GLfq;Ic7EeiQ@NE>0^t-|7XLrY8V!dn3mqFA6geBz&Qs-XFjI6G(%7`zB;*PZkKAqM?! zd@{1N33zB`&xjEY1omg!4$tIULVWyp3R<*?NJWjO zrpd>Tv!MbXn>ePA6R-Q@@S(s5|G%(n#9Q#@=J6z~=7WA=LYX@oX7Ek6fU#t6y=p?_ zXPs56s(wVe{Z5sLL!NQpFHEN!N3^GVRZ5u?d*mgiVK>LsQQazqxWl)w<>7k4ossCjvH8m@6$=Z+JRP$FS@pV5A%smbvemL-s(N`K z8IaW2doDG?D{gDJF%zj}Y^NYaR2Zb}oENr+MN_~4JQWOJ3u~X?MJMx8NFdz~<$Fb_wWW23x&cJZ6i`776tE2H z*#mr7F=DAkO*W^o5E^eR7 zqvCgZAO+07M%EPjNffeLK~2W<<2a+u+6oeUd+5o#JZtJ7Z7&Jq8!l@_lAW-tH8BEm zyQWrA+PwT+^Gz-|UNL`q>8K35sFko}rkfMxpr2n>p}W&=uaU%Rtt1;Ym$ctXk_?pB zqH<#pj0ZF}G5Cy(xIY5mNMuPj6+Ui9W3ab|U7Iu~X1b?`7B5duB!N-B!`@E{SlrdH zymfwWPmhc6=5MzKA_R;Y{X?hWlye+2F{2;-j9@!lTyLAxdjqofJr{TcvRW4M0)1aqWa0~z1r`>I4@Q&KL=Q<<(5GBc?R@FGaougEe;&2m>q+0HjE5DX^s=e z=X_}LtS5k#%gt{Udzvq5X;Qy{!oS=EM_Z(YdaJtQg2X2<;eq{h^X^*k_v4qH%HV!I zsHO|VL+0a%jqF84Xo}$#Z{1{^*6WWEMPZ&bQa(vVA}j0sPQGx_i$S6t@!tij{Ie7D zmlDpY-(_e&-RtsB@{AZ)?f8ENFWC*t1_P%lcimwgDjJ$J$F{!COe+*V_Gi+e<@1uk z>MN+`#*Q@L_8%S|;wl`*igADYG$13)BK33qahKsLD1Pr{hzO|-=OE2S3qqv$Ay@6j z0ak}DmY@K7*f`t7ugu2+WuX@SiZdX%{>i{#TUGi##FCRSc`VJ=&vLdyCR@=Yu}1>#dfgqTD6(TzgSzeuw$VuBmhNVjI)&pW_o!Cx|{ z0vEkCn)KN-#~_wOamIRoAD13Q^em-)wszXl zRio9R+A6%*4EMK4&zuNZ=Gk_1)TbhXj!mVI4S$iDa4xY83OQC z&NdyUvX6c$2dwMpu|Q_~?FuKiz!!wTR;geJ}rWxSx!i{AHsUP}Qt0;mX?rQHpzj z;X71FJNdUCE_)DH4n~z4pb60F733EHqp0bJmvN-rFdHer*Xj#qJ5TM}q7f;)Q=^05F^M1Vo11Oy9@i> zIXVl4UQ+i9BKba?qA}h152CG`XSKra@tkcQ={0c@*!%j1JG$_GbQdcbyEWST{ryS* zWCa_Yni`>$$RVUnN+&kR+R(T3#GND3cNWyPG+t@v=94%18uZ_fN)gz__Wnz#3>8B( ziRUD3JuLy%SKE|!uia1jHI_IphCO9Zyoe|F?Hy#c8j)aMDi(}havg4gH?(;M^XI_U zQ_B&^7(*&7db0sx9oXT(`NJM9K8~y4BI#7Fez-=**H;vBL*a*195M{U-`)uwwc%Ak zg0$DuwGeXw)u*JJTg}T%bW~IYTsVMg$?b6XcQ49NHHUCuZO7Ln0Zu|4hzN+DH{O&2 zOkZx+1xzYj0~v=FCKLE#5G1Eok)MBbotFqm>w>BAk7+BQp1;M)kTO;+d#eQ4)$b22 zH)~q!ti~oE?L$IC&B3V5tF1&6kgPn->jbleL`YUz@+*60<;Xfxz5HcIA_KwoVfV)J z-^OS%L(N-OY5MXioR1c}Z)9hwo{KmjdE*|i7drafIB(;P+PbMG!XFa&JP*4p14k?% zaS)P0g>mv9W%bp%8if$OUBH+E#jXsH|GcrAd?^YhRFHFj#K_Lc5&F>Jina&xnpNLp z4JwNxp5C!*ab*2!n+_{iBET4jYm`v0UoAe3Zw4y`D`&9=KoJuVjJ%D?sIwW9)_9`u z&g`G}9Lg>1cVF~tO|&nf)6&lV#e#XbU{yFL-N)yz)9&EPsQhSHSi~%hqL85QLq88| z@aZ}WV;cI19xpo{0MY!MWg#2KTJF4fSDKhGHk$t{25HYbjb?&2Ep&i2F>7k)Ob2D0=%V|{-l(M@<8Q01@6+oBTW>nZ98yH%mK6i8L5ytF<&YaQZrC1B&B77(_?3i84L2S1f(raUJ zGSChR!|nh>K)F1Q3?~-I{Ewf-7n`YWVI7+_mn%ZTz3L8UkkKn_?_Y>sj>FX(Z|OQk z$n~alROP4=zunAVlFwqbpq+Psp0d}Bz1jl5Ur4W&N_6gPiy4vc9_b`jrJCwdJ7hQl z4OjTh$`u`{bQrnYM!hIKVrtZN!@UVT37kOvfG2i_-(reoDfwpKJ>R$07C_P`AaVgT zkrF`9_+MXt>+jvFb|hkToU637>)gceC4)W9e=RPC2!VGQ2n7hiuEPXtI4?}5A&|kZ zt)-P2T=Dxyi+wu?e4l!`Q4$aM=snLO30~mdU=VS||5Rk) zI#lVKm}GL&A%nItvJtTE+35_5yuJK9YM4e-zluy%S)1jF@8)OS-R38L#UD@D7lnD( zA-?ZjmgDzHDc@aDg>e4C=M^p z*!t3|_p;$#4AZ8Ikk+gCOzz+~PNveg;iMd4LhXm-*5#ssbXp+T%b~*EF?LURbH=Kf z-;D?;@)#x{a83bM4LcR~wUxo`pa?h3nhAOi2!E|hC_WyrCeS=JTbu-s$Mof(pCwV$ zpeuds-2(OpBIqq=9RW_TZd*7aOV+~~yodFj)(2tcm{Uc4YPP@4KW0@c&V)dZu4D_iYB8{}Wq}Z5w9(C8O1$NDI5p z2>IW4;o5;C#berQ?urSTZVN#|ZU;J!(_%ruW5F5{5laD^be5O276};7Rp8fYRN0vU zlX5vgzy}4H88Fa$2|(SIKn5mld6xKOT zQGlGEH^*XQJyWZQ>FZO;wKu~*0!}spN4x$`#PT#wR5_U!6Tm*mQi4^2;d#kVp+~36 zQRH9oG!!?I4B@2Ukr~P~a%3@mNlaQ8s92CqYmtb63ClDr4D05UY-B|facU&(cL3OKNB310VNYH2|; zkC`S-0^m5Kt1lehsB%Aax~lvu+mhU}$E{NLY(kLu^f-;;BpBRSC;fG{UbpcF3Sxaz z6C)t}f$2541&%4AAY>0cSez|3kb7vQapo3qpzQ`N{R#l&05BEdrMG#rhyq8?K+RlP=dR@fH!Dm^0bKvuZwE51N!0JKKWzD}__5{-9FOlUe`UjhfO za3FS}LO9M-q|QrBObkbA)F^V*tsUi$PfYAmH?R*C`c#g{ObyQl!mE$50lu z5%EIX=KRWc&e|Q`+~9@kJEeGckpqNZe)Ao+kv$Q=qUgi7o^C?$nn37f93iuf;XKFX^+Qhs5=SEnt-t9KE)eQA!kVJ zaM%!}UUC3H^A*0=F0V~msdD6gtPl3)`+%}RKLX#pEF8T=wYck7yd2i_j0$1^*M|A? zF-H;FCBmDkjFjFcaryZsxO`u~x!qlaf^NOm)twi;IvI#^$oa~0OM+D&>m<|k$EQF* zJ=?T+2$ljg$w~{#2>7#}EJ&8Lr)OKib+?$b{a=XCih6P6xWc%g)ho0e=>p{wTTOp6 zapd*I8NHW-L_inYakqt|^yUuJ4DT_c);B7;J`8ot6`FcUDBM!d zRbf!;0J@O@eKt*7+if7V{uc4AdsF^}#pA>MYB4C^n1Pu$x)tWAU?Sk)K9yR?3^4t0 z^IuTyP)GZXR`PKQhLgcKvq?82MGd192=Rbhb9uom)QhfXtkvWL#9sHMy7G&i_b^1H z@k^a}`DStu!{Qt_7aLhd-Q2D}g?~}Nfk<9y{6e5h97yUBK>Y36Ktx4v^3?}am79A; zsPjPF15AIxsJ3rN!hDvIYGS?%u1$0+)ehb(IOFYiU z8cGTLtRBw`R*U(?4b^Cb%tUvXCas5(QS%hv8Z3X=s$tYiU3dBXQD%1^tKYcoOpRM( z*d$O{?j+EAdseq`e~FiVNsA0jE&K}lg1VB61d~&CB)HV~$Qv&rsv4{)exOCE`BO25 zMM*lUM!roh&N9v`?f$beLeI&bf_B>im`2Z+qNr{yPnR#iZ4e}(G5ezX`_{_=t}u({ zeV1HD^lQL?Oo^B@vpn0&(|cR*lOncQNDk^Q{tEPIm*C$0^|T^NAoHsK$6^AC5Wq_J zHPWCi!qUVc6s28dq_mVj)f%}lD^3er>@v;T)x^U1uoTuIBd0wi& zU)=Ky6``)`-|GGb);P-JBs}q_H$4f86xb@gk?-j+zVPb7P|SjXTFI*puAWuSl`(+4 z*W^DN#F2ka0(CI1ap6n%{PfCIxcGF&2f?i!`(jh#A+)SpwAqRs$Ragv>$zH0dH{9= z;CIT;kav0m9k|6xif#}1?SD_#Td}6c_s?R`lGb8))Mpm?#R5`+fc(x@OV?#PU2-OV z>-P3m0Ju3rGk#E+7eA#C=2T0a(x6iJ+o{|Q1@dL7E6uA+iwpeWOITRg1Q+_C5vBAa z@P+Gbyj;!4X=Q#bH{6vzLb>bRS_O(=?M{%-CA#37SH3sSsh0 zQzBm|1xTV&+CGV9wmR?2VN-piSTgqwRg<_T7T2|md}aklZIxF?k2qbLh|!oUbt40I zDRGFesxe?~#ut0>J^SQ4Yk1k|hoOOg-pFm^(ImcfWkaBHbFLG~tK%>4wjod-QR!c%L!)07o6p{@lnhK>ajmiyEH5Y&WYW9`}zM_ z0PZr`r^YcD_c?xT1kPJ?XL8lk^UOPXJt#popFi$0Q1Lp`*6d+CbOtp;-WFcz=00Jf z+tO|RxUQEkLp4)uQK&{G(Xm+Mi0BBzwGC!g00UEy4(DrgD&A{(qHo6xQ+z!{*gJ9& z3JePR!Ik*_2c2zieaXQmFm`rgOa1sO)}9)>H-*|DFP@b8p`ZI&)ohi0)D|DY0NFK- zG&RCM9vA2PPZSh|73VL2f=lhM?oB#%)2`QUDKWdA?|ehK-uBfnMnd7j{Xrj3;K-Q0 z+wA$ZyQq*Asa&sku+-tL=^9jMw#p0rO#dkC!64;>=_oWSaG$L?IgG+6UK4!#V$8xN zN@E#E#&hmDfN|94{F%F@0?^@WM=h+(rluxzoL%!%`9ez;&GbBGMnV(dOJ|T;U^WKjD z)~fO?5VYrMd!l$EGbj&T*rLy9g-e_3Q&pJ|sU8o>F{IIwBAhVJS65Ae@YZ%9mBy7h z!sz4Mw;qyzBTN|O)dNf=1De~cNS1IF!_&PPhOUp46lkl4h;>A(U;|93RCV;{`7)T{BqOI26$Q0^&G+x zj;oQL_>8YBSRCC8cadK~F#zKtF$_g0A+?U~``96EI$Vp^`16C^0s$zT960P?4(}8?jkcCqsvRlOJd1qQTt4$-j?cuAG4RF3_! zY^N-5`TE%-Kq+y+cOW~9gXIh9k>ocPd>Cf1Cqf5}qz@k5JKUE`2m;&w2wJvm(dn*9 zwUdZ5ov9iNHV+B#GU_G-1fb3ElpKEdhH-K4RPk8iHNhz2DwP_Wn1lc=M1Dk4%2C`p z9W0%wm=z7nq~Da{C((KmY7|*d6lL{CwysW%Iu?7V=7+NC!P$+g&w-7AqXH;~1C|k` z(Tms$gB@VtfK335C&Ao%(0z$zQt)Un$Y23{^{$~u(~|@-=E4!ZyUTE=-`1>x0Q#7I z@=kO5zliWomRo_fuVX=<#%Zi7hGR#Pq&tN%&lNUU-jsc3o@T%N(P-dJCjM-%m+r)4 zTrZ9^Q5q;B@%Mn!*NKj2$_mPopQGVVV1SdHc}Tuj{@Rb^P$rQ5|_hZPI|1( zJ9)qK)$tj=%v8G*-)I;5w|^)MqF*DI+aE2C2RAkge}&#J{@P1Vud$9%=GL)vJ2Rdyj=unIA8rx=xb&-4+ej@9G9qT3NUr=}(WR~S?*JU-GL4_*gU{p% z6r0s)pFy!uqJP=gu=^eE@ikkim{C5bOz-`hE>;N{rAH?!kJ|oa9Crtwa*}+UW?sqU zc`vxHW1StlKXRi#e9m{O@Bi;?MA}-u`p@(vmZi-AD&+e|gKYMF|4W51Z>xmPjzFQ+ z#gQ)k#bA8Ve}5T=)f-|{EkVf@?|f(fe$A_Q1eA0VyE>_ysEE*zAgoGiN%{bA{(Wek zcz6moH(Q>W`M^E+`4)~>7&${+W5ki7(7KZGcoEz`~ciz$d) z9J0hD9@H7%q~XAPTaf7){|965kZt;od*Ha~mq_m0N)uVAN#PYA`prhYSZeVL1+qEP zE8cIyNZ+Md5v^zb1Yc(^v!0p9Y99F)t8Cwvb0SkLo6iDL(>wy2rn0S~^* zH`?Y#X>cUSy`B#wS5-No&)Uc@fGI^c%B68Y& z`t{AI7-J9yzuTe97mdhS#uzZ9j@$i&;z~7w$-^tgARGw2?9OeYhrzL- z>-HF<4Q}IyK!49#822n!q6Tv-?aRTuxU-9kUvI`4-cD3kb{Z-wWOqr-2)-T+|1q*G z=*YCy_ahQ*dpGoaNM#bqI9F>*W*ALyreA$e&qdey~@1es@T1LyIify z!ACD;3Ki-O`r~=@z@bG_52ij zahCEk&d$&falB89RQA&t<5~&k_Y0H}(R1wH z3|CP%lA2FSwbl}v-r`=pQ-^|x$nlY~==(b576(@qLi?MP0wc_6UZTqmwsy~lqP9i5 z`B;q81xlUsXVq8S@*CZ|+NqqBk1lGkt`c}85-pZY>uA5rhN8gKJvqEbYo`s*tP#x~ zUj@f;7o=zGe_x=~vf?r`?!WR<*P9*nmeSDHj;}k^h%C>UxR)Xg6jCP~EZ+Nd-Ba$k zZw|NFN=4T-eQgU@q0Ug-celVM@8Lw~j93zY@w8Zmq?_edn~AI5#PA4Q~uy=v)= zokmOkK^GCH%k@&oc7j-A^AGx?V4~eM%#wbGcX+l*t&o>cMS>4DyYXHK^2Z% z3w6&o&${T^skBC`3}dihz{e1`3I3n~@1Tm)Tr}-6RMe~eSqzMdnGst6U0ebV^7u@# zs^N=4kED96H&Mtm>Kc{tPs>q-+)lL`l$W%zohRitA6F#a)#&kBY~qe1udncZPHIeE zc;fiXM0mdaPNO)Jy2MsB=T&5JOH10*0;tjkhkA!drp_V|eBJ4KQx&d{e8a4toXStSiMS-t{4kMWUkBYTEj)taf^)wEM$RlUZV!fx-Kr7O&hfyzfW`)QIA$hFFc5Xa*Pr4g$c z23}W#NMShK_x>T}zvZ&?uAxsx3;Osl1WE&Vuj?g8fJUYxvLBZj&6&^#y&mtdCEQWQ z=x-YhL};*({F1o=K*Q}tGQx?<@TndFtgC#Y_) zB$eU5cg1B&_s6*Mbk8?4bRM&3)=kZ}szH|I{O1!LhTxv=?iXGF$uDMwQvaU)y z$}*ka=YKn$$RvM!on_X^T#sbC@O3qixm;oh@#(wPay9L*F0!0^Y?GFa5IHX1hK$b@ zke1X9Y%bMb^$aM9Cun4~x_2nnmO2b!LFhB9>g<~&J-8M=tT@=18h>(1ddIXbSZ$rO z2(Hk$(ttwKWnf!u3YFP?zs@bTi2e+$1$El@_G4UivT`;d@!O{*$SR=Kds>25SkDDL zh6uC7v))*b;zhO_vOQ-WuEHqT&UFRBYBJw?*X+99!A zU&SX-eMZ$x5NuvW-tWA`jzZCzKeb##IyW`U@*#4-xNO_L9%Cm{W+xi$>OTlOUaO=m z&wUYgec$F-pDJ(iNK}KUDH9&eI3k)*Ro<4lb2!a$#Z|zVq{-(KSDcvwW0~#!HVL>AsT_6r`2X zI^>m?n;@pBvIsBW#`1I79h8*NW~{vc^+RbT`Z=79=~ueL&)l>gm@V*)Hmaw3YJ!h3Vm6zcrUWwY6mE!en$*D^1}%5UBk3YK92sI zUQIjte2F7?r72NdGiklpZS+ua?^Z~xFVYRoGDq@QHwMeWcMm&%nZS1Eb*6{rve(GSJ&(YBTCA z%hb4-MB}RzREJI}zbHjnS^0|sYG^nyb~$zaP2WO|#xIL#x~7TIl-fIVUp3LW0w#FA zW%l4HU*mbe=RhCy+@GVm;mf`k@Vj!qM#9-2bFFoAtdDlHT2C2-&}Y zm?Vkh_UcoXZ{${~oz7+E##sh6u+J<9FluxvMTLZU3&&gip*(&w7T8DzLrAG}lv5Pi z9Hkz-!096AhJIeC{Q+!rf2wgWT#qNV@?Hbp&%dP*gKe49(H;t-OpHjv#5o=4md4 zzLpNw5N$uj6x+)e$e#>zl$VTSeaPXrNo1)*Jdlj-xhI9y=hoKD>!szREi#jJTF!^G zNLeJz=BpVpaM^40GNE+3H}_lnXXs)oXnNHw;5tbEuJ>!W{d0g$j`?VOSDV~8Z7)pC z6#N$xVo*ur#5@|0_8b9Xgp7F8?eu=$omcN;(vn+N5oERG6es;wae&n&}5b}tl zEN-K}_8(0}R{BAOP-eeT{pXc8$1Zhd25Jt^UqfXcitMEhJ(*okV9Kjj2{@#KLBhgS zrCbB7CXQoKZZ0m`z-_FSac}v>+e%Oa5uc zEv?g#r3o_YoZF?5UY&bOjzsJ3BnIX^rIf~AmXUZ`_$o}iJ ziY1`$??hQao;NT5Annav0_ z=?@R6*+QX)2D(ZTr@2H8dv?cKtTh?H&bP|@{1pOhB;$CK<1&5j#xvD+q5xGi_8qKM zH1WfBtG?5tv0l9?Jwm)b>V1C74IkWVBBbT!hzF0_8^^D3YoV<*h*Ir=f|f&%z&pkD z)lk@HzxHnAOUbAm&(Gy467z$Fa(oVF6S+kT87&&BP;@`sCfwJVU_2rT^~Dq=#GT75 zeZOUPOGBpBJE%Vn8PDi;RnlQ+@Z0ttZCf-n1e{IUqa{it=tYvP=y{mLHeVZZ znGs-`^DvHTg8wuO+US z-Tkf5k}KA0apW^vGQ!Y&Rn`2vhS@%#5x5X>1!iC*9u4G;#u{*u`fIu1QxI2JXI}626gRYVYJ%BlQSjyvF{08A%pb| zu+e1+2My}-wPBWkK@}DgP2x!(!le>VxY!Ho+)PI$nAqtAg4=OZo$Ba6$vVs!-+kbB zYJgzr5+%zZBqkAPihG1|)e-6iWO>v4d9OccX>oa<*?SKR3?lqs+)(t*JrJ*lbScPQ| z9uw)mK+t`0KDf|S{V1wqGtz}js4_tv+vq@n$K7V%2!pN^|0?FDX*GrCt0;=pDDO86 z9vfG+SV&(g+sa_@8hx?6nc~GyCRs5g`xZ^2lS%%a>pjd}^T$*y8a;EdK#9ffe|fIw z?nOCD{Sl|8?W6cLjn5p4Q5Uga@$wlvo;Tqq7h7T?wph^(^2wM+U-56<&~XR*Nkyt#a%6!Hg_ONN?CfG!_5=TmXVN`e9zEBNeea@^J$720 zdHMLZ4laK+zAC$JTbW-o!~NLa=vrv~A1%nb|4sj13C1V)HY>zZfn+*b+s0}LtGIc% z8T{rzpX58ED-?K3Z~^twm)2)cUL)rYmi4MM(66@&(4J@<&hukLe4oe4)5iQ&eI|sv zbYbIWkG57uJby5-VHCAFC2mD6#N%yejvZ%5C&&fezI zIQinXnm)a;RxD50xQm)uvIV|@Yw}H3B>%PmbFX2%Fo6grwaQ^tD9AGEfdbv0HxWvN zm(K9A$Mv_3Rc0FwDl$lkEgIS%{-{K)C|JP%wx5gS#v$*mcGS9xH!US0 zdX8+x+Stq6=)YJ0OvTqZlOCsGJDu*ew>3Ihl_~z}zXP6lt8}?PW{EU~N<$(1gvvOe zkN*WhrLcMD%l;B6f*Vd=U++QVg-2DUBOx|KCNqk)BoB;87Cye|2_<+9ZKK=1Y2a*& zff%tux@Sr%qk5wt&ni1{Z?q6-bIHw0yD=MEEI2g zsP*)7Whj}C`G0!L{tnRpebz-8<#l`AZq#1&#Y5jqo|hzgSs-M=nRa8{(_qT`$lG5EEB1(6cbV@f!x5SVRNOyO4mo!64NOyNg3=ADZ$9ulN_5Lr; z1$g0F&w1Eq@BJwtEDk$_y!$KR&!CORd!AA7F8(1`3ZL>Awc(#t@B~(u*6i~?xDyC$ zM&#>%_S}WG?XzTkA?a{C=N`W9aJa0={Y5W^F-dKx1Oq04aQX8W7LKD3Vs2gCv{N`5 z+NC~Z@_5&|Tk!G;NCq3)Ru%-72Y&#Yskm>tmuYij?tqJF`{TukQdY!iM|!d{$*8@D zJo`zkn@NA`D{06 zHdM|}MmDgFdW=&XmCJ}c?_05^t@s-re8Ql0q^vYWy23*%2qa!|yOENvn#{ z6y9;K1m#f&9oX#6ON8OQ>Cq>8-9b$@X%B6px|_lE{od`5B=fF9tIDFWKuo^6{a$YT z>B6(~GJ{b|AB^-XX?eQp4mPr6cwh;>vtvrEFkqUg+hX3K(0kdS^(Nrc!IZI4R7!n!+ciO;;L4Uy$|1jnUP1qcND0h1}p>-iU>%qdDgmQ;WMKF&Uq_9 z6AH;Oaj?;sj0?1l3b^xAVLJs}rA%Nqkhy&5sVte zZXKKqhcV>z0nfhRON(XgS;t^55)Ae@Kk4&O17O%_)HhwAy1{Ev%dkp<4kEim6GOtzX&l0vnzG{M?c?PjsD|kcS19 zaaS+LmdNTCwiIes0y++_jrUrfAn>{j?Ix=OH(r|C3;Pt-!-fg`Mnz!S^1bb)3?^$0 zn0t=KbU`6zbnxyGw4%(BOm%m4J^L5I!VU=9fi%Q4PHUY18mF0P_eZi^^O~&1hkY;t z5kVNo=Woj2J{)j8>?__(nO;xD!SXYw=hlZZUwkroa=eqUQYv#>tJBMnPsfH*GW#2d zy$RP0747Z&4Qk(9w$XBP()(n4iSXhf<&BP^?TtYLZjw#XtrgVxv6Lb$?MX#43G={%fQp~0n-_3el9aVuTkq%~&1tbh7in^XoDXaSD6boH0BWjZWFAWr%NS6x4WtPe>_55t9sUbq~` zM%+aQvl_p7*uHG89A>hYttVYaWJG?Qnbe5nM*>l^u4oKubg+jnrS&8xr?kcX3RXz_ zlw_kmf(D{~B_VCBtNO2!?+``dA#oq}XeF*jyyiMK_YZ`Tht}|^*AGH4HI>gV`Nm7V z#1iE0v>^U#^?7aOvfB5)jL*~02Wnp*v0jqp#i@rz*y(=rGD!t~N{9QgP9)}RJgM3I zYs_@gaWcstp-x$M$EYBvF&k^63|`-(e7Qv)p!9u={cm43p}#(5jEVH?`NhOAoBI`z z&xZKGfdXsnJxu+%@2a4t>m*kA_ruG(V+GJmHY!w9Rp!3~ZB_zw{+9}OE2lY@>LXU; z5B*xUgNZNg7F4t~aF>2J}lkf2h8qlJn>n>1MeN zAFs#Vl@+lf8bK_>duk+JcK0f#&eawF9ZQxFN=)`FrA449RaWNx)JfZK}hlM58vR!Fr5~l>o zZdGRH6S`hwk7=Gg!z`Uo#)hdY7b~Yvl-xB-+K-raib7ULWd0*hs0q;JGt;#fVw$PY z=cAV^?S!9o&}``LaS-NEm2whBn6ve#Yy z9qoYRh)rJ1)$oP2979z5vfq9rdb)9}DUnnNbIwx76gHj;(bY20=mkNI{*D>7MC;&Q z7ZkanH%ifSsn>7pfFb*ZmuXFhc$^Yyd)GEX@Aq^i2SUHfRDVLx`Dsmc83e+hJw{xm z@Mji@Sr-m$x`tOQoX^|7pc-^>Obyk?2y=x>C+d|0@Y6hQJuzD~oB9)AkzBgjQ8x?P zwJOlwwfk+7UGpT4Q<_KU?`e_M?GJIkOF(t;UJ}S5OWbq*gMd7_T8UG)n0{Z4d=!S= zxILg}T2d^_Bg;*%cK|T-NtGdHBg=}PeQ4X8uI^o2_~6qsy&6rYiSdu=UYo&UyYq{# zo4Ojy3k&iZUyJUkWn|ksqoZ1<2mQ#U)KcaNRWa?8i`N;jJ8-_B61|mb6f5W0-O(lN zIYzAi5~S(4Ge0W?{y5cgvRbj&VUj=7^{rT^-c!iBEEE2{R!%9^>GKo&5HhLOck~LB zKnMXxY?k$?N?64<4x}YMw&65jgHWqpS#umAgvn1EF{T?O9olB6!vCQ{k^)IOO-#X zAagC_|C?uIC2;Gp{TH?W@0KC?YLl(KdsK^$&14G z(dl~CMLC*Z4vC#jF`@ceNr7>yGJ`wSPPTa_eL1+QC`qrWa!FtPsag`-!l#A+6OzYl z{zquOoWU-kb#(G?(NhY7hjbA#b!pVV6b2HM90PXXnl97#XZDZZeG_N?kmwAZlp=b4 z4Jn89TM4ipj%ty_C`WO%t(B5x>2_-41UluYcS1+yixn-n%+S_uBi*s;U9`xpw$C$+ zmaak-(}{bO$+e->&oD0`we2r|N4Fo3-QDn4NQmXz@;pLRrVM$vj8^1VOQ!oxEiMyC zfMMTb{Iy!7opycazCHg+ZyFR?UU$LaodFMthFEC3u;ls#WZt|p#9+L!TE+WrercmS zx!d292={08_8EfE=h1+MMg3!Rbq+^cTT>uJi7)1h-CYZS4M{Rxk6eFmqCVl3@iYYf z;ZjHiugyrWSUG3>@fT??&^yZmhSbOu9#pSRJ32$Rwxy<7%Mlp4xQq2(k?-lsW zrmGVwPwnHhfCv$P(ApO$sEI0QR~T#qNQ$ z$MiPijpxgiY_1El*<90V+)JjgY`%pk>!D-Y-?YOOF&%vc8+YcVt-xepdV97d>R=Uw zpr_56QqYm>UQ;s@jpFi={dZ*Zy2>BH4Zjp!!^%Y4E+8mp91`Psxd&v8M<>QVulpE! zAJH#!I~LHceQndBC~5x5UT3bZ3a>b{5nre(D?5+L2|xq2je2^{=0`dct~9+PUX|~w zY1UGg6xtr~2f{H;_JcWs9rmTh*+7a5!9Nv*mQvJp8-Mq=sgZbDk{n&rkW85*p%{Q< z_EP!9siuMBDik>h0s6@#f5WnitedpHcz#L;{V`jE#F1LC3+3R-E5X!5S*mpvSprNctlvjW!Y|hzgu?)$1j{b3-8*va52foW0Pd;G zK8v=t3Pk^IX=C1dKX}4xQ#>9z{5%mtk^uXMNHRhS7_zUA#cjX+N38cSv~`31H@2$( zNR~JTW{Tjis45RjTbqKl&A)yu6*!eZ0WlUi$6ktqB}fe7xXEU@{6r;Ykl3wh9_TET zQI{;gm1xx$RVAHtQp|OwQ|@`Z9*(pnlc>y($F9ZR2V|~ulcsN_IDymovwqzd;s>+c z1HJrZ0kc8PYrW=dn4Y~H7!xTP)e|04&r$c6(mf_|Dh(UU3!m_4O$TC3H;5nb8^`N`X0byr%t;VuJa3NqN6Ki5zyzarxc0uY)09a@0#Hy^m^@egsjS zzc!E?x^Fy$9Pc>RSqy~~QMzI~!=E$U(_#@T6AHCB_!sz| z0%edmI$UQ(@AO$)a4{rI>o)T@o3DJtivIgHq1L>)tS!OwtfxMfuc@89DW- z{!~?s(1B!`%N-mr^#x-29zD2Hw=RA~xg+l6eZ7etF_(?H&aY0pCH8gS7x0Gd!F17h zMPp;q{JbU*5kR|P``b)9kPn^en|?KXH_%fU_~ILMUO3AzKERWWJhp;X0sCn``x>LJ zbuD+mw&=>$)#ZlJVXuGSl;|q4Obs)8e8J~J@uUNmoe7E-+}38!0)teK=jUg&e>HVx zxIeasvcd08nK%DDVg5LjVVBY@f{M_oG3HCndh%M42&Knx`$&f41%sEML~4}vm%P)( zs1&BUepU*MRpvac0L0YLfH<5wm>9N{)UQyqX60HeSzKjqjl)Lc>gHBwF-FpE3NxPG zNTDN%_*I=(q&UhYTN;y#HWH@9F@+u)T}m@IC0))DRvciBx+@tbiHhNO(Vrw^xmwdv z5#XViRTQ?J4hy<)pcMGdnS{@_%f|9%q*d#CUp^{~jmv>K;RB^eU5~Fnhcc$F~>4wq7H{NLQ`*j}j=Rdi@s_ z(3g;k@%GO(39G~@S-oi~SqU@E#;j&@@ky(0FpRI=WSjnI%pXUdH-M9FKiu$U5xAiI zL)ewNBBx${RLUB{{xy6=pF#m>%wz-atxK}{FDFDME_O!{SJr_jZy?P4jWHk*d-dO& zSs?5j0~V2DBZdMgy8=7$6Io8^v>6#5R}Wnmil(GXt9^_qKf~0Rg{t0#-pwhxPdFrg`f(K@VC}*QW#VUJLqT>kKk3)YHtH=F2GDlvXE+Z~o z3KGiGun!e4M~kP|Ts7~KE4^X@N+^uQ^x@5U#OM)Nre;qlJTvL<3rF!B9eh?u1QsU0 zztxqrJa%92Ia0JVIz&);Ihddr_f%|XY-EED^|+K;?oCbhD(OUMN|g~CqODn*`Npr6 zcs7`AK{z`;wL-UhkRrs786qQXiM4)@pQznzDmx1PrNw#l_( ztTNWJ${xE7IjnBug|52nAC6(7m?~$?a7IbeY$e_RZv*|C9|-+{v{oIpe6WI<*xdZ#BeD ztr@-sykYG&3;X1owlp~t*f4rbbsi`!mGZh*NmXPvj*3R|5M*W$sIDCDYJ?icsZpc7 z2O`yU{G2^d4RCCowQ1*)<~V2j%BrfrF1RwFM0Jc&@;pcR#9Jl3^$H3O-M8!XeJ4cO zvS21$O6htgrjW|&_jy>49XiB^G%%sedmh++XoOLgH}Fs6)u0cE#%*H-sTISeOY?*W zlH&6C^XS%T2ZmcS+ke<{RLlgq>Sy|?)tcTIi;wH1Vm|i||0i_T5f9^1hO-BQXH}(X zdlCCrXF)F+fKLGD|9k9c_alquaHCOMds$hS3$q}LtrG3Ws#R{NmmengY!{cADJ*x> zkR0oDDqH@8V&+b*U280(g#x(S8_l4g6?yd;YdX)XvUOUGSrj#0ub;8hyMH2}fA+!q zev-?!Qcru_PF!MPZ6f`|pv2fdCJc>w(gs7aD#;D667H}TY=R+aIwdL%Q8((seK6Q3 zS#IL|F0VU>?bg6YZqUr$NK7JSpBUc%Dc|%{7^fx1T%T#qUs)br-sU7 z+x@#&KFV-7lQbVG?C>6&^18xYQF;MsSVzge!1i@sfCUi|8)DTb@xnZR840`sYN@Xh zNF8x_A|6{l&(Ht{&t@>aEC&XO>xTyq?-h0jqerTjl+5O$BZ=7jllKVz)C6to;dH*B z5hNn-H^Lz$mB*nMTmSG^onavQ?w<<*H~Bu25=+rVRaI4Vsal$v$;U+P|8-k#`fE(| zK(Xc_>;T|%AR9&C^e8<|p3B`G1S;d3`YOjsQUpjY>@0xl!-Y=SKUMNGoACLO3}D2) za&>jxLE``Da+YP(66Pr6!?2C)snDTcchk_3)@6l|N?d#ePy%Zn54oa+A3wJH0Ly2g zKPZg!;31z+v}~5{il*t>t@{SA;B;yP9$k706}(kL=%whrttbG-*{ z;!L8Icv_!^g@zx2>IaYe>B+R<#Dhnx3R@c@?n*x(hXm|Ny*K?7>WHd?9*N6W z%I{EAg}l7O*yIoClX2qw)J}!f(bx$4trtHQkXrNBHy$@dMjy`XlY+TusPgl)h@!RH z3<35mJ?V*|40NTc{Gsx2iH}yCcmBQi8o=LcIepI2-g5AFlxzmyH2ra|$#hwVcv7N< zJB3EfX_Or@)APMB5mJ?RFbL?eAd4)I6y;I=81yr@w*0u$`tDvSY^4)A1V{K}zJGUK^|PP;ojI}oitqZk}T)UV1wd1wU- zlk9QIA7%h(vlhNvA2eBXh_5G`D|ol}b(1s#Jg|X zFDFLYo(~vum>1uEOg+RVzgHk3C0%mQnTU^WH9j-6f$b`f)>**Q>pWX3&M(Q0g!S7q z9dn$If0=YjUsjt7Re$5Wa(+-f-e*Nd+b>i9q>4T&_Vv{RUD}d+0~-h+122Y}ka=FP zNq#QPD7N+#fu<XvSI zzeO|eb3^`3??JSMZ46E9DKCWL`|vCyv1OlcGC(>@_wVXWKL0YB$;AY{zi#5rPQ%6A z=jyF$hk}0$GnPzd9eqXJnDVAmlPCQAkxj@p_DIJV^FEr2iI4?a%>IXL*u4u$OJW1N ze=_9tUT-i4)4hknj2&=XfJ6}qYGLL-Z`(;uDdA zynv&=K$Av^TLyufx=UJJ^P=Ko^ z6viyiG4ZSQ%yx^r9e?)Rb{})r-jX}7f4u@^r4sFuG?xU#wezb>LVy|f{^35(8n>xv zOT=K1Ug$U1aj{U;EtiXlHB_okw9ggY(g6~zX)@Vd8Sn+`vpIa>MRuX53bQZhJ?3l> zIQwihv{Jb1tOpHp#zgow+nW?70=W?;&{6wy@g(fn2~Tccn9eNe=_bo{P!|$MNhcj( zH|;{{OAFks3FLcQtj&H#1;jVa4bry*;9S z;3wYdk#o^Z<8;d9%*rfVYKAfDvr5aQd7ZS zCrQvH6(o2#1F5NKCcjN?EJr|!ayoa9U43Jz*0R*G#&OdmR%E7IZ6)4%)OSntf&C(Bq?RR-@~tzKdM zPE;@umG^WC$@=GCC@}TczGQvyi}LDNAo-}O!?W#+$@8J(Ojp&y+&JxWsc?vF9m#H50o}(VRD`m(RmCl0IjPoa(riM6M&S(e8%Jll_y+ zz<>0$d!QqJ zFwcCYj$)li8pKmcRi(=hxThIeZm$%dSYm{GUpk;rJHs|rd~_aTtdSkQSEXIgr#xr> zTdr_;3*yVtdef!j**vQEob_X?tE>MyE{{cqJsE(3!Pf$XF4=;4HMTrfGf#^PVL#Pk z8H3YwjzdwcNR3NzI@zMylgnd;Nq?r)@f%OiZ+;SxO>JE`!i+lD zIzVUBK@WYlrsL#r)#-seJNiaqt#jDdc|$o>z};cK3^d*Z7f9o`{{#i|b#bgdQ8&7% z>|GCQ)0a@zO+NDc_a}*(+;gqw~!mY+` z@pm2_FSM>Y`I7|F<+489ew3m=|6pBdW#{N;J|Tp9;)}>xJ<41P5Yy|Co$lkSc}&ojfjd? zO23IuQ(G_V`XO9nN`wERbG#9Ut1hUU7!# zUdTYG5KLOJzW?uW?RU$r?2Nb{0b7fv``7$ytR9aOzI)dKCn%Yp_7B|tqYfU{w5=O4 zY%)*>Zia|Fn@kq%48k-j?v5ROGMb~m#0`H0DZ-+nePY-|MCySUWXvqwtViaY@~RDhqqvD*%d5o`5|*6?<%eu>FTaX&$23-VEZb~fkb0Zso$u~tSx_RBgw++p6@Sn=}Pa+%px zDw~~d*N|^ywu90VPbpsEef-r8U05H@Nh%+&iPzfeKhwpv4bB>cJp(j>sN}X2Y71|A z@T$`&@UaYM-qfala$9o5n(yig?vpcw)~YN$EqqjWw$1LJ|7kd z9XKXc`V;A5n-O#g6$oRi^Fbs|zsJ`yh+C*9-;6$8&vx(7BI%DZPDu_U>#VWis7j-w z%`Fg^h#*#uUAL6NIVKl0_>dc8Pdw0az8&6#De9QuV4aE#qrJVo0UAQwzwm>=yy;PU z%RmK2DGufV!K-iA85KVz1DqF8fFz`1;dZ}XWx+Z+#izCsp8$=Bh?!Xqz=_cO_(P}D zw1#V=JHe_CP-QP~Cn!b?sN=3}H|T9(F+xuRWc3qkIF8o3JhBOz(N?d%si51a53*(+tmq$JPpl4zUBAyp@bc9mZ@< zZdI&dJvC+0wAd#PL&_fB&ntb~aAKisq3!mnswmnR-uP?Do?^>u$3ORrfI*Cge%qXf_auEuyQ~*M zN_MAjy#)|qrk1B|ktgsoYSqxD_VHJ7@DNZRHYWPD4*!n}(88P&w}vBP#UJUgam7`b zYd!kWbqoawq_BSq1Lamj{aX>8(9SkFh6EtPZf8~BTjAVAGr>`q6n}hzKOtfBkHBD!Sl<@7@>>};j6>UL*JX34d)>! z%g1*xCIavu5QCwZR{mM9XK`Q<3aT&Af4ajn%tB{2utq}CWZNW-Z}DW$7ya1+1XD~=qdLnZnW+Bd6}Ez1K3ee zu$Pg0&U7XSLvbGfZp7<$yOTuNk+ z@Vy#|jvsH;l#Mrra*))(Q1wQ-sERGPo*jRm! zY6l1ckgooN)O?vGh*V~lwN4G|=b!}8)-&!K5~uu4JS{TRfz zU_MMSbMvnup{vjh@W`)VlGTu9_YJ2(gE1fZ-egEioYur1`3@p<3Xd`X1&_k>Oe=52 z=i1$6vBg4SEBw#J*O8X%zL5~X6ppLb&(f-ao+JtgF0WrB{}+t9XE>tIHgMfb`TUz) z{B5$I-QpfQybN%# z5FCGWA1PaKS-}-CE@6a}G=NX83Oo;L312Ue-`+`FoD{S&n{_o6=XR@L{%ESth&>5B zqLSuY*&5kaY;?Hf-+O|75w5>k_iV3vdRov*5O@2;!#tKKqlf{Hw5J#WV4gYk#!+Zd zq(ibbuF&_E01fN8=r7jO$psl2`=G=G*xI#L0#0ChS25YD0)`)|VSt4|SD8iNhtC6| z^d00vRy558nXx#y93=&-0NAkvS}<6$oe<(X`xCHe%d#8xrP8N9YpvbEQ7qb-DisXP zTIG9CVuzNkEOdF#zoJfMH)r?t_!sl+Gv-#a{rqr(B?PW)ZB4JJfus+I%YnvZa-~W( zWFX@|I)yxP=nOn>8L)zujfnVQfu`aMV8<=RZ5BgnD5O96%h7%TeY2)Z<37GroY}Jh%yhpB9gRA^$Pd#u;1E0PU zN>gAClce#xWb)@9@Oe%0-&aeb11~fgMwG$_sv=Wq9!TrySxvq@^Rgg!=dBTZxWUQw zA#Z-VLp~Dp{ALW$U|al?B2q55aJsmChsd?q;hP|5}m)$Nbu?KRLSDodPV)(1xN~@4af%cG^jp9{f$4QB9+Fq!r<-e0e7xbu9XW<|&5#JwXw(Acv|EWVnX`dDpG^SqsEnub4ru||U-wk}yTBlcr4b#c7gTH3~nx}fa zCXWR;`kE|{rC30`*vV{o_1q%^MBf06cpa5SF~FI_;{N`AvE9>U$+>oAdSyj`jujd8 zKGDn}L*YZpqWQSJv>dUO8w*#9Lbbg-Tm8zG5l4}>OLJCngZBCBj>M<8NiigRSi_fTNtDKCui}ar_GtpCDFrZGpR8n1OO%IK2Sb{Z0}WXND|MEjWz&j;%yJaSav;Kn?By2o7=BwzC|Y8 zGx@8xF>+FAZEMJQWp)&mB%sZT%!O4;_Wle0z8EIKE^l@#30HF`QR>P+(GD4C%!wo+ zPtFCrT}1>qR>(uyL(BCuDVoim;oSuf3#z5pMy%_WplIpKJyzGb=)luyND@&Ni)?5v`(V2FEo29Hcs{kUHzh0(^x3S=cZi@1V0GRR<$VGPIZ!J(KkLO3*gi*5eGfao_cFX)F#;yAa%igmZuE)+ zv{B0tp0s;!K~^Aa;FC4u8dubiAWfaZ)0CzXd2@1*PJnftHxsj2f| z_pd}8DMDGctR@aAMc>L0Bsdjxr>V}7uoz9cAj7t{FgXAKI5&Zh3f@n~=RO~+Rgb-c ze=908=hRyDRNM;Ji)ZdbMu8i>Y+*C(OE|=J`ka&=)sD7N&BV`-QL5%u*g~8Zf6z$L zG0YZBl_KwW_196tT2H)M1ay`K)mDDG%m!>Sw`ZUBF!o+FU?GCw$7_azSnyX-20ei5 zW6MQ2)7|KL&X)Ja14USLAeu9(gpeU6G^nd{vuD*Z?P6p`S!nEN#N*?0j```2SKp2vFP|`%a+X_{d+>$W4_kWc zhqJw}teG=G^KO1Xe-*r}OgYK1#G%cK#oVu znqhe`X1B`}vX|f&#qG@9?DCG7whHkG9* z$3I&djiaSHZ=Kxrskxzq36b3y)~DNRmVoJLoItjQJJ~MbH=Q-obZp ztIse*NQIwwUiC$RcixH3M)n;{yd_6SWx%g>;4%x{(Sv%m=~7gv9;-(jd>&8#corgJ z1`xk?LwjR3YefX5dgPQ$^iX?5JBo^epfC5Y)dbV|vY#N9NC1_6@UIbMuqpu=_Hf!I z0?l%#s7;qkdcvflC!Xi@k1iiYzFGA-&J`S`^ez-d52D!_1X}!|Ri6{B2`qyfKps9G zPI9wa;L>tgvBBuor9zR4c(mRwFZ-|&_qT!-kiZAMSJ%+k6^v%J@El+~0W35O1%KY2 ziH~QpVa$FI?vb^fl~&ae3zR zTe0b^{eQ)3)w_URtZzJFc$-78X_N8!VxOb^dX>plSB%wW8${;3ng>)-);(sA z0C&pHfzvb1{DM_l-=B#bogPxjO@xB^)x-Qu4>DC7l8S}8-FjMBl8qW%`(FJ!SR<-R zGhF#osM8k9Gn)PIEQl6vVX_n12N?wMgim;t+v=A5VTN`k-1zxi_DP=YTUvxWo zN><{0NN{o#?UuL8y6^d)3E76AbO@ee8k14S!6(4IVnXfZQgYpEAP0oAu>PdD zk#v1j;F4wonD!f$0Nc+!@i7n(}s6~oj2uBf&RETSK0`35UZadMT z#m*`Ou$Nhmz+m2<(*?8$x&2ce*%3wJ4eH7_fE5RjiLH}osHY|XXvI|WRJDu-s6)tl zDr!1)1!t8zlLc}f*>FctK)*~U__KjWER8EjOBv_C{l|&-4g!B$>sxdevZ$8 zwb9^@^#s1;FS4h2MHdA`LRa6^ihN|wTY2%N5-YpY@YK~cJjm$iH{FvHb$AI82Hg+8 z!%}sZ{aR-~(+2Kh)b#vrGdxYt`m4x6Zoe_B(AcpC)=_DG&x|B4V|f3t;dwDs^4VB^ zzD92X$j#1-v~x@5&I<~CQUb6+pF49vPP8Vr!H)(zKDH-w*_ryR+n^2C-E-_mgirWf z*JnEQ6Qd}q%xyyMis&#*gX`z^hkvQ=MNPgyIHtN;PF_6!5Pwp%*>3!KzB(h9&CT_& zp{t^c_9}Va%kkQgw0BVX{ z#P<5y+Oc31zbHTkxmi%i5f(ZP-bA*q2DG~7h<<#Djxb$IOUv<++@Jpxr@t|mVo?@n zhj&z%>3(mzVKTP|I5{0gvJblw zGe8lmY{gMapMQ7RE2u)3YyN`SUZ!PVS^+tK%{i9V${fVSKtASQ9yVE+4y|Sy5SZQx zYDH5;f@e5(rb*@_7WQ!}CPjX&@8_43-S?-2owxE+{M@IG7Ff?Z-wbIv?#L~y>c}#U z7EBM)bma^DBd|6mgz)3mB*f)v%EpdgQ>*A7!mHHytpce@;!_FKiMTL3+O}36R49Dp z!B;H5<Ztd^8e}+>EZCJDf8#W(9aW>97HNz9kH)b0(Jxu>MDHI$rNMYH@L(vL6`54 zuMQWgq3cU`Gff0cMv#B`JxSs+_U+NVF(Ur*j_v<@CMfERG_(HGVXU}Qr7DxPsZ9;U zD;s)j)qK|eom*+2Ow+^x2TWm5y43UmchpRmaX!p8a6r(3t5;U_;dUL*ySMf#9v$7k zAc^tw^Ye99{Y9^ZIHGK7AI3C?uC zOE`7G$hYI8Vh7XI-wv%cM3iX3`Ua;z-_5Q)qcO8-QZTm0O{K(W185L4u2 zW=bIH9OgI9+;$Xh4ZsYH=)Jk-b{rkxj!OMY>Q@J)eiU3XMQSpSVZzQ$M+PQQX$A85 zu~J%>x?GAb6OfwDD#q=1k_p#^hMSOD6$i2SR!edS3r95gkX zk&)rK`TW3lyBSc0{E15{=8SZyBi+l}n{=gomDcuU6k1zaP!N^`;{~LtoqFVbyzi-L*Kgp`kz^;iJ_K;yzeJjM_)%O zt2h2m=8;>SK;C-i%M&GU4ujHanry;{soB}StAiOpU-Vs5?zkK0G_kQekZ;p!-^3(a zsbs-Z#PT&*@%`jw6!O;sRpj^pBp1E-A-XsjGtu{71phKNOVY%B7RAJaeKAeHn}~OJ zj!uK(#08?3nM&mu$(NB@s!O<)h?SShA(OklcWghGQdL22xhZeMejUvVEMJ`jyIC;#nDiJSY>KIc}Vt1<67Ga zcbABTrJI|3(`i=R#wkY1n&+)iHRJwZm$8m`u4g5uJyHNpB|sa z=O|n>9{pw@S+eCg>u52L85ukwbo1JVCT)3Hm*8{i1aK9~s;Y`=Ykxb5b{n&PC>yov z(U15sfwz~-zS2UDcqK~pTfj#}nA{8q2e7ucCkLelkPvC9s>bn1KKb}6Rh(;oCQ#$u za}iG3P15OI{iwGnUOVTPViGJtyBVwcR%0_UF>wbSzQU}5m=1UdEoP20seQ@h%R%CR zo}Yd>#eV}+7Jk4RsMPT3RoTmkC7X$FecZx3Bqk+M&n=(JB9=GzNS-f9 z9j`jHTnrQ+yUbZ8v+Qy(VNxgYl)k^;h^YP-hDk#0}R(D~yd`;}HbwS)aZb{amVhYuTRJ0Je z*LH&v+1+y>badt9_=&uNADb4zR>`ePv10sdZU>5$-e(6#${*#)yS^vgEw&72_Z@SZ z!WLex-nu>rUT~p?u_7?aP?7afqP|CYgYq`uzTg~kZS{zGjd@k)GBMEJvAgk6jwr%x zYG5>q(ZpPqoFOGBU8bK`+F;@n;Se1I8ejSc?s%}0RL~!XW|!640jEWiesc|^lX9G+ll>M*?@6vjKkv0{?ab`Ua9z--l7>SmU|yD6J}bqPmna@s^Z~qQng1ib;ufx_*`r&QmHB4!?VWI zuNl|HC)8(32)RqOB7RWXr=n5UVa^kXZ{9p4=+=`{z-`(~n_omOAo5vPxd78 zlayJ(tYGStjT2Q|8|0~-ol{e#A^06X<L*J=ujK&@NYxPGvGuiKQm#)i2 z*)n0o{bO^jwk$X6cLQ{d5Nq+LH%fY7se7VS!K>aHe1g5dJz_!n;dm|;3A$gK_A!!b zW8UX)A~=!qIEJW~^1C%L|DoBU~7GI!j!W>#u{!4-Io89-|_!OUt z80${{Rlh~F_2>1cE39i=6r{Lq6O7v_A3^NPncx3N-i~k?vJpP9Qk8u~1|4XG$>i#5 zBgh7|e16xVM7lgrv&@wyE=1Px!%8KEE-v<`R6y&%c42L87?6fo>oN5``Lm8c2{r}! zOY}IGmQe`tY!veiyrvQwUt`o$ZO}IR4Ljqf6pG)R&Gw`OmdQooP}~xo>L9Nmrr=yr zoasBW2nEwibpE4S_u*UnDTZa4VIim+=M6lD4?Zxb_mSv}fH}ie>Lg&CX)}zp& zPjvkEbj&RLtaU=wAa#Ge;q}}pJS>-AVROZ`vwVzNhh)af4L#9$q)~%YfqbPE!WJ~9 zzT0H3p@{e4_)PN|Vl$;4n{*>k;3YKKM}dI8xEQn~KFeFfs;BcgIdxPl=$F?MFPCCr zGN+VwAiwz+iIE9teVrOPVmr<9|7g0( zsHnOw3?foWNJ&d~w{%Ijba!`mgS2#)beF`?(lK=ROLq)i1K;(>$8XlGHD~VKXYc*g z&!|Ln;nER+X{B;8Ae?qjR5L zTKc!X-5HFHZtdngAqWi?Yys?PO!DpR%kS@RUBP%a)WFtsWH62bagN3%#FY~DL-nnt2;1Z`zYZNja2=X?` z60D*3NA#HfEm4c#g84xmTjB^;)D!HUYJ0q**`qr43IbR&DRe7=cm>&gyZ|Sn|Rk#>x0$q zj&GIz8OK-5`lAv;k5u_s?~h6RIzkMfcN)5Y^aE*#t;&oY~HJ2IuN z-9*_rlt}+jsh6PeJ*n>?n%*$lxvyH4BXjIpfE)RXDGQeNq>zUGm7(^JH7Im0`5@+8jJ9`;gCUb__} z>&|w6?~&-hlR|-ps8igQ#C<>ZnTk8A9FfeNo2Gz!RHM!%u>bL3<$5}h_t&oXI&h>pi*(`Ha$Ry#d{kY zP8QP51O7=V#S>}A;?`?QlPbTd)3Q1a1l44#=C8FOC7g&s7 z?h?`5w@8v~H7y#D<7`DP-xlQ>H{G=7Ebz%|xA|+D`oeiv$whF$M0%Edi zw@rnQPF_#x7hLn{aDqaZeSCT?R{LXdpAC|)NTGG;q4DR?ITc#K}y$T7tzBiqPfeJSH@b0`hOLLUNthsz5@v>b>CXF%q%ZUlMNTH z_Vp^Vd?`v>;)m~?5D{!RKCwM{t>@^1%G1oZ?b+xoI z1epx9wD8Iov*9w+U}T0;wrb`GL#?;|@W%2CwjY{y7bK^1L39RZbh>?16&&SCr|TwK z?ALnBBYeB^S<(_{ljL)1w2qRRab{1nNDuNVRj0qX9P`;}8?B!~b`A>RuU%oCM!v9d za3p^|g!zbuHWd2T;&YMNpD9VqePJ+L@EbW?f;o-e(zl<5whOLzdoN0pEQkIAw zm#|(`{hUdfK}wRa9%6x*UKpr~d6Lco=Jschz9TUH++VjuknBI~#2r*MPHe|=Z?MQ? z>gec={SHAj-s%mZVP;-j--6%*AzNjcD$#}g*kU_J*O@=k>7P}D*K~ua7X=3~Z5rZH z6-#F)cte)2_pw~_bhz!e#)h)xPii{<)mWFH9@^#lB26DdO$hrJF2(9KQ7F^Lv@WCTm+HqurV9Fsn?+&;lVVwsCVd+r^e;u7wd5u8kzzr>Z8o@}Y`&e}Kdf2A|JM#+AUZ;8nZKSp zTbHE${NQA9n9Tv3qSk1=X;vSj%LX7_M}n)OWZsyzL1OR)n}G|(C2gXQbwj?i!Qdo6 zfY{tI{xK41sosiUQQtN8=pZAWpOV;L*YM;eY-ka(XEI@47x49@3mdaC-OaNRXtmaQ z`G2ohew@ZX{!RXe`Fvbp{3fYlu5BbJwwuFk|Ag9(>a5KG!5FAlG zJK)*W)Rdup$hz1H_+{9KgNrFIiaG_r^8E|ALls4;+$eDy7#w#98X6xJ;YYMoy z{;%})bxbgG1`k6h{I5$U-?C%yoytbcUQ}rCjXswWAAHq`_P|7rC{#)t2hwQN+svy` zv`Bp7gLTGkCt*8(P-JkjKC=J`CaEM zARr7vAeMq@bI;HaQ~O61S@h%H@HCl`@+gdnl#StCk98Y)GS#uDx;Qyu*E45YwY=Wi zGMc@$m>oHEp4@9489m?{-@1);I5IP87si))&D9iRBX{PYkNQn>dcHCC2Wgrl!#~J< zWQt&}TG@m|si4afV!Yvf!ua7sLwnun(w`g@G@Ws~`1OGski6Edd`V**e@Z~tGxCKk z)Ptjfi1PZ-14dl*=6T&?Gq!PQWJ{8e*h4%_PxTIytBafJV4m7%S-l}mT0o7bNTt@Av2COn=6{Z6gisVJud#ymFF6 zf$KW-u?ig*X+%EQ->5f{oY*-Cb8oR(0F_LKg66Gb@x&(I???T<+4O%t>x2xHkT(Sh z8zzmL%i?w6p;0oHwrlA%2xcq{EP8l&s2b$)*e5ZH`w5Z|E8hJj^OhMO7DR!+1^6T~ zYm_$o?~77DzE@MR zzx_pg{GGP{oqoRP=B}J5G9s^$2(DJ5+sUG+b(sxL+fU)n#>S9|2_~-2H-FPFA2xh0 z^pfj(0r47v7P-JX$3E>Nb*(aD#7gY;@wh^%CYqw3VR5L=1?`&{E9u`@Q`;K*r6t6g zp73vM((>I^h-UY>XGm|+m4cmEaFN~y`8GuKK0IVm>-S4uILJQb?iP}4s8(m>-BO65mJ#V z^NH|%`LDv}VcJco#NQe2aKcQ!yxKJ|AF;l$A?I%w=`mvydW_A{gSK??poqk%ABKD?2)-UV72V;OH^gI-Y?%+L-9{r1y));#?n^de8a zAxL|<6tFHZ`rYwoXMC7Xme#r7_^vS(3;+HVS*Q(QEbSUgW2Rs73Ot5qZ(9S}&-@9l z(GUB-e)Z{f3lG5Q!FoQQwV)*GQt9RC8rDc>b)_j-zeF-Ep6f1%FHVbbYTuuZk76+-Py|@z!ENaO9DG zf@zp%zZ!Qla7>GzPU&s4@+~b@QTqxX<1DGumd>VtdM#ce^;Q_9SvKaRw5Vhiu({+ zs$6r<^W-B0L{EFJ*NYykUCi4@G z&jTG1UcOcjwLN6yHmT8{Xe7DP4fQy&JS@2j|7#%{kSVcJ#0L2+dbyzEkioWsg@LQ* zI&Cke&HGirx2dO9?s*r^C9tN33F-y(|Ja9Q&dTGrKtq*9#W`q8AC-9xP+~9|(pxVu zV(4qsH4dXH)N3r}Zcjd`>8iH+isV5mrzg8WD zXZ!Aj`j;j1a#bnXn~k-t^o+gdT~ob&qWg`0^`~4Yv=SL42bX$FzN9DZ^unyIYaH_s8<8k%f+D5wtv?q5!Mvs}4^f|XZhzat>+c#4!&HJfQC->2kK zKFyG764Ppn#t6-3Cb_6Vk(CW%JX`qAQ3M+5!|m~qAt{YVS#PmcP) z5T5l>HQi>9n0MdX>VwOfmx&2^qxm?Sz=iAa()!?Awj-&c(50sWlrzV3n3Yg4V7W{L zI;8PNgK;ba7W*2)c5k1x|tj|;C zI5oPWJ(wkYbCpc<_{wahg;FXPXZOyl#oP_{SVmm{?UZL{?PXiUzWdd}_n=Z^7ykNT zPmxprOnPk1ohpk+SFAFN_uhySObzFA2_K%+ONe}8kD%G@@23FWAJ5Xbd^~`IgEM*O zvh(0YHS_d+i7-G*9!Nm?WsW&rVPU=KBHd3BHGSPfkT@wtW-o&KX-&IL3*%GptgwRzj_?QUU`+zHYoe4osOS_F)Qa6^b=czmoF$ZUnQAJP89{?H}#sLPkvUQv7os< z|9nL)ue!m(pTGDgPfVtWc4KZ zB)JzQvzj4$dlpw$NzD6m-B!J>HFJZrlCZ~8!J9AJi&c+(ex{-qat|BKk4rkMV;iIT zzE_A`m1?ohX$((Mwi&|ftz=nkQ99mbl}z`RcP;%f&SVoRxFtc(4FkcIa}p9_*gIJ# zc--y8if*(EWCWHq_rrPf_C_x^k%aCm7;-|cTzwNT&!T>z$rMP~Dm1USGYwt{n=hwf zg~%>}C-$Hq-s}DSx%=BRgPo-ijfOoa+6*_B@<4w@aNin}?VJ=gPpBRdX?D6s5exm#>QZ|0?lw6TStxV{;pMC8i?@7z4^?n*M}*)y4q@}-r! z75x~Ad@+l6j^d?DZZfSevn&R!|8$n4efM?SGr zwA+(NxvK;i{g-PO-|L^X+l-ehu#mRP#9AlwxSjnLJr8<-{$j1Lvj^iQk15yKEppC+ z;AZRF%_f{SBP-b&(J6!bob2!Wk^0QU9lR2i`L5Qli@o8q@g3ctcA_~#Y8EaQ#RGfp zXMWLwsa#W7r(bKL2t60~)S5>}|5e5oTC50aq=#5*4V50U(`8-hR=duUhy>+#IS#%| zhk+I*$dq&=4Z?nyoZv)B#}tIJAt+R=mUt!H9EPaQ z*R|d!!rF`z<$!p?FdqeX17(Y|w&mih)(p1a8S;D+IJ zaB}X(sKk`mpoYlUWWzy&I_EbhS7Ek4!%OIYC$mosf>9L1dk%s7817plJ7xXZd{V+! z{!gpfwSxac7`+#S85ApFQMe3bzB2*(<&D;i!ZhEw1L6R#(w$NDjEso!;)br3KY|A7 z1kV=MffRh^E~-XpG2`>=HC{+4<+g>Z*Fj!%`P9$0uz+$wpE67>VMcVb!7Q3sK8@Cw zJ<@g3JmBb$hl8tIz3JWyAamyZO4!{biU8BX)Ib8%<-4_gG1?2QEOfPq7A+Kx*(|Gl?+f!DwqpgW$J^ z49rC`i%b*z)}Q|v+$%6nAWCUXX4*+&dd=eDDj#v$xSE+xOpX#H#s0JdPae7I90jSP zx9*%g-sEZDe*Jc|B-_c)#~+;Y+l?_(xcH_t{KlV8Q}c4$o|RwkQ8cbb_KB=TP#644 zGS~SdhH?YQPQJFb2S9YxiF_%1JTl@GN>U1o(la7BcNjQHy1xA~?8>jl0}?}((&E)? z1tW@O)6Cavrxtk2@T7*2_eBv$$Kwko_NWt|E{0D5P#`4PPm<&rx0BU$FF9P#z4_4qpwDi zHpIXQ-ulXh6N)GyWPkx1z$52nM~T`3=b=V>E`t{Lxis@RhlN}wP>H6oJQu{$>Z3^A z{km`GTleaBO@woIHmJJ2HLaV9qQzYx1_mn+5^?`Xawi|ke;eNiB(F{DAVI)G_`YqoH_U&8v{=� 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 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_06-04.png b/.vaunt/badges/badge_06-04.png new file mode 100644 index 0000000000000000000000000000000000000000..6f237981a0b540d4e6c8305fe1cfb302805b92d6 GIT binary patch literal 167564 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

    SVy?xRM?l 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 literal 0 HcmV?d00001 diff --git a/.vaunt/config.yaml b/.vaunt/config.yaml new file mode 100644 index 0000000000000..e761c1a7baa3b --- /dev/null +++ b/.vaunt/config.yaml @@ -0,0 +1,202 @@ +version: 0.0.1 + +achievements: + - achievement: + name: Debugging Dynamo + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-00.png + description: Awarded for creating useful issues. + triggers: + - trigger: + actor: author + action: issue + condition: count(created_at >= "2023-12-26") >= 1 + + - achievement: + name: Pull Request Pioneer + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-00.png + description: Awarded for creating pull requests. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(created_at >= "2023-12-26") >= 1 + + - achievement: + name: Merging Master + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-00.png + description: Awarded for getting pull requests merged. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(merged = true & created_at >= "2023-12-26") >= 1 + + - achievement: + name: Merging Wizard + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-00.png + description: Awarded for getting priority pull requests merged. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(merged = true & labels in {'Priority PR'} & created_at >= "2023-12-26") >= 1 + + - achievement: + name: Ivy Inspectors + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-00.png + description: Awarded for reviewing pull requests. + triggers: + - trigger: + actor: reviewer + action: pull_request + condition: count(created_at >= "2023-12-26") >= 1 + + - achievement: + name: Debugging Dynamo Bronze + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-02.png + description: Awarded for creating 5 useful issues. + triggers: + - trigger: + actor: author + action: issue + condition: count(created_at >= "2023-12-26") >= 5 + + - achievement: + name: Pull Request Pioneer Bronze + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-02.png + description: Awarded for creating 5 pull requests. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(created_at >= "2023-12-26") >= 5 + + - achievement: + name: Merging Master Bronze + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-02.png + description: Awarded for getting 5 pull requests merged. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(merged = true & created_at >= "2023-12-26") >= 5 + + - achievement: + name: Merging Wizard Bronze + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-02.png + description: Awarded for getting 5 priority pull requests merged. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(merged = true & labels in {'Priority PR'} & created_at >= "2023-12-26") >= 5 + + - achievement: + name: Ivy Inspectors Bronze + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-02.png + description: Awarded for reviewing 5 pull requests. + triggers: + - trigger: + actor: reviewer + action: pull_request + condition: count(created_at >= "2023-12-26") >= 5 + + - achievement: + name: Debugging Dynamo Silver + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-03.png + description: Awarded for creating 15 useful issues. + triggers: + - trigger: + actor: author + action: issue + condition: count(created_at >= "2023-12-26") >= 15 + + - achievement: + name: Pull Request Pioneer Silver + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-03.png + description: Awarded for creating 15 pull requests. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(created_at >= "2023-12-26") >= 15 + + - achievement: + name: Merging Master Silver + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-03.png + description: Awarded for getting 15 pull requests merged. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(merged = true & created_at >= "2023-12-26") >= 15 + + - achievement: + name: Merging Wizard Silver + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-03.png + description: Awarded for getting 15 priority pull requests merged. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(merged = true & labels in {'Priority PR'} & created_at >= "2023-12-26") >= 15 + + - achievement: + name: Ivy Inspectors Silver + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-03.png + description: Awarded for reviewing 15 pull requests. + triggers: + - trigger: + actor: reviewer + action: pull_request + condition: count(created_at >= "2023-12-26") >= 15 + + - achievement: + name: Debugging Dynamo Gold + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-04.png + description: Awarded for creating 30 useful issues. + triggers: + - trigger: + actor: author + action: issue + condition: count(created_at >= "2023-12-26") >= 30 + + - achievement: + name: Pull Request Pioneer Gold + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-04.png + description: Awarded for creating 30 pull requests. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(created_at >= "2023-12-26") >= 30 + + - achievement: + name: Merging Master Gold + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-04.png + description: Awarded for getting 30 pull requests merged. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(merged = true & created_at >= "2023-12-26") >= 30 + + - achievement: + name: Merging Wizard Gold + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-04.png + description: Awarded for getting 30 priority pull requests merged. + triggers: + - trigger: + actor: author + action: pull_request + condition: count(merged = true & labels in {'Priority PR'} & created_at >= "2023-12-26") >= 30 + + - achievement: + name: Ivy Inspectors Gold + icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-04.png + description: Awarded for reviewing 30 pull requests. + triggers: + - trigger: + actor: reviewer + action: pull_request + condition: count(created_at >= "2023-12-26") >= 30 From 5a0ea330a158a73b1b8bc6a2a90f620553f3540d Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Tue, 26 Dec 2023 04:15:20 +0000 Subject: [PATCH 429/978] fix(torch-frontend): failing test for torch.Tensor.expand (#27789) Co-authored-by: NripeshN --- .../test_ivy/test_frontends/test_torch/test_tensor.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index e79b86ece43f4..d05d19743fff9 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -6463,6 +6463,13 @@ def test_torch_expand( backend_fw, ): input_dtype, x, shape = dtype_x_shape + + if backend_fw == "paddle": + assume( + input_dtype[0] in ["int32", "int64", "float32", "float64", "bool"] + and len(shape) < 7 + ) + if unpack_shape: method_flags.num_positional_args = len(shape) + 1 size = {} From 43b81ff3dd7ebdadae0d6b05b7ed81f5620463bf Mon Sep 17 00:00:00 2001 From: Ahmed Hisham <62694574+Mghrabi@users.noreply.github.com> Date: Tue, 26 Dec 2023 07:26:38 +0300 Subject: [PATCH 430/978] fix: torch.pow frontend function (#26564) Co-authored-by: NripeshN --- .../test_frontends/test_torch/test_pointwise_ops.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py index 0e7744ac41a41..e59d370752821 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py @@ -9,7 +9,6 @@ two_broadcastable_shapes, ) from ivy_tests.test_ivy.helpers import handle_frontend_test -from ivy_tests.test_ivy.test_functional.test_core.test_elementwise import pow_helper # --- Helpers --- # @@ -2325,7 +2324,13 @@ def test_torch_positive( @handle_frontend_test( fn_tree="torch.pow", - dtype_and_x=pow_helper(), + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=2, + min_value=1, + max_value=7, + shared_dtype=True, + ), ) def test_torch_pow( dtype_and_x, From 28d2e4cd610ef9f4ff9a77b3c4c63dd9918ebbf4 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 26 Dec 2023 05:40:19 +0000 Subject: [PATCH 431/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 98870b7b92546..d73e8c32a2ecd 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 98870b7b92546a9e1dc9b45a0042771bd3c7b505 +Subproject commit d73e8c32a2ecd739a4ecc777fb69ceb01b9622c5 From 66f49c07588cc7fdc75fea9988c6a93cdfabb773 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 26 Dec 2023 11:36:28 +0530 Subject: [PATCH 432/978] fix: added sudo pip install to all other workflows as they don't work with pyproject.toml without sudo (#27791) --- .github/workflows/manual-tests.yml | 6 +++--- .github/workflows/run-all-tests.yml | 2 +- .github/workflows/test-frontend-jax.yml | 2 +- .github/workflows/test-frontend-numpy.yml | 2 +- .github/workflows/test-frontend-tensorflow.yml | 2 +- .github/workflows/test-frontend-torch.yml | 2 +- .github/workflows/test-ivy-core.yml | 2 +- .github/workflows/test-ivy-cron-gpu.yml | 2 +- .github/workflows/test-ivy-cron-multi-version.yml | 2 +- .github/workflows/test-ivy-cron.yml | 2 +- .github/workflows/test-ivy-experimental-core.yml | 2 +- .github/workflows/test-ivy-experimental-nn.yml | 2 +- .github/workflows/test-ivy-nn.yml | 2 +- .github/workflows/test-ivy-stateful.yml | 2 +- 14 files changed, 16 insertions(+), 16 deletions(-) diff --git a/.github/workflows/manual-tests.yml b/.github/workflows/manual-tests.yml index 819ff6cccc31e..0fa60e5338106 100644 --- a/.github/workflows/manual-tests.yml +++ b/.github/workflows/manual-tests.yml @@ -40,7 +40,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem @@ -81,7 +81,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem @@ -99,7 +99,7 @@ jobs: run: | pip3 install pymongo cd ivy - pip3 install -e . + sudo pip3 install -e . python scripts/setup_tests/setup_tests.py "${{ github.event.inputs.test }}" python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} ${{ github.event.inputs.version}} 'false' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true diff --git a/.github/workflows/run-all-tests.yml b/.github/workflows/run-all-tests.yml index 64153d06ffa31..5464f50283b52 100644 --- a/.github/workflows/run-all-tests.yml +++ b/.github/workflows/run-all-tests.yml @@ -45,7 +45,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-frontend-jax.yml b/.github/workflows/test-frontend-jax.yml index 7724876d33b7e..13e676f735a5a 100644 --- a/.github/workflows/test-frontend-jax.yml +++ b/.github/workflows/test-frontend-jax.yml @@ -19,7 +19,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-frontend-numpy.yml b/.github/workflows/test-frontend-numpy.yml index d99000c459b95..464b98a0d802d 100644 --- a/.github/workflows/test-frontend-numpy.yml +++ b/.github/workflows/test-frontend-numpy.yml @@ -19,7 +19,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-frontend-tensorflow.yml b/.github/workflows/test-frontend-tensorflow.yml index f5a03dcef7e1a..1ba8b51c427d6 100644 --- a/.github/workflows/test-frontend-tensorflow.yml +++ b/.github/workflows/test-frontend-tensorflow.yml @@ -19,7 +19,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-frontend-torch.yml b/.github/workflows/test-frontend-torch.yml index 732958fd972a4..acbe96ab030c4 100644 --- a/.github/workflows/test-frontend-torch.yml +++ b/.github/workflows/test-frontend-torch.yml @@ -19,7 +19,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-ivy-core.yml b/.github/workflows/test-ivy-core.yml index f87a42a0abb43..25c41a929e9e8 100644 --- a/.github/workflows/test-ivy-core.yml +++ b/.github/workflows/test-ivy-core.yml @@ -30,7 +30,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-ivy-cron-gpu.yml b/.github/workflows/test-ivy-cron-gpu.yml index b4cd6719fbe58..08ee34cd83dc1 100644 --- a/.github/workflows/test-ivy-cron-gpu.yml +++ b/.github/workflows/test-ivy-cron-gpu.yml @@ -56,7 +56,7 @@ jobs: run: | cd ivy export TAG="cp310-cp310-manylinux_2_17_x86_64" - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-ivy-cron-multi-version.yml b/.github/workflows/test-ivy-cron-multi-version.yml index fd36dd585d175..14d9e02820c75 100644 --- a/.github/workflows/test-ivy-cron-multi-version.yml +++ b/.github/workflows/test-ivy-cron-multi-version.yml @@ -19,7 +19,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-ivy-cron.yml b/.github/workflows/test-ivy-cron.yml index 8e9e62f3faf35..7ee07cd6d3b99 100644 --- a/.github/workflows/test-ivy-cron.yml +++ b/.github/workflows/test-ivy-cron.yml @@ -19,7 +19,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-ivy-experimental-core.yml b/.github/workflows/test-ivy-experimental-core.yml index 8f8117978b2f5..e45ca220c1be2 100644 --- a/.github/workflows/test-ivy-experimental-core.yml +++ b/.github/workflows/test-ivy-experimental-core.yml @@ -29,7 +29,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-ivy-experimental-nn.yml b/.github/workflows/test-ivy-experimental-nn.yml index ef5ebe1c294b1..d6d3e5e3ed5cc 100644 --- a/.github/workflows/test-ivy-experimental-nn.yml +++ b/.github/workflows/test-ivy-experimental-nn.yml @@ -27,7 +27,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-ivy-nn.yml b/.github/workflows/test-ivy-nn.yml index 9f213e1e013bd..8e89adaf2ab2b 100644 --- a/.github/workflows/test-ivy-nn.yml +++ b/.github/workflows/test-ivy-nn.yml @@ -27,7 +27,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem diff --git a/.github/workflows/test-ivy-stateful.yml b/.github/workflows/test-ivy-stateful.yml index c4aeeb690f0b4..b8ea545d0ff24 100644 --- a/.github/workflows/test-ivy-stateful.yml +++ b/.github/workflows/test-ivy-stateful.yml @@ -28,7 +28,7 @@ jobs: - name: Install ivy and fetch binaries run: | cd ivy - pip3 install -e . + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem From 05992a120529b10247248b22e4b5b7e0be0807c4 Mon Sep 17 00:00:00 2001 From: Brahmika Shree Balaji <59389153+brahmika@users.noreply.github.com> Date: Tue, 26 Dec 2023 15:06:11 +0530 Subject: [PATCH 433/978] docs: fix helper function name in navigating the code section (#27786) --- docs/overview/deep_dive/navigating_the_code.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/deep_dive/navigating_the_code.rst b/docs/overview/deep_dive/navigating_the_code.rst index 1fe0e6f256cd7..f70b51aac7c33 100644 --- a/docs/overview/deep_dive/navigating_the_code.rst +++ b/docs/overview/deep_dive/navigating_the_code.rst @@ -199,7 +199,7 @@ To have a better idea on this, let's look at an example! In the :func:`full_like` function in :mod:`creation.py`, the types of :code:`fill_value` and :code:`dtype` has to be verified to avoid errors. This check has to be applied to all backends, which means the related code is common and identical. In this case, we can extract the code to be a helper function on its own, placed in its related submodule (:mod:`creation.py` here). -In this example, the helper function is named as :func:`_assert_fill_value_and_dtype_are_compatible`. +In this example, the helper function is named as :func:`check_fill_value_and_dtype_are_compatible`. Then, we import this submodule-specific helper function to the respective backends, where examples for each backend is shown below. From d3a7737d0b3b0957c5379b6adcb8b7041cbf2d15 Mon Sep 17 00:00:00 2001 From: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> Date: Tue, 26 Dec 2023 15:48:23 +0530 Subject: [PATCH 434/978] Added matmul method to the Paddle frontend (#22654) --- .../frontends/paddle/tensor/tensor.py | 6 + .../test_paddle/test_tensor/test_tensor.py | 105 ++++++++++++++++++ 2 files changed, 111 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 22759dcda4b0d..22b76a5db33d8 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -540,6 +540,12 @@ def squeeze_(self, axis=None, name=None): def multiply(self, y, name=None): return paddle_frontend.multiply(self, y) + @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + def matmul(self, y, transpose_x=False, transpose_y=False, name=None): + return paddle_frontend.matmul( + self, y, transpose_x=transpose_x, transpose_y=transpose_y + ) + @with_supported_dtypes( {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 1c10000a75def..912ba9a7f3593 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -160,6 +160,39 @@ def _get_clip_inputs_(draw): return x_dtype, x, min, max +@st.composite +def _get_dtype_and_3dbatch_matrices_for_matmul(draw): + dim_size1 = draw(helpers.ints(min_value=2, max_value=5)) + dim_size2 = draw(helpers.ints(min_value=2, max_value=5)) + shared_size = draw(helpers.ints(min_value=2, max_value=5)) + dtype = draw(helpers.get_dtypes("float", full=True)) + dtype = [ + draw(st.sampled_from(tuple(set(dtype).difference({"bfloat16", "float16"})))) + ] + batch_size = draw(helpers.ints(min_value=2, max_value=4)) + transpose_x = draw(st.booleans()) + transpose_y = draw(st.booleans()) + + mat1_shape = ( + (batch_size, dim_size1, shared_size) + if not transpose_x + else (batch_size, shared_size, dim_size1) + ) + mat2_shape = ( + (batch_size, shared_size, dim_size2) + if not transpose_y + else (batch_size, dim_size2, shared_size) + ) + + mat1 = draw( + helpers.array_values(dtype=dtype[0], shape=mat1_shape, min_value=2, max_value=5) + ) + mat2 = draw( + helpers.array_values(dtype=dtype[0], shape=mat2_shape, min_value=2, max_value=5) + ) + return dtype, mat1, mat2, transpose_x, transpose_y + + # cond @st.composite def _get_dtype_and_matrix_non_singular(draw, dtypes): @@ -186,6 +219,16 @@ def _get_dtype_and_matrix_non_singular(draw, dtypes): return matrix[0], matrix[1] +@st.composite +def _get_dtype_and_multiplicative_matrices(draw): + return draw( + st.one_of( + _get_dtype_input_and_matrices_for_matmul(), + _get_dtype_and_3dbatch_matrices_for_matmul(), + ) + ) + + @st.composite def _get_dtype_and_square_matrix(draw): dim_size = draw(helpers.ints(min_value=2, max_value=5)) @@ -245,6 +288,30 @@ def _get_dtype_and_values_for_lerp(draw): return input_dtype, x[0], x[1], weight +@st.composite +def _get_dtype_input_and_matrices_for_matmul(draw): + dim_size1 = draw(helpers.ints(min_value=2, max_value=5)) + dim_size2 = draw(helpers.ints(min_value=2, max_value=5)) + shared_size = draw(helpers.ints(min_value=2, max_value=5)) + dtype = draw(helpers.get_dtypes("float", full=True)) + dtype = [ + draw(st.sampled_from(tuple(set(dtype).difference({"bfloat16", "float16"})))) + ] + transpose_x = draw(st.booleans()) + transpose_y = draw(st.booleans()) + + mat1_shape = (shared_size, dim_size1) if transpose_x else (dim_size1, shared_size) + mat2_shape = (dim_size2, shared_size) if transpose_y else (shared_size, dim_size2) + + mat1 = draw( + helpers.array_values(dtype=dtype[0], shape=mat1_shape, min_value=2, max_value=5) + ) + mat2 = draw( + helpers.array_values(dtype=dtype[0], shape=mat2_shape, min_value=2, max_value=5) + ) + return dtype, mat1, mat2, transpose_x, transpose_y + + @st.composite def _reshape_helper(draw): # generate a shape s.t len(shape) > 0 @@ -5736,6 +5803,44 @@ def test_paddle_tensor_heaviside( ) +# matmul +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="matmul", + dtype_tensor1_tensor2=_get_dtype_and_multiplicative_matrices(), +) +def test_paddle_tensor_matmul( + dtype_tensor1_tensor2, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + dtype, tensor1, tensor2, transpose_x, transpose_y = dtype_tensor1_tensor2 + + helpers.test_frontend_method( + init_input_dtypes=dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": tensor1, + }, + method_input_dtypes=dtype, + method_all_as_kwargs_np={ + "y": tensor2, + "transpose_x": transpose_x, + "transpose_y": transpose_y, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # squeeze @handle_frontend_method( class_tree=CLASS_TREE, From c817e4239f22798f5d8fbaf362fb14203d5123f8 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Tue, 26 Dec 2023 22:13:42 +0530 Subject: [PATCH 435/978] Add merge condition for ivy inspectors --- .vaunt/config.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.vaunt/config.yaml b/.vaunt/config.yaml index e761c1a7baa3b..2022b8e133301 100644 --- a/.vaunt/config.yaml +++ b/.vaunt/config.yaml @@ -49,7 +49,7 @@ achievements: - trigger: actor: reviewer action: pull_request - condition: count(created_at >= "2023-12-26") >= 1 + condition: count(created_at >= "2023-12-26" & merged = true) >= 1 - achievement: name: Debugging Dynamo Bronze @@ -99,7 +99,7 @@ achievements: - trigger: actor: reviewer action: pull_request - condition: count(created_at >= "2023-12-26") >= 5 + condition: count(created_at >= "2023-12-26" & merged = true) >= 5 - achievement: name: Debugging Dynamo Silver @@ -149,7 +149,7 @@ achievements: - trigger: actor: reviewer action: pull_request - condition: count(created_at >= "2023-12-26") >= 15 + condition: count(created_at >= "2023-12-26" & merged = true) >= 15 - achievement: name: Debugging Dynamo Gold @@ -199,4 +199,4 @@ achievements: - trigger: actor: reviewer action: pull_request - condition: count(created_at >= "2023-12-26") >= 30 + condition: count(created_at >= "2023-12-26" & merged = true) >= 30 From 23f7c206b18c9ca2099f90e53ac0f128bf37d799 Mon Sep 17 00:00:00 2001 From: Ambroise <56084688+Ambro19@users.noreply.github.com> Date: Tue, 26 Dec 2023 11:57:54 -0500 Subject: [PATCH 436/978] Updated a Minor Grammar Issue in building_blocks.rst (#27292) --- docs/overview/design/building_blocks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/design/building_blocks.rst b/docs/overview/design/building_blocks.rst index 249e48050e006..ca520798d67c2 100644 --- a/docs/overview/design/building_blocks.rst +++ b/docs/overview/design/building_blocks.rst @@ -11,7 +11,7 @@ These are the 4 parts labelled as (a) in the image below: Backend Functional APIs ✅ -------------------------- -The first important point to make is that, Ivy does not implement it’s own C++ or CUDA backend. +The first important point to make is that, Ivy does not implement its own C++ or CUDA backend. Instead, Ivy **wraps** the functional APIs of existing frameworks, bringing them into syntactic and semantic alignment. Let’s take the function :func:`ivy.stack` as an example. From d0631ed6fa7cb381139545c5fdc657cf7529ba20 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 27 Dec 2023 02:30:36 +0530 Subject: [PATCH 437/978] fix: Fixed passing of wrong key-word argument in `paddle.nn.functional.smooth_l1_loss()` (#27794) Fixes wrong key-word argument beta->delta in paddle.nn.functional.smooth_l1_loss() --- ivy/functional/backends/paddle/experimental/losses.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/experimental/losses.py b/ivy/functional/backends/paddle/experimental/losses.py index 7e3d245bbed72..7d23b31362e40 100644 --- a/ivy/functional/backends/paddle/experimental/losses.py +++ b/ivy/functional/backends/paddle/experimental/losses.py @@ -66,7 +66,7 @@ def smooth_l1_loss( reduction: Optional[str] = "mean", ) -> paddle.Tensor: return paddle.nn.functional.smooth_l1_loss( - input, target, reduction=reduction, beta=beta + input, target, reduction=reduction, delta=beta ) From b93182271726af0f359f5353baa7f4983358c2b0 Mon Sep 17 00:00:00 2001 From: yopknopixx <30761130+yopknopixx@users.noreply.github.com> Date: Wed, 27 Dec 2023 11:15:13 +0530 Subject: [PATCH 438/978] fix(torch-frontend): fix failing test for torch.nn.functional.group_norm (#27078) --- ivy/functional/ivy/experimental/norms.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/ivy/experimental/norms.py b/ivy/functional/ivy/experimental/norms.py index 8688da4dccd0a..5418c3fb50df8 100644 --- a/ivy/functional/ivy/experimental/norms.py +++ b/ivy/functional/ivy/experimental/norms.py @@ -489,7 +489,7 @@ def group_norm( x = ivy.permute_dims(x, axes=(0, xdims - 1, *range(1, xdims - 1))) N = x.shape[0] C = x.shape[1] - S = ivy.to_scalar(ivy.prod(x.shape[2:])) if xdims > 2 else 1 + S = int(ivy.to_scalar(ivy.prod(x.shape[2:])) if xdims > 2 else 1) assert C % num_groups == 0 x_ = ivy.reshape(x, [N, num_groups, C // num_groups, S]) mean = ivy.mean(x_, axis=(2, 3), keepdims=True) From 93f71fb4b905ab79a5f38889524b65265d096a8f Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 27 Dec 2023 17:32:32 +0530 Subject: [PATCH 439/978] Added tf.keras.backend frontends and fixed unsupported dtypes function (#27771) Added the tf.keras.backend.rnn, tf.keras.backend.dot and tf.keras.backend.bias_add frontends Added the ivy.rnn function Fixes to the unsupported dtypes functions for inferring the unsupported dtypes of frontend code that uses other frontend code which uses ivy code A fix to ivy.Array.__repr__ to use it when trying to print arrays created with with_backend Fixed the issue with paddle.fluid being deprecated in the recent release --- ivy/data_classes/array/array.py | 8 +- .../container/experimental/layers.py | 75 +++++ .../backends/jax/control_flow_ops.py | 3 +- .../backends/numpy/control_flow_ops.py | 4 +- .../backends/paddle/control_flow_ops.py | 4 + ivy/functional/backends/paddle/elementwise.py | 2 +- .../backends/paddle/manipulation.py | 18 +- ivy/functional/backends/paddle/random.py | 10 +- .../backends/tensorflow/control_flow_ops.py | 2 +- .../tensorflow/experimental/layers.py | 33 ++ .../backends/torch/control_flow_ops.py | 4 +- .../torch/experimental/linear_algebra.py | 1 + .../frontends/tensorflow/keras/__init__.py | 1 + .../frontends/tensorflow/keras/backend.py | 69 ++++ ivy/functional/frontends/tensorflow/nn.py | 4 +- ivy/functional/ivy/control_flow_ops.py | 8 + ivy/functional/ivy/data_type.py | 49 ++- ivy/functional/ivy/experimental/layers.py | 297 ++++++++++++++++++ ivy/functional/ivy/general.py | 8 +- ivy/functional/ivy/nest.py | 2 +- .../test_keras/test_backend.py | 198 ++++++++++++ .../test_frontends/test_tensorflow/test_nn.py | 6 +- .../test_core/test_linalg.py | 6 +- .../test_experimental/test_nn/test_layers.py | 178 ++++++++++- 24 files changed, 954 insertions(+), 36 deletions(-) create mode 100644 ivy/functional/frontends/tensorflow/keras/backend.py create mode 100644 ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 358efed6ddd7b..7794ebee4d7d9 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -399,7 +399,13 @@ def __repr__(self): self._post_repr = ")" sig_fig = ivy.array_significant_figures dec_vals = ivy.array_decimal_values - backend = ivy.with_backend(self.backend) + if self.backend == "" or ivy.is_local(): + # If the array was constructed using implicit backend + backend = ivy.current_backend() + else: + # Requirerd in the case that backend is different + # from the currently set backend + backend = ivy.with_backend(self.backend) arr_np = backend.to_numpy(self._data) rep = ( np.array(ivy.vec_sig_fig(arr_np, sig_fig)) diff --git a/ivy/data_classes/container/experimental/layers.py b/ivy/data_classes/container/experimental/layers.py index cc980962c2e48..ebbb6ed120669 100644 --- a/ivy/data_classes/container/experimental/layers.py +++ b/ivy/data_classes/container/experimental/layers.py @@ -2826,3 +2826,78 @@ def max_unpool1d( padding=padding, data_format=data_format, ) + + @staticmethod + def static_rnn( + step_function: Callable, + inputs: ivy.Array, + initial_states: List[ivy.Array], + /, + *, + go_backwards: bool = False, + mask: Optional[ivy.Array] = None, + constants: Optional[ivy.Array] = None, + unroll: bool = False, + input_length: Optional[int] = None, + time_major: bool = False, + zero_output_for_mask: bool = False, + return_all_outputs: bool = True, + ) -> ivy.Container: + """ivy.Container static method variant of ivy.rnn. + + Parameters + ---------- + step_function + RNN step function. + inputs + Array of temporal data of shape (samples, time, ...). + initial_states + Array with shape (samples, state_size). + go_backwards + If True, do the iteration over the time dimension in reverse order and + return the reversed sequence. + mask + Binary array with shape (samples, time, 1), with a zero for every element + that is masked. + constants + List of constant values passed at each step. + unroll + Whether to use a pythonic while loop or ivy.while_loop + input_length + An integer or 1-D array, depending on whether the time dimension is + fixed-length. In case of variable length input, it is used for masking in + case there is no mask specified. + time_major + If True, the inputs and outputs will be in shape (timesteps, batch, ...) + whereas in the False case, it will be (batch, timesteps, ...). + zero_output_for_mask + If True, the otput for masked timestep will be zeros, whereas in the False + case, output from previous timestep is returned + return_all_outputs + If True, return the recurrent outputs for all timesteps in the sequence. If + False, only return the output for the last timestep. + + Returns + ------- + ret + A tuple of + - the latest output of the rnn of shape (samples, ...) + - the output of the rnn of shape (samples, time, ...) if + return_all_outputs=True else (samples, 1, ...) + - list of tensors, latest states returned by the step funciton, of shape + (samples, ...) + """ + return ContainerBase.cont_multi_map_in_function( + "rnn", + step_function, + inputs, + initial_states, + go_backwards=go_backwards, + mask=mask, + constants=constants, + unroll=unroll, + input_length=input_length, + time_major=time_major, + zero_output_for_mask=zero_output_for_mask, + return_all_outputs=return_all_outputs, + ) diff --git a/ivy/functional/backends/jax/control_flow_ops.py b/ivy/functional/backends/jax/control_flow_ops.py index ba981aadf58b4..3331fc7bef0c8 100644 --- a/ivy/functional/backends/jax/control_flow_ops.py +++ b/ivy/functional/backends/jax/control_flow_ops.py @@ -16,7 +16,8 @@ def body_fn_wrapper(loop_vars): def test_fn_wrapper(loop_vars): return test_fn(*loop_vars) - vars = list(vars.values()) + if isinstance(vars, dict): + vars = list(vars.values()) with jax.disable_jit(): final_loop_vars = jax.lax.while_loop(test_fn_wrapper, body_fn_wrapper, vars) return final_loop_vars diff --git a/ivy/functional/backends/numpy/control_flow_ops.py b/ivy/functional/backends/numpy/control_flow_ops.py index 0a80ff33a461e..97d3b91dcc53e 100644 --- a/ivy/functional/backends/numpy/control_flow_ops.py +++ b/ivy/functional/backends/numpy/control_flow_ops.py @@ -14,7 +14,9 @@ def cond(*_): def while_loop(test_fn, body_fn, vars): - result = list(vars.values()) + result = vars + if isinstance(vars, dict): + result = list(vars.values()) while test_fn(*result): result = body_fn(*result) if not isinstance(result, tuple): diff --git a/ivy/functional/backends/paddle/control_flow_ops.py b/ivy/functional/backends/paddle/control_flow_ops.py index 9d14c8233819a..221625819eb89 100644 --- a/ivy/functional/backends/paddle/control_flow_ops.py +++ b/ivy/functional/backends/paddle/control_flow_ops.py @@ -12,6 +12,10 @@ def if_else(cond, body_fn, orelse_fn, vars): def while_loop(test_fn, body_fn, vars): result = vars + if isinstance(vars, dict): + result = list(vars.values()) while test_fn(*result): result = body_fn(*result) + if not isinstance(result, tuple): + result = (result,) return result diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 146d7e53ee102..01103f05fa2a3 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -28,7 +28,7 @@ def _elementwise_helper(x1, x2): @with_unsupported_dtypes( - {"2.5.1 and below": ("int8", "uint8", "float16", "bool", "bfloat16")}, + {"2.5.2 and below": ("int8", "uint8", "float16", "bool", "bfloat16")}, backend_version, ) def add( diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index f3bb163807d58..8bc317e29c6f5 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -91,7 +91,7 @@ def flip( @with_unsupported_dtypes( - {"2.5.2 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version + {"2.5.2 and below": ("uint8", "int8", "int16", "bfloat16")}, backend_version ) def permute_dims( x: paddle.Tensor, @@ -417,6 +417,22 @@ def zero_pad( return paddle_backend.constant_pad(x, pad_width=pad_width, value=0) +@with_supported_dtypes( + { + "2.5.2 and below": ( + "bool", + "int32", + "int64", + "float16", + "bfloat16", + "float32", + "float64", + "complex64", + "complex128", + ) + }, + backend_version, +) def swapaxes( x: paddle.Tensor, axis0: int, diff --git a/ivy/functional/backends/paddle/random.py b/ivy/functional/backends/paddle/random.py index 3579c42c8bbb7..aa16a3d9d1666 100644 --- a/ivy/functional/backends/paddle/random.py +++ b/ivy/functional/backends/paddle/random.py @@ -8,7 +8,7 @@ # local import ivy -from paddle.fluid.libpaddle import Place +from paddle.device import core from ivy.functional.ivy.random import ( _check_bounds_and_get_shape, _randint_check_dtype_and_bound, @@ -35,7 +35,7 @@ def random_uniform( high: Union[float, paddle.Tensor] = 1.0, shape: Optional[Union[paddle.Tensor, ivy.NativeShape, Sequence[int]]] = None, dtype: paddle.dtype, - device: Place = None, + device: core.Place = None, seed=None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: @@ -66,7 +66,7 @@ def random_normal( shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, dtype: paddle.dtype, seed: Optional[int] = None, - device: Place = None, + device: core.Place = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: _check_valid_scale(std) @@ -95,7 +95,7 @@ def multinomial( batch_size: int = 1, probs: Optional[paddle.Tensor] = None, replace: bool = True, - device: Place = None, + device: core.Place = None, seed: Optional[int] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: @@ -118,7 +118,7 @@ def randint( /, *, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - device: Place = None, + device: core.Place = None, dtype: Optional[Union[paddle.dtype, ivy.Dtype]] = None, seed: Optional[int] = None, out: Optional[paddle.Tensor] = None, diff --git a/ivy/functional/backends/tensorflow/control_flow_ops.py b/ivy/functional/backends/tensorflow/control_flow_ops.py index e56beb4e35731..375ca64e2de40 100644 --- a/ivy/functional/backends/tensorflow/control_flow_ops.py +++ b/ivy/functional/backends/tensorflow/control_flow_ops.py @@ -24,7 +24,7 @@ def test_fn_wrapper(*loop_vars): if not vars: vars = (0,) - else: + elif isinstance(vars, dict): vars = list(vars.values()) return tf.while_loop(test_fn_wrapper, body_fn_wrapper, loop_vars=vars) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index 722ea553bbe95..fd9a1cbace641 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -5,6 +5,8 @@ # local from ivy.func_wrapper import ( + inputs_to_ivy_arrays, + output_to_native_arrays, with_unsupported_dtypes, with_supported_dtypes, with_supported_device_and_dtypes, @@ -1675,3 +1677,34 @@ def sliding_window( return tf.image.extract_patches( images=input, sizes=kernel_size, strides=stride, rates=dilation, padding=padding ) + + +def rnn( + step_function, + inputs, + initial_states, + /, + *, + go_backwards: bool = False, + mask: Optional[Union[tf.Tensor, tf.Variable]] = None, + constants: Optional[Union[tf.Tensor, tf.Variable]] = None, + unroll: bool = False, + input_length: Optional[int] = None, + time_major: bool = False, + zero_output_for_mask: bool = False, + return_all_outputs: bool = True, +): + step_function = inputs_to_ivy_arrays(output_to_native_arrays(step_function)) + return tf.keras.backend.rnn( + step_function, + inputs, + initial_states, + go_backwards=go_backwards, + mask=mask, + constants=constants, + unroll=unroll, + input_length=input_length, + time_major=time_major, + zero_output_for_mask=zero_output_for_mask, + return_all_outputs=return_all_outputs, + ) diff --git a/ivy/functional/backends/torch/control_flow_ops.py b/ivy/functional/backends/torch/control_flow_ops.py index d3a7f92c58d02..7d97ef344120c 100644 --- a/ivy/functional/backends/torch/control_flow_ops.py +++ b/ivy/functional/backends/torch/control_flow_ops.py @@ -17,7 +17,9 @@ def cond(*_): def while_loop(test_fn, body_fn, vars): - result = list(vars.values()) + result = vars + if isinstance(vars, dict): + result = list(vars.values()) while test_fn(*result): result = body_fn(*result) if not isinstance(result, tuple): diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index e73e9f297d7c1..84badc28138d0 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -213,6 +213,7 @@ def lu_factor( raise IvyNotImplementedException() +@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) def dot( a: torch.Tensor, b: torch.Tensor, diff --git a/ivy/functional/frontends/tensorflow/keras/__init__.py b/ivy/functional/frontends/tensorflow/keras/__init__.py index 0d11e115ad78c..052c66a399130 100644 --- a/ivy/functional/frontends/tensorflow/keras/__init__.py +++ b/ivy/functional/frontends/tensorflow/keras/__init__.py @@ -1,4 +1,5 @@ from . import activations +from . import backend from . import layers from . import metrics from . import regularizers diff --git a/ivy/functional/frontends/tensorflow/keras/backend.py b/ivy/functional/frontends/tensorflow/keras/backend.py new file mode 100644 index 0000000000000..0b52cef263d56 --- /dev/null +++ b/ivy/functional/frontends/tensorflow/keras/backend.py @@ -0,0 +1,69 @@ +import functools +import ivy +import ivy.functional.frontends.tensorflow as tf_frontend +from ivy.functional.frontends.tensorflow.func_wrapper import ( + _ivy_array_to_tensorflow, + _to_ivy_array, + to_ivy_arrays_and_back, +) + + +def bias_add(x, bias, data_format=None): + if data_format is None: + data_format = "channels_last" + bias_shape = bias.shape + if len(bias_shape) == 1: + if data_format == "channels_first": + return tf_frontend.nn.bias_add(x, bias, data_format="NC...") + return tf_frontend.nn.bias_add(x, bias, data_format="N...C") + if x.ndim in (3, 4, 5): + if data_format == "channels_first": + bias_reshape_axis = (1, bias_shape[-1]) + bias_shape[:-1] + return x + tf_frontend.reshape(bias, bias_reshape_axis) + return x + tf_frontend.reshape(bias, (1,) + bias_shape) + return tf_frontend.nn.bias_add(x, bias) + + +@to_ivy_arrays_and_back +def dot(x, y): + return ivy.dot(x, y) + + +@to_ivy_arrays_and_back +def rnn( + step_function, + inputs, + initial_states, + go_backwards=False, + mask=None, + constants=None, + unroll=False, + input_length=None, + time_major=False, + zero_output_for_mask=False, + return_all_outputs=True, +): + @functools.wraps(step_function) + def _new_step_function(*args, **kwargs): + frontend_args = ivy.nested_map( + _ivy_array_to_tensorflow, args, include_derived=True, shallow=False + ) + frontend_kwargs = ivy.nested_map( + _ivy_array_to_tensorflow, kwargs, include_derived=True, shallow=False + ) + ret = step_function(*frontend_args, **frontend_kwargs) + return ivy.nested_map(_to_ivy_array, ret, include_derived=True) + + return ivy.rnn( + _new_step_function, + inputs, + initial_states, + go_backwards=go_backwards, + mask=mask, + constants=constants, + unroll=unroll, + input_length=input_length, + time_major=time_major, + zero_output_for_mask=zero_output_for_mask, + return_all_outputs=return_all_outputs, + ) diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index 7c473ff53e72e..724c6d71d1a36 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -127,8 +127,8 @@ def bias_add(value, bias, data_format=None, name=None): if data_format is None: data_format = "N...C" - chanel_index = data_format.find("C") - if chanel_index != 1: + channel_index = data_format.find("C") + if channel_index != 1: return ivy.add(value, bias) else: value = ivy.swapaxes(value, 1, -1) diff --git a/ivy/functional/ivy/control_flow_ops.py b/ivy/functional/ivy/control_flow_ops.py index 9973de660b546..7537d6c202408 100644 --- a/ivy/functional/ivy/control_flow_ops.py +++ b/ivy/functional/ivy/control_flow_ops.py @@ -3,8 +3,12 @@ from ivy.utils.backend import current_backend from ivy.func_wrapper import ( handle_array_like_without_promotion, + handle_backend_invalid, + handle_device, + outputs_to_ivy_arrays, to_native_arrays_and_back, ) +from ivy.utils.exceptions import handle_exceptions def if_else( @@ -61,6 +65,10 @@ def _if_else(cond, body_fn, orelse_fn, **vars): return _if_else(cond, body_fn, orelse_fn, **vars) +@handle_exceptions +@handle_backend_invalid +@outputs_to_ivy_arrays +@handle_device def while_loop( test_fn: Callable, body_fn: Callable, diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index 8c55058f0d3ce..5e418ff22ec49 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -96,9 +96,10 @@ def _get_function_list(func): hasattr(nodef, "value") and hasattr(nodef.value, "id") and nodef.value.id not in ["ivy", "self"] + and "_frontend" not in nodef.value.id ): continue - names[nodef.attr] = getattr( + names[ast.unparse(nodef)] = getattr( func, "__self__", getattr( @@ -115,13 +116,14 @@ def _get_function_list(func): def _get_functions_from_string(func_names, module): ret = set() # We only care about the functions in the ivy or the same module - for func_name in func_names.keys(): + for orig_func_name in func_names.keys(): + func_name = orig_func_name.split(".")[-1] if hasattr(ivy, func_name) and callable(getattr(ivy, func_name, None)): ret.add(getattr(ivy, func_name)) - elif hasattr(module, func_name) and callable(getattr(ivy, func_name, None)): + elif hasattr(module, func_name) and callable(getattr(module, func_name, None)): ret.add(getattr(module, func_name)) - elif callable(getattr(func_names[func_name], func_name, None)): - ret.add(getattr(func_names[func_name], func_name)) + elif callable(getattr(func_names[orig_func_name], func_name, None)): + ret.add(getattr(func_names[orig_func_name], func_name)) return ret @@ -147,7 +149,10 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): # if it's einops, we need to recurse if not getattr(fn, "__module__", None): continue - if "backend" in fn.__module__: + is_frontend_fn = "frontend" in fn.__module__ + is_backend_fn = "backend" in fn.__module__ and not is_frontend_fn + is_einops_fn = "einops" in fn.__name__ + if is_backend_fn: f_supported = get_fn(fn, False) if hasattr(fn, "partial_mixed_handler"): f_supported = merge_fn( @@ -162,9 +167,7 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): ) out = merge_fn(wrapper(f_supported), out) continue - elif "frontend" in fn.__module__ or ( - hasattr(fn, "__name__") and "einops" in fn.__name__ - ): + elif is_frontend_fn or (hasattr(fn, "__name__") and is_einops_fn): f_supported = wrapper(get_fn(fn, False)) out = merge_fn(f_supported, out) @@ -174,8 +177,30 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): continue fl = _get_function_list(fn) - res = _get_functions_from_string(fl, __import__(fn.__module__)) - to_visit.extend(res) + res = list(_get_functions_from_string(fl, __import__(fn.__module__))) + if is_frontend_fn: + frontends = { + "jax_frontend": "ivy.functional.frontends.jax", + "np_frontend": "ivy.functional.frontends.numpy", + "tf_frontend": "ivy.functional.frontends.tensorflow", + "torch_frontend": "ivy.functional.frontends.torch", + "paddle_frontend": "ivy.functional.frontends.paddle", + } + for key in fl: + if "frontend" in key: + fn_tree = key.split(".") + root, tree, fn_name = fn_tree[0], fn_tree[1:-1], fn_tree[-1] + root_module = importlib.import_module( + ".".join([frontends[root], *tree]) + ) + frontend_fn = getattr(root_module, fn_name) + frontend_fl = _get_function_list(frontend_fn) + res += list( + _get_functions_from_string( + frontend_fl, __import__(frontend_fn.__module__) + ) + ) + to_visit.extend(set(res)) return out @@ -208,8 +233,8 @@ def _get_dtypes(fn, complement=True): # We only care about getting dtype info from the base function # if we do need to at some point use dtype information from the parent function # we can comment out the following condition - is_backend_fn = "backend" in fn.__module__ is_frontend_fn = "frontend" in fn.__module__ + is_backend_fn = "backend" in fn.__module__ and not is_frontend_fn has_unsupported_dtypes_attr = hasattr(fn, "unsupported_dtypes") if not is_backend_fn and not is_frontend_fn and not has_unsupported_dtypes_attr: if complement: diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 4feb56a7c788f..5f629ef41f639 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -3243,3 +3243,300 @@ def max_unpool1d( ), "to_skip": ("inputs_to_ivy_arrays", "handle_partial_mixed_function"), } + + +@handle_exceptions +@handle_backend_invalid +@handle_nestable +@inputs_to_ivy_arrays +@handle_device +def rnn( + step_function: Callable, + inputs: ivy.Array, + initial_states: List[ivy.Array], + /, + *, + go_backwards: bool = False, + mask: Optional[ivy.Array] = None, + constants: Optional[ivy.Array] = None, + unroll: bool = False, + input_length: Optional[int] = None, + time_major: bool = False, + zero_output_for_mask: bool = False, + return_all_outputs: bool = True, +): + """Iterate over the time dimension of a tensor. + + Parameters + ---------- + step_function + RNN step function. + inputs + Array of temporal data of shape (samples, time, ...). + initial_states + Array with shape (samples, state_size). + go_backwards + If True, do the iteration over the time dimension in reverse order and return + the reversed sequence. + mask + Binary array with shape (samples, time, 1), with a zero for every element that + is masked. + constants + List of constant values passed at each step. + unroll + Whether to use a pythonic while loop or ivy.while_loop + input_length + An integer or 1-D array, depending on whether the time dimension is + fixed-length. In case of variable length input, it is used for masking in case + there is no mask specified. + time_major + If True, the inputs and outputs will be in shape (timesteps, batch, ...) whereas + in the False case, it will be (batch, timesteps, ...). + zero_output_for_mask + If True, the otput for masked timestep will be zeros, whereas in the False case, + output from previous timestep is returned + return_all_outputs + If True, return the recurrent outputs for all timesteps in the sequence. If + False, only return the output for the last timestep. + + Returns + ------- + ret + A tuple of + - the latest output of the rnn of shape (samples, ...) + - the output of the rnn of shape (samples, time, ...) if + return_all_outputs=True else (samples, 1, ...) + - list of tensors, latest states returned by the step funciton, of shape + (samples, ...) + + Both the description and the type hints above assumes an array input for simplicity, + but this function is *nestable*, and therefore also accepts :class:`ivy.Container` + instances in place of any of the arguments. + """ + # an ivy implementation of rnn inspired from + # https://github.com/keras-team/keras/blob/v2.14.0/keras/backend.py#L4723-L5202 + + # Swap the batch and timestep dim for the incoming tensor. + if not time_major: + inputs = ivy.permute_dims(inputs, (1, 0, *range(2, len(inputs.shape)))) + + time_steps = inputs.shape[0] + batch = inputs.shape[1] + time_steps_t = ivy.asarray(inputs.shape[0]) + + if mask is not None: + if not ivy.is_bool_dtype(mask): + mask = ivy.astype(mask, ivy.bool) + if len(mask.shape) == 2: + mask = ivy.expand_dims(mask) + if not time_major: + mask = ivy.permute_dims(mask, (1, 0, *range(2, len(mask.shape)))) + + if constants is None: + constants = [] + + def _expand_mask(mask_t, input_t, fixed_dim=1): + rank_diff = len(input_t.shape) - len(mask_t.shape) + for _ in range(rank_diff): + mask_t = ivy.expand_dims(mask_t, axis=-1) + multiples = [1] * fixed_dim + list(input_t.shape[fixed_dim:]) + return ivy.tile(mask_t, repeats=multiples) + + if unroll: + states = tuple(initial_states) + successive_states = [] + successive_outputs = [] + + processed_input = ivy.unstack(inputs) + if go_backwards: + processed_input.reverse() + + if mask is not None: + mask_list = ivy.unstack(mask) + if go_backwards: + mask_list.reverse() + + for i in range(time_steps): + input_t = processed_input[i] + mask_t = mask_list[i] + output_t, new_states = step_function( + input_t, tuple(states) + tuple(constants) + ) + tiled_mask_t = _expand_mask(mask_t, output_t) + + if not successive_outputs: + prev_output = ivy.zeros_like(output_t) + else: + prev_output = successive_outputs[-1] + + output = ivy.where(tiled_mask_t, output_t, prev_output) + + tiled_mask_t = tuple(_expand_mask(mask_t, s) for s in states) + final_states = tuple( + ivy.where(m, s, ps) + for m, s, ps in zip(tiled_mask_t, new_states, states) + ) + states = final_states + + if return_all_outputs: + successive_outputs.append(output) + successive_states.append(states) + else: + successive_outputs = [output] + successive_states = [states] + last_output = successive_outputs[-1] + new_states = successive_states[-1] + outputs = ivy.stack(successive_outputs) + + if zero_output_for_mask: + last_output = ivy.where( + _expand_mask(mask_list[-1], last_output), + last_output, + ivy.zeros_like(last_output), + ) + outputs = ivy.where( + _expand_mask(mask, outputs, fixed_dim=2), + outputs, + ivy.zeros_like(outputs), + ) + + else: + for i in range(time_steps): + input_t = processed_input[i] + output_t, states = step_function( + input_t, tuple(states) + tuple(constants) + ) + if return_all_outputs: + successive_outputs.append(output_t) + successive_states.append(states) + else: + successive_outputs = [output_t] + successive_states = [states] + last_output = successive_outputs[-1] + new_states = successive_states[-1] + outputs = ivy.stack(successive_outputs) + + else: + states = tuple(initial_states) + input_time_zero = inputs[0] + output_time_zero, _ = step_function( + input_time_zero, tuple(initial_states) + tuple(constants) + ) + + output_size = int(time_steps_t) if return_all_outputs else 1 + output_loop = ivy.empty( + (output_size, *output_time_zero.shape), dtype=output_time_zero.dtype + ) + + if go_backwards: + inputs = ivy.flip(inputs, axis=0) + time = 0 + + test_fn = lambda time, *_: time < time_steps_t + if mask is not None: + if go_backwards: + mask = ivy.flip(mask, axis=0) + + mask_list = ivy.unstack(mask) + + def masking_fn(time): + return mask_list[time] + + def compute_masked_output(mask_t, output, mask): + tiled_mask_t = tuple( + _expand_mask(mask_t, o, fixed_dim=len(mask_t.shape)) for o in output + ) + return tuple( + ivy.where(m, o, fm) for m, o, fm in zip(tiled_mask_t, output, mask) + ) + + elif ivy.is_ivy_array(input_length): + if go_backwards: + max_len = ivy.max(input_length) + rev_input_length = ivy.subtract(max_len - 1, input_length) + + def masking_fn(time): + return rev_input_length < time + + else: + + def masking_fn(time): + return input_length > time + + def compute_masked_output(mask_t, output, mask): + return ivy.where(mask_t, output, mask) + + else: + masking_fn = None + + if masking_fn is not None: + zero_output = ivy.zeros_like(output_time_zero) + + def _step(time, output_t, prev_output, *states): + current_input = inputs[time] + mask_t = masking_fn(time) + output, new_states = step_function( + current_input, tuple(states) + tuple(constants) + ) + mask_output = zero_output if zero_output_for_mask else prev_output + new_output = compute_masked_output(mask_t, [output], [mask_output])[0] + + for state, new_state in zip(states, new_states): + if ivy.is_ivy_array(new_state): + ivy.reshape(new_state, shape=state.shape, out=new_state) + final_states = compute_masked_output(mask_t, new_states, states) + new_states = final_states + output_t[time if return_all_outputs else 0] = new_output + + return (time + 1, output_t, new_output) + tuple(new_states) + + final_outputs = ivy.while_loop( + test_fn=test_fn, + body_fn=_step, + vars=(time, output_loop, zero_output) + states, + ) + new_states = final_outputs[3:] + else: + + def _step(time, output_t, *states): + current_input = inputs[time] + output, new_states = step_function( + current_input, tuple(states) + tuple(constants) + ) + + for state, new_state in zip(states, new_states): + if ivy.is_ivy_array(new_state): + ivy.reshape(new_state, shape=state.shape, out=new_state) + + output_t[time if return_all_outputs else 0] = output + return (time + 1, output_t) + tuple(new_states) + + final_outputs = ivy.while_loop( + test_fn=test_fn, body_fn=_step, vars=(time, output_loop) + states + ) + new_states = final_outputs[2:] + + outputs = final_outputs[1] + last_output = outputs[-1] + + shape = list(outputs.shape) + if return_all_outputs: + shape[0] = time_steps + else: + shape[0] = 1 + shape[1] = batch + outputs = ivy.reshape(outputs, shape) + + if not time_major: + outputs = ivy.permute_dims(outputs, (1, 0, *range(2, len(outputs.shape)))) + + return last_output, outputs, new_states + + +rnn.mixed_backend_wrappers = { + "to_add": ( + "inputs_to_native_arrays", + "outputs_to_ivy_arrays", + ), + "to_skip": ("inputs_to_ivy_arrays",), +} diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index a1de906212d34..ab09c25b25d43 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -3974,7 +3974,7 @@ def _expand_typesets(dtypes): return dtypes -def _get_devices_and_dtypes(fn, recurse=False, complement=True): +def _get_devices_and_dtypes(fn, recurse=True, complement=True): supported_devices = ivy.function_supported_devices(fn, recurse=recurse) supported_dtypes = ivy.function_supported_dtypes(fn, recurse=recurse) @@ -3987,8 +3987,8 @@ def _get_devices_and_dtypes(fn, recurse=False, complement=True): for device in supported_devices: supported[device] = supported_dtypes - is_backend_fn = "backend" in fn.__module__ is_frontend_fn = "frontend" in fn.__module__ + is_backend_fn = "backend" in fn.__module__ and not is_frontend_fn is_einops_fn = "einops" in fn.__name__ if not is_backend_fn and not is_frontend_fn and not is_einops_fn: if complement: @@ -4003,7 +4003,7 @@ def _get_devices_and_dtypes(fn, recurse=False, complement=True): if hasattr(fn, "supported_device_and_dtype"): fn_supported_dnd = fn.supported_device_and_dtype.__get__() - if "einops" in fn.__name__ and isinstance(fn_supported_dnd, dict): + if is_einops_fn and isinstance(fn_supported_dnd, dict): fn_supported_dnd = fn_supported_dnd.get(backend, supported) if fn_supported_dnd: @@ -4021,7 +4021,7 @@ def _get_devices_and_dtypes(fn, recurse=False, complement=True): if hasattr(fn, "unsupported_device_and_dtype"): fn_unsupported_dnd = fn.unsupported_device_and_dtype.__get__() - if "einops" in fn.__name__ and isinstance(fn_unsupported_dnd, dict): + if is_einops_fn and isinstance(fn_unsupported_dnd, dict): fn_unsupported_dnd = fn_unsupported_dnd.get(backend, supported) if fn_unsupported_dnd: diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index 39b49a647ea89..e0e97a718cda6 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -1510,7 +1510,7 @@ def _found_in_index_chains(this_index_chain, index_chains): ) ) ret = func(values, this_index_chain) - if to_ivy: + if to_ivy and ret is not None: if isinstance(nest, (ivy.Array, ivy.NativeArray)): return ret else: diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py new file mode 100644 index 0000000000000..15a4e171fa146 --- /dev/null +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py @@ -0,0 +1,198 @@ +# global +from hypothesis import assume, strategies as st +from ivy.func_wrapper import output_to_native_arrays + +# local +import ivy_tests.test_ivy.helpers as helpers +from ivy_tests.test_ivy.helpers import handle_frontend_test +from ivy_tests.test_ivy.test_functional.test_experimental.test_core.test_linalg import ( + _generate_dot_dtype_and_arrays, +) +from ivy_tests.test_ivy.test_frontends.test_tensorflow.test_nn import ( + _generate_bias_data, +) +from ivy_tests.test_ivy.test_functional.test_experimental.test_nn.test_layers import ( + _lstm_helper, +) +import ivy +from ivy.functional.frontends.tensorflow.func_wrapper import ( + inputs_to_ivy_arrays, + outputs_to_frontend_arrays, +) +import ivy.functional.frontends.tensorflow as tf_frontend + + +@handle_frontend_test( + fn_tree="tensorflow.keras.backend.dot", + data=_generate_dot_dtype_and_arrays(min_num_dims=2), +) +def test_tensorflow_dot(*, data, on_device, fn_tree, frontend, test_flags, backend_fw): + (input_dtypes, x) = data + return helpers.test_frontend_function( + input_dtypes=input_dtypes, + test_flags=test_flags, + backend_to_test=backend_fw, + on_device=on_device, + frontend=frontend, + fn_tree=fn_tree, + rtol=0.5, + atol=0.5, + x=x[0], + y=x[1], + ) + + +@handle_frontend_test( + fn_tree="tensorflow.keras.backend.bias_add", + data=_generate_bias_data(keras_backend_fn=True), + test_with_out=st.just(False), +) +def test_tensorflow_keras_backend_bias_add( + *, + data, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + data_format, dtype, x, bias = data + helpers.test_frontend_function( + input_dtypes=dtype * 2, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x=x[0], + bias=bias, + data_format=data_format, + ) + + +@handle_frontend_test( + fn_tree="tensorflow.keras.backend.rnn", + rnn_args=_lstm_helper(), + test_with_out=st.just(False), +) +def test_tensorflow_keras_backend_rnn( + *, + rnn_args, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + ( + input_dtypes, + inputs, + kernel_orig, + recurrent_kernel_orig, + bias_orig, + recurrent_bias_orig, + initial_states, + go_backwards, + mask, + unroll, + input_length, + time_major, + zero_output_for_mask, + return_all_outputs, + ) = rnn_args + + # unsupported dtype of float16 is in our _lstm_step function + # so can't be inferred through ivy.function_unsupported_devices_and_dtypes + assume(not (backend_fw == "torch" and input_dtypes[0] == "float16")) + + def _lstm_step(cell_inputs, cell_states): + nonlocal kernel_orig, recurrent_kernel_orig, bias_orig, recurrent_bias_orig + kernel = ivy.array(kernel_orig) + recurrent_kernel = ivy.array(recurrent_kernel_orig) + bias = ivy.array(bias_orig) + recurrent_bias = ivy.array(recurrent_bias_orig) + + h_tm1 = cell_states[0] # previous memory state + c_tm1 = cell_states[1] # previous carry state + + z = ivy.dot(cell_inputs, kernel) + bias + z += ivy.dot(h_tm1, recurrent_kernel) + recurrent_bias + + z0, z1, z2, z3 = ivy.split(z, num_or_size_splits=4, axis=-1) + + i = ivy.sigmoid(z0) # input + f = ivy.sigmoid(z1) # forget + c = f * c_tm1 + i * ivy.tanh(z2) + o = ivy.sigmoid(z3) # output + + h = o * ivy.tanh(c) + return h, [h, c] + + np_vals = [inputs, *initial_states, mask] + + if mask is None: + np_vals.pop(-1) + + with ivy.utils.backend.ContextManager(backend_fw): + _lstm_step_backend = outputs_to_frontend_arrays( + inputs_to_ivy_arrays(_lstm_step) + ) + vals = [ivy.array(val) for val in np_vals] + if len(vals) > 3: + inputs, init_h, init_c, mask = vals + else: + inputs, init_h, init_c = vals + initial_states = [init_h, init_c] + + args = (_lstm_step_backend, inputs, initial_states) + kwargs = { + "go_backwards": go_backwards, + "mask": mask, + "constants": None, + "unroll": unroll, + "input_length": input_length, + "time_major": time_major, + "zero_output_for_mask": zero_output_for_mask, + "return_all_outputs": return_all_outputs, + } + ret = tf_frontend.keras.backend.rnn(*args, **kwargs) + ivy_ret = ivy.nested_map(lambda x: x.ivy_array, ret, shallow=False) + ivy_idxs = ivy.nested_argwhere(ivy_ret, ivy.is_ivy_array) + ivy_vals = ivy.multi_index_nest(ivy_ret, ivy_idxs) + ret_np_flat = [x.to_numpy() for x in ivy_vals] + + with ivy.utils.backend.ContextManager(frontend): + _lstm_step_gt = output_to_native_arrays(inputs_to_ivy_arrays(_lstm_step)) + import tensorflow as tf + + vals = [ivy.array(val).data for val in np_vals] + if len(vals) > 3: + inputs, init_h, init_c, mask = vals + else: + inputs, init_h, init_c = vals + initial_states = [init_h, init_c] + + args = (_lstm_step_gt, inputs, initial_states) + kwargs = { + "go_backwards": go_backwards, + "mask": mask, + "constants": None, + "unroll": unroll, + "input_length": input_length, + "time_major": time_major, + "zero_output_for_mask": zero_output_for_mask, + "return_all_outputs": return_all_outputs, + } + ret = tf.keras.backend.rnn(*args, **kwargs) + native_idxs = ivy.nested_argwhere(ret, lambda x: isinstance(x, ivy.NativeArray)) + native_vals = ivy.multi_index_nest(ret, native_idxs) + frontend_ret_np_flat = [x.numpy() for x in native_vals] + + helpers.value_test( + ret_np_flat=ret_np_flat, + ret_np_from_gt_flat=frontend_ret_np_flat, + rtol=1e-1, + atol=1e-1, + backend=backend_fw, + ground_truth_backend=frontend, + ) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py index 9c26b4a068eb4..ce528f775d260 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py @@ -136,9 +136,13 @@ def _dropout_helper(draw): @st.composite -def _generate_bias_data(draw): +def _generate_bias_data(draw, keras_backend_fn=False): data_format = draw(st.sampled_from(["NC...", "N...C", None])) channel_dim = 1 if data_format == "NC..." else -1 + if keras_backend_fn: + data_format = {"NC...": "channels_first", "N...C": "channels_last", None: None}[ + data_format + ] dtype, value, shape = draw( helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("numeric"), diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py index fe2f805d4759b..e89b36633e92f 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py @@ -162,15 +162,15 @@ def _generate_diag_args(draw): # dot @st.composite -def _generate_dot_dtype_and_arrays(draw): +def _generate_dot_dtype_and_arrays(draw, min_num_dims=0): shape_a = draw( helpers.get_shape( - min_dim_size=2, max_dim_size=5, min_num_dims=0, max_num_dims=5 + min_dim_size=2, max_dim_size=5, min_num_dims=min_num_dims, max_num_dims=5 ) ) shape_b = draw( helpers.get_shape( - min_dim_size=2, max_dim_size=5, min_num_dims=0, max_num_dims=5 + min_dim_size=2, max_dim_size=5, min_num_dims=min_num_dims, max_num_dims=5 ) ) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index 1425e1eaf79fe..a4dd5711d5c64 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -6,7 +6,7 @@ # local import ivy import ivy_tests.test_ivy.helpers as helpers -from ivy_tests.test_ivy.helpers import handle_test +from ivy_tests.test_ivy.helpers import handle_test, BackendHandler # --- Helpers --- # @@ -154,6 +154,93 @@ def _interp_args(draw, mode=None, mode_list=None): return (dtype, x, mode, size, align_corners, scale_factor, recompute_scale_factor) +@st.composite +def _lstm_helper(draw): + input_size = draw(helpers.ints(min_value=2, max_value=5)) + hidden_size = 4 * input_size + input_length = draw(helpers.ints(min_value=2, max_value=5)) + batch_size = draw(helpers.ints(min_value=1, max_value=4)) * 2 + dtype = draw(helpers.get_dtypes("float", full=False)) + (time_major, go_backwards, unroll, zero_output_for_mask, return_all_outputs) = draw( + helpers.array_bools(size=5) + ) + shape = [batch_size, input_length, input_size] + if time_major: + shape = [input_length, batch_size, input_size] + inputs = draw( + helpers.dtype_and_values( + available_dtypes=dtype, + shape=shape, + min_value=-1, + max_value=1, + abs_smallest_val=1e-5, + safety_factor_scale="log", + ) + )[1][0] + mask = draw( + st.just([None, [None]]) + | helpers.dtype_and_values( + available_dtypes=["bool"], + shape=[*shape[:2], 1], + ) + )[1][0] + kernel, recurrent_kernel = draw( + helpers.dtype_and_values( + available_dtypes=dtype, + num_arrays=2, + shape=(input_size, hidden_size), + min_value=-1, + max_value=1, + abs_smallest_val=1e-5, + safety_factor_scale="log", + ) + )[1] + bias, recurrent_bias = draw( + helpers.dtype_and_values( + available_dtypes=dtype, + num_arrays=2, + shape=(1, hidden_size), + min_value=-1, + max_value=1, + abs_smallest_val=1e-5, + safety_factor_scale="log", + ) + )[1] + init_h, init_c = draw( + helpers.dtype_and_values( + available_dtypes=dtype, + num_arrays=2, + shape=(batch_size, input_size), + min_value=-1, + max_value=1, + abs_smallest_val=1e-5, + safety_factor_scale="log", + ) + )[1] + dtypes = [dtype[0] for _ in range(7)] + if mask is not None: + dtypes.append("bool") + # ToDo : zero_output_for_mask doesn't work if we don't return_all_outputs + # in tensorflow + zero_output_for_mask = zero_output_for_mask and return_all_outputs + return ( + dtypes, + inputs, + kernel, + recurrent_kernel, + bias, + recurrent_bias, + [init_h, init_c], + go_backwards, + mask, + unroll, + input_length, + time_major, + zero_output_for_mask, + return_all_outputs, + ) + + @st.composite def _reduce_window_helper(draw, get_func_st): dtype = draw(helpers.get_dtypes("valid", full=False, index=2)) @@ -1371,6 +1458,95 @@ def test_rfftn( ) +# test_rnn +@handle_test( + fn_tree="functional.ivy.experimental.rnn", + rnn_args=_lstm_helper(), + test_with_out=st.just(False), + test_instance_method=st.just(False), +) +def test_rnn( + *, + rnn_args, + test_flags, + backend_fw, + fn_name, + on_device, +): + # ToDo : Get the tests passing with paddle + ( + input_dtypes, + inputs, + kernel_orig, + recurrent_kernel_orig, + bias_orig, + recurrent_bias_orig, + initial_states, + go_backwards, + mask, + unroll, + input_length, + time_major, + zero_output_for_mask, + return_all_outputs, + ) = rnn_args + + # unsupported dtype of float16 is in our _lstm_step function + # so can't be inferred through ivy.function_unsupported_devices_and_dtypes + assume(not (backend_fw == "torch" and input_dtypes[0] == "float16")) + + def _lstm_step(cell_inputs, cell_states): + with BackendHandler.update_backend( + ivy.current_backend( + cell_inputs.to_native() + if "ivy" in str(type(cell_inputs)) + else cell_inputs + ).backend + ) as ivy_backend: + nonlocal kernel_orig, recurrent_kernel_orig, bias_orig, recurrent_bias_orig + kernel = ivy_backend.array(kernel_orig) + recurrent_kernel = ivy_backend.array(recurrent_kernel_orig) + bias = ivy_backend.array(bias_orig) + recurrent_bias = ivy_backend.array(recurrent_bias_orig) + + h_tm1 = cell_states[0] # previous memory state + c_tm1 = cell_states[1] # previous carry state + + z = ivy_backend.dot(cell_inputs, kernel) + bias + z += ivy_backend.dot(h_tm1, recurrent_kernel) + recurrent_bias + + z0, z1, z2, z3 = ivy_backend.split(z, num_or_size_splits=4, axis=-1) + + i = ivy_backend.sigmoid(z0) # input + f = ivy_backend.sigmoid(z1) # forget + c = f * c_tm1 + i * ivy_backend.tanh(z2) + o = ivy_backend.sigmoid(z3) # output + + h = o * ivy_backend.tanh(c) + return h, [h, c] + + helpers.test_function( + input_dtypes=input_dtypes, + test_flags=test_flags, + backend_to_test=backend_fw, + on_device=on_device, + fn_name=fn_name, + rtol_=1e-1, + atol_=1e-1, + step_function=_lstm_step, + inputs=inputs, + initial_states=initial_states, + go_backwards=go_backwards, + mask=mask, + constants=None, + unroll=unroll, + input_length=input_length, + time_major=time_major, + zero_output_for_mask=zero_output_for_mask, + return_all_outputs=return_all_outputs, + ) + + @handle_test( fn_tree="functional.ivy.experimental.sliding_window", all_args=helpers.arrays_for_pooling(3, 3, 1, 2, return_dilation=True), From 13c16b99fc6f2de9c8f400b31026d0bcff097f7f Mon Sep 17 00:00:00 2001 From: Zois <64856990+joyios1@users.noreply.github.com> Date: Wed, 27 Dec 2023 19:58:29 +0200 Subject: [PATCH 440/978] feat: implementation of torch.cdist function to pytorch frontend. (#27004) Co-authored-by: zois Co-authored-by: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Co-authored-by: NripeshN --- .../frontends/torch/miscellaneous_ops.py | 40 +++++++++++++++++ .../test_torch/test_miscellaneous_ops.py | 44 +++++++++++++++++++ 2 files changed, 84 insertions(+) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 9369885c74745..7bd69abad45d5 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -92,6 +92,46 @@ def cartesian_prod(*tensors): return ret +@with_unsupported_dtypes({"2.1.2 and below": "float16"}, "torch") +@to_ivy_arrays_and_back +def cdist(x1, x2, p=2.0, compute_mode="use_mm_for_euclid_dist_if_necessary"): + if len(x1.shape) != 3 or len(x2.shape) != 3: + raise ivy.exceptions.IvyError( + "Both ivy arrays need to have 3 dimensions (BxRxM)" + ) + + if ( + compute_mode != "use_mm_for_euclid_dist_if_necessary" + and compute_mode != "use_mm_for_euclid_dist" + and compute_mode != "donot_use_mm_for_euclid_dist" + ): + raise ivy.exceptions.IvyError( + f"{compute_mode} is not a valid value for compute_mode" + ) + if p == 2: + B, P, M = x1.shape + _, R, _ = x2.shape + if ( + compute_mode == "use_mm_for_euclid_dist_if_necessary" + and (P > 25 or R > 25) + or compute_mode == "use_mm_for_euclid_dist" + ): + return ivy.vector_norm( + x1[:, :, None, :] - x2[:, None, :, :], axis=-1, ord=p + ) + else: + distances = ivy.zeros((B, P, R), dtype=x1.dtype) + for b in range(B): + for i in range(P): + for j in range(R): + distances[b, i, j] = ivy.vector_norm( + x1[b, i, :] - x2[b, j, :], ord=p + ) + return distances + else: + return ivy.vector_norm(x1[:, :, None, :] - x2[:, None, :, :], axis=-1, ord=p) + + @to_ivy_arrays_and_back def clone(input, *, memory_format=None): return ivy.copy_array(input) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 340fe6bed6930..d0e35c7d98f6b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -510,6 +510,50 @@ def test_torch_cartesian_prod( ) +@handle_frontend_test( + fn_tree="torch.cdist", + dtypes_and_x=helpers.dtype_and_values( + shape=st.shared(helpers.get_shape(min_num_dims=3, max_num_dims=3), key="shape"), + shared_dtype=True, + num_arrays=2, + allow_inf=False, + available_dtypes=["float32", "float64"], + ), + p=st.integers(min_value=0, max_value=1000000), + compute_mode=st.sampled_from( + [ + "use_mm_for_euclid_dist_if_necessary", + "use_mm_for_euclid_dist", + "donot_use_mm_for_euclid_dist", + ] + ), +) +def test_torch_cdist( + *, + dtypes_and_x, + p, + compute_mode, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + input_dtypes, xs = dtypes_and_x + helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x1=xs[0], + x2=xs[1], + p=p, + compute_mode=compute_mode, + ) + + # clone @handle_frontend_test( fn_tree="torch.clone", From 164b223e7bc45b83147097f723eed06d5b9b5ada Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 28 Dec 2023 11:07:38 +0530 Subject: [PATCH 441/978] fix: Fixed the glibc version issue with the gpu docker image after the new release of paddle --- docker/gpu_framework_directory.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docker/gpu_framework_directory.py b/docker/gpu_framework_directory.py index d5ecc15c70ecc..ba365c1efb467 100644 --- a/docker/gpu_framework_directory.py +++ b/docker/gpu_framework_directory.py @@ -53,9 +53,8 @@ def install_pkg(path, pkg, base="fw/"): elif pkg.split("==")[0] if "==" in pkg else pkg == "paddle": subprocess.run( "yes |pip install " - f" paddlepaddle-gpu=={get_latest_package_version('paddlepaddle')}.post120" - f" --target {path} -f" - " https://www.paddlepaddle.org.cn/whl/linux/mkl/avx/stable.html " + f" paddlepaddle-gpu=={get_latest_package_version('paddlepaddle')}" + f" --target {path} -f https://mirror.baidu.com/pypi/simple " " --no-cache-dir", shell=True, ) From 3f28537e0a0783ebcd68e2c11e9c6a30ed4b4d17 Mon Sep 17 00:00:00 2001 From: Bhushan Srivastava <59949692+he11owthere@users.noreply.github.com> Date: Thu, 28 Dec 2023 13:38:30 +0530 Subject: [PATCH 442/978] Fixed the test failures for tensor.torch.Tensor.__rmul__ (#27805) Co-authored-by: NripeshN --- ivy/functional/frontends/torch/tensor.py | 13 ++++++++++++- .../test_frontends/test_torch/test_tensor.py | 2 +- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index ba131b8fa34d7..bc1c9536cc07a 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1237,7 +1237,18 @@ def __mul__(self, other): def __matmul__(self, other): return torch_frontend.matmul(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes( + { + "2.1.2 and below": ( + "float16", + "int8", + "int16", + "bool", + "uint8", + ) + }, + "torch", + ) def __rmul__(self, other): return torch_frontend.mul(other, self) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index d05d19743fff9..838b3c80026d4 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -1177,7 +1177,7 @@ def test_torch___radd__( init_tree="torch.tensor", method_name="__rmul__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, min_value=-1e04, max_value=1e04, From 56bf012e05512f7f65abb893aa9027aec4cbf4cf Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 28 Dec 2023 19:42:25 +0000 Subject: [PATCH 443/978] test: add helper function to run fit for given inputs and return the predict method --- .../test_frontends/test_sklearn/test_tree/test_tree.py | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py diff --git a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py new file mode 100644 index 0000000000000..fe372fad46d1a --- /dev/null +++ b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py @@ -0,0 +1,8 @@ +import ivy.functional.frontends.sklearn as sklearn_frontend + + +# helper functions +def _get_sklearn_predict(X, y, max_depth): + ivy_clf = sklearn_frontend.tree.DecisionTreeClassifier(max_depth=max_depth) + ivy_clf.fit(X, y) + return ivy_clf.predict From d78fd4ad20cbfda174c5834befb63ef8a3071fae Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 28 Dec 2023 21:19:37 +0000 Subject: [PATCH 444/978] test: add simple outline to test the predict method in sklearn frontend. the integration with already exisiting strategies requires some work as predict method assume fit called etc. --- .../test_sklearn/test_tree/test_tree.py | 41 +++++++++++++++++-- 1 file changed, 37 insertions(+), 4 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py index fe372fad46d1a..2ccfa67fb8212 100644 --- a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py +++ b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py @@ -1,8 +1,41 @@ import ivy.functional.frontends.sklearn as sklearn_frontend +import numpy as np +import ivy +from hypothesis import given +import ivy_tests.test_ivy.helpers as helpers + + +# --- Helpers --- # +# --------------- # # helper functions -def _get_sklearn_predict(X, y, max_depth): - ivy_clf = sklearn_frontend.tree.DecisionTreeClassifier(max_depth=max_depth) - ivy_clf.fit(X, y) - return ivy_clf.predict +def _get_sklearn_predict(X, y, max_depth, module=None): + clf = module.tree.DecisionTreeClassifier(max_depth=max_depth) + clf.fit(X, y) + return clf.predict + + +# --- Main --- # +# ------------ # + + +# todo: integrate with already existing strats and generalize +@given( + X=helpers.array_values(shape=(5, 2), dtype=helpers.get_dtypes("float")), + y=helpers.array_values(shape=(5,), dtype=helpers.get_dtypes("integer")), +) +def test_sklearn_tree_predict(X, y): + try: + import sklearn + except ImportError: + print("sklearn not installed, skipping test_sklearn_tree_predict") + return + sklearn_pred = _get_sklearn_predict(X, y, max_depth=3, module=sklearn)(X) + for fw in helpers.available_frameworks: + ivy.set_backend(fw) + ivy_pred = _get_sklearn_predict( + ivy.array(X), ivy.array(y), max_depth=3, module=sklearn_frontend + )(X) + assert np.allclose(ivy_pred.to_numpy(), sklearn_pred) + ivy.unset_backend() From d5e04d4c666034344202225d4ce172e0abfd3df9 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 29 Dec 2023 10:07:02 +0000 Subject: [PATCH 445/978] fix: generate only signed integer labels for testing sklearn decision tree predict method, simplify and refactor of the logic to avoid attribute error when calling upon sklearn tree submodule. --- .../test_sklearn/test_tree/test_tree.py | 27 +++++++++---------- 1 file changed, 13 insertions(+), 14 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py index 2ccfa67fb8212..8bb3c7353c26d 100644 --- a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py +++ b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py @@ -1,4 +1,4 @@ -import ivy.functional.frontends.sklearn as sklearn_frontend +from ivy.functional.frontends.sklearn.tree import DecisionTreeClassifier as ivy_DTC import numpy as np import ivy from hypothesis import given @@ -10,8 +10,8 @@ # helper functions -def _get_sklearn_predict(X, y, max_depth, module=None): - clf = module.tree.DecisionTreeClassifier(max_depth=max_depth) +def _get_sklearn_predict(X, y, max_depth, DecisionTreeClassifier): + clf = DecisionTreeClassifier(max_depth=max_depth) clf.fit(X, y) return clf.predict @@ -22,20 +22,19 @@ def _get_sklearn_predict(X, y, max_depth, module=None): # todo: integrate with already existing strats and generalize @given( - X=helpers.array_values(shape=(5, 2), dtype=helpers.get_dtypes("float")), - y=helpers.array_values(shape=(5,), dtype=helpers.get_dtypes("integer")), + X=helpers.array_values( + shape=(5, 2), dtype=helpers.get_dtypes("float", prune_function=False) + ), + y=helpers.array_values( + shape=(5,), dtype=helpers.get_dtypes("signed_integer", prune_function=False) + ), ) def test_sklearn_tree_predict(X, y): try: - import sklearn + from sklearn.tree import DecisionTreeClassifier as sklearn_DTC except ImportError: print("sklearn not installed, skipping test_sklearn_tree_predict") return - sklearn_pred = _get_sklearn_predict(X, y, max_depth=3, module=sklearn)(X) - for fw in helpers.available_frameworks: - ivy.set_backend(fw) - ivy_pred = _get_sklearn_predict( - ivy.array(X), ivy.array(y), max_depth=3, module=sklearn_frontend - )(X) - assert np.allclose(ivy_pred.to_numpy(), sklearn_pred) - ivy.unset_backend() + sklearn_pred = _get_sklearn_predict(X, y, 3, sklearn_DTC)(X) + ivy_pred = _get_sklearn_predict(ivy.array(X), ivy.array(y), 3, ivy_DTC)(X) + assert np.allclose(ivy_pred.to_numpy(), sklearn_pred) From 65102a97fa5d7b921aebbe7e2016ed2a00889821 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 29 Dec 2023 15:11:23 +0400 Subject: [PATCH 446/978] fix: update discord links (#27811) --- CONTRIBUTING.md | 2 +- docs/overview/contributing/error_handling.rst | 12 ++++++------ docs/overview/contributing/open_tasks.rst | 6 +++--- docs/overview/contributing/setting_up.rst | 18 +++++++++--------- docs/overview/contributing/the_basics.rst | 14 +++++++------- docs/overview/deep_dive/array_api_tests.rst | 4 ++-- docs/overview/deep_dive/arrays.rst | 4 ++-- docs/overview/deep_dive/backend_setting.rst | 4 ++-- docs/overview/deep_dive/containers.rst | 4 ++-- .../deep_dive/continuous_integration.rst | 4 ++-- docs/overview/deep_dive/data_types.rst | 4 ++-- docs/overview/deep_dive/devices.rst | 4 ++-- docs/overview/deep_dive/docstring_examples.rst | 4 ++-- docs/overview/deep_dive/docstrings.rst | 4 ++-- docs/overview/deep_dive/exception_handling.rst | 4 ++-- docs/overview/deep_dive/fix_failing_tests.rst | 14 +++++++------- docs/overview/deep_dive/formatting.rst | 4 ++-- docs/overview/deep_dive/function_arguments.rst | 4 ++-- docs/overview/deep_dive/function_types.rst | 4 ++-- docs/overview/deep_dive/function_wrapping.rst | 4 ++-- docs/overview/deep_dive/gradients.rst | 4 ++-- docs/overview/deep_dive/inplace_updates.rst | 4 ++-- docs/overview/deep_dive/ivy_frontends.rst | 4 ++-- .../overview/deep_dive/ivy_frontends_tests.rst | 4 ++-- docs/overview/deep_dive/ivy_lint.rst | 2 +- docs/overview/deep_dive/ivy_tests.rst | 4 ++-- .../overview/deep_dive/navigating_the_code.rst | 4 ++-- docs/overview/deep_dive/superset_behaviour.rst | 4 ++-- 28 files changed, 76 insertions(+), 76 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 37cfa8e39bd59..1655ef485e509 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -48,4 +48,4 @@ Please, follow the next process when you work on your subtask: [![Video](https://img.youtube.com/vi/wBKTOGmwfbo/0.jpg)](https://www.youtube.com/embed/wBKTOGmwfbo) -For questions, please reach out on [discord](https://discord.gg/MDK979Ga) in the [todo list issues channel](https://discord.com/channels/799879767196958751/982728618469912627)! +For questions, please reach out on [discord](https://discord.gg/MDK979Ga) in the [todo list issues thread](https://discord.com/channels/799879767196958751/1189903501011202128)! diff --git a/docs/overview/contributing/error_handling.rst b/docs/overview/contributing/error_handling.rst index 2ddfa6be2c4ca..75f7e300e5432 100644 --- a/docs/overview/contributing/error_handling.rst +++ b/docs/overview/contributing/error_handling.rst @@ -2,11 +2,11 @@ Error Handling ============== .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`pycharm channel`: https://discord.com/channels/799879767196958751/942114831039856730 -.. _`docker channel`: https://discord.com/channels/799879767196958751/942114744691740772 -.. _`pre-commit channel`: https://discord.com/channels/799879767196958751/982725464110034944 -.. _`pip packages channel`: https://discord.com/channels/799879767196958751/942114789642080317 -.. _`ivy tests channel`: https://discord.com/channels/799879767196958751/982738436383445073 +.. _`pycharm thread`: https://discord.com/channels/799879767196958751/1186628916522262629 +.. _`docker thread`: https://discord.com/channels/799879767196958751/1186629067966009424 +.. _`pre-commit thread`: https://discord.com/channels/799879767196958751/1186629635694399539 +.. _`pip packages thread`: https://discord.com/channels/799879767196958751/1186629837515935765 +.. _`ivy tests thread`: https://discord.com/channels/799879767196958751/1189907526226034698 This section, "Error Handling" aims to assist you in navigating through some common errors you might encounter while working with the Ivy's Functional API. We'll go through some common errors which you might encounter while working as a contributor or a developer. @@ -150,4 +150,4 @@ This section is specifically targeted towards dealing with the Ivy Functional AP This should have hopefully given you an understanding of how to deal with common errors while working with the the functional API. -If you have any questions, please feel free to reach out on `discord`_ in the `ivy tests channel`_, `pycharm channel`_, `docker channel`_, `pre-commit channel`_, `pip packages channel`_ depending on the question! +If you have any questions, please feel free to reach out on `discord`_ in the `ivy tests thread`_, `pycharm thread`_, `docker thread`_, `pre-commit thread`_, `pip packages thread`_ depending on the question! diff --git a/docs/overview/contributing/open_tasks.rst b/docs/overview/contributing/open_tasks.rst index de80e03222b7c..38556ecf8594f 100644 --- a/docs/overview/contributing/open_tasks.rst +++ b/docs/overview/contributing/open_tasks.rst @@ -3,7 +3,7 @@ Open Tasks .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`open tasks channel`: https://discord.com/channels/799879767196958751/982728618469912627 +.. _`open tasks thread`: https://discord.com/channels/799879767196958751/1189903501011202128 .. _`issue description`: https://github.com/unifyai/ivy/issues/1526 .. _`reference API`: https://numpy.org/doc/stable/reference/routines.linalg.html .. _`imports`: https://github.com/unifyai/ivy/blob/38dbb607334cb32eb513630c4496ad0024f80e1c/ivy/functional/frontends/numpy/__init__.py#L27 @@ -25,7 +25,7 @@ The tasks currently open are: #. Frontend APIs #. Ivy Experimental API -We try to explain these tasks as clearly as possible, but in cases where things are not clear, then please feel free to reach out on `discord`_ in the `open tasks channel`_! +We try to explain these tasks as clearly as possible, but in cases where things are not clear, then please feel free to reach out on `discord`_ in the `open tasks thread`_! Please always use the latest commit on GitHub when working on any of these tasks, **DO NOT** develop your code using the latest PyPI release of :code:`ivy`. @@ -338,4 +338,4 @@ Creating an Issue on Ivy's GitHub using a Template This should have hopefully given you a good understanding of the basics for contributing. -If you have any questions, please feel free to reach out on `discord`_ in the `open tasks channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `open tasks thread`_! diff --git a/docs/overview/contributing/setting_up.rst b/docs/overview/contributing/setting_up.rst index 0b6c0535dbc93..876ab5e8c54d0 100644 --- a/docs/overview/contributing/setting_up.rst +++ b/docs/overview/contributing/setting_up.rst @@ -3,10 +3,10 @@ Setting Up .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`pycharm channel`: https://discord.com/channels/799879767196958751/942114831039856730 -.. _`docker channel`: https://discord.com/channels/799879767196958751/942114744691740772 -.. _`pre-commit channel`: https://discord.com/channels/799879767196958751/982725464110034944 -.. _`pip packages channel`: https://discord.com/channels/799879767196958751/942114789642080317 +.. _`pycharm thread`: https://discord.com/channels/799879767196958751/1186628916522262629 +.. _`docker thread`: https://discord.com/channels/799879767196958751/1186629067966009424 +.. _`pre-commit thread`: https://discord.com/channels/799879767196958751/1186629635694399539 +.. _`pip packages thread`: https://discord.com/channels/799879767196958751/1186629837515935765 .. _`miniconda`: https://docs.conda.io/en/latest/miniconda.html .. _`venv`: https://docs.python.org/3/library/venv.html .. _`ivy/scripts`: https://github.com/unifyai/ivy/tree/bcddc79978afe447958dfa3ea660716845c85846/scripts @@ -66,7 +66,7 @@ In order to install and properly set up pre-commit, these steps should be follow That's it! Now when you make a commit, the pre-commit hooks will all be run correctly, as explained above. -For questions, please reach out on `discord`_ in the `pre-commit channel`_! +For questions, please reach out on `discord`_ in the `pre-commit thread`_! PyCharm @@ -83,7 +83,7 @@ Many people seem to miss this option, so we thought we would add an explicit rem #. To continue using PyCharm Professional, you can use the trial version making a jetbrains account but that would be only valid for 1 month. #. After the trial expires you have to buy the paid version of PyCharm Professional. -For questions, please reach out on `discord`_ in the `pycharm channel`_! +For questions, please reach out on `discord`_ in the `pycharm thread`_! Virtual environments - No Docker -------------------------------- @@ -445,7 +445,7 @@ This is a common error which you might face. If you are not successfully able to sudo chmod a+rwx /var/run/docker.pid -For questions, please reach out on `discord`_ in the `docker channel`_! +For questions, please reach out on `discord`_ in the `docker thread`_! **Video** @@ -560,7 +560,7 @@ Now, if Hypothesis detects an error in the code it will return more detailed inf .. image:: https://raw.githubusercontent.com/unifyai/unifyai.github.io/main/img/externally_linked/contributing/setting_up/more_detailed_hypothesis_logs/detailed_hypothesis_example.png?raw=true :width: 420 -For questions, please reach out on `discord`_ in the `docker channel`_! +For questions, please reach out on `discord`_ in the `docker thread`_! **"Empty Suite" error fix:** @@ -893,4 +893,4 @@ Running a :code:`pip install -e .` is sufficient to download the binaries if the This should have hopefully given you a good understanding of how to get things properly set up. -If you have any questions, please feel free to reach out on `discord`_ in the `pycharm channel`_, `docker channel`_, `pre-commit channel`_, `pip packages channel`_ depending on the question! +If you have any questions, please feel free to reach out on `discord`_ in the `pycharm thread`_, `docker thread`_, `pre-commit thread`_, `pip packages thread`_ depending on the question! diff --git a/docs/overview/contributing/the_basics.rst b/docs/overview/contributing/the_basics.rst index 1c2f3966ce8c9..7f2add42f6967 100644 --- a/docs/overview/contributing/the_basics.rst +++ b/docs/overview/contributing/the_basics.rst @@ -3,9 +3,9 @@ The Basics .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`todo list issues channel`: https://discord.com/channels/799879767196958751/982728618469912627 +.. _`todo list issues thread`: https://discord.com/channels/799879767196958751/1189903501011202128 .. _`Atlassian tutorial`: https://www.atlassian.com/git/tutorials/saving-changes/git-stash -.. _`fork management channel`: https://discord.com/channels/799879767196958751/982728689408167956 +.. _`fork management thread`: https://discord.com/channels/799879767196958751/1189903708465672272 .. _`pull requests channel`: https://discord.com/channels/799879767196958751/982728733859414056 .. _`PyCharm blog`: https://www.jetbrains.com/help/pycharm/finding-and-replacing-text-in-file.html .. _`Debugging`: https://www.jetbrains.com/help/pycharm/debugging-code.html @@ -112,7 +112,7 @@ For example, a sequence of comments like this :code:`- [ ] #Issue_number` will r | -For questions, please reach out on `discord`_ in the `todo list issues channel`_! +For questions, please reach out on `discord`_ in the `todo list issues thread`_! Managing Your Fork ------------------ @@ -153,7 +153,7 @@ For a comprehensive explanation of git stashing, check out this `Atlassian tutor | -For questions, please reach out on `discord`_ in the `fork management channel`_! +For questions, please reach out on `discord`_ in the `fork management thread`_! Who To Ask ---------- @@ -248,7 +248,7 @@ The code review process is explained in more detail in the following video. | -For questions, please reach out on `discord`_ in the `pull requests channel`_! +For questions, please reach out on `discord`_ in the `pull requests thread`_! Small Commits Often ------------------- @@ -294,7 +294,7 @@ As a final note, a beautiful commit history is not something we particularly car We're much more concerned that the code itself is good, that things are updated as quickly as possible, and that all developers are able to work efficiently. If a mistake is committed into the history, it's generally not too difficult to simply undo this in future commits, so don't stress about this too much 🙂 -For questions, please reach out on the on `discord`_ in the `commit frequency channel`_! +For questions, please reach out on the on `discord`_ in the `commit frequency thread`_! Interactive Ivy Docker Container -------------------------------- @@ -598,4 +598,4 @@ with PyCharm This should have hopefully given you a good understanding of the basics for contributing. -If you have any questions, please feel free to reach out on `discord`_ in the `todo list issues channel`_, `fork management channel`_, `pull requests channel`_, depending on the question! +If you have any questions, please feel free to reach out on `discord`_ in the `todo list issues thread`_, `fork management thread`_, `pull requests thread`_, depending on the question! diff --git a/docs/overview/deep_dive/array_api_tests.rst b/docs/overview/deep_dive/array_api_tests.rst index 3a6aa29a8d67b..383c3e30098a0 100644 --- a/docs/overview/deep_dive/array_api_tests.rst +++ b/docs/overview/deep_dive/array_api_tests.rst @@ -7,7 +7,7 @@ Array API Tests .. _`for each backend`: https://github.com/unifyai/ivy/tree/20d07d7887766bb0d1707afdabe6e88df55f27a5/.github/workflows .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`array api tests channel`: https://discord.com/channels/799879767196958751/982738404611592256 +.. _`array api tests thread`: https://discord.com/channels/799879767196958751/1189907361494741073 .. _`scripts/shell/test_array_api.sh`: https://github.com/unifyai/ivy/blob/bcddc79978afe447958dfa3ea660716845c85846/scripts/shell/test_array_api.sh .. _`array-api test repository`: https://github.com/data-apis/array-api/tree/main .. _`issue`: https://github.com/numpy/numpy/issues/21213 @@ -204,7 +204,7 @@ The fact that the skip instruction itself contains the exact input conditions th This should have hopefully given you a good understanding of how the Array API test suite is used for testing Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `array api tests channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `array api tests thread`_! **Video** diff --git a/docs/overview/deep_dive/arrays.rst b/docs/overview/deep_dive/arrays.rst index 02dccc5352c56..83ee85f9d9026 100644 --- a/docs/overview/deep_dive/arrays.rst +++ b/docs/overview/deep_dive/arrays.rst @@ -21,7 +21,7 @@ Arrays .. _`__truediv__`: https://github.com/unifyai/ivy/blob/e4d9247266f5d99faad59543923bb24b88a968d9/ivy/array/__init__.py#L319 .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`arrays channel`: https://discord.com/channels/799879767196958751/933380487353872454 +.. _`arrays thread`: https://discord.com/channels/799879767196958751/1189905906905919609 .. _`wrapped logic`: https://github.com/unifyai/ivy/blob/6a729004c5e0db966412b00aa2fce174482da7dd/ivy/func_wrapper.py#L95 .. _`NumPy's`: https://numpy.org/doc/stable/user/basics.dispatch.html#basics-dispatch .. _`PyTorch's`: https://pytorch.org/docs/stable/notes/extending.html#extending-torch @@ -176,7 +176,7 @@ It is relevant to mention again that any function not stored inside the dict :co This should have hopefully given you a good feel for the different types of arrays, and how these are handled in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `arrays channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `arrays thread`_! **Video** diff --git a/docs/overview/deep_dive/backend_setting.rst b/docs/overview/deep_dive/backend_setting.rst index 6a7565ec335f0..18e89197b684c 100644 --- a/docs/overview/deep_dive/backend_setting.rst +++ b/docs/overview/deep_dive/backend_setting.rst @@ -8,7 +8,7 @@ Backend Setting .. _`wrap the functions`: https://github.com/unifyai/ivy/blob/1eb841cdf595e2bb269fce084bd50fb79ce01a69/ivy/backend_handler.py#L204 .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`backend setting channel`: https://discord.com/channels/799879767196958751/982737886963187772 +.. _`backend setting thread`: https://discord.com/channels/799879767196958751/1189905734645850254 The backend framework can either be set by calling :code:`ivy.set_backend(backend_name)` or it can inferred from the arguments. For the latter, a global variable `implicit_backend`_ is located in the file which is initialized as numpy, and is always used to infer the backend in cases where: (a) no backend has been set using the :code:`set_backend` function and (b) the backend cannot be inferred from the inputs. @@ -129,7 +129,7 @@ If the user's system doesn't have the backend framework installed, we default to This should have hopefully given you a good feel for how the backend framework is set. -If you have any questions, please feel free to reach out on `discord`_ in the `backend setting channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `backend setting thread`_! **Video** diff --git a/docs/overview/deep_dive/containers.rst b/docs/overview/deep_dive/containers.rst index bfcc94e048bbe..5ffa466429872 100644 --- a/docs/overview/deep_dive/containers.rst +++ b/docs/overview/deep_dive/containers.rst @@ -31,7 +31,7 @@ Containers .. _`__truediv__`: https://github.com/unifyai/ivy/blob/b725ed10bca15f6f10a0e5154af10231ca842da2/ivy/container/container.py#L399 .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`containers channel`: https://discord.com/channels/799879767196958751/982738042886422598 +.. _`containers thread`: https://discord.com/channels/799879767196958751/1189906066549506048 The `ivy.Container`_ inherits from `dict`_, and is useful for storing nested data. @@ -334,7 +334,7 @@ This is for three reasons, (a) the key chain :code:`g` is not shared by any cont This should have hopefully given you a good feel for containers, and how these are handled in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `containers channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `containers thread`_! **Video** diff --git a/docs/overview/deep_dive/continuous_integration.rst b/docs/overview/deep_dive/continuous_integration.rst index 9653ddd175da9..09c63c4fd4f5b 100644 --- a/docs/overview/deep_dive/continuous_integration.rst +++ b/docs/overview/deep_dive/continuous_integration.rst @@ -1,7 +1,7 @@ Continuous Integration ====================== -.. _`continuous integration channel`: https://discord.com/channels/799879767196958751/1028268051776413759 +.. _`continuous integration channel`: https://discord.com/channels/799879767196958751/1189908611208597544 .. _`discord`: https://discord.gg/sXyFF8tDtm We follow the practice of Continuous Integration (CI), in order to regularly build and test code at Ivy. @@ -397,7 +397,7 @@ You can filter tests by selecting choices from the various dropdowns. The link c This should have hopefully given you a good feel for how Continuous Integration works in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `continuous integration channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `continuous integration thread`_! **Video** diff --git a/docs/overview/deep_dive/data_types.rst b/docs/overview/deep_dive/data_types.rst index f3cb6defae24b..0dff16390e4bf 100644 --- a/docs/overview/deep_dive/data_types.rst +++ b/docs/overview/deep_dive/data_types.rst @@ -24,7 +24,7 @@ Data Types .. _`ivy.set_default_dtype`: https://github.com/unifyai/ivy/blob/8482eb3fcadd0721f339a1a55c3f3b9f5c86d8ba/ivy/functional/ivy/data_type.py#L1555 .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`data types channel`: https://discord.com/channels/799879767196958751/982738078445760532 +.. _`data type thread`: https://discord.com/channels/799879767196958751/1190234670806351892 The data types supported by Ivy are as follows: @@ -739,7 +739,7 @@ As with all superset design decisions, this behavior makes it much easier to sup This should have hopefully given you a good feel for data types, and how these are handled in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `data types channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `data types thread`_! **Video** diff --git a/docs/overview/deep_dive/devices.rst b/docs/overview/deep_dive/devices.rst index 2b68f1bbabec1..33636fdee3b6f 100644 --- a/docs/overview/deep_dive/devices.rst +++ b/docs/overview/deep_dive/devices.rst @@ -25,7 +25,7 @@ Devices .. _`ivy.unset_default_device()`: https://github.com/unifyai/ivy/blob/2f90ce7b6a4c8ddb7227348d58363cd2a3968602/ivy/functional/ivy/device.py#L869 .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`devices channel`: https://discord.com/channels/799879767196958751/982738108166602752 +.. _`devices thread`: https://discord.com/channels/799879767196958751/1189906353653817354 The devices currently supported by Ivy are as follows: @@ -270,7 +270,7 @@ There are some functions(mostly creation function) which accept a :code:`device` This should have hopefully given you a good feel for devices, and how these are handled in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `devices channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `devices thread`_! **Video** diff --git a/docs/overview/deep_dive/docstring_examples.rst b/docs/overview/deep_dive/docstring_examples.rst index 1debbc8d67963..5ca12840e0534 100644 --- a/docs/overview/deep_dive/docstring_examples.rst +++ b/docs/overview/deep_dive/docstring_examples.rst @@ -3,7 +3,7 @@ Docstring Examples .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`docstring examples channel`: https://discord.com/channels/799879767196958751/982738352103129098 +.. _`docstring examples thread`: https://discord.com/channels/799879767196958751/1189906990307233822 After writing the general docstrings, the final step is to add helpful examples to the docstrings. @@ -747,7 +747,7 @@ Passing docstring tests is a necessary but not sufficient condition for the comp These three examples should give you a good understanding of what is required when adding docstring examples. -If you have any questions, please feel free to reach out on `discord`_ in the `docstring examples channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `docstring examples thread`_! **Video** diff --git a/docs/overview/deep_dive/docstrings.rst b/docs/overview/deep_dive/docstrings.rst index ead0f7a5b19c4..5e83f4face088 100644 --- a/docs/overview/deep_dive/docstrings.rst +++ b/docs/overview/deep_dive/docstrings.rst @@ -5,7 +5,7 @@ Docstrings .. _`spec/API_specification/array_api`: https://github.com/data-apis/array-api/blob/main .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`docstrings channel`: https://discord.com/channels/799879767196958751/982738313897197600 +.. _`docstrings thread`: https://discord.com/channels/799879767196958751/1189906836426596412 All functions in the Ivy API at :mod:`ivy/functional/ivy/category_name.py` should have full and thorough docstrings. @@ -193,7 +193,7 @@ Therefore, with the exception of the :class:`ivy.Array` and :class:`ivy.Containe These examples should hopefully give you a good understanding of what is required when adding docstings. -If you have any questions, please feel free to reach out on `discord`_ in the `docstrings channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `docstrings thread`_! **Video** diff --git a/docs/overview/deep_dive/exception_handling.rst b/docs/overview/deep_dive/exception_handling.rst index 55313c46b00a4..2ad306b06f03a 100644 --- a/docs/overview/deep_dive/exception_handling.rst +++ b/docs/overview/deep_dive/exception_handling.rst @@ -1,7 +1,7 @@ Exception Handling ================== -.. _`exception handling channel`: https://discord.com/channels/799879767196958751/1028267924043092068 +.. _`exception handling thread`: https://discord.com/channels/799879767196958751/1189908450570928149 .. _`discord`: https://discord.gg/sXyFF8tDtm As Ivy is unifying multiple backends, various issues are seen during exception handling: @@ -545,7 +545,7 @@ Instead of coding a conditional block and raising an exception if the conditions This should have hopefully given you a good feel for how function wrapping is applied to functions in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `exception handling channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `exception handling thread`_! **Video** diff --git a/docs/overview/deep_dive/fix_failing_tests.rst b/docs/overview/deep_dive/fix_failing_tests.rst index c2dc97832636c..f86dfc62cc99e 100644 --- a/docs/overview/deep_dive/fix_failing_tests.rst +++ b/docs/overview/deep_dive/fix_failing_tests.rst @@ -5,17 +5,17 @@ Fix Failing Tests: .. _`issues`: https://github.com/unifyai/ivy/issues?q=is%3Aopen+is%3Aissue+label%3A%22Failing+Test%22 .. _`issue`: https://github.com/unifyai/ivy/issues/25849 .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`docker channel`: https://discord.com/channels/799879767196958751/942114744691740772 +.. _`docker thread`: https://discord.com/channels/799879767196958751/1186629067966009424 .. _`miniconda`: https://docs.conda.io/en/latest/miniconda.html .. _`venv`: https://docs.python.org/3/library/venv.html .. _`ivy/scripts/shell`: https://github.com/unifyai/ivy/tree/f71a414417646e1dfecb5de27fb555f80333932c/scripts/shell .. _`platform compatibility tags`: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags/ .. _`logging level`: https://docs.python.org/3/library/logging.html#logging.Logger.setLevel -.. _`pycharm channel`: https://discord.com/channels/799879767196958751/942114831039856730 -.. _`pre-commit channel`: https://discord.com/channels/799879767196958751/982725464110034944 -.. _`pip packages channel`: https://discord.com/channels/799879767196958751/942114789642080317 -.. _`ivy tests channel`: https://discord.com/channels/799879767196958751/982738436383445073 -.. _`ivy frontend tests channel`: https://discord.com/channels/799879767196958751/1028267758028337193 +.. _`pycharm thread`: https://discord.com/channels/799879767196958751/1186628916522262629 +.. _`pre-commit thread`: https://discord.com/channels/799879767196958751/1186629635694399539 +.. _`pip packages thread`: https://discord.com/channels/799879767196958751/1186629837515935765 +.. _`ivy tests thread`: https://discord.com/channels/799879767196958751/1189907526226034698 +.. _`ivy frontend tests thread`: https://discord.com/channels/799879767196958751/1190246804940402738 We're really happy you'd like to learn how to contribute towards Ivy 🙂 @@ -307,4 +307,4 @@ This section aims to assist you in navigating through some common errors you mig Where to ask for Help ********************* -The best place to ask for help is our `discord`_ server in the relevant channels. For instance, lets say you're facing an issue with :code:`test_jax_transpose` function, in this case you should post your query in the `ivy frontend tests channel`_. +The best place to ask for help is our `discord`_ server in the relevant channels. For instance, lets say you're facing an issue with :code:`test_jax_transpose` function, in this case you should post your query in the `ivy frontend tests thread`_. diff --git a/docs/overview/deep_dive/formatting.rst b/docs/overview/deep_dive/formatting.rst index f970f8e0c24d2..9cb5d4b15cbf4 100644 --- a/docs/overview/deep_dive/formatting.rst +++ b/docs/overview/deep_dive/formatting.rst @@ -3,7 +3,7 @@ Formatting .. _`flake8`: https://flake8.pycqa.org/en/latest/index.html .. _`black`: https://black.readthedocs.io/en/stable/index.html -.. _`formatting channel`: https://discord.com/channels/799879767196958751/1028266706436624456 +.. _`formatting thread`: https://discord.com/channels/799879767196958751/1190247322626572408 .. _`discord`: https://discord.gg/sXyFF8tDtm Currently, Ivy follows the `black`_ code style, and `flake8`_ formatter in order to ensure that our code is consistent, @@ -192,7 +192,7 @@ another try, or manually resolve the formatting errors by committing the changes This should have hopefully given you a good feel for what is our coding style and how to format your code to contribute to Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `formatting channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `formatting thread`_! **Video** diff --git a/docs/overview/deep_dive/function_arguments.rst b/docs/overview/deep_dive/function_arguments.rst index 988db211600ec..60888fdb0335e 100644 --- a/docs/overview/deep_dive/function_arguments.rst +++ b/docs/overview/deep_dive/function_arguments.rst @@ -5,7 +5,7 @@ Function Arguments .. _`spec/API_specification/signatures`: https://github.com/data-apis/array-api/tree/main/spec/2022.12/API_specification .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`function arguments channel`: https://discord.com/channels/799879767196958751/982738240354254898 +.. _`function arguments thread`: https://discord.com/channels/799879767196958751/1190247823275470978 .. _`Array API Standard convention`: https://data-apis.org/array-api/2021.12/API_specification/array_object.html#api-specification-array-object--page-root Here, we explain how the function arguments differ between the placeholder implementation at :mod:`ivy/functional/ivy/category_name.py`, and the backend-specific implementation at :mod:`ivy/functional/backends/backend_name/category_name.py`. @@ -210,7 +210,7 @@ Therefore, we simply omit these :class:`ivy.Container` type hints from *nestable These examples should hopefully give you a good understanding of what is required when adding function arguments. -If you have any questions, please feel free to reach out on `discord`_ in the `function arguments channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `function arguments thread`_! **Video** diff --git a/docs/overview/deep_dive/function_types.rst b/docs/overview/deep_dive/function_types.rst index d2bc16af271f8..c00d2839c73b5 100644 --- a/docs/overview/deep_dive/function_types.rst +++ b/docs/overview/deep_dive/function_types.rst @@ -33,7 +33,7 @@ Function Types .. _`handle`: https://github.com/unifyai/ivy/blob/0ef2888cbabeaa8f61ce8aaea4f1175071f7c396/ivy/func_wrapper.py#L1027-L1030 .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`function types channel`: https://discord.com/channels/799879767196958751/982737839861145630 +.. _`function types thread`: https://discord.com/channels/799879767196958751/1189905318650576896 Firstly, we explain the difference between *primary*, *compositional*, *mixed* and *standalone* functions. These four function categorizations are all **mutually exclusive**, and combined they constitute the set of **all** functions in Ivy, as outlined in the simple Venn diagram below. @@ -249,7 +249,7 @@ Feel free to have a look through all of the `submodules`_, you should be able to This should have hopefully given you a good feel for the different function types. -If you have any questions, please feel free to reach out on `discord`_ in the `function types channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `function types thread`_! **Video** diff --git a/docs/overview/deep_dive/function_wrapping.rst b/docs/overview/deep_dive/function_wrapping.rst index 8a585244222e6..5cee12cd1a25d 100644 --- a/docs/overview/deep_dive/function_wrapping.rst +++ b/docs/overview/deep_dive/function_wrapping.rst @@ -24,7 +24,7 @@ Function Wrapping .. _`handle_complex_input`: https://github.com/unifyai/ivy/blob/bd9b5b1080d33004e821a48c486b3a879b9d6616/ivy/func_wrapper.py#L1393 .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`function wrapping channel`: https://discord.com/channels/799879767196958751/982737993028755496 +.. _`function wrapping thread`: https://discord.com/channels/799879767196958751/1189906704775794688 .. _`handle_partial_mixed_function`: https://github.com/unifyai/ivy/blob/5658401b266352d3bf72c95e4af6ae9233115722/ivy/func_wrapper.py#L944 .. _`stored as an attribute`: https://github.com/unifyai/ivy/blob/5658401b266352d3bf72c95e4af6ae9233115722/ivy/func_wrapper.py#L1054 .. _`ivy.linear`: https://github.com/unifyai/ivy/blob/5658401b266352d3bf72c95e4af6ae9233115722/ivy/functional/ivy/layers.py#L81 @@ -151,7 +151,7 @@ For now, suffice it to say that they do quite a lot. This should have hopefully given you a good feel for how function wrapping is applied to functions in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `function wrapping channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `function wrapping thread`_! **Video** diff --git a/docs/overview/deep_dive/gradients.rst b/docs/overview/deep_dive/gradients.rst index bd502228f5031..2ae91e75aedf1 100644 --- a/docs/overview/deep_dive/gradients.rst +++ b/docs/overview/deep_dive/gradients.rst @@ -2,7 +2,7 @@ Gradients ========= .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`gradients channel`: https://discord.com/channels/799879767196958751/1000043921633722509 +.. _`gradients thread`: https://discord.com/channels/799879767196958751/1190235826806853672 Overview -------- @@ -172,7 +172,7 @@ Framework-specific Considerations This should have hopefully given you a good feel for how the gradient API is implemented in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `gradients channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `gradients thread`_! **Video** diff --git a/docs/overview/deep_dive/inplace_updates.rst b/docs/overview/deep_dive/inplace_updates.rst index a2a4019a8e106..17bfa0aca2c7b 100644 --- a/docs/overview/deep_dive/inplace_updates.rst +++ b/docs/overview/deep_dive/inplace_updates.rst @@ -18,7 +18,7 @@ Inplace Updates .. _`ivy.asarray`: https://github.com/unifyai/ivy/blob/8482eb3fcadd0721f339a1a55c3f3b9f5c86d8ba/ivy/functional/ivy/creation.py#L114 .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`inplace updates channel`: https://discord.com/channels/799879767196958751/1028681763947552778 +.. _`inplace updates thread`: https://discord.com/channels/799879767196958751/1189906590166437938 .. _`example`: https://github.com/unifyai/ivy/blob/0ef2888cbabeaa8f61ce8aaea4f1175071f7c396/ivy/functional/ivy/layers.py#L169-L176 @@ -511,7 +511,7 @@ Here's a brief description of what happens during an inplace operation with a Py This should have hopefully given you a good feel for inplace updates, and how these are handled in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `inplace updates channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `inplace updates thread`_! **Video** diff --git a/docs/overview/deep_dive/ivy_frontends.rst b/docs/overview/deep_dive/ivy_frontends.rst index ac7f1aab1ea14..c13c69169ae62 100644 --- a/docs/overview/deep_dive/ivy_frontends.rst +++ b/docs/overview/deep_dive/ivy_frontends.rst @@ -16,7 +16,7 @@ Ivy Frontends .. _`torch.tan`: https://pytorch.org/docs/stable/generated/torch.tan.html#torch.tan .. _`YouTube tutorial series`: https://www.youtube.com/watch?v=72kBVJTpzIw&list=PLwNuX3xB_tv-wTpVDMSJr7XW6IP_qZH0t .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`ivy frontends channel`: https://discord.com/channels/799879767196958751/998782045494976522 +.. _`ivy frontends thread`: https://discord.com/channels/799879767196958751/1189908295041941514 .. _`Array manipulation routines`: https://numpy.org/doc/stable/reference/routines.array-manipulation.html# .. _`Array creation routines`: https://numpy.org/doc/stable/reference/routines.array-creation.html @@ -676,7 +676,7 @@ Unit tests should be written for all aliases. This is arguably a duplication, bu This should hopefully have given you a better grasp on what the Ivy Frontend APIs are for, how they should be implemented, and the things to watch out for! We also have a short `YouTube tutorial series`_ on this as well if you prefer a video explanation! -If you have any questions, please feel free to reach out on `discord`_ in the `ivy frontends channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `ivy frontends thread`_! **Video** diff --git a/docs/overview/deep_dive/ivy_frontends_tests.rst b/docs/overview/deep_dive/ivy_frontends_tests.rst index 6cdad3a87772d..aacc3c6eefe42 100644 --- a/docs/overview/deep_dive/ivy_frontends_tests.rst +++ b/docs/overview/deep_dive/ivy_frontends_tests.rst @@ -2,7 +2,7 @@ Ivy Frontend Tests ================== .. _`here`: ../design/ivy_as_a_transpiler.rst -.. _`ivy frontends tests channel`: https://discord.com/channels/799879767196958751/1028267758028337193 +.. _`ivy frontends tests thread`: https://discord.com/channels/799879767196958751/1190246804940402738 .. _`test ivy`: https://github.com/unifyai/ivy/tree/db9a22d96efd3820fb289e9997eb41dda6570868/ivy_tests/test_ivy .. _`test_frontend_function`: https://github.com/unifyai/ivy/blob/591ac37a664ebdf2ca50a5b0751a3a54ee9d5934/ivy_tests/test_ivy/helpers.py#L1047 .. _`discord`: https://discord.gg/sXyFF8tDtm @@ -816,7 +816,7 @@ The configuration files are located at: :code:`ivy_tests/test_ivy/test_frontends This should have hopefully given you a good understanding of Ivy Frontend Tests! -If you have any questions, please feel free to reach out on `discord`_ in the `ivy frontends tests channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `ivy frontends tests thread`_! **Video** diff --git a/docs/overview/deep_dive/ivy_lint.rst b/docs/overview/deep_dive/ivy_lint.rst index a777f110a7470..1ac74dbd30979 100644 --- a/docs/overview/deep_dive/ivy_lint.rst +++ b/docs/overview/deep_dive/ivy_lint.rst @@ -55,4 +55,4 @@ Round Up ``ivy-lint`` stands as a testament to Ivy's commitment to code clarity and uniformity. As the landscape of our needs shifts, we foresee further refining and expanding our suite of formatters. -For all discussions or inquiries, you're always welcome on `discord `_ in the `formatting channel `_. +For all discussions or inquiries, you're always welcome on `discord `_ in the `formatting thread `_. diff --git a/docs/overview/deep_dive/ivy_tests.rst b/docs/overview/deep_dive/ivy_tests.rst index be78008687a57..673f7e8dee994 100644 --- a/docs/overview/deep_dive/ivy_tests.rst +++ b/docs/overview/deep_dive/ivy_tests.rst @@ -47,7 +47,7 @@ Ivy Tests .. _`artifact`: https://docs.github.com/en/actions/using-workflows/storing-workflow-data-as-artifacts .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`ivy tests channel`: https://discord.com/channels/799879767196958751/982738436383445073 +.. _`ivy tests thread`: https://discord.com/channels/799879767196958751/1189907526226034698 .. _`test helpers`: https://github.com/unifyai/ivy/tree/main/ivy_tests/test_ivy/helpers/hypothesis_helpers .. _`get_dtypes`: https://github.com/unifyai/ivy/blob/e50f71e283313caa9737f3c284496022ac67b58b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py#L60 .. _`dtype_and_values`: https://github.com/unifyai/ivy/blob/e50f71e283313caa9737f3c284496022ac67b58b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py#L83 @@ -895,7 +895,7 @@ This ensures that the given example is always tested while running the test, all This should have hopefully given you a good feel for how the tests are implemented in Ivy. -If you have any questions, please feel free to reach out on `discord`_ in the `ivy tests channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `ivy tests thread`_! **Video** diff --git a/docs/overview/deep_dive/navigating_the_code.rst b/docs/overview/deep_dive/navigating_the_code.rst index f70b51aac7c33..0bdb82f9418c0 100644 --- a/docs/overview/deep_dive/navigating_the_code.rst +++ b/docs/overview/deep_dive/navigating_the_code.rst @@ -4,7 +4,7 @@ Navigating the Code .. _`Array API Standard`: https://data-apis.org/array-api/latest/ .. _`repo`: https://github.com/unifyai/ivy .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`navigating the code channel`: https://discord.com/channels/799879767196958751/982737793476345888 +.. _`navigating the code thread`: https://discord.com/channels/799879767196958751/1189905165373935616 .. _`Array API Standard convention`: https://data-apis.org/array-api/2021.12/API_specification/array_object.html#api-specification-array-object--page-root .. _`flake8`: https://flake8.pycqa.org/en/latest/index.html @@ -299,7 +299,7 @@ This helps to prevent our work from culminating over a fixed version while strid This should have hopefully given you a good feel for how to navigate the Ivy codebase. -If you have any questions, please feel free to reach out on `discord`_ in the `navigating the code channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `navigating the code thread`_! **Video** diff --git a/docs/overview/deep_dive/superset_behaviour.rst b/docs/overview/deep_dive/superset_behaviour.rst index 6ccccad5696f6..d2e9e940cdc44 100644 --- a/docs/overview/deep_dive/superset_behaviour.rst +++ b/docs/overview/deep_dive/superset_behaviour.rst @@ -3,7 +3,7 @@ Superset Behaviour .. _`Array API Standard`: https://data-apis.org/array-api/latest/ .. _`discord`: https://discord.gg/sXyFF8tDtm -.. _`superset behavior channel`: https://discord.com/channels/799879767196958751/1018954266322419732 +.. _`superset behavior thread`: https://discord.com/channels/799879767196958751/1189905520686014514 .. _`partial_mixed_handler`: https://github.com/unifyai/ivy/blob/a07919ebf64181852a3564c4d994bc1c25bd9a6f/ivy/functional/backends/tensorflow/experimental/layers.py#L817 .. _`handle_partial_mixed_function`: https://github.com/unifyai/ivy/blob/a07919ebf64181852a3564c4d994bc1c25bd9a6f/ivy/func_wrapper.py#L981 @@ -266,7 +266,7 @@ This should have hopefully given you a good feel of what should and should not b In many cases, there is not a clear right and wrong answer, and we arrive at the final decision via open discussion. If you find yourself proposing the addition of a new function in Ivy, then we will most likely have this discussion on your Pull Request! -If you have any questions, please feel free to reach out on `discord`_ in the `superset behavior channel`_! +If you have any questions, please feel free to reach out on `discord`_ in the `superset behavior thread`_! **Video** From 0e41f1161f43e5388cfbfb4d66e82b2251151124 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 29 Dec 2023 12:35:36 +0000 Subject: [PATCH 447/978] fix: set seed in fit and predict methods of sklearn decision tree classifier to avoid some value mismatches --- ivy/functional/frontends/sklearn/tree/_classes.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/frontends/sklearn/tree/_classes.py b/ivy/functional/frontends/sklearn/tree/_classes.py index acc2702bd8c64..6cfbe791630ef 100644 --- a/ivy/functional/frontends/sklearn/tree/_classes.py +++ b/ivy/functional/frontends/sklearn/tree/_classes.py @@ -57,6 +57,7 @@ def _fit( check_input=True, missing_values_in_feature_mask=None, ): + ivy.seed(seed_value=self.random_state) n_samples, self.n_features_in_ = X.shape y = ivy.atleast_1d(y) if y.ndim == 1: @@ -146,6 +147,7 @@ def _prune_tree(self): self.tree_ = pruned_tree def predict(self, X, check_input=True): + ivy.seed(seed_value=self.random_state) proba = self.tree_.predict(X) n_samples = X.shape[0] From 0d3f9df7a62cf5490d5b1bdfefe33932e57b69af Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 29 Dec 2023 15:27:21 +0000 Subject: [PATCH 448/978] fix: fix min in numpy backend as np.amin throws error when `where` is None and still passed as kw --- ivy/functional/backends/numpy/statistical.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/numpy/statistical.py b/ivy/functional/backends/numpy/statistical.py index d4c0f015e7a7d..87f469e19062f 100644 --- a/ivy/functional/backends/numpy/statistical.py +++ b/ivy/functional/backends/numpy/statistical.py @@ -25,11 +25,13 @@ def min( out: Optional[np.ndarray] = None, ) -> np.ndarray: axis = tuple(axis) if isinstance(axis, list) else axis - return np.asarray( - np.amin( + if where is not None: + ret = np.amin( a=x, axis=axis, keepdims=keepdims, initial=initial, where=where, out=out ) - ) + else: + ret = np.amin(a=x, axis=axis, keepdims=keepdims, initial=initial, out=out) + return np.asarray(ret) min.support_native_out = True From 285807144916b397015d78f8b3b7325639bd1619 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 09:54:54 +0000 Subject: [PATCH 449/978] fix(frontend): fix dtype mismatches in test_torch_round by ensuring input dtype is preserved --- ivy/functional/frontends/torch/pointwise_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py index 33e7e15db2ba9..e2414108b8c4a 100644 --- a/ivy/functional/frontends/torch/pointwise_ops.py +++ b/ivy/functional/frontends/torch/pointwise_ops.py @@ -463,7 +463,7 @@ def remainder(input, other, *, out=None): @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def round(input, *, decimals=0, out=None): - m = ivy.full(input.shape, 10.0**decimals) + m = ivy.full(input.shape, 10.0**decimals, dtype=input.dtype) upscale = ivy.multiply(input, m) rounded = ivy.round(upscale) return ivy.divide(rounded, m, out=out) From 372cd185bbc45cd5fa409c6297b276758d5bf2be Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 10:05:48 +0000 Subject: [PATCH 450/978] fix: specify float16 as unsupported for abs in paddle to fix test_torch_frac. paddle error: The kernel with key (CPU, NCHW, float16) of kernel is not registered --- ivy/functional/backends/paddle/elementwise.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 01103f05fa2a3..600f6800a44f4 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -841,6 +841,9 @@ def trapz( return ret +@with_unsupported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version +) def abs( x: Union[float, paddle.Tensor], /, From 6f174d43f440aad738d25e59551b5a9b622a5571 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 10:24:33 +0000 Subject: [PATCH 451/978] fix(frontend): specify complex types as unsupported to fix test_torch_maximum --- ivy/functional/frontends/torch/comparison_ops.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index fc7591d156487..5c0cf667ce511 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -255,6 +255,7 @@ def less_equal(input, other, *, out=None): return ivy.less_equal(input, other, out=out) +@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def maximum(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) From d51a853ce72d0bfcf45dcbdd037e5b4af2ef2fb1 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 10:32:03 +0000 Subject: [PATCH 452/978] fix(frontend): specify unsupported complex in line with torch.isin which also doesn't support complex with fix for test_torch_isin --- ivy/functional/frontends/torch/comparison_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 5c0cf667ce511..71b251f224aea 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -142,7 +142,7 @@ def isfinite(input): return ivy.isfinite(input) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16", "complex")}, "torch") @to_ivy_arrays_and_back def isin(elements, test_elements, *, assume_unique=False, invert=False): input_elements_copy = ivy.reshape(ivy.to_ivy(elements), (-1,)) From bd5618975484df2a70f277469b02228f9574aec3 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 10:33:04 +0000 Subject: [PATCH 453/978] fix: specify complex unsupported for minimum in torch front --- ivy/functional/frontends/torch/comparison_ops.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 71b251f224aea..21c5e34106b6f 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -262,6 +262,7 @@ def maximum(input, other, *, out=None): return ivy.maximum(input, other, out=out) +@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def minimum(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) From a1616e48e283212e60158119cbaee97d9694c44f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 10:35:00 +0000 Subject: [PATCH 454/978] test: update tests for several comparison ops to include all valid types --- .../test_frontends/test_torch/test_comparison_ops.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_comparison_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_comparison_ops.py index 9d1a64830280c..0227a3aa47a96 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_comparison_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_comparison_ops.py @@ -368,7 +368,7 @@ def test_torch_isfinite( @handle_frontend_test( fn_tree="torch.isin", dtype_and_inputs=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True, ), @@ -658,7 +658,7 @@ def test_torch_less_equal( @handle_frontend_test( fn_tree="torch.maximum", dtype_and_inputs=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True, ), @@ -688,7 +688,7 @@ def test_torch_maximum( @handle_frontend_test( fn_tree="torch.minimum", dtype_and_inputs=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True, ), From 79fca7d1fff54202189273b94e2099012efa02ba Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 30 Dec 2023 10:36:39 +0000 Subject: [PATCH 455/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/frontends/torch/comparison_ops.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 21c5e34106b6f..719317c801f3a 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -142,7 +142,9 @@ def isfinite(input): return ivy.isfinite(input) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16", "complex")}, "torch") +@with_unsupported_dtypes( + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, "torch" +) @to_ivy_arrays_and_back def isin(elements, test_elements, *, assume_unique=False, invert=False): input_elements_copy = ivy.reshape(ivy.to_ivy(elements), (-1,)) From 7673380b8fed8763fcbcd47ea07d4c2afd593c60 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 10:39:54 +0000 Subject: [PATCH 456/978] fix: specify bool as unsupported type for isin in torch front --- ivy/functional/frontends/torch/comparison_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 719317c801f3a..53962d82e1ffc 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -143,7 +143,7 @@ def isfinite(input): @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, "torch" + {"2.1.2 and below": ("float16", "bfloat16", "complex", "bool")}, "torch" ) @to_ivy_arrays_and_back def isin(elements, test_elements, *, assume_unique=False, invert=False): From ce1c97101beab36acdadb0e9f69713c0cece238f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 11:59:17 +0000 Subject: [PATCH 457/978] fix: specify complex as unsupported for sort and msort in torch frontend --- ivy/functional/frontends/torch/comparison_ops.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 53962d82e1ffc..2a178c80a9520 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -271,6 +271,7 @@ def minimum(input, other, *, out=None): return ivy.minimum(input, other, out=out) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def msort(input, *, out=None): return ivy.sort(input, axis=0, out=out) @@ -283,6 +284,7 @@ def not_equal(input, other, *, out=None): return ivy.not_equal(input, other, out=out) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back # TODO: the original torch.sort places * right before `out` def sort(input, *, dim=-1, descending=False, stable=False, out=None): From 2c833055ad2b2425e17f9c2139b6389eef755649 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 12:00:25 +0000 Subject: [PATCH 458/978] fix: specify complex as unsupported for argsort in torch frontend --- ivy/functional/frontends/torch/comparison_ops.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 2a178c80a9520..157165338ab1b 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -59,6 +59,7 @@ def allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False): return ivy.all(ret) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def argsort(input, dim=-1, descending=False): return ivy.argsort(input, axis=dim, descending=descending) From 515200e576f80316d182335a23e4e4df6ed47054 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 12:07:28 +0000 Subject: [PATCH 459/978] fix: specify complex as unsupported for isposinf and isneginf in torch front --- ivy/functional/frontends/torch/comparison_ops.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 157165338ab1b..7ed083f88b1fe 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -199,6 +199,7 @@ def isnan(input): return ivy.isnan(input) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def isneginf(input, *, out=None): is_inf = ivy.isinf(input) @@ -206,6 +207,7 @@ def isneginf(input, *, out=None): return ivy.logical_and(is_inf, neg_sign_bit, out=out) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def isposinf(input, *, out=None): is_inf = ivy.isinf(input) From b0cb95d1e703a87afe5451bd63a4f9b978a7a766 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 30 Dec 2023 12:18:48 +0000 Subject: [PATCH 460/978] test: generate max_depth parameter and test values using helper assert function in test_sklearn_predict --- .../test_frontends/test_sklearn/test_tree/test_tree.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py index 8bb3c7353c26d..5c14291a9c557 100644 --- a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py +++ b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py @@ -1,5 +1,4 @@ from ivy.functional.frontends.sklearn.tree import DecisionTreeClassifier as ivy_DTC -import numpy as np import ivy from hypothesis import given import ivy_tests.test_ivy.helpers as helpers @@ -28,13 +27,14 @@ def _get_sklearn_predict(X, y, max_depth, DecisionTreeClassifier): y=helpers.array_values( shape=(5,), dtype=helpers.get_dtypes("signed_integer", prune_function=False) ), + max_depth=helpers.ints(max_value=5, min_value=1), ) -def test_sklearn_tree_predict(X, y): +def test_sklearn_tree_predict(X, y, max_depth): try: from sklearn.tree import DecisionTreeClassifier as sklearn_DTC except ImportError: print("sklearn not installed, skipping test_sklearn_tree_predict") return - sklearn_pred = _get_sklearn_predict(X, y, 3, sklearn_DTC)(X) - ivy_pred = _get_sklearn_predict(ivy.array(X), ivy.array(y), 3, ivy_DTC)(X) - assert np.allclose(ivy_pred.to_numpy(), sklearn_pred) + sklearn_pred = _get_sklearn_predict(X, y, max_depth, sklearn_DTC)(X) + ivy_pred = _get_sklearn_predict(ivy.array(X), ivy.array(y), max_depth, ivy_DTC)(X) + helpers.assert_same_type_and_shape([sklearn_pred, ivy_pred]) From f9aa17fcb4319927ea568e8fbf2ba8bc910b41d5 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 31 Dec 2023 21:29:53 +0000 Subject: [PATCH 461/978] test:generalize test_aminmax dtypes to valid and update function unsupported types of bool for min and max in tf backend and complex for aminmax in torch frontend --- ivy/functional/backends/tensorflow/statistical.py | 3 ++- ivy/functional/frontends/torch/reduction_ops.py | 4 +++- .../test_ivy/test_frontends/test_torch/test_reduction_ops.py | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/tensorflow/statistical.py b/ivy/functional/backends/tensorflow/statistical.py index 54c8ad1bcf251..7f8a539eb2500 100644 --- a/ivy/functional/backends/tensorflow/statistical.py +++ b/ivy/functional/backends/tensorflow/statistical.py @@ -12,7 +12,7 @@ # -------------------# -@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def min( x: Union[tf.Tensor, tf.Variable], /, @@ -37,6 +37,7 @@ def min( return result +@with_unsupported_dtypes({"2.15.0 and below": ("bool",)}, backend_version) def max( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index c40bb033b9824..35a294b0df27d 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -32,7 +32,9 @@ def amin(input, dim=None, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes( + {"2.1.2 and below": ("float16", "bfloat16", "complex")}, "torch" +) def aminmax(input, *, dim=None, keepdim=False, out=None): minmax_tuple = namedtuple("minmax", ["min", "max"]) return minmax_tuple( diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index 9d3f52db9a672..36b734e306b4b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -174,7 +174,7 @@ def test_torch_amin( @handle_frontend_test( fn_tree="torch.aminmax", dtype_input_axis=helpers.dtype_values_axis( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), min_num_dims=1, min_axis=-1, max_axis=0, From 1ac59c7e0d5c8ec1494a0e4811798b4650c387d5 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 31 Dec 2023 21:35:41 +0000 Subject: [PATCH 462/978] test: run test_torch_amax and amin for all `valid` types and specify `complex` as unsupported --- ivy/functional/frontends/torch/reduction_ops.py | 2 ++ .../test_ivy/test_frontends/test_torch/test_reduction_ops.py | 4 ++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 35a294b0df27d..ed2d14306b79c 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -18,12 +18,14 @@ def all(input, dim=None, keepdim=False, *, out=None): return ret +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def amax(input, dim=None, keepdim=False, *, out=None): return ivy.max(input, axis=dim, keepdims=keepdim, out=out) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def amin(input, dim=None, keepdim=False, *, out=None): diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index 36b734e306b4b..080bf5f526f82 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -106,7 +106,7 @@ def test_torch_all( @handle_frontend_test( fn_tree="torch.amax", dtype_input_axis=helpers.dtype_values_axis( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), min_num_dims=1, min_axis=-1, max_axis=0, @@ -140,7 +140,7 @@ def test_torch_amax( @handle_frontend_test( fn_tree="torch.amin", dtype_input_axis=helpers.dtype_values_axis( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), min_num_dims=1, min_axis=-1, max_axis=0, From 9aa3c22b54b872b5e8e156b386e8b7dd0d1b1779 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 31 Dec 2023 21:39:41 +0000 Subject: [PATCH 463/978] test: fix value unpacking issue in test_torch_mean --- .../test_ivy/test_frontends/test_torch/test_reduction_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index 080bf5f526f82..98a7a4a808d0a 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -476,7 +476,7 @@ def test_torch_mean( test_flags, backend_fw, ): - input_dtype, x, axis = dtype_and_x + input_dtype, x, axis, *_ = dtype_and_x helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, From 0ec22413a9b13dbd4331c274839e79084d772409 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 1 Jan 2024 03:18:28 +0530 Subject: [PATCH 464/978] fix: fixed the failing jax backend test in ivy log (#27819) Co-authored-by: NripeshN --- ivy/functional/backends/tensorflow/elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index ff46eefbf34ed..ac832299752ae 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -431,6 +431,7 @@ def less_equal( return tf.math.less_equal(x1, x2) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def log( x: Union[tf.Tensor, tf.Variable], /, From 980f9c6e89906abee8ea5e5fad77deb4be4468e1 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 1 Jan 2024 03:19:07 +0530 Subject: [PATCH 465/978] fix: fixed tanh paddle backend failing test (#27817) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/elementwise.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 600f6800a44f4..563ff86695c00 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -619,7 +619,7 @@ def not_equal( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float32", "float64", "complex")}}, + {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def tanh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: From 4e2905cb95efe5d491c729ec9d3b844127052e97 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 1 Jan 2024 03:19:43 +0530 Subject: [PATCH 466/978] fix: fix failing test case at jax backend (#27815) Co-authored-by: NripeshN --- ivy/functional/backends/jax/activations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/activations.py b/ivy/functional/backends/jax/activations.py index 08f4f42c88ebf..cdb9340436cf6 100644 --- a/ivy/functional/backends/jax/activations.py +++ b/ivy/functional/backends/jax/activations.py @@ -37,7 +37,7 @@ def leaky_relu( def relu( x: JaxArray, /, *, complex_mode="jax", out: Optional[JaxArray] = None ) -> JaxArray: - return jnp.maximum(x, 0) + return jax.nn.relu(x) def sigmoid( From e711cf725cb9f80f0f65e77a74fbc619c592af18 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 31 Dec 2023 21:54:44 +0000 Subject: [PATCH 467/978] test: run test_torch_median for all `valid` types and specify unsupported types of half, complex and bool Test passing. --- ivy/functional/frontends/torch/reduction_ops.py | 1 + .../test_ivy/test_frontends/test_torch/test_reduction_ops.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index ed2d14306b79c..8b686a7ac2184 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -131,6 +131,7 @@ def mean(input, dim=None, keepdim=False, *, dtype=None, out=None): return ivy.mean(input, axis=dim, keepdims=keepdim, out=out) +@with_unsupported_dtypes({"2.1.2 and below": ("complex", "float16", "bool")}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def median(input, dim=None, keepdim=False, *, out=None): diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index 98a7a4a808d0a..6bfb34e818547 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -495,7 +495,7 @@ def test_torch_mean( @handle_frontend_test( fn_tree="torch.median", dtype_input_axis=helpers.dtype_values_axis( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), min_num_dims=1, valid_axis=True, force_int_axis=True, From 40b95ae30270407fc2fb82ef216612d8f4465c10 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 1 Jan 2024 08:57:58 +0000 Subject: [PATCH 468/978] test: update the arrays safety scale in `test_sklearn_tree_predict` to be log and ensure random state is passed through the helper function to the DecisionTreeClassifier class Test passing. --- .../test_frontends/test_sklearn/test_tree/test_tree.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py index 5c14291a9c557..350d6d208e671 100644 --- a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py +++ b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_tree/test_tree.py @@ -10,7 +10,7 @@ # helper functions def _get_sklearn_predict(X, y, max_depth, DecisionTreeClassifier): - clf = DecisionTreeClassifier(max_depth=max_depth) + clf = DecisionTreeClassifier(max_depth=max_depth, random_state=0) clf.fit(X, y) return clf.predict @@ -22,10 +22,14 @@ def _get_sklearn_predict(X, y, max_depth, DecisionTreeClassifier): # todo: integrate with already existing strats and generalize @given( X=helpers.array_values( - shape=(5, 2), dtype=helpers.get_dtypes("float", prune_function=False) + shape=(5, 2), + dtype=helpers.get_dtypes("float", prune_function=False), + safety_factor_scale="log", ), y=helpers.array_values( - shape=(5,), dtype=helpers.get_dtypes("signed_integer", prune_function=False) + shape=(5,), + dtype=helpers.get_dtypes("signed_integer", prune_function=False), + safety_factor_scale="log", ), max_depth=helpers.ints(max_value=5, min_value=1), ) From a5aea35de889e5115a7f606a402a5612be33b118 Mon Sep 17 00:00:00 2001 From: akshatvishu <33392262+akshatvishu@users.noreply.github.com> Date: Mon, 1 Jan 2024 23:29:46 +0530 Subject: [PATCH 469/978] feat(losses): add hinge_embedding_loss to ivy experimental API. (#27048) Co-authored-by: ivy-branch --- ivy/data_classes/array/experimental/losses.py | 81 ++++++++ .../container/experimental/losses.py | 183 ++++++++++++++++++ .../backends/jax/experimental/losses.py | 33 +++- .../backends/numpy/experimental/losses.py | 37 +++- .../backends/paddle/experimental/losses.py | 24 +++ .../tensorflow/experimental/losses.py | 33 +++- .../backends/torch/experimental/losses.py | 21 ++ ivy/functional/ivy/experimental/losses.py | 89 +++++++++ .../test_experimental/test_nn/test_losses.py | 94 +++++++++ 9 files changed, 581 insertions(+), 14 deletions(-) diff --git a/ivy/data_classes/array/experimental/losses.py b/ivy/data_classes/array/experimental/losses.py index f676338c11c89..e06132caf1638 100644 --- a/ivy/data_classes/array/experimental/losses.py +++ b/ivy/data_classes/array/experimental/losses.py @@ -365,3 +365,84 @@ def poisson_nll_loss( eps=eps, reduction=reduction, ) + + def hinge_embedding_loss( + self: Union[ivy.Array, ivy.NativeArray], + target: Union[ivy.Array, ivy.NativeArray], + *, + margin: float = 1.0, + reduction: str = "mean", + ) -> ivy.Array: + r"""Measures loss from input `x` and label `y` with values 1 or -1. It + evaluates if two inputs are similar or not, often used for embedding or + semi-supervised learning. + + Loss for the `n`-th sample: + .. math:: + l_n = \begin{cases} + x_n, & \text{if}\; y_n = 1,\\ + \max \{0, margin - x_n\}, & \text{if}\; y_n = -1, + \end{cases} + + Total loss: + .. math:: + \ell(x, y) = \begin{cases} + \operatorname{mean}(L), & \text{if reduction} = \text{`mean';}\\ + \operatorname{sum}(L), & \text{if reduction} = \text{`sum'.} + \end{cases} + + where :math:`L = \{l_1,\dots,l_N\}^\top` + + Parameters + ---------- + input + Input tensor with dtype float. + The shape is [N, \*], where N is batch size and `\*` represents + any number of additional dimensions. + label + Label tensor containing 1 or -1 with dtype float32 or float64. + Its shape matches that of the input. + margin + Sets the hyperparameter margin. Determines the necessary input size + for hinge_embedding_loss calculations when label is -1. Inputs smaller + than the margin are minimized with hinge_embedding_loss. + Default is 1.0. + reduction + Specifies how to aggregate the loss across the batch. Options are: + - ``'none'``: Returns the unreduced loss. + - ``'mean'``: Returns the mean loss. + - ``'sum'``: Returns the summed loss. + Default is ``'mean'``. + + Shape + ----- + - Input: :math:`(*)` where :math:`*` means, any number of dimensions. \ + The sum operation operates over all the elements. + - Target: :math:`(*)`, same shape as the input + - Output: scalar. If :attr:`reduction` is ``'none'``, + then same shape as the input + + Returns + ------- + ret + Hinge embedding loss calculated from the input and label, + shaped based on the reduction method. + + Examples + -------- + >>> input_tensor = ivy.array([1, 2, 3, 4], dtype=ivy.float64) + >>> target_tensor = ivy.array([1, 1, 1, 1], dtype=ivy.float64) + >>> input_tensor.hinge_embedding_loss(target_tensor,reduction="sum") + ivy.array(10.) + + >>> input_tensor = ivy.array([1, 2, 3], dtype=ivy.float64) + >>> target_tensor = ivy.array([1, -1, -1], dtype=ivy.float64) + >>> input_tensor.hinge_embedding_loss(target_tensor, margin=2.0) + ivy.array(0.33333333) + """ + return ivy.hinge_embedding_loss( + self._data, + target, + margin=margin, + reduction=reduction, + ) diff --git a/ivy/data_classes/container/experimental/losses.py b/ivy/data_classes/container/experimental/losses.py index 799c44adfcb25..26fc89086aadc 100644 --- a/ivy/data_classes/container/experimental/losses.py +++ b/ivy/data_classes/container/experimental/losses.py @@ -1089,3 +1089,186 @@ def poisson_nll_loss( prune_unapplied=prune_unapplied, map_sequences=map_sequences, ) + + @staticmethod + def _static_hinge_embedding_loss( + input: Union[ivy.Container, ivy.Array, ivy.NativeArray], + target: Union[ivy.Container, ivy.Array, ivy.NativeArray], + *, + margin: [Union[float, ivy.Container]] = 1.0, + reduction: [Union[str, ivy.Container]] = "mean", + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + r"""ivy.Container static method variant of ivy.hinge_embedding_loss. + This method simplywraps the function, and so the docstring for + ivy.hinge_embedding_loss also applies to this method with minimal + changes. + + Parameters + ---------- + input + input array or container containing input labels. + target + input array or container containing the target labels. + margin + Sets the hyperparameter margin. Determines the necessary input size + for hinge_embedding_loss calculations when label is -1. Inputs smaller + than the margin are minimized with hinge_embedding_loss. + Default is 1.0. + reduction + Specifies how to aggregate the loss across the batch. Options are: + - ``'none'``: Returns the unreduced loss. + - ``'mean'``: Returns the mean loss. + - ``'sum'``: Returns the summed loss. + Default is ``'mean'``. + key_chains + The key-chains to apply or not apply the method to. Default is ``None``. + to_apply + If input, the method will be applied to key_chains, otherwise key_chains + will be skipped. Default is ``input``. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + + Shape + ----- + - Input: :math:`(*)` where :math:`*` means, any number of dimensions. \ + The sum operation operates over all the elements. + - Target: :math:`(*)`, same shape as the input + - Output: scalar. If :attr:`reduction` is ``'none'``, + then same shape as the input + + Returns + ------- + ret + Hinge embedding loss calculated from the input and label, + shaped based on the reduction method. + + Examples + -------- + With :class:`ivy.Container` inputs: + + >>> x = ivy.Container(a=ivy.array([[1, 0, 2]], dtype=ivy.float32), + ... b=ivy.array([[-1, 1, 1]], dtype=ivy.float32)) + >>> y = ivy.Container(a=ivy.array([[0.6, 0.2, 0.3]], dtype=ivy.float32), + ... b=ivy.array([[1, 1, 1]], dtype=ivy.float32)) + >>> z = ivy.Container._static_hinge_embedding_loss(x, y, reduction="none") + >>> z + { + a: ivy.array([[0., 0., 0.]]), + b: ivy.array([[-1., 1., 1.]]) + } + + With a mix of :class:`ivy.Array` and :class:`ivy.Container` inputs: + + >>> x = ivy.array([[10, 20, 32]], dtype=ivy.float32) + >>> y = ivy.Container(a=ivy.array([[-1, -1, -1]], dtype=ivy.float32), + ... b=ivy.array([[1, 1, 1]], dtype=ivy.float32)) + >>> z = ivy.Container._static_hinge_embedding_loss(x, y, + ... reduction="sum", margin=2.0) + >>> z + { + a: ivy.array(0.), + b: ivy.array(62.) + } + """ + return ContainerBase.cont_multi_map_in_function( + "hinge_embedding_loss", + input, + target, + margin=margin, + reduction=reduction, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + + def hinge_embedding_loss( + self: Union[ivy.Container, ivy.Array, ivy.NativeArray], + target: Union[ivy.Container, ivy.Array, ivy.NativeArray], + *, + margin: [Union[float, ivy.Container]] = 1.0, + reduction: [Union[str, ivy.Container]] = "mean", + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + r"""ivy.Container instance method variant of ivy.hinge_embedding_loss. + This method simply wraps the function, and so the docstring for + ivy.hinge_embedding_loss also applies to this method with minimal + changes. + + Parameters + ---------- + input + input array or container containing input labels. + target + input array or container containing the target labels. + margin + Sets the hyperparameter margin. Determines the necessary input size + for hinge_embedding_loss calculations when label is -1. Inputs smaller + than the margin are minimized with hinge_embedding_loss. + Default is 1.0. + reduction + Specifies how to aggregate the loss across the batch. Options are: + - ``'none'``: Returns the unreduced loss. + - ``'mean'``: Returns the mean loss. + - ``'sum'``: Returns the summed loss. + Default is ``'mean'``. + key_chains + The key-chains to apply or not apply the method to. Default is ``None``. + to_apply + If input, the method will be applied to key_chains, otherwise key_chains + will be skipped. Default is ``input``. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + + Shape + ----- + - Input: :math:`(*)` where :math:`*` means, any number of dimensions. \ + The sum operation operates over all the elements. + - Target: :math:`(*)`, same shape as the input + - Output: scalar. If :attr:`reduction` is ``'none'``, + then same shape as the input + + Returns + ------- + ret + Hinge embedding loss calculated from the input and label, + shaped based on the reduction method. + + + Examples + -------- + >>> x = ivy.Container(a=ivy.array([[1, 0, 2]], dtype=ivy.float32), + ... b=ivy.array([[3, 2, 1]], dtype=ivy.float32)) + >>> y = ivy.Container(a=ivy.array([[-1, -1, -1]], dtype=ivy.float32), + ... b=ivy.array([[1, 1, 1]], dtype=ivy.float32)) + >>> x.hinge_embedding_loss(y, reduction="none", margin=0.5) + { + a: ivy.array([[0., 0.5, 0.]]), + b: ivy.array([[3., 2., 1.]]) + } + """ + return self._static_hinge_embedding_loss( + self, + target, + margin=margin, + reduction=reduction, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) diff --git a/ivy/functional/backends/jax/experimental/losses.py b/ivy/functional/backends/jax/experimental/losses.py index 24359a26366be..91aa08c222779 100644 --- a/ivy/functional/backends/jax/experimental/losses.py +++ b/ivy/functional/backends/jax/experimental/losses.py @@ -64,11 +64,11 @@ def soft_margin_loss( return loss -def _apply_loss_reduction(loss: JaxArray, reduction: str, axis=None) -> JaxArray: +def _apply_loss_reduction(loss: JaxArray, reduction: str) -> JaxArray: if reduction == "sum": - return jnp.sum(loss, axis=axis) + return jnp.sum(loss) elif reduction == "mean": - return jnp.mean(loss, axis=axis) + return jnp.mean(loss) else: # reduction == "none" return loss @@ -114,7 +114,7 @@ def _validate_poisson_nll_params( @with_supported_device_and_dtypes( { - "0.4.14 and below": { + "0.4.18 and below": { "cpu": ("float16", "float32", "float64"), } }, @@ -153,3 +153,28 @@ def poisson_nll_loss( cond = jnp.logical_and(target_arr >= zeroes, target_arr <= ones) loss = loss + jnp.where(cond, zeroes, striling_approx_term) return _apply_loss_reduction(loss, reduction) + + +@with_supported_device_and_dtypes( + { + "0.4.18 and below": { + "cpu": ("float32", "float64"), + } + }, + backend_version, +) +def hinge_embedding_loss( + input: JaxArray, + target: JaxArray, + *, + margin: float = 1.0, + reduction: str = "mean", +) -> JaxArray: + zero_ = jnp.zeros([1], dtype=input.dtype) + + relu_part = jnp.maximum(margin - input, 0) + + loss = jnp.where(target == 1.0, input, zero_) + jnp.where( + target == -1.0, relu_part, zero_ + ) + return _apply_loss_reduction(loss, reduction) diff --git a/ivy/functional/backends/numpy/experimental/losses.py b/ivy/functional/backends/numpy/experimental/losses.py index 35cc06af9c8c4..873bc604d8a6e 100644 --- a/ivy/functional/backends/numpy/experimental/losses.py +++ b/ivy/functional/backends/numpy/experimental/losses.py @@ -75,15 +75,12 @@ def soft_margin_loss( return loss -def _apply_loss_reduction(loss: np.ndarray, reduction: str, axis, out) -> np.ndarray: +def _apply_loss_reduction(loss: np.ndarray, reduction: str) -> np.ndarray: if reduction == "sum": - return np.sum(loss, axis=axis, out=out) + return np.sum(loss) elif reduction == "mean": - return np.mean(loss, axis=axis, out=out) + return np.mean(loss) else: # reduction == "none" - if out is not None: - out[...] = loss - return out return loss @@ -128,7 +125,7 @@ def _validate_poisson_nll_params( @with_supported_device_and_dtypes( { - "1.25.2 and below": { + "1.26.0 and below": { "cpu": ("float16", "float32", "float64"), } }, @@ -167,3 +164,29 @@ def poisson_nll_loss( cond = np.logical_and(target_arr >= zeroes, target_arr <= ones) loss = loss + np.where(cond, zeroes, striling_approx_term) return _apply_loss_reduction(loss, reduction) + + +@with_supported_device_and_dtypes( + { + "1.26.0 and below": { + "cpu": ("float32", "float64"), + } + }, + backend_version, +) +def hinge_embedding_loss( + input: np.ndarray, + target: np.ndarray, + *, + margin: float = 1.0, + reduction: str = "mean", +) -> np.ndarray: + zero_ = np.zeros([1], dtype=input.dtype) + + relu_part = np.maximum(margin - input, 0) + + loss = np.where(target == 1.0, input, zero_) + np.where( + target == -1.0, relu_part, zero_ + ) + + return _apply_loss_reduction(loss, reduction) diff --git a/ivy/functional/backends/paddle/experimental/losses.py b/ivy/functional/backends/paddle/experimental/losses.py index 7d23b31362e40..ec01230538bae 100644 --- a/ivy/functional/backends/paddle/experimental/losses.py +++ b/ivy/functional/backends/paddle/experimental/losses.py @@ -239,3 +239,27 @@ def poisson_nll_loss( cond = paddle.logical_and(target_arr >= zeroes, target_arr <= ones) loss = loss + paddle.where(cond, zeroes, striling_approx_term) return _apply_loss_reduction(loss, reduction) + + +@with_supported_device_and_dtypes( + { + "2.5.1 and below": { + "cpu": ("float32", "float64"), + "gpu": ("float16", "float32", "float64"), + } + }, + backend_version, +) +def hinge_embedding_loss( + input: paddle.Tensor, + target: paddle.Tensor, + *, + margin: float = 1.0, + reduction: str = "mean", +) -> paddle.Tensor: + return paddle.nn.functional.hinge_embedding_loss( + input, + target, + margin=margin, + reduction=reduction, + ) diff --git a/ivy/functional/backends/tensorflow/experimental/losses.py b/ivy/functional/backends/tensorflow/experimental/losses.py index ecc812b53c085..404e2764b8d61 100644 --- a/ivy/functional/backends/tensorflow/experimental/losses.py +++ b/ivy/functional/backends/tensorflow/experimental/losses.py @@ -68,11 +68,11 @@ def soft_margin_loss( return loss -def _apply_loss_reduction(loss: tf.Tensor, reduction: str, axis) -> tf.Tensor: +def _apply_loss_reduction(loss: tf.Tensor, reduction: str) -> tf.Tensor: if reduction == "sum": - return tf.math.reduce_sum(loss, axis=axis) + return tf.math.reduce_sum(loss) elif reduction == "mean": - return tf.reduce_mean(loss, axis=axis) + return tf.reduce_mean(loss) else: # reduction == "none" return loss @@ -156,3 +156,30 @@ def poisson_nll_loss( cond = tf.math.logical_and(target_tensor >= zeros, target_tensor <= ones) loss = loss + tf.where(cond, zeros, stirling_approx) return _apply_loss_reduction(loss, reduction) + + +@with_supported_device_and_dtypes( + { + "2.14.0 and below": { + "cpu": ("float32", "float64"), + "gpu": ("float32", "float64"), + } + }, + backend_version, +) +def hinge_embedding_loss( + input: tf.Tensor, + target: tf.Tensor, + *, + margin: float = 1.0, + reduction: str = "mean", +) -> tf.Tensor: + zero_ = tf.zeros([1], dtype=input.dtype) + + relu_part = tf.math.maximum(margin - input, 0) + + loss = tf.where(tf.equal(target, 1.0), input, zero_) + tf.where( + tf.equal(target, -1.0), relu_part, zero_ + ) + + return _apply_loss_reduction(loss, reduction) diff --git a/ivy/functional/backends/torch/experimental/losses.py b/ivy/functional/backends/torch/experimental/losses.py index fbd5a899d964e..42a65a78451fe 100644 --- a/ivy/functional/backends/torch/experimental/losses.py +++ b/ivy/functional/backends/torch/experimental/losses.py @@ -152,3 +152,24 @@ def poisson_nll_loss( return torch.nn.functional.poisson_nll_loss( input, target, log_input=log_input, full=full, eps=eps, reduction=reduction ) + + +@with_supported_device_and_dtypes( + { + "2.1.2 and below": { + "cpu": ("float16", "float32", "float64"), + "gpu": ("float16", "float32", "float64"), + } + }, + backend_version, +) +def hinge_embedding_loss( + input: torch.Tensor, + target: torch.Tensor, + *, + margin: float = 1.0, + reduction: str = "mean", +) -> torch.Tensor: + return torch.nn.functional.hinge_embedding_loss( + input, target, margin=margin, reduction=reduction + ) diff --git a/ivy/functional/ivy/experimental/losses.py b/ivy/functional/ivy/experimental/losses.py index 0824093ca069d..394863b5ddc26 100644 --- a/ivy/functional/ivy/experimental/losses.py +++ b/ivy/functional/ivy/experimental/losses.py @@ -571,3 +571,92 @@ def poisson_nll_loss( eps=eps, reduction=reduction, ) + + +@handle_exceptions +@handle_nestable +@handle_array_like_without_promotion +@to_native_arrays_and_back +def hinge_embedding_loss( + input: Union[ivy.Array, ivy.NativeArray], + target: Union[ivy.Array, ivy.NativeArray], + *, + margin: float = 1.0, + reduction: str = "mean", +) -> ivy.Array: + r"""Measures loss from input `x` and label `y` with values 1 or -1. It + evaluates if two inputs are similar or not, often used for embedding or + semi-supervised learning. + + Loss for the `n`-th sample: + .. math:: + l_n = \begin{cases} + x_n, & \text{if}\; y_n = 1,\\ + \max \{0, margin - x_n\}, & \text{if}\; y_n = -1, + \end{cases} + + Total loss: + .. math:: + \ell(x, y) = \begin{cases} + \operatorname{mean}(L), & \text{if reduction} = \text{`mean';}\\ + \operatorname{sum}(L), & \text{if reduction} = \text{`sum'.} + \end{cases} + + where :math:`L = \{l_1,\dots,l_N\}^\top` . + + Parameters + ---------- + input + Input tensor with dtype float. + The shape is [N, \*], where N is batch size and `\*` represents + any number of additional dimensions. + label + Label tensor containing 1 or -1 with dtype float32 or float64. + Its shape matches that of the input. + margin + Sets the hyperparameter margin. Determines the necessary input size + for hinge_embedding_loss calculations when label is -1. Inputs smaller + than the margin are minimized with hinge_embedding_loss. + Default is 1.0. + reduction + Specifies how to aggregate the loss across the batch. Options are: + - ``'none'``: Returns the unreduced loss. + - ``'mean'``: Returns the mean loss. + - ``'sum'``: Returns the summed loss. + Default is ``'mean'``. + + Shape + ----- + - Input: :math:`(*)` where :math:`*` means, any number of dimensions. \ + The sum operation operates over all the elements. + - Target: :math:`(*)`, same shape as the input + - Output: scalar. If :attr:`reduction` is ``'none'``, + then same shape as the input + + Returns + ------- + ret + Hinge embedding loss calculated from the input and label, + shaped based on the reduction method. + + Examples + -------- + >>> input_tensor = ivy.array([1, 2, 3, 4], dtype=ivy.float64) + >>> target_tensor = ivy.array([1, 1, 1, 1], dtype=ivy.float64) + >>> loss = ivy.hinge_embedding_loss(input_tensor, target_tensor, reduction="none") + >>> loss + ivy.array([1., 2., 3., 4.]) + + >>> input_tensor = ivy.array([21, 22], dtype=ivy.float32) + >>> target_tensor = ivy.array([-1, 1], dtype=ivy.float32) + >>> loss = ivy.hinge_embedding_loss(input_tensor,target_tensor, + ... margin=2.0, reduction="sum") + >>> loss + ivy.array(22.) + """ + return ivy.current_backend().hinge_embedding_loss( + input, + target, + margin=margin, + reduction=reduction, + ) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_losses.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_losses.py index 2161ee814304b..8c0028d457e24 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_losses.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_losses.py @@ -7,6 +7,100 @@ from ivy_tests.test_ivy.helpers import handle_test +# --- Helpers --- # +# --------------- # + + +@st.composite +def _hinge_embedding_loss_input( + draw, min_num_dims=1, max_num_dims=5, min_dim_size=1, max_dim_size=10 +): + # determine the shape for both arrays (input and target) + shape = draw( + st.shared( + helpers.get_shape( + min_num_dims=min_num_dims, + max_num_dims=max_num_dims, + min_dim_size=min_dim_size, + max_dim_size=max_dim_size, + ), + key="shared_shape", + ) + ) + + # Generate an array of -1 and 1 with the given shape (target_array) + def _arrays_of_neg1_and_1(shape): + value_strategy = st.sampled_from([-1, 1]) + prod_shape = int(np.prod(shape)) # Convert np.int64 to int + array_data = draw( + st.lists(value_strategy, min_size=prod_shape, max_size=prod_shape) + ) + return np.asarray(array_data).reshape(shape) + + # input_array + dtype, xx = draw( + helpers.dtype_and_values( + shape=shape, + available_dtypes=helpers.get_dtypes("valid"), + safety_factor_scale="linear", + large_abs_safety_factor=2, + small_abs_safety_factor=2, + min_value=1, + max_value=10, + min_dim_size=1, + min_num_dims=1, + max_num_dims=5, + max_dim_size=5, + ) + ) + + # generate the target array 'yy' containing either 1 or -1 + yy = _arrays_of_neg1_and_1(shape=shape) + + return dtype, xx, yy + + +# --- Main --- # +# ------------ # + + +# hinge_embedding_loss +@handle_test( + fn_tree="functional.ivy.experimental.hinge_embedding_loss", + dtype_and_inputs=_hinge_embedding_loss_input(), + margin=st.floats(min_value=1, max_value=5), + reduction=st.sampled_from(["none", "sum", "mean"]), + test_gradients=st.just( + False + ), # Gradients are failing for "jax" and "paddle" backend. + test_with_out=st.just(False), + ground_truth_backend="torch", +) +def test_hinge_embedding_loss( + dtype_and_inputs, + margin, + reduction, + test_flags, + backend_fw, + fn_name, + on_device, +): + dtype, xx, yy = dtype_and_inputs + helpers.test_function( + input_dtypes=dtype, + test_flags=test_flags, + backend_to_test=backend_fw, + fn_name=fn_name, + on_device=on_device, + input=xx[0], + target=yy, + margin=margin, + reduction=reduction, + rtol_=1e-05, + atol_=1e-05, + ) + + # huber_loss @handle_test( fn_tree="functional.ivy.experimental.huber_loss", From e9267fc908276654c099dff7381c430563db022d Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Tue, 2 Jan 2024 04:13:14 +0000 Subject: [PATCH 470/978] fix paddle problem with zipping iterables of tensors (#27810) --- ivy/functional/backends/paddle/general.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 60f32855f4992..8bdb2a2a86cbc 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -227,6 +227,10 @@ def _gather(params1): return _gather(params) +@with_unsupported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, + backend_version, +) def gather_nd( params: paddle.Tensor, indices: paddle.Tensor, @@ -269,6 +273,8 @@ def gather_nd( indices_shape = indices.shape batch_shape = params_shape[:batch_dims] batch_size = paddle.prod(batch_shape, [0]).numpy().tolist() + if isinstance(batch_size, int): + batch_size = [batch_size] index_internal_ndims = indices.ndim - batch_dims - 1 indices_internal_shape = indices_shape[batch_dims:-1] @@ -647,7 +653,11 @@ def _vmap(*args, **kwargs): # vectorisation - applying map_fn if only one arg provided as reduce requires # two elements to begin with. - arr_results = [func(*arrays) for arrays in zip(*args)] + arr_results = [] + for arrays in zip(*args): + arrays = [a if a.shape != [] else a.unsqueeze(0) for a in arrays] + arr_results.append(func(*arrays)) + res = paddle_backend.concat(arr_results) if out_axes: From 75f2b22dd524112f5e55604f9f08e6bf24ac31e2 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 2 Jan 2024 10:13:52 +0000 Subject: [PATCH 471/978] tes: fix value unpacking issue for test_torch_nanmean --- .../test_ivy/test_frontends/test_torch/test_reduction_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index 6bfb34e818547..9bd834075bb3e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -656,7 +656,7 @@ def test_torch_nanmean( test_flags, backend_fw, ): - input_dtype, x, axis = dtype_and_x + input_dtype, x, axis, *_ = dtype_and_x helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, From 9913984cf25ffa524d6f2cd2fce29c31b7cafbdb Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 2 Jan 2024 10:19:26 +0000 Subject: [PATCH 472/978] fix: specify the supported type of float for nanmean although torch.nanmean upon given the wrong dtype (like bool) says it only accepts complex or float but passing in complex also throws error saying `RuntimeError: nansum does not support complex inputs`. so only leaving float as supported. --- ivy/functional/frontends/torch/reduction_ops.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 8b686a7ac2184..075391faf74f4 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -195,6 +195,7 @@ def moveaxis(input, source, destination): return ivy.moveaxis(input, source, destination) +@with_supported_dtypes({"2.1.2 and below": ("float",)}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def nanmean(input, dim=None, keepdim=False, *, dtype=None, out=None): From 8620edf3d4b8bab4aa64443c7e69b276b885b581 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 2 Jan 2024 10:41:19 +0000 Subject: [PATCH 473/978] test: avoid value unpacking mismatch in test_nanmean from experimental tests --- .../test_experimental/test_core/test_statistical.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_statistical.py index 6ceea7b2c08a1..4a7f96a3f0714 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_statistical.py @@ -599,7 +599,7 @@ def test_median(*, dtype_x_axis, keep_dims, test_flags, backend_fw, fn_name, on_ def test_nanmean( *, dtype_x_axis, keep_dims, dtype, test_flags, backend_fw, fn_name, on_device ): - input_dtype, x, axis = dtype_x_axis + input_dtype, x, axis, *_ = dtype_x_axis helpers.test_function( input_dtypes=input_dtype, test_flags=test_flags, From 62b835dc180edffc50a17037862a18dafe9d81c9 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 2 Jan 2024 10:52:32 +0000 Subject: [PATCH 474/978] fix: specify supported types for nanmean in tensorflow and torch backends --- .../backends/tensorflow/experimental/statistical.py | 9 +++++++++ .../backends/torch/experimental/statistical.py | 3 ++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/experimental/statistical.py b/ivy/functional/backends/tensorflow/experimental/statistical.py index 1febdbbf918a2..974b9886c3674 100644 --- a/ivy/functional/backends/tensorflow/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/experimental/statistical.py @@ -53,6 +53,15 @@ def median( # TODO: Implement in pure tensorflow +@with_supported_dtypes( + { + "2.15.0 and below": ( + "float", + "complex", + ) + }, + backend_version, +) def nanmean( a: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index efad6240c1400..f44069500b9c1 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -3,7 +3,7 @@ import torch # local -from ivy.func_wrapper import with_unsupported_dtypes +from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes from . import backend_version import ivy from ..statistical import _infer_dtype @@ -170,6 +170,7 @@ def median( median.support_native_out = False +@with_supported_dtypes({"2.1.2 and below": ("float",)}, backend_version) def nanmean( a: torch.Tensor, /, From 1d32057c5a2508e60b66eecc98e555c16ced07ea Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 2 Jan 2024 11:06:59 +0000 Subject: [PATCH 475/978] fix: pass generated data correctly in test_torch_norm --- .../test_ivy/test_frontends/test_torch/test_reduction_ops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index 9bd834075bb3e..b27d96da93ed1 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -760,14 +760,14 @@ def test_torch_norm( helpers.test_frontend_function( backend_to_test=backend_fw, - input_dtypes=[x_dtype], + input_dtypes=x_dtype, frontend=frontend, test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, rtol=1e-01, atol=1e-08, - input=x, + input=x[0], p=p, dim=axis, keepdim=keepdim, From ea75d3c0686accfedd0bc821d0eb76b1810c525f Mon Sep 17 00:00:00 2001 From: ksheroz <87086877+ksheroz@users.noreply.github.com> Date: Tue, 2 Jan 2024 18:26:24 +0500 Subject: [PATCH 476/978] feat: Paddle Frontend: tensor __rtruediv__ (#27813) --- .../frontends/paddle/tensor/tensor.py | 7 +++ .../test_paddle/test_tensor/test_tensor.py | 43 +++++++++++++++++++ 2 files changed, 50 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 22b76a5db33d8..60daa04eb2967 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -233,6 +233,13 @@ def __neg__(self): def __rdiv__(self, y, /, name=None): return paddle_frontend.divide(y, self) + @with_unsupported_dtypes( + {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + "paddle", + ) + def __rtruediv__(self, y, /, name=None): + return paddle_frontend.divide(y, self) + @with_unsupported_dtypes( {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 912ba9a7f3593..bb38c75a90680 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -1287,6 +1287,49 @@ def test_paddle__rsub__( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__rtruediv__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + shared_dtype=True, + large_abs_safety_factor=10, + small_abs_safety_factor=10, + safety_factor_scale="log", + ), +) +def test_paddle__rtruediv__( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + assume(not np.any(np.isclose(x[0], 0))) + assume(not np.any(np.isclose(x[1], 0))) + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + # __xor__ @handle_frontend_method( class_tree=CLASS_TREE, From bc1421bfa3c5d0a66ebf3d85ceeb015f67472da8 Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Tue, 2 Jan 2024 19:06:07 +0300 Subject: [PATCH 477/978] (fix)(tf backend): made a small fix to the linear implementation, removing an optimization to skip an additional transpose that was leading to incorrect results. --- ivy/functional/backends/tensorflow/layers.py | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index a983821bd6a13..d1e6c2043cd5b 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -30,15 +30,11 @@ def linear( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: # TODO: try to generalize this for >=2 dimensions - if len(x.shape) == 2 and len(weight.shape) == 2: - if x.shape[-1] == weight.shape[-2]: - result = tf.matmul(x, weight) - elif x.shape[-1] == weight.shape[-1]: - result = tf.matmul(x, weight, transpose_b=True) - else: - result = tf.einsum("...i,...ji->...j", x, weight) - else: - result = tf.einsum("...i,...ji->...j", x, weight) + result = ( + tf.matmul(x, weight, transpose_b=True) + if len(x.shape) == len(weight.shape) == 2 and x.shape[-1] == weight.shape[-1] + else tf.einsum("...i,...ji->...j", x, weight) + ) if bias is not None: return tf.add(result, bias) From f655b4c8c8535aeb19612ab0bbdcabcf1432c7aa Mon Sep 17 00:00:00 2001 From: Muhammad Ali Shahbaz Date: Wed, 3 Jan 2024 00:33:18 +0500 Subject: [PATCH 478/978] feat(frontend): Added logsumexp function in paddlepaddle frontend (#21725) Co-authored-by: NripeshN --- ivy/functional/frontends/paddle/math.py | 23 +++++++++++++ .../test_frontends/test_paddle/test_math.py | 33 +++++++++++++++++++ 2 files changed, 56 insertions(+) diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index f8cd603766781..f81f5b5f89584 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -417,6 +417,29 @@ def logit(x, eps=None, name=None): return ivy.logit(x, eps=eps) +@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@to_ivy_arrays_and_back +def logsumexp(x, axis=None, y=None): + x = ivy.asarray(x) + if y is not None: + y = ivy.asarray(y) + x = ivy.where(y != 0, x, -ivy.inf) + if axis is None: + amax = ivy.max(x) + expsub = ivy.exp(x - amax) + sumexp = ivy.sum(expsub) + out = ivy.log(sumexp) + amax + else: + amax = ivy.max(x, axis=axis, keepdims=True) + expsub = ivy.exp(x - amax) + sumexp = ivy.sum(expsub, axis=axis, keepdims=True) + out = ivy.log(sumexp) + amax + if y is not None: + sign = ivy.stop_gradient(ivy.sign(sumexp)) + out = ivy.where(sign < 0, ivy.nan, out) + return out + + @with_supported_dtypes( {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py index 3aa1a088b7e79..c93967b71cf46 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py @@ -1720,6 +1720,39 @@ def test_paddle_logit( ) +# logsumexp +@handle_frontend_test( + fn_tree="paddle.tensor.math.logsumexp", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + max_num_dims=4, + num_arrays=2, + allow_inf=False, + shared_dtype=True, + ), +) +def test_paddle_logsumexp( + *, + dtype_and_x, + on_device, + fn_tree, + backend_fw, + frontend, + test_flags, +): + input_dtypes, xs = dtype_and_x + helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x=xs[0], + axis=None, + ) + + # max @handle_frontend_test( fn_tree="paddle.max", From 70345e939e7c382ba0a2fd5d04487e273dccf92d Mon Sep 17 00:00:00 2001 From: saeedashrraf <48128381+saeedashrraf@users.noreply.github.com> Date: Wed, 3 Jan 2024 03:44:33 +0200 Subject: [PATCH 479/978] refactor: Refactoring the frontend torch.nn module and the backend ivy module (#27833) - Removed the NoneType dictionaries for both the parameters and the buffers - Fixed some issues with the buffer's implementation. Now the buffers are added correctly to the buffers Container in the module + the NoneType buffers are only instantiated in their respective submodules but are not added to the parent modules. --- .../frontends/torch/nn/modules/module.py | 14 -------------- ivy/stateful/helpers.py | 9 +++++---- ivy/stateful/module.py | 15 +++++++++------ 3 files changed, 14 insertions(+), 24 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 5f33aac3eebc9..16ac649480c6a 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -26,8 +26,6 @@ def __init__(self, *args, device=None, devices=None, **kwargs) -> None: **kwargs, ) super().__setattr__("_frontend_module", True) - super().__setattr__("_nonetype_param_dict", {}) - super().__setattr__("_nonetype_buffers_dict", {}) super().__setattr__( "_attr_mapping", {"_parameters": "v", "_modules": "module_dict"} ) @@ -115,13 +113,9 @@ def add_module(self, name: str, module: Optional["Module"]) -> None: super().__setattr__(name, module) def register_buffer(self, name: str, value: Optional["Tensor"]) -> None: - if value is None: - self._nonetype_buffers_dict[name] = value super().register_buffer(name, value) def register_parameter(self, name: str, value: Optional["Parameter"]) -> None: - if value is None: - self._nonetype_param_dict[name] = value super().register_parameter(name, value) def register_module(self, name: str, module: Optional["Module"]) -> None: @@ -255,14 +249,6 @@ def __getattribute__(self, name: str) -> Any: v = self.__dict__["_v"] if name in v: return v[name] - if "_nonetype_param_dict" in self.__dict__: - nonetype_param_dict = self.__dict__["_nonetype_param_dict"] - if name in nonetype_param_dict: - return nonetype_param_dict[name] - if "_nonetype_buffers_dict" in self.__dict__: - nonetype_buffers_dict = self.__dict__["_nonetype_buffers_dict"] - if name in nonetype_buffers_dict: - return nonetype_buffers_dict[name] # Adding this attribute mapping s.t if someone tries # to retrieve self._modules/self._parameters, we # can handle that here diff --git a/ivy/stateful/helpers.py b/ivy/stateful/helpers.py index 202acfde78d37..c62ea0bea79f1 100644 --- a/ivy/stateful/helpers.py +++ b/ivy/stateful/helpers.py @@ -89,9 +89,10 @@ def _find_variables( return vs def _find_buffers(self): - for obj in self.__dict__.keys(): - if isinstance(getattr(self, obj), ivy.Module): - self._buffers.update({obj: getattr(self, obj).buffers}) + if hasattr(self, "_module_dict"): + for key, sub_module in self._module_dict.items(): + if len(sub_module._buffers) > 0: + self._buffers[key] = sub_module._buffers def _build_and_return_v(self, *args, **kwargs): self.build(*args, **kwargs) @@ -128,7 +129,7 @@ def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): # Check if `v` contains `new_kc` before replacing in `ret_cont` if v.cont_has_key_chain(new_kc): ret_cont = ret_cont.cont_set_at_key_chain( - "/".join(new_kc.split("/")[1:]), v.cont_at_key_chain(new_kc) + "/".join(old_kc.split("/")[1:]), v.cont_at_key_chain(new_kc) ) else: continue diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 195ea30ea1f1f..12a16f95f39dc 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -288,12 +288,12 @@ def build( # ToDo: verify variables in self.v are released once this method exits self._v = ivy.Container() - # once all variables built, find and assign buffers - self._find_buffers() - # compute the module dict self._compute_module_dict() + # once all variables built, find and assign buffers + self._find_buffers() + return v_ret if bool(v_ret) or isinstance(built, bool) else built def trace_graph( @@ -345,7 +345,10 @@ def register_buffer(self, name, value): value Value of the buffer """ - self._buffers.update({name: value}) + if value is not None: + self._buffers.update({name: value}) + else: + super().__setattr__(name, value) def register_parameter(self, name, value): """Register a parameter. @@ -353,9 +356,9 @@ def register_parameter(self, name, value): Parameters ---------- name - Name of the buffer + Name of the parameter value - Value of the buffer + Value of the parameter """ self._v.update({name: value}) From c7bbdac0339089325ff94125eba42eb591977909 Mon Sep 17 00:00:00 2001 From: Ambroise <56084688+Ambro19@users.noreply.github.com> Date: Wed, 3 Jan 2024 04:26:09 -0500 Subject: [PATCH 480/978] Updated a Minor Grammar Issue in building_blocks.rst (#27832) Co-authored-by: NripeshN From 3927f5b01db8fb0e0adf724fd7151f1ff1c6ac9b Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 3 Jan 2024 15:42:30 +0530 Subject: [PATCH 481/978] fix: fixed the failing tests at torch backend (#27829) Co-authored-by: NripeshN --- ivy/functional/backends/torch/data_type.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index 05faab29b6c2e..b650590e6c290 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -72,6 +72,7 @@ def smallest_normal(self): # -------------------# +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def astype( x: torch.Tensor, dtype: torch.dtype, From 086445af9c6b1c4d690bbae9ef1fcd9cfd701a41 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 3 Jan 2024 15:59:01 +0530 Subject: [PATCH 482/978] fix: Fixed wrong argument name in `paddle.concat()` function call (#27799) --- ivy/functional/backends/paddle/set.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/set.py b/ivy/functional/backends/paddle/set.py index aeedd6bae6d05..177953d137981 100644 --- a/ivy/functional/backends/paddle/set.py +++ b/ivy/functional/backends/paddle/set.py @@ -135,7 +135,7 @@ def unique_inverse( x.dtype ) unique = paddle.concat( - input=[unique.astype(x.dtype), paddle.reshape(unique_nan, [nan_count])], + [unique.astype(x.dtype), paddle.reshape(unique_nan, [nan_count])], axis=-1, ) inverse_val = paddle.reshape(inverse_val, shape=x.shape) From ef2c6d04e7c6c76535ff159011dbfd8b1f7f3704 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 3 Jan 2024 15:59:36 +0530 Subject: [PATCH 483/978] fix: Fixed passing of missing `ret_idxs` argument in `_rebuild_flattened_containers()` function call (#27822) --- ivy/functional/backends/mxnet/experimental/gradients.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/mxnet/experimental/gradients.py b/ivy/functional/backends/mxnet/experimental/gradients.py index e952f2264ccbb..bcd6d00b7e2e7 100644 --- a/ivy/functional/backends/mxnet/experimental/gradients.py +++ b/ivy/functional/backends/mxnet/experimental/gradients.py @@ -46,7 +46,7 @@ def vjpfun(x_in): ) return _rebuild_flattened_containers( - ivy.to_ivy(grads, nested=True, include_derived=True) + ivy.to_ivy(grads, nested=True, include_derived=True), ret_idxs ) return (ivy.to_ivy(primals_out, nested=True, include_derived=True), vjpfun) From 1c4d5aa3a6b5950d0ef6266fa1afa52f271e80aa Mon Sep 17 00:00:00 2001 From: Deeptendu Santra <55111154+Dsantra92@users.noreply.github.com> Date: Wed, 3 Jan 2024 22:28:30 +0530 Subject: [PATCH 484/978] Update compiler.py bb1b2b7 (#27837) Co-authored-by: ivy-brach --- binaries.json | 32 +++++++++++++++----------------- ivy/compiler/compiler.py | 11 +++++------ 2 files changed, 20 insertions(+), 23 deletions(-) diff --git a/binaries.json b/binaries.json index 8f31596c7a3a7..8fc0942e14a2d 100644 --- a/binaries.json +++ b/binaries.json @@ -4,6 +4,7 @@ "_compiler.so", { "utils": [ + "C.so", "CC.so", "CD.so", "CI.so", @@ -11,8 +12,7 @@ "CM.so", "CV.so", "CX.so", - "C.so", - + "D.so", "DC.so", "DD.so", "DI.so", @@ -20,17 +20,21 @@ "DM.so", "DV.so", "DX.so", - "D.so", - + "I.so", "IC.so", "ID.so", "II.so", + "IIC.so", + "IID.so", + "III.so", + "IIL.so", + "IIV.so", + "IIX.so", "IL.so", "IM.so", "IV.so", "IX.so", - "I.so", - + "L.so", "LC.so", "LD.so", "LI.so", @@ -38,8 +42,7 @@ "LM.so", "LV.so", "LX.so", - "L.so", - + "M.so", "MC.so", "MD.so", "MI.so", @@ -47,8 +50,7 @@ "MM.so", "MV.so", "MX.so", - "M.so", - + "V.so", "VC.so", "VD.so", "VI.so", @@ -56,20 +58,16 @@ "VM.so", "VV.so", "VX.so", - "V.so", - + "X.so", "XC.so", "XD.so", "XI.so", "XL.so", "XM.so", "XV.so", - "XX.so", - "X.so", - - "IIC.so" + "XX.so" ] } ] } -} +} \ No newline at end of file diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 535e749daff4b..aa49abb1997d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" + from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -156,8 +155,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" + from ._compiler import transpile as _transpile return _transpile( From 6ba08042782a456afc3ccd47212f461a75475c4b Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 3 Jan 2024 17:00:06 +0000 Subject: [PATCH 485/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- binaries.json | 2 +- ivy/compiler/compiler.py | 11 ++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/binaries.json b/binaries.json index 8fc0942e14a2d..1bc4c24020693 100644 --- a/binaries.json +++ b/binaries.json @@ -70,4 +70,4 @@ } ] } -} \ No newline at end of file +} diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index aa49abb1997d3..535e749daff4b 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,8 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" - + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -155,8 +156,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" - + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile return _transpile( From e3971e71dfceb3cc4691b46319c5750f5164eddf Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 3 Jan 2024 22:32:37 +0530 Subject: [PATCH 486/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index d1bfff206d3b1..23b93d8e1bed4 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.4.0" +__version__ = "0.0.5.0" From 648b82c17b3aff3c1c438aeac2f6052c397bf102 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 3 Jan 2024 22:41:34 +0530 Subject: [PATCH 487/978] Update release.yml --- .github/workflows/release.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index f29e7b8bbf2c8..9f12075e97259 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -10,10 +10,10 @@ jobs: uses: unifyai/workflows/.github/workflows/docs.yml@main secrets: inherit - publish-binaries: - name: Publish Binaries - uses: unifyai/workflows/.github/workflows/binaries.yml@main - secrets: inherit + # publish-binaries: + # name: Publish Binaries + # uses: unifyai/workflows/.github/workflows/binaries.yml@main + # secrets: inherit deploy: name: Deploy to PyPI From 4674f26cffe5379516c060eff139046322d55545 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 3 Jan 2024 21:16:53 +0000 Subject: [PATCH 488/978] test: increase safety factor for test_torch_any to avoid several value mismatches --- .../test_ivy/test_frontends/test_torch/test_reduction_ops.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index b27d96da93ed1..49ab2e9228a5e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -209,6 +209,9 @@ def test_torch_aminmax( fn_tree="torch.any", dtype_input_axis=helpers.dtype_values_axis( available_dtypes=helpers.get_dtypes("valid"), + safety_factor_scale="log", + small_abs_safety_factor=8, + large_abs_safety_factor=8, min_axis=-1, max_axis=0, min_num_dims=1, From 674823feb04bbb575bb987612723d3fa19d83a49 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 3 Jan 2024 21:52:55 +0000 Subject: [PATCH 489/978] fix: make ivy Array method `clip` arg positions match with that of `ivy.clip` functional form to avoid discrepancies in func/method call --- ivy/data_classes/array/manipulation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/data_classes/array/manipulation.py b/ivy/data_classes/array/manipulation.py index a090309c39673..231a356ca6be4 100644 --- a/ivy/data_classes/array/manipulation.py +++ b/ivy/data_classes/array/manipulation.py @@ -440,9 +440,9 @@ def stack( def clip( self: ivy.Array, + /, x_min: Optional[Union[Number, ivy.Array, ivy.NativeArray]] = None, x_max: Optional[Union[Number, ivy.Array, ivy.NativeArray]] = None, - /, *, out: Optional[ivy.Array] = None, ) -> ivy.Array: From 738182bc3bbe92fb8fb15a14c640ee3267aaca4a Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 3 Jan 2024 21:58:44 +0000 Subject: [PATCH 490/978] feat: add box_iou for torchvision frontend along with the test --- ivy/functional/frontends/torchvision/ops.py | 13 ++++++++ .../test_torchvision/test_ops.py | 30 +++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/ivy/functional/frontends/torchvision/ops.py b/ivy/functional/frontends/torchvision/ops.py index 4ef4e86eecf44..582003655838c 100644 --- a/ivy/functional/frontends/torchvision/ops.py +++ b/ivy/functional/frontends/torchvision/ops.py @@ -23,6 +23,19 @@ def box_area(boxes): return ivy.prod(boxes[..., 2:] - boxes[..., :2], axis=-1) +@to_ivy_arrays_and_back +def box_iou(boxes1, boxes2): + area1 = box_area(boxes1) + area2 = box_area(boxes2) + lt = ivy.maximum(boxes1[:, None, :2], boxes2[:, :2]) + rb = ivy.minimum(boxes1[:, None, 2:], boxes2[:, 2:]) + wh = (rb - lt).clip(x_min=0) + inter = wh[:, :, 0] * wh[:, :, 1] + union = area1[:, None] + area2 - inter + iou = inter / union + return iou + + @with_unsupported_device_and_dtypes( { "2.1.2 and below": { diff --git a/ivy_tests/test_ivy/test_frontends/test_torchvision/test_ops.py b/ivy_tests/test_ivy/test_frontends/test_torchvision/test_ops.py index 919c05a30274f..70510ca8f8829 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torchvision/test_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torchvision/test_ops.py @@ -148,6 +148,36 @@ def test_torchvision_box_area( ) +@handle_frontend_test( + fn_tree="torchvision.ops.box_iou", + boxes=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + shape=st.tuples(helpers.ints(min_value=1, max_value=5), st.just(4)), + num_arrays=2, + ), +) +def test_torchvision_box_iou( + *, + boxes, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + dtype, boxes = boxes + helpers.test_frontend_function( + input_dtypes=dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + boxes1=boxes[0], + boxes2=boxes[1], + ) + + @handle_frontend_test( fn_tree="torchvision.ops.clip_boxes_to_image", boxes=helpers.dtype_and_values( From 81058daa4d9c852f8fd6b034a0c98dd2bc41192b Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 4 Jan 2024 11:19:26 +0530 Subject: [PATCH 491/978] fix: added access to github secret in binaries.yml to update the tag --- .github/workflows/binaries.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/binaries.yml b/.github/workflows/binaries.yml index 51dd639e700d0..9520707a2bd18 100644 --- a/.github/workflows/binaries.yml +++ b/.github/workflows/binaries.yml @@ -6,11 +6,11 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout 🛎️Binaries - uses: actions/checkout@v2 + uses: actions/checkout@v4 with: repository: unifyai/binaries + token: ${{ secrets.IVY_BRANCH_TOKEN }} path: binaries - persist-credentials: false - name: Add Tag to Binaries run: | From 0da75ebd93bdb17c6886742a74368b2011670da7 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 4 Jan 2024 11:20:25 +0530 Subject: [PATCH 492/978] chore: uncommented the binaries job in release.yml --- .github/workflows/release.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 9f12075e97259..98f08e09360a6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -10,10 +10,10 @@ jobs: uses: unifyai/workflows/.github/workflows/docs.yml@main secrets: inherit - # publish-binaries: - # name: Publish Binaries - # uses: unifyai/workflows/.github/workflows/binaries.yml@main - # secrets: inherit + publish-binaries: + name: Publish Binaries + uses: ./.github/workflows/binaries.yml + secrets: inherit deploy: name: Deploy to PyPI From 09c532a5355395f9a24400d90735e671a8b1886b Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 4 Jan 2024 12:54:07 +0530 Subject: [PATCH 493/978] fix: added the CLEAN environment variable to setup.py to overwrite the binaries downloaded for the previous tag for the next tag while releasing (#27839) --- scripts/shell/deploy_pypi.sh | 1 + setup.py | 9 ++++++--- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/scripts/shell/deploy_pypi.sh b/scripts/shell/deploy_pypi.sh index c185f62dbb87d..cb51bbcc1e196 100644 --- a/scripts/shell/deploy_pypi.sh +++ b/scripts/shell/deploy_pypi.sh @@ -1,5 +1,6 @@ jq -c '.compiler[]' available_configs.json | while read config; do export TAG=${config:1:${#config}-2} + export CLEAN=true python -m build python3 scripts/rename_wheels.py done diff --git a/setup.py b/setup.py index e98695ecf1b84..75571b84efc24 100644 --- a/setup.py +++ b/setup.py @@ -46,9 +46,10 @@ def _strip(line): binaries_dict = json.load(open("binaries.json")) available_configs = json.load(open("available_configs.json")) binaries_paths = _get_paths_from_binaries(binaries_dict) -version = os.environ["VERSION"] if "VERSION" in os.environ else "main" +version = os.environ.get("VERSION", "main") +fixed_tag = os.environ.get("TAG", None) +clean = os.environ.get("CLEAN", None) terminate = False -fixed_tag = os.environ["TAG"] if "TAG" in os.environ else None all_tags, python_tag, plat_name, options = None, None, None, None if fixed_tag: python_tag, _, plat_name = str(fixed_tag).split("-") @@ -65,7 +66,9 @@ def _strip(line): break for path in binaries_paths: module = path.split(os.sep)[1] - if os.path.exists(path) or str(tag) not in available_configs[module]: + if (os.path.exists(path) and not clean) or str(tag) not in available_configs[ + module + ]: continue folders = path.split(os.sep) folder_path, file_path = os.sep.join(folders[:-1]), folders[-1] From 9a60718e9dd8afc30df35e642aaacaf6ff00a3ef Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 4 Jan 2024 13:33:51 +0530 Subject: [PATCH 494/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index 23b93d8e1bed4..e083ce379d981 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.5.0" +__version__ = "0.0.5.1" From a4ae5ea846be0a2441a68a241c6526c6bce32756 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 4 Jan 2024 13:44:45 +0530 Subject: [PATCH 495/978] feat: Updated `NumPy` version from `1.26.2` to `1.26.3` (#27834) Updated `NumPy` version from `1.26.2` to `1.26.3` --- ivy/functional/backends/numpy/__init__.py | 24 ++++++------ ivy/functional/backends/numpy/data_type.py | 4 +- ivy/functional/backends/numpy/elementwise.py | 32 ++++++++-------- .../numpy/experimental/activations.py | 2 +- .../numpy/experimental/elementwise.py | 2 +- .../backends/numpy/experimental/general.py | 2 +- .../backends/numpy/experimental/layers.py | 4 +- .../numpy/experimental/linear_algebra.py | 6 +-- .../backends/numpy/experimental/losses.py | 6 +-- .../backends/numpy/experimental/norms.py | 2 +- .../backends/numpy/experimental/searching.py | 2 +- .../numpy/experimental/statistical.py | 4 +- ivy/functional/backends/numpy/general.py | 2 +- .../backends/numpy/linear_algebra.py | 38 +++++++++---------- ivy/functional/backends/numpy/manipulation.py | 2 +- ivy/functional/backends/numpy/random.py | 2 +- ivy/functional/backends/numpy/sorting.py | 2 +- ivy/functional/backends/numpy/statistical.py | 2 +- .../numpy/fft/discrete_fourier_transform.py | 10 ++--- .../numpy/linalg/norms_and_other_numbers.py | 4 +- ...olving_equations_and_inverting_matrices.py | 10 ++--- .../mathematical_functions/miscellaneous.py | 2 +- .../frontends/numpy/ndarray/ndarray.py | 2 +- .../frontends/numpy/statistics/histograms.py | 2 +- 24 files changed, 84 insertions(+), 84 deletions(-) diff --git a/ivy/functional/backends/numpy/__init__.py b/ivy/functional/backends/numpy/__init__.py index 0939aa145f73c..5ddf86a0b9a17 100644 --- a/ivy/functional/backends/numpy/__init__.py +++ b/ivy/functional/backends/numpy/__init__.py @@ -81,7 +81,7 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): # update these to add new dtypes valid_dtypes = { - "1.26.2 and below": ( + "1.26.3 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -99,7 +99,7 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): ) } valid_numeric_dtypes = { - "1.26.2 and below": ( + "1.26.3 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -116,7 +116,7 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): ) } valid_int_dtypes = { - "1.26.2 and below": ( + "1.26.3 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -127,11 +127,11 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): ivy.uint64, ) } -valid_float_dtypes = {"1.26.2 and below": (ivy.float16, ivy.float32, ivy.float64)} +valid_float_dtypes = {"1.26.3 and below": (ivy.float16, ivy.float32, ivy.float64)} valid_uint_dtypes = { - "1.26.2 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) + "1.26.3 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) } -valid_complex_dtypes = {"1.26.2 and below": (ivy.complex64, ivy.complex128)} +valid_complex_dtypes = {"1.26.3 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -143,12 +143,12 @@ def rep_method(self, ufunc, method, *inputs, **kwargs): # invalid data types # update these to add new dtypes -invalid_dtypes = {"1.26.2 and below": (ivy.bfloat16,)} -invalid_numeric_dtypes = {"1.26.2 and below": (ivy.bfloat16,)} -invalid_int_dtypes = {"1.26.2 and below": ()} -invalid_float_dtypes = {"1.26.2 and below": (ivy.bfloat16,)} -invalid_uint_dtypes = {"1.26.2 and below": ()} -invalid_complex_dtypes = {"1.26.2 and below": ()} +invalid_dtypes = {"1.26.3 and below": (ivy.bfloat16,)} +invalid_numeric_dtypes = {"1.26.3 and below": (ivy.bfloat16,)} +invalid_int_dtypes = {"1.26.3 and below": ()} +invalid_float_dtypes = {"1.26.3 and below": (ivy.bfloat16,)} +invalid_uint_dtypes = {"1.26.3 and below": ()} +invalid_complex_dtypes = {"1.26.3 and below": ()} # leave these untouched diff --git a/ivy/functional/backends/numpy/data_type.py b/ivy/functional/backends/numpy/data_type.py index facd6d6f3b645..0f59bfe7ac0e9 100644 --- a/ivy/functional/backends/numpy/data_type.py +++ b/ivy/functional/backends/numpy/data_type.py @@ -133,7 +133,7 @@ def broadcast_arrays(*arrays: np.ndarray) -> List[np.ndarray]: raise ivy.utils.exceptions.IvyBroadcastShapeError(e) -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def broadcast_to( x: np.ndarray, /, @@ -216,7 +216,7 @@ def as_ivy_dtype( ) -@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bfloat16",)}, backend_version) def as_native_dtype(dtype_in: Union[np.dtype, str, bool, int, float], /) -> np.dtype: if dtype_in is int: return ivy.default_int_dtype(as_native=True) diff --git a/ivy/functional/backends/numpy/elementwise.py b/ivy/functional/backends/numpy/elementwise.py index 0d0c6e8ce9022..3000ed0954685 100644 --- a/ivy/functional/backends/numpy/elementwise.py +++ b/ivy/functional/backends/numpy/elementwise.py @@ -83,7 +83,7 @@ def atan(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def atan2( x1: np.ndarray, x2: np.ndarray, /, *, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -103,7 +103,7 @@ def atanh(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def bitwise_and( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -119,7 +119,7 @@ def bitwise_and( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def bitwise_invert( x: Union[int, bool, np.ndarray], /, *, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -130,7 +130,7 @@ def bitwise_invert( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def bitwise_left_shift( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -146,7 +146,7 @@ def bitwise_left_shift( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def bitwise_or( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -162,7 +162,7 @@ def bitwise_or( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def bitwise_right_shift( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -178,7 +178,7 @@ def bitwise_right_shift( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def bitwise_xor( x1: Union[int, bool, np.ndarray], x2: Union[int, bool, np.ndarray], @@ -193,7 +193,7 @@ def bitwise_xor( bitwise_xor.support_native_out = True -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) @_scalar_output_to_0d_array def ceil(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: if "int" in str(x.dtype): @@ -216,7 +216,7 @@ def cos(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: cos.support_native_out = True -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) @_scalar_output_to_0d_array def cosh(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.cosh(x, out=out) @@ -289,7 +289,7 @@ def expm1(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def floor(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: if "int" in str(x.dtype): ret = np.copy(x) @@ -304,7 +304,7 @@ def floor(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def floor_divide( x1: Union[float, np.ndarray], x2: Union[float, np.ndarray], @@ -486,7 +486,7 @@ def log2(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def logaddexp( x1: np.ndarray, x2: np.ndarray, /, *, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -623,7 +623,7 @@ def pow( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def remainder( x1: Union[float, np.ndarray], x2: Union[float, np.ndarray], @@ -865,7 +865,7 @@ def reciprocal( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def deg2rad(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.deg2rad(x, out=out) @@ -874,7 +874,7 @@ def deg2rad(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def rad2deg(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.rad2deg(x, out=out) @@ -891,7 +891,7 @@ def isreal(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def fmod( x1: np.ndarray, x2: np.ndarray, diff --git a/ivy/functional/backends/numpy/experimental/activations.py b/ivy/functional/backends/numpy/experimental/activations.py index e48bbedb99b28..45d1a6b3c01d0 100644 --- a/ivy/functional/backends/numpy/experimental/activations.py +++ b/ivy/functional/backends/numpy/experimental/activations.py @@ -55,7 +55,7 @@ def relu6( relu6.support_native_out = True -@with_unsupported_dtypes({"1.26.2 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bool",)}, backend_version) @_scalar_output_to_0d_array def logsigmoid( input: np.ndarray, /, *, complex_mode="jax", out: Optional[np.ndarray] = None diff --git a/ivy/functional/backends/numpy/experimental/elementwise.py b/ivy/functional/backends/numpy/experimental/elementwise.py index 47fed86917172..895a0daf0f271 100644 --- a/ivy/functional/backends/numpy/experimental/elementwise.py +++ b/ivy/functional/backends/numpy/experimental/elementwise.py @@ -42,7 +42,7 @@ def amin( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bfloat16",)}, backend_version) def sinc(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.sinc(x).astype(x.dtype) diff --git a/ivy/functional/backends/numpy/experimental/general.py b/ivy/functional/backends/numpy/experimental/general.py index 2077d276631c9..acd4ba7321d4a 100644 --- a/ivy/functional/backends/numpy/experimental/general.py +++ b/ivy/functional/backends/numpy/experimental/general.py @@ -7,7 +7,7 @@ from ivy import with_unsupported_dtypes -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def reduce( operand: np.ndarray, init_value: Union[int, float], diff --git a/ivy/functional/backends/numpy/experimental/layers.py b/ivy/functional/backends/numpy/experimental/layers.py index 8672a0d49f587..8e8344a78d166 100644 --- a/ivy/functional/backends/numpy/experimental/layers.py +++ b/ivy/functional/backends/numpy/experimental/layers.py @@ -729,7 +729,7 @@ def fft( return np.fft.fft(x, n, dim, norm).astype(out_dtype) -@with_supported_dtypes({"1.26.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"1.26.3 and below": ("float32", "float64")}, backend_version) def dct( x: np.ndarray, /, @@ -994,7 +994,7 @@ def ifftn( return np.fft.ifftn(x, s, axes, norm).astype(x.dtype) -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def embedding( weights: np.ndarray, indices: np.ndarray, diff --git a/ivy/functional/backends/numpy/experimental/linear_algebra.py b/ivy/functional/backends/numpy/experimental/linear_algebra.py index 1fc7eb964c89e..98e87e7efafa3 100644 --- a/ivy/functional/backends/numpy/experimental/linear_algebra.py +++ b/ivy/functional/backends/numpy/experimental/linear_algebra.py @@ -90,7 +90,7 @@ def kron( @with_supported_dtypes( - {"1.26.2 and below": ("float32", "float64", "complex64", "complex128")}, + {"1.26.3 and below": ("float32", "float64", "complex64", "complex128")}, backend_version, ) def matrix_exp( @@ -106,7 +106,7 @@ def matrix_exp( return exp_mat.astype(x.dtype) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def eig( x: np.ndarray, /, @@ -120,7 +120,7 @@ def eig( eig.support_native_out = False -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def eigvals(x: np.ndarray, /) -> np.ndarray: e = np.linalg.eigvals(x) return e.astype(complex) diff --git a/ivy/functional/backends/numpy/experimental/losses.py b/ivy/functional/backends/numpy/experimental/losses.py index 873bc604d8a6e..622b3464b3311 100644 --- a/ivy/functional/backends/numpy/experimental/losses.py +++ b/ivy/functional/backends/numpy/experimental/losses.py @@ -8,7 +8,7 @@ from . import backend_version -@with_unsupported_dtypes({"1.26.2 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bool",)}, backend_version) @_scalar_output_to_0d_array def huber_loss( input: np.ndarray, @@ -32,7 +32,7 @@ def huber_loss( # Implementation of smooth_l1_loss in the given format -@with_unsupported_dtypes({"1.26.2 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bool",)}, backend_version) @_scalar_output_to_0d_array def smooth_l1_loss( input: np.ndarray, @@ -56,7 +56,7 @@ def smooth_l1_loss( return loss -@with_unsupported_dtypes({"1.26.2 and below": ("bool",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bool",)}, backend_version) @_scalar_output_to_0d_array def soft_margin_loss( input: np.ndarray, diff --git a/ivy/functional/backends/numpy/experimental/norms.py b/ivy/functional/backends/numpy/experimental/norms.py index a8f2ec9b6a8a3..54a7bfe5362f5 100644 --- a/ivy/functional/backends/numpy/experimental/norms.py +++ b/ivy/functional/backends/numpy/experimental/norms.py @@ -4,7 +4,7 @@ from . import backend_version -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def l1_normalize( x: np.ndarray, /, diff --git a/ivy/functional/backends/numpy/experimental/searching.py b/ivy/functional/backends/numpy/experimental/searching.py index f49b9c9c3a8fd..191e15681caf9 100644 --- a/ivy/functional/backends/numpy/experimental/searching.py +++ b/ivy/functional/backends/numpy/experimental/searching.py @@ -7,7 +7,7 @@ from . import backend_version -@with_supported_dtypes({"1.26.2 and below": ("int32", "int64")}, backend_version) +@with_supported_dtypes({"1.26.3 and below": ("int32", "int64")}, backend_version) def unravel_index( indices: np.ndarray, shape: Tuple[int], diff --git a/ivy/functional/backends/numpy/experimental/statistical.py b/ivy/functional/backends/numpy/experimental/statistical.py index a69b2a58bd10e..e2dffa696bc2a 100644 --- a/ivy/functional/backends/numpy/experimental/statistical.py +++ b/ivy/functional/backends/numpy/experimental/statistical.py @@ -9,7 +9,7 @@ @with_unsupported_dtypes( - {"1.26.2 and below": ("bfloat16",)}, + {"1.26.3 and below": ("bfloat16",)}, backend_version, ) def histogram( @@ -534,7 +534,7 @@ def __get_index(lst, indices=None, prefix=None): return indices -@with_unsupported_dtypes({"1.26.2 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": "bfloat16"}, backend_version) def cummin( x: np.ndarray, /, diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index 803e582bbbfaf..7c73a37ba78ca 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -435,7 +435,7 @@ def _vmap(*args): return _vmap -@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bfloat16",)}, backend_version) def isin( elements: np.ndarray, test_elements: np.ndarray, diff --git a/ivy/functional/backends/numpy/linear_algebra.py b/ivy/functional/backends/numpy/linear_algebra.py index d5fe77211f752..1f0eb33a2506d 100644 --- a/ivy/functional/backends/numpy/linear_algebra.py +++ b/ivy/functional/backends/numpy/linear_algebra.py @@ -18,7 +18,7 @@ # -------------------# -@with_unsupported_dtypes({"1.26.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16", "complex")}, backend_version) def cholesky( x: np.ndarray, /, *, upper: bool = False, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -30,7 +30,7 @@ def cholesky( return ret -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def cross( x1: np.ndarray, x2: np.ndarray, @@ -46,7 +46,7 @@ def cross( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def det(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: return np.linalg.det(x) @@ -63,7 +63,7 @@ def diagonal( return np.diagonal(x, offset=offset, axis1=axis1, axis2=axis2) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def eigh( x: np.ndarray, /, *, UPLO: str = "L", out: Optional[np.ndarray] = None ) -> Tuple[np.ndarray]: @@ -74,7 +74,7 @@ def eigh( return result_tuple(eigenvalues, eigenvectors) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def eigvalsh( x: np.ndarray, /, *, UPLO: str = "L", out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -90,7 +90,7 @@ def inner( @with_unsupported_dtypes( - {"1.26.2 and below": ("bfloat16", "float16", "complex")}, + {"1.26.3 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def inv( @@ -110,7 +110,7 @@ def inv( return np.linalg.inv(x) -@with_unsupported_dtypes({"1.26.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16", "bfloat16")}, backend_version) def matmul( x1: np.ndarray, x2: np.ndarray, @@ -140,7 +140,7 @@ def matmul( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16", "bfloat16")}, backend_version) def matrix_norm( x: np.ndarray, /, @@ -162,7 +162,7 @@ def matrix_power( @with_unsupported_dtypes( - {"1.26.2 and below": ("float16", "bfloat16", "complex")}, + {"1.26.3 and below": ("float16", "bfloat16", "complex")}, backend_version, ) @_scalar_output_to_0d_array @@ -201,7 +201,7 @@ def matrix_transpose( return np.swapaxes(x, -1, -2) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def outer( x1: np.ndarray, x2: np.ndarray, @@ -216,7 +216,7 @@ def outer( outer.support_native_out = True -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def pinv( x: np.ndarray, /, @@ -230,7 +230,7 @@ def pinv( return np.linalg.pinv(x, rtol) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def qr( x: np.ndarray, /, @@ -243,7 +243,7 @@ def qr( return res(q, r) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def slogdet( x: np.ndarray, /, @@ -258,7 +258,7 @@ def slogdet( return results(sign, logabsdet) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def solve( x1: np.ndarray, x2: np.ndarray, @@ -283,7 +283,7 @@ def solve( return ret -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def svd( x: np.ndarray, /, *, compute_uv: bool = True, full_matrices: bool = True ) -> Union[np.ndarray, Tuple[np.ndarray, ...]]: @@ -297,7 +297,7 @@ def svd( return results(D) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def svdvals( x: np.ndarray, /, *, driver: Optional[str] = None, out: Optional[np.ndarray] = None ) -> np.ndarray: @@ -330,7 +330,7 @@ def tensordot( @_scalar_output_to_0d_array -@with_unsupported_dtypes({"1.26.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16", "bfloat16")}, backend_version) def trace( x: np.ndarray, /, @@ -358,7 +358,7 @@ def vecdot( return np.tensordot(x1, x2, axes=(axis, axis)) -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, backend_version) def eig(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> Tuple[np.ndarray]: result_tuple = NamedTuple( "eig", [("eigenvalues", np.ndarray), ("eigenvectors", np.ndarray)] @@ -435,7 +435,7 @@ def vander( @with_unsupported_dtypes( { - "1.26.2 and below": ( + "1.26.3 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/numpy/manipulation.py b/ivy/functional/backends/numpy/manipulation.py index 9845a2d2061e5..23303b6fbba8e 100644 --- a/ivy/functional/backends/numpy/manipulation.py +++ b/ivy/functional/backends/numpy/manipulation.py @@ -189,7 +189,7 @@ def split( return np.split(x, num_or_size_splits, axis) -@with_unsupported_dtypes({"1.26.2 and below": ("uint64",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("uint64",)}, backend_version) def repeat( x: np.ndarray, /, diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index 3df9936a21769..4d3daa4a00c6e 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -52,7 +52,7 @@ def random_normal( return np.asarray(np.random.normal(mean, std, shape), dtype=dtype) -@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/numpy/sorting.py b/ivy/functional/backends/numpy/sorting.py index bbc49f1076797..78fb8f5d6c925 100644 --- a/ivy/functional/backends/numpy/sorting.py +++ b/ivy/functional/backends/numpy/sorting.py @@ -42,7 +42,7 @@ def sort( # msort -@with_unsupported_dtypes({"1.26.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) def msort( a: Union[np.ndarray, list, tuple], /, *, out: Optional[np.ndarray] = None ) -> np.ndarray: diff --git a/ivy/functional/backends/numpy/statistical.py b/ivy/functional/backends/numpy/statistical.py index 87f469e19062f..bca5a48a850d1 100644 --- a/ivy/functional/backends/numpy/statistical.py +++ b/ivy/functional/backends/numpy/statistical.py @@ -177,7 +177,7 @@ def var( # ------# -@with_unsupported_dtypes({"1.26.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bfloat16",)}, backend_version) def cumprod( x: np.ndarray, /, diff --git a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py index bbf898a2c02d7..738f68cdd1681 100644 --- a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py +++ b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py @@ -33,7 +33,7 @@ def fft(a, n=None, axis=-1, norm=None): return ivy.fft(ivy.astype(a, ivy.complex128), axis, norm=norm, n=n) -@with_unsupported_dtypes({"1.26.2 and below": ("int",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("int",)}, "numpy") @to_ivy_arrays_and_back def fftfreq(n, d=1.0): if not isinstance( @@ -54,7 +54,7 @@ def fftfreq(n, d=1.0): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") def fftshift(x, axes=None): x = ivy.asarray(x) @@ -99,7 +99,7 @@ def ifftn(a, s=None, axes=None, norm=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") def ifftshift(x, axes=None): x = ivy.asarray(x) @@ -119,7 +119,7 @@ def ifftshift(x, axes=None): return roll -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def ihfft(a, n=None, axis=-1, norm=None): if n is None: @@ -129,7 +129,7 @@ def ihfft(a, n=None, axis=-1, norm=None): return output -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def rfft(a, n=None, axis=-1, norm=None): if norm is None: diff --git a/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py b/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py index e1d492dddfe2d..2ca07b851cadd 100644 --- a/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py +++ b/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py @@ -23,7 +23,7 @@ def matrix_rank(A, tol=None, hermitian=False): # solve -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar def norm(x, ord=None, axis=None, keepdims=False): @@ -46,7 +46,7 @@ def norm(x, ord=None, axis=None, keepdims=False): # slogdet -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar def slogdet(a): diff --git a/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py b/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py index e6c504d83f360..9c464431774bb 100644 --- a/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py +++ b/ivy/functional/frontends/numpy/linalg/solving_equations_and_inverting_matrices.py @@ -10,7 +10,7 @@ # inv -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def inv(a): return ivy.inv(a) @@ -19,7 +19,7 @@ def inv(a): # TODO: replace this with function from API # As the compositon provides unstable results @to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") def lstsq(a, b, rcond="warn"): solution = ivy.matmul( ivy.pinv(a, rtol=1e-15).astype(ivy.float64), b.astype(ivy.float64) @@ -32,14 +32,14 @@ def lstsq(a, b, rcond="warn"): # pinv # TODO: add hermitian functionality -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def pinv(a, rcond=1e-15, hermitian=False): return ivy.pinv(a, rtol=rcond) # solve -@with_unsupported_dtypes({"1.26.2 and below": ("float16",)}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") @to_ivy_arrays_and_back def solve(a, b): a, b = promote_types_of_numpy_inputs(a, b) @@ -47,7 +47,7 @@ def solve(a, b): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"1.26.2 and below": ("float16", "blfloat16")}, "numpy") +@with_unsupported_dtypes({"1.26.3 and below": ("float16", "blfloat16")}, "numpy") def tensorinv(a, ind=2): old_shape = ivy.shape(a) prod = 1 diff --git a/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py b/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py index 43da4792f5f9d..e14023acadb6d 100644 --- a/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py +++ b/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py @@ -147,7 +147,7 @@ def _fabs( @to_ivy_arrays_and_back @from_zero_dim_arrays_to_scalar @with_supported_dtypes( - {"1.26.2 and below": ("int8", "int16", "int32", "int64")}, "numpy" + {"1.26.3 and below": ("int8", "int16", "int32", "int64")}, "numpy" ) # Add def _gcd( x1, diff --git a/ivy/functional/frontends/numpy/ndarray/ndarray.py b/ivy/functional/frontends/numpy/ndarray/ndarray.py index dc54cdbdd7267..fcb9e0e6684ed 100644 --- a/ivy/functional/frontends/numpy/ndarray/ndarray.py +++ b/ivy/functional/frontends/numpy/ndarray/ndarray.py @@ -415,7 +415,7 @@ def tolist(self) -> list: @with_supported_device_and_dtypes( { - "1.26.2 and below": { + "1.26.3 and below": { "cpu": ( "int64", "float32", diff --git a/ivy/functional/frontends/numpy/statistics/histograms.py b/ivy/functional/frontends/numpy/statistics/histograms.py index fb0795ec8750c..8220eff8fbd27 100644 --- a/ivy/functional/frontends/numpy/statistics/histograms.py +++ b/ivy/functional/frontends/numpy/statistics/histograms.py @@ -3,7 +3,7 @@ from ivy.func_wrapper import with_supported_dtypes -@with_supported_dtypes({"1.26.2 and below": ("int64",)}, "numpy") +@with_supported_dtypes({"1.26.3 and below": ("int64",)}, "numpy") @to_ivy_arrays_and_back def bincount(x, /, weights=None, minlength=0): return ivy.bincount(x, weights=weights, minlength=minlength) From 4ea435f259ebc576a11c440aede9a6a5b7e9ae0f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 4 Jan 2024 15:21:39 +0000 Subject: [PATCH 496/978] fix: specify bool and integers as unsupported for torch frontend std function --- ivy/functional/frontends/torch/reduction_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 075391faf74f4..c512e35d6e917 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -301,7 +301,7 @@ def quantile(input, q, dim=None, keepdim=False, *, interpolation="linear", out=N @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bool", "integer")}, "torch") def std(input, dim=None, unbiased=True, keepdim=False, *, out=None): return ivy.std(input, axis=dim, correction=int(unbiased), keepdims=keepdim, out=out) From fbc12111ab98ba3e69dd1db7726208b0fdf0ccac Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 4 Jan 2024 15:30:02 +0000 Subject: [PATCH 497/978] fix: update container.clip method's signature to match with ivy.clip and avoid discrepancies --- ivy/data_classes/container/manipulation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/data_classes/container/manipulation.py b/ivy/data_classes/container/manipulation.py index 94e1ba3658401..2b22319bacb04 100644 --- a/ivy/data_classes/container/manipulation.py +++ b/ivy/data_classes/container/manipulation.py @@ -2287,13 +2287,13 @@ def _static_clip( def clip( self: ivy.Container, + /, x_min: Optional[ Union[Number, ivy.Array, ivy.NativeArray, ivy.Container] ] = None, x_max: Optional[ Union[Number, ivy.Array, ivy.NativeArray, ivy.Container] ] = None, - /, *, key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, to_apply: Union[bool, ivy.Container] = True, From 92d41348ab05256e08bbd89edab404b47cd2576e Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 4 Jan 2024 21:47:42 +0530 Subject: [PATCH 498/978] fix: Fixed passing of missing `shape` argument in 1 function call (#27836) --- ivy/functional/frontends/paddle/tensor/tensor.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 60daa04eb2967..95ac52b70ee27 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -301,9 +301,8 @@ def reshape_(self, *args, shape=None): self._ivy_array, args ).ivy_array return self - - self.ivy_array = paddle_frontend.reshape(self._ivy_array).ivy_array - return self + else: + raise ValueError("reshape_() got no values for argument 'shape'") def dim(self): return self.ivy_array.ndim From e12cd4744ca6bc87a82265df1e970a4df79dfa2e Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Thu, 4 Jan 2024 17:24:14 +0000 Subject: [PATCH 499/978] chore: Modify the fill_ and zero_ frontend torch methods to use ivy.inplace_update explicitly --- ivy/functional/frontends/torch/tensor.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index bc1c9536cc07a..86dd7263f24b1 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1455,9 +1455,10 @@ def reciprocal(self): return torch_frontend.reciprocal(self) def fill_(self, value): - self.ivy_array = torch_frontend.full_like( + ret = torch_frontend.full_like( self, value, dtype=self.dtype, device=self.device - ).ivy_array + ) + self.ivy_array = ivy.inplace_update(self.ivy_array, ret) return self def nonzero(self, as_tuple=False): @@ -1502,7 +1503,8 @@ def log10_(self): @with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, "torch") def zero_(self): - self.ivy_array = torch_frontend.zeros_like(self).ivy_array + ret = torch_frontend.zeros_like(self) + self.ivy_array = ivy.inplace_update(self.ivy_array, ret) return self def short(self, memory_format=None): From 0c486eefd9eef0dbdb3789a0dd9df01a41e9f6c4 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 4 Jan 2024 20:33:13 +0000 Subject: [PATCH 500/978] fix: pass input_dtypes correctly from all valid types for test_torch_corrcoef and specify unsupported types --- ivy/functional/frontends/torch/miscellaneous_ops.py | 1 + ivy/functional/ivy/experimental/statistical.py | 2 +- .../test_frontends/test_torch/test_miscellaneous_ops.py | 4 ++-- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 7bd69abad45d5..b38ee9bde458c 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -137,6 +137,7 @@ def clone(input, *, memory_format=None): return ivy.copy_array(input) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bool")}, "torch") @to_ivy_arrays_and_back def corrcoef(input): if len(ivy.shape(input)) > 2: diff --git a/ivy/functional/ivy/experimental/statistical.py b/ivy/functional/ivy/experimental/statistical.py index 756f066c02ecb..bf69d12cd5cf2 100644 --- a/ivy/functional/ivy/experimental/statistical.py +++ b/ivy/functional/ivy/experimental/statistical.py @@ -478,7 +478,7 @@ def corrcoef( rowvar: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - return ivy.current_backend().corrcoef(x, y=y, rowvar=rowvar, out=out) + return ivy.current_backend(x).corrcoef(x, y=y, rowvar=rowvar, out=out) @handle_exceptions diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index d0e35c7d98f6b..03d370b1f20fb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -587,7 +587,7 @@ def test_torch_clone( @handle_frontend_test( fn_tree="torch.corrcoef", dtypes_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), + available_dtypes=helpers.get_dtypes("valid"), num_arrays=1, min_num_dims=2, max_num_dims=2, @@ -607,7 +607,7 @@ def test_torch_corrcoef( ): input_dtypes, x = dtypes_and_x helpers.test_frontend_function( - input_dtypes=["float64"], + input_dtypes=input_dtypes, frontend=frontend, fn_tree=fn_tree, test_flags=test_flags, From 360922279285e31f4dc5bf5dcd1c802068bbfdfa Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 4 Jan 2024 20:51:26 +0000 Subject: [PATCH 501/978] fix: update `test_frontend_function` to avoid failures based on the fact that it can't change requires_grad for non leaf variables fixes several tests like flip, flipud, clone etc. for torch frontend. --- ivy_tests/test_ivy/helpers/function_testing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index c86ac233d22e8..e58c0d329b3a2 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -932,7 +932,7 @@ def test_frontend_function( first_array = first_array.data ret_ = ret_.data if hasattr(first_array, "requires_grad"): - first_array.requires_grad = False + first_array = first_array.detach() assert not np.may_share_memory(first_array, ret_) elif test_flags.inplace: assert _is_frontend_array(ret) From b59d1ee6ecd92919121a5d2812f179c995fd064c Mon Sep 17 00:00:00 2001 From: Jeff Simpson Date: Thu, 4 Jan 2024 17:50:28 -0500 Subject: [PATCH 502/978] fix: use plural reviewers actor type for Vaunt (#27843) --- .vaunt/config.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.vaunt/config.yaml b/.vaunt/config.yaml index 2022b8e133301..99840afc3069e 100644 --- a/.vaunt/config.yaml +++ b/.vaunt/config.yaml @@ -47,7 +47,7 @@ achievements: description: Awarded for reviewing pull requests. triggers: - trigger: - actor: reviewer + actor: reviewers action: pull_request condition: count(created_at >= "2023-12-26" & merged = true) >= 1 @@ -97,7 +97,7 @@ achievements: description: Awarded for reviewing 5 pull requests. triggers: - trigger: - actor: reviewer + actor: reviewers action: pull_request condition: count(created_at >= "2023-12-26" & merged = true) >= 5 @@ -147,7 +147,7 @@ achievements: description: Awarded for reviewing 15 pull requests. triggers: - trigger: - actor: reviewer + actor: reviewers action: pull_request condition: count(created_at >= "2023-12-26" & merged = true) >= 15 @@ -197,6 +197,6 @@ achievements: description: Awarded for reviewing 30 pull requests. triggers: - trigger: - actor: reviewer + actor: reviewers action: pull_request condition: count(created_at >= "2023-12-26" & merged = true) >= 30 From d755ad4e7897e44e98bd81506f994ae6fdfa453d Mon Sep 17 00:00:00 2001 From: JG <67888047+juliagsy@users.noreply.github.com> Date: Fri, 5 Jan 2024 10:15:51 +0000 Subject: [PATCH 503/978] updated traced_if_required for fixing test_trace exiting issue (#27802) Co-authored-by: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> --- .../test_ivy/helpers/function_testing.py | 40 +++++++++++++++++-- ivy_tests/test_ivy/helpers/globals.py | 1 + 2 files changed, 37 insertions(+), 4 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index e58c0d329b3a2..6a824827a19d0 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -38,7 +38,35 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=None): with BackendHandler.update_backend(backend) as ivy_backend: if test_trace: - fn = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs) + try: + if ( + t_globals.CURRENT_RUNNING_TEST.fn_name + in t_globals.CURRENT_TRACED_DATA + and backend + not in t_globals.CURRENT_TRACED_DATA[ + t_globals.CURRENT_RUNNING_TEST.fn_name + ] + ): + t_globals.CURRENT_TRACED_DATA[ + t_globals.CURRENT_RUNNING_TEST.fn_name + ][backend] = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs) + elif ( + t_globals.CURRENT_RUNNING_TEST.fn_name + not in t_globals.CURRENT_TRACED_DATA + ): + t_globals.CURRENT_TRACED_DATA[ + t_globals.CURRENT_RUNNING_TEST.fn_name + ] = {} + t_globals.CURRENT_TRACED_DATA[ + t_globals.CURRENT_RUNNING_TEST.fn_name + ][backend] = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs) + fn = t_globals.CURRENT_TRACED_DATA[ + t_globals.CURRENT_RUNNING_TEST.fn_name + ][backend] + except Exception: + import logging + + logging.warn("API key is invalid, test_trace is skipped.") return fn @@ -637,9 +665,13 @@ def test_function( backend=backend_to_test, ground_truth_backend=test_flags.ground_truth_backend, ) - assert_same_type( - ret_from_target, ret_from_gt, backend_to_test, test_flags.ground_truth_backend - ) + if not test_flags.test_trace: + assert_same_type( + ret_from_target, + ret_from_gt, + backend_to_test, + test_flags.ground_truth_backend, + ) assert ret_device == ret_from_gt_device, ( f"ground truth backend ({test_flags.ground_truth_backend}) returned array on" diff --git a/ivy_tests/test_ivy/helpers/globals.py b/ivy_tests/test_ivy/helpers/globals.py index 02d2f16d2b122..d1a4fb6e83791 100644 --- a/ivy_tests/test_ivy/helpers/globals.py +++ b/ivy_tests/test_ivy/helpers/globals.py @@ -46,6 +46,7 @@ CURRENT_DEVICE = _Notsetval CURRENT_DEVICE_STRIPPED = _Notsetval CURRENT_FRONTEND_STR = None +CURRENT_TRACED_DATA = {} @dataclass(frozen=True) # ToDo use kw_only=True when version is updated From 4e6be3a3d76d3a882e82636f8565d3f0fee3a8dc Mon Sep 17 00:00:00 2001 From: yopknopixx <30761130+yopknopixx@users.noreply.github.com> Date: Fri, 5 Jan 2024 16:56:14 +0530 Subject: [PATCH 504/978] feat(framework): add cython wrappers mode (#27770) Co-authored-by: ivy-branch --- .gitignore | 1 + ivy/__init__.py | 42 +++- ivy/func_wrapper.py | 29 +++ ivy/utils/_importlib.py | 2 +- ivy/utils/backend/handler.py | 1 - ivy/wrappers/__init__.py | 29 +++ ivy/wrappers/utils.py | 54 +++++ ivy_tests/test_ivy/conftest.py | 6 + .../test_ivy/helpers/function_testing.py | 5 + ivy_tests/test_ivy/helpers/pipeline_helper.py | 5 +- .../test_ivy/helpers/test_parameter_flags.py | 6 + ivy_tests/test_ivy/helpers/testing_helpers.py | 3 + wrappers.json | 200 ++++++++++++++++++ 13 files changed, 375 insertions(+), 8 deletions(-) create mode 100644 ivy/wrappers/__init__.py create mode 100644 ivy/wrappers/utils.py create mode 100644 wrappers.json diff --git a/.gitignore b/.gitignore index 44004a0156e8c..9d225dc28b7ff 100644 --- a/.gitignore +++ b/.gitignore @@ -21,6 +21,7 @@ with_time_logs/ *.jpg *.jpeg *.gif +*.so .hypothesis .array_api_tests_k_flag* internal_automation_tools/ diff --git a/ivy/__init__.py b/ivy/__init__.py index 14b89bbe65615..620bc5860fbd5 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -591,7 +591,7 @@ class Node(str): nan_policy_stack = [] dynamic_backend_stack = [] warn_to_regex = {"all": "!.*", "ivy_only": "^(?!.*ivy).*$", "none": ".*"} - +cython_wrappers_stack = [] # local import threading @@ -741,7 +741,7 @@ class Node(str): locks = {"backend_setter": threading.Lock()} - +from .wrappers import * from .func_wrapper import * from .data_classes.array import Array, add_ivy_array_instance_methods from .data_classes.array.conversions import * @@ -776,6 +776,7 @@ class Node(str): choose_random_backend, unset_backend, ) +from . import wrappers from . import func_wrapper from .utils import assertions, exceptions, verbosity from .utils.backend import handler @@ -961,6 +962,7 @@ def __deepcopy__(self, memo): "default_uint_dtype_stack": data_type.default_uint_dtype_stack, "nan_policy_stack": nan_policy_stack, "dynamic_backend_stack": dynamic_backend_stack, + "cython_wrappers_stack": cython_wrappers_stack, }) _default_globals = copy.deepcopy(globals_vars) @@ -1144,7 +1146,7 @@ def unset_nan_policy(): ivy.dynamic_backend = dynamic_backend_stack[-1] if dynamic_backend_stack else True -def set_dynamic_backend(flag): +def set_dynamic_backend(flag): # noqa: D209 """Set the global dynamic backend setting to the provided flag (True or False)""" global dynamic_backend_stack @@ -1166,6 +1168,37 @@ def unset_dynamic_backend(): ivy.__setattr__("dynamic_backend", flag, True) +# Cython wrappers + +ivy.cython_wrappers_mode = cython_wrappers_stack[-1] if cython_wrappers_stack else False + + +@handle_exceptions +def set_cython_wrappers_mode(flag: bool = True) -> None: + """Set the mode of whether to use cython wrappers for functions. + + Parameter + --------- + flag + boolean whether to use cython wrappers for functions + + Examples + -------- + >>> ivy.set_cython_wrappers_mode(False) + >>> ivy.cython_wrappers_mode + False + + >>> ivy.set_cython_wrappers_mode(True) + >>> ivy.cython_wrappers_mode + True + """ + global cython_wrappers_stack + if flag not in [True, False]: + raise ValueError("cython_wrappers_mode must be a boolean value (True or False)") + cython_wrappers_stack.append(flag) + ivy.__setattr__("cython_wrappers_mode", flag, True) + + # Context Managers @@ -1438,6 +1471,7 @@ def cast_data_types(val=True): "default_int_dtype", "default_complex_dtype", "default_uint_dtype", + "cython_wrappers_mode", ] @@ -1479,7 +1513,7 @@ def set_logging_mode(self, mode): logging.getLogger().setLevel(mode) self.logging_mode_stack.append(mode) - def unset_logging_mode(self): + def unset_logging_mode(self): # noqa: D209 """Remove the most recently set logging mode, returning to the previous one.""" if len(self.logging_mode_stack) > 1: diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index 006bd4e8a7e41..6f3b991d81d73 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -1002,6 +1002,29 @@ def _to_ivy_array(x): return _temp_asarray_wrapper +# Download compiled cython wrapper wrapper + + +def download_cython_wrapper_wrapper(fn: Callable) -> Callable: + @functools.wraps(fn) + def _download_cython_wrapper_wrapper(*args, **kwargs): + """Wrap the function to download compiled cython wrapper for the + function and re-wraps it with the downloaded wrapper. + + Download the compiled cython wrapper by calling + ivy.wrappers.get_wrapper(func_name: str) and then wrap the + function with the downloaded wrapper. + """ + ivy.wrappers.download_cython_wrapper(fn.__name__) + ivy.wrappers.load_one_wrapper(fn.__name__) + ivy.functional.__dict__[fn.__name__] = getattr( + ivy.wrappers, fn.__name__ + "_wrapper" + )(fn) + return ivy.functional.__dict__[fn.__name__](*args, **kwargs) + + return _download_cython_wrapper_wrapper + + # Functions # @@ -1046,6 +1069,12 @@ def _wrap_function( ) return to_wrap if isinstance(to_wrap, FunctionType): + if ivy.cython_wrappers_mode and ivy.wrappers.wrapper_exists(to_wrap.__name__): + if to_wrap.__name__ + "_wrapper" in ivy.wrappers.__all__: + to_wrap = getattr(ivy.wrappers, to_wrap.__name__ + "_wrapper")(to_wrap) + return to_wrap + else: + return download_cython_wrapper_wrapper(to_wrap) # set attributes for attr in original.__dict__.keys(): # private attribute or decorator diff --git a/ivy/utils/_importlib.py b/ivy/utils/_importlib.py index 13503024aff14..01247a3bd719f 100644 --- a/ivy/utils/_importlib.py +++ b/ivy/utils/_importlib.py @@ -12,7 +12,7 @@ # expected. Import these modules along with Ivy initialization, as the import logic # assumes they exist in sys.modules. -MODULES_TO_SKIP = ["ivy.compiler", "ivy.engines"] +MODULES_TO_SKIP = ["ivy.compiler", "ivy.engines", "ivy.wrappers"] IS_COMPILING_WITH_BACKEND = False diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 282d5beb047dc..04974f0557488 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -358,7 +358,6 @@ def set_backend(backend: str, dynamic: bool = False): global ivy_original_dict if not backend_stack: ivy_original_dict = ivy.__dict__.copy() - _clear_current_sub_backends() if isinstance(backend, str): temp_stack = [] diff --git a/ivy/wrappers/__init__.py b/ivy/wrappers/__init__.py new file mode 100644 index 0000000000000..880046091c527 --- /dev/null +++ b/ivy/wrappers/__init__.py @@ -0,0 +1,29 @@ +import os +import sys +import glob +import importlib + +dir_path = os.path.dirname(os.path.realpath(__file__)) +so_files = glob.glob(dir_path + "/*.so") +sys.path.append(dir_path) + +__all__ = [] + +for so_file in so_files: + # if os.path.basename(so_file) != "add.so": + # continue + module_name = os.path.splitext(os.path.basename(so_file))[0] + + locals()[module_name] = importlib.import_module(module_name) + + if module_name + "_wrapper" in locals()[module_name].__dict__.keys(): + locals()[module_name + "_wrapper"] = getattr( + locals()[module_name], module_name + "_wrapper" + ) + __all__.append(module_name + "_wrapper") + +del dir_path +del so_files + +import utils +from utils import * diff --git a/ivy/wrappers/utils.py b/ivy/wrappers/utils.py new file mode 100644 index 0000000000000..0d64041a96c9a --- /dev/null +++ b/ivy/wrappers/utils.py @@ -0,0 +1,54 @@ +import os +import logging +import json +from urllib import request +import importlib +import ivy + +folder_path = os.sep.join(__file__.split(os.sep)[:-3]) +wrappers_path = os.path.join(folder_path, "wrappers.json") +wrappers = json.loads(open(wrappers_path).read()) +wrapers_dir = os.path.join(folder_path, "ivy/wrappers") + + +def download_cython_wrapper(func_name: str): + """Get the wrapper for the given function name.""" + if func_name + ".so" not in wrappers["ivy"]["functional"]: + logging.warn(f"Wrapper for {func_name} not found.") + return False + try: + response = request.urlopen( + "https://raw.githubusercontent.com/unifyai" + + "/binaries/cython_wrappers/wrappers/" + + func_name + + ".so" + ) + os.makedirs(wrapers_dir, exist_ok=True) + with open(os.path.join(wrapers_dir, func_name + ".so"), "wb") as f: + f.write(response.read()) + print("Downloaded wrapper for " + func_name) + return True + except request.HTTPError: + logging.warn(f"Unable to download wrapper for {func_name}.") + return False + + +def wrapper_exists(func_name: str): + """Check if the wrapper for the given function name exists.""" + return func_name + ".so" in wrappers["ivy"]["functional"] + + +def load_one_wrapper(func_name: str): + """Load the wrapper for the given function name.""" + module_name = func_name + dir_path = os.path.dirname(os.path.realpath(__file__)) + # check if file exists + if os.path.isfile(os.path.join(dir_path, module_name + ".so")): + ivy.wrappers.__dict__[module_name] = importlib.import_module(module_name) + ivy.wrappers.__dict__[module_name + "_wrapper"] = getattr( + ivy.wrappers.__dict__[module_name], module_name + "_wrapper" + ) + ivy.wrappers.__all__.append(module_name + "_wrapper") + return True + else: + return False diff --git a/ivy_tests/test_ivy/conftest.py b/ivy_tests/test_ivy/conftest.py index 06b4054ff086f..3501bdbf4dc01 100644 --- a/ivy_tests/test_ivy/conftest.py +++ b/ivy_tests/test_ivy/conftest.py @@ -292,6 +292,10 @@ def process_cl_flags(config) -> Dict[str, bool]: False, getopt("--with-transpile"), ), + "test_cython_wrapper": ( + getopt("--skip-cython-wrapper-testing"), + getopt("--with-cython-wrapper-testing"), + ), } # whether to skip gt testing or not @@ -358,6 +362,8 @@ def pytest_addoption(parser): default=None, help="Print test items in my custom format", ) + parser.addoption("--skip-cython-wrapper-testing", action="store_true") + parser.addoption("--with-cython-wrapper-testing", action="store_true") def pytest_collection_finish(session): diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 6a824827a19d0..ae7abf618aed0 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -154,6 +154,11 @@ def test_function_backend_computation( test_flags.container[0] for _ in range(total_num_arrays) ] + if test_flags.test_cython_wrapper: + ivy.set_cython_wrappers_mode(True) + else: + ivy.set_cython_wrappers_mode(False) + with BackendHandler.update_backend(fw) as ivy_backend: # Update variable flags to be compatible with float dtype and with_out args test_flags.as_variable = [ diff --git a/ivy_tests/test_ivy/helpers/pipeline_helper.py b/ivy_tests/test_ivy/helpers/pipeline_helper.py index f704ab4cd171d..361177808f3b9 100644 --- a/ivy_tests/test_ivy/helpers/pipeline_helper.py +++ b/ivy_tests/test_ivy/helpers/pipeline_helper.py @@ -11,11 +11,12 @@ class BackendHandlerMode(Enum): class WithBackendContext: - def __init__(self, backend) -> None: + def __init__(self, backend, cached=True) -> None: self.backend = backend + self.cached = cached def __enter__(self): - return ivy.with_backend(self.backend) + return ivy.with_backend(self.backend, cached=self.cached) def __exit__(self, exc_type, exc_val, exc_tb): return diff --git a/ivy_tests/test_ivy/helpers/test_parameter_flags.py b/ivy_tests/test_ivy/helpers/test_parameter_flags.py index e123f1764db31..d3429718636d6 100644 --- a/ivy_tests/test_ivy/helpers/test_parameter_flags.py +++ b/ivy_tests/test_ivy/helpers/test_parameter_flags.py @@ -48,6 +48,7 @@ def _as_varaible_strategy(draw): BuiltFrontendArrayStrategy = DynamicFlag(st.booleans()) BuiltTranspileStrategy = DynamicFlag(st.just(False)) BuiltPrecisionModeStrategy = DynamicFlag(st.booleans()) +BuiltCythonWrapperStrategy = DynamicFlag(st.just(False)) flags_mapping = { @@ -62,6 +63,7 @@ def _as_varaible_strategy(draw): "test_trace": "BuiltTraceStrategy", "transpile": "BuiltTranspileStrategy", "precision_mode": "BuiltPrecisionModeStrategy", + "test_cython_wrapper": "BuiltCythonWrapperStrategy", } @@ -98,6 +100,7 @@ def __init__( test_trace, transpile, precision_mode, + test_cython_wrapper, ): self.ground_truth_backend = ground_truth_backend self.num_positional_args = num_positional_args @@ -111,6 +114,7 @@ def __init__( self.test_trace = test_trace self.transpile = transpile self.precision_mode = precision_mode + self.test_cython_wrapper = test_cython_wrapper def apply_flags(self, args_to_iterate, input_dtypes, offset, *, backend, on_device): ret = [] @@ -162,6 +166,7 @@ def function_flags( native_arrays, container_flags, precision_mode, + test_cython_wrapper, ): return draw( st.builds( @@ -178,6 +183,7 @@ def function_flags( native_arrays=native_arrays, container=container_flags, precision_mode=precision_mode, + test_cython_wrapper=test_cython_wrapper, ) ) diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index 1628eb85cd84d..6c76e6e9f645a 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -30,6 +30,7 @@ BuiltFrontendArrayStrategy, BuiltTranspileStrategy, BuiltPrecisionModeStrategy, + BuiltCythonWrapperStrategy, ) from ivy_tests.test_ivy.helpers.structs import FrontendMethodData from ivy_tests.test_ivy.helpers.available_frameworks import available_frameworks @@ -337,6 +338,7 @@ def handle_test( as_variable_flags=BuiltAsVariableStrategy, native_array_flags=BuiltNativeArrayStrategy, container_flags=BuiltContainerStrategy, + test_cython_wrapper=BuiltCythonWrapperStrategy, **_given_kwargs, ): """Test wrapper for Ivy functions. @@ -414,6 +416,7 @@ def handle_test( native_arrays=_get_runtime_flag_value(native_array_flags), container_flags=_get_runtime_flag_value(container_flags), precision_mode=_get_runtime_flag_value(precision_mode), + test_cython_wrapper=_get_runtime_flag_value(test_cython_wrapper), ) def test_wrapper(test_fn): diff --git a/wrappers.json b/wrappers.json new file mode 100644 index 0000000000000..fea73ecbb96e4 --- /dev/null +++ b/wrappers.json @@ -0,0 +1,200 @@ +{ + "ivy": { + "functional": ["negative.so", + "bitwise_xor.so", + "vander.so", + "std.so", + "atanh.so", + "argmin.so", + "asinh.so", + "squeeze.so", + "square.so", + "matrix_norm.so", + "not_equal.so", + "log.so", + "expand_dims.so", + "divide.so", + "min.so", + "unique_counts.so", + "vector_norm.so", + "matrix_rank.so", + "equal.so", + "expm1.so", + "sigmoid.so", + "adam_update.so", + "cumsum.so", + "lars_update.so", + "isinf.so", + "pinv.so", + "deg2rad.so", + "var.so", + "pow.so", + "random_uniform.so", + "trapz.so", + "adam_step.so", + "tile.so", + "tan.so", + "sparse_cross_entropy.so", + "det.so", + "round.so", + "acos.so", + "matrix_power.so", + "while_loop.so", + "cross.so", + "trunc.so", + "jac.so", + "sqrt.so", + "bitwise_left_shift.so", + "atan.so", + "clip.so", + "conv2d_transpose.so", + "exp2.so", + "less.so", + "conv2d.so", + "einsum.so", + "searchsorted.so", + "floor.so", + "cross_entropy.so", + "seed.so", + "scaled_dot_product_attention.so", + "bitwise_and.so", + "logaddexp2.so", + "optimizer_update.so", + "mish.so", + "mean.so", + "argsort.so", + "eigh.so", + "svd.so", + "cumprod.so", + "eigvalsh.so", + "asin.so", + "random_normal.so", + "try_except.so", + "split.so", + "log_softmax.so", + "nan_to_num.so", + "cmp_isnot.so", + "matrix_transpose.so", + "diag.so", + "remainder.so", + "sinh.so", + "bitwise_or.so", + "softplus.so", + "flip.so", + "conv_general_transpose.so", + "shuffle.so", + "roi_align.so", + "log1p.so", + "tensordot.so", + "zero_pad.so", + "logical_xor.so", + "inv.so", + "softmax.so", + "greater.so", + "logical_not.so", + "conv1d.so", + "vecdot.so", + "multi_head_attention.so", + "diagonal.so", + "isnan.so", + "inner.so", + "bitwise_invert.so", + "slogdet.so", + "tensorsolve.so", + "value_and_grad.so", + "depthwise_conv2d.so", + "trunc_divide.so", + "erf.so", + "svdvals.so", + "reshape.so", + "constant_pad.so", + "unique_all.so", + "qr.so", + "isfinite.so", + "logical_and.so", + "if_else.so", + "nonzero.so", + "tanh.so", + "conv.so", + "add.so", + "subtract.so", + "argmax.so", + "maximum.so", + "real.so", + "msort.so", + "fmin.so", + "abs.so", + "lstm_update.so", + "permute_dims.so", + "lamb_update.so", + "swapaxes.so", + "cosh.so", + "log10.so", + "bitwise_right_shift.so", + "for_loop.so", + "imag.so", + "dropout.so", + "where.so", + "roll.so", + "leaky_relu.so", + "fmod.so", + "randint.so", + "logical_or.so", + "relu.so", + "binary_cross_entropy.so", + "unique_values.so", + "linear.so", + "sin.so", + "vector_to_skew_symmetric_matrix.so", + "closest_valid_dtype.so", + "atan2.so", + "stack.so", + "max.so", + "sign.so", + "exp.so", + "cholesky.so", + "ceil.so", + "cmp_is.so", + "repeat.so", + "gelu.so", + "reciprocal.so", + "unstack.so", + "conv1d_transpose.so", + "less_equal.so", + "stop_gradient.so", + "angle.so", + "matmul.so", + "cos.so", + "execute_with_gradients.so", + "gradient_descent_update.so", + "softsign.so", + "unique_inverse.so", + "solve.so", + "sum.so", + "argwhere.so", + "greater_equal.so", + "outer.so", + "rad2deg.so", + "floor_divide.so", + "conv_general_dilated.so", + "logaddexp.so", + "concat.so", + "positive.so", + "minimum.so", + "log2.so", + "lcm.so", + "acosh.so", + "conv3d_transpose.so", + "multinomial.so", + "lu_factor.so", + "layer_norm.so", + "eig.so", + "conv3d.so", + "sort.so", + "isreal.so", + "multiply.so", + "gcd.so", + "grad.so", + "prod.so"] + } +} From 8142a86184fa524917d5df5737cde4705b2d2a1f Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Sat, 6 Jan 2024 01:07:49 +0530 Subject: [PATCH 505/978] fix: fixed the failing test at paddle backend (#27827) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/elementwise.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 563ff86695c00..735034e9ac3de 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -841,8 +841,9 @@ def trapz( return ret -@with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version +@with_supported_device_and_dtypes( + {"2.5.2 and below": {"cpu": ("float32", "float64", "int32", "int64", "complex")}}, + backend_version, ) def abs( x: Union[float, paddle.Tensor], From b198353ec908d1ab5e818adf8ebb3cee87224166 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Sat, 6 Jan 2024 01:09:46 +0530 Subject: [PATCH 506/978] fix: fixed tests not passing on torch and jax backend (#27845) Co-authored-by: NripeshN --- ivy/functional/backends/jax/elementwise.py | 3 +++ ivy/functional/backends/torch/elementwise.py | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index 8da329110a6d5..64ecb5e891bda 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -514,6 +514,9 @@ def trapz( return jnp.trapz(y, x=x, dx=dx, axis=axis) +@with_unsupported_dtypes( + {"0.4.23 and below": ("complex", "float16", "bfloat16")}, backend_version +) def tan(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.tan(x) diff --git a/ivy/functional/backends/torch/elementwise.py b/ivy/functional/backends/torch/elementwise.py index fd95b2089f6a3..a10cac96704db 100644 --- a/ivy/functional/backends/torch/elementwise.py +++ b/ivy/functional/backends/torch/elementwise.py @@ -723,7 +723,7 @@ def logaddexp2( logaddexp2.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) @handle_numpy_arrays_in_specific_backend def tan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) From 3243991503a185c91d6bd8d71815533adcc492eb Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Sat, 6 Jan 2024 01:32:42 +0530 Subject: [PATCH 507/978] fix: fixed tests not passing at jax backend (#27847) Co-authored-by: NripeshN --- ivy/functional/backends/jax/elementwise.py | 1 + .../test_ivy/test_functional/test_core/test_elementwise.py | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index 64ecb5e891bda..62ac7a5fa5c6d 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -68,6 +68,7 @@ def atan2(x1: JaxArray, x2: JaxArray, /, *, out: Optional[JaxArray] = None) -> J return jnp.arctan2(x1, x2) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def atanh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arctanh(x) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 89071dec7917e..df93ccd30e631 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -390,7 +390,9 @@ def test_atan2(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.atanh", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float_and_complex") + min_value=1e-30, + max_value=1e30, + available_dtypes=helpers.get_dtypes("float_and_complex"), ), ) def test_atanh(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): From 8405f2ba95d8721300219b347ab7d9fb8fbb0237 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sat, 6 Jan 2024 00:13:49 +0400 Subject: [PATCH 508/978] fix: pre-commit docsformatting (#27848) --- ivy/__init__.py | 27 +- ivy/compiler/compiler.py | 10 +- ivy/compiler/replace_with.py | 9 +- ivy/data_classes/array/activations.py | 55 +- ivy/data_classes/array/array.py | 126 +- ivy/data_classes/array/conversions.py | 44 +- ivy/data_classes/array/creation.py | 91 +- ivy/data_classes/array/data_type.py | 54 +- ivy/data_classes/array/device.py | 14 +- ivy/data_classes/array/elementwise.py | 520 +++++---- .../array/experimental/activations.py | 93 +- .../array/experimental/creation.py | 55 +- .../array/experimental/elementwise.py | 197 ++-- .../array/experimental/general.py | 7 +- ivy/data_classes/array/experimental/layers.py | 113 +- .../array/experimental/linear_algebra.py | 166 +-- ivy/data_classes/array/experimental/losses.py | 52 +- .../array/experimental/manipulation.py | 218 ++-- ivy/data_classes/array/experimental/norms.py | 30 +- ivy/data_classes/array/experimental/random.py | 21 +- .../array/experimental/searching.py | 7 +- .../array/experimental/sorting.py | 7 +- .../array/experimental/statistical.py | 91 +- .../array/experimental/utility.py | 9 +- ivy/data_classes/array/general.py | 227 ++-- ivy/data_classes/array/gradients.py | 50 +- ivy/data_classes/array/layers.py | 102 +- ivy/data_classes/array/linear_algebra.py | 116 +- ivy/data_classes/array/losses.py | 23 +- ivy/data_classes/array/manipulation.py | 112 +- ivy/data_classes/array/norms.py | 7 +- ivy/data_classes/array/random.py | 35 +- ivy/data_classes/array/searching.py | 35 +- ivy/data_classes/array/set.py | 21 +- ivy/data_classes/array/sorting.py | 24 +- ivy/data_classes/array/statistical.py | 59 +- ivy/data_classes/array/utility.py | 14 +- ivy/data_classes/array/wrapping.py | 13 +- ivy/data_classes/container/activations.py | 126 +- ivy/data_classes/container/base.py | 356 +++--- ivy/data_classes/container/container.py | 95 +- ivy/data_classes/container/conversions.py | 15 +- ivy/data_classes/container/creation.py | 91 +- ivy/data_classes/container/data_type.py | 117 +- ivy/data_classes/container/device.py | 28 +- ivy/data_classes/container/elementwise.py | 1040 ++++++++++------- .../container/experimental/activations.py | 184 +-- .../container/experimental/creation.py | 171 +-- .../container/experimental/elementwise.py | 373 +++--- .../container/experimental/general.py | 14 +- .../container/experimental/layers.py | 237 ++-- .../container/experimental/linear_algebra.py | 299 ++--- .../container/experimental/losses.py | 114 +- .../container/experimental/manipulation.py | 407 ++++--- .../container/experimental/norms.py | 84 +- .../container/experimental/random.py | 56 +- .../container/experimental/searching.py | 14 +- .../container/experimental/sorting.py | 20 +- .../container/experimental/statistical.py | 182 +-- .../container/experimental/utility.py | 16 +- ivy/data_classes/container/general.py | 430 ++++--- ivy/data_classes/container/gradients.py | 52 +- ivy/data_classes/container/layers.py | 200 ++-- ivy/data_classes/container/linear_algebra.py | 261 +++-- ivy/data_classes/container/losses.py | 46 +- ivy/data_classes/container/manipulation.py | 216 ++-- ivy/data_classes/container/norms.py | 7 +- ivy/data_classes/container/random.py | 70 +- ivy/data_classes/container/searching.py | 70 +- ivy/data_classes/container/set.py | 47 +- ivy/data_classes/container/sorting.py | 48 +- ivy/data_classes/container/statistical.py | 91 +- ivy/data_classes/container/utility.py | 28 +- ivy/data_classes/container/wrapping.py | 8 +- .../factorized_tensor/cp_tensor.py | 54 +- .../factorized_tensor/parafac2_tensor.py | 34 +- .../factorized_tensor/tt_tensor.py | 25 +- ivy/func_wrapper.py | 121 +- ivy/functional/backends/jax/activations.py | 3 +- ivy/functional/backends/jax/device.py | 3 +- ivy/functional/backends/jax/general.py | 3 +- ivy/functional/backends/jax/gradients.py | 3 +- ivy/functional/backends/jax/layers.py | 3 +- ivy/functional/backends/jax/random.py | 3 +- ivy/functional/backends/mxnet/activations.py | 3 +- ivy/functional/backends/mxnet/device.py | 3 +- ivy/functional/backends/mxnet/gradients.py | 3 +- ivy/functional/backends/mxnet/layers.py | 3 +- ivy/functional/backends/mxnet/random.py | 3 +- ivy/functional/backends/numpy/activations.py | 3 +- ivy/functional/backends/numpy/device.py | 3 +- ivy/functional/backends/numpy/general.py | 3 +- ivy/functional/backends/numpy/gradients.py | 3 +- ivy/functional/backends/numpy/helpers.py | 3 +- ivy/functional/backends/numpy/layers.py | 3 +- ivy/functional/backends/numpy/random.py | 3 +- ivy/functional/backends/paddle/activations.py | 3 +- ivy/functional/backends/paddle/device.py | 3 +- .../paddle/experimental/elementwise.py | 3 +- ivy/functional/backends/paddle/general.py | 3 +- ivy/functional/backends/paddle/gradients.py | 3 +- ivy/functional/backends/paddle/layers.py | 3 +- ivy/functional/backends/paddle/random.py | 3 +- .../backends/tensorflow/activations.py | 3 +- ivy/functional/backends/tensorflow/device.py | 3 +- ivy/functional/backends/tensorflow/general.py | 3 +- .../backends/tensorflow/gradients.py | 3 +- ivy/functional/backends/tensorflow/layers.py | 3 +- ivy/functional/backends/tensorflow/random.py | 3 +- .../experimental/statistical.py | 5 +- ivy/functional/backends/torch/activations.py | 3 +- ivy/functional/backends/torch/device.py | 3 +- ivy/functional/backends/torch/general.py | 3 +- ivy/functional/backends/torch/gradients.py | 3 +- ivy/functional/backends/torch/layers.py | 3 +- ivy/functional/backends/torch/random.py | 3 +- .../frontends/jax/numpy/__init__.py | 9 +- .../mindspore/ops/function/nn_func.py | 4 +- .../frontends/mxnet/func_wrapper.py | 9 +- .../frontends/mxnet/numpy/__init__.py | 9 +- ivy/functional/frontends/numpy/__init__.py | 5 +- .../frontends/numpy/func_wrapper.py | 28 +- .../numpy/statistics/order_statistics.py | 3 +- ivy/functional/frontends/onnx/__init__.py | 9 +- ivy/functional/frontends/onnx/func_wrapper.py | 9 +- ivy/functional/frontends/paddle/__init__.py | 9 +- ivy/functional/frontends/paddle/fft.py | 4 +- .../frontends/paddle/func_wrapper.py | 9 +- .../frontends/tensorflow/__init__.py | 7 +- .../frontends/tensorflow/func_wrapper.py | 23 +- .../frontends/tensorflow/variable.py | 6 +- ivy/functional/frontends/torch/__init__.py | 9 +- .../frontends/torch/func_wrapper.py | 12 +- ivy/functional/frontends/torch/tensor.py | 3 +- ivy/functional/frontends/xgboost/core.py | 14 +- .../xgboost/linear/updater_coordinate.py | 18 +- ivy/functional/frontends/xgboost/sklearn.py | 8 +- ivy/functional/frontends/xgboost/training.py | 3 +- ivy/functional/ivy/activations.py | 30 +- ivy/functional/ivy/control_flow_ops.py | 18 +- ivy/functional/ivy/creation.py | 133 ++- ivy/functional/ivy/data_type.py | 136 ++- ivy/functional/ivy/device.py | 136 ++- ivy/functional/ivy/elementwise.py | 435 ++++--- .../ivy/experimental/activations.py | 47 +- ivy/functional/ivy/experimental/creation.py | 107 +- .../ivy/experimental/elementwise.py | 116 +- ivy/functional/ivy/experimental/general.py | 4 +- ivy/functional/ivy/experimental/gradients.py | 9 +- ivy/functional/ivy/experimental/layers.py | 119 +- .../ivy/experimental/linear_algebra.py | 108 +- ivy/functional/ivy/experimental/losses.py | 37 +- .../ivy/experimental/manipulation.py | 162 +-- ivy/functional/ivy/experimental/norms.py | 14 +- ivy/functional/ivy/experimental/random.py | 25 +- ivy/functional/ivy/experimental/searching.py | 4 +- ivy/functional/ivy/experimental/sorting.py | 13 +- .../ivy/experimental/statistical.py | 45 +- ivy/functional/ivy/experimental/utility.py | 9 +- ivy/functional/ivy/general.py | 288 +++-- ivy/functional/ivy/gradients.py | 74 +- ivy/functional/ivy/layers.py | 86 +- ivy/functional/ivy/linear_algebra.py | 120 +- ivy/functional/ivy/losses.py | 9 +- ivy/functional/ivy/manipulation.py | 57 +- ivy/functional/ivy/meta.py | 12 +- ivy/functional/ivy/nest.py | 79 +- ivy/functional/ivy/norms.py | 3 +- ivy/functional/ivy/random.py | 31 +- ivy/functional/ivy/searching.py | 23 +- ivy/functional/ivy/set.py | 21 +- ivy/functional/ivy/sorting.py | 12 +- ivy/functional/ivy/statistical.py | 32 +- ivy/functional/ivy/utility.py | 8 +- ivy/stateful/activations.py | 39 +- ivy/stateful/converters.py | 24 +- ivy/stateful/helpers.py | 41 +- ivy/stateful/initializers.py | 41 +- ivy/stateful/layers.py | 200 ++-- ivy/stateful/losses.py | 6 +- ivy/stateful/module.py | 50 +- ivy/stateful/norms.py | 12 +- ivy/stateful/optimizers.py | 72 +- ivy/stateful/sequential.py | 8 +- ivy/utils/_importlib.py | 3 +- ivy/utils/backend/ast_helpers.py | 3 +- ivy/utils/backend/handler.py | 40 +- ivy/utils/einsum_parser.py | 33 +- ivy/utils/einsum_path_helpers.py | 47 +- ivy/utils/exceptions.py | 12 +- ivy/utils/inspection.py | 5 +- ivy/utils/logging.py | 6 +- ivy/utils/profiler.py | 3 +- ivy_tests/test_docstrings.py | 3 +- ivy_tests/test_ivy/helpers/assertions.py | 28 +- .../test_ivy/helpers/function_testing.py | 37 +- ivy_tests/test_ivy/helpers/globals.py | 8 +- .../hypothesis_helpers/array_helpers.py | 62 +- .../hypothesis_helpers/dtype_helpers.py | 14 +- .../hypothesis_helpers/general_helpers.py | 39 +- .../hypothesis_helpers/number_helpers.py | 11 +- ivy_tests/test_ivy/helpers/testing_helpers.py | 31 +- ivy_tests/test_ivy/test_frontends/__init__.py | 7 +- .../test_jax/test_numpy/test_linalg.py | 4 +- .../test_frontends/test_numpy/__init__.py | 3 +- .../test_frontends/test_numpy/helpers.py | 9 +- .../test_linalg/test_matrix_eigenvalues.py | 4 +- .../test_frontends/test_paddle/__init__.py | 3 +- .../test_frontends/test_scipy/__init__.py | 3 +- .../test_tensorflow/__init__.py | 3 +- .../test_tensorflow/test_raw_ops.py | 5 +- .../test_frontends/test_torch/__init__.py | 3 +- .../test_frontends/test_torch/test_linalg.py | 3 +- .../test_core/test_manipulation.py | 5 +- ivy_tests/test_ivy/test_misc/test_array.py | 3 +- scripts/eager_mode_benchmark/benchmark.py | 8 +- 216 files changed, 7240 insertions(+), 5290 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 620bc5860fbd5..a748c51e37c44 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -1016,7 +1016,8 @@ def vec_sig_fig(x, sig_fig=3): def set_array_significant_figures(sig_figs): - """Summary. + """ + Summary. Parameters ---------- @@ -1056,7 +1057,8 @@ def _assert_array_decimal_values_formatting(dec_vals): def set_array_decimal_values(dec_vals): - """Summary. + """ + Summary. Parameters ---------- @@ -1082,7 +1084,8 @@ def unset_array_decimal_values(): def set_warning_level(warn_level): - """Summary. + """ + Summary. Parameters ---------- @@ -1114,7 +1117,8 @@ def warn(warning_message, stacklevel=0): def set_nan_policy(warn_level): - """Summary. + """ + Summary. Parameters ---------- @@ -1147,8 +1151,7 @@ def unset_nan_policy(): def set_dynamic_backend(flag): # noqa: D209 - """Set the global dynamic backend setting to the provided flag (True or - False)""" + """Set the global dynamic backend setting to the provided flag (True or False)""" global dynamic_backend_stack if flag not in [True, False]: raise ValueError("dynamic_backend must be a boolean value (True or False)") @@ -1157,7 +1160,8 @@ def set_dynamic_backend(flag): # noqa: D209 def unset_dynamic_backend(): - """Remove the current dynamic backend setting. + """ + Remove the current dynamic backend setting. Also restore the previous setting (if any) """ @@ -1175,7 +1179,8 @@ def unset_dynamic_backend(): @handle_exceptions def set_cython_wrappers_mode(flag: bool = True) -> None: - """Set the mode of whether to use cython wrappers for functions. + """ + Set the mode of whether to use cython wrappers for functions. Parameter --------- @@ -1501,7 +1506,8 @@ def __init__(self): self.logging_mode_stack.append(logging.WARNING) def set_logging_mode(self, mode): - """Set the current logging mode for Ivy. + """ + Set the current logging mode for Ivy. Possible modes are 'DEBUG', 'INFO', 'WARNING', 'ERROR'. """ @@ -1514,8 +1520,7 @@ def set_logging_mode(self, mode): self.logging_mode_stack.append(mode) def unset_logging_mode(self): # noqa: D209 - """Remove the most recently set logging mode, returning to the previous - one.""" + """Remove the most recently set logging mode, returning to the previous one.""" if len(self.logging_mode_stack) > 1: # Remove the current mode self.logging_mode_stack.pop() diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 535e749daff4b..083e4da28e1d3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """ + Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -137,9 +137,9 @@ def transpile( params_v=None, v=None ): - """Transpiles Callable objects passed as arguments. If args and kwargs are - specified, transpilation is performed eagerly, otherwise, transpilation - will happen lazily. + """ + Transpiles Callable objects passed as arguments. If args and kwargs are specified, + transpilation is performed eagerly, otherwise, transpilation will happen lazily. Parameters ---------- diff --git a/ivy/compiler/replace_with.py b/ivy/compiler/replace_with.py index 2bfdd8140b7b5..51af07f192249 100644 --- a/ivy/compiler/replace_with.py +++ b/ivy/compiler/replace_with.py @@ -6,7 +6,8 @@ def replace_with(new_func): - """Decorate a function/method/attribute to be replaced by another. + """ + Decorate a function/method/attribute to be replaced by another. Parameters ---------- @@ -42,8 +43,7 @@ def decorator(original_func): class ReplaceFunction(ast.NodeTransformer): - """AST Node Transformer to replace function calls, methods, and - attributes.""" + """AST Node Transformer to replace function calls, methods, and attributes.""" def visit_Attribute(self, node): if ( @@ -69,8 +69,7 @@ def visit_Call(self, node): def transform_function(func): - """Transform the function by replacing its calls based on the - replace_map.""" + """Transform the function by replacing its calls based on the replace_map.""" source = inspect.getsource(func) tree = ast.parse(source) transformed_tree = ReplaceFunction().visit(tree) diff --git a/ivy/data_classes/array/activations.py b/ivy/data_classes/array/activations.py index 6fcdafe056a19..950dd0512b6f7 100644 --- a/ivy/data_classes/array/activations.py +++ b/ivy/data_classes/array/activations.py @@ -17,9 +17,10 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.relu. This method simply - wraps the function, and so the docstring for ivy.relu also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.relu. This method simply wraps the + function, and so the docstring for ivy.relu also applies to this method with + minimal changes. Parameters ---------- @@ -54,9 +55,10 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.leaky_relu. This method - simply wraps the function, and so the docstring for ivy.leaky_relu also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.leaky_relu. This method simply wraps + the function, and so the docstring for ivy.leaky_relu also applies to this + method with minimal changes. Parameters ---------- @@ -95,9 +97,10 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.gelu. This method simply - wraps the function, and so the docstring for ivy.gelu also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.gelu. This method simply wraps the + function, and so the docstring for ivy.gelu also applies to this method with + minimal changes. Parameters ---------- @@ -135,7 +138,8 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.sigmoid. + """ + ivy.Array instance method variant of ivy.sigmoid. This method simply wraps the function, and so the docstring for ivy.sigmoid also applies to this method with minimal changes. @@ -174,9 +178,10 @@ def softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.softmax. This method simply - wraps the function, and so the docstring for ivy.softmax also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.softmax. This method simply wraps the + function, and so the docstring for ivy.softmax also applies to this method with + minimal changes. Parameters ---------- @@ -214,9 +219,10 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.softplus. This method - simply wraps the function, and so the docstring for ivy.softplus also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.softplus. This method simply wraps the + function, and so the docstring for ivy.softplus also applies to this method with + minimal changes. Parameters ---------- @@ -270,9 +276,10 @@ def log_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.log_softmax. This method - simply wraps the function, and so the docstring for ivy.log_softmax - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.log_softmax. This method simply wraps + the function, and so the docstring for ivy.log_softmax also applies to this + method with minimal changes. Parameters ---------- @@ -317,9 +324,10 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.mish. This method simply - wraps the function, and so the docstring for ivy.mish also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.mish. This method simply wraps the + function, and so the docstring for ivy.mish also applies to this method with + minimal changes. Parameters ---------- @@ -348,7 +356,8 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the hardswish activation function element-wise. + """ + Apply the hardswish activation function element-wise. Parameters ---------- diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 7794ebee4d7d9..eb76a03676aab 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -232,7 +232,8 @@ def device(self) -> ivy.Device: @property def mT(self) -> ivy.Array: - """Transpose of a matrix (or a stack of matrices). + """ + Transpose of a matrix (or a stack of matrices). Returns ------- @@ -289,7 +290,8 @@ def strides(self) -> Optional[int]: @property def T(self) -> ivy.Array: - """Transpose of the array. + """ + Transpose of the array. Returns ------- @@ -307,7 +309,8 @@ def base(self) -> ivy.Array: @property def real(self) -> ivy.Array: - """Real part of the array. + """ + Real part of the array. Returns ------- @@ -320,7 +323,8 @@ def real(self) -> ivy.Array: @property def imag(self) -> ivy.Array: - """Imaginary part of the array. + """ + Imaginary part of the array. Returns ------- @@ -481,9 +485,10 @@ def __neg__(self): return ivy.negative(self._data) def __pow__(self, power): - """ivy.Array special method variant of ivy.pow. This method simply - wraps the function, and so the docstring for ivy.pow also applies to - this method with minimal changes. + """ + ivy.Array special method variant of ivy.pow. This method simply wraps the + function, and so the docstring for ivy.pow also applies to this method with + minimal changes. Parameters ---------- @@ -522,9 +527,10 @@ def __ipow__(self, power): return ivy.pow(self._data, power) def __add__(self, other): - """ivy.Array special method variant of ivy.add. This method simply - wraps the function, and so the docstring for ivy.add also applies to - this method with minimal changes. + """ + ivy.Array special method variant of ivy.add. This method simply wraps the + function, and so the docstring for ivy.add also applies to this method with + minimal changes. Parameters ---------- @@ -551,9 +557,10 @@ def __add__(self, other): return ivy.add(self._data, other) def __radd__(self, other): - """ivy.Array reverse special method variant of ivy.add. This method - simply wraps the function, and so the docstring for ivy.add also - applies to this method with minimal changes. + """ + ivy.Array reverse special method variant of ivy.add. This method simply wraps + the function, and so the docstring for ivy.add also applies to this method with + minimal changes. Parameters ---------- @@ -583,9 +590,10 @@ def __iadd__(self, other): return ivy.add(self._data, other) def __sub__(self, other): - """ivy.Array special method variant of ivy.subtract. This method simply - wraps the function, and so the docstring for ivy.subtract also applies - to this method with minimal changes. + """ + ivy.Array special method variant of ivy.subtract. This method simply wraps the + function, and so the docstring for ivy.subtract also applies to this method with + minimal changes. Parameters ---------- @@ -614,9 +622,10 @@ def __sub__(self, other): return ivy.subtract(self._data, other) def __rsub__(self, other): - """ivy.Array reverse special method variant of ivy.subtract. This - method simply wraps the function, and so the docstring for ivy.subtract - also applies to this method with minimal changes. + """ + ivy.Array reverse special method variant of ivy.subtract. This method simply + wraps the function, and so the docstring for ivy.subtract also applies to this + method with minimal changes. Parameters ---------- @@ -670,9 +679,10 @@ def __rdivmod__(self, other): return ivy.divide(other, self._data), ivy.remainder(other, self._data) def __truediv__(self, other): - """ivy.Array reverse special method variant of ivy.divide. This method - simply wraps the function, and so the docstring for ivy.divide also - applies to this method with minimal changes. + """ + ivy.Array reverse special method variant of ivy.divide. This method simply wraps + the function, and so the docstring for ivy.divide also applies to this method + with minimal changes. Parameters ---------- @@ -723,9 +733,10 @@ def __imatmul__(self, other): return ivy.matmul(self._data, other) def __abs__(self): - """ivy.Array special method variant of ivy.abs. This method simply - wraps the function, and so the docstring for ivy.abs also applies to - this method with minimal changes. + """ + ivy.Array special method variant of ivy.abs. This method simply wraps the + function, and so the docstring for ivy.abs also applies to this method with + minimal changes. Parameters ---------- @@ -798,9 +809,10 @@ def __dlpack_device__(self): return self._data.__dlpack_device__() def __lt__(self, other): - """ivy.Array special method variant of ivy.less. This method simply - wraps the function, and so the docstring for ivy.less also applies to - this method with minimal changes. + """ + ivy.Array special method variant of ivy.less. This method simply wraps the + function, and so the docstring for ivy.less also applies to this method with + minimal changes. Parameters ---------- @@ -827,9 +839,10 @@ def __lt__(self, other): return ivy.less(self._data, other) def __le__(self, other): - """ivy.Array special method variant of ivy.less_equal. This method - simply wraps the function, and so the docstring for ivy.less_equal also - applies to this method with minimal changes. + """ + ivy.Array special method variant of ivy.less_equal. This method simply wraps the + function, and so the docstring for ivy.less_equal also applies to this method + with minimal changes. Parameters ---------- @@ -856,9 +869,10 @@ def __le__(self, other): return ivy.less_equal(self._data, other) def __eq__(self, other): - """ivy.Array special method variant of ivy.equal. This method simply - wraps the function, and so the docstring for ivy.equal also applies to - this method with minimal changes. + """ + ivy.Array special method variant of ivy.equal. This method simply wraps the + function, and so the docstring for ivy.equal also applies to this method with + minimal changes. Parameters ---------- @@ -893,9 +907,10 @@ def __eq__(self, other): return ivy.equal(self._data, other) def __ne__(self, other): - """ivy.Array special method variant of ivy.not_equal. This method - simply wraps the function, and so the docstring for ivy.not_equal also - applies to this method with minimal changes. + """ + ivy.Array special method variant of ivy.not_equal. This method simply wraps the + function, and so the docstring for ivy.not_equal also applies to this method + with minimal changes. Parameters ---------- @@ -930,9 +945,10 @@ def __ne__(self, other): return ivy.not_equal(self._data, other) def __gt__(self, other): - """ivy.Array special method variant of ivy.greater. This method simply - wraps the function, and so the docstring for ivy.greater also applies - to this method with minimal changes. + """ + ivy.Array special method variant of ivy.greater. This method simply wraps the + function, and so the docstring for ivy.greater also applies to this method with + minimal changes. Parameters ---------- @@ -976,9 +992,10 @@ def __gt__(self, other): return ivy.greater(self._data, other) def __ge__(self, other): - """ivy.Array special method variant of ivy.greater_equal. This method - simply wraps the function, and so the docstring for ivy.bitwise_xor - also applies to this method with minimal changes. + """ + ivy.Array special method variant of ivy.greater_equal. This method simply wraps + the function, and so the docstring for ivy.bitwise_xor also applies to this + method with minimal changes. Parameters ---------- @@ -1043,9 +1060,10 @@ def __invert__(self): return ivy.bitwise_invert(self._data) def __xor__(self, other): - """ivy.Array special method variant of ivy.bitwise_xor. This method - simply wraps the function, and so the docstring for ivy.bitwise_xor - also applies to this method with minimal changes. + """ + ivy.Array special method variant of ivy.bitwise_xor. This method simply wraps + the function, and so the docstring for ivy.bitwise_xor also applies to this + method with minimal changes. Parameters ---------- @@ -1100,10 +1118,10 @@ def __ilshift__(self, other): return ivy.bitwise_left_shift(self._data, other) def __rshift__(self, other): - """ivy.Array special method variant of ivy.bitwise_right_shift. This - method simply wraps the function, and so the docstring for - ivy.bitwise_right_shift also applies to this method with minimal - changes. + """ + ivy.Array special method variant of ivy.bitwise_right_shift. This method simply + wraps the function, and so the docstring for ivy.bitwise_right_shift also + applies to this method with minimal changes. Parameters ---------- @@ -1133,10 +1151,10 @@ def __rshift__(self, other): return ivy.bitwise_right_shift(self._data, other) def __rrshift__(self, other): - """ivy.Array reverse special method variant of ivy.bitwise_right_shift. - This method simply wraps the function, and so the docstring for - ivy.bitwise_right_shift also applies to this method with minimal - changes. + """ + ivy.Array reverse special method variant of ivy.bitwise_right_shift. This method + simply wraps the function, and so the docstring for ivy.bitwise_right_shift also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/conversions.py b/ivy/data_classes/array/conversions.py index 67898f34951cd..988286408e763 100644 --- a/ivy/data_classes/array/conversions.py +++ b/ivy/data_classes/array/conversions.py @@ -1,4 +1,5 @@ -"""Ivy wrapping functions for conversions. +""" +Ivy wrapping functions for conversions. Collection of Ivy functions for wrapping functions to accept and return ivy.Array instances. @@ -140,10 +141,10 @@ def to_ivy( nested: bool = False, include_derived: Optional[Dict[str, bool]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """Return the input array converted to an ivy.Array instance if it is a - native array type, otherwise the input is returned unchanged. If nested is - set, the check is applied to all nested leafs of tuples, lists and dicts - contained within x. + """ + Return the input array converted to an ivy.Array instance if it is a native array + type, otherwise the input is returned unchanged. If nested is set, the check is + applied to all nested leafs of tuples, lists and dicts contained within x. Parameters ---------- @@ -172,8 +173,9 @@ def args_to_ivy( include_derived: Optional[Dict[str, bool]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """Return args and keyword args in their ivy.Array or form for all nested - instances, otherwise the arguments are returned unchanged. + """ + Return args and keyword args in their ivy.Array or form for all nested instances, + otherwise the arguments are returned unchanged. Parameters ---------- @@ -203,10 +205,10 @@ def to_native( cont_inplace: bool = False, to_ignore: Optional[Union[type, Tuple[type]]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """Return the input item in its native backend framework form if it is an - ivy.Array instance, otherwise the input is returned unchanged. If nested is - set, the check is applied to all nested leaves of tuples, lists and dicts - contained within ``x``. + """ + Return the input item in its native backend framework form if it is an ivy.Array + instance, otherwise the input is returned unchanged. If nested is set, the check is + applied to all nested leaves of tuples, lists and dicts contained within ``x``. Parameters ---------- @@ -246,9 +248,9 @@ def args_to_native( to_ignore: Optional[Union[type, Tuple[type]]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """Return args and keyword args in their native backend framework form for - all nested ivy.Array instances, otherwise the arguments are returned - unchanged. + """ + Return args and keyword args in their native backend framework form for all nested + ivy.Array instances, otherwise the arguments are returned unchanged. Parameters ---------- @@ -294,10 +296,11 @@ def to_new_backend( cont_inplace: bool = False, to_ignore: Optional[Union[type, Tuple[type]]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """Return the input array converted to new backend framework form if it is - an `ivy.Array`, `ivy.NativeArray` or NativeVariable instance. If nested is - set, the check is applied to all nested leaves of tuples, lists and dicts - contained within ``x``. + """ + Return the input array converted to new backend framework form if it is an + `ivy.Array`, `ivy.NativeArray` or NativeVariable instance. If nested is set, the + check is applied to all nested leaves of tuples, lists and dicts contained within + ``x``. Parameters ---------- @@ -344,8 +347,9 @@ def args_to_new_backend( to_ignore: Optional[Union[type, Tuple[type]]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """Return args and keyword args in the new current backend framework for - all nested ivy.Array, ivy.NativeArray or NativeVariable instances. + """ + Return args and keyword args in the new current backend framework for all nested + ivy.Array, ivy.NativeArray or NativeVariable instances. Parameters ---------- diff --git a/ivy/data_classes/array/creation.py b/ivy/data_classes/array/creation.py index 6486096f38b13..94e2ab7a096d3 100644 --- a/ivy/data_classes/array/creation.py +++ b/ivy/data_classes/array/creation.py @@ -21,9 +21,10 @@ def asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.asarray. This method simply - wraps the function, and so the docstring for ivy.asarray also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.asarray. This method simply wraps the + function, and so the docstring for ivy.asarray also applies to this method with + minimal changes. Parameters ---------- @@ -86,9 +87,10 @@ def full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.full_like. This method - simply wraps the function, and so the docstring for ivy.full_like also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.full_like. This method simply wraps the + function, and so the docstring for ivy.full_like also applies to this method + with minimal changes. Parameters ---------- @@ -149,9 +151,10 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.ones_like. This method - simply wraps the function, and so the docstring for ivy.ones_like also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.ones_like. This method simply wraps the + function, and so the docstring for ivy.ones_like also applies to this method + with minimal changes. Parameters ---------- @@ -182,9 +185,10 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.zeros_like. This method - simply wraps the function, and so the docstring for ivy.zeros_like also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.zeros_like. This method simply wraps + the function, and so the docstring for ivy.zeros_like also applies to this + method with minimal changes. Parameters ---------- @@ -210,9 +214,10 @@ def zeros_like( def tril( self: ivy.Array, /, *, k: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ivy.Array instance method variant of ivy.tril. This method simply - wraps the function, and so the docstring for ivy.tril also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.tril. This method simply wraps the + function, and so the docstring for ivy.tril also applies to this method with + minimal changes. Parameters ---------- @@ -240,9 +245,10 @@ def tril( def triu( self: ivy.Array, /, *, k: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ivy.Array instance method variant of ivy.triu. This method simply - wraps the function, and so the docstring for ivy.triu also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.triu. This method simply wraps the + function, and so the docstring for ivy.triu also applies to this method with + minimal changes. Parameters ---------- @@ -275,9 +281,10 @@ def empty_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.empty_like. This method - simply wraps the function, and so the docstring for ivy.empty_like also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.empty_like. This method simply wraps + the function, and so the docstring for ivy.empty_like also applies to this + method with minimal changes. Parameters ---------- @@ -308,9 +315,10 @@ def meshgrid( sparse: bool = False, indexing: str = "xy", ) -> List[ivy.Array]: - """ivy.Array instance method variant of ivy.meshgrid. This method - simply wraps the function, and so the docstring for ivy.meshgrid also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.meshgrid. This method simply wraps the + function, and so the docstring for ivy.meshgrid also applies to this method with + minimal changes. Parameters ---------- @@ -343,9 +351,10 @@ def from_dlpack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.from_dlpack. This method - simply wraps the function, and so the docstring for ivy.from_dlpack - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.from_dlpack. This method simply wraps + the function, and so the docstring for ivy.from_dlpack also applies to this + method with minimal changes. Parameters ---------- @@ -372,9 +381,10 @@ def copy_array( to_ivy_array: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.copy_array. This method - simply wraps the function, and so the docstring for ivy.copy_array also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.copy_array. This method simply wraps + the function, and so the docstring for ivy.copy_array also applies to this + method with minimal changes. Parameters ---------- @@ -402,9 +412,10 @@ def native_array( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.NativeArray: - """ivy.Array instance method variant of ivy.native_array. This method - simply wraps the function, and so the docstring for ivy.native_array - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.native_array. This method simply wraps + the function, and so the docstring for ivy.native_array also applies to this + method with minimal changes. Parameters ---------- @@ -434,9 +445,10 @@ def one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.one_hot. This method simply - wraps the function, and so the docstring for ivy.one_hot also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.one_hot. This method simply wraps the + function, and so the docstring for ivy.one_hot also applies to this method with + minimal changes. Parameters ---------- @@ -537,9 +549,10 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.logspace. This method - simply wraps the function, and so the docstring for ivy.logspace also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logspace. This method simply wraps the + function, and so the docstring for ivy.logspace also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/data_type.py b/ivy/data_classes/array/data_type.py index afaaade47303c..01cdedea04c58 100644 --- a/ivy/data_classes/array/data_type.py +++ b/ivy/data_classes/array/data_type.py @@ -18,8 +18,9 @@ def astype( copy: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Copy an array to a specified data type irrespective of :ref:`type- - promotion` rules. + """ + Copy an array to a specified data type irrespective of :ref:`type- promotion` + rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -68,10 +69,10 @@ def astype( def broadcast_arrays( self: ivy.Array, *arrays: Union[ivy.Array, ivy.NativeArray] ) -> List[ivy.Array]: - """`ivy.Array` instance method variant of `ivy.broadcast_arrays`. This - method simply wraps the function, and so the docstring for - `ivy.broadcast_arrays` also applies to this method with minimal - changes. + """ + `ivy.Array` instance method variant of `ivy.broadcast_arrays`. This method + simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also + applies to this method with minimal changes. Parameters ---------- @@ -112,9 +113,10 @@ def broadcast_arrays( def broadcast_to( self: ivy.Array, /, shape: Tuple[int, ...], *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """`ivy.Array` instance method variant of `ivy.broadcast_to`. This - method simply wraps the function, and so the docstring for - `ivy.broadcast_to` also applies to this method with minimal changes. + """ + `ivy.Array` instance method variant of `ivy.broadcast_to`. This method simply + wraps the function, and so the docstring for `ivy.broadcast_to` also applies to + this method with minimal changes. Parameters ---------- @@ -144,9 +146,10 @@ def broadcast_to( return ivy.broadcast_to(self._data, shape=shape, out=out) def can_cast(self: ivy.Array, to: ivy.Dtype) -> bool: - """`ivy.Array` instance method variant of `ivy.can_cast`. This method - simply wraps the function, and so the docstring for `ivy.can_cast` also - applies to this method with minimal changes. + """ + `ivy.Array` instance method variant of `ivy.can_cast`. This method simply wraps + the function, and so the docstring for `ivy.can_cast` also applies to this + method with minimal changes. Parameters ---------- @@ -176,8 +179,9 @@ def can_cast(self: ivy.Array, to: ivy.Dtype) -> bool: def dtype( self: ivy.Array, as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """`ivy.Array` instance method variant of `ivy.dtype`. This method - helps to get the data type of the array. + """ + `ivy.Array` instance method variant of `ivy.dtype`. This method helps to get the + data type of the array. Parameters ---------- @@ -208,7 +212,8 @@ def dtype( return ivy.dtype(self._data, as_native=as_native) def finfo(self: ivy.Array, /) -> Finfo: - """Array instance method variant of `ivy.finfo`. + """ + Array instance method variant of `ivy.finfo`. Parameters ---------- @@ -230,9 +235,10 @@ def finfo(self: ivy.Array, /) -> Finfo: return ivy.finfo(self._data) def iinfo(self: ivy.Array, /) -> Iinfo: - """`ivy.Array` instance method variant of `ivy.iinfo`. This method - simply wraps the function, and so the docstring for `ivy.iinfo` also - applies to this method with minimal changes. + """ + `ivy.Array` instance method variant of `ivy.iinfo`. This method simply wraps the + function, and so the docstring for `ivy.iinfo` also applies to this method with + minimal changes. Parameters ---------- @@ -261,8 +267,9 @@ def is_bool_dtype(self: ivy.Array) -> bool: return ivy.is_bool_dtype(self._data) def is_float_dtype(self: ivy.Array) -> bool: - """`ivy.Array` instance method variant of `ivy.is_float_dtype`. This - method simply checks to see if the array is of type `float`. + """ + `ivy.Array` instance method variant of `ivy.is_float_dtype`. This method simply + checks to see if the array is of type `float`. Parameters ---------- @@ -296,9 +303,10 @@ def result_type( self: ivy.Array, *arrays_and_dtypes: Union[ivy.Array, ivy.NativeArray, ivy.Dtype], ) -> ivy.Dtype: - """`ivy.Array` instance method variant of `ivy.result_type`. This - method simply wraps the function, and so the docstring for - `ivy.result_type` also applies to this method with minimal changes. + """ + `ivy.Array` instance method variant of `ivy.result_type`. This method simply + wraps the function, and so the docstring for `ivy.result_type` also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/device.py b/ivy/data_classes/array/device.py index 18ac9887abd27..f0eb01d3b048f 100644 --- a/ivy/data_classes/array/device.py +++ b/ivy/data_classes/array/device.py @@ -12,9 +12,10 @@ class _ArrayWithDevice(abc.ABC): def dev( self: ivy.Array, *, as_native: bool = False ) -> Union[ivy.Device, ivy.NativeDevice]: - """ivy.Array instance method variant of ivy.dev. This method simply - wraps the function, and so the docstring for ivy.dev also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dev. This method simply wraps the + function, and so the docstring for ivy.dev also applies to this method with + minimal changes. Parameters ---------- @@ -39,9 +40,10 @@ def to_device( stream: Optional[Union[int, Any]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.to_device. This method - simply wraps the function, and so the docstring for ivy.to_device also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.to_device. This method simply wraps the + function, and so the docstring for ivy.to_device also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/elementwise.py b/ivy/data_classes/array/elementwise.py index b8de2d75e91ad..f33601eac27da 100644 --- a/ivy/data_classes/array/elementwise.py +++ b/ivy/data_classes/array/elementwise.py @@ -14,9 +14,10 @@ def abs( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: # noqa - """ivy.Array instance method variant of ivy.abs. This method simply - wraps the function, and so the docstring for ivy.abs also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.abs. This method simply wraps the + function, and so the docstring for ivy.abs also applies to this method with + minimal changes. Parameters ---------- @@ -42,9 +43,10 @@ def abs( return ivy.abs(self, out=out) def acosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.acosh. This method simply - wraps the function, and so the docstring for ivy.acosh also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.acosh. This method simply wraps the + function, and so the docstring for ivy.acosh also applies to this method with + minimal changes. Parameters ---------- @@ -72,9 +74,10 @@ def acosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.acosh(self._data, out=out) def acos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.acos. This method simply - wraps the function, and so the docstring for ivy.acos also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.acos. This method simply wraps the + function, and so the docstring for ivy.acos also applies to this method with + minimal changes. Parameters ---------- @@ -107,9 +110,10 @@ def add( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.add. This method simply - wraps the function, and so the docstring for ivy.add also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.add. This method simply wraps the + function, and so the docstring for ivy.add also applies to this method with + minimal changes. Parameters ---------- @@ -147,9 +151,10 @@ def add( return ivy.add(self._data, x2, alpha=alpha, out=out) def asin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.asin. This method simply - wraps the function, and so the docstring for ivy.asin also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.asin. This method simply wraps the + function, and so the docstring for ivy.asin also applies to this method with + minimal changes. Parameters ---------- @@ -183,9 +188,10 @@ def asin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.asin(self._data, out=out) def asinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.asinh. This method simply - wraps the function, and so the docstring for ivy.asinh also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.asinh. This method simply wraps the + function, and so the docstring for ivy.asinh also applies to this method with + minimal changes. Parameters ---------- @@ -213,9 +219,10 @@ def asinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.asinh(self._data, out=out) def atan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.atan. This method simply - wraps the function, and so the docstring for ivy.atan also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.atan. This method simply wraps the + function, and so the docstring for ivy.atan also applies to this method with + minimal changes. Parameters ---------- @@ -247,9 +254,10 @@ def atan2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.atan2. This method simply - wraps the function, and so the docstring for ivy.atan2 also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.atan2. This method simply wraps the + function, and so the docstring for ivy.atan2 also applies to this method with + minimal changes. Parameters ---------- @@ -321,9 +329,10 @@ def atan2( return ivy.atan2(self._data, x2, out=out) def atanh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.atanh. This method simply - wraps the function, and so the docstring for ivy.atanh also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.atanh. This method simply wraps the + function, and so the docstring for ivy.atanh also applies to this method with + minimal changes. Parameters ---------- @@ -357,9 +366,10 @@ def bitwise_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.bitwise_and. This method - simply wraps the function, and so the docstring for ivy.bitwise_and - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.bitwise_and. This method simply wraps + the function, and so the docstring for ivy.bitwise_and also applies to this + method with minimal changes. Parameters ---------- @@ -402,10 +412,10 @@ def bitwise_left_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.bitwise_left_shift. This - method simply wraps the function, and so the docstring for - ivy.bitwise_left_shift also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.bitwise_left_shift. This method simply + wraps the function, and so the docstring for ivy.bitwise_left_shift also applies + to this method with minimal changes. Parameters ---------- @@ -431,9 +441,10 @@ def bitwise_left_shift( def bitwise_invert( self: ivy.Array, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ivy.Array instance method variant of ivy.bitwise_invert. This method - simply wraps the function, and so the docstring for ivy.bitiwse_invert - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.bitwise_invert. This method simply + wraps the function, and so the docstring for ivy.bitiwse_invert also applies to + this method with minimal changes. Parameters ---------- @@ -471,9 +482,10 @@ def bitwise_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.bitwise_or. This method - simply wraps the function, and so the docstring for ivy.bitwise_or also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.bitwise_or. This method simply wraps + the function, and so the docstring for ivy.bitwise_or also applies to this + method with minimal changes. Parameters ---------- @@ -509,10 +521,10 @@ def bitwise_right_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.bitwise_right_shift. This - method simply wraps the function, and so the docstring for - ivy.bitwise_right_shift also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.bitwise_right_shift. This method simply + wraps the function, and so the docstring for ivy.bitwise_right_shift also + applies to this method with minimal changes. Parameters ---------- @@ -550,9 +562,10 @@ def bitwise_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.bitwise_xor. This method - simply wraps the function, and so the docstring for ivy.bitwise_xor - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.bitwise_xor. This method simply wraps + the function, and so the docstring for ivy.bitwise_xor also applies to this + method with minimal changes. Parameters ---------- @@ -584,9 +597,10 @@ def bitwise_xor( return ivy.bitwise_xor(self._data, x2, out=out) def ceil(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.ceil. This method simply - wraps the function, and so the docstring for ivy.ceil also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.ceil. This method simply wraps the + function, and so the docstring for ivy.ceil also applies to this method with + minimal changes. Parameters ---------- @@ -612,9 +626,10 @@ def ceil(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.ceil(self._data, out=out) def cos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.cos. This method simply - wraps the function, and so the docstring for ivy.cos also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cos. This method simply wraps the + function, and so the docstring for ivy.cos also applies to this method with + minimal changes. Parameters ---------- @@ -655,9 +670,10 @@ def cos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.cos(self._data, out=out) def cosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.cosh. This method simply - wraps the function, and so the docstring for ivy.cosh also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cosh. This method simply wraps the + function, and so the docstring for ivy.cosh also applies to this method with + minimal changes. Parameters ---------- @@ -695,9 +711,10 @@ def divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.divide. This method simply - wraps the function, and so the docstring for ivy.divide also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.divide. This method simply wraps the + function, and so the docstring for ivy.divide also applies to this method with + minimal changes. Parameters ---------- @@ -745,9 +762,10 @@ def equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.equal. This method simply - wraps the function, and so the docstring for ivy.equal also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.equal. This method simply wraps the + function, and so the docstring for ivy.equal also applies to this method with + minimal changes. Parameters ---------- @@ -807,9 +825,10 @@ def equal( return ivy.equal(self._data, x2, out=out) def exp(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.exp. This method simply - wraps the function, and so the docstring for ivy.exp also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.exp. This method simply wraps the + function, and so the docstring for ivy.exp also applies to this method with + minimal changes. Parameters ---------- @@ -835,9 +854,10 @@ def exp(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.exp(self._data, out=out) def expm1(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.expm1. This method simply - wraps the function, and so the docstring for ivy.expm1 also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.expm1. This method simply wraps the + function, and so the docstring for ivy.expm1 also applies to this method with + minimal changes. Parameters ---------- @@ -870,9 +890,10 @@ def expm1(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.expm1(self._data, out=out) def floor(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.floor. This method simply - wraps the function, and so the docstring for ivy.floor also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.floor. This method simply wraps the + function, and so the docstring for ivy.floor also applies to this method with + minimal changes. Parameters ---------- @@ -904,9 +925,10 @@ def floor_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.floor_divide. This method - simply wraps the function, and so the docstring for ivy.floor_divide - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.floor_divide. This method simply wraps + the function, and so the docstring for ivy.floor_divide also applies to this + method with minimal changes. Parameters ---------- @@ -954,9 +976,10 @@ def fmin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.fmin. This method simply - wraps the function, and so the docstring for ivy.fmin also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.fmin. This method simply wraps the + function, and so the docstring for ivy.fmin also applies to this method with + minimal changes. Parameters ---------- @@ -993,9 +1016,10 @@ def greater( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.greater. This method simply - wraps the function, and so the docstring for ivy.greater also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.greater. This method simply wraps the + function, and so the docstring for ivy.greater also applies to this method with + minimal changes. Parameters ---------- @@ -1032,9 +1056,10 @@ def greater_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.greater_equal. This method - simply wraps the function, and so the docstring for ivy.greater_equal - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.greater_equal. This method simply wraps + the function, and so the docstring for ivy.greater_equal also applies to this + method with minimal changes. Parameters ---------- @@ -1065,9 +1090,10 @@ def greater_equal( return ivy.greater_equal(self._data, x2, out=out) def isfinite(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.isfinite. This method - simply wraps the function, and so the docstring for ivy.isfinite also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.isfinite. This method simply wraps the + function, and so the docstring for ivy.isfinite also applies to this method with + minimal changes. Parameters ---------- @@ -1100,9 +1126,10 @@ def isinf( detect_negative: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.isinf. This method simply - wraps the function, and so the docstring for ivy.isinf also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.isinf. This method simply wraps the + function, and so the docstring for ivy.isinf also applies to this method with + minimal changes. Parameters ---------- @@ -1157,9 +1184,10 @@ def isinf( ) def isnan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.isnan. This method simply - wraps the function, and so the docstring for ivy.isnan also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.isnan. This method simply wraps the + function, and so the docstring for ivy.isnan also applies to this method with + minimal changes. Parameters ---------- @@ -1217,9 +1245,10 @@ def less( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.less. This method simply - wraps the function, and so the docstring for ivy.less also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.less. This method simply wraps the + function, and so the docstring for ivy.less also applies to this method with + minimal changes. Parameters ---------- @@ -1256,9 +1285,10 @@ def less_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.less_equal. This method - simply wraps the function, and so the docstring for ivy.less_equal also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.less_equal. This method simply wraps + the function, and so the docstring for ivy.less_equal also applies to this + method with minimal changes. Parameters ---------- @@ -1310,9 +1340,10 @@ def less_equal( return ivy.less_equal(self._data, x2, out=out) def log(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.log. This method simply - wraps the function, and so the docstring for ivy.log also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.log. This method simply wraps the + function, and so the docstring for ivy.log also applies to this method with + minimal changes. Parameters ---------- @@ -1353,9 +1384,10 @@ def log(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log(self._data, out=out) def log1p(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.log1p. This method simply - wraps the function, and so the docstring for ivy.log1p also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.log1p. This method simply wraps the + function, and so the docstring for ivy.log1p also applies to this method with + minimal changes. Parameters ---------- @@ -1387,9 +1419,10 @@ def log1p(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log1p(self._data, out=out) def log2(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.log2. This method simply - wraps the function, and so the docstring for ivy.log2 also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.log2. This method simply wraps the + function, and so the docstring for ivy.log2 also applies to this method with + minimal changes. Parameters ---------- @@ -1430,9 +1463,10 @@ def log2(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log2(self._data, out=out) def log10(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.log10. This method simply - wraps the function, and so the docstring for ivy.log10 also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.log10. This method simply wraps the + function, and so the docstring for ivy.log10 also applies to this method with + minimal changes. Parameters ---------- @@ -1479,9 +1513,10 @@ def logaddexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.logaddexp. This method - simply wraps the function, and so the docstring for ivy.logaddexp also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logaddexp. This method simply wraps the + function, and so the docstring for ivy.logaddexp also applies to this method + with minimal changes. Parameters ---------- @@ -1519,9 +1554,10 @@ def logaddexp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.logaddexp2. This method - simply wraps the function, and so the docstring for ivy.logaddexp2 also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logaddexp2. This method simply wraps + the function, and so the docstring for ivy.logaddexp2 also applies to this + method with minimal changes. Parameters ---------- @@ -1552,9 +1588,10 @@ def logical_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.logical_and. This method - simply wraps the function, and so the docstring for ivy.logical_and - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logical_and. This method simply wraps + the function, and so the docstring for ivy.logical_and also applies to this + method with minimal changes. Parameters ---------- @@ -1587,9 +1624,10 @@ def logical_and( return ivy.logical_and(self._data, x2, out=out) def logical_not(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.logical_not. This method - simply wraps the function, and so the docstring for ivy.logical_not - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logical_not. This method simply wraps + the function, and so the docstring for ivy.logical_not also applies to this + method with minimal changes. Parameters ---------- @@ -1626,9 +1664,10 @@ def logical_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.logical_or. This method - simply wraps the function, and so the docstring for ivy.logical_or also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logical_or. This method simply wraps + the function, and so the docstring for ivy.logical_or also applies to this + method with minimal changes. Parameters ---------- @@ -1677,9 +1716,10 @@ def logical_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.logical_xor. This method - simply wraps the function, and so the docstring for ivy.logical_xor - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logical_xor. This method simply wraps + the function, and so the docstring for ivy.logical_xor also applies to this + method with minimal changes. Parameters ---------- @@ -1716,9 +1756,10 @@ def multiply( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.multiply. This method - simply wraps the function, and so the docstring for ivy.multiply also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.multiply. This method simply wraps the + function, and so the docstring for ivy.multiply also applies to this method with + minimal changes. Parameters ---------- @@ -1767,9 +1808,10 @@ def maximum( use_where: bool = True, out: Optional[ivy.Array] = None, ): - """ivy.Array instance method variant of ivy.maximum. This method simply - wraps the function, and so the docstring for ivy.maximum also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.maximum. This method simply wraps the + function, and so the docstring for ivy.maximum also applies to this method with + minimal changes. Parameters ---------- @@ -1825,9 +1867,10 @@ def minimum( use_where: bool = True, out: Optional[ivy.Array] = None, ): - """ivy.Array instance method variant of ivy.minimum. This method simply - wraps the function, and so the docstring for ivy.minimum also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.minimum. This method simply wraps the + function, and so the docstring for ivy.minimum also applies to this method with + minimal changes. Parameters ---------- @@ -1876,9 +1919,10 @@ def minimum( return ivy.minimum(self, x2, use_where=use_where, out=out) def negative(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.negative. This method - simply wraps the function, and so the docstring for ivy.negative also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.negative. This method simply wraps the + function, and so the docstring for ivy.negative also applies to this method with + minimal changes. Parameters ---------- @@ -1925,9 +1969,10 @@ def not_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.not_equal. This method - simply wraps the function, and so the docstring for ivy.not_equal also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.not_equal. This method simply wraps the + function, and so the docstring for ivy.not_equal also applies to this method + with minimal changes. Parameters ---------- @@ -1986,9 +2031,10 @@ def not_equal( return ivy.not_equal(self._data, x2, out=out) def positive(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.positive. This method - simply wraps the function, and so the docstring for ivy.positive also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.positive. This method simply wraps the + function, and so the docstring for ivy.positive also applies to this method with + minimal changes. Parameters ---------- @@ -2035,9 +2081,10 @@ def pow( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.pow. This method simply - wraps the function, and so the docstring for ivy.pow also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.pow. This method simply wraps the + function, and so the docstring for ivy.pow also applies to this method with + minimal changes. Parameters ---------- @@ -2077,9 +2124,10 @@ def pow( return ivy.pow(self._data, x2, out=out) def real(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.real. This method simply - wraps the function, and so the docstring for ivy.real also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.real. This method simply wraps the + function, and so the docstring for ivy.real also applies to this method with + minimal changes. Parameters ---------- @@ -2112,9 +2160,10 @@ def remainder( modulus: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.remainder. This method - simply wraps the function, and so the docstring for ivy.remainder also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.remainder. This method simply wraps the + function, and so the docstring for ivy.remainder also applies to this method + with minimal changes. Parameters ---------- @@ -2162,9 +2211,10 @@ def remainder( def round( self: ivy.Array, *, decimals: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ivy.Array instance method variant of ivy.round. This method simply - wraps the function, and so the docstring for ivy.round also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.round. This method simply wraps the + function, and so the docstring for ivy.round also applies to this method with + minimal changes. Parameters ---------- @@ -2216,9 +2266,10 @@ def sign( np_variant: Optional[bool] = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.sign. This method simply - wraps the function, and so the docstring for ivy.sign also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.sign. This method simply wraps the + function, and so the docstring for ivy.sign also applies to this method with + minimal changes. Parameters ---------- @@ -2255,9 +2306,10 @@ def sign( return ivy.sign(self._data, np_variant=np_variant, out=out) def sin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.sin. This method simply - wraps the function, and so the docstring for ivy.sin also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.sin. This method simply wraps the + function, and so the docstring for ivy.sin also applies to this method with + minimal changes. Parameters ---------- @@ -2285,9 +2337,10 @@ def sin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.sin(self._data, out=out) def sinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.sinh. This method simply - wraps the function, and so the docstring for ivy.sinh also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.sinh. This method simply wraps the + function, and so the docstring for ivy.sinh also applies to this method with + minimal changes. Parameters ---------- @@ -2319,9 +2372,10 @@ def sinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.sinh(self._data, out=out) def square(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.square. This method simply - wraps the function, and so the docstring for ivy.square also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.square. This method simply wraps the + function, and so the docstring for ivy.square also applies to this method with + minimal changes. Parameters ---------- @@ -2355,9 +2409,10 @@ def square(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.square(self._data, out=out) def sqrt(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.sqrt. This method simply - wraps the function, and so the docstring for ivy.sqrt also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.sqrt. This method simply wraps the + function, and so the docstring for ivy.sqrt also applies to this method with + minimal changes. Parameters ---------- @@ -2394,9 +2449,10 @@ def subtract( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.subtract. This method - simply wraps the function, and so the docstring for ivy.subtract also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.subtract. This method simply wraps the + function, and so the docstring for ivy.subtract also applies to this method with + minimal changes. Parameters ---------- @@ -2443,9 +2499,10 @@ def trapz( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.trapz. This method simply - wraps the function, and so the docstring for ivy.trapz also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.trapz. This method simply wraps the + function, and so the docstring for ivy.trapz also applies to this method with + minimal changes. Parameters ---------- @@ -2486,9 +2543,10 @@ def trapz( return ivy.trapz(self._data, x=x, dx=dx, axis=axis, out=out) def tan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.tan. This method simply - wraps the function, and so the docstring for ivy.tan also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.tan. This method simply wraps the + function, and so the docstring for ivy.tan also applies to this method with + minimal changes. Parameters ---------- @@ -2521,9 +2579,10 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.tanh. This method simply - wraps the function, and so the docstring for ivy.tanh also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.tanh. This method simply wraps the + function, and so the docstring for ivy.tanh also applies to this method with + minimal changes. Parameters ---------- @@ -2554,9 +2613,10 @@ def tanh( return ivy.tanh(self._data, complex_mode=complex_mode, out=out) def trunc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.trunc. This method simply - wraps the function, and so the docstring for ivy.trunc also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.trunc. This method simply wraps the + function, and so the docstring for ivy.trunc also applies to this method with + minimal changes. Parameters ---------- @@ -2582,9 +2642,10 @@ def trunc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.trunc(self._data, out=out) def erf(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.erf. This method simply - wraps the function, and so the docstring for ivy.erf also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.erf. This method simply wraps the + function, and so the docstring for ivy.erf also applies to this method with + minimal changes. Parameters ---------- @@ -2613,9 +2674,10 @@ def exp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.exp2. This method simply - wraps the function, and so the docstring for ivy.exp2 also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.exp2. This method simply wraps the + function, and so the docstring for ivy.exp2 also applies to this method with + minimal changes. Parameters ---------- @@ -2647,9 +2709,10 @@ def gcd( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.gcd. This method simply - wraps the function, and so the docstring for ivy.gcd also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.gcd. This method simply wraps the + function, and so the docstring for ivy.gcd also applies to this method with + minimal changes. Parameters ---------- @@ -2687,9 +2750,10 @@ def nan_to_num( neginf: Optional[Union[float, int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.nan_to_num. This method - simply wraps the function, and so the docstring for ivy.nan_to_num also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nan_to_num. This method simply wraps + the function, and so the docstring for ivy.nan_to_num also applies to this + method with minimal changes. Parameters ---------- @@ -2737,9 +2801,10 @@ def imag( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.imag. This method simply - wraps the function, and so the docstring for ivy.imag also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.imag. This method simply wraps the + function, and so the docstring for ivy.imag also applies to this method with + minimal changes. Parameters ---------- @@ -2772,9 +2837,10 @@ def angle( deg: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.angle. This method simply - wraps the function, and so the docstring for ivy.angle also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.angle. This method simply wraps the + function, and so the docstring for ivy.angle also applies to this method with + minimal changes. Parameters ---------- @@ -2812,9 +2878,10 @@ def reciprocal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.reciprocal.This method - simply wraps the function, and so the docstring for ivy.reciprocal also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.reciprocal.This method simply wraps the + function, and so the docstring for ivy.reciprocal also applies to this method + with minimal changes. Parameters ---------- @@ -2839,9 +2906,10 @@ def reciprocal( return ivy.reciprocal(self._data, out=out) def deg2rad(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.deg2rad. This method simply - wraps the function, and so the docstring for ivy.deg2rad also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.deg2rad. This method simply wraps the + function, and so the docstring for ivy.deg2rad also applies to this method with + minimal changes. Parameters ---------- @@ -2868,9 +2936,10 @@ def deg2rad(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.deg2rad(self._data, out=out) def rad2deg(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.rad2deg. This method simply - wraps the function, and so the docstring for ivy.rad2deg also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.rad2deg. This method simply wraps the + function, and so the docstring for ivy.rad2deg also applies to this method with + minimal changes. Parameters ---------- @@ -2903,9 +2972,10 @@ def trunc_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.trunc_divide. This method - simply wraps the function, and so the docstring for ivy.trunc_divide - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.trunc_divide. This method simply wraps + the function, and so the docstring for ivy.trunc_divide also applies to this + method with minimal changes. Parameters ---------- @@ -2939,9 +3009,10 @@ def trunc_divide( return ivy.trunc_divide(self._data, x2, out=out) def isreal(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.isreal. This method simply - wraps the function, and so the docstring for ivy.isreal also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.isreal. This method simply wraps the + function, and so the docstring for ivy.isreal also applies to this method with + minimal changes. Parameters ---------- @@ -2969,9 +3040,10 @@ def isreal(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: def lcm( self: ivy.Array, x2: ivy.Array, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ivy.Array instance method variant of ivy.lcm. This method simply - wraps the function, and so the docstring for ivy.lcm also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.lcm. This method simply wraps the + function, and so the docstring for ivy.lcm also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/activations.py b/ivy/data_classes/array/experimental/activations.py index 6e44b4240c190..24e38a9dc52ff 100644 --- a/ivy/data_classes/array/experimental/activations.py +++ b/ivy/data_classes/array/experimental/activations.py @@ -15,9 +15,10 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.logit. This method simply - wraps the function, and so the docstring for ivy.logit also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logit. This method simply wraps the + function, and so the docstring for ivy.logit also applies to this method with + minimal changes. Parameters ---------- @@ -59,9 +60,10 @@ def thresholded_relu( threshold: Union[int, float] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.thresholded_relu. This - method simply wraps the function, and so the docstring for - ivy.thresholded_relu also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.thresholded_relu. This method simply + wraps the function, and so the docstring for ivy.thresholded_relu also applies + to this method with minimal changes. Parameters ---------- @@ -95,7 +97,8 @@ def prelu( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Prelu takes input data (Array) and slope array as input, + """ + Prelu takes input data (Array) and slope array as input, and produces one output data (array) where the function f(x) = slope * x for x < 0, f(x) = x for x >= 0., is applied @@ -127,7 +130,8 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the rectified linear unit 6 function element-wise. + """ + Apply the rectified linear unit 6 function element-wise. Parameters ---------- @@ -167,9 +171,10 @@ def logsigmoid( self: ivy.Array, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Array: - """ivy.Array instance method variant of ivy.logsigmoid. This method - simply wraps the function, and so the docstring for ivy.logsigmoid also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.logsigmoid. This method simply wraps + the function, and so the docstring for ivy.logsigmoid also applies to this + method with minimal changes. Parameters ---------- @@ -198,7 +203,8 @@ def logsigmoid( return ivy.logsigmoid(self._data, complex_mode=complex_mode) def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """Apply the scaled exponential linear unit function element-wise. + """ + Apply the scaled exponential linear unit function element-wise. Parameters ---------- @@ -234,9 +240,10 @@ def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.selu(self._data, out=out) def silu(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.silu. This method simply - wraps the function, and so the docstring for ivy.silu also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.silu. This method simply wraps the + function, and so the docstring for ivy.silu also applies to this method with + minimal changes. Parameters ---------- @@ -262,9 +269,10 @@ def elu( alpha: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Ivy.Array instance method variant of ivy.elu. This method simply - wraps the function, and so the docstring for ivy.elu also applies to - this method with minimal. + """ + Ivy.Array instance method variant of ivy.elu. This method simply wraps the + function, and so the docstring for ivy.elu also applies to this method with + minimal. Parameters ---------- @@ -298,9 +306,10 @@ def hardtanh( min_val: float = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.hardtanh. This method - simply wraps the function, and so the docstring for ivy.hardtanh also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.hardtanh. This method simply wraps the + function, and so the docstring for ivy.hardtanh also applies to this method with + minimal changes. Parameters ---------- @@ -330,9 +339,10 @@ def hardtanh( return ivy.hardtanh(self._data, min_val=min_val, max_val=max_val, out=out) def tanhshrink(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.tanhshrink. This method - simply wraps the function, and so the docstring for ivy.tanhshrink also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.tanhshrink. This method simply wraps + the function, and so the docstring for ivy.tanhshrink also applies to this + method with minimal changes. Parameters ---------- @@ -359,9 +369,10 @@ def threshold( value: Union[int, float], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.threshold. This method - simply wraps the function, and so the docstring for ivy.threshold also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.threshold. This method simply wraps the + function, and so the docstring for ivy.threshold also applies to this method + with minimal changes. Parameters ---------- @@ -396,9 +407,10 @@ def softshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.softshrink. This method - simply wraps the function, and so the docstring for ivy.softshrink also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.softshrink. This method simply wraps + the function, and so the docstring for ivy.softshrink also applies to this + method with minimal changes. Parameters ---------- @@ -436,9 +448,10 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.celu. This method simply - wraps the function, and so the docstring for ivy.celu also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.celu. This method simply wraps the + function, and so the docstring for ivy.celu also applies to this method with + minimal changes. Parameters ---------- @@ -475,9 +488,10 @@ def scaled_tanh( beta: float = 0.67, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.scaled_tanh. This method - simply wraps the function, and so the docstring for ivy.scaled_tanh - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.scaled_tanh. This method simply wraps + the function, and so the docstring for ivy.scaled_tanh also applies to this + method with minimal changes. Parameters ---------- @@ -523,9 +537,10 @@ def hardshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.hardshrink. This method - simply wraps the function, and so the docstring for ivy.hardshrink also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.hardshrink. This method simply wraps + the function, and so the docstring for ivy.hardshrink also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/creation.py b/ivy/data_classes/array/experimental/creation.py index 62ab0e9f1744d..6d814ee70f85b 100644 --- a/ivy/data_classes/array/experimental/creation.py +++ b/ivy/data_classes/array/experimental/creation.py @@ -16,9 +16,10 @@ def eye_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.eye_like. This method - simply wraps the function, and so the docstring for ivy.eye_like also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.eye_like. This method simply wraps the + function, and so the docstring for ivy.eye_like also applies to this method with + minimal changes. Parameters ---------- @@ -59,10 +60,10 @@ def unsorted_segment_min( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - r"""ivy.Array instance method variant of ivy.unsorted_segment_min. This - method simply wraps the function, and so the docstring for - ivy.unsorted_segment_min also applies to this method with minimal - changes. + r""" + ivy.Array instance method variant of ivy.unsorted_segment_min. This method + simply wraps the function, and so the docstring for ivy.unsorted_segment_min + also applies to this method with minimal changes. Note ---- @@ -96,10 +97,10 @@ def unsorted_segment_sum( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - r"""ivy.Array instance method variant of ivy.unsorted_segment_sum. This - method simply wraps the function, and so the docstring for - ivy.unsorted_segment_sum also applies to this method with minimal - changes. + r""" + ivy.Array instance method variant of ivy.unsorted_segment_sum. This method + simply wraps the function, and so the docstring for ivy.unsorted_segment_sum + also applies to this method with minimal changes. Parameters ---------- @@ -132,9 +133,10 @@ def blackman_window( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.blackman_window. This - method simply wraps the function, and so the docstring for - ivy.blackman_window also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.blackman_window. This method simply + wraps the function, and so the docstring for ivy.blackman_window also applies to + this method with minimal changes. Parameters ---------- @@ -179,9 +181,10 @@ def trilu( upper: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.trilu. This method simply - wraps the function, and so the docstring for ivy.trilu also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.trilu. This method simply wraps the + function, and so the docstring for ivy.trilu also applies to this method with + minimal changes. Parameters ---------- @@ -217,10 +220,10 @@ def mel_weight_matrix( lower_edge_hertz: Optional[Union[float, ivy.Array]] = 0.0, upper_edge_hertz: Optional[Union[float, ivy.Array]] = 3000.0, ): - """Generate a MelWeightMatrix that can be used to re-weight a Tensor - containing a linearly sampled frequency spectra (from DFT or STFT) into - num_mel_bins frequency information based on the [lower_edge_hertz, - upper_edge_hertz] + """ + Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a + linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins + frequency information based on the [lower_edge_hertz, upper_edge_hertz] range on the mel scale. This function defines the mel scale in terms of a frequency in hertz according to the following @@ -267,8 +270,8 @@ def unsorted_segment_mean( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - """Compute the mean of values in the array 'self' based on segment - identifiers. + """ + Compute the mean of values in the array 'self' based on segment identifiers. Parameters ---------- @@ -315,9 +318,9 @@ def polyval( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.Array: - """ivy.Array instance method of polyval. This method simply wraps the - function, and so the docstring for ivy.polyval also applies to this method - with minimal changes. + """ + ivy.Array instance method of polyval. This method simply wraps the function, and so + the docstring for ivy.polyval also applies to this method with minimal changes. Evaluate and return a polynomial at specific given values. diff --git a/ivy/data_classes/array/experimental/elementwise.py b/ivy/data_classes/array/experimental/elementwise.py index f48d1b303fc55..31e4245b01f15 100644 --- a/ivy/data_classes/array/experimental/elementwise.py +++ b/ivy/data_classes/array/experimental/elementwise.py @@ -16,9 +16,10 @@ def amax( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.amax. This method simply - wraps the function, and so the docstring for ivy.amax also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.amax. This method simply wraps the + function, and so the docstring for ivy.amax also applies to this method with + minimal changes. Parameters ---------- @@ -77,9 +78,10 @@ def amin( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.amin. This method simply - wraps the function, and so the docstring for ivy.amin also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.amin. This method simply wraps the + function, and so the docstring for ivy.amin also applies to this method with + minimal changes. Parameters ---------- @@ -131,9 +133,10 @@ def amin( return ivy.amin(self._data, axis=axis, keepdims=keepdims, out=out) def lgamma(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.lgamma. This method simply - wraps the function, and so the docstring for ivy.lgamma also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.lgamma. This method simply wraps the + function, and so the docstring for ivy.lgamma also applies to this method with + minimal changes. Parameters ---------- @@ -165,9 +168,10 @@ def lgamma(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.lgamma(self._data, out=out) def sinc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.sinc. This method simply - wraps the function, and so the docstring for ivy.sinc also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.sinc. This method simply wraps the + function, and so the docstring for ivy.sinc also applies to this method with + minimal changes. Parameters ---------- @@ -201,9 +205,10 @@ def fmod( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.fmod. This method simply - wraps the function, and so the docstring for ivy.fmod also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.fmod. This method simply wraps the + function, and so the docstring for ivy.fmod also applies to this method with + minimal changes. Parameters ---------- @@ -240,9 +245,10 @@ def fmax( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.fmax. This method simply - wraps the function, and so the docstring for ivy.fmax also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.fmax. This method simply wraps the + function, and so the docstring for ivy.fmax also applies to this method with + minimal changes. Parameters ---------- @@ -279,9 +285,10 @@ def float_power( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.float_power. This method - simply wraps the function, and so the docstring for ivy.float_power - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.float_power. This method simply wraps + the function, and so the docstring for ivy.float_power also applies to this + method with minimal changes. Parameters ---------- @@ -319,9 +326,10 @@ def copysign( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.copysign. This method - simply wraps the function, and so the docstring for ivy.copysign also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.copysign. This method simply wraps the + function, and so the docstring for ivy.copysign also applies to this method with + minimal changes. Parameters ---------- @@ -359,9 +367,10 @@ def count_nonzero( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.count_nonzero. This method - simply wraps the function, and so the docstring for ivy.count_nonzero - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.count_nonzero. This method simply wraps + the function, and so the docstring for ivy.count_nonzero also applies to this + method with minimal changes. Parameters ---------- @@ -412,9 +421,10 @@ def nansum( keepdims: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.nansum. This method simply - wraps the function, and so the docstring for ivy.nansum also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nansum. This method simply wraps the + function, and so the docstring for ivy.nansum also applies to this method with + minimal changes. Parameters ---------- @@ -463,9 +473,10 @@ def isclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.isclose. This method simply - wraps the function, and so the docstring for ivy.isclose also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.isclose. This method simply wraps the + function, and so the docstring for ivy.isclose also applies to this method with + minimal changes. Parameters ---------- @@ -517,9 +528,10 @@ def signbit( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.signbit. This method simply - wraps the function, and so the docstring for ivy.signbit also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.signbit. This method simply wraps the + function, and so the docstring for ivy.signbit also applies to this method with + minimal changes. Parameters ---------- @@ -548,9 +560,10 @@ def hypot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.hypot. This method simply - wraps the function, and so the docstring for ivy.hypot also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.hypot. This method simply wraps the + function, and so the docstring for ivy.hypot also applies to this method with + minimal changes. Parameters ---------- @@ -587,9 +600,10 @@ def allclose( equal_nan: bool = False, out: Optional[ivy.Container] = None, ) -> bool: - """ivy.Array instance method variant of ivy.allclose. This method - simply wraps the function, and so the docstring for ivy.allclose also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.allclose. This method simply wraps the + function, and so the docstring for ivy.allclose also applies to this method with + minimal changes. Parameters ---------- @@ -648,9 +662,10 @@ def diff( append: Optional[Union[ivy.Array, ivy.NativeArray, int, list, tuple]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.diff. This method simply - wraps the function, and so the docstring for ivy.diff also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.diff. This method simply wraps the + function, and so the docstring for ivy.diff also applies to this method with + minimal changes. Parameters ---------- @@ -690,9 +705,10 @@ def fix( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.fix. This method simply - wraps the function, and so the docstring for ivy.fix also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.fix. This method simply wraps the + function, and so the docstring for ivy.fix also applies to this method with + minimal changes. Parameters ---------- @@ -722,9 +738,10 @@ def nextafter( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.nextafter. This method - simply wraps the function, and so the docstring for ivy.nextafter also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nextafter. This method simply wraps the + function, and so the docstring for ivy.nextafter also applies to this method + with minimal changes. Parameters ---------- @@ -757,9 +774,10 @@ def zeta( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.zeta. This method simply - wraps the function, and so the docstring for ivy.zeta also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.zeta. This method simply wraps the + function, and so the docstring for ivy.zeta also applies to this method with + minimal changes. Parameters ---------- @@ -794,7 +812,8 @@ def gradient( edge_order: int = 1, axis: Optional[Union[int, list, tuple]] = None, ) -> Union[ivy.Array, List[ivy.Array]]: - """Calculate gradient of x with respect to (w.r.t.) spacing. + """ + Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -866,9 +885,10 @@ def xlogy( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.xlogy. This method simply - wraps the function, and so the docstring for ivy.xlogy also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.xlogy. This method simply wraps the + function, and so the docstring for ivy.xlogy also applies to this method with + minimal changes. Parameters ---------- @@ -902,8 +922,9 @@ def xlogy( def binarizer( self: ivy.Array, /, *, threshold: float = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """Map the values of the input tensor to either 0 or 1, element-wise, - based on the outcome of a comparison against a threshold value. + """ + Map the values of the input tensor to either 0 or 1, element-wise, based on the + outcome of a comparison against a threshold value. Parameters ---------- @@ -924,9 +945,10 @@ def binarizer( return ivy.binarizer(self._data, threshold=threshold, out=out) def conj(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.conj. This method simply - wraps the function, and so the docstring for ivy.conj also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.conj. This method simply wraps the + function, and so the docstring for ivy.conj also applies to this method with + minimal changes. Parameters ---------- @@ -958,9 +980,10 @@ def lerp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.lerp. This method simply - wraps the function, and so the docstring for ivy.lerp also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.lerp. This method simply wraps the + function, and so the docstring for ivy.lerp also applies to this method with + minimal changes. Parameters ---------- @@ -998,9 +1021,10 @@ def ldexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.ldexp. This method simply - wraps the function, and so the docstring for ivy.ldexp also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.ldexp. This method simply wraps the + function, and so the docstring for ivy.ldexp also applies to this method with + minimal changes. Parameters ---------- @@ -1029,9 +1053,10 @@ def ldexp( def frexp( self: ivy.Array, /, *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None ) -> ivy.Array: - """ivy.Array instance method variant of ivy.frexp. This method simply - wraps the function, and so the docstring for ivy.frexp also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.frexp. This method simply wraps the + function, and so the docstring for ivy.frexp also applies to this method with + minimal changes. Parameters ---------- @@ -1057,9 +1082,10 @@ def frexp( def modf( self: ivy.Array, /, *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None ) -> Tuple[ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.modf. This method simply - wraps the function, and so the docstring for ivy.modf also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.modf. This method simply wraps the + function, and so the docstring for ivy.modf also applies to this method with + minimal changes. Parameters ---------- @@ -1088,9 +1114,10 @@ def digamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.digamma. This method simply - wraps the function, and so the docstring for ivy.digamma also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.digamma. This method simply wraps the + function, and so the docstring for ivy.digamma also applies to this method with + minimal changes. Note ---- @@ -1125,9 +1152,10 @@ def sparsify_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array class method variant of ivy.sparsify_tensor. This method - simply wraps the function, and so the docstring for ivy.sparsify_tensor - also applies to this method with minimal changes. + """ + ivy.Array class method variant of ivy.sparsify_tensor. This method simply wraps + the function, and so the docstring for ivy.sparsify_tensor also applies to this + method with minimal changes. Parameters ---------- @@ -1167,9 +1195,10 @@ def erfc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.erfc. This method simply - wraps the function, and so the docstring for ivy.erfc also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.erfc. This method simply wraps the + function, and so the docstring for ivy.erfc also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/general.py b/ivy/data_classes/array/experimental/general.py index c51957e6b51bb..d07f50f94981c 100644 --- a/ivy/data_classes/array/experimental/general.py +++ b/ivy/data_classes/array/experimental/general.py @@ -16,9 +16,10 @@ def reduce( axes: Union[int, Sequence[int]] = 0, keepdims: bool = False, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.reduce. This method simply - wraps the function, and so the docstring for ivy.reduce also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.reduce. This method simply wraps the + function, and so the docstring for ivy.reduce also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/layers.py b/ivy/data_classes/array/experimental/layers.py index 257b29e8d766e..3c9513e22d960 100644 --- a/ivy/data_classes/array/experimental/layers.py +++ b/ivy/data_classes/array/experimental/layers.py @@ -19,9 +19,10 @@ def max_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of `ivy.max_pool1d`. This method - simply wraps the function, and so the docstring for `ivy.max_pool1d` - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of `ivy.max_pool1d`. This method simply wraps + the function, and so the docstring for `ivy.max_pool1d` also applies to this + method with minimal changes. Parameters ---------- @@ -86,9 +87,10 @@ def max_pool2d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of `ivy.max_pool2d`. This method - simply wraps the function, and so the docstring for `ivy.max_pool2d` - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of `ivy.max_pool2d`. This method simply wraps + the function, and so the docstring for `ivy.max_pool2d` also applies to this + method with minimal changes. Parameters ---------- @@ -164,7 +166,8 @@ def max_pool3d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 3-D max pool given 5-D input x. + """ + Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -228,9 +231,10 @@ def avg_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of `ivy.avg_pool1d`. This method - simply wraps the function, and so the docstring for `ivy.avg_pool1d` - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of `ivy.avg_pool1d`. This method simply wraps + the function, and so the docstring for `ivy.avg_pool1d` also applies to this + method with minimal changes. Parameters ---------- @@ -296,9 +300,10 @@ def avg_pool2d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of `ivy.avg_pool2d`. This method - simply wraps the function, and so the docstring for `ivy.avg_pool2d` - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of `ivy.avg_pool2d`. This method simply wraps + the function, and so the docstring for `ivy.avg_pool2d` also applies to this + method with minimal changes. Parameters ---------- @@ -372,7 +377,8 @@ def avg_pool3d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 3-D max pool given 5-D input x. + """ + Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -437,9 +443,10 @@ def dct( norm: Optional[Literal["ortho"]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.dct. This method simply - wraps the function, and so the docstring for ivy.dct also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dct. This method simply wraps the + function, and so the docstring for ivy.dct also applies to this method with + minimal changes. Parameters ---------- @@ -485,9 +492,10 @@ def idct( norm: Optional[Literal["ortho"]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.idct. This method simply - wraps the function, and so the docstring for ivy.idct also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.idct. This method simply wraps the + function, and so the docstring for ivy.idct also applies to this method with + minimal changes. Parameters ---------- @@ -533,9 +541,10 @@ def fft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.ifft. This method simply - wraps the function, and so the docstring for ivy.ifft also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.ifft. This method simply wraps the + function, and so the docstring for ivy.ifft also applies to this method with + minimal changes. Parameters ---------- @@ -588,9 +597,10 @@ def ifft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.ifft. This method simply - wraps the function, and so the docstring for ivy.ifft also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.ifft. This method simply wraps the + function, and so the docstring for ivy.ifft also applies to this method with + minimal changes. Parameters ---------- @@ -656,7 +666,8 @@ def dft( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the discrete Fourier transform of input. + """ + Compute the discrete Fourier transform of input. Parameters ---------- @@ -740,7 +751,8 @@ def interpolate( antialias: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Down/up samples the input to the given size. The algorithm used for + """ + Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -799,8 +811,9 @@ def adaptive_avg_pool1d( self: ivy.Array, output_size: int, ) -> ivy.Array: - """Apply a 1D adaptive average pooling over an input signal composed of - several input planes. + """ + Apply a 1D adaptive average pooling over an input signal composed of several + input planes. Parameters ---------- @@ -828,8 +841,9 @@ def adaptive_avg_pool2d( *, data_format: str = "NHWC", ) -> ivy.Array: - """Apply a 2D adaptive average pooling over an input signal composed of - several input planes. + """ + Apply a 2D adaptive average pooling over an input signal composed of several + input planes. Parameters ---------- @@ -855,8 +869,9 @@ def adaptive_max_pool2d( self: ivy.Array, output_size: Union[Sequence[int], int], ) -> ivy.Array: - """Apply a 2D adaptive maximum pooling over an input signal composed of - several input planes. + """ + Apply a 2D adaptive maximum pooling over an input signal composed of several + input planes. Parameters ---------- @@ -889,8 +904,8 @@ def reduce_window( base_dilation: Union[int, Sequence[int]] = 1, window_dilation: Union[int, Sequence[int]] = 1, ) -> ivy.Array: - """Apply a reduction function to all elements in each window of an - array. + """ + Apply a reduction function to all elements in each window of an array. Parameters ---------- @@ -946,7 +961,8 @@ def fft2( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the 2-dimensional discrete Fourier Transform. + """ + Compute the 2-dimensional discrete Fourier Transform. Parameters ---------- @@ -1010,7 +1026,8 @@ def ifftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the N-dimensional inverse discrete Fourier Transform. + """ + Compute the N-dimensional inverse discrete Fourier Transform. Parameters ---------- @@ -1082,9 +1099,10 @@ def rfft( norm: Literal["backward", "ortho", "forward"] = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.rfft. This method simply - wraps the function, and so the docstring for ivy.rfft also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.rfft. This method simply wraps the + function, and so the docstring for ivy.rfft also applies to this method with + minimal changes. Parameters ---------- @@ -1136,7 +1154,8 @@ def rfftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the n-dimensional discrete Fourier Transform. + """ + Compute the n-dimensional discrete Fourier Transform. Parameters ---------- @@ -1171,7 +1190,8 @@ def stft( name: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Short-time Fourier Transform of signals. + """ + Compute the Short-time Fourier Transform of signals. Parameters ---------- @@ -1223,7 +1243,8 @@ def sliding_window( dilation: Union[int, Tuple[int, int]] = 1, padding: Union[str, int, Sequence[Tuple[int, int]]] = "VALID", ) -> ivy.Array: - """Slide a window of specified dimension over all elements of an array. + """ + Slide a window of specified dimension over all elements of an array. Parameters ---------- @@ -1278,8 +1299,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Array: - """Compute a 1-D max unpooling given the 1-D pooled input x and its - indices. + """ + Compute a 1-D max unpooling given the 1-D pooled input x and its indices. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/linear_algebra.py b/ivy/data_classes/array/experimental/linear_algebra.py index 09ff0484e31ea..7a8a99d3f288d 100644 --- a/ivy/data_classes/array/experimental/linear_algebra.py +++ b/ivy/data_classes/array/experimental/linear_algebra.py @@ -19,9 +19,10 @@ def eigh_tridiagonal( ] = None, tol: Optional[float] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array]]: - """ivy.Array instance method variant of ivy.eigh_tridiagonal. This - method simply wraps the function, and so the docstring for - ivy.eigh_tridiagonal also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.eigh_tridiagonal. This method simply + wraps the function, and so the docstring for ivy.eigh_tridiagonal also applies + to this method with minimal changes. Parameters ---------- @@ -88,9 +89,10 @@ def diagflat( num_cols: int = -1, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.diagflat. This method - simply wraps the function, and so the docstring for ivy.diagflat also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.diagflat. This method simply wraps the + function, and so the docstring for ivy.diagflat also applies to this method with + minimal changes. Examples -------- @@ -117,9 +119,10 @@ def kron( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.kron. This method simply - wraps the function, and so the docstring for ivy.kron also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.kron. This method simply wraps the + function, and so the docstring for ivy.kron also applies to this method with + minimal changes. Examples -------- @@ -131,9 +134,10 @@ def kron( return ivy.kron(self._data, b, out=out) def matrix_exp(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.kron. This method simply - wraps the function, and so the docstring for ivy.matrix_exp also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.kron. This method simply wraps the + function, and so the docstring for ivy.matrix_exp also applies to this method + with minimal changes. Examples -------- @@ -153,9 +157,10 @@ def eig( self: ivy.Array, /, ) -> Tuple[ivy.Array, ...]: - """ivy.Array instance method variant of ivy.eig. This method simply - wraps the function, and so the docstring for ivy.eig also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.eig. This method simply wraps the + function, and so the docstring for ivy.eig also applies to this method with + minimal changes. Examples -------- @@ -173,9 +178,10 @@ def eigvals( self: ivy.Array, /, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.eigvals. This method simply - wraps the function, and so the docstring for ivy.eigvals also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.eigvals. This method simply wraps the + function, and so the docstring for ivy.eigvals also applies to this method with + minimal changes. Examples -------- @@ -191,9 +197,10 @@ def adjoint( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.adjoint. This method simply - wraps the function, and so the docstring for ivy.adjoint also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.adjoint. This method simply wraps the + function, and so the docstring for ivy.adjoint also applies to this method with + minimal changes. Examples -------- @@ -216,9 +223,10 @@ def multi_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.multi_dot. This method - simply wraps the function, and so the docstring for ivy.multi_dot also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.multi_dot. This method simply wraps the + function, and so the docstring for ivy.multi_dot also applies to this method + with minimal changes. Examples -------- @@ -234,9 +242,10 @@ def multi_dot( def cond( self: ivy.Array, /, *, p: Optional[Union[int, float, str]] = None ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cond. This method simply - wraps the function, and so the docstring for ivy.cond also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cond. This method simply wraps the + function, and so the docstring for ivy.cond also applies to this method with + minimal changes. Examples -------- @@ -259,9 +268,10 @@ def mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.mode_dot. This method - simply wraps the function, and so the docstring for ivy.mode_dot also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.mode_dot. This method simply wraps the + function, and so the docstring for ivy.mode_dot also applies to this method with + minimal changes. Parameters ---------- @@ -300,9 +310,10 @@ def multi_mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""ivy.Array instance method variant of ivy.multi_mode_dot. This method - simply wraps the function, and so the docstring for ivy.multi_mode_dot - also applies to this method with minimal changes. + r""" + ivy.Array instance method variant of ivy.multi_mode_dot. This method simply + wraps the function, and so the docstring for ivy.multi_mode_dot also applies to + this method with minimal changes. Parameters ---------- @@ -346,9 +357,10 @@ def svd_flip( /, u_based_decision: Optional[bool] = True, ) -> Tuple[ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.svd_flip. This method - simply wraps the function, and so the docstring for ivy.svd_flip also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.svd_flip. This method simply wraps the + function, and so the docstring for ivy.svd_flip also applies to this method with + minimal changes. Parameters ---------- @@ -376,10 +388,10 @@ def make_svd_non_negative( *, nntype: Optional[Literal["nndsvd", "nndsvda"]] = "nndsvd", ) -> Tuple[ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.make_svd_non_negative. This - method simply wraps the function, and so the docstring for - ivy.make_svd_non_negative also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.make_svd_non_negative. This method + simply wraps the function, and so the docstring for ivy.make_svd_non_negative + also applies to this method with minimal changes. Parameters ---------- @@ -406,9 +418,10 @@ def tensor_train( svd: Optional[Literal["truncated_svd"]] = "truncated_svd", verbose: Optional[bool] = False, ) -> ivy.TTTensor: - """ivy.Array instance method variant of ivy.tensor_train. This method - simply wraps the function, and so the docstring for ivy.tensor_train - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.tensor_train. This method simply wraps + the function, and so the docstring for ivy.tensor_train also applies to this + method with minimal changes. Parameters ---------- @@ -435,10 +448,10 @@ def truncated_svd( compute_uv: bool = True, n_eigenvecs: Optional[int] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array, ivy.Array]]: - """ivy.Array instance method variant of ivy.make_svd_non_negative. This - method simply wraps the function, and so the docstring for - ivy.make_svd_non_negative also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.make_svd_non_negative. This method + simply wraps the function, and so the docstring for ivy.make_svd_non_negative + also applies to this method with minimal changes. Parameters ---------- @@ -474,9 +487,10 @@ def initialize_tucker( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, svd_mask_repeats: Optional[int] = 5, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ivy.Array instance method variant of ivy.initialize_tucker. This - method simply wraps the function, and so the docstring for - ivy.initialize_tucker also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.initialize_tucker. This method simply + wraps the function, and so the docstring for ivy.initialize_tucker also applies + to this method with minimal changes. Parameters ---------- @@ -539,9 +553,10 @@ def partial_tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ivy.Array instance method variant of ivy.partial_tucker. This method - simply wraps the function, and so the docstring for ivy.partial_tucker - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.partial_tucker. This method simply + wraps the function, and so the docstring for ivy.partial_tucker also applies to + this method with minimal changes. Parameters ---------- @@ -620,9 +635,10 @@ def tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ): - """ivy.Array instance method variant of ivy.tucker. This method simply - wraps the function, and so the docstring for ivy.tucker also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.tucker. This method simply wraps the + function, and so the docstring for ivy.tucker also applies to this method with + minimal changes. Parameters ---------- @@ -697,10 +713,10 @@ def tt_matrix_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Ivy.Array instance method variant of ivy.tt_matrix_to_tensor. This - method simply wraps the function, and so the docstring for - ivy.tt_matrix_to_tensor also applies to this method with minimal - changes. + """ + Ivy.Array instance method variant of ivy.tt_matrix_to_tensor. This method simply + wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also + applies to this method with minimal changes. Parameters ---------- @@ -750,9 +766,10 @@ def dot( *, out: Optional[ivy.Array] = None, ): - """Compute the dot product between two arrays `a` and `b` using the - current backend's implementation. The dot product is defined as the sum - of the element- wise product of the input arrays. + """ + Compute the dot product between two arrays `a` and `b` using the current + backend's implementation. The dot product is defined as the sum of the element- + wise product of the input arrays. Parameters ---------- @@ -803,10 +820,10 @@ def general_inner_product( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.general_inner_product. This - method simply wraps the function, and so the docstring for - ivy.general_inner_product also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.general_inner_product. This method + simply wraps the function, and so the docstring for ivy.general_inner_product + also applies to this method with minimal changes. Parameters ---------- @@ -858,10 +875,10 @@ def higher_order_moment( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.higher_order_moment. This - method simply wraps the function, and so the docstring for - ivy.higher_order_moment also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.higher_order_moment. This method simply + wraps the function, and so the docstring for ivy.higher_order_moment also + applies to this method with minimal changes. Parameters ---------- @@ -899,9 +916,10 @@ def batched_outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Ivy Array instance method variant of ivy.batched_outer. This method - simply wraps the function, and so the docstring for ivy.batched_outer - also applies to this method with minimal changes. + """ + Ivy Array instance method variant of ivy.batched_outer. This method simply wraps + the function, and so the docstring for ivy.batched_outer also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/losses.py b/ivy/data_classes/array/experimental/losses.py index e06132caf1638..94c60683bd2e5 100644 --- a/ivy/data_classes/array/experimental/losses.py +++ b/ivy/data_classes/array/experimental/losses.py @@ -15,9 +15,10 @@ def l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.l1_loss. This method simply - wraps the function, and so the docstring for ivy.l1_loss also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.l1_loss. This method simply wraps the + function, and so the docstring for ivy.l1_loss also applies to this method with + minimal changes. Parameters ---------- @@ -58,9 +59,10 @@ def log_poisson_loss( reduction: str = "none", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.log_poisson_loss. This - method simply wraps the function, and so the docstring for ivy.l1_loss - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.log_poisson_loss. This method simply + wraps the function, and so the docstring for ivy.l1_loss also applies to this + method with minimal changes. Parameters ---------- @@ -120,9 +122,10 @@ def huber_loss( delta: Optional[float] = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of huber_loss. This method simply - wraps the function, and so the docstring for huber_loss also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of huber_loss. This method simply wraps the + function, and so the docstring for huber_loss also applies to this method with + minimal changes. Parameters ---------- @@ -167,9 +170,10 @@ def smooth_l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy. smooth_l1_loss. This - method simply wraps the function, and so the docstring for - ivy.smooth_l1_loss also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy. smooth_l1_loss. This method simply + wraps the function, and so the docstring for ivy.smooth_l1_loss also applies to + this method with minimal changes. Parameters ---------- @@ -214,9 +218,10 @@ def soft_margin_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.soft_margin_loss. This - method simply wraps the function, and so the docstring for - ivy.soft_margin_loss also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.soft_margin_loss. This method simply + wraps the function, and so the docstring for ivy.soft_margin_loss also applies + to this method with minimal changes. Parameters ---------- @@ -256,9 +261,10 @@ def kl_div( log_target=False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.kl_div. This method simply - wraps the function, and so the docstring for ivy.kl_div also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.kl_div. This method simply wraps the + function, and so the docstring for ivy.kl_div also applies to this method with + minimal changes. Parameters ---------- @@ -302,7 +308,8 @@ def poisson_nll_loss( eps: float = 1e-8, reduction: str = "mean", ) -> ivy.Array: - r"""Compute the Poisson Negative Log Likelihood Loss. + r""" + Compute the Poisson Negative Log Likelihood Loss. This function calculates the negative log likelihood loss between the `input` and `target`under the assumption that @@ -373,9 +380,10 @@ def hinge_embedding_loss( margin: float = 1.0, reduction: str = "mean", ) -> ivy.Array: - r"""Measures loss from input `x` and label `y` with values 1 or -1. It - evaluates if two inputs are similar or not, often used for embedding or - semi-supervised learning. + r""" + Measures loss from input `x` and label `y` with values 1 or -1. It evaluates if + two inputs are similar or not, often used for embedding or semi-supervised + learning. Loss for the `n`-th sample: .. math:: diff --git a/ivy/data_classes/array/experimental/manipulation.py b/ivy/data_classes/array/experimental/manipulation.py index 013af82658b0a..f7027eafa78ab 100644 --- a/ivy/data_classes/array/experimental/manipulation.py +++ b/ivy/data_classes/array/experimental/manipulation.py @@ -29,9 +29,10 @@ def moveaxis( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.moveaxis. This method - simply wraps the function, and so the docstring for ivy.unstack also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.moveaxis. This method simply wraps the + function, and so the docstring for ivy.unstack also applies to this method with + minimal changes. Parameters ---------- @@ -73,9 +74,10 @@ def heaviside( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.heaviside. This method - simply wraps the function, and so the docstring for ivy.heaviside also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.heaviside. This method simply wraps the + function, and so the docstring for ivy.heaviside also applies to this method + with minimal changes. Parameters ---------- @@ -114,9 +116,10 @@ def flipud( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.flipud. This method simply - wraps the function, and so the docstring for ivy.flipud also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.flipud. This method simply wraps the + function, and so the docstring for ivy.flipud also applies to this method with + minimal changes. Parameters ---------- @@ -157,9 +160,10 @@ def vstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.vstack. This method simply - wraps the function, and so the docstring for ivy.vstack also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.vstack. This method simply wraps the + function, and so the docstring for ivy.vstack also applies to this method with + minimal changes. Examples -------- @@ -188,9 +192,10 @@ def hstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.hstack. This method simply - wraps the function, and so the docstring for ivy.hstack also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.hstack. This method simply wraps the + function, and so the docstring for ivy.hstack also applies to this method with + minimal changes. Examples -------- @@ -217,9 +222,10 @@ def rot90( axes: Tuple[int, int] = (0, 1), out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.rot90. This method simply - wraps the function, and so the docstring for ivy.rot90 also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.rot90. This method simply wraps the + function, and so the docstring for ivy.rot90 also applies to this method with + minimal changes. Parameters ---------- @@ -278,9 +284,10 @@ def top_k( sorted: bool = True, out: Optional[tuple] = None, ) -> Tuple[ivy.Array, ivy.NativeArray]: - """ivy.Array instance method variant of ivy.top_k. This method simply - wraps the function, and so the docstring for ivy.top_k also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.top_k. This method simply wraps the + function, and so the docstring for ivy.top_k also applies to this method with + minimal changes. Parameters ---------- @@ -322,9 +329,10 @@ def fliplr( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.fliplr. This method simply - wraps the function, and so the docstring for ivy.fliplr also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.fliplr. This method simply wraps the + function, and so the docstring for ivy.fliplr also applies to this method with + minimal changes. Parameters ---------- @@ -361,9 +369,10 @@ def i0( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.i0. This method simply - wraps the function, and so the docstring for ivy.i0 also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.i0. This method simply wraps the + function, and so the docstring for ivy.i0 also applies to this method with + minimal changes. Parameters ---------- @@ -395,9 +404,10 @@ def flatten( order: str = "C", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.flatten. This method simply - wraps the function, and so the docstring for ivy.flatten also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.flatten. This method simply wraps the + function, and so the docstring for ivy.flatten also applies to this method with + minimal changes. Parameters ---------- @@ -530,7 +540,8 @@ def pad( out: Optional[ivy.Array] = None, **kwargs: Optional[Any], ) -> ivy.Array: - """ivy.Array instance method variant of ivy.pad. + """ + ivy.Array instance method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -555,9 +566,10 @@ def vsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ivy.Array instance method variant of ivy.vsplit. This method simply - wraps the function, and so the docstring for ivy.vsplit also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.vsplit. This method simply wraps the + function, and so the docstring for ivy.vsplit also applies to this method with + minimal changes. Parameters ---------- @@ -601,9 +613,10 @@ def dsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ivy.Array instance method variant of ivy.dsplit. This method simply - wraps the function, and so the docstring for ivy.dsplit also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dsplit. This method simply wraps the + function, and so the docstring for ivy.dsplit also applies to this method with + minimal changes. Parameters ---------- @@ -646,9 +659,10 @@ def atleast_1d( *arys: Union[ivy.Array, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ivy.Array instance method variant of ivy.atleast_1d. This method - simply wraps the function, and so the docstring for ivy.atleast_1d also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.atleast_1d. This method simply wraps + the function, and so the docstring for ivy.atleast_1d also applies to this + method with minimal changes. Parameters ---------- @@ -688,9 +702,10 @@ def dstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.dstack. This method simply - wraps the function, and so the docstring for ivy.dstack also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dstack. This method simply wraps the + function, and so the docstring for ivy.dstack also applies to this method with + minimal changes. Examples -------- @@ -715,9 +730,10 @@ def atleast_2d( *arys: ivy.Array, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ivy.Array instance method variant of ivy.atleast_2d. This method - simply wraps the function, and so the docstring for ivy.atleast_2d also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.atleast_2d. This method simply wraps + the function, and so the docstring for ivy.atleast_2d also applies to this + method with minimal changes. Parameters ---------- @@ -753,9 +769,10 @@ def atleast_3d( *arys: Union[ivy.Array, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ivy.Array instance method variant of ivy.atleast_3d. This method - simply wraps the function, and so the docstring for ivy.atleast_3d also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.atleast_3d. This method simply wraps + the function, and so the docstring for ivy.atleast_3d also applies to this + method with minimal changes. Parameters ---------- @@ -799,9 +816,10 @@ def take_along_axis( mode: str = "fill", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.take_along_axis. This - method simply wraps the function, and so the docstring for - ivy.take_along_axis also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.take_along_axis. This method simply + wraps the function, and so the docstring for ivy.take_along_axis also applies to + this method with minimal changes. Parameters ---------- @@ -840,9 +858,10 @@ def hsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ivy.Array instance method variant of ivy.hsplit. This method simply - wraps the function, and so the docstring for ivy.hsplit also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.hsplit. This method simply wraps the + function, and so the docstring for ivy.hsplit also applies to this method with + minimal changes. Parameters ---------- @@ -894,8 +913,8 @@ def expand( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Broadcast the input Array following the given shape and the - broadcast rule. + """ + Broadcast the input Array following the given shape and the broadcast rule. Parameters ---------- @@ -926,7 +945,8 @@ def as_strided( strides: Sequence[int], /, ) -> ivy.Array: - """Create a copy of the input array with the given shape and strides. + """ + Create a copy of the input array with the given shape and strides. Parameters ---------- @@ -957,7 +977,8 @@ def concat_from_sequence( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Concatenate a sequence of arrays along a new or an existing axis. + """ + Concatenate a sequence of arrays along a new or an existing axis. Parameters ---------- @@ -1004,7 +1025,8 @@ def associative_scan( reverse: bool = False, axis: int = 0, ) -> ivy.Array: - """Perform an associative scan over the given array. + """ + Perform an associative scan over the given array. Parameters ---------- @@ -1030,7 +1052,8 @@ def unique_consecutive( *, axis: Optional[int] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.unique_consecutive. + """ + ivy.Array instance method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -1045,7 +1068,8 @@ def fill_diagonal( *, wrap: bool = False, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.fill_diag. + """ + ivy.Array instance method variant of ivy.fill_diag. This method simply wraps the function, and so the docstring for ivy.fill_diag also applies to this method with minimal changes. @@ -1062,7 +1086,8 @@ def take( fill_value: Optional[Number] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.take. + """ + ivy.Array instance method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -1140,7 +1165,8 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ivy.Array instance method variant of ivy.trim_zeros. + """ + ivy.Array instance method variant of ivy.trim_zeros. This method simply wraps the function, and so the docstring for ivy.trim_zeros also applies to this method with minimal changes. @@ -1180,9 +1206,10 @@ def unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.unfold. This method simply - wraps the function, and so the docstring for ivy.unfold also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.unfold. This method simply wraps the + function, and so the docstring for ivy.unfold also applies to this method with + minimal changes. Parameters ---------- @@ -1208,9 +1235,10 @@ def fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.fold. This method simply - wraps the function, and so the docstring for ivy.fold also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.fold. This method simply wraps the + function, and so the docstring for ivy.fold also applies to this method with + minimal changes. Parameters ---------- @@ -1240,9 +1268,10 @@ def partial_unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.partial_unfold. This method - simply wraps the function, and so the docstring for ivy.partial_unfold - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.partial_unfold. This method simply + wraps the function, and so the docstring for ivy.partial_unfold also applies to + this method with minimal changes. Parameters ---------- @@ -1282,9 +1311,10 @@ def partial_fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.partial_fold. This method - simply wraps the function, and so the docstring for ivy.partial_fold - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.partial_fold. This method simply wraps + the function, and so the docstring for ivy.partial_fold also applies to this + method with minimal changes. Parameters ---------- @@ -1313,10 +1343,10 @@ def partial_tensor_to_vec( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.partial_tensor_to_vec. This - method simply wraps the function, and so the docstring for - ivy.partial_tensor_to_vec also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.partial_tensor_to_vec. This method + simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec + also applies to this method with minimal changes. Parameters ---------- @@ -1344,10 +1374,10 @@ def partial_vec_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.partial_vec_to_tensor. This - method simply wraps the function, and so the docstring for - ivy.partial_vec_to_tensor also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.partial_vec_to_tensor. This method + simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor + also applies to this method with minimal changes. Parameters ---------- @@ -1375,9 +1405,10 @@ def matricize( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.matricize. This method - simply wraps the function, and so the docstring for ivy.matricize also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.matricize. This method simply wraps the + function, and so the docstring for ivy.matricize also applies to this method + with minimal changes. Parameters ---------- @@ -1404,9 +1435,10 @@ def soft_thresholding( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.soft_thresholding. This - method simply wraps the function, and so the docstring for - ivy.soft_thresholding also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.soft_thresholding. This method simply + wraps the function, and so the docstring for ivy.soft_thresholding also applies + to this method with minimal changes. Parameters ---------- @@ -1433,7 +1465,8 @@ def column_stack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.column_stack. + """ + ivy.Array instance method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -1471,7 +1504,8 @@ def put_along_axis( mode: Literal["sum", "min", "max", "mul", "mean", "replace"] = "replace", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.put_along_axis. + """ + ivy.Array instance method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal diff --git a/ivy/data_classes/array/experimental/norms.py b/ivy/data_classes/array/experimental/norms.py index 6d8be11765f95..916c63a32a521 100644 --- a/ivy/data_classes/array/experimental/norms.py +++ b/ivy/data_classes/array/experimental/norms.py @@ -12,7 +12,8 @@ def l1_normalize( axis: Optional[Union[int, Tuple[int, ...]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Normalize the array to have unit L1 norm. + """ + Normalize the array to have unit L1 norm. Parameters ---------- @@ -45,7 +46,8 @@ def l2_normalize( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Normalize the array to have unit L2 norm. + """ + Normalize the array to have unit L2 norm. Parameters ---------- @@ -87,9 +89,10 @@ def batch_norm( data_format: str = "NSC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.batch_norm. This method - simply wraps the function, and so the docstring for ivy.batch_norm also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.batch_norm. This method simply wraps + the function, and so the docstring for ivy.batch_norm also applies to this + method with minimal changes. Parameters ---------- @@ -157,9 +160,10 @@ def instance_norm( data_format: str = "NSC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.instance_norm. This method - simply wraps the function, and so the docstring for ivy.instance_norm - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.instance_norm. This method simply wraps + the function, and so the docstring for ivy.instance_norm also applies to this + method with minimal changes. Parameters ---------- @@ -222,9 +226,10 @@ def group_norm( data_format: Optional[str] = "NSC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.group_norm. This method - simply wraps the function, and so the docstring for ivy.group_norm also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.group_norm. This method simply wraps + the function, and so the docstring for ivy.group_norm also applies to this + method with minimal changes. Parameters ---------- @@ -272,7 +277,8 @@ def lp_normalize( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Normalize the array to have Lp norm. + """ + Normalize the array to have Lp norm. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/random.py b/ivy/data_classes/array/experimental/random.py index 8c5f407e350e0..cd067cd304ba2 100644 --- a/ivy/data_classes/array/experimental/random.py +++ b/ivy/data_classes/array/experimental/random.py @@ -16,9 +16,10 @@ def dirichlet( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.dirichlet. This method - simply wraps the function, and so the docstring for ivy.shuffle also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dirichlet. This method simply wraps the + function, and so the docstring for ivy.shuffle also applies to this method with + minimal changes. Parameters ---------- @@ -70,9 +71,10 @@ def beta( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.beta. This method simply - wraps the function, and so the docstring for ivy.beta also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.beta. This method simply wraps the + function, and so the docstring for ivy.beta also applies to this method with + minimal changes. Parameters ---------- @@ -120,9 +122,10 @@ def gamma( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.gamma. This method simply - wraps the function, and so the docstring for ivy.gamma also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.gamma. This method simply wraps the + function, and so the docstring for ivy.gamma also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/searching.py b/ivy/data_classes/array/experimental/searching.py index 99b5925179417..6dc82e7b1716a 100644 --- a/ivy/data_classes/array/experimental/searching.py +++ b/ivy/data_classes/array/experimental/searching.py @@ -14,9 +14,10 @@ def unravel_index( *, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array]: - """ivy.Array instance method variant of ivy.unravel_index. This method - simply wraps the function, and so the docstring for ivy.unravel_index - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.unravel_index. This method simply wraps + the function, and so the docstring for ivy.unravel_index also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/sorting.py b/ivy/data_classes/array/experimental/sorting.py index a073f02fd812e..e3aa93f401e0b 100644 --- a/ivy/data_classes/array/experimental/sorting.py +++ b/ivy/data_classes/array/experimental/sorting.py @@ -15,9 +15,10 @@ def lexsort( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.lexsort. This method simply - wraps the function, and so the docstring for ivy.lexsort also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.lexsort. This method simply wraps the + function, and so the docstring for ivy.lexsort also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/statistical.py b/ivy/data_classes/array/experimental/statistical.py index 8b8570f8d885d..d206ff796fae0 100644 --- a/ivy/data_classes/array/experimental/statistical.py +++ b/ivy/data_classes/array/experimental/statistical.py @@ -21,9 +21,10 @@ def histogram( density: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.histogram. This method - simply wraps the function, and so the docstring for ivy.histogram also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.histogram. This method simply wraps the + function, and so the docstring for ivy.histogram also applies to this method + with minimal changes. Parameters ---------- @@ -96,9 +97,10 @@ def median( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.median. This method simply - wraps the function, and so the docstring for ivy.median also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.median. This method simply wraps the + function, and so the docstring for ivy.median also applies to this method with + minimal changes. Parameters ---------- @@ -137,9 +139,10 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.nanmean. This method simply - wraps the function, and so the docstring for ivy.nanmean also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nanmean. This method simply wraps the + function, and so the docstring for ivy.nanmean also applies to this method with + minimal changes. Parameters ---------- @@ -187,9 +190,10 @@ def nanmin( where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.nanmin. This method simply - wraps the function, and so the docstring for ivy.min also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nanmin. This method simply wraps the + function, and so the docstring for ivy.min also applies to this method with + minimal changes. Parameters ---------- @@ -242,9 +246,10 @@ def nanprod( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.nanprod. This method simply - wraps the function, and so the docstring for ivy.prod also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nanprod. This method simply wraps the + function, and so the docstring for ivy.prod also applies to this method with + minimal changes. Parameters ---------- @@ -300,9 +305,10 @@ def quantile( interpolation: str = "linear", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.quantile. This method - simply wraps the function, and so the docstring for ivy.quantile also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.quantile. This method simply wraps the + function, and so the docstring for ivy.quantile also applies to this method with + minimal changes. Parameters ---------- @@ -383,9 +389,10 @@ def corrcoef( rowvar: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.corrcoef. This method - simply wraps the function, and so the docstring for ivy.corrcoef also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.corrcoef. This method simply wraps the + function, and so the docstring for ivy.corrcoef also applies to this method with + minimal changes. Parameters ---------- @@ -426,9 +433,10 @@ def nanmedian( overwrite_input: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.nanmedian. This method - simply wraps the function, and so the docstring for ivy.nanmedian also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nanmedian. This method simply wraps the + function, and so the docstring for ivy.nanmedian also applies to this method + with minimal changes. Parameters ---------- @@ -488,9 +496,10 @@ def bincount( minlength: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.bincount. This method - simply wraps the function, and so the docstring for ivy.bincount also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.bincount. This method simply wraps the + function, and so the docstring for ivy.bincount also applies to this method with + minimal changes. Parameters ---------- @@ -533,9 +542,10 @@ def igamma( x: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.igamma. This method simply - wraps the function, and so the docstring for ivy.igamma also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.igamma. This method simply wraps the + function, and so the docstring for ivy.igamma also applies to this method with + minimal changes. Parameters ---------- @@ -577,9 +587,10 @@ def cov( aweights: Optional[ivy.Array] = None, dtype: Optional[type] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cov. This method simply - wraps the function, and so the docstring for ivy.cov also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cov. This method simply wraps the + function, and so the docstring for ivy.cov also applies to this method with + minimal changes. Parameters ---------- @@ -661,9 +672,10 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cummax. This method simply - wraps the function, and so the docstring for ivy.cummax also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cummax. This method simply wraps the + function, and so the docstring for ivy.cummax also applies to this method with + minimal changes. Parameters ---------- @@ -730,9 +742,10 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cummin. This method simply - wraps the function, and so the docstring for ivy.cummin also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cummin. This method simply wraps the + function, and so the docstring for ivy.cummin also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/utility.py b/ivy/data_classes/array/experimental/utility.py index d8f8c8e8554c1..46aaccd3510ad 100644 --- a/ivy/data_classes/array/experimental/utility.py +++ b/ivy/data_classes/array/experimental/utility.py @@ -13,10 +13,11 @@ def optional_get_element( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """If the input is a tensor or sequence type, it returns the input. If - the input is an optional type, it outputs the element in the input. It - is an error if the input is an empty optional-type (i.e. does not have - an element) and the behavior is undefined in this case. + """ + If the input is a tensor or sequence type, it returns the input. If the input is + an optional type, it outputs the element in the input. It is an error if the + input is an empty optional-type (i.e. does not have an element) and the behavior + is undefined in this case. Parameters ---------- diff --git a/ivy/data_classes/array/general.py b/ivy/data_classes/array/general.py index 8aa3194c8caf2..87d5bae046c94 100644 --- a/ivy/data_classes/array/general.py +++ b/ivy/data_classes/array/general.py @@ -17,9 +17,10 @@ def is_native_array( *, exclusive: bool = False, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.is_native_array. This - method simply wraps the function, and so the docstring for - ivy.is_native_array also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.is_native_array. This method simply + wraps the function, and so the docstring for ivy.is_native_array also applies to + this method with minimal changes. Parameters ---------- @@ -44,9 +45,10 @@ def is_native_array( return ivy.is_native_array(self, exclusive=exclusive) def is_ivy_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: - """ivy.Array instance method variant of ivy.is_ivy_array. This method - simply wraps the function, and so the docstring for ivy.is_ivy_array - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.is_ivy_array. This method simply wraps + the function, and so the docstring for ivy.is_ivy_array also applies to this + method with minimal changes. Parameters ---------- @@ -71,9 +73,10 @@ def is_ivy_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: return ivy.is_ivy_array(self, exclusive=exclusive) def is_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: - """ivy.Array instance method variant of ivy.is_array. This method - simply wraps the function, and so the docstring for ivy.is_array also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.is_array. This method simply wraps the + function, and so the docstring for ivy.is_array also applies to this method with + minimal changes. Parameters ---------- @@ -97,9 +100,10 @@ def is_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: return ivy.is_array(self, exclusive=exclusive) def is_ivy_container(self: ivy.Array) -> bool: - """ivy.Array instance method variant of ivy.is_ivy_container. This - method simply wraps the function, and so the docstring for - ivy.is_ivy_container also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.is_ivy_container. This method simply + wraps the function, and so the docstring for ivy.is_ivy_container also applies + to this method with minimal changes. Parameters ---------- @@ -122,9 +126,10 @@ def is_ivy_container(self: ivy.Array) -> bool: def all_equal( self: ivy.Array, *x2: Iterable[Any], equality_matrix: bool = False ) -> Union[bool, ivy.Array, ivy.NativeArray]: - """ivy.Array instance method variant of ivy.all_equal. This method - simply wraps the function, and so the docstring for ivy.all_equal also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.all_equal. This method simply wraps the + function, and so the docstring for ivy.all_equal also applies to this method + with minimal changes. Parameters ---------- @@ -163,9 +168,10 @@ def all_equal( return ivy.all_equal(*arrays, equality_matrix=equality_matrix) def has_nans(self: ivy.Array, /, *, include_infs: bool = True): - """ivy.Array instance method variant of ivy.has_nans. This method - simply wraps the function, and so the docstring for ivy.has_nans also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.has_nans. This method simply wraps the + function, and so the docstring for ivy.has_nans also applies to this method with + minimal changes. Parameters ---------- @@ -198,9 +204,10 @@ def gather( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.gather. This method simply - wraps the function, and so the docstring for ivy.gather also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.gather. This method simply wraps the + function, and so the docstring for ivy.gather also applies to this method with + minimal changes. Parameters ---------- @@ -270,7 +277,8 @@ def scatter_nd( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Scatter updates into an array according to indices. + """ + Scatter updates into an array according to indices. Parameters ---------- @@ -323,9 +331,10 @@ def gather_nd( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.gather_nd. This method - simply wraps the function, and so the docstring for ivy.gather_nd also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.gather_nd. This method simply wraps the + function, and so the docstring for ivy.gather_nd also applies to this method + with minimal changes. Parameters ---------- @@ -362,9 +371,10 @@ def einops_rearrange( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ivy.Array instance method variant of ivy.einops_rearrange. This - method simply wraps the function, and so the docstring for - ivy.einops_rearrange also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.einops_rearrange. This method simply + wraps the function, and so the docstring for ivy.einops_rearrange also applies + to this method with minimal changes. Parameters ---------- @@ -423,9 +433,10 @@ def einops_reduce( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ivy.Array instance method variant of ivy.einops_reduce. This method - simply wraps the function, and so the docstring for ivy.einops_reduce - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.einops_reduce. This method simply wraps + the function, and so the docstring for ivy.einops_reduce also applies to this + method with minimal changes. Parameters ---------- @@ -484,9 +495,10 @@ def einops_repeat( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ivy.Array instance method variant of ivy.einops_repeat. This method - simply wraps the function, and so the docstring for ivy.einops_repeat - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.einops_repeat. This method simply wraps + the function, and so the docstring for ivy.einops_repeat also applies to this + method with minimal changes. Parameters ---------- @@ -528,9 +540,10 @@ def einops_repeat( return ivy.einops_repeat(self._data, pattern, out=out, **axes_lengths) def to_numpy(self: ivy.Array, /, *, copy: bool = True) -> np.ndarray: - """ivy.Array instance method variant of ivy.to_numpy. This method - simply wraps the function, and so the docstring for ivy.to_numpy also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.to_numpy. This method simply wraps the + function, and so the docstring for ivy.to_numpy also applies to this method with + minimal changes. Parameters ---------- @@ -563,9 +576,10 @@ def to_numpy(self: ivy.Array, /, *, copy: bool = True) -> np.ndarray: return ivy.to_numpy(self, copy=copy) def to_list(self: ivy.Array, /) -> List: - """ivy.Array instance method variant of ivy.to_list. This method simply - wraps the function, and so the docstring for ivy.to_list also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.to_list. This method simply wraps the + function, and so the docstring for ivy.to_list also applies to this method with + minimal changes. Parameters ---------- @@ -591,8 +605,9 @@ def to_list(self: ivy.Array, /) -> List: def to_file( self: ivy.Array, fid: Union[str, bytes, int], sep: str = "", format_: str = "%s" ) -> None: - """ivy.Array instance method variant of to_file. Write array to a file - as text or binary. The data is always written in 'C' order. + """ + ivy.Array instance method variant of to_file. Write array to a file as text or + binary. The data is always written in 'C' order. Parameters ---------- @@ -625,10 +640,10 @@ def to_file( return ivy.to_file(self, fid, sep, format_) def supports_inplace_updates(self: ivy.Array, /) -> bool: - """ivy.Array instance method variant of ivy.supports_inplace_updates. - This method simply wraps the function, and so the docstring for - ivy.supports_inplace_updates also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.supports_inplace_updates. This method + simply wraps the function, and so the docstring for ivy.supports_inplace_updates + also applies to this method with minimal changes. Parameters ---------- @@ -662,9 +677,10 @@ def supports_inplace_updates(self: ivy.Array, /) -> bool: def inplace_decrement( self: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray] ) -> ivy.Array: - """ivy.Array instance method variant of ivy.inplace_decrement. This - method simply wraps the function, and so the docstring for - ivy.inplace_decrement also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.inplace_decrement. This method simply + wraps the function, and so the docstring for ivy.inplace_decrement also applies + to this method with minimal changes. Parameters ---------- @@ -703,9 +719,10 @@ def stable_divide( Union[Number, ivy.Array, ivy.NativeArray, ivy.Container] ] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.stable_divide. This method - simply wraps the function, and so the docstring for ivy.stable_divide - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.stable_divide. This method simply wraps + the function, and so the docstring for ivy.stable_divide also applies to this + method with minimal changes. Parameters ---------- @@ -753,9 +770,10 @@ def clip_vector_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.clip_vector_norm. This - method simply wraps the function, and so the docstring for - ivy.clip_vector_norm also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.clip_vector_norm. This method simply + wraps the function, and so the docstring for ivy.clip_vector_norm also applies + to this method with minimal changes. Parameters ---------- @@ -787,9 +805,10 @@ def clip_vector_norm( return ivy.clip_vector_norm(self, max_norm, p=p, out=out) def array_equal(self: ivy.Array, x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """ivy.Array instance method variant of ivy.array_equal. This method - simply wraps the function, and so the docstring for ivy.array_equal - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.array_equal. This method simply wraps + the function, and so the docstring for ivy.array_equal also applies to this + method with minimal changes. Parameters ---------- @@ -826,10 +845,10 @@ def array_equal(self: ivy.Array, x: Union[ivy.Array, ivy.NativeArray], /) -> boo return ivy.array_equal(self, x) def assert_supports_inplace(self: ivy.Array, /) -> bool: - """ivy.Array instance method variant of ivy.assert_supports_inplace. - This method simply wraps the function, and so the docstring for - ivy.assert_supports_inplace also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.assert_supports_inplace. This method + simply wraps the function, and so the docstring for ivy.assert_supports_inplace + also applies to this method with minimal changes. Parameters ---------- @@ -860,9 +879,10 @@ def assert_supports_inplace(self: ivy.Array, /) -> bool: return ivy.assert_supports_inplace(self) def to_scalar(self: ivy.Array) -> Number: - """ivy.Array instance method variant of ivy.to_scalar. This method - simply wraps the function, and so the docstring for ivy.to_scalar also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.to_scalar. This method simply wraps the + function, and so the docstring for ivy.to_scalar also applies to this method + with minimal changes. Parameters ---------- @@ -895,9 +915,10 @@ def fourier_encode( concat: bool = True, flatten: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Tuple]: - """ivy.Array instance method variant of ivy.fourier_encode. This method - simply wraps the function, and so the docstring for ivy.fourier_encode - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.fourier_encode. This method simply + wraps the function, and so the docstring for ivy.fourier_encode also applies to + this method with minimal changes. Parameters ---------- @@ -958,9 +979,10 @@ def fourier_encode( ) def value_is_nan(self: ivy.Array, /, *, include_infs: bool = True) -> bool: - """ivy.Array instance method variant of ivy.value_is_nan. This method - simply wraps the function, and so the docstring for ivy.value_is_nan - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.value_is_nan. This method simply wraps + the function, and so the docstring for ivy.value_is_nan also applies to this + method with minimal changes. Parameters ---------- @@ -1001,9 +1023,10 @@ def value_is_nan(self: ivy.Array, /, *, include_infs: bool = True) -> bool: return ivy.value_is_nan(self, include_infs=include_infs) def exists(self: ivy.Array, /) -> bool: - """ivy.Array instance method variant of ivy.exists. This method simply - wraps the function, and so the docstring for ivy.exists also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.exists. This method simply wraps the + function, and so the docstring for ivy.exists also applies to this method with + minimal changes. Parameters ---------- @@ -1038,9 +1061,10 @@ def default( rev: bool = False, with_callable: bool = False, ) -> Any: - """ivy.Array instance method variant of ivy.default. This method simply - wraps the function, and so the docstring for ivy.default also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.default. This method simply wraps the + function, and so the docstring for ivy.default also applies to this method with + minimal changes. Parameters ---------- @@ -1083,9 +1107,10 @@ def stable_pow( *, min_base: Optional[float] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.stable_pow. This method - simply wraps the function, and so the docstring for ivy.stable_pow also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.stable_pow. This method simply wraps + the function, and so the docstring for ivy.stable_pow also applies to this + method with minimal changes. Parameters ---------- @@ -1127,9 +1152,10 @@ def inplace_update( ensure_in_backend: bool = False, keep_input_dtype: bool = False, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.inplace_update. This method - simply wraps the function, and so the docstring for ivy.inplace_update - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.inplace_update. This method simply + wraps the function, and so the docstring for ivy.inplace_update also applies to + this method with minimal changes. Parameters ---------- @@ -1194,9 +1220,10 @@ def inplace_update( def inplace_increment( self: ivy.Array, val: Union[ivy.Array, ivy.NativeArray] ) -> ivy.Array: - """ivy.Array instance method variant of ivy.inplace_increment. This - method wraps the function, and so the docstring for - ivy.inplace_increment also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.inplace_increment. This method wraps + the function, and so the docstring for ivy.inplace_increment also applies to + this method with minimal changes. Parameters ---------- @@ -1234,9 +1261,10 @@ def clip_matrix_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.clip_matrix_norm. This - method simply wraps the function, and so the docstring for - ivy.clip_matrix_norm also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.clip_matrix_norm. This method simply + wraps the function, and so the docstring for ivy.clip_matrix_norm also applies + to this method with minimal changes. Parameters ---------- @@ -1275,9 +1303,10 @@ def scatter_flat( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.scatter_flat. This method - simply wraps the function, and so the docstring for ivy.scatter_flat - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.scatter_flat. This method simply wraps + the function, and so the docstring for ivy.scatter_flat also applies to this + method with minimal changes. Parameters ---------- @@ -1322,9 +1351,10 @@ def scatter_flat( return ivy.scatter_flat(self, updates, size=size, reduction=reduction, out=out) def get_num_dims(self: ivy.Array, /, *, as_array: bool = False) -> int: - """ivy.Array instance method variant of ivy.shape. This method simply - wraps the function, and so the docstring for ivy.shape also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.shape. This method simply wraps the + function, and so the docstring for ivy.shape also applies to this method with + minimal changes. Parameters ---------- @@ -1366,9 +1396,10 @@ def isin( assume_unique: bool = False, invert: bool = False, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.isin. This method simply - wraps the function, and so the docstring for ivy.isin also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.isin. This method simply wraps the + function, and so the docstring for ivy.isin also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/gradients.py b/ivy/data_classes/array/gradients.py index bb0b7164d95d4..3f0cb0fda507f 100644 --- a/ivy/data_classes/array/gradients.py +++ b/ivy/data_classes/array/gradients.py @@ -16,9 +16,10 @@ def stop_gradient( preserve_type: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.stop_gradient. This method - simply wraps the function, and so the docstring for ivy.stop_gradient - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.stop_gradient. This method simply wraps + the function, and so the docstring for ivy.stop_gradient also applies to this + method with minimal changes. Parameters ---------- @@ -57,9 +58,10 @@ def adam_step( epsilon: float = 1e-7, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.adam_step. This method - simply wraps the function, and so the docstring for ivy.adam_step also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.adam_step. This method simply wraps the + function, and so the docstring for ivy.adam_step also applies to this method + with minimal changes. Parameters ---------- @@ -114,9 +116,10 @@ def optimizer_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.optimizer_update. This - method simply wraps the function, and so the docstring for - ivy.optimizer_update also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.optimizer_update. This method simply + wraps the function, and so the docstring for ivy.optimizer_update also applies + to this method with minimal changes. Parameters ---------- @@ -162,10 +165,10 @@ def gradient_descent_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.gradient_descent_update. - This method simply wraps the function, and so the docstring for - ivy.gradient_descent_update also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.gradient_descent_update. This method + simply wraps the function, and so the docstring for ivy.gradient_descent_update + also applies to this method with minimal changes. Parameters ---------- @@ -219,9 +222,10 @@ def lars_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.lars_update. This method - simply wraps the function, and so the docstring for ivy.lars_update - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.lars_update. This method simply wraps + the function, and so the docstring for ivy.lars_update also applies to this + method with minimal changes. Parameters ---------- @@ -284,9 +288,10 @@ def adam_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.adam_update. This method - simply wraps the function, and so the docstring for ivy.adam_update - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.adam_update. This method simply wraps + the function, and so the docstring for ivy.adam_update also applies to this + method with minimal changes. Parameters ---------- @@ -371,9 +376,10 @@ def lamb_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.lamb_update. This method - simply wraps the function, and so the docstring for ivy.lamb_update - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.lamb_update. This method simply wraps + the function, and so the docstring for ivy.lamb_update also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/layers.py b/ivy/data_classes/array/layers.py index 3ecec50f7bc0e..f4c42a5d6de6d 100644 --- a/ivy/data_classes/array/layers.py +++ b/ivy/data_classes/array/layers.py @@ -20,9 +20,10 @@ def linear( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.linear. This method simply - wraps the function, and so the docstring for ivy.linear also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.linear. This method simply wraps the + function, and so the docstring for ivy.linear also applies to this method with + minimal changes. Parameters ---------- @@ -77,9 +78,10 @@ def dropout( noise_shape: Optional[Sequence[int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.dropout. This method simply - wraps the function, and so the docstring for ivy.dropout also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dropout. This method simply wraps the + function, and so the docstring for ivy.dropout also applies to this method with + minimal changes. Parameters ---------- @@ -155,9 +157,10 @@ def dropout1d( data_format: str = "NWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.dropout1d. This method - simply wraps the function, and so the docstring for ivy.droput1d also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dropout1d. This method simply wraps the + function, and so the docstring for ivy.droput1d also applies to this method with + minimal changes. Parameters ---------- @@ -202,9 +205,10 @@ def dropout2d( data_format: str = "NHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.dropout2d. This method - simply wraps the function, and so the docstring for ivy.droput1d also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dropout2d. This method simply wraps the + function, and so the docstring for ivy.droput1d also applies to this method with + minimal changes. Parameters ---------- @@ -250,9 +254,10 @@ def dropout3d( data_format: str = "NDHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.dropout3d. This method - simply wraps the function, and so the docstring for ivy.droput3d also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.dropout3d. This method simply wraps the + function, and so the docstring for ivy.droput3d also applies to this method with + minimal changes. Parameters ---------- @@ -294,10 +299,11 @@ def scaled_dot_product_attention( training: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of - ivy.scaled_dot_product_attention. This method simply wraps the - function, and so the docstring for ivy.scaled_dot_product_attention - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.scaled_dot_product_attention. This + method simply wraps the function, and so the docstring for + ivy.scaled_dot_product_attention also applies to this method with minimal + changes. Parameters ---------- @@ -457,9 +463,10 @@ def conv1d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.conv1d. This method simply - wraps the function, and so the docstring for ivy.conv1d also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.conv1d. This method simply wraps the + function, and so the docstring for ivy.conv1d also applies to this method with + minimal changes. Parameters ---------- @@ -529,9 +536,10 @@ def conv1d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.conv1d_transpose. This - method simply wraps the function, and so the docstring for - ivy.conv1d_transpose also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.conv1d_transpose. This method simply + wraps the function, and so the docstring for ivy.conv1d_transpose also applies + to this method with minimal changes. Parameters ---------- @@ -602,9 +610,10 @@ def depthwise_conv2d( dilations: Union[int, Tuple[int], Tuple[int, int]] = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.depthwise_conv2d. This - method simply wraps the function, and so the docstring for - ivy.depthwise_conv2d also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.depthwise_conv2d. This method simply + wraps the function, and so the docstring for ivy.depthwise_conv2d also applies + to this method with minimal changes. Parameters ---------- @@ -662,9 +671,10 @@ def conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of `ivy.conv2d`. This method - simply wraps the function, and so the docstring for `ivy.conv2d` also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of `ivy.conv2d`. This method simply wraps the + function, and so the docstring for `ivy.conv2d` also applies to this method with + minimal changes. Parameters ---------- @@ -740,10 +750,10 @@ def conv2d_transpose( out: Optional[ivy.Array] = None, bias: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of `ivy.conv2d_transpose`. This - method simply wraps the function, and so the docstring for - `ivy.conv2d_transpose` also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of `ivy.conv2d_transpose`. This method simply + wraps the function, and so the docstring for `ivy.conv2d_transpose` also applies + to this method with minimal changes. Parameters ---------- @@ -814,9 +824,10 @@ def conv3d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of `ivy.conv3d`. This method - simply wraps the function, and so the docstring for `ivy.conv3d` also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of `ivy.conv3d`. This method simply wraps the + function, and so the docstring for `ivy.conv3d` also applies to this method with + minimal changes. Parameters ---------- @@ -885,10 +896,10 @@ def conv3d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of `ivy.conv3d_transpose`. This - method simply wraps the function, and so the docstring for - `ivy.conv3d_transpose` also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of `ivy.conv3d_transpose`. This method simply + wraps the function, and so the docstring for `ivy.conv3d_transpose` also applies + to this method with minimal changes. Parameters ---------- @@ -957,9 +968,10 @@ def lstm_update( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, recurrent_bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.lstm_update. This method - simply wraps the function, and so the docstring for ivy.lstm_update - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.lstm_update. This method simply wraps + the function, and so the docstring for ivy.lstm_update also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/linear_algebra.py b/ivy/data_classes/array/linear_algebra.py index 025932fa11f0c..a25df9d4cabb7 100644 --- a/ivy/data_classes/array/linear_algebra.py +++ b/ivy/data_classes/array/linear_algebra.py @@ -21,9 +21,10 @@ def matmul( adjoint_b: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.matmul. This method simply - wraps the function, and so the docstring for ivy.matmul also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.matmul. This method simply wraps the + function, and so the docstring for ivy.matmul also applies to this method with + minimal changes. Parameters ---------- @@ -81,9 +82,10 @@ def cholesky( upper: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cholesky. This method - simply wraps the function, and so the docstring for ivy.cholesky also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cholesky. This method simply wraps the + function, and so the docstring for ivy.cholesky also applies to this method with + minimal changes. Parameters ---------- @@ -133,9 +135,10 @@ def cross( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cross. This method simply - wraps the function, and so the docstring for ivy.cross also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cross. This method simply wraps the + function, and so the docstring for ivy.cross also applies to this method with + minimal changes. Parameters ---------- @@ -191,9 +194,10 @@ def diagonal( axis2: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.diagonal. This method - simply wraps the function, and so the docstring for ivy.diagonal also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.diagonal. This method simply wraps the + function, and so the docstring for ivy.diagonal also applies to this method with + minimal changes. Parameters ---------- @@ -270,9 +274,10 @@ def diag( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.diag. This method simply - wraps the function, and so the docstring for ivy.diag also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.diag. This method simply wraps the + function, and so the docstring for ivy.diag also applies to this method with + minimal changes. Examples -------- @@ -308,9 +313,10 @@ def eigvalsh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.eigvalsh. This method - simply wraps the function, and so the docstring for ivy.eigvalsh also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.eigvalsh. This method simply wraps the + function, and so the docstring for ivy.eigvalsh also applies to this method with + minimal changes. Parameters ---------- @@ -356,7 +362,8 @@ def inner( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the inner product of two vectors ``self`` and ``x2``. + """ + Return the inner product of two vectors ``self`` and ``x2``. Parameters ---------- @@ -414,9 +421,10 @@ def inner( def inv( self: ivy.Array, /, *, adjoint: bool = False, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ivy.Array instance method variant of ivy.inv. This method simply - wraps the function, and so the docstring for ivy.inv also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.inv. This method simply wraps the + function, and so the docstring for ivy.inv also applies to this method with + minimal changes. Parameters ---------- @@ -455,9 +463,10 @@ def matrix_norm( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.matrix_norm. This method - simply wraps the function, and so the docstring for ivy.matrix_norm - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.matrix_norm. This method simply wraps + the function, and so the docstring for ivy.matrix_norm also applies to this + method with minimal changes. Parameters ---------- @@ -516,9 +525,10 @@ def matrix_rank( hermitian: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.matrix_rank. This method - returns the rank (i.e., number of non-zero singular values) of a matrix - (or a stack of matrices). + """ + ivy.Array instance method variant of ivy.matrix_rank. This method returns the + rank (i.e., number of non-zero singular values) of a matrix (or a stack of + matrices). Parameters ---------- @@ -589,7 +599,8 @@ def matrix_rank( def matrix_transpose( self: ivy.Array, /, *, conjugate: bool = False, out: Optional[ivy.Array] = None ) -> ivy.Array: - """Transpose a matrix (or a stack of matrices) ``x``. + """ + Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -626,7 +637,8 @@ def outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the outer product between two arrays. + """ + Compute the outer product between two arrays. Parameters ---------- @@ -662,9 +674,10 @@ def pinv( rtol: Optional[Union[float, Tuple[float]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.pinv. This method simply - wraps the function, and so the docstring for ivy.pinv also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.pinv. This method simply wraps the + function, and so the docstring for ivy.pinv also applies to this method with + minimal changes. Parameters ---------- @@ -706,9 +719,10 @@ def qr( mode: str = "reduced", out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.qr. This method simply - wraps the function, and so the docstring for ivy.qr also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.qr. This method simply wraps the + function, and so the docstring for ivy.qr also applies to this method with + minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -765,9 +779,10 @@ def qr( def slogdet( self: ivy.Array, ) -> Tuple[ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.slogdet. This method simply - wraps the function, and so the docstring for ivy.slogdet also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.slogdet. This method simply wraps the + function, and so the docstring for ivy.slogdet also applies to this method with + minimal changes. Parameters ---------- @@ -821,9 +836,10 @@ def svd( compute_uv: bool = True, full_matrices: bool = True, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """ivy.Array instance method variant of ivy.svf. This method simply - wraps the function, and so the docstring for ivy.svd also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.svf. This method simply wraps the + function, and so the docstring for ivy.svd also applies to this method with + minimal changes. Parameters ---------- @@ -908,9 +924,9 @@ def trace( axis2: int = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.trace. This method Returns - the sum along the specified diagonals of a matrix (or a stack of - matrices). + """ + ivy.Array instance method variant of ivy.trace. This method Returns the sum + along the specified diagonals of a matrix (or a stack of matrices). Parameters ---------- @@ -980,8 +996,9 @@ def vector_norm( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.vector_norm. This method - computes the vector norm of a vector (or batch of vectors). + """ + ivy.Array instance method variant of ivy.vector_norm. This method computes the + vector norm of a vector (or batch of vectors). Parameters ---------- @@ -1072,8 +1089,9 @@ def vander( increasing: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.vander. This method Returns - the Vandermonde matrix of the input array. + """ + ivy.Array instance method variant of ivy.vander. This method Returns the + Vandermonde matrix of the input array. Parameters ---------- diff --git a/ivy/data_classes/array/losses.py b/ivy/data_classes/array/losses.py index b11f9d9399e3b..214c05ac5a189 100644 --- a/ivy/data_classes/array/losses.py +++ b/ivy/data_classes/array/losses.py @@ -17,9 +17,10 @@ def cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cross_entropy. This method - simply wraps the function, and so the docstring for ivy.cross_entropy - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cross_entropy. This method simply wraps + the function, and so the docstring for ivy.cross_entropy also applies to this + method with minimal changes. Parameters ---------- @@ -68,10 +69,10 @@ def binary_cross_entropy( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.binary_cross_entropy. This - method simply wraps the function, and so the docstring for - ivy.binary_cross_entropy also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.binary_cross_entropy. This method + simply wraps the function, and so the docstring for ivy.binary_cross_entropy + also applies to this method with minimal changes. Parameters ---------- @@ -133,10 +134,10 @@ def sparse_cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.sparse_cross_entropy. This - method simply wraps the function, and so the docstring for - ivy.sparse_cross_entropy also applies to this method with minimal - changes. + """ + ivy.Array instance method variant of ivy.sparse_cross_entropy. This method + simply wraps the function, and so the docstring for ivy.sparse_cross_entropy + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/manipulation.py b/ivy/data_classes/array/manipulation.py index 231a356ca6be4..b2a4abb98243a 100644 --- a/ivy/data_classes/array/manipulation.py +++ b/ivy/data_classes/array/manipulation.py @@ -32,9 +32,10 @@ def concat( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.concat. This method simply - wraps the function, and so the docstring for ivy.concat also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.concat. This method simply wraps the + function, and so the docstring for ivy.concat also applies to this method with + minimal changes. Parameters ---------- @@ -68,9 +69,10 @@ def expand_dims( axis: Union[int, Sequence[int]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.expand_dims. This method - simply wraps the function, and so the docstring for ivy.expand_dims - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.expand_dims. This method simply wraps + the function, and so the docstring for ivy.expand_dims also applies to this + method with minimal changes. Parameters ---------- @@ -114,9 +116,10 @@ def flip( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.flip. This method simply - wraps the function, and so the docstring for ivy.flip also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.flip. This method simply wraps the + function, and so the docstring for ivy.flip also applies to this method with + minimal changes. Parameters ---------- @@ -167,9 +170,10 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.permute_dims. This method - simply wraps the function, and so the docstring for ivy.permute_dims - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.permute_dims. This method simply wraps + the function, and so the docstring for ivy.permute_dims also applies to this + method with minimal changes. Parameters ---------- @@ -225,9 +229,10 @@ def reshape( allowzero: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.reshape. This method simply - wraps the function, and so the docstring for ivy.reshape also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.reshape. This method simply wraps the + function, and so the docstring for ivy.reshape also applies to this method with + minimal changes. Parameters ---------- @@ -292,9 +297,10 @@ def roll( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.roll. This method simply - wraps the function, and so the docstring for ivy.roll also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.roll. This method simply wraps the + function, and so the docstring for ivy.roll also applies to this method with + minimal changes. Parameters ---------- @@ -348,9 +354,10 @@ def squeeze( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.squeeze. This method simply - wraps the function, and so the docstring for ivy.squeeze also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.squeeze. This method simply wraps the + function, and so the docstring for ivy.squeeze also applies to this method with + minimal changes. Parameters ---------- @@ -396,9 +403,10 @@ def stack( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.stack. This method simply - wraps the function, and so the docstring for ivy.stack also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.stack also applies to this method with + minimal changes. Parameters ---------- @@ -446,9 +454,10 @@ def clip( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.clip. This method simply - wraps the function, and so the docstring for ivy.clip also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.clip. This method simply wraps the + function, and so the docstring for ivy.clip also applies to this method with + minimal changes. Parameters ---------- @@ -485,9 +494,10 @@ def constant_pad( value: Number = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.constant_pad. This method - simply wraps the function, and so the docstring for ivy.constant_pad - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.constant_pad. This method simply wraps + the function, and so the docstring for ivy.constant_pad also applies to this + method with minimal changes. Parameters ---------- @@ -526,9 +536,10 @@ def repeat( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.repeat. This method simply - wraps the function, and so the docstring for ivy.repeat also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.repeat. This method simply wraps the + function, and so the docstring for ivy.repeat also applies to this method with + minimal changes. Parameters ---------- @@ -570,9 +581,10 @@ def split( axis: int = 0, with_remainder: bool = False, ) -> List[ivy.Array]: - """ivy.Array instance method variant of ivy.split. This method simply - wraps the function, and so the docstring for ivy.split also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.split. This method simply wraps the + function, and so the docstring for ivy.split also applies to this method with + minimal changes. Parameters ---------- @@ -624,9 +636,10 @@ def swapaxes( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.swap_axes. This method - simply wraps the function, and so the docstring for ivy.split also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.swap_axes. This method simply wraps the + function, and so the docstring for ivy.split also applies to this method with + minimal changes. Parameters ---------- @@ -679,9 +692,10 @@ def tile( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.tile. This method simply - wraps the function, and so the docstring for ivy.tile also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.tile. This method simply wraps the + function, and so the docstring for ivy.tile also applies to this method with + minimal changes. Parameters ---------- @@ -724,9 +738,10 @@ def unstack( axis: int = 0, keepdims: bool = False, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.unstack. This method simply - wraps the function, and so the docstring for ivy.unstack also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.unstack. This method simply wraps the + function, and so the docstring for ivy.unstack also applies to this method with + minimal changes. Parameters ---------- @@ -771,9 +786,10 @@ def zero_pad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.zero_pad. This method - simply wraps the function, and so the docstring for ivy.zero_pad also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.zero_pad. This method simply wraps the + function, and so the docstring for ivy.zero_pad also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/norms.py b/ivy/data_classes/array/norms.py index d3116b4d0cf43..3c66c85517c20 100644 --- a/ivy/data_classes/array/norms.py +++ b/ivy/data_classes/array/norms.py @@ -20,9 +20,10 @@ def layer_norm( new_std: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.layer_norm. This method - simply wraps the function, and so the docstring for ivy.layer_norm also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.layer_norm. This method simply wraps + the function, and so the docstring for ivy.layer_norm also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/random.py b/ivy/data_classes/array/random.py index 2835b7690c798..047386ee6779f 100644 --- a/ivy/data_classes/array/random.py +++ b/ivy/data_classes/array/random.py @@ -18,9 +18,10 @@ def random_uniform( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.random_uniform. This method - simply wraps the function, and so the docstring for ivy.random_uniform - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.random_uniform. This method simply + wraps the function, and so the docstring for ivy.random_uniform also applies to + this method with minimal changes. Parameters ---------- @@ -116,9 +117,10 @@ def random_normal( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.random_normal. This method - simply wraps the function, and so the docstring for ivy.random_normal - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.random_normal. This method simply wraps + the function, and so the docstring for ivy.random_normal also applies to this + method with minimal changes. Parameters ---------- @@ -213,9 +215,10 @@ def multinomial( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.multinomial. This method - simply wraps the function, and so the docstring for ivy.multinomial - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.multinomial. This method simply wraps + the function, and so the docstring for ivy.multinomial also applies to this + method with minimal changes. Parameters ---------- @@ -266,9 +269,10 @@ def randint( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.randint. This method simply - wraps the function, and so the docstring for ivy.randint also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.randint. This method simply wraps the + function, and so the docstring for ivy.randint also applies to this method with + minimal changes. Parameters ---------- @@ -359,9 +363,10 @@ def shuffle( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.shuffle. This method simply - wraps the function, and so the docstring for ivy.shuffle also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.shuffle. This method simply wraps the + function, and so the docstring for ivy.shuffle also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/searching.py b/ivy/data_classes/array/searching.py index 527132b4248fa..15537fa4b2005 100644 --- a/ivy/data_classes/array/searching.py +++ b/ivy/data_classes/array/searching.py @@ -18,9 +18,10 @@ def argmax( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, int]: - """ivy.Array instance method variant of ivy.argmax. This method simply - wraps the function, and so the docstring for ivy.argmax also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.argmax. This method simply wraps the + function, and so the docstring for ivy.argmax also applies to this method with + minimal changes. Parameters ---------- @@ -93,9 +94,10 @@ def argmin( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, int]: - """ivy.Array instance method variant of ivy.argmin. This method simply - wraps the function, and so the docstring for ivy.argmin also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.argmin. This method simply wraps the + function, and so the docstring for ivy.argmin also applies to this method with + minimal changes. Parameters ---------- @@ -160,9 +162,10 @@ def nonzero( size: Optional[int] = None, fill_value: Number = 0, ) -> Union[Tuple[ivy.Array], ivy.Array]: - """ivy.Array instance method variant of ivy.nonzero. This method simply - wraps the function, and so the docstring for ivy.nonzero also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nonzero. This method simply wraps the + function, and so the docstring for ivy.nonzero also applies to this method with + minimal changes. Parameters ---------- @@ -199,9 +202,10 @@ def where( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.where. This method simply - wraps the function, and so the docstring for ivy.where also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.where. This method simply wraps the + function, and so the docstring for ivy.where also applies to this method with + minimal changes. Parameters ---------- @@ -234,9 +238,10 @@ def where( return ivy.where(self._data, x1._data, x2._data, out=out) def argwhere(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ivy.Array instance method variant of ivy.argwhere. This method - simply wraps the function, and so the docstring for ivy.argwhere also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.argwhere. This method simply wraps the + function, and so the docstring for ivy.argwhere also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/set.py b/ivy/data_classes/array/set.py index 83e2aefdfbc67..cde03cfce2555 100644 --- a/ivy/data_classes/array/set.py +++ b/ivy/data_classes/array/set.py @@ -8,9 +8,10 @@ class _ArrayWithSet(abc.ABC): def unique_counts(self: ivy.Array) -> Tuple[ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.unique_counts. This method - simply wraps the function, and so the docstring for ivy.unique_counts - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.unique_counts. This method simply wraps + the function, and so the docstring for ivy.unique_counts also applies to this + method with minimal changes. Parameters ---------- @@ -107,9 +108,10 @@ def unique_all( axis: Optional[int] = None, by_value: bool = True, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.unique_all. This method - simply wraps the function, and so the docstring for ivy.unique_all also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.unique_all. This method simply wraps + the function, and so the docstring for ivy.unique_all also applies to this + method with minimal changes. Parameters ---------- @@ -144,9 +146,10 @@ def unique_all( return ivy.unique_all(self._data, axis=axis, by_value=by_value) def unique_inverse(self: ivy.Array) -> Tuple[ivy.Array, ivy.Array]: - """ivy.Array instance method variant of ivy.unique_inverse. This method - simply wraps the function, and so the docstring for ivy.unique_inverse - also applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.unique_inverse. This method simply + wraps the function, and so the docstring for ivy.unique_inverse also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/sorting.py b/ivy/data_classes/array/sorting.py index b32929c132296..ceb6cfddd0566 100644 --- a/ivy/data_classes/array/sorting.py +++ b/ivy/data_classes/array/sorting.py @@ -17,9 +17,10 @@ def argsort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.argsort. This method simply - wraps the function, and so the docstring for ivy.argsort also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.argsort. This method simply wraps the + function, and so the docstring for ivy.argsort also applies to this method with + minimal changes. Parameters ---------- @@ -75,9 +76,10 @@ def sort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.sort. This method simply - wraps the function, and so the docstring for ivy.sort also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.sort. This method simply wraps the + function, and so the docstring for ivy.sort also applies to this method with + minimal changes. Examples -------- @@ -101,9 +103,10 @@ def msort( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.msort. This method simply - wraps the function, and so the docstring for ivy.msort also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.msort. This method simply wraps the + function, and so the docstring for ivy.msort also applies to this method with + minimal changes. Parameters ---------- @@ -138,7 +141,8 @@ def searchsorted( ret_dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.searchsorted. + """ + ivy.Array instance method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal diff --git a/ivy/data_classes/array/statistical.py b/ivy/data_classes/array/statistical.py index b07294c52696e..08f98dd2860ee 100644 --- a/ivy/data_classes/array/statistical.py +++ b/ivy/data_classes/array/statistical.py @@ -19,7 +19,8 @@ def min( where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the minimum value of the input array ``x``. + """ + Calculate the minimum value of the input array ``x``. Parameters ---------- @@ -92,9 +93,10 @@ def max( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.max. This method simply - wraps the function, and so the docstring for ivy.max also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.max. This method simply wraps the + function, and so the docstring for ivy.max also applies to this method with + minimal changes. Parameters ---------- @@ -154,9 +156,10 @@ def mean( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.mean. This method simply - wraps the function, and so the docstring for ivy.mean also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.mean. This method simply wraps the + function, and so the docstring for ivy.mean also applies to this method with + minimal changes. **Special Cases** @@ -241,9 +244,10 @@ def var( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.var. This method simply - wraps the function, and so the docstring for ivy.var also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.var. This method simply wraps the + function, and so the docstring for ivy.var also applies to this method with + minimal changes. **Special Cases** @@ -326,9 +330,10 @@ def prod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.array instance method variant of ivy.prod. This method simply - wraps the function, and so the docstring for ivy.prod also applies to - this method with minimal changes. + """ + ivy.array instance method variant of ivy.prod. This method simply wraps the + function, and so the docstring for ivy.prod also applies to this method with + minimal changes. Parameters ---------- @@ -411,9 +416,10 @@ def std( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.array instance method variant of ivy.std. This method simply - wraps the function, and so the docstring for ivy.std also applies to - this method with minimal changes. + """ + ivy.array instance method variant of ivy.std. This method simply wraps the + function, and so the docstring for ivy.std also applies to this method with + minimal changes. Parameters ---------- @@ -505,9 +511,10 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cumsum. This method simply - wraps the function, and so the docstring for ivy.cumsum also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cumsum. This method simply wraps the + function, and so the docstring for ivy.cumsum also applies to this method with + minimal changes. Parameters ---------- @@ -579,9 +586,10 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.cumprod. This method simply - wraps the function, and so the docstring for ivy.cumprod also applies - to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.cumprod. This method simply wraps the + function, and so the docstring for ivy.cumprod also applies to this method with + minimal changes. Parameters ---------- @@ -649,9 +657,10 @@ def einsum( *operands: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.einsum. This method simply - wraps the function, and so the docstring for ivy.einsum also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.einsum. This method simply wraps the + function, and so the docstring for ivy.einsum also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/utility.py b/ivy/data_classes/array/utility.py index a711dfd46f1f8..089b99918be1b 100644 --- a/ivy/data_classes/array/utility.py +++ b/ivy/data_classes/array/utility.py @@ -15,9 +15,10 @@ def all( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.all. This method simply - wraps the function, and so the docstring for ivy.all also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.all. This method simply wraps the + function, and so the docstring for ivy.all also applies to this method with + minimal changes. Parameters ---------- @@ -75,9 +76,10 @@ def any( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.any. This method simply - wraps the function, and so the docstring for ivy.any also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.any. This method simply wraps the + function, and so the docstring for ivy.any also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/wrapping.py b/ivy/data_classes/array/wrapping.py index f79ad5a07191a..74105ef566edc 100644 --- a/ivy/data_classes/array/wrapping.py +++ b/ivy/data_classes/array/wrapping.py @@ -9,7 +9,8 @@ def _wrap_function(function_name: str) -> Callable: - """Wrap the function called `function_name`. + """ + Wrap the function called `function_name`. Parameters ---------- @@ -32,8 +33,9 @@ def _wrap_function(function_name: str) -> Callable: """ def new_function(self, *args, **kwargs): - """Add the data of the current array from which the instance function - is invoked as the first arg parameter or kwarg parameter. + """ + Add the data of the current array from which the instance function is invoked as + the first arg parameter or kwarg parameter. Return the new function with the name function_name and the new args variable or kwargs as the new inputs. @@ -61,8 +63,9 @@ def new_function(self, *args, **kwargs): def add_ivy_array_instance_methods( cls: Type[ivy.Array], modules: List[ModuleType], to_ignore: Iterable = () ): - """Loop over all ivy modules such as activations, general, etc. and add the - module functions to ivy arrays as instance methods using _wrap_function. + """ + Loop over all ivy modules such as activations, general, etc. and add the module + functions to ivy arrays as instance methods using _wrap_function. Parameters ---------- diff --git a/ivy/data_classes/container/activations.py b/ivy/data_classes/container/activations.py index c8499ef9d6f91..9d5883bd1d213 100644 --- a/ivy/data_classes/container/activations.py +++ b/ivy/data_classes/container/activations.py @@ -21,9 +21,10 @@ def _static_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.relu. This method simply - wraps the function, and so the docstring for ivy.relu also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.relu. This method simply wraps the + function, and so the docstring for ivy.relu also applies to this method with + minimal changes. Parameters ---------- @@ -85,9 +86,10 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.relu. This method - simply wraps the function, and so the docstring for ivy.relu also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.relu. This method simply wraps the + function, and so the docstring for ivy.relu also applies to this method with + minimal changes. Parameters ---------- @@ -150,9 +152,10 @@ def _static_leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.leaky_relu. This method - simply wraps the function, and so the docstring for ivy.leaky_relu also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.leaky_relu. This method simply wraps + the function, and so the docstring for ivy.leaky_relu also applies to this + method with minimal changes. Parameters ---------- @@ -217,9 +220,10 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.leaky_relu. This method - simply wraps the function, and so the docstring for ivy.leaky_relu also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.leaky_relu. This method simply + wraps the function, and so the docstring for ivy.leaky_relu also applies to this + method with minimal changes. Parameters ---------- @@ -284,9 +288,10 @@ def _static_gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.gelu. This method simply - wraps the function, and so the docstring for ivy.gelu also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.gelu. This method simply wraps the + function, and so the docstring for ivy.gelu also applies to this method with + minimal changes. Parameters ---------- @@ -350,9 +355,10 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.gelu. This method - simply wraps the function, and so the docstring for ivy.gelu also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.gelu. This method simply wraps the + function, and so the docstring for ivy.gelu also applies to this method with + minimal changes. Parameters ---------- @@ -416,9 +422,10 @@ def _static_sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sigmoid. This method - simply wraps the function, and so the docstring for ivy.sigmoid also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.sigmoid. This method simply wraps the + function, and so the docstring for ivy.sigmoid also applies to this method with + minimal changes. Parameters ---------- @@ -479,9 +486,10 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sigmoid. This method - simply wraps the function, and so the docstring for ivy.sigmoid also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.sigmoid. This method simply wraps + the function, and so the docstring for ivy.sigmoid also applies to this method + with minimal changes. Parameters ---------- @@ -543,9 +551,10 @@ def _static_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.softmax. This method - simply wraps the function, and so the docstring for ivy.softmax also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.softmax. This method simply wraps the + function, and so the docstring for ivy.softmax also applies to this method with + minimal changes. Parameters ---------- @@ -610,9 +619,10 @@ def softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.softmax. This method - simply wraps the function, and so the docstring for ivy.softmax also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.softmax. This method simply wraps + the function, and so the docstring for ivy.softmax also applies to this method + with minimal changes. Parameters ---------- @@ -678,9 +688,10 @@ def _static_softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.softplus. This method - simply wraps the function, and so the docstring for ivy.softplus also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.softplus. This method simply wraps + the function, and so the docstring for ivy.softplus also applies to this method + with minimal changes. Parameters ---------- @@ -756,9 +767,10 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.softplus. This method - simply wraps the function, and so the docstring for ivy.softplus also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.softplus. This method simply wraps + the function, and so the docstring for ivy.softplus also applies to this method + with minimal changes. Parameters ---------- @@ -832,9 +844,10 @@ def _static_log_softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.log_softmax. This method - simply wraps the function, and so the docstring for ivy.log_softmax - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.log_softmax. This method simply wraps + the function, and so the docstring for ivy.log_softmax also applies to this + method with minimal changes. Parameters ---------- @@ -906,9 +919,10 @@ def log_softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ivy.Container instance method variant of ivy.log_softmax. This - method simply wraps the function, and so the docstring for - ivy.log_softmax also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.log_softmax. This method simply + wraps the function, and so the docstring for ivy.log_softmax also applies to + this method with minimal changes. Parameters ---------- @@ -979,9 +993,10 @@ def _static_mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.mish. This method simply - wraps the function, and so the docstring for ivy.mish also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.mish. This method simply wraps the + function, and so the docstring for ivy.mish also applies to this method with + minimal changes. Parameters ---------- @@ -1043,9 +1058,10 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.mish. This method - simply wraps the function, and so the docstring for ivy.mish also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.mish. This method simply wraps the + function, and so the docstring for ivy.mish also applies to this method with + minimal changes. Parameters ---------- @@ -1107,9 +1123,10 @@ def _static_hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.hardswish. This method - simply wraps the function, and so the docstring for ivy.hardswish also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.hardswish. This method simply wraps + the function, and so the docstring for ivy.hardswish also applies to this method + with minimal changes. Parameters ---------- @@ -1171,9 +1188,10 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.hardswish. This method - simply wraps the function, and so the docstring for ivy.hardswish also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.hardswish. This method simply wraps + the function, and so the docstring for ivy.hardswish also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index b782245f53dae..69dfdd6944781 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -72,7 +72,8 @@ def __init__( build_callable=False, **kwargs, ): - """Initialize container object from input dict representation. + """ + Initialize container object from input dict representation. Parameters ---------- @@ -271,8 +272,9 @@ def map_fn(vals, _): @staticmethod def cont_handle_inplace(ret, out): - """Return an inplace update of out, provided it is not None, by - updating with the values in ret. + """ + Return an inplace update of out, provided it is not None, by updating with the + values in ret. Parameters ---------- @@ -293,7 +295,8 @@ def cont_handle_inplace(ret, out): @staticmethod def cont_list_join(containers, config=None): - """Join containers of lists together along the specified dimension. + """ + Join containers of lists together along the specified dimension. Parameters ---------- @@ -325,7 +328,8 @@ def cont_list_join(containers, config=None): @staticmethod def cont_list_stack(containers, dim, config=None): - """List stack containers together along the specified dimension. + """ + List stack containers together along the specified dimension. Parameters ---------- @@ -375,8 +379,9 @@ def _cont_mean_unify(containers, device, _=None, _1=None): @staticmethod def cont_unify(containers, device, mode, axis=0): - """Unify a list of containers, on arbitrary devices, to a single - container on the specified device. + """ + Unify a list of containers, on arbitrary devices, to a single container on the + specified device. Parameters ---------- @@ -402,8 +407,9 @@ def cont_unify(containers, device, mode, axis=0): @staticmethod def cont_combine(*containers, config=None): - """Combine keys and values in a sequence of containers, with priority - given to the right-most container in the case of duplicates. + """ + Combine keys and values in a sequence of containers, with priority given to the + right-most container in the case of duplicates. Parameters ---------- @@ -460,9 +466,10 @@ def cont_diff( detect_shape_diffs=True, config=None, ): - """Compare keys and values in a sequence of containers, returning the - single shared values where they are the same, and new nested sub-dicts - with all values where they are different. + """ + Compare keys and values in a sequence of containers, returning the single shared + values where they are the same, and new nested sub-dicts with all values where + they are different. Parameters ---------- @@ -606,9 +613,10 @@ def cont_structural_diff( detect_shape_diffs=True, config=None, ): - """Compare keys and shapes in a sequence of containers, returning the - single shared values where they are the same, and new nested sub-dicts - with all values where they are different. + """ + Compare keys and shapes in a sequence of containers, returning the single shared + values where they are the same, and new nested sub-dicts with all values where + they are different. Parameters ---------- @@ -658,7 +666,8 @@ def cont_multi_map( map_nests=False, assert_identical=False, ): - """Apply function to all array values from a collection of containers. + """ + Apply function to all array values from a collection of containers. Parameters ---------- @@ -777,7 +786,8 @@ def _found_in_key_chains(this_key_chain, key_chains): @staticmethod def cont_common_key_chains(containers): - """Return the key-chains common across all containers. + """ + Return the key-chains common across all containers. Parameters ---------- @@ -806,8 +816,9 @@ def cont_identical( key_chain="", assert_and_assign=False, ): - """Return a single boolean as to whether the input containers have - identical key- chains and data types. + """ + Return a single boolean as to whether the input containers have identical key- + chains and data types. Parameters ---------- @@ -919,8 +930,9 @@ def cont_assert_identical( to_apply=True, partial=False, ): - """Assert whether the input containers are identical. Otherwise, the - diff is shown in an exception. + """ + Assert whether the input containers are identical. Otherwise, the diff is shown + in an exception. Parameters ---------- @@ -971,8 +983,9 @@ def cont_identical_structure( key_chain="", assert_and_assign=False, ): - """Return a single boolean as to whether the input containers have - identical structure. + """ + Return a single boolean as to whether the input containers have identical + structure. Parameters ---------- @@ -1025,8 +1038,9 @@ def cont_assert_identical_structure( partial=False, assert_and_assign=False, ): - """Assert whether the input containers have identical structure. - Otherwise, the diff is shown in an exception. + """ + Assert whether the input containers have identical structure. Otherwise, the + diff is shown in an exception. Parameters ---------- @@ -1066,8 +1080,9 @@ def cont_assert_identical_structure( @staticmethod def cont_identical_configs(containers): - """Return a single boolean as to whether the input containers all have - identical configs. + """ + Return a single boolean as to whether the input containers all have identical + configs. Parameters ---------- @@ -1083,9 +1098,9 @@ def cont_identical_configs(containers): @staticmethod def cont_identical_array_shapes(containers, exclusive=False): - """Determine whether all of the containers have identical number of - arrays and identical array shapes, regardless of their key-chain - structures. + """ + Determine whether all of the containers have identical number of arrays and + identical array shapes, regardless of their key-chain structures. Parameters ---------- @@ -1127,8 +1142,9 @@ def cont_load(filepath, format="h5py"): def cont_from_disk_as_hdf5( h5_obj_or_filepath, slice_obj=slice(None), alphabetical_keys=True, ivyh=None ): - """Load container object from disk, as an h5py file, at the specified - hdf5 filepath. + """ + Load container object from disk, as an h5py file, at the specified hdf5 + filepath. Parameters ---------- @@ -1177,7 +1193,8 @@ def cont_from_disk_as_hdf5( @staticmethod def cont_from_disk_as_pickled(pickle_filepath, ivyh=None): - """Load container object from disk at the specified pickle filepath. + """ + Load container object from disk at the specified pickle filepath. Parameters ---------- @@ -1199,9 +1216,9 @@ def cont_from_disk_as_pickled(pickle_filepath, ivyh=None): @staticmethod def cont_from_disk_as_json(json_filepath, ivyh=None): - """Load container object from disk at the specified json filepath. If - some objects were not json-able during saving, then they will be loaded - as strings. + """ + Load container object from disk at the specified json filepath. If some objects + were not json-able during saving, then they will be loaded as strings. Parameters ---------- @@ -1220,7 +1237,8 @@ def cont_from_disk_as_json(json_filepath, ivyh=None): @staticmethod def h5_file_size(h5_obj_or_filepath): - """Get file size of h5 file contents. + """ + Get file size of h5 file contents. Parameters ---------- @@ -1261,8 +1279,9 @@ def h5_file_size(h5_obj_or_filepath): @staticmethod def shuffle_h5_file(h5_obj_or_filepath, seed_value=0): - """Shuffle entries in all datasets of h5 file, such that they are still - aligned along axis 0. + """ + Shuffle entries in all datasets of h5 file, such that they are still aligned + along axis 0. Parameters ---------- @@ -1301,7 +1320,8 @@ def shuffle_h5_file(h5_obj_or_filepath, seed_value=0): @staticmethod def cont_reduce(containers, reduction, config=None): - """Reduce containers. + """ + Reduce containers. Parameters ---------- @@ -1343,7 +1363,8 @@ def cont_reduce(containers, reduction, config=None): def cont_flatten_key_chain( key_chain, replacement="__", above_height=None, below_depth=None ): - """Summary. + """ + Summary. Parameters ---------- @@ -1379,7 +1400,8 @@ def cont_flatten_key_chain( @staticmethod def cont_trim_key(key, max_length): - """Summary. Returns a trimmed key with a maximum length of max_length. + """ + Summary. Returns a trimmed key with a maximum length of max_length. Parameters ---------- @@ -1619,8 +1641,9 @@ def cont_update_config(self, **config): def cont_inplace_update( self, dict_in: Union[ivy.Container, dict], **config ) -> ivy.Container: - """Update the contents of this container inplace, using either a new - dict or container. + """ + Update the contents of this container inplace, using either a new dict or + container. Parameters ---------- @@ -1672,8 +1695,8 @@ def cont_all_true( prune_unapplied=False, map_sequences=False, ): - """Determine whether all the entries in the container boolean evaluate - to True. + """ + Determine whether all the entries in the container boolean evaluate to True. Parameters ---------- @@ -1717,8 +1740,8 @@ def cont_all_false( prune_unapplied=False, map_sequences=False, ): - """Determine whether all the entries in the container boolean evaluate - to False. + """ + Determine whether all the entries in the container boolean evaluate to False. Parameters ---------- @@ -1755,7 +1778,8 @@ def cont_all_false( ) def cont_slice_via_key(self, slice_key): - """Get slice of container, based on key. + """ + Get slice of container, based on key. Parameters ---------- @@ -1784,7 +1808,8 @@ def cont_as_bools( prune_unapplied=False, map_sequences=False, ): - """Return boolean evaluation for all nested items in the container. + """ + Return boolean evaluation for all nested items in the container. Parameters ---------- @@ -1823,7 +1848,8 @@ def _ret_bool(x): ) def cont_unstack_conts(self, axis, keepdims=False, dim_size=None): - """Unstack containers along specified dimension. + """ + Unstack containers along specified dimension. Parameters ---------- @@ -1866,7 +1892,8 @@ def split_conts( prune_unapplied=False, map_sequences=False, ): - """Split a container into multiple sub-containers. + """ + Split a container into multiple sub-containers. The function does that by splitting their constituent arrays. @@ -1921,8 +1948,9 @@ def split_conts( ).cont_unstack_conts(0, dim_size=dim_size) def cont_num_arrays(self, exclusive=False): - """Compute the number of arrays present at the leaf nodes, including - variables by default. + """ + Compute the number of arrays present at the leaf nodes, including variables by + default. Parameters ---------- @@ -1937,8 +1965,9 @@ def cont_num_arrays(self, exclusive=False): ) def cont_size_ordered_arrays(self, exclusive=False): - """Return a container with keychains mapped to flat keys, and arrays - given in order of smallest to largest. + """ + Return a container with keychains mapped to flat keys, and arrays given in order + of smallest to largest. Parameters ---------- @@ -1973,8 +2002,8 @@ def cont_save(self, filepath, format="h5py"): def cont_to_disk_as_hdf5( self, h5_obj_or_filepath, starting_index=0, mode="a", max_batch_size=None ): - """Save container object to disk, as an h5py file, at the specified - filepath. + """ + Save container object to disk, as an h5py file, at the specified filepath. Parameters ---------- @@ -2033,8 +2062,8 @@ def cont_to_disk_as_hdf5( ) def cont_to_disk_as_pickled(self, pickle_filepath): - """Save container object to disk, as an pickled file, at the specified - filepath. + """ + Save container object to disk, as an pickled file, at the specified filepath. Parameters ---------- @@ -2063,8 +2092,8 @@ def cont_to_jsonable(self, return_dict=None): return return_dict def cont_to_disk_as_json(self, json_filepath): - """Save container object to disk, as an json file, at the specified - filepath. + """ + Save container object to disk, as an json file, at the specified filepath. Parameters ---------- @@ -2084,7 +2113,8 @@ def cont_to_nested_list(self): return return_list def cont_to_raw(self): - """Convert container to its original form. + """ + Convert container to its original form. Returns ------- @@ -2106,7 +2136,8 @@ def cont_to_raw(self): return return_item def cont_to_dict(self): - """Summary. + """ + Summary. Returns ------- @@ -2200,7 +2231,8 @@ def cont_to_iterator_keys( yield kc def cont_to_flat_list(self): - """Summary. + """ + Summary. Returns ------- @@ -2210,8 +2242,9 @@ def cont_to_flat_list(self): return [item for key, item in self.cont_to_iterator()] def cont_from_flat_list(self, flat_list): - """Return new container object with the same hierarchy, but with values - replaced from flat list. + """ + Return new container object with the same hierarchy, but with values replaced + from flat list. Parameters ---------- @@ -2232,8 +2265,9 @@ def cont_from_flat_list(self, flat_list): return ivy.Container(new_dict, **self._config) def cont_has_key(self, query_key): - """Determine whether container object has specified key somewhere in - the nested structure. + """ + Determine whether container object has specified key somewhere in the nested + structure. Parameters ---------- @@ -2266,7 +2300,8 @@ def map_fn(x, kc): return has_key def cont_has_key_chain(self, key_chain): - """Determine whether container object has specified key-chain. + """ + Determine whether container object has specified key-chain. Parameters ---------- @@ -2288,7 +2323,8 @@ def cont_has_key_chain(self, key_chain): return True def cont_find_sub_container(self, sub_cont_to_find, partial=False): - """Find the sub-container in the current container if it exists. + """ + Find the sub-container in the current container if it exists. Parameters ---------- @@ -2319,8 +2355,9 @@ def _check_sub_cont(sub_cont, kc): return key_chain_found def cont_contains_sub_container(self, sub_cont, partial=False): - """Determine whether the current container contains the sub-container, - with matching structure and array values. + """ + Determine whether the current container contains the sub-container, with + matching structure and array values. Parameters ---------- @@ -2337,8 +2374,9 @@ def cont_contains_sub_container(self, sub_cont, partial=False): return isinstance(self.cont_find_sub_container(sub_cont, partial), str) def cont_assert_contains_sub_container(self, sub_cont, partial=False): - """Assert that the current container contains the sub-container, - otherwise exception raised with the diff printed to screen. + """ + Assert that the current container contains the sub-container, otherwise + exception raised with the diff printed to screen. Parameters ---------- @@ -2367,8 +2405,8 @@ def cont_assert_contains_sub_container(self, sub_cont, partial=False): def cont_find_sub_structure( self, sub_struc_to_find, check_shapes=True, partial=False ): - """Find the sub-container structure in the current container if it - exists. + """ + Find the sub-container structure in the current container if it exists. Parameters ---------- @@ -2412,8 +2450,8 @@ def _check_sub_cont(sub_cont, kc): return key_chain_found def cont_contains_sub_structure(self, sub_cont, check_shapes=True, partial=False): - """Determine whether the current container contains the sub-container - structure. + """ + Determine whether the current container contains the sub-container structure. Parameters ---------- @@ -2432,8 +2470,9 @@ def cont_contains_sub_structure(self, sub_cont, check_shapes=True, partial=False def cont_assert_contains_sub_structure( self, sub_cont, check_shapes=True, partial=False ): - """Assert that the current container contains the sub-container - structure, otherwise exception raised with the diff printed to screen. + """ + Assert that the current container contains the sub-container structure, + otherwise exception raised with the diff printed to screen. Parameters ---------- @@ -2471,8 +2510,8 @@ def cont_assert_contains_sub_structure( def cont_at_keys( self, queries, ignore_none=True, containing=False, ignore_key_errors=False ): - """Query container object at specified keys, either as list or nested - dict. + """ + Query container object at specified keys, either as list or nested dict. Parameters ---------- @@ -2515,7 +2554,8 @@ def map_fn(x, kc): ) def cont_at_key_chain(self, key_chain, ignore_key_errors=False): - """Query container object at a specified key-chain. + """ + Query container object at a specified key-chain. Parameters ---------- @@ -2541,8 +2581,8 @@ def cont_at_key_chain(self, key_chain, ignore_key_errors=False): return ret def cont_at_key_chains(self, key_chains, ignore_none=True, ignore_key_errors=False): - """Query container object at specified key-chains, either as list or - nested dict. + """ + Query container object at specified key-chains, either as list or nested dict. Parameters ---------- @@ -2607,7 +2647,8 @@ def cont_key_chains_containing(self, sub_str, include_empty=False): ] def cont_set_at_keys(self, target_dict): - """Set values of container object at specified keys. + """ + Set values of container object at specified keys. Parameters ---------- @@ -2630,7 +2671,8 @@ def cont_set_at_keys(self, target_dict): return ivy.Container(return_dict, **self._config) def cont_set_at_key_chain(self, key_chain, val, inplace=False): - """Set value of container object at a specified key-chain. + """ + Set value of container object at a specified key-chain. Parameters ---------- @@ -2660,7 +2702,8 @@ def cont_set_at_key_chain(self, key_chain, val, inplace=False): return cont def cont_overwrite_at_key_chain(self, key_chain, val, inplace=False): - """Overwrite value of container object at a specified key-chain. + """ + Overwrite value of container object at a specified key-chain. Parameters ---------- @@ -2704,7 +2747,8 @@ def cont_overwrite_at_key_chain(self, key_chain, val, inplace=False): return cont def cont_set_at_key_chains(self, target_dict, return_dict=None, inplace=False): - """Set values of container object at specified key-chains. + """ + Set values of container object at specified key-chains. Parameters ---------- @@ -2735,7 +2779,8 @@ def cont_set_at_key_chains(self, target_dict, return_dict=None, inplace=False): def cont_overwrite_at_key_chains( self, target_dict, return_dict=None, inplace=False ): - """Overwrite values of container object at specified key-chains. + """ + Overwrite values of container object at specified key-chains. Parameters ---------- @@ -2775,7 +2820,8 @@ def cont_overwrite_at_key_chains( return return_dict def cont_prune_keys(self, query_keys, ignore_none=True): - """Recursively prune set of keys. + """ + Recursively prune set of keys. Parameters ---------- @@ -2815,7 +2861,8 @@ def map_fn(x, kc): return self.cont_prune_key_chains(key_chains_to_prune) def cont_prune_key_chain(self, key_chain): - """Recursively prune chain of keys, specified as 'key1/key2/key3/...'. + """ + Recursively prune chain of keys, specified as 'key1/key2/key3/...'. Parameters ---------- @@ -2849,7 +2896,8 @@ def cont_prune_key_chain(self, key_chain): return ivy.Container(out_dict, **self._config) def cont_prune_key_chains(self, key_chains, ignore_none=True): - """Recursively prune set of key chains. + """ + Recursively prune set of key chains. Parameters ---------- @@ -2878,7 +2926,8 @@ def cont_prune_key_chains(self, key_chains, ignore_none=True): ) def cont_format_key_chains(self, format_fn): - """Format all key-chains, using the formatting function. + """ + Format all key-chains, using the formatting function. Parameters ---------- @@ -2903,8 +2952,9 @@ def cont_sort_by_key(self): return ivy.Container(new_dict, **self._config) def cont_prune_empty(self, keep_nones=False, base=True): - """Recursively prunes empty keys from the container dict structure. - Returns None if the entire container is empty. + """ + Recursively prunes empty keys from the container dict structure. Returns None if + the entire container is empty. Parameters ---------- @@ -2933,8 +2983,9 @@ def cont_prune_empty(self, keep_nones=False, base=True): return def cont_prune_key_from_key_chains(self, absolute=None, containing=None): - """Recursively prune absolute key or key containing a certain substring - from all key chains. + """ + Recursively prune absolute key or key containing a certain substring from all + key chains. Parameters ---------- @@ -2974,8 +3025,9 @@ def cont_prune_key_from_key_chains(self, absolute=None, containing=None): return out_cont def cont_prune_keys_from_key_chains(self, absolute=None, containing=None): - """Recursively prune absolute keys or keys containing certain - substrings from all key chains. + """ + Recursively prune absolute keys or keys containing certain substrings from all + key chains. Parameters ---------- @@ -3021,9 +3073,9 @@ def cont_prune_keys_from_key_chains(self, absolute=None, containing=None): def cont_restructure_key_chains( self, keychain_mapping, keep_orig=True, replace=True ): - """Create a new container with the same contents, but a new key-chain - structure. Given by the mapping with keys as old key-chains and values - as new key-chains. + """ + Create a new container with the same contents, but a new key-chain structure. + Given by the mapping with keys as old key-chains and values as new key-chains. Parameters ---------- @@ -3045,9 +3097,10 @@ def cont_restructure_key_chains( return new_cont def cont_restructure(self, mapping, keep_orig=True, replace=True): - """Create a new container with the same contents, but a new key-chain - structure, and transposes and/or reshaped arrays. Given by the mapping - with keys as old key-chains and values as new key-chains. + """ + Create a new container with the same contents, but a new key-chain structure, + and transposes and/or reshaped arrays. Given by the mapping with keys as old + key-chains and values as new key-chains. Parameters ---------- @@ -3083,7 +3136,8 @@ def cont_restructure(self, mapping, keep_orig=True, replace=True): def cont_flatten_key_chains( self, include_empty=False, above_height=None, below_depth=None ): - """Summary. + """ + Summary. Parameters ---------- @@ -3105,7 +3159,8 @@ def cont_flatten_key_chains( ) def cont_copy(self): - """Create a copy of this container. + """ + Create a copy of this container. Returns ------- @@ -3114,7 +3169,8 @@ def cont_copy(self): return ivy.Container(self.cont_to_dict(), **self._config) def cont_deep_copy(self): - """Create a deep copy (copying all internal tensors) of this container. + """ + Create a deep copy (copying all internal tensors) of this container. return: A deep copy of the container """ @@ -3137,7 +3193,8 @@ def cont_map( inplace=False, key_chain="", ): - """Apply function to all array values of container. + """ + Apply function to all array values of container. Parameters ---------- @@ -3212,7 +3269,8 @@ def cont_map_sub_conts( key_chain="", include_self=True, ): - """Apply function to all sub-contains in the container. + """ + Apply function to all sub-contains in the container. Parameters ---------- @@ -3274,8 +3332,9 @@ def to_list(x, _=""): return self.cont_map(to_list) def cont_reshape_like(self, target_dict, leading_shape=None, return_cont=None): - """Set shapes of container entries to shapes specified by new container - with the same key structure. + """ + Set shapes of container entries to shapes specified by new container with the + same key structure. Parameters ---------- @@ -3306,8 +3365,9 @@ def cont_reshape_like(self, target_dict, leading_shape=None, return_cont=None): return ivy.Container(return_cont, **self._config) def cont_create_if_absent(self, key, value, inplace=True): - """Add a key to the container with corresponding value, if it is not - already present. otherwise, do nothing. + """ + Add a key to the container with corresponding value, if it is not already + present. otherwise, do nothing. Parameters ---------- @@ -3322,8 +3382,8 @@ def cont_create_if_absent(self, key, value, inplace=True): self.cont_set_at_key_chain(key, value, inplace) def cont_if_exists(self, key): - """Return the sub-container at the following key if it exists, - otherwise None. + """ + Return the sub-container at the following key if it exists, otherwise None. Parameters ---------- @@ -3335,7 +3395,8 @@ def cont_if_exists(self, key): return def cont_try_kc(self, key): - """Try the following key or key chain, returning self if not present. + """ + Try the following key or key chain, returning self if not present. Parameters ---------- @@ -3347,7 +3408,8 @@ def cont_try_kc(self, key): return self def cont_cutoff_at_depth(self, depth_cutoff, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3372,7 +3434,8 @@ def _maybe_cutoff(cont, kc): return ret def cont_cutoff_at_height(self, height_cutoff, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3411,7 +3474,8 @@ def _cont_slice_keys(self, key_slice): return ret.cont_at_key_chains(desired_keys) def cont_slice_keys(self, key_slice, all_depths=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3442,7 +3506,8 @@ def _fn(cont, kc): return self._cont_slice_keys(key_slice) def cont_with_print_limit(self, print_limit, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3463,7 +3528,8 @@ def _update_print_limit(cont, _): # noinspection PyTypeChecker def cont_remove_print_limit(self, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3473,7 +3539,8 @@ def cont_remove_print_limit(self, inplace=False): return self.cont_with_print_limit(None, inplace) def cont_with_key_length_limit(self, key_length_limit, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3493,7 +3560,8 @@ def _update_key_length_limit(cont, _): return ret def cont_remove_key_length_limit(self, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3503,7 +3571,8 @@ def cont_remove_key_length_limit(self, inplace=False): return self.cont_with_key_length_limit(None, inplace) def cont_with_print_indent(self, print_indent, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3523,7 +3592,8 @@ def _update_print_indent(cont, _): return ret def cont_with_print_line_spacing(self, print_line_spacing, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3543,7 +3613,8 @@ def _update_print_line_spacing(cont, _): return ret def cont_with_default_key_color(self, default_key_color, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3563,7 +3634,8 @@ def _update_default_key_color(cont, _): return ret def cont_with_ivy_backend(self, ivy_backend: str, inplace=False): - """Summary. + """ + Summary. Parameters ---------- @@ -3586,7 +3658,8 @@ def cont_show(self): # noinspection PyUnresolvedReferences def cont_show_sub_container(self, sub_cont_or_keychain): - """Summary. + """ + Summary. Parameters ---------- @@ -3976,7 +4049,8 @@ def _get_queue_item(self, query): return combined_cont[shifted_query] def __getitem__(self, query): - """Get slice, key or key chain of container object. + """ + Get slice, key or key chain of container object. Parameters ---------- @@ -4017,7 +4091,8 @@ def __getitem__(self, query): return ret def __setitem__(self, query, val): - """Set key or key chain of container object. + """ + Set key or key chain of container object. Parameters ---------- @@ -4126,7 +4201,8 @@ def _cont_ivy(self, local_ivy): @property def cont_shape(self): - """The shape of the arrays in the container. + """ + The shape of the arrays in the container. None is placed in indices which are not consistent across arrays. @@ -4135,7 +4211,8 @@ def cont_shape(self): @property def cont_dtype(self): - """The dtype of the arrays in the container. + """ + The dtype of the arrays in the container. None is returned if the dtypes are not consistent. """ @@ -4143,7 +4220,8 @@ def cont_dtype(self): @property def cont_shapes(self): - """The shapes of each array in the container. + """ + The shapes of each array in the container. None is placed in leaf entries without a shape attribute. """ @@ -4151,7 +4229,8 @@ def cont_shapes(self): @property def cont_dev(self): - """The device to which the arrays in the container belong. + """ + The device to which the arrays in the container belong. None returned if the devices are not consistent. """ @@ -4159,7 +4238,8 @@ def cont_dev(self): @property def cont_dev_str(self): - """The device to which the arrays in the container belong. + """ + The device to which the arrays in the container belong. None returned if the devices are not consistent. """ diff --git a/ivy/data_classes/container/container.py b/ivy/data_classes/container/container.py index 2c430ec1d3426..cc7d4fcf1b6dc 100644 --- a/ivy/data_classes/container/container.py +++ b/ivy/data_classes/container/container.py @@ -141,9 +141,9 @@ def __neg__(self): return self.cont_map(lambda x, kc: -x, map_sequences=True) def __pow__(self, power): - """ivy.Container special method for the power operator, calling - :code:`operator.pow` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the power operator, calling + :code:`operator.pow` for each of the corresponding leaves of the two containers. Parameters ---------- @@ -196,9 +196,9 @@ def __ipow__(self, power): return self.cont_map(lambda x, _: operator.ipow(x, power), map_sequences=True) def __add__(self, other): - """ivy.Container special method for the add operator, calling - :code:`operator.add` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the add operator, calling :code:`operator.add` + for each of the corresponding leaves of the two containers. Parameters ---------- @@ -261,9 +261,9 @@ def __add__(self, other): ) def __radd__(self, other): - """ivy.Container reverse special method for the add operator, calling - :code:`operator.add` for each of the corresponding leaves of the two - containers. + """ + ivy.Container reverse special method for the add operator, calling + :code:`operator.add` for each of the corresponding leaves of the two containers. Parameters ---------- @@ -300,9 +300,9 @@ def __iadd__(self, other): ) def __sub__(self, other): - """ivy.Container special method for the subtract operator, calling - :code:`operator.sub` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the subtract operator, calling + :code:`operator.sub` for each of the corresponding leaves of the two containers. Parameters ---------- @@ -370,9 +370,9 @@ def __isub__(self, other): ) def __rsub__(self, other): - """ivy.Container reverse special method for the subtract operator, - calling :code:`operator.sub` for each of the corresponding leaves of - the two containers. + """ + ivy.Container reverse special method for the subtract operator, calling + :code:`operator.sub` for each of the corresponding leaves of the two containers. Parameters ---------- @@ -448,9 +448,10 @@ def __rdivmod__(self, other): ) def __truediv__(self, other): - """ivy.Container special method for the divide operator, calling - :code:`operator.truediv` for each of the corresponding leaves of the - two containers. + """ + ivy.Container special method for the divide operator, calling + :code:`operator.truediv` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -563,9 +564,9 @@ def __imatmul__(self, other): ) def __abs__(self): - """ivy.Container special method for the abs operator, calling - :code:`operator.abs` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the abs operator, calling :code:`operator.abs` + for each of the corresponding leaves of the two containers. Parameters ---------- @@ -593,9 +594,9 @@ def __abs__(self): return self.cont_map(lambda x, kc: operator.abs(x), map_sequences=True) def __lt__(self, other): - """ivy.Container special method for the less operator, calling - :code:`operator.lt` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the less operator, calling :code:`operator.lt` + for each of the corresponding leaves of the two containers. Parameters ---------- @@ -631,9 +632,9 @@ def __lt__(self, other): return self.cont_map(lambda x, kc: x < other, map_sequences=True) def __le__(self, other): - """ivy.Container special method for the less_equal operator, calling - :code:`operator.le` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the less_equal operator, calling + :code:`operator.le` for each of the corresponding leaves of the two containers. Parameters ---------- @@ -669,9 +670,9 @@ def __le__(self, other): return self.cont_map(lambda x, kc: x <= other, map_sequences=True) def __eq__(self, other): - """ivy.Container special method for the equal operator, calling - :code:`operator.eq` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the equal operator, calling :code:`operator.eq` + for each of the corresponding leaves of the two containers. Parameters ---------- @@ -731,9 +732,9 @@ def __eq__(self, other): return self.cont_map(lambda x, kc: x == other, map_sequences=True) def __ne__(self, other): - """ivy.Container special method for the not_equal operator, calling - :code:`operator.ne` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the not_equal operator, calling + :code:`operator.ne` for each of the corresponding leaves of the two containers. Parameters ---------- @@ -793,9 +794,9 @@ def __ne__(self, other): return self.cont_map(lambda x, kc: x != other, map_sequences=True) def __gt__(self, other): - """ivy.Container special method for the greater operator, calling - :code:`operator.gt` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the greater operator, calling + :code:`operator.gt` for each of the corresponding leaves of the two containers. Parameters ---------- @@ -831,9 +832,9 @@ def __gt__(self, other): return self.cont_map(lambda x, kc: x > other, map_sequences=True) def __ge__(self, other): - """ivy.Container special method for the greater_equal operator, calling - :code:`operator.ge` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the greater_equal operator, calling + :code:`operator.ge` for each of the corresponding leaves of the two containers. Parameters ---------- @@ -904,9 +905,9 @@ def __invert__(self): return self.cont_map(lambda x, kc: operator.not_(x), map_sequences=True) def __xor__(self, other): - """ivy.Container special method for the ge operator, calling - :code:`operator.ge` for each of the corresponding leaves of the two - containers. + """ + ivy.Container special method for the ge operator, calling :code:`operator.ge` + for each of the corresponding leaves of the two containers. Parameters ---------- @@ -979,7 +980,8 @@ def __ilshift__(self, other): ) def __rshift__(self, other): - """ivy.Container special method for the right shift operator, calling + """ + ivy.Container special method for the right shift operator, calling :code:`operator.rshift` for each of the corresponding leaves of the two containers. @@ -1047,9 +1049,10 @@ def __rshift__(self, other): ) def __rrshift__(self, other): - """ivy.Container reverse special method for the right shift operator, - calling :code:`operator.rshift` for each of the corresponding leaves of - the two containers. + """ + ivy.Container reverse special method for the right shift operator, calling + :code:`operator.rshift` for each of the corresponding leaves of the two + containers. Parameters ---------- diff --git a/ivy/data_classes/container/conversions.py b/ivy/data_classes/container/conversions.py index f57bc6b58b2c8..00cdf6cdcfef8 100644 --- a/ivy/data_classes/container/conversions.py +++ b/ivy/data_classes/container/conversions.py @@ -1,4 +1,5 @@ -"""Ivy wrapping functions for conversions. +""" +Ivy wrapping functions for conversions. Collection of Ivy functions for wrapping functions to accept and return ivy.Array instances. @@ -25,7 +26,8 @@ def _static_to_native( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.to_native. + """ + ivy.Container static method variant of ivy.to_native. This method simply wraps the function, and so the docstring for ivy.to_native also applies to this method with minimal changes. @@ -84,7 +86,8 @@ def to_native( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.to_native. + """ + ivy.Container instance method variant of ivy.to_native. This method simply wraps the function, and so the docstring for ivy.to_native also applies to this method with minimal changes. @@ -143,7 +146,8 @@ def _static_to_ivy( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.to_ivy. + """ + ivy.Container static method variant of ivy.to_ivy. This method simply wraps the function, and so the docstring for ivy.to_ivy also applies to this method with minimal changes. @@ -203,7 +207,8 @@ def to_ivy( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.to_ivy. + """ + ivy.Container instance method variant of ivy.to_ivy. This method simply wraps the function, and so the docstring for ivy.to_ivy also applies to this method with minimal changes. diff --git a/ivy/data_classes/container/creation.py b/ivy/data_classes/container/creation.py index f66a19fc9d2b0..83ec6aafc6884 100644 --- a/ivy/data_classes/container/creation.py +++ b/ivy/data_classes/container/creation.py @@ -59,9 +59,10 @@ def _static_asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.asarray. This method - simply wraps the function, and so the docstring for ivy.asarray also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.asarray. This method simply wraps the + function, and so the docstring for ivy.asarray also applies to this method with + minimal changes. Parameters ---------- @@ -256,9 +257,10 @@ def _static_full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.full_like. This method - simply wraps the function, and so the docstring for ivy.full_like also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.full_like. This method simply wraps + the function, and so the docstring for ivy.full_like also applies to this method + with minimal changes. Parameters ---------- @@ -341,9 +343,10 @@ def full_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.full_like. This method - simply wraps the function, and so the docstring for ivy.full_like also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.full_like. This method simply wraps + the function, and so the docstring for ivy.full_like also applies to this method + with minimal changes. Parameters ---------- @@ -425,9 +428,10 @@ def _static_ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.ones_like. This method - simply wraps the function, and so the docstring for ivy.ones_like also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.ones_like. This method simply wraps + the function, and so the docstring for ivy.ones_like also applies to this method + with minimal changes. Parameters ---------- @@ -483,9 +487,10 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.ones_like. This method - simply wraps the function, and so the docstring for ivy.ones_like also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.ones_like. This method simply wraps + the function, and so the docstring for ivy.ones_like also applies to this method + with minimal changes. Parameters ---------- @@ -541,9 +546,10 @@ def _static_zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.zeros_like. This method - simply wraps the function, and so the docstring for ivy.zeros_like also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.zeros_like. This method simply wraps + the function, and so the docstring for ivy.zeros_like also applies to this + method with minimal changes. Parameters ---------- @@ -599,9 +605,10 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.zeros_like. This method - simply wraps the function, and so the docstring for ivy.zeros_like also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.zeros_like. This method simply + wraps the function, and so the docstring for ivy.zeros_like also applies to this + method with minimal changes. Parameters ---------- @@ -1074,9 +1081,10 @@ def _static_logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.logspace. This method - simply wraps the function, and so the docstring for ivy.logspace also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.logspace. This method simply wraps + the function, and so the docstring for ivy.logspace also applies to this method + with minimal changes. Parameters ---------- @@ -1156,9 +1164,10 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.logspace. This method - simply wraps the function, and so the docstring for ivy.logspace also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.logspace. This method simply wraps + the function, and so the docstring for ivy.logspace also applies to this method + with minimal changes. Parameters ---------- @@ -1257,9 +1266,10 @@ def _static_one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.one_hot. This method - simply wraps the function, and so the docstring for ivy.one_hot also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.one_hot. This method simply wraps the + function, and so the docstring for ivy.one_hot also applies to this method with + minimal changes. Parameters ---------- @@ -1356,9 +1366,10 @@ def one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.one_hot. This method - simply wraps the function, and so the docstring for ivy.one_hot also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.one_hot. This method simply wraps + the function, and so the docstring for ivy.one_hot also applies to this method + with minimal changes. Parameters ---------- @@ -1452,9 +1463,10 @@ def static_frombuffer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container static method variant of ivy.frombuffer. This method - simply wraps the function, and so the docstring for ivy.frombuffer also - applies to this method with minimal changes. + r""" + ivy.Container static method variant of ivy.frombuffer. This method simply wraps + the function, and so the docstring for ivy.frombuffer also applies to this + method with minimal changes. Parameters ---------- @@ -1531,9 +1543,10 @@ def frombuffer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.frombuffer. This method - simply wraps the function, and so the docstring for ivy.frombuffer also - applies to this method with minimal changes. + r""" + ivy.Container instance method variant of ivy.frombuffer. This method simply + wraps the function, and so the docstring for ivy.frombuffer also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/data_type.py b/ivy/data_classes/container/data_type.py index 7e45fe10c6b7d..c8d7533d64006 100644 --- a/ivy/data_classes/container/data_type.py +++ b/ivy/data_classes/container/data_type.py @@ -22,8 +22,9 @@ def _static_astype( copy: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Copy an array to a specified data type irrespective of :ref:`type- - promotion` rules. + """ + Copy an array to a specified data type irrespective of :ref:`type- promotion` + rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -92,8 +93,9 @@ def astype( copy: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Copy an array to a specified data type irrespective of :ref:`type- - promotion` rules. + """ + Copy an array to a specified data type irrespective of :ref:`type- promotion` + rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -160,10 +162,10 @@ def _static_broadcast_arrays( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` static method variant of `ivy.broadcast_arrays`. - This method simply wraps the function, and so the docstring for - `ivy.broadcast_arrays` also applies to this method with minimal - changes. + """ + `ivy.Container` static method variant of `ivy.broadcast_arrays`. This method + simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also + applies to this method with minimal changes. Parameters ---------- @@ -236,10 +238,10 @@ def broadcast_arrays( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` instance method variant of `ivy.broadcast_arrays`. - This method simply wraps the function, and so the docstring for - `ivy.broadcast_arrays` also applies to this method with minimal - changes. + """ + `ivy.Container` instance method variant of `ivy.broadcast_arrays`. This method + simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also + applies to this method with minimal changes. Parameters ---------- @@ -313,9 +315,10 @@ def _static_broadcast_to( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """`ivy.Container` static method variant of `ivy.broadcast_to`. This - method simply wraps the function, and so the docstring for - `ivy.broadcast_to` also applies to this method with minimal changes. + """ + `ivy.Container` static method variant of `ivy.broadcast_to`. This method simply + wraps the function, and so the docstring for `ivy.broadcast_to` also applies to + this method with minimal changes. Parameters ---------- @@ -370,9 +373,10 @@ def broadcast_to( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """`ivy.Container` instance method variant of `ivy.broadcast_to`. This - method simply wraps the function, and so the docstring for - `ivy.broadcast_to` also applies to this method with minimal changes. + """ + `ivy.Container` instance method variant of `ivy.broadcast_to`. This method + simply wraps the function, and so the docstring for `ivy.broadcast_to` also + applies to this method with minimal changes. Parameters ---------- @@ -424,9 +428,10 @@ def _static_can_cast( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` static method variant of `ivy.can_cast`. This method - simply wraps the function, and so the docstring for `ivy.can_cast` also - applies to this method with minimal changes. + """ + `ivy.Container` static method variant of `ivy.can_cast`. This method simply + wraps the function, and so the docstring for `ivy.can_cast` also applies to this + method with minimal changes. Parameters ---------- @@ -483,9 +488,10 @@ def can_cast( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` instance method variant of `ivy.can_cast`. This - method simply wraps the function, and so the docstring for - `ivy.can_cast` also applies to this method with minimal changes. + """ + `ivy.Container` instance method variant of `ivy.can_cast`. This method simply + wraps the function, and so the docstring for `ivy.can_cast` also applies to this + method with minimal changes. Parameters ---------- @@ -673,7 +679,8 @@ def _static_finfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` static method variant of `ivy.finfo`. + """ + `ivy.Container` static method variant of `ivy.finfo`. Parameters ---------- @@ -718,7 +725,8 @@ def finfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` instance method variant of `ivy.finfo`. + """ + `ivy.Container` instance method variant of `ivy.finfo`. Parameters ---------- @@ -762,9 +770,10 @@ def _static_iinfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` static method variant of `ivy.iinfo`. This method - simply wraps the function, and so the docstring for `ivy.iinfo` also - applies to this method with minimal changes. + """ + `ivy.Container` static method variant of `ivy.iinfo`. This method simply wraps + the function, and so the docstring for `ivy.iinfo` also applies to this method + with minimal changes. Parameters ---------- @@ -821,9 +830,10 @@ def iinfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` instance method variant of `ivy.iinfo`. This method - simply wraps the function, and so the docstring for `ivy.iinfo` also - applies to this method with minimal changes. + """ + `ivy.Container` instance method variant of `ivy.iinfo`. This method simply wraps + the function, and so the docstring for `ivy.iinfo` also applies to this method + with minimal changes. Parameters ---------- @@ -922,9 +932,10 @@ def _static_is_float_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` static method variant of `is_float_dtype`. This - method simply wraps this function, so the docstring of `is_float_dtype` - roughly applies to this method. + """ + `ivy.Container` static method variant of `is_float_dtype`. This method simply + wraps this function, so the docstring of `is_float_dtype` roughly applies to + this method. Parameters ---------- @@ -992,9 +1003,10 @@ def is_float_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` instance method variant of `ivy.is_float_dtype`. - This method simply wraps the function, and so the docstring for - `ivy.is_float_dtype` also applies to this method with minimal changes. + """ + `ivy.Container` instance method variant of `ivy.is_float_dtype`. This method + simply wraps the function, and so the docstring for `ivy.is_float_dtype` also + applies to this method with minimal changes. Parameters ---------- @@ -1131,9 +1143,10 @@ def _static_is_complex_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` static method variant of `is_complex_dtype`. This - method simply wraps this function, so the docstring of - `is_complex_dtype` roughly applies to this method. + """ + `ivy.Container` static method variant of `is_complex_dtype`. This method simply + wraps this function, so the docstring of `is_complex_dtype` roughly applies to + this method. Parameters ---------- @@ -1189,10 +1202,10 @@ def is_complex_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` instance method variant of `ivy.is_complex_dtype`. - This method simply wraps the function, and so the docstring for - `ivy.is_complex_dtype` also applies to this method with minimal - changes. + """ + `ivy.Container` instance method variant of `ivy.is_complex_dtype`. This method + simply wraps the function, and so the docstring for `ivy.is_complex_dtype` also + applies to this method with minimal changes. Parameters ---------- @@ -1250,9 +1263,10 @@ def _static_result_type( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` static method variant of `ivy.result_type`. This - method simply wraps the function, and so the docstring for - `ivy.result_type` also applies to this method with minimal changes. + """ + `ivy.Container` static method variant of `ivy.result_type`. This method simply + wraps the function, and so the docstring for `ivy.result_type` also applies to + this method with minimal changes. Parameters ---------- @@ -1305,9 +1319,10 @@ def result_type( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """`ivy.Container` instance method variant of `ivy.result_type`. This - method simply wraps the function, and so the docstring for - `ivy.result_type` also applies to this method with minimal changes. + """ + `ivy.Container` instance method variant of `ivy.result_type`. This method simply + wraps the function, and so the docstring for `ivy.result_type` also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/device.py b/ivy/data_classes/container/device.py index 9012fd4f4e989..3960c59d83f1f 100644 --- a/ivy/data_classes/container/device.py +++ b/ivy/data_classes/container/device.py @@ -13,9 +13,10 @@ class _ContainerWithDevice(ContainerBase): def _static_dev( x: ivy.Container, /, *, as_native: Union[bool, ivy.Container] = False ) -> ivy.Container: - """ivy.Container static method variant of ivy.dev. This method simply - wraps the function, and so the docstring for ivy.dev also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.dev. This method simply wraps the + function, and so the docstring for ivy.dev also applies to this method with + minimal changes. Examples -------- @@ -34,9 +35,10 @@ def _static_dev( def dev( self: ivy.Container, as_native: Union[bool, ivy.Container] = False ) -> ivy.Container: - """ivy.Container instance method variant of ivy.dev. This method simply - wraps the function, and so the docstring for ivy.dev also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.dev. This method simply wraps the + function, and so the docstring for ivy.dev also applies to this method with + minimal changes. Parameters ---------- @@ -72,9 +74,10 @@ def _static_to_device( stream: Optional[Union[int, Any, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.to_device. This method - simply wraps the function, and so the docstring for ivy.to_device also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.to_device. This method simply wraps + the function, and so the docstring for ivy.to_device also applies to this method + with minimal changes. Parameters ---------- @@ -138,9 +141,10 @@ def to_device( stream: Optional[Union[int, Any, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.to_device. This method - simply wraps the function, and so the docstring for ivy.to_device also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.to_device. This method simply wraps + the function, and so the docstring for ivy.to_device also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/elementwise.py b/ivy/data_classes/container/elementwise.py index 8932ae067e331..c52a3f42ba646 100644 --- a/ivy/data_classes/container/elementwise.py +++ b/ivy/data_classes/container/elementwise.py @@ -18,9 +18,10 @@ def _static_abs( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: # noqa - """ivy.Container static method variant of ivy.abs. This method simply - wraps the function, and so the docstring for ivy.abs also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.abs. This method simply wraps the + function, and so the docstring for ivy.abs also applies to this method with + minimal changes. Parameters ---------- @@ -77,9 +78,10 @@ def abs( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.abs. This method simply - wraps the function, and so the docstring for ivy.abs also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.abs. This method simply wraps the + function, and so the docstring for ivy.abs also applies to this method with + minimal changes. Parameters ---------- @@ -138,9 +140,10 @@ def _static_acosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cosh. This method simply - wraps the function, and so the docstring for ivy.cosh also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.cosh. This method simply wraps the + function, and so the docstring for ivy.cosh also applies to this method with + minimal changes. Parameters ---------- @@ -199,9 +202,10 @@ def acosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.acosh. This method - simply wraps the function, and so the docstring for ivy.acosh also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.acosh. This method simply wraps the + function, and so the docstring for ivy.acosh also applies to this method with + minimal changes. Parameters ---------- @@ -261,9 +265,10 @@ def _static_acos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.acos. This method simply - wraps the function, and so the docstring for ivy.acos also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.acos. This method simply wraps the + function, and so the docstring for ivy.acos also applies to this method with + minimal changes. Parameters ---------- @@ -324,9 +329,10 @@ def _static_add( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.add. This method simply - wraps the function, and so the docstring for ivy.add also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.add. This method simply wraps the + function, and so the docstring for ivy.add also applies to this method with + minimal changes. Parameters ---------- @@ -422,9 +428,10 @@ def acos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.acos. This method - simply wraps the function, and so the docstring for ivy.acos also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.acos. This method simply wraps the + function, and so the docstring for ivy.acos also applies to this method with + minimal changes. Parameters ---------- @@ -483,9 +490,10 @@ def add( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.add. This method simply - wraps the function, and so the docstring for ivy.add also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.add. This method simply wraps the + function, and so the docstring for ivy.add also applies to this method with + minimal changes. Parameters ---------- @@ -561,9 +569,10 @@ def _static_asin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.asin. This method simply - wraps the function, and so the docstring for ivy.asin also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.asin. This method simply wraps the + function, and so the docstring for ivy.asin also applies to this method with + minimal changes. Parameters ---------- @@ -631,9 +640,10 @@ def asin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.asin. This method - simply wraps the function, and so the docstring for ivy.asin also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.asin. This method simply wraps the + function, and so the docstring for ivy.asin also applies to this method with + minimal changes. Parameters ---------- @@ -702,9 +712,10 @@ def _static_asinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.asinh. This method simply - wraps the function, and so the docstring for ivy.asinh also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.asinh. This method simply wraps the + function, and so the docstring for ivy.asinh also applies to this method with + minimal changes. Parameters ---------- @@ -763,9 +774,10 @@ def asinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.asinh. This method - simply wraps the function, and so the docstring for ivy.asinh also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.asinh. This method simply wraps the + function, and so the docstring for ivy.asinh also applies to this method with + minimal changes. Parameters ---------- @@ -825,9 +837,10 @@ def _static_atan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.atan. This method simply - wraps the function, and so the docstring for ivy.atan also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.atan. This method simply wraps the + function, and so the docstring for ivy.atan also applies to this method with + minimal changes. Parameters ---------- @@ -884,9 +897,10 @@ def atan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.atan. This method - simply wraps the function, and so the docstring for ivy.atan also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.atan. This method simply wraps the + function, and so the docstring for ivy.atan also applies to this method with + minimal changes. Parameters ---------- @@ -945,9 +959,10 @@ def _static_atan2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.atan2. This method simply - wraps the function, and so the docstring for ivy.atan2 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.atan2. This method simply wraps the + function, and so the docstring for ivy.atan2 also applies to this method with + minimal changes. Parameters ---------- @@ -1025,9 +1040,10 @@ def atan2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.atan2. This method - simply wraps the function, and so the docstring for ivy.atan2 also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.atan2. This method simply wraps the + function, and so the docstring for ivy.atan2 also applies to this method with + minimal changes. Parameters ---------- @@ -1103,9 +1119,10 @@ def _static_atanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.atanh. This method simply - wraps the function, and so the docstring for ivy.atanh also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.atanh. This method simply wraps the + function, and so the docstring for ivy.atanh also applies to this method with + minimal changes. Parameters ---------- @@ -1163,9 +1180,10 @@ def atanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.atanh. This method - simply wraps the function, and so the docstring for ivy.atanh also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.atanh. This method simply wraps the + function, and so the docstring for ivy.atanh also applies to this method with + minimal changes. Parameters ---------- @@ -1225,9 +1243,10 @@ def _static_bitwise_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.bitwise_and. This method - simply wraps the function, and so the docstring for ivy.bitwise_and - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.bitwise_and. This method simply wraps + the function, and so the docstring for ivy.bitwise_and also applies to this + method with minimal changes. Parameters ---------- @@ -1309,9 +1328,10 @@ def bitwise_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.bitwise_and. This - method simply wraps the function, and so the docstring for - ivy.bitwise_and also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.bitwise_and. This method simply + wraps the function, and so the docstring for ivy.bitwise_and also applies to + this method with minimal changes. Parameters ---------- @@ -1377,10 +1397,10 @@ def _static_bitwise_left_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.bitwise_left_shift. This - method simply wraps the function, and so the docstring for - ivy.bitwise_left_shift also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.bitwise_left_shift. This method + simply wraps the function, and so the docstring for ivy.bitwise_left_shift also + applies to this method with minimal changes. Parameters ---------- @@ -1435,10 +1455,10 @@ def bitwise_left_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.bitwise_left_shift. - This method simply wraps the function, and so the docstring for - ivy.bitwise_left_shift also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.bitwise_left_shift. This method + simply wraps the function, and so the docstring for ivy.bitwise_left_shift also + applies to this method with minimal changes. Parameters ---------- @@ -1491,9 +1511,10 @@ def _static_bitwise_invert( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.bitwise_invert. This - method simply wraps the function, and so the docstring for - ivy.bitwise_invert also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.bitwise_invert. This method simply + wraps the function, and so the docstring for ivy.bitwise_invert also applies to + this method with minimal changes. Parameters ---------- @@ -1557,9 +1578,10 @@ def bitwise_invert( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.bitwise_invert. This - method simply wraps the function, and so the docstring for - ivy.bitwise_invert also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.bitwise_invert. This method simply + wraps the function, and so the docstring for ivy.bitwise_invert also applies to + this method with minimal changes. Parameters ---------- @@ -1626,9 +1648,10 @@ def _static_cos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cos. This method simply - wraps the function, and so the docstring for ivy.cos also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.cos. This method simply wraps the + function, and so the docstring for ivy.cos also applies to this method with + minimal changes. Parameters ---------- @@ -1688,9 +1711,10 @@ def cos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cos. This method simply - wraps the function, and so the docstring for ivy.cos also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cos. This method simply wraps the + function, and so the docstring for ivy.cos also applies to this method with + minimal changes. Parameters ---------- @@ -1752,9 +1776,10 @@ def _static_bitwise_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.bitwise_or. This method - simply wraps the function, and so the docstring for ivy.bitwise_or also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.bitwise_or. This method simply wraps + the function, and so the docstring for ivy.bitwise_or also applies to this + method with minimal changes. Parameters ---------- @@ -1828,9 +1853,10 @@ def bitwise_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.bitwise_or. This method - simply wraps the function, and so the docstring for ivy.bitwise_or also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.bitwise_or. This method simply + wraps the function, and so the docstring for ivy.bitwise_or also applies to this + method with minimal changes. Parameters ---------- @@ -1894,10 +1920,10 @@ def _static_bitwise_right_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.bitwise_right_shift. This - method simply wraps the function, and so the docstring for - ivy.bitwise_right_shift also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.bitwise_right_shift. This method + simply wraps the function, and so the docstring for ivy.bitwise_right_shift also + applies to this method with minimal changes. Parameters ---------- @@ -1975,10 +2001,10 @@ def bitwise_right_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.bitwise_right_shift. - This method simply wraps the function, and so the docstring for - ivy.bitwise_right_shift also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.bitwise_right_shift. This method + simply wraps the function, and so the docstring for ivy.bitwise_right_shift also + applies to this method with minimal changes. Parameters ---------- @@ -2042,9 +2068,10 @@ def _static_bitwise_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.bitwise_xor. This method - simply wraps the function, and so the docstring for ivy.bitwise_xor - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.bitwise_xor. This method simply wraps + the function, and so the docstring for ivy.bitwise_xor also applies to this + method with minimal changes. Parameters ---------- @@ -2110,9 +2137,10 @@ def bitwise_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.bitwise_xor. This - method simply wraps the function, and so the docstring for - ivy.bitwise_xor also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.bitwise_xor. This method simply + wraps the function, and so the docstring for ivy.bitwise_xor also applies to + this method with minimal changes. Parameters ---------- @@ -2177,9 +2205,10 @@ def _static_ceil( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.ceil. This method simply - wraps the function, and so the docstring for ivy.ceil also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.ceil. This method simply wraps the + function, and so the docstring for ivy.ceil also applies to this method with + minimal changes. Parameters ---------- @@ -2236,9 +2265,10 @@ def ceil( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.ceil. This method - simply wraps the function, and so the docstring for ivy.ceil also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.ceil. This method simply wraps the + function, and so the docstring for ivy.ceil also applies to this method with + minimal changes. Parameters ---------- @@ -2296,9 +2326,10 @@ def _static_cosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cosh. This method simply - wraps the function, and so the docstring for ivy.cosh also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.cosh. This method simply wraps the + function, and so the docstring for ivy.cosh also applies to this method with + minimal changes. Parameters ---------- @@ -2368,9 +2399,10 @@ def cosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cosh. This method - simply wraps the function, and so the docstring for ivy.cosh also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cosh. This method simply wraps the + function, and so the docstring for ivy.cosh also applies to this method with + minimal changes. Parameters ---------- @@ -2442,9 +2474,10 @@ def _static_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.divide. This method - simply wraps the function, and so the docstring for ivy.divide also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.divide. This method simply wraps the + function, and so the docstring for ivy.divide also applies to this method with + minimal changes. Parameters ---------- @@ -2511,9 +2544,10 @@ def divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.divide. This method - simply wraps the function, and so the docstring for ivy.divide also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.divide. This method simply wraps + the function, and so the docstring for ivy.divide also applies to this method + with minimal changes. Parameters ---------- @@ -2592,9 +2626,10 @@ def _static_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.equal. This method simply - wraps the function, and so the docstring for ivy.equal also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.equal. This method simply wraps the + function, and so the docstring for ivy.equal also applies to this method with + minimal changes. Parameters ---------- @@ -2660,9 +2695,10 @@ def equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.equal. This method - simply wraps the function, and so the docstring for ivy.equal also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.equal. This method simply wraps the + function, and so the docstring for ivy.equal also applies to this method with + minimal changes. Parameters ---------- @@ -2740,9 +2776,10 @@ def static_nan_to_num( neginf: Optional[Union[float, int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.nan_to_num. This method - simply wraps the function, and so the docstring for ivy.nan_to_num also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.nan_to_num. This method simply wraps + the function, and so the docstring for ivy.nan_to_num also applies to this + method with minimal changes. Parameters ---------- @@ -2804,9 +2841,10 @@ def nan_to_num( neginf: Optional[Union[float, int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.nan_to_num. This method - simply wraps the function, and so the docstring for ivy.nan_to_num also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.nan_to_num. This method simply + wraps the function, and so the docstring for ivy.nan_to_num also applies to this + method with minimal changes. Parameters ---------- @@ -2861,9 +2899,10 @@ def static_imag( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.imag. This method simply - wraps the function, and so the docstring for ivy.imag also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.imag. This method simply wraps the + function, and so the docstring for ivy.imag also applies to this method with + minimal changes. Parameters ---------- @@ -2909,9 +2948,10 @@ def imag( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.imag. This method - simply wraps the function, and so the docstring for ivy.imag also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.imag. This method simply wraps the + function, and so the docstring for ivy.imag also applies to this method with + minimal changes. Parameters ---------- @@ -2955,9 +2995,10 @@ def static_angle( deg: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.angle. This method simply - wraps the function, and so the docstring for ivy.angle also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.angle. This method simply wraps the + function, and so the docstring for ivy.angle also applies to this method with + minimal changes. Parameters ---------- @@ -3015,9 +3056,10 @@ def angle( deg: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.angle. This method - simply wraps the function, and so the docstring for ivy.angle also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.angle. This method simply wraps the + function, and so the docstring for ivy.angle also applies to this method with + minimal changes. Parameters ---------- @@ -3071,9 +3113,10 @@ def static_gcd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.gcd. This method simply - wraps the function, and so the docstring for ivy.gcd also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.gcd. This method simply wraps the + function, and so the docstring for ivy.gcd also applies to this method with + minimal changes. Parameters ---------- @@ -3119,9 +3162,10 @@ def gcd( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.gcd. This method simply - wraps the function, and so the docstring for ivy.gcd also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.gcd. This method simply wraps the + function, and so the docstring for ivy.gcd also applies to this method with + minimal changes. Parameters ---------- @@ -3162,9 +3206,10 @@ def static_exp2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.exp2. This method simply - wraps the function, and so the docstring for ivy.exp2 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.exp2. This method simply wraps the + function, and so the docstring for ivy.exp2 also applies to this method with + minimal changes. Parameters ---------- @@ -3205,9 +3250,10 @@ def exp2( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.exp2. This method - simply wraps the function, and so the docstring for ivy.exp2 also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.exp2. This method simply wraps the + function, and so the docstring for ivy.exp2 also applies to this method with + minimal changes. Parameters ---------- @@ -3245,9 +3291,10 @@ def _static_exp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.exp. This method simply - wraps the function, and so the docstring for ivy.exp also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.exp. This method simply wraps the + function, and so the docstring for ivy.exp also applies to this method with + minimal changes. Parameters ---------- @@ -3304,9 +3351,10 @@ def exp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.exp. This method simply - wraps the function, and so the docstring for ivy.exp also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.exp. This method simply wraps the + function, and so the docstring for ivy.exp also applies to this method with + minimal changes. Parameters ---------- @@ -3364,9 +3412,10 @@ def _static_expm1( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.expm1. This method simply - wraps thefunction, and so the docstring for ivy.expm1 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.expm1. This method simply wraps + thefunction, and so the docstring for ivy.expm1 also applies to this method with + minimal changes. Parameters ---------- @@ -3424,9 +3473,10 @@ def expm1( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.expm1. This method - simply wraps the function, and so the docstring for ivy.expm1 also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.expm1. This method simply wraps the + function, and so the docstring for ivy.expm1 also applies to this method with + minimal changes. Parameters ---------- @@ -3493,9 +3543,10 @@ def _static_floor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.floor. This method simply - wraps thefunction, and so the docstring for ivy.floor also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.floor. This method simply wraps + thefunction, and so the docstring for ivy.floor also applies to this method with + minimal changes. Parameters ---------- @@ -3552,9 +3603,10 @@ def floor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.floor. This method - simply wraps the function, and so the docstring for ivy.floor also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.floor. This method simply wraps the + function, and so the docstring for ivy.floor also applies to this method with + minimal changes. Parameters ---------- @@ -3613,9 +3665,10 @@ def _static_floor_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.floor_divide. This method - simply wraps the function, and so the docstring for ivy.floor_divide - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.floor_divide. This method simply + wraps the function, and so the docstring for ivy.floor_divide also applies to + this method with minimal changes. Parameters ---------- @@ -3693,9 +3746,10 @@ def floor_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.floor_divide. This - method simply wraps the function, and so the docstring for - ivy.floor_divide also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.floor_divide. This method simply + wraps the function, and so the docstring for ivy.floor_divide also applies to + this method with minimal changes. Parameters ---------- @@ -3774,9 +3828,10 @@ def static_fmin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fmin. This method simply - wraps the function, and so the docstring for ivy.fmin also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.fmin. This method simply wraps the + function, and so the docstring for ivy.fmin also applies to this method with + minimal changes. Parameters ---------- @@ -3822,9 +3877,10 @@ def fmin( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fmin. This method - simply wraps the function, and so the docstring for ivy.fmin also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.fmin. This method simply wraps the + function, and so the docstring for ivy.fmin also applies to this method with + minimal changes. Parameters ---------- @@ -3866,9 +3922,10 @@ def _static_greater( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.greater. This method - simply wraps the function, and so the docstring for ivy.greater also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.greater. This method simply wraps the + function, and so the docstring for ivy.greater also applies to this method with + minimal changes. Parameters ---------- @@ -3934,9 +3991,10 @@ def greater( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.greater. This method - simply wraps the function, and so the docstring for ivy.greater also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.greater. This method simply wraps + the function, and so the docstring for ivy.greater also applies to this method + with minimal changes. Parameters ---------- @@ -4002,9 +4060,10 @@ def _static_greater_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.greater_equal. This - method simply wraps the function, and so the docstring for - ivy.greater_equal also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.greater_equal. This method simply + wraps the function, and so the docstring for ivy.greater_equal also applies to + this method with minimal changes. Parameters ---------- @@ -4070,9 +4129,10 @@ def greater_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.greater_equal. This - method simply wraps the function, and so the docstring for - ivy.greater_equal also applies to this metho with minimal changes. + """ + ivy.Container instance method variant of ivy.greater_equal. This method simply + wraps the function, and so the docstring for ivy.greater_equal also applies to + this metho with minimal changes. Parameters ---------- @@ -4137,9 +4197,10 @@ def _static_isfinite( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.isfinite. This method - simply wraps the function, and so the docstring for ivy.isfinite also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.isfinite. This method simply wraps + the function, and so the docstring for ivy.isfinite also applies to this method + with minimal changes. Parameters ---------- @@ -4197,9 +4258,10 @@ def isfinite( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.isfinite. This method - simply wraps the function, and so the docstring for ivy.isfinite also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.isfinite. This method simply wraps + the function, and so the docstring for ivy.isfinite also applies to this method + with minimal changes. Parameters ---------- @@ -4260,9 +4322,10 @@ def _static_isinf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.isinf. This method simply - wraps the function, and so the docstring for ivy.isinf also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.isinf. This method simply wraps the + function, and so the docstring for ivy.isinf also applies to this method with + minimal changes. Parameters ---------- @@ -4330,9 +4393,10 @@ def isinf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.isinf. This method - simply wraps the function, and so the docstring for ivy.isinf also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.isinf. This method simply wraps the + function, and so the docstring for ivy.isinf also applies to this method with + minimal changes. Parameters ---------- @@ -4399,9 +4463,10 @@ def _static_isnan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.isnan. This method simply - wraps the function, and so the docstring for ivy.isnan also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.isnan. This method simply wraps the + function, and so the docstring for ivy.isnan also applies to this method with + minimal changes. Parameters ---------- @@ -4461,9 +4526,10 @@ def isnan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.isnan. This method - simply wraps the function, and so the docstring for ivy.isnan also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.isnan. This method simply wraps the + function, and so the docstring for ivy.isnan also applies to this method with + minimal changes. Parameters ---------- @@ -4523,9 +4589,10 @@ def _static_less( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.less. This method simply - wraps the function, and so the docstring for ivy.less also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.less. This method simply wraps the + function, and so the docstring for ivy.less also applies to this method with + minimal changes. Parameters ---------- @@ -4591,9 +4658,10 @@ def less( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.less. This method - simply wraps the function, and so the docstring for ivy.less also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.less. This method simply wraps the + function, and so the docstring for ivy.less also applies to this method with + minimal changes. Parameters ---------- @@ -4659,9 +4727,10 @@ def _static_less_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.less_equal. This method - simply wraps the function, and so the docstring for ivy.less_equal also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.less_equal. This method simply wraps + the function, and so the docstring for ivy.less_equal also applies to this + method with minimal changes. Parameters ---------- @@ -4727,9 +4796,10 @@ def less_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.less_equal. This method - simply wraps the function, and so the docstring for ivy.less_equal also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.less_equal. This method simply + wraps the function, and so the docstring for ivy.less_equal also applies to this + method with minimal changes. Parameters ---------- @@ -4805,9 +4875,10 @@ def _static_log( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.log. This method simply - wraps the function, and so the docstring for ivy.log also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.log. This method simply wraps the + function, and so the docstring for ivy.log also applies to this method with + minimal changes. Parameters ---------- @@ -4869,9 +4940,10 @@ def log( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.log. This method simply - wraps the function, and so the docstring for ivy.log also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.log. This method simply wraps the + function, and so the docstring for ivy.log also applies to this method with + minimal changes. Parameters ---------- @@ -4934,9 +5006,10 @@ def _static_log1p( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.log1p. This method simply - wraps the function, and so the docstring for ivy.log1p also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.log1p. This method simply wraps the + function, and so the docstring for ivy.log1p also applies to this method with + minimal changes. Parameters ---------- @@ -5001,9 +5074,10 @@ def log1p( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.log1p. This method - simply wraps the function, and so the docstring for ivy.log1p also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.log1p. This method simply wraps the + function, and so the docstring for ivy.log1p also applies to this method with + minimal changes. Parameters ---------- @@ -5062,9 +5136,10 @@ def _static_log2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.log2. This method simply - wraps the function, and so the docstring for ivy.log2 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.log2. This method simply wraps the + function, and so the docstring for ivy.log2 also applies to this method with + minimal changes. Parameters ---------- @@ -5126,9 +5201,10 @@ def log2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.log2. This method - simply wraps the function, and so the docstring for ivy.log2 also - applies to this metho with minimal changes. + """ + ivy.Container instance method variant of ivy.log2. This method simply wraps the + function, and so the docstring for ivy.log2 also applies to this metho with + minimal changes. Parameters ---------- @@ -5191,9 +5267,10 @@ def _static_log10( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.log10. This method simply - wraps the function, and so the docstring for ivy.log10 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.log10. This method simply wraps the + function, and so the docstring for ivy.log10 also applies to this method with + minimal changes. Parameters ---------- @@ -5255,9 +5332,10 @@ def log10( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.log10. This method - simply wraps the function, and so the docstring for ivy.log10 also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.log10. This method simply wraps the + function, and so the docstring for ivy.log10 also applies to this method with + minimal changes. Parameters ---------- @@ -5321,9 +5399,10 @@ def _static_logaddexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.greater_equal. This - method simply wraps the function, and so the docstring for - ivy.greater_equal also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.greater_equal. This method simply + wraps the function, and so the docstring for ivy.greater_equal also applies to + this method with minimal changes. Parameters ---------- @@ -5392,9 +5471,10 @@ def logaddexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.greater_equal. This - method simply wraps the function, and so the docstring for - ivy.greater_equal also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.greater_equal. This method simply + wraps the function, and so the docstring for ivy.greater_equal also applies to + this method with minimal changes. Parameters ---------- @@ -5463,9 +5543,10 @@ def static_logaddexp2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.logaddexp2. This method - simply wraps the function, and so the docstring for ivy.logaddexp2 also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.logaddexp2. This method simply wraps + the function, and so the docstring for ivy.logaddexp2 also applies to this + method with minimal changes. Parameters ---------- @@ -5511,9 +5592,10 @@ def logaddexp2( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.logaddexp2. This method - simply wraps the function, and so the docstring for ivy.logaddexp2 also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.logaddexp2. This method simply + wraps the function, and so the docstring for ivy.logaddexp2 also applies to this + method with minimal changes. Parameters ---------- @@ -5555,9 +5637,10 @@ def _static_logical_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.logical_and. This method - simply wraps the function, and so the docstring for ivy.logical_and - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.logical_and. This method simply wraps + the function, and so the docstring for ivy.logical_and also applies to this + method with minimal changes. Parameters ---------- @@ -5642,9 +5725,10 @@ def logical_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.logical_and. This - method simply wraps the function, and so the docstring for - ivy.logical_and also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.logical_and. This method simply + wraps the function, and so the docstring for ivy.logical_and also applies to + this method with minimal changes. Parameters ---------- @@ -5727,9 +5811,10 @@ def _static_logical_not( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.logical_not. This method - simply wraps the function, and so the docstring for ivy.logical_not - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.logical_not. This method simply wraps + the function, and so the docstring for ivy.logical_not also applies to this + method with minimal changes. Parameters ---------- @@ -5786,9 +5871,10 @@ def logical_not( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.logical_not. This - method simply wraps the function, and so the docstring for - ivy.logical_not also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.logical_not. This method simply + wraps the function, and so the docstring for ivy.logical_not also applies to + this method with minimal changes. Parameters ---------- @@ -5856,9 +5942,10 @@ def _static_logical_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.logical_or. This method - simply wraps the function, and so the docstring for ivy.logical_or also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.logical_or. This method simply wraps + the function, and so the docstring for ivy.logical_or also applies to this + method with minimal changes. Parameters ---------- @@ -5924,9 +6011,10 @@ def logical_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.logical_or. This method - simply wraps the function, and so the docstring for ivy.logical_or also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.logical_or. This method simply + wraps the function, and so the docstring for ivy.logical_or also applies to this + method with minimal changes. Parameters ---------- @@ -6003,9 +6091,10 @@ def _static_logical_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.logical_xor. This method - simply wraps the function, and so the docstring for ivy.logical_xor - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.logical_xor. This method simply wraps + the function, and so the docstring for ivy.logical_xor also applies to this + method with minimal changes. Parameters ---------- @@ -6082,9 +6171,10 @@ def logical_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.logical_xor. This - method simply wraps the function, and so the docstring for - ivy.logical_xor also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.logical_xor. This method simply + wraps the function, and so the docstring for ivy.logical_xor also applies to + this method with minimal changes. Parameters ---------- @@ -6148,9 +6238,10 @@ def _static_multiply( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.multiply. This method - simply wraps the function, and so the docstring for ivy.multiply also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.multiply. This method simply wraps + the function, and so the docstring for ivy.multiply also applies to this method + with minimal changes. Parameters ---------- @@ -6219,9 +6310,10 @@ def multiply( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.multiply. This method - simply wraps the function, and so the docstring for ivy.multiply also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.multiply. This method simply wraps + the function, and so the docstring for ivy.multiply also applies to this method + with minimal changes. Parameters ---------- @@ -6301,9 +6393,10 @@ def _static_negative( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.negative. This method - simply wraps the function, and so the docstring for ivy.negative also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.negative. This method simply wraps + the function, and so the docstring for ivy.negative also applies to this method + with minimal changes. Parameters ---------- @@ -6362,9 +6455,10 @@ def negative( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.negative. This method - simply wraps the function, and so the docstring for ivy.negative also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.negative. This method simply wraps + the function, and so the docstring for ivy.negative also applies to this method + with minimal changes. Parameters ---------- @@ -6425,9 +6519,10 @@ def _static_not_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.not_equal. This method - simply wraps the function, and so the docstring for ivy.not_equal also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.not_equal. This method simply wraps + the function, and so the docstring for ivy.not_equal also applies to this method + with minimal changes. Parameters ---------- @@ -6493,9 +6588,10 @@ def not_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.not_equal. This method - simply wraps the function, and so the docstring for ivy.not_equal also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.not_equal. This method simply wraps + the function, and so the docstring for ivy.not_equal also applies to this method + with minimal changes. Parameters ---------- @@ -6571,9 +6667,10 @@ def _static_positive( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.positive. This method - simply wraps the function, and so the docstring for ivy.positive also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.positive. This method simply wraps + the function, and so the docstring for ivy.positive also applies to this method + with minimal changes. Parameters ---------- @@ -6632,9 +6729,10 @@ def positive( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.positive. This method - simply wraps the function, and so the docstring for ivy.positive also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.positive. This method simply wraps + the function, and so the docstring for ivy.positive also applies to this method + with minimal changes. Parameters ---------- @@ -6695,9 +6793,10 @@ def _static_pow( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.pow. This method simply - wraps the function, and so the docstring for ivy.pow also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.pow. This method simply wraps the + function, and so the docstring for ivy.pow also applies to this method with + minimal changes. Parameters ---------- @@ -6762,9 +6861,10 @@ def pow( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.pow. This method simply - wraps the function, and so the docstring for ivy.pow also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.pow. This method simply wraps the + function, and so the docstring for ivy.pow also applies to this method with + minimal changes. Parameters ---------- @@ -6828,9 +6928,10 @@ def static_real( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.real. This method simply - wraps the function, and so the docstring for ivy.real also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.real. This method simply wraps the + function, and so the docstring for ivy.real also applies to this method with + minimal changes. Parameters ---------- @@ -6889,9 +6990,10 @@ def real( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.real. This method - simply wraps the function, and so the docstring for ivy.real also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.real. This method simply wraps the + function, and so the docstring for ivy.real also applies to this method with + minimal changes. Parameters ---------- @@ -6953,9 +7055,10 @@ def _static_remainder( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.remainder. This method - simply wraps the function, and so the docstring for ivy.remainder also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.remainder. This method simply wraps + the function, and so the docstring for ivy.remainder also applies to this method + with minimal changes. Parameters ---------- @@ -7048,9 +7151,10 @@ def remainder( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.remainder. This method - simply wraps the function, and so the docstring for ivy.remainder also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.remainder. This method simply wraps + the function, and so the docstring for ivy.remainder also applies to this method + with minimal changes. Parameters ---------- @@ -7142,9 +7246,10 @@ def _static_round( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.round. This method simply - wraps thevfunction, and so the docstring for ivy.round also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.round. This method simply wraps + thevfunction, and so the docstring for ivy.round also applies to this method + with minimal changes. Parameters ---------- @@ -7207,9 +7312,10 @@ def round( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.round. This method - simply wraps the function, and so the docstring for ivy.round also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.round. This method simply wraps the + function, and so the docstring for ivy.round also applies to this method with + minimal changes. Parameters ---------- @@ -7273,9 +7379,10 @@ def _static_sign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sign. This method simply - wraps the function, and so the docstring for ivy.sign also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.sign. This method simply wraps the + function, and so the docstring for ivy.sign also applies to this method with + minimal changes. Parameters ---------- @@ -7334,9 +7441,10 @@ def sign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sign. This method - simply wraps the function, and so the docstring for ivy.sign also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.sign. This method simply wraps the + function, and so the docstring for ivy.sign also applies to this method with + minimal changes. Parameters ---------- @@ -7397,9 +7505,10 @@ def _static_sin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sin. This method simply - wraps the function, and so the docstring for ivy.sin also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.sin. This method simply wraps the + function, and so the docstring for ivy.sin also applies to this method with + minimal changes. Parameters ---------- @@ -7458,9 +7567,10 @@ def sin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sin. This method simply - wraps the function, and so the docstring for ivy.sin also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.sin. This method simply wraps the + function, and so the docstring for ivy.sin also applies to this method with + minimal changes. Parameters ---------- @@ -7520,9 +7630,10 @@ def _static_sinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sinh. This method simply - wraps the function, and so the docstring for ivy.sinh also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.sinh. This method simply wraps the + function, and so the docstring for ivy.sinh also applies to this method with + minimal changes. Parameters ---------- @@ -7590,9 +7701,10 @@ def sinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sinh. This method - simply wraps the function, and so the docstring for ivy.sinh also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.sinh. This method simply wraps the + function, and so the docstring for ivy.sinh also applies to this method with + minimal changes. Parameters ---------- @@ -7661,9 +7773,10 @@ def _static_square( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.square. This method - simply wraps the function, and so the docstring for ivy.square also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.square. This method simply wraps the + function, and so the docstring for ivy.square also applies to this method with + minimal changes. Parameters ---------- @@ -7720,9 +7833,10 @@ def square( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.square. This method - simply wraps the function, and so the docstring for ivy.square also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.square. This method simply wraps + the function, and so the docstring for ivy.square also applies to this method + with minimal changes. Parameters ---------- @@ -7780,9 +7894,10 @@ def _static_sqrt( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sqrt. This method simply - wraps the function, and so the docstring for ivy.sqrt also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.sqrt. This method simply wraps the + function, and so the docstring for ivy.sqrt also applies to this method with + minimal changes. Parameters ---------- @@ -7842,9 +7957,10 @@ def sqrt( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sqrt. This method - simply wraps the function, and so the docstring for ivy.sqrt also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.sqrt. This method simply wraps the + function, and so the docstring for ivy.sqrt also applies to this method with + minimal changes. Parameters ---------- @@ -7907,9 +8023,10 @@ def _static_subtract( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.subtract. This method - simply wraps the function, and so the docstring for ivy.subtract also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.subtract. This method simply wraps + the function, and so the docstring for ivy.subtract also applies to this method + with minimal changes. Parameters ---------- @@ -7986,9 +8103,10 @@ def subtract( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.subtract. This method - simply wraps the function, and so the docstring for ivy.subtract also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.subtract. This method simply wraps + the function, and so the docstring for ivy.subtract also applies to this method + with minimal changes. Parameters ---------- @@ -8063,9 +8181,10 @@ def _static_tan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.tan. This method simply - wraps the function, and so the docstring for ivy.tan also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.tan. This method simply wraps the + function, and so the docstring for ivy.tan also applies to this method with + minimal changes. Parameters ---------- @@ -8123,9 +8242,10 @@ def tan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.tan. This method simply - wraps the function, and so the docstring for ivy.tan also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.tan. This method simply wraps the + function, and so the docstring for ivy.tan also applies to this method with + minimal changes. Parameters ---------- @@ -8185,9 +8305,10 @@ def _static_tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.tanh. This method simply - wraps the function, and so the docstring for ivy.tanh also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.tanh. This method simply wraps the + function, and so the docstring for ivy.tanh also applies to this method with + minimal changes. Parameters ---------- @@ -8250,9 +8371,10 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.tanh. This method - simply wraps the function, and so the docstring for ivy.tanh also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.tanh. This method simply wraps the + function, and so the docstring for ivy.tanh also applies to this method with + minimal changes. Parameters ---------- @@ -8316,9 +8438,10 @@ def _static_trunc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.trunc. This method simply - wraps the function, and so the docstring for ivy.trunc also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.trunc. This method simply wraps the + function, and so the docstring for ivy.trunc also applies to this method with + minimal changes. Parameters ---------- @@ -8377,9 +8500,10 @@ def trunc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.trunc. This method - simply wraps the function, and so the docstring for ivy.trunc also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.trunc. This method simply wraps the + function, and so the docstring for ivy.trunc also applies to this method with + minimal changes. Parameters ---------- @@ -8437,9 +8561,10 @@ def _static_erf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.erf. This method simply - wraps the function, and so the docstring for ivy.erf also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.erf. This method simply wraps the + function, and so the docstring for ivy.erf also applies to this method with + minimal changes. Parameters ---------- @@ -8495,9 +8620,10 @@ def erf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.erf. This method simply - wraps thefunction, and so the docstring for ivy.erf also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.erf. This method simply wraps + thefunction, and so the docstring for ivy.erf also applies to this method with + minimal changes. Parameters ---------- @@ -8556,9 +8682,10 @@ def _static_minimum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.minimum. This method - simply wraps the function, and so the docstring for ivy.minimum also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.minimum. This method simply wraps the + function, and so the docstring for ivy.minimum also applies to this method with + minimal changes. Parameters ---------- @@ -8628,9 +8755,10 @@ def minimum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.minimum. This method - simply wraps the function, and so the docstring for ivy.minimum also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.minimum. This method simply wraps + the function, and so the docstring for ivy.minimum also applies to this method + with minimal changes. Parameters ---------- @@ -8700,9 +8828,10 @@ def _static_maximum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.maximum. This method - simply wraps the function, and so the docstring for ivy.maximum also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.maximum. This method simply wraps the + function, and so the docstring for ivy.maximum also applies to this method with + minimal changes. Parameters ---------- @@ -8777,9 +8906,10 @@ def maximum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.maximum. This method - simply wraps the function, and so the docstring for ivy.maximum also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.maximum. This method simply wraps + the function, and so the docstring for ivy.maximum also applies to this method + with minimal changes. Parameters ---------- @@ -8852,9 +8982,10 @@ def _static_reciprocal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.reciprocal. This method - simply wraps the function, and so the docstring for ivy.reciprocal also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.reciprocal. This method simply wraps + the function, and so the docstring for ivy.reciprocal also applies to this + method with minimal changes. Parameters ---------- @@ -8909,9 +9040,10 @@ def reciprocal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.reciprocal. This method - simply wraps the function, and so the docstring for ivy.reciprocal also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.reciprocal. This method simply + wraps the function, and so the docstring for ivy.reciprocal also applies to this + method with minimal changes. Parameters ---------- @@ -8967,9 +9099,10 @@ def _static_deg2rad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.deg2rad. This method - simply wraps the function, and so the docstring for ivy.deg2rad also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.deg2rad. This method simply wraps the + function, and so the docstring for ivy.deg2rad also applies to this method with + minimal changes. Parameters ---------- @@ -9025,9 +9158,10 @@ def deg2rad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.deg2rad. This method - simply wraps the function, and so the docstring for ivy.deg2rad also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.deg2rad. This method simply wraps + the function, and so the docstring for ivy.deg2rad also applies to this method + with minimal changes. Parameters ---------- @@ -9086,9 +9220,10 @@ def _static_rad2deg( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.rad2deg. This method - simply wraps the function, and so the docstring for ivy.rad2deg also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.rad2deg. This method simply wraps the + function, and so the docstring for ivy.rad2deg also applies to this method with + minimal changes. Parameters ---------- @@ -9144,9 +9279,10 @@ def rad2deg( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.rad2deg. This method - simply wraps the function, and so the docstring for ivy.rad2deg also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.rad2deg. This method simply wraps + the function, and so the docstring for ivy.rad2deg also applies to this method + with minimal changes. Parameters ---------- @@ -9206,9 +9342,10 @@ def _static_trunc_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.trunc_divide. This method - simply wraps the function, and so the docstring for ivy.trunc_divide - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.trunc_divide. This method simply + wraps the function, and so the docstring for ivy.trunc_divide also applies to + this method with minimal changes. Parameters ---------- @@ -9275,9 +9412,10 @@ def trunc_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.trunc_divide. This - method simply wraps the function, and so the docstring for - ivy.trunc_divide also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.trunc_divide. This method simply + wraps the function, and so the docstring for ivy.trunc_divide also applies to + this method with minimal changes. Parameters ---------- @@ -9344,9 +9482,10 @@ def _static_isreal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.isreal. This method - simply wraps the function, and so the docstring for ivy.isreal also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.isreal. This method simply wraps the + function, and so the docstring for ivy.isreal also applies to this method with + minimal changes. Parameters ---------- @@ -9404,9 +9543,10 @@ def isreal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.isreal. This method - simply wraps the function, and so the docstring for ivy.isreal also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.isreal. This method simply wraps + the function, and so the docstring for ivy.isreal also applies to this method + with minimal changes. Parameters ---------- @@ -9468,9 +9608,10 @@ def _static_trapz( axis: Union[int, ivy.Container] = -1, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.trapz. This method simply - wraps the function, and so the docstring for ivy.trapz also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.trapz. This method simply wraps the + function, and so the docstring for ivy.trapz also applies to this method with + minimal changes. Parameters ---------- @@ -9525,9 +9666,10 @@ def trapz( axis: Union[int, ivy.Container] = -1, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.trapz. This method - simply wraps the function, and so the docstring for ivy.trapz also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.trapz. This method simply wraps the + function, and so the docstring for ivy.trapz also applies to this method with + minimal changes. Parameters ---------- @@ -9574,9 +9716,10 @@ def _static_lcm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.lcm. This method simply - wraps the function, and so the docstring for ivy.lcm also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.lcm. This method simply wraps the + function, and so the docstring for ivy.lcm also applies to this method with + minimal changes. Parameters ---------- @@ -9626,9 +9769,10 @@ def lcm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.lcm. This method simply - wraps the function, and so the docstring for ivy.lcm also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.lcm. This method simply wraps the + function, and so the docstring for ivy.lcm also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/activations.py b/ivy/data_classes/container/experimental/activations.py index e42c7d270d00c..1d1cb87018641 100644 --- a/ivy/data_classes/container/experimental/activations.py +++ b/ivy/data_classes/container/experimental/activations.py @@ -16,9 +16,10 @@ def static_logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.logit. This method simply - wraps the function, and so the docstring for ivy.logit also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.logit. This method simply wraps the + function, and so the docstring for ivy.logit also applies to this method with + minimal changes. Parameters ---------- @@ -77,9 +78,10 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.logit. This method - simply wraps the function, and so the docstring for ivy.logit also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.logit. This method simply wraps the + function, and so the docstring for ivy.logit also applies to this method with + minimal changes. Parameters ---------- @@ -136,9 +138,10 @@ def static_thresholded_relu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.thresholded_relu. This - method simply wraps the function, and so the docstring for - ivy.thresholded_relu also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.thresholded_relu. This method simply + wraps the function, and so the docstring for ivy.thresholded_relu also applies + to this method with minimal changes. Parameters ---------- @@ -199,9 +202,10 @@ def thresholded_relu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.thresholded_relu. This - method simply wraps the function, and so the docstring for - ivy.thresholded_relu also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.thresholded_relu. This method + simply wraps the function, and so the docstring for ivy.thresholded_relu also + applies to this method with minimal changes. Parameters ---------- @@ -328,9 +332,10 @@ def static_relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.relu6. This method simply - wraps the function, and so the docstring for ivy.relu6 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.relu6. This method simply wraps the + function, and so the docstring for ivy.relu6 also applies to this method with + minimal changes. Parameters ---------- @@ -393,9 +398,10 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.relu6. This method - simply wraps the function, and so the docstring for ivy.relu6 also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.relu6. This method simply wraps the + function, and so the docstring for ivy.relu6 also applies to this method with + minimal changes. Parameters ---------- @@ -457,9 +463,10 @@ def static_logsigmoid( map_sequences: Union[bool, ivy.Container] = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Container: - """ivy.Container static method variant of ivy.logsigmoid. This method - simply wraps the function, and so the docstring for ivy.logsigmoid also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.logsigmoid. This method simply wraps + the function, and so the docstring for ivy.logsigmoid also applies to this + method with minimal changes. Parameters ---------- @@ -526,7 +533,8 @@ def logsigmoid( map_sequences: Union[bool, ivy.Container] = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Container: - """Apply element-wise Log-sigmoid of x i.e. log(1 / (1 + exp(-x)). + """ + Apply element-wise Log-sigmoid of x i.e. log(1 / (1 + exp(-x)). Parameters ---------- @@ -571,9 +579,10 @@ def static_selu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.selu. This method simply - wraps the function, and so the docstring for ivy.selu also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.selu. This method simply wraps the + function, and so the docstring for ivy.selu also applies to this method with + minimal changes. Parameters ---------- @@ -630,9 +639,10 @@ def selu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.selu. This method - simply wraps the function, and so the docstring for ivy.selu also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.selu. This method simply wraps the + function, and so the docstring for ivy.selu also applies to this method with + minimal changes. Parameters ---------- @@ -689,9 +699,10 @@ def _static_silu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.silu. This method simply - wraps the function, and so the docstring for ivy.silu also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.silu. This method simply wraps the + function, and so the docstring for ivy.silu also applies to this method with + minimal changes. Parameters ---------- @@ -748,9 +759,10 @@ def silu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.silu. This method - simply wraps the function, and so the docstring for ivy.silu also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.silu. This method simply wraps the + function, and so the docstring for ivy.silu also applies to this method with + minimal changes. Parameters ---------- @@ -808,9 +820,10 @@ def _static_elu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.elu. This method simply - wraps the function, and so the docstring for ivy.elu also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.elu. This method simply wraps the + function, and so the docstring for ivy.elu also applies to this method with + minimal changes. Parameters ---------- @@ -870,9 +883,10 @@ def elu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.elu. This method simply - wraps the function, and so the docstring for ivy.elu also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.elu. This method simply wraps the + function, and so the docstring for ivy.elu also applies to this method with + minimal changes. Parameters ---------- @@ -933,9 +947,10 @@ def _static_hardtanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.hardtanh.This method - simply wrap the function,the docstring for ivy.hardtanh also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.hardtanh.This method simply wrap the + function,the docstring for ivy.hardtanh also applies to this method with minimal + changes. Parameters ---------- @@ -999,9 +1014,10 @@ def hardtanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.hardtanh.This method - simply wraps the function, so the docstring for ivy.elu also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.hardtanh.This method simply wraps + the function, so the docstring for ivy.elu also applies to this method with + minimal changes. Parameters ---------- @@ -1063,9 +1079,10 @@ def _static_tanhshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.tanhshrink. This method - simply wraps the function, and so the docstring for ivy.tanhshrink also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.tanhshrink. This method simply wraps + the function, and so the docstring for ivy.tanhshrink also applies to this + method with minimal changes. Parameters ---------- @@ -1122,9 +1139,10 @@ def tanhshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.tanhshrink. This method - simply wraps the function, and so the docstring for ivy.tanhshrink also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.tanhshrink. This method simply + wraps the function, and so the docstring for ivy.tanhshrink also applies to this + method with minimal changes. Parameters ---------- @@ -1183,9 +1201,10 @@ def _static_threshold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.threshold. This method - simply wraps the function, and so the docstring for ivy.threshold also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.threshold. This method simply wraps + the function, and so the docstring for ivy.threshold also applies to this method + with minimal changes. Parameters ---------- @@ -1248,9 +1267,10 @@ def threshold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.threshold. This method - simply wraps the function, and so the docstring for ivy.threshold also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.threshold. This method simply wraps + the function, and so the docstring for ivy.threshold also applies to this method + with minimal changes. Parameters ---------- @@ -1312,9 +1332,10 @@ def _static_softshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.softshrink. This method - simply wraps the function, and so the docstring for ivy.softshrink also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.softshrink. This method simply wraps + the function, and so the docstring for ivy.softshrink also applies to this + method with minimal changes. Parameters ---------- @@ -1372,7 +1393,8 @@ def softshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Apply the soft shrinkage function element-wise. + """ + Apply the soft shrinkage function element-wise. Parameters ---------- @@ -1432,9 +1454,10 @@ def _static_celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.celu. This method simply - wraps the function, and so the docstring for ivy.celu also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.celu. This method simply wraps the + function, and so the docstring for ivy.celu also applies to this method with + minimal changes. Parameters ---------- @@ -1499,9 +1522,10 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.leaky_relu. This method - simply wraps the function, and so the docstring for ivy.leaky_relu also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.leaky_relu. This method simply + wraps the function, and so the docstring for ivy.leaky_relu also applies to this + method with minimal changes. Parameters ---------- @@ -1567,9 +1591,10 @@ def _static_scaled_tanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.scaled_tanh. This method - simply wraps the function, and so the docstring for ivy.scaled_tanh - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.scaled_tanh. This method simply wraps + the function, and so the docstring for ivy.scaled_tanh also applies to this + method with minimal changes. Parameters ---------- @@ -1653,9 +1678,10 @@ def scaled_tanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.scaled_tanh. This - method simplywraps the function, and so the docstring for - ivy.scaled_tanh also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.scaled_tanh. This method + simplywraps the function, and so the docstring for ivy.scaled_tanh also applies + to this method with minimal changes. Parameters ---------- @@ -1735,9 +1761,10 @@ def _static_hardshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.hardshrink. This method - simply wraps the function, and so the docstring for ivy.hardshrink also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.hardshrink. This method simply wraps + the function, and so the docstring for ivy.hardshrink also applies to this + method with minimal changes. Parameters ---------- @@ -1792,7 +1819,8 @@ def hardshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Apply the hard shrinkage function element-wise. + """ + Apply the hard shrinkage function element-wise. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/creation.py b/ivy/data_classes/container/experimental/creation.py index e563d358474c2..fc861420bc843 100644 --- a/ivy/data_classes/container/experimental/creation.py +++ b/ivy/data_classes/container/experimental/creation.py @@ -19,9 +19,10 @@ def static_hann_window( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.hann_window. This method - simply wraps the function, and so the docstring for ivy.hann_window - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.hann_window. This method simply wraps + the function, and so the docstring for ivy.hann_window also applies to this + method with minimal changes. Parameters ---------- @@ -70,9 +71,10 @@ def hann_window( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.hann_window. This - method simply wraps the function, and so the docstring for - ivy.hann_window also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.hann_window. This method simply + wraps the function, and so the docstring for ivy.hann_window also applies to + this method with minimal changes. Parameters ---------- @@ -117,9 +119,10 @@ def static_kaiser_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.kaiser_window. This - method simply wraps the function, and so the docstring for - ivy.kaiser_window also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.kaiser_window. This method simply + wraps the function, and so the docstring for ivy.kaiser_window also applies to + this method with minimal changes. Parameters ---------- @@ -174,9 +177,10 @@ def kaiser_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.kaiser_window. This - method simply wraps the function, and so the docstring for - ivy.kaiser_window also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.kaiser_window. This method simply + wraps the function, and so the docstring for ivy.kaiser_window also applies to + this method with minimal changes. Parameters ---------- @@ -231,10 +235,11 @@ def static_kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of - ivy.kaiser_bessel_derived_window. This method simply wraps the - function, and so the docstring for ivy.kaiser_bessel_derived_window - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.kaiser_bessel_derived_window. This + method simply wraps the function, and so the docstring for + ivy.kaiser_bessel_derived_window also applies to this method with minimal + changes. Parameters ---------- @@ -289,10 +294,11 @@ def kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of - ivy.kaiser_bessel_derived_window. This method simply wraps the - function, and so the docstring for ivy.kaiser_bessel_derived_window - also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.kaiser_bessel_derived_window. This + method simply wraps the function, and so the docstring for + ivy.kaiser_bessel_derived_window also applies to this method with minimal + changes. Parameters ---------- @@ -349,9 +355,10 @@ def static_hamming_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.hamming_window. This - method simply wraps the function, and so the docstring for - ivy.hamming_window also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.hamming_window. This method simply + wraps the function, and so the docstring for ivy.hamming_window also applies to + this method with minimal changes. Parameters ---------- @@ -410,9 +417,10 @@ def hamming_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.hamming_window. This - method simply wraps the function, and so the docstring for - ivy.hamming_window also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.hamming_window. This method simply + wraps the function, and so the docstring for ivy.hamming_window also applies to + this method with minimal changes. Parameters ---------- @@ -460,9 +468,10 @@ def static_vorbis_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.vorbis_window. This - method simply wraps the function, and so the docstring for - ivy.vorbis_window also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.vorbis_window. This method simply + wraps the function, and so the docstring for ivy.vorbis_window also applies to + this method with minimal changes. Parameters ---------- @@ -511,9 +520,10 @@ def vorbis_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.vorbis_window. This - method simply wraps the function, and so the docstring for - ivy.vorbis_window also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.vorbis_window. This method simply + wraps the function, and so the docstring for ivy.vorbis_window also applies to + this method with minimal changes. Parameters ---------- @@ -613,9 +623,10 @@ def static_eye_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.eye_like. This method - simply wraps the function, and so the docstring for ivy.eye_like also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.eye_like. This method simply wraps + the function, and so the docstring for ivy.eye_like also applies to this method + with minimal changes. Parameters ---------- @@ -689,9 +700,10 @@ def eye_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.eye_like. This method - simply wraps the function, and so the docstring for ivy.eye_like also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.eye_like. This method simply wraps + the function, and so the docstring for ivy.eye_like also applies to this method + with minimal changes. Parameters ---------- @@ -763,10 +775,10 @@ def static_unsorted_segment_min( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.unsorted_segment_min. - This method simply wraps the function, and so the docstring for - ivy.unsorted_segment_min also applies to this method with minimal - changes. + r""" + ivy.Container instance method variant of ivy.unsorted_segment_min. This method + simply wraps the function, and so the docstring for ivy.unsorted_segment_min + also applies to this method with minimal changes. Note ---- @@ -818,10 +830,10 @@ def unsorted_segment_min( segment_ids: ivy.Container, num_segments: Union[int, ivy.Container], ): - r"""ivy.Container instance method variant of ivy.unsorted_segment_min. - This method simply wraps the function, and so the docstring for - ivy.unsorted_segment_min also applies to this method with minimal - changes. + r""" + ivy.Container instance method variant of ivy.unsorted_segment_min. This method + simply wraps the function, and so the docstring for ivy.unsorted_segment_min + also applies to this method with minimal changes. Note ---- @@ -863,10 +875,10 @@ def static_unsorted_segment_sum( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.unsorted_segment_sum. - This method simply wraps the function, and so the docstring for - ivy.unsorted_segment_sum also applies to this method with minimal - changes. + r""" + ivy.Container instance method variant of ivy.unsorted_segment_sum. This method + simply wraps the function, and so the docstring for ivy.unsorted_segment_sum + also applies to this method with minimal changes. Parameters ---------- @@ -913,10 +925,10 @@ def unsorted_segment_sum( segment_ids: ivy.Container, num_segments: Union[int, ivy.Container], ): - r"""ivy.Container instance method variant of ivy.unsorted_segment_sum. - This method simply wraps the function, and so the docstring for - ivy.unsorted_segment_sum also applies to this method with minimal - changes. + r""" + ivy.Container instance method variant of ivy.unsorted_segment_sum. This method + simply wraps the function, and so the docstring for ivy.unsorted_segment_sum + also applies to this method with minimal changes. Parameters ---------- @@ -954,9 +966,10 @@ def static_blackman_window( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.blackman_window. This - method simply wraps the function, and so the docstring for - ivy.blackman_window also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.blackman_window. This method simply + wraps the function, and so the docstring for ivy.blackman_window also applies to + this method with minimal changes. Parameters ---------- @@ -1005,9 +1018,10 @@ def blackman_window( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.blackman_window. This - method simply wraps the function, and so the docstring for - ivy.blackman_window also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.blackman_window. This method simply + wraps the function, and so the docstring for ivy.blackman_window also applies to + this method with minimal changes. Parameters ---------- @@ -1100,9 +1114,10 @@ def static_mel_weight_matrix( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.mel_weight_matrix. This - method simply wraps the function, and so the docstring for - ivy.mel_weight_matrix also applies to this method with minimal changes. + r""" + ivy.Container instance method variant of ivy.mel_weight_matrix. This method + simply wraps the function, and so the docstring for ivy.mel_weight_matrix also + applies to this method with minimal changes. Parameters ---------- @@ -1154,9 +1169,10 @@ def mel_weight_matrix( lower_edge_hertz: Optional[float] = 0.0, upper_edge_hertz: Optional[float] = 3000.0, ): - r"""ivy.Container instance method variant of ivy.mel_weight_matrix. This - method simply wraps the function, and so the docstring for - ivy.mel_weight_matrix also applies to this method with minimal changes. + r""" + ivy.Container instance method variant of ivy.mel_weight_matrix. This method + simply wraps the function, and so the docstring for ivy.mel_weight_matrix also + applies to this method with minimal changes. Parameters ---------- @@ -1195,8 +1211,8 @@ def static_unsorted_segment_mean( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """Compute the mean of values in the input data based on segment - identifiers. + """ + Compute the mean of values in the input data based on segment identifiers. Parameters ---------- @@ -1241,8 +1257,9 @@ def unsorted_segment_mean( segment_ids: Union[ivy.Array, ivy.Container], num_segments: Union[int, ivy.Container], ) -> ivy.Container: - """Compute the mean of values in the input array or container based on - segment identifiers. + """ + Compute the mean of values in the input array or container based on segment + identifiers. Parameters ---------- @@ -1301,9 +1318,10 @@ def static_polyval( prune_unapplied: bool = False, map_sequences: bool = False, ) -> ivy.Container: - r"""ivy.Container static method variant of ivy.polyval. This method - simply wraps the function, and so the docstring for ivy.polyval also - applies to this method with minimal changes. + r""" + ivy.Container static method variant of ivy.polyval. This method simply wraps the + function, and so the docstring for ivy.polyval also applies to this method with + minimal changes. Evaluate and return a polynomial at specific given values. @@ -1347,9 +1365,10 @@ def polyval( coeffs: ivy.Container, x: ivy.Container, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.polyval. This method - simply wraps the function, and so the docstring for ivy.polyval also - applies to this method with minimal changes. + r""" + ivy.Container instance method variant of ivy.polyval. This method simply wraps + the function, and so the docstring for ivy.polyval also applies to this method + with minimal changes. Evaluate and return a polynomial at specific given values. diff --git a/ivy/data_classes/container/experimental/elementwise.py b/ivy/data_classes/container/experimental/elementwise.py index 939c32874fc50..45cf7674adbb0 100644 --- a/ivy/data_classes/container/experimental/elementwise.py +++ b/ivy/data_classes/container/experimental/elementwise.py @@ -21,9 +21,10 @@ def static_amax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.amax. This method simply - wraps the function, and so the docstring for ivy.amax also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.amax. This method simply wraps the + function, and so the docstring for ivy.amax also applies to this method with + minimal changes. Parameters ---------- @@ -116,9 +117,10 @@ def amax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.amax. This method - simply wraps the function, and so the docstring for ivy.amax also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.amax. This method simply wraps the + function, and so the docstring for ivy.amax also applies to this method with + minimal changes. Parameters ---------- @@ -211,9 +213,10 @@ def static_amin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.amin. This method simply - wraps the function, and so the docstring for ivy.amin also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.amin. This method simply wraps the + function, and so the docstring for ivy.amin also applies to this method with + minimal changes. Parameters ---------- @@ -305,9 +308,10 @@ def amin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.amin. This method - simply wraps the function, and so the docstring for ivy.amin also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.amin. This method simply wraps the + function, and so the docstring for ivy.amin also applies to this method with + minimal changes. Parameters ---------- @@ -397,9 +401,10 @@ def static_sinc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sinc. This method simply - wraps the function, and so the docstring for ivy.sinc also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.sinc. This method simply wraps the + function, and so the docstring for ivy.sinc also applies to this method with + minimal changes. Parameters ---------- @@ -458,9 +463,10 @@ def sinc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sinc. This method - simply wraps the function, and so the docstring for ivy.sinc also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.sinc. This method simply wraps the + function, and so the docstring for ivy.sinc also applies to this method with + minimal changes. Parameters ---------- @@ -521,9 +527,10 @@ def static_fmod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fmod. This method simply - wraps the function, and so the docstring for ivy.fmod also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.fmod. This method simply wraps the + function, and so the docstring for ivy.fmod also applies to this method with + minimal changes. Parameters ---------- @@ -569,9 +576,10 @@ def fmod( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fmod. This method - simply wraps the function, and so the docstring for ivy.fmod also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.fmod. This method simply wraps the + function, and so the docstring for ivy.fmod also applies to this method with + minimal changes. Parameters ---------- @@ -613,9 +621,10 @@ def static_fmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fmax. This method simply - wraps the function, and so the docstring for ivy.fmax also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.fmax. This method simply wraps the + function, and so the docstring for ivy.fmax also applies to this method with + minimal changes. Parameters ---------- @@ -661,9 +670,10 @@ def fmax( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fmax. This method - simply wraps the function, and so the docstring for ivy.fmax also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.fmax. This method simply wraps the + function, and so the docstring for ivy.fmax also applies to this method with + minimal changes. Parameters ---------- @@ -705,9 +715,10 @@ def static_float_power( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.float_power. This method - simply wraps the function, and so the docstring for ivy.float_power - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.float_power. This method simply wraps + the function, and so the docstring for ivy.float_power also applies to this + method with minimal changes. Parameters ---------- @@ -753,9 +764,10 @@ def float_power( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.float_power. This - method simply wraps the function, and so the docstring for - ivy.float_power also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.float_power. This method simply + wraps the function, and so the docstring for ivy.float_power also applies to + this method with minimal changes. Parameters ---------- @@ -797,9 +809,10 @@ def static_copysign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.copysign. This method - simply wraps the function, and so the docstring for ivy.copysign also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.copysign. This method simply wraps + the function, and so the docstring for ivy.copysign also applies to this method + with minimal changes. Parameters ---------- @@ -850,9 +863,10 @@ def copysign( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.copysign. This method - simply wraps the function, and so the docstring for ivy.copysign also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.copysign. This method simply wraps + the function, and so the docstring for ivy.copysign also applies to this method + with minimal changes. Parameters ---------- @@ -901,9 +915,10 @@ def static_count_nonzero( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.count_nonzero. This - method simply wraps the function, and so the docstring for - ivy.count_nonzero also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.count_nonzero. This method simply + wraps the function, and so the docstring for ivy.count_nonzero also applies to + this method with minimal changes. Parameters ---------- @@ -990,9 +1005,10 @@ def count_nonzero( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.count_nonzero. This - method simply wraps the function, and so the docstring for - ivy.count_nonzero also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.count_nonzero. This method simply + wraps the function, and so the docstring for ivy.count_nonzero also applies to + this method with minimal changes. Parameters ---------- @@ -1080,9 +1096,10 @@ def static_nansum( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.nansum. This method - simply wraps the function, and so the docstring for ivy.nansum also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.nansum. This method simply wraps the + function, and so the docstring for ivy.nansum also applies to this method with + minimal changes. Parameters ---------- @@ -1150,9 +1167,10 @@ def nansum( keepdims: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.nansum. This method - simply wraps the function, and so the docstring for ivy.nansum also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.nansum. This method simply wraps + the function, and so the docstring for ivy.nansum also applies to this method + with minimal changes. Parameters ---------- @@ -1212,9 +1230,10 @@ def static_isclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.isclose. This method - simply wraps the function, and so the docstring for ivy.isclose also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.isclose. This method simply wraps the + function, and so the docstring for ivy.isclose also applies to this method with + minimal changes. Parameters ---------- @@ -1310,9 +1329,10 @@ def isclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.isclose. This method - simply wraps the function, and so the docstring for ivy.isclose also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.isclose. This method simply wraps + the function, and so the docstring for ivy.isclose also applies to this method + with minimal changes. Parameters ---------- @@ -1404,9 +1424,10 @@ def static_signbit( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.signbit. This method - simply wraps the function, and so the docstring for ivy.signbit also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.signbit. This method simply wraps the + function, and so the docstring for ivy.signbit also applies to this method with + minimal changes. Parameters ---------- @@ -1446,9 +1467,10 @@ def signbit( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.signbit. This method - simply wraps the function, and so the docstring for ivy.signbit also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.signbit. This method simply wraps + the function, and so the docstring for ivy.signbit also applies to this method + with minimal changes. Parameters ---------- @@ -1486,9 +1508,10 @@ def static_hypot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.hypot. This method simply - wraps the function, and so the docstring for ivy.hypot also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.hypot. This method simply wraps the + function, and so the docstring for ivy.hypot also applies to this method with + minimal changes. Parameters ---------- @@ -1550,9 +1573,10 @@ def hypot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.hypot. This method - simply wraps the function, and so the docstring for ivy.hypot also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.hypot. This method simply wraps the + function, and so the docstring for ivy.hypot also applies to this method with + minimal changes. Parameters ---------- @@ -1617,9 +1641,10 @@ def static_allclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.allclose. This method - simply wraps the function, and so the docstring for ivy.allclose also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.allclose. This method simply wraps + the function, and so the docstring for ivy.allclose also applies to this method + with minimal changes. Parameters ---------- @@ -1707,9 +1732,10 @@ def allclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.allclose. This method - simply wraps the function, and so the docstring for ivy.allclose also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.allclose. This method simply wraps + the function, and so the docstring for ivy.allclose also applies to this method + with minimal changes. Parameters ---------- @@ -1799,9 +1825,10 @@ def static_diff( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.diff. This method simply - wraps the function, and so the docstring for ivy.diff also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.diff. This method simply wraps the + function, and so the docstring for ivy.diff also applies to this method with + minimal changes. Parameters ---------- @@ -1875,9 +1902,10 @@ def diff( ] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.diff. This method - simply wraps the function, and so the docstring for ivy.diff also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.diff. This method simply wraps the + function, and so the docstring for ivy.diff also applies to this method with + minimal changes. Parameters ---------- @@ -1927,9 +1955,10 @@ def static_fix( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fix. This method simply - wraps the function, and so the docstring for ivy.fix also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.fix. This method simply wraps the + function, and so the docstring for ivy.fix also applies to this method with + minimal changes. Parameters ---------- @@ -1970,9 +1999,10 @@ def fix( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fix. This method simply - wraps the function, and so the docstring for ivy.fix also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.fix. This method simply wraps the + function, and so the docstring for ivy.fix also applies to this method with + minimal changes. Parameters ---------- @@ -2011,9 +2041,10 @@ def static_nextafter( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.nextafter. This method - simply wraps the function, and so the docstring for ivy.nextafter also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.nextafter. This method simply wraps + the function, and so the docstring for ivy.nextafter also applies to this method + with minimal changes. Parameters ---------- @@ -2076,9 +2107,10 @@ def nextafter( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.nextafter. This method - simply wraps the function, and so the docstring for ivy.nextafter also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.nextafter. This method simply wraps + the function, and so the docstring for ivy.nextafter also applies to this method + with minimal changes. Parameters ---------- @@ -2141,9 +2173,10 @@ def static_zeta( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.zeta. This method simply - wraps the function, and so the docstring for ivy.zeta also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.zeta. This method simply wraps the + function, and so the docstring for ivy.zeta also applies to this method with + minimal changes. Parameters ---------- @@ -2205,9 +2238,10 @@ def zeta( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.zeta. This method - simply wraps the function, and so the docstring for ivy.zeta also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.zeta. This method simply wraps the + function, and so the docstring for ivy.zeta also applies to this method with + minimal changes. Parameters ---------- @@ -2290,7 +2324,8 @@ def gradient( edge_order: Union[int, ivy.Container] = 1, axis: Optional[Union[int, list, tuple, ivy.Container]] = None, ) -> ivy.Container: - """Calculate gradient of x with respect to (w.r.t.) spacing. + """ + Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -2430,9 +2465,10 @@ def static_xlogy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.xlogy. This method simply - wraps the function, and so the docstring for ivy.xlogy also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.xlogy. This method simply wraps the + function, and so the docstring for ivy.xlogy also applies to this method with + minimal changes. Parameters ---------- @@ -2495,9 +2531,10 @@ def xlogy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.xlogy. This method - simply wraps the function, and so the docstring for ivy.xlogy also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.xlogy. This method simply wraps the + function, and so the docstring for ivy.xlogy also applies to this method with + minimal changes. Parameters ---------- @@ -2560,8 +2597,9 @@ def static_binarizer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Map the values of the input tensor to either 0 or 1, element-wise, - based on the outcome of a comparison against a threshold value. + """ + Map the values of the input tensor to either 0 or 1, element-wise, based on the + outcome of a comparison against a threshold value. Parameters ---------- @@ -2611,8 +2649,9 @@ def binarizer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Map the values of the input tensor to either 0 or 1, element-wise, - based on the outcome of a comparison against a threshold value. + """ + Map the values of the input tensor to either 0 or 1, element-wise, based on the + outcome of a comparison against a threshold value. Parameters ---------- @@ -2660,9 +2699,10 @@ def static_conj( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.conj. This method simply - wraps the function, and so the docstring for ivy.conj also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.conj. This method simply wraps the + function, and so the docstring for ivy.conj also applies to this method with + minimal changes. Parameters ---------- @@ -2722,9 +2762,10 @@ def conj( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.conj. This method - simply wraps the function, and so the docstring for ivy.conj also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.conj. This method simply wraps the + function, and so the docstring for ivy.conj also applies to this method with + minimal changes. Parameters ---------- @@ -2785,9 +2826,10 @@ def static_ldexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.ldexp. This method simply - wraps the function, and so the docstring for ivy.ldexp also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.ldexp. This method simply wraps the + function, and so the docstring for ivy.ldexp also applies to this method with + minimal changes. Parameters ---------- @@ -2844,9 +2886,10 @@ def ldexp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.ldexp. This method - simply wraps the function, and so the docstring for ivy.ldexp also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.ldexp. This method simply wraps the + function, and so the docstring for ivy.ldexp also applies to this method with + minimal changes. Parameters ---------- @@ -2888,9 +2931,10 @@ def static_lerp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.lerp. This method simply - wraps the function, and so the docstring for ivy.lerp also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.lerp. This method simply wraps the + function, and so the docstring for ivy.lerp also applies to this method with + minimal changes. Parameters ---------- @@ -2963,9 +3007,10 @@ def lerp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.lerp. This method - simply wraps the function, and so the docstring for ivy.lerp also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.lerp. This method simply wraps the + function, and so the docstring for ivy.lerp also applies to this method with + minimal changes. Parameters ---------- @@ -3008,9 +3053,10 @@ def static_frexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.frexp. This method simply - wraps the function, and so the docstring for ivy.frexp also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.frexp. This method simply wraps the + function, and so the docstring for ivy.frexp also applies to this method with + minimal changes. Parameters ---------- @@ -3061,9 +3107,10 @@ def frexp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.frexp. This method - simply wraps the function, and so the docstring for ivy.frexp also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.frexp. This method simply wraps the + function, and so the docstring for ivy.frexp also applies to this method with + minimal changes. Parameters ---------- @@ -3101,9 +3148,10 @@ def static_modf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.modf. This method simply - wraps the function, and so the docstring for ivy.modf also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.modf. This method simply wraps the + function, and so the docstring for ivy.modf also applies to this method with + minimal changes. Parameters ---------- @@ -3156,9 +3204,10 @@ def modf( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.modf. This method - simply wraps the function, and so the docstring for ivy.modf also - applies to this method with minimal changes. + r""" + ivy.Container instance method variant of ivy.modf. This method simply wraps the + function, and so the docstring for ivy.modf also applies to this method with + minimal changes. Parameters ---------- @@ -3197,9 +3246,10 @@ def static_digamma( map_sequences: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.digamma. This method - simply wraps the function, and so the docstring for ivy.digamma also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.digamma. This method simply wraps the + function, and so the docstring for ivy.digamma also applies to this method with + minimal changes. Note ---- @@ -3259,9 +3309,10 @@ def digamma( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.digamma. This method - simply wraps the function, and so the docstring for ivy.digamma also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.digamma. This method simply wraps + the function, and so the docstring for ivy.digamma also applies to this method + with minimal changes. Note ---- @@ -3321,9 +3372,10 @@ def static_sparsify_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sparsify_tensor. This - method simply wraps the function, and so the docstring for - ivy.sparsify_tensor also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.sparsify_tensor. This method simply + wraps the function, and so the docstring for ivy.sparsify_tensor also applies to + this method with minimal changes. Parameters ---------- @@ -3385,7 +3437,8 @@ def sparsify_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sparsify_tensor. + """ + ivy.Container instance method variant of ivy.sparsify_tensor. This method simply wraps the function, and so the docstring for ivy.sparsify_tensor also applies to this method with minimal @@ -3412,9 +3465,10 @@ def static_erfc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.erfc. This method simply - wraps the function, and so the docstring for ivy.erfc also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.erfc. This method simply wraps the + function, and so the docstring for ivy.erfc also applies to this method with + minimal changes. Parameters ---------- @@ -3464,9 +3518,10 @@ def erfc( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.erfc. This method - simply wraps the function, and so the docstring for ivy.erfc also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.erfc. This method simply wraps the + function, and so the docstring for ivy.erfc also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/general.py b/ivy/data_classes/container/experimental/general.py index e44bc1fc8e506..af380102a50ce 100644 --- a/ivy/data_classes/container/experimental/general.py +++ b/ivy/data_classes/container/experimental/general.py @@ -21,9 +21,10 @@ def _static_reduce( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.reduce. This method - simply wraps the function, and so the docstring for ivy.reduce also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.reduce. This method simply wraps the + function, and so the docstring for ivy.reduce also applies to this method with + minimal changes. Parameters ---------- @@ -94,9 +95,10 @@ def reduce( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.reduce. This method - simply wraps the function, and so the docstring for ivy.reduce also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.reduce. This method simply wraps + the function, and so the docstring for ivy.reduce also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/layers.py b/ivy/data_classes/container/experimental/layers.py index ebbb6ed120669..1d22b10c04f52 100644 --- a/ivy/data_classes/container/experimental/layers.py +++ b/ivy/data_classes/container/experimental/layers.py @@ -24,9 +24,10 @@ def static_max_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.max_pool1d. This method - simply wraps the function, and so the docstring for ivy.max_pool1d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.max_pool1d. This method simply wraps + the function, and so the docstring for ivy.max_pool1d also applies to this + method with minimal changes. Parameters ---------- @@ -100,9 +101,10 @@ def max_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of `ivy.max_pool1d`. This - method simply wraps the function, and so the docstring for - `ivy.max_pool1d` also applies to this method with minimal changes. + """ + ivy.Container instance method variant of `ivy.max_pool1d`. This method simply + wraps the function, and so the docstring for `ivy.max_pool1d` also applies to + this method with minimal changes. Parameters ---------- @@ -176,9 +178,10 @@ def static_max_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.max_pool2dd. This method - simply wraps the function, and so the docstring for ivy.max_pool2d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.max_pool2dd. This method simply wraps + the function, and so the docstring for ivy.max_pool2d also applies to this + method with minimal changes. Parameters ---------- @@ -250,9 +253,10 @@ def max_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of `ivy.max_pool2d`. This - method simply wraps the function, and so the docstring for - `ivy.max_pool2d` also applies to this method with minimal changes. + """ + ivy.Container instance method variant of `ivy.max_pool2d`. This method simply + wraps the function, and so the docstring for `ivy.max_pool2d` also applies to + this method with minimal changes. Parameters ---------- @@ -328,9 +332,10 @@ def static_max_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.max_pool3d. This method - simply wraps the function, and so the docstring for ivy.max_pool3d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.max_pool3d. This method simply wraps + the function, and so the docstring for ivy.max_pool3d also applies to this + method with minimal changes. Parameters ---------- @@ -405,9 +410,10 @@ def max_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.max_pool3d. This method - simply wraps the function, and so the docstring for ivy.max_pool3d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.max_pool3d. This method simply wraps + the function, and so the docstring for ivy.max_pool3d also applies to this + method with minimal changes. Parameters ---------- @@ -479,9 +485,10 @@ def static_avg_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.avg_pool1d. This method - simply wraps the function, and so the docstring for ivy.avg_pool1d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.avg_pool1d. This method simply wraps + the function, and so the docstring for ivy.avg_pool1d also applies to this + method with minimal changes. Parameters ---------- @@ -554,9 +561,10 @@ def avg_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of `ivy.avg_pool1d`. This - method simply wraps the function, and so the docstring for - `ivy.avg_pool1d` also applies to this method with minimal changes. + """ + ivy.Container instance method variant of `ivy.avg_pool1d`. This method simply + wraps the function, and so the docstring for `ivy.avg_pool1d` also applies to + this method with minimal changes. Parameters ---------- @@ -630,9 +638,10 @@ def static_avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.avg_pool2d. This method - simply wraps the function, and so the docstring for ivy.avg_pool2d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.avg_pool2d. This method simply wraps + the function, and so the docstring for ivy.avg_pool2d also applies to this + method with minimal changes. Parameters ---------- @@ -709,9 +718,10 @@ def avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of `ivy.avg_pool2d`. This - method simply wraps the function, and so the docstring for - `ivy.avg_pool2d` also applies to this method with minimal changes. + """ + ivy.Container instance method variant of `ivy.avg_pool2d`. This method simply + wraps the function, and so the docstring for `ivy.avg_pool2d` also applies to + this method with minimal changes. Parameters ---------- @@ -788,9 +798,10 @@ def static_avg_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.avg_pool3d. This method - simply wraps the function, and so the docstring for ivy.avg_pool3d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.avg_pool3d. This method simply wraps + the function, and so the docstring for ivy.avg_pool3d also applies to this + method with minimal changes. Parameters ---------- @@ -868,9 +879,10 @@ def avg_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.avg_pool3d. This method - simply wraps the function, and so the docstring for ivy.avg_pool3d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.avg_pool3d. This method simply wraps + the function, and so the docstring for ivy.avg_pool3d also applies to this + method with minimal changes. Parameters ---------- @@ -947,9 +959,10 @@ def static_dct( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.dct. This method simply - wraps the function, and so the docstring for ivy.dct also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.dct. This method simply wraps the + function, and so the docstring for ivy.dct also applies to this method with + minimal changes. Parameters ---------- @@ -1022,9 +1035,10 @@ def dct( norm: Optional[Union[Literal["ortho"], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.dct. This method simply - wraps the function, and so the docstring for ivy.dct also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.dct. This method simply wraps the + function, and so the docstring for ivy.dct also applies to this method with + minimal changes. Parameters ---------- @@ -1081,9 +1095,10 @@ def static_idct( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.idct. This method simply - wraps the function, and so the docstring for ivy.idct also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.idct. This method simply wraps the + function, and so the docstring for ivy.idct also applies to this method with + minimal changes. Parameters ---------- @@ -1158,9 +1173,10 @@ def idct( norm: Optional[Union[Literal["ortho"], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.idct. This method - simply wraps the function, and so the docstring for ivy.idct also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.idct. This method simply wraps the + function, and so the docstring for ivy.idct also applies to this method with + minimal changes. Parameters ---------- @@ -1216,9 +1232,10 @@ def _static_fft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fft. This method simply - wraps the function, and so the docstring for ivy.fft also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.fft. This method simply wraps the + function, and so the docstring for ivy.fft also applies to this method with + minimal changes. Parameters ---------- @@ -1287,9 +1304,10 @@ def fft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fft. This method simply - wraps the function, and so the docstring for ivy.fft also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.fft. This method simply wraps the + function, and so the docstring for ivy.fft also applies to this method with + minimal changes. Parameters ---------- @@ -1357,9 +1375,10 @@ def static_ifft( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ivy.Container static method variant of ivy.ifft. This method simply - wraps the function, and so the docstring for ivy.ifft also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.ifft. This method simply wraps the + function, and so the docstring for ivy.ifft also applies to this method with + minimal changes. Parameters ---------- @@ -1423,9 +1442,10 @@ def ifft( n: Optional[Union[int, Tuple[int], ivy.Container]] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ): - """ivy.Container instance method variant of ivy.ifft. This method - simply wraps the function, and so the docstring for ivy.ifft also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.ifft. This method simply wraps the + function, and so the docstring for ivy.ifft also applies to this method with + minimal changes. Parameters ---------- @@ -1646,7 +1666,8 @@ def static_interpolate( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Down/up samples the input to the given size. The algorithm used for + """ + Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -1734,7 +1755,8 @@ def interpolate( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Down/up samples the input to the given size. The algorithm used for + """ + Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -1803,10 +1825,10 @@ def static_adaptive_avg_pool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.adaptive_avg_pool1d. This - method simply wraps the function, and so the docstring for - ivy.adaptive_avg_pool1d also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.adaptive_avg_pool1d. This method + simply wraps the function, and so the docstring for ivy.adaptive_avg_pool1d also + applies to this method with minimal changes. Parameters ---------- @@ -1841,8 +1863,9 @@ def adaptive_avg_pool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """Apply a 1D adaptive average pooling over an input signal composed of - several input planes. + """ + Apply a 1D adaptive average pooling over an input signal composed of several + input planes. Parameters ---------- @@ -1876,10 +1899,10 @@ def static_adaptive_avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, data_format: str = "NHWC", ) -> ivy.Container: - """ivy.Container static method variant of ivy.adaptive_avg_pool2d. This - method simply wraps the function, and so the docstring for - ivy.adaptive_avg_pool2d also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.adaptive_avg_pool2d. This method + simply wraps the function, and so the docstring for ivy.adaptive_avg_pool2d also + applies to this method with minimal changes. Parameters ---------- @@ -1917,8 +1940,9 @@ def adaptive_avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, data_format: str = "NHWC", ) -> ivy.Container: - """Apply a 2D adaptive average pooling over an input signal composed of - several input planes. + """ + Apply a 2D adaptive average pooling over an input signal composed of several + input planes. Parameters ---------- @@ -1953,10 +1977,10 @@ def static_adaptive_max_pool2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.adaptive_max_pool2d. This - method simply wraps the function, and so the docstring for - ivy.adaptive_max_pool2d also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.adaptive_max_pool2d. This method + simply wraps the function, and so the docstring for ivy.adaptive_max_pool2d also + applies to this method with minimal changes. Parameters ---------- @@ -1991,8 +2015,9 @@ def adaptive_max_pool2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """Apply a 2D adaptive maximum pooling over an input signal composed of - several input planes. + """ + Apply a 2D adaptive maximum pooling over an input signal composed of several + input planes. Parameters ---------- @@ -2027,7 +2052,8 @@ def static_ifftn( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ivy.Container static method variant of ivy.ifftn. + """ + ivy.Container static method variant of ivy.ifftn. This method simply wraps the function, and so the docstring for ivy.ifftn also applies to this method with minimal changes. @@ -2085,7 +2111,8 @@ def ifftn( norm: Union[str, ivy.Container] = "backward", out: Optional[Union[ivy.Array, ivy.Container]] = None, ): - """ivy.Container static method variant of ivy.ifftn. + """ + ivy.Container static method variant of ivy.ifftn. This method simply wraps the function, and so the docstring for ivy.ifftn also applies to this method with minimal changes. @@ -2169,7 +2196,8 @@ def static_rfft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.rfft. + """ + ivy.Container static method variant of ivy.rfft. This method simply wraps the function, and so the docstring for ivy.rfft also applies to this method with minimal changes. @@ -2258,9 +2286,10 @@ def rfft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ): - """ivy.Container instance method variant of ivy.rfft. This method - simply wraps the function, and so the docstring for ivy.rfft also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.rfft. This method simply wraps the + function, and so the docstring for ivy.rfft also applies to this method with + minimal changes. Parameters ---------- @@ -2343,7 +2372,8 @@ def static_rfftn( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.rfftn. + """ + ivy.Container static method variant of ivy.rfftn. This method simply wraps the function, and so the docstring for ivy.rfftn also applies to this method with minimal changes. @@ -2407,7 +2437,8 @@ def rfftn( norm: Union[str, ivy.Container] = "backward", out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """Compute the n-dimensional discrete Fourier Transform for real input. + """ + Compute the n-dimensional discrete Fourier Transform for real input. Parameters ---------- @@ -2454,7 +2485,8 @@ def static_stft( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.stft. + """ + ivy.Container static method variant of ivy.stft. This method simply wraps the function, and so the docstring for ivy.stft also applies to this method with minimal changes. @@ -2518,7 +2550,8 @@ def stft( name: Optional[Union[str, ivy.Container]] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """Compute the Short-time Fourier Transform of signals. + """ + Compute the Short-time Fourier Transform of signals. Parameters ---------- @@ -2575,9 +2608,10 @@ def _static_sliding_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sliding_window. This - method simply wraps the function, and so the docstring for - ivy.sliding_window also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.sliding_window. This method simply + wraps the function, and so the docstring for ivy.sliding_window also applies to + this method with minimal changes. Parameters ---------- @@ -2656,9 +2690,10 @@ def sliding_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sliding_window. This - method simply wraps the function, and so the docstring for - ivy.sliding_window also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.sliding_window. This method simply + wraps the function, and so the docstring for ivy.sliding_window also applies to + this method with minimal changes. Parameters ---------- @@ -2734,7 +2769,8 @@ def static_max_unpool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.max_unpool1d. + """ + ivy.Container static method variant of ivy.max_unpool1d. Parameters ---------- @@ -2793,8 +2829,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Container: - """Compute a 1-D max unpooling given the 1-D pooled input x and its - indices. + """ + Compute a 1-D max unpooling given the 1-D pooled input x and its indices. Parameters ---------- @@ -2843,7 +2879,8 @@ def static_rnn( zero_output_for_mask: bool = False, return_all_outputs: bool = True, ) -> ivy.Container: - """ivy.Container static method variant of ivy.rnn. + """ + ivy.Container static method variant of ivy.rnn. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/linear_algebra.py b/ivy/data_classes/container/experimental/linear_algebra.py index 697d0ef749e52..b3fa46889d2d2 100644 --- a/ivy/data_classes/container/experimental/linear_algebra.py +++ b/ivy/data_classes/container/experimental/linear_algebra.py @@ -24,9 +24,10 @@ def static_eigh_tridiagonal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container]]: - """ivy.Container static method variant of ivy.eigh_tridiagonal. This - method simply wraps the function, and so the docstring for - ivy.eigh_tridiagonal also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.eigh_tridiagonal. This method simply + wraps the function, and so the docstring for ivy.eigh_tridiagonal also applies + to this method with minimal changes. Parameters ---------- @@ -117,9 +118,10 @@ def eigh_tridiagonal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container]]: - """ivy.Container instance method variant of ivy.eigh_tridiagonal. This - method simply wraps the function, and so the docstring for - ivy.eigh_tridiagonal also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.eigh_tridiagonal. This method + simply wraps the function, and so the docstring for ivy.eigh_tridiagonal also + applies to this method with minimal changes. Parameters ---------- @@ -234,9 +236,10 @@ def diagflat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.diagflat. This method - simply wraps the function, and so the docstring for ivy.diagflat also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.diagflat. This method simply wraps + the function, and so the docstring for ivy.diagflat also applies to this method + with minimal changes. Examples -------- @@ -274,9 +277,10 @@ def static_kron( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.kron. This method simply - wraps the function, and so the docstring for ivy.kron also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.kron. This method simply wraps the + function, and so the docstring for ivy.kron also applies to this method with + minimal changes. Parameters ---------- @@ -325,9 +329,10 @@ def kron( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.kron. This method - simply wraps the function, and so the docstring for ivy.kron also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.kron. This method simply wraps the + function, and so the docstring for ivy.kron also applies to this method with + minimal changes. Examples -------- @@ -374,9 +379,10 @@ def matrix_exp( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.diagflat. This method - simply wraps the function, and so the docstring for ivy.diagflat also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.diagflat. This method simply wraps + the function, and so the docstring for ivy.diagflat also applies to this method + with minimal changes. Examples -------- @@ -407,9 +413,10 @@ def static_eig( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.eig. This method simply - wraps the function, and so the docstring for ivy.eig also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.eig. This method simply wraps the + function, and so the docstring for ivy.eig also applies to this method with + minimal changes. Parameters ---------- @@ -459,9 +466,10 @@ def eig( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.eig. This method simply - wraps the function, and so the docstring for ivy.eig also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.eig. This method simply wraps the + function, and so the docstring for ivy.eig also applies to this method with + minimal changes. Parameters ---------- @@ -511,9 +519,10 @@ def static_eigvals( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.eigvals. This method - simply wraps the function, and so the docstring for ivy.eigvals also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.eigvals. This method simply wraps the + function, and so the docstring for ivy.eigvals also applies to this method with + minimal changes. Parameters ---------- @@ -557,9 +566,10 @@ def eigvals( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.eigvals. This method - simply wraps the function, and so the docstring for ivy.eigvals also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.eigvals. This method simply wraps + the function, and so the docstring for ivy.eigvals also applies to this method + with minimal changes. Parameters ---------- @@ -602,9 +612,10 @@ def static_adjoint( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """ivy.Container static method variant of ivy.adjoint. This method - simply wraps the function, and so the docstring for ivy.adjoint also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.adjoint. This method simply wraps the + function, and so the docstring for ivy.adjoint also applies to this method with + minimal changes. Parameters ---------- @@ -650,9 +661,10 @@ def adjoint( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """ivy.Container instance method variant of ivy.adjoint. This method - simply wraps the function, and so the docstring for ivy.adjoint also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.adjoint. This method simply wraps + the function, and so the docstring for ivy.adjoint also applies to this method + with minimal changes. Examples -------- @@ -680,9 +692,10 @@ def static_multi_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.multi_dot. This method - simply wraps the function, and so the docstring for ivy.multi_dot also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.multi_dot. This method simply wraps + the function, and so the docstring for ivy.multi_dot also applies to this method + with minimal changes. Parameters ---------- @@ -737,9 +750,10 @@ def multi_dot( map_sequences: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.multi_dot. This method - simply wraps the function, and so the docstring for ivy.multi_dot also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.multi_dot. This method simply wraps + the function, and so the docstring for ivy.multi_dot also applies to this method + with minimal changes. Examples -------- @@ -778,9 +792,10 @@ def static_cond( p: Optional[Union[int, float, None, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ivy.Container static method variant of ivy.cond. This method simply - wraps the function, and so the docstring for ivy.cond also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.cond. This method simply wraps the + function, and so the docstring for ivy.cond also applies to this method with + minimal changes. Parameters ---------- @@ -822,9 +837,10 @@ def cond( map_sequences: Union[bool, ivy.Container] = False, p: Optional[Union[int, float, None, ivy.Container]] = None, ): - """ivy.Container instance method variant of ivy.cond. This method - simply wraps the function, and so the docstring for ivy.cond also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cond. This method simply wraps the + function, and so the docstring for ivy.cond also applies to this method with + minimal changes. Parameters ---------- @@ -884,9 +900,10 @@ def static_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.mode_dot. This method - simply wraps the function, and so the docstring for ivy.mode_dot also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.mode_dot. This method simply wraps + the function, and so the docstring for ivy.mode_dot also applies to this method + with minimal changes. Parameters ---------- @@ -939,9 +956,10 @@ def mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ivy.Container instance method variant of ivy.mode_dot. This method - simply wraps the function, and so the docstring for ivy.mode_dot also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.mode_dot. This method simply wraps + the function, and so the docstring for ivy.mode_dot also applies to this method + with minimal changes. Parameters ---------- @@ -995,9 +1013,10 @@ def static_multi_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.multi_mode_dot. This - method simply wraps the function, and so the docstring for - ivy.multi_mode_dot also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.multi_mode_dot. This method simply + wraps the function, and so the docstring for ivy.multi_mode_dot also applies to + this method with minimal changes. Parameters ---------- @@ -1054,9 +1073,10 @@ def multi_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.multi_mode_dot. This - method simply wraps the function, and so the docstring for - ivy.multi_mode_dot also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.multi_mode_dot. This method simply + wraps the function, and so the docstring for ivy.multi_mode_dot also applies to + this method with minimal changes. Parameters ---------- @@ -1110,9 +1130,10 @@ def static_svd_flip( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container static method variant of ivy.svd_flip. This method - simply wraps the function, and so the docstring for ivy.svd_flip also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.svd_flip. This method simply wraps + the function, and so the docstring for ivy.svd_flip also applies to this method + with minimal changes. Parameters ---------- @@ -1151,9 +1172,10 @@ def svd_flip( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container instance method variant of ivy.svd_flip. This method - simply wraps the function, and so the docstring for ivy.svd_flip - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.svd_flip. This method simply wraps + the function, and so the docstring for ivy.svd_flip applies to this method with + minimal changes. Parameters ---------- @@ -1194,10 +1216,10 @@ def static_make_svd_non_negative( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container static method variant of ivy.make_svd_non_negative. - This method simply wraps the function, and so the docstring for - ivy.make_svd_non_negative also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.make_svd_non_negative. This method + simply wraps the function, and so the docstring for ivy.make_svd_non_negative + also applies to this method with minimal changes. Parameters ---------- @@ -1241,9 +1263,10 @@ def make_svd_non_negative( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container instance method variant of ivy.make_svd_non_negative. - This method simply wraps the function, and so the docstring for - ivy.make_svd_non_negative applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.make_svd_non_negative. This method + simply wraps the function, and so the docstring for ivy.make_svd_non_negative + applies to this method with minimal changes. Parameters ---------- @@ -1286,9 +1309,10 @@ def static_tensor_train( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ivy.Container static method variant of ivy.tensor_train. This method - simply wraps the function, and so the docstring for ivy.tensor_train - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.tensor_train. This method simply + wraps the function, and so the docstring for ivy.tensor_train also applies to + this method with minimal changes. Parameters ---------- @@ -1325,9 +1349,10 @@ def tensor_train( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ivy.Container instance method variant of ivy.tensor_train. This - method simply wraps the function, and so the docstring for - ivy.tensor_train also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.tensor_train. This method simply + wraps the function, and so the docstring for ivy.tensor_train also applies to + this method with minimal changes. Parameters ---------- @@ -1363,9 +1388,10 @@ def static_truncated_svd( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container, ivy.Container]]: - """ivy.Container static method variant of ivy.truncated_svd. This - method simply wraps the function, and so the docstring for - ivy.truncated_svd also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.truncated_svd. This method simply + wraps the function, and so the docstring for ivy.truncated_svd also applies to + this method with minimal changes. Parameters ---------- @@ -1409,9 +1435,10 @@ def truncated_svd( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container, ivy.Container]]: - """ivy.Container instance method variant of ivy.truncated_svd. This - method simply wraps the function, and so the docstring for - ivy.truncated_svd also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.truncated_svd. This method simply + wraps the function, and so the docstring for ivy.truncated_svd also applies to + this method with minimal changes. Parameters ---------- @@ -1463,9 +1490,10 @@ def static_initialize_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ivy.Container static method variant of ivy.initialize_tucker. This - method simply wraps the function, and so the docstring for - ivy.initialize_tucker also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.initialize_tucker. This method simply + wraps the function, and so the docstring for ivy.initialize_tucker also applies + to this method with minimal changes. Parameters ---------- @@ -1536,9 +1564,10 @@ def initialize_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ivy.Container instance method variant of ivy.initialize_tucker. This - method simply wraps the function, and so the docstring for - ivy.initialize_tucker also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.initialize_tucker. This method + simply wraps the function, and so the docstring for ivy.initialize_tucker also + applies to this method with minimal changes. Parameters ---------- @@ -1612,9 +1641,10 @@ def static_partial_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ivy.Container static method variant of ivy.partial_tucker. This - method simply wraps the function, and so the docstring for - ivy.partial_tucker also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.partial_tucker. This method simply + wraps the function, and so the docstring for ivy.partial_tucker also applies to + this method with minimal changes. Parameters ---------- @@ -1689,9 +1719,10 @@ def partial_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ivy.Container static method variant of ivy.partial_tucker. This - method simply wraps the function, and so the docstring for - ivy.partial_tucker also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.partial_tucker. This method simply + wraps the function, and so the docstring for ivy.partial_tucker also applies to + this method with minimal changes. Parameters ---------- @@ -1766,9 +1797,10 @@ def static_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ivy.Container static method variant of ivy.tucker. This method - simply wraps the function, and so the docstring for ivy.tucker also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.tucker. This method simply wraps the + function, and so the docstring for ivy.tucker also applies to this method with + minimal changes. Parameters ---------- @@ -1863,9 +1895,10 @@ def tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ivy.Container static method variant of ivy.tucker. This method - simply wraps the function, and so the docstring for ivy.tucker also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.tucker. This method simply wraps the + function, and so the docstring for ivy.tucker also applies to this method with + minimal changes. Parameters ---------- @@ -1949,9 +1982,10 @@ def static_dot( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Array, ivy.Container]: - """Compute the dot product between two arrays `a` and `b` using the - current backend's implementation. The dot product is defined as the sum - of the element- wise product of the input arrays. + """ + Compute the dot product between two arrays `a` and `b` using the current + backend's implementation. The dot product is defined as the sum of the element- + wise product of the input arrays. Parameters ---------- @@ -2014,9 +2048,10 @@ def dot( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Array, ivy.Container]: - """Compute the dot product between two arrays `a` and `b` using the - current backend's implementation. The dot product is defined as the sum - of the element- wise product of the input arrays. + """ + Compute the dot product between two arrays `a` and `b` using the current + backend's implementation. The dot product is defined as the sum of the element- + wise product of the input arrays. Parameters ---------- @@ -2078,10 +2113,10 @@ def static_tt_matrix_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.tt_matrix_to_tensor. This - method simply wraps the function, and so the docstring for - ivy.tt_matrix_to_tensor also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.tt_matrix_to_tensor. This method + simply wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also + applies to this method with minimal changes. Parameters ---------- @@ -2145,10 +2180,10 @@ def tt_matrix_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.tt_matrix_to_tensor. - This method simply wraps the function, and so the docstring for - ivy.tt_matrix_to_tensor also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.tt_matrix_to_tensor. This method + simply wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also + applies to this method with minimal changes. Parameters ---------- @@ -2213,10 +2248,10 @@ def static_higher_order_moment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.higher_order_moment. This - method simply wraps the function, and so the docstring for - ivy.higher_order_moment also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.higher_order_moment. This method + simply wraps the function, and so the docstring for ivy.higher_order_moment also + applies to this method with minimal changes. Parameters ---------- @@ -2255,10 +2290,10 @@ def higher_order_moment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.higher_order_moment. - This method simply wraps the function, and so the docstring for - ivy.higher_order_moment also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.higher_order_moment. This method + simply wraps the function, and so the docstring for ivy.higher_order_moment also + applies to this method with minimal changes. Parameters ---------- @@ -2308,9 +2343,10 @@ def static_batched_outer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.batched_outer. This - method simply wraps the function, and so the docstring for - ivy.batched_outer also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.batched_outer. This method simply + wraps the function, and so the docstring for ivy.batched_outer also applies to + this method with minimal changes. Parameters ---------- @@ -2367,9 +2403,10 @@ def batched_outer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.batched_outer. This - method simply wraps the function, and so the docstring for - ivy.batched_outer also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.batched_outer. This method simply + wraps the function, and so the docstring for ivy.batched_outer also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/losses.py b/ivy/data_classes/container/experimental/losses.py index 26fc89086aadc..cbd27d371dc1d 100644 --- a/ivy/data_classes/container/experimental/losses.py +++ b/ivy/data_classes/container/experimental/losses.py @@ -20,9 +20,10 @@ def _static_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.l1_loss. This method - simply wraps the function, and so the docstring for ivy.l1_loss also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.l1_loss. This method simply wraps the + function, and so the docstring for ivy.l1_loss also applies to this method with + minimal changes. Parameters ---------- @@ -102,9 +103,10 @@ def l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.l1_loss. This method - simply wraps the function, and so the docstring for ivy.l1_loss also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.l1_loss. This method simply wraps + the function, and so the docstring for ivy.l1_loss also applies to this method + with minimal changes. Parameters ---------- @@ -173,9 +175,10 @@ def _static_log_poisson_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.log_poisson_loss. This - method simply wraps the function, and so the docstring for - ivy.log_poisson_loss also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.log_poisson_loss. This method simply + wraps the function, and so the docstring for ivy.log_poisson_loss also applies + to this method with minimal changes. Parameters ---------- @@ -266,9 +269,10 @@ def log_poisson_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.log_poisson_loss. This - method simply wraps the function, and so the docstring for - ivy.log_poisson_loss also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.log_poisson_loss. This method + simply wraps the function, and so the docstring for ivy.log_poisson_loss also + applies to this method with minimal changes. Parameters ---------- @@ -345,9 +349,10 @@ def _static_smooth_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.smooth_l1_loss. This - method simply wraps the function, and so the docstring for ivy. - smooth_l1_loss also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.smooth_l1_loss. This method simply + wraps the function, and so the docstring for ivy. smooth_l1_loss also applies to + this method with minimal changes. Parameters ---------- @@ -434,9 +439,10 @@ def smooth_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.smooth_l1_loss. This - method simply wraps the function, and so the docstring for ivy. - smooth_l1_loss also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.smooth_l1_loss. This method simply + wraps the function, and so the docstring for ivy. smooth_l1_loss also applies to + this method with minimal changes. Parameters ---------- @@ -512,9 +518,10 @@ def _static_huber_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of huber_loss. This method - simply wraps the function, and so the docstring for huber_loss also - applies to this method with minimal changes. + """ + ivy.Container static method variant of huber_loss. This method simply wraps the + function, and so the docstring for huber_loss also applies to this method with + minimal changes. Parameters ---------- @@ -601,9 +608,10 @@ def huber_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of huber_loss. This method - simply wraps the function, and so the docstring for huber_loss also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of huber_loss. This method simply wraps + the function, and so the docstring for huber_loss also applies to this method + with minimal changes. Parameters ---------- @@ -675,9 +683,10 @@ def _static_soft_margin_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.soft_margin_loss. This - method simply wraps the function, and so the docstring for - ivy.soft_margin_loss also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.soft_margin_loss. This method simply + wraps the function, and so the docstring for ivy.soft_margin_loss also applies + to this method with minimal changes. # Insert the docstring here @@ -733,9 +742,10 @@ def soft_margin_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.soft_margin_loss. This - method simply wraps the function, and so the docstring for - ivy.soft_margin_loss also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.soft_margin_loss. This method + simply wraps the function, and so the docstring for ivy.soft_margin_loss also + applies to this method with minimal changes. # Insert the docstring here @@ -792,9 +802,10 @@ def _static_kl_div( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.kl_div. This method - simply wraps the function, and so the docstring for ivy.kl_div also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.kl_div. This method simply wraps the + function, and so the docstring for ivy.kl_div also applies to this method with + minimal changes. Parameters ---------- @@ -850,9 +861,10 @@ def kl_div( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.kl_div. This method - simply wraps the function, and so the docstring for ivy.kl_div also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.kl_div. This method simply wraps + the function, and so the docstring for ivy.kl_div also applies to this method + with minimal changes. Parameters ---------- @@ -908,9 +920,10 @@ def _static_poisson_nll_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container static method variant of ivy.poisson_nll_loss. This - method simplywraps the function, and so the docstring for - ivy.poisson_nll_loss also applies to this method with minimal changes. + r""" + ivy.Container static method variant of ivy.poisson_nll_loss. This method + simplywraps the function, and so the docstring for ivy.poisson_nll_loss also + applies to this method with minimal changes. Parameters ---------- @@ -1013,9 +1026,10 @@ def poisson_nll_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.poisson_nll_loss. This - method simply wraps the function, and so the docstring for ivy. - poisson_nll_loss also applies to this method with minimal changes. + r""" + ivy.Container instance method variant of ivy.poisson_nll_loss. This method + simply wraps the function, and so the docstring for ivy. poisson_nll_loss also + applies to this method with minimal changes. Parameters ---------- @@ -1102,10 +1116,10 @@ def _static_hinge_embedding_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container static method variant of ivy.hinge_embedding_loss. - This method simplywraps the function, and so the docstring for - ivy.hinge_embedding_loss also applies to this method with minimal - changes. + r""" + ivy.Container static method variant of ivy.hinge_embedding_loss. This method + simplywraps the function, and so the docstring for ivy.hinge_embedding_loss also + applies to this method with minimal changes. Parameters ---------- @@ -1201,10 +1215,10 @@ def hinge_embedding_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.hinge_embedding_loss. - This method simply wraps the function, and so the docstring for - ivy.hinge_embedding_loss also applies to this method with minimal - changes. + r""" + ivy.Container instance method variant of ivy.hinge_embedding_loss. This method + simply wraps the function, and so the docstring for ivy.hinge_embedding_loss + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/manipulation.py b/ivy/data_classes/container/experimental/manipulation.py index 20e72671746e1..0621ae4be3267 100644 --- a/ivy/data_classes/container/experimental/manipulation.py +++ b/ivy/data_classes/container/experimental/manipulation.py @@ -33,9 +33,10 @@ def static_moveaxis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.moveaxis. This method - simply wraps the function, and so the docstring for ivy.moveaxis also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.moveaxis. This method simply wraps + the function, and so the docstring for ivy.moveaxis also applies to this method + with minimal changes. Parameters ---------- @@ -93,9 +94,10 @@ def moveaxis( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.moveaxis. This method - simply wraps the function, and so the docstring for ivy.flatten also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.moveaxis. This method simply wraps + the function, and so the docstring for ivy.flatten also applies to this method + with minimal changes. Parameters ---------- @@ -145,9 +147,10 @@ def static_heaviside( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.heaviside. This method - simply wraps the function, and so the docstring for ivy.heaviside also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.heaviside. This method simply wraps + the function, and so the docstring for ivy.heaviside also applies to this method + with minimal changes. Parameters ---------- @@ -192,9 +195,10 @@ def heaviside( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.heaviside. This method - simply wraps the function, and so the docstring for ivy.heaviside also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.heaviside. This method simply wraps + the function, and so the docstring for ivy.heaviside also applies to this method + with minimal changes. Parameters ---------- @@ -235,9 +239,10 @@ def static_flipud( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.flipud. This method - simply wraps the function, and so the docstring for ivy.flipud also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.flipud. This method simply wraps the + function, and so the docstring for ivy.flipud also applies to this method with + minimal changes. Parameters ---------- @@ -292,9 +297,10 @@ def flipud( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.flipud. This method - simply wraps the function, and so the docstring for ivy.flipud also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.flipud. This method simply wraps + the function, and so the docstring for ivy.flipud also applies to this method + with minimal changes. Parameters ---------- @@ -347,9 +353,10 @@ def vstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.stack. This method - simply wraps the function, and so the docstring for ivy.stack also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.stack also applies to this method with + minimal changes. Examples -------- @@ -390,9 +397,10 @@ def static_vstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.stack. This method simply - wraps the function, and so the docstring for ivy.vstack also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.vstack also applies to this method with + minimal changes. Examples -------- @@ -434,9 +442,10 @@ def hstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.hstack. This method - simply wraps the function, and so the docstring for ivy.hstack also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.hstack. This method simply wraps + the function, and so the docstring for ivy.hstack also applies to this method + with minimal changes. Examples -------- @@ -475,9 +484,10 @@ def static_hstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.hstack. This method - simply wraps the function, and so the docstring for ivy.hstack also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.hstack. This method simply wraps the + function, and so the docstring for ivy.hstack also applies to this method with + minimal changes. Examples -------- @@ -512,9 +522,10 @@ def static_rot90( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.rot90. This method simply - wraps the function, and so the docstring for ivy.rot90 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.rot90. This method simply wraps the + function, and so the docstring for ivy.rot90 also applies to this method with + minimal changes. Parameters ---------- @@ -586,9 +597,10 @@ def rot90( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.rot90. This method simply - wraps the function, and so the docstring for ivy.rot90 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.rot90. This method simply wraps the + function, and so the docstring for ivy.rot90 also applies to this method with + minimal changes. Parameters ---------- @@ -660,9 +672,10 @@ def static_top_k( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[Tuple[ivy.Container, ivy.Container], ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container static method variant of ivy.top_k. This method simply - wraps the function, and so the docstring for ivy.top_k also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.top_k. This method simply wraps the + function, and so the docstring for ivy.top_k also applies to this method with + minimal changes. Parameters ---------- @@ -742,9 +755,10 @@ def top_k( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container instance method variant of ivy.top_k. This method - simply wraps the function, and so the docstring for ivy.top_k also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.top_k. This method simply wraps the + function, and so the docstring for ivy.top_k also applies to this method with + minimal changes. Parameters ---------- @@ -818,9 +832,10 @@ def static_fliplr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fliplr. This method - simply wraps the function, and so the docstring for ivy.fliplr also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.fliplr. This method simply wraps the + function, and so the docstring for ivy.fliplr also applies to this method with + minimal changes. Parameters ---------- @@ -885,9 +900,10 @@ def fliplr( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fliplr. This method - simply wraps the function, and so the docstring for ivy.fliplr also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.fliplr. This method simply wraps + the function, and so the docstring for ivy.fliplr also applies to this method + with minimal changes. Parameters ---------- @@ -937,9 +953,10 @@ def static_i0( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.i0. This method simply - wraps the function, and so the docstring for ivy.i0 also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.i0. This method simply wraps the + function, and so the docstring for ivy.i0 also applies to this method with + minimal changes. Parameters ---------- @@ -981,9 +998,10 @@ def i0( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.i0. This method simply - wraps the function, and so the docstring for ivy.i0 also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.i0. This method simply wraps the + function, and so the docstring for ivy.i0 also applies to this method with + minimal changes. Parameters ---------- @@ -1026,9 +1044,10 @@ def static_flatten( order: Union[str, ivy.Container] = "C", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.flatten. This method - simply wraps the function, and so the docstring for ivy.flatten also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.flatten. This method simply wraps the + function, and so the docstring for ivy.flatten also applies to this method with + minimal changes. Parameters ---------- @@ -1105,9 +1124,10 @@ def flatten( order: Union[str, ivy.Container] = "C", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.flatten. This method - simply wraps the function, and so the docstring for ivy.flatten also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.flatten. This method simply wraps + the function, and so the docstring for ivy.flatten also applies to this method + with minimal changes. Parameters ---------- @@ -1200,7 +1220,8 @@ def static_pad( out: Optional[ivy.Container] = None, **kwargs: Optional[Union[Any, ivy.Container]], ) -> ivy.Container: - """ivy.Container static method variant of ivy.pad. + """ + ivy.Container static method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -1256,7 +1277,8 @@ def pad( out: Optional[ivy.Container] = None, **kwargs: Optional[Union[Any, ivy.Container]], ) -> ivy.Container: - """ivy.Container instance method variant of ivy.pad. + """ + ivy.Container instance method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -1291,9 +1313,10 @@ def static_vsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container static method variant of ivy.vsplit. This method - simply wraps the function, and so the docstring for ivy.vsplit also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.vsplit. This method simply wraps the + function, and so the docstring for ivy.vsplit also applies to this method with + minimal changes. Parameters ---------- @@ -1376,9 +1399,10 @@ def vsplit( *, copy: Optional[Union[bool, ivy.Container]] = None, ) -> List[ivy.Container]: - """ivy.Container instance method variant of ivy.vsplit. This method - simply wraps the function, and so the docstring for ivy.vsplit also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.vsplit. This method simply wraps + the function, and so the docstring for ivy.vsplit also applies to this method + with minimal changes. Parameters ---------- @@ -1447,9 +1471,10 @@ def static_dsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container static method variant of ivy.dsplit. This method - simply wraps the function, and so the docstring for ivy.dsplit also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.dsplit. This method simply wraps the + function, and so the docstring for ivy.dsplit also applies to this method with + minimal changes. Parameters ---------- @@ -1530,9 +1555,10 @@ def dsplit( *, copy: Optional[Union[bool, ivy.Container]] = None, ) -> List[ivy.Container]: - """ivy.Container instance method variant of ivy.dsplit. This method - simply wraps the function, and so the docstring for ivy.dsplit also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.dsplit. This method simply wraps + the function, and so the docstring for ivy.dsplit also applies to this method + with minimal changes. Parameters ---------- @@ -1594,9 +1620,10 @@ def static_atleast_1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container static method variant of ivy.atleast_1d. This method - simply wraps the function, and so the docstring for ivy.atleast_1d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.atleast_1d. This method simply wraps + the function, and so the docstring for ivy.atleast_1d also applies to this + method with minimal changes. Parameters ---------- @@ -1657,9 +1684,10 @@ def atleast_1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container instance method variant of ivy.atleast_1d. This method - simply wraps the function, and so the docstring for ivy.atleast_1d also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.atleast_1d. This method simply + wraps the function, and so the docstring for ivy.atleast_1d also applies to this + method with minimal changes. Parameters ---------- @@ -1733,9 +1761,10 @@ def dstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.stack. This method - simply wraps the function, and so the docstring for ivy.stack also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.stack also applies to this method with + minimal changes. Examples -------- @@ -1776,9 +1805,10 @@ def static_dstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.stack. This method simply - wraps the function, and so the docstring for ivy.dstack also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.dstack also applies to this method with + minimal changes. Examples -------- @@ -1812,9 +1842,10 @@ def static_atleast_2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container static method variant of ivy.atleast_2d. This method - simply wraps the function, and so the docstring for ivy.atleast_2d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.atleast_2d. This method simply wraps + the function, and so the docstring for ivy.atleast_2d also applies to this + method with minimal changes. Parameters ---------- @@ -1875,9 +1906,10 @@ def atleast_2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container instance method variant of ivy.atleast_2d. This method - simply wraps the function, and so the docstring for ivy.atleast_2d also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.atleast_2d. This method simply + wraps the function, and so the docstring for ivy.atleast_2d also applies to this + method with minimal changes. Parameters ---------- @@ -1946,9 +1978,10 @@ def static_atleast_3d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container static method variant of ivy.atleast_3d. This method - simply wraps the function, and so the docstring for ivy.atleast_3d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.atleast_3d. This method simply wraps + the function, and so the docstring for ivy.atleast_3d also applies to this + method with minimal changes. Parameters ---------- @@ -2013,9 +2046,10 @@ def atleast_3d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container instance method variant of ivy.atleast_3d. This method - simply wraps the function, and so the docstring for ivy.atleast_3d also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.atleast_3d. This method simply + wraps the function, and so the docstring for ivy.atleast_3d also applies to this + method with minimal changes. Parameters ---------- @@ -2084,9 +2118,10 @@ def static_take_along_axis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.take_along_axis. This - method simply wraps the function, and so the docstring for - ivy.take_along_axis also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.take_along_axis. This method simply + wraps the function, and so the docstring for ivy.take_along_axis also applies to + this method with minimal changes. Parameters ---------- @@ -2157,9 +2192,10 @@ def take_along_axis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.take_along_axis. This - method simply wraps the function, and so the docstring for - ivy.take_along_axis also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.take_along_axis. This method simply + wraps the function, and so the docstring for ivy.take_along_axis also applies to + this method with minimal changes. Parameters ---------- @@ -2232,9 +2268,10 @@ def static_hsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container static method variant of ivy.hsplit. This method - simply wraps the function, and so the docstring for ivy.hsplit also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.hsplit. This method simply wraps the + function, and so the docstring for ivy.hsplit also applies to this method with + minimal changes. Parameters ---------- @@ -2308,9 +2345,10 @@ def hsplit( copy: Optional[Union[bool, ivy.Container]] = None, /, ) -> List[ivy.Container]: - """ivy.Container instance method variant of ivy.hsplit. This method - simply wraps the function, and so the docstring for ivy.hsplit also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.hsplit. This method simply wraps + the function, and so the docstring for ivy.hsplit also applies to this method + with minimal changes. Parameters ---------- @@ -2367,9 +2405,10 @@ def static_broadcast_shapes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.broadcast_shapes. This - method simply wraps the function, and so the docstring for ivy.hsplit - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.broadcast_shapes. This method simply + wraps the function, and so the docstring for ivy.hsplit also applies to this + method with minimal changes. Parameters ---------- @@ -2423,9 +2462,10 @@ def broadcast_shapes( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.broadcast_shapes. This - method simply wraps the function, and so the docstring for - ivy.broadcast_shapes also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.broadcast_shapes. This method + simply wraps the function, and so the docstring for ivy.broadcast_shapes also + applies to this method with minimal changes. Parameters ---------- @@ -2562,9 +2602,10 @@ def static_as_strided( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.as_strided. This method - simply wraps the function, and so the docstring for ivy.as_strided also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.as_strided. This method simply + wraps the function, and so the docstring for ivy.as_strided also applies to this + method with minimal changes. Parameters ---------- @@ -2608,9 +2649,10 @@ def as_strided( strides: Union[Sequence[int], ivy.Container], /, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.as_strided. This method - simply wraps the function, and so the docstring for ivy.as_strided also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.as_strided. This method simply + wraps the function, and so the docstring for ivy.as_strided also applies to this + method with minimal changes. Parameters ---------- @@ -2644,10 +2686,10 @@ def static_concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.concat_from_sequence. - This method simply wraps the function, and so the docstring for - ivy.concat_from_sequence also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.concat_from_sequence. This method + simply wraps the function, and so the docstring for ivy.concat_from_sequence + also applies to this method with minimal changes. Parameters ---------- @@ -2748,9 +2790,10 @@ def concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.stack. This method - simply wraps the function, and so the docstring for ivy.stack also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.stack also applies to this method with + minimal changes. Parameters ---------- @@ -2828,9 +2871,10 @@ def associative_scan( reverse: Union[bool, ivy.Container] = False, axis: Union[int, ivy.Container] = 0, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.associative_scan. This - method simply wraps the function, and so the docstring for - ivy.associative_scan also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.associative_scan. This method + simply wraps the function, and so the docstring for ivy.associative_scan also + applies to this method with minimal changes. Parameters ---------- @@ -2861,7 +2905,8 @@ def _static_unique_consecutive( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.unique_consecutive. + """ + ivy.Container static method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -2887,7 +2932,8 @@ def unique_consecutive( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.unique_consecutive. + """ + ivy.Container instance method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -2910,7 +2956,8 @@ def _static_fill_diagonal( *, wrap: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fill_diagonal. + """ + ivy.Container static method variant of ivy.fill_diagonal. This method simply wraps the function, and so the docstring for ivy.fill_diagonal also applies to this method with minimal @@ -2930,7 +2977,8 @@ def fill_diagonal( *, wrap: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fill_diagonal. + """ + ivy.Container instance method variant of ivy.fill_diagonal. This method simply wraps the function, and so the docstring for ivy.fill_diagonal also applies to this method with minimal @@ -2954,7 +3002,8 @@ def static_unfold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.unfold. + """ + ivy.Container static method variant of ivy.unfold. This method simply wraps the function, and so the docstring for ivy.unfold also applies to this method with minimal @@ -2993,7 +3042,8 @@ def unfold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.unfold. + """ + ivy.Container instance method variant of ivy.unfold. This method simply wraps the function, and so the docstring for ivy.unfold also applies to this method with minimal @@ -3029,7 +3079,8 @@ def static_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fold. + """ + ivy.Container static method variant of ivy.fold. This method simply wraps the function, and so the docstring for ivy.fold also applies to this method with minimal @@ -3070,7 +3121,8 @@ def fold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fold. + """ + ivy.Container instance method variant of ivy.fold. This method simply wraps the function, and so the docstring for ivy.fold also applies to this method with minimal @@ -3109,7 +3161,8 @@ def static_partial_unfold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.partial_unfold. + """ + ivy.Container static method variant of ivy.partial_unfold. This method simply wraps the function, and so the docstring for ivy.partial_unfold also applies to this method with minimal @@ -3160,7 +3213,8 @@ def partial_unfold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.partial_unfold. + """ + ivy.Container instance method variant of ivy.partial_unfold. This method simply wraps the function, and so the docstring for ivy.partial_unfold also applies to this method with minimal @@ -3205,7 +3259,8 @@ def static_partial_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.partial_fold. + """ + ivy.Container static method variant of ivy.partial_fold. This method simply wraps the function, and so the docstring for ivy.partial_fold also applies to this method with minimal @@ -3256,7 +3311,8 @@ def partial_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.partial_fold. + """ + ivy.Container instance method variant of ivy.partial_fold. This method simply wraps the function, and so the docstring for ivy.partial_fold also applies to this method with minimal @@ -3296,7 +3352,8 @@ def static_partial_tensor_to_vec( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.partial_tensor_to_vec. + """ + ivy.Container static method variant of ivy.partial_tensor_to_vec. This method simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec also applies to this method with minimal @@ -3344,7 +3401,8 @@ def partial_tensor_to_vec( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.partial_tensor_to_vec. + """ + ivy.Container instance method variant of ivy.partial_tensor_to_vec. This method simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec also applies to this method with minimal @@ -3382,7 +3440,8 @@ def static_partial_vec_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.partial_vec_to_tensor. + """ + ivy.Container static method variant of ivy.partial_vec_to_tensor. This method simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor also applies to this method with minimal @@ -3428,7 +3487,8 @@ def partial_vec_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.partial_vec_to_tensor. + """ + ivy.Container instance method variant of ivy.partial_vec_to_tensor. This method simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor also applies to this method with minimal @@ -3466,7 +3526,8 @@ def static_matricize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.matricize. + """ + ivy.Container static method variant of ivy.matricize. This method simply wraps the function, and so the docstring for ivy.matricize also applies to this method with minimal @@ -3512,7 +3573,8 @@ def matricize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.matricize. + """ + ivy.Container instance method variant of ivy.matricize. This method simply wraps the function, and so the docstring for ivy.matricize also applies to this method with minimal @@ -3547,7 +3609,8 @@ def static_soft_thresholding( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.soft_thresholding. + """ + ivy.Container static method variant of ivy.soft_thresholding. This method simply wraps the function, and so the docstring for ivy.soft_thresholding also applies to this method with minimal @@ -3591,7 +3654,8 @@ def soft_thresholding( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.soft_thresholding. + """ + ivy.Container instance method variant of ivy.soft_thresholding. This method simply wraps the function, and so the docstring for ivy.soft_thresholding also applies to this method with minimal @@ -3626,7 +3690,8 @@ def static_column_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.column_stack. + """ + ivy.Container static method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -3677,7 +3742,8 @@ def column_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.column_stack. + """ + ivy.Container instance method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -3737,7 +3803,8 @@ def _static_put_along_axis( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.put_along_axis. + """ + ivy.Container static method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal @@ -3773,7 +3840,8 @@ def put_along_axis( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.put_along_axis. + """ + ivy.Container instance method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal @@ -3807,7 +3875,8 @@ def _static_take( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.take. + """ + ivy.Container static method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -3907,7 +3976,8 @@ def take( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.take. + """ + ivy.Container instance method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -3999,9 +4069,10 @@ def _static_trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Container: - """ivy.Container static method variant of ivy.trim_zeros. This method - simply wraps the function, and so the docstring for ivy.trim_zeros also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.trim_zeros. This method simply wraps + the function, and so the docstring for ivy.trim_zeros also applies to this + method with minimal changes. Parameters ---------- @@ -4035,9 +4106,10 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ivy.Container instance method variant of ivy.trim_zeros. This method - simply wraps the function, and so the docstring for ivy.trim_zeros also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.trim_zeros. This method simply + wraps the function, and so the docstring for ivy.trim_zeros also applies to this + method with minimal changes. Parameters ---------- @@ -4082,9 +4154,10 @@ def concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.stack. This method simply - wraps the function, and so the docstring for ivy.stack also applies to this - method with minimal changes. + """ + ivy.Container instance method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.stack also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/norms.py b/ivy/data_classes/container/experimental/norms.py index 72d8e3d7485da..aab171d3242df 100644 --- a/ivy/data_classes/container/experimental/norms.py +++ b/ivy/data_classes/container/experimental/norms.py @@ -14,9 +14,10 @@ def static_l1_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.l1_normalize. This method - simply wraps the function, and so the docstring for ivy.l1_normalize - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.l1_normalize. This method simply + wraps the function, and so the docstring for ivy.l1_normalize also applies to + this method with minimal changes. Parameters ---------- @@ -77,9 +78,10 @@ def l1_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.l1_normalize. This - method simply wraps the function, and so the docstring for - ivy.l1_normalize also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.l1_normalize. This method simply + wraps the function, and so the docstring for ivy.l1_normalize also applies to + this method with minimal changes. Parameters ---------- @@ -127,9 +129,10 @@ def static_l2_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.l2_normalize. This method - simply wraps the function, and so the docstring for ivy.l2_normalize - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.l2_normalize. This method simply + wraps the function, and so the docstring for ivy.l2_normalize also applies to + this method with minimal changes. Parameters ---------- @@ -190,9 +193,10 @@ def l2_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.l2_normalize. This - method simply wraps the function, and so the docstring for - ivy.l2_normalize also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.l2_normalize. This method simply + wraps the function, and so the docstring for ivy.l2_normalize also applies to + this method with minimal changes. Parameters ---------- @@ -268,9 +272,10 @@ def static_batch_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ivy.Container static method variant of ivy.batch_norm. This method - simply wraps the function, and so the docstring for ivy.batch_norm also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.batch_norm. This method simply wraps + the function, and so the docstring for ivy.batch_norm also applies to this + method with minimal changes. Parameters ---------- @@ -364,9 +369,10 @@ def batch_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ivy.Container instance method variant of ivy.batch_norm. This method - simply wraps the function, and so the docstring for ivy.batch_norm also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.batch_norm. This method simply + wraps the function, and so the docstring for ivy.batch_norm also applies to this + method with minimal changes. Parameters ---------- @@ -460,9 +466,10 @@ def static_instance_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ivy.Container static method variant of ivy.instance_norm. This - method simply wraps the function, and so the docstring for - ivy.instance_norm also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.instance_norm. This method simply + wraps the function, and so the docstring for ivy.instance_norm also applies to + this method with minimal changes. Parameters ---------- @@ -554,9 +561,10 @@ def instance_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ivy.Container instance method variant of ivy.instance_norm. This - method simply wraps the function, and so the docstring for - ivy.instance_norm also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.instance_norm. This method simply + wraps the function, and so the docstring for ivy.instance_norm also applies to + this method with minimal changes. Parameters ---------- @@ -639,9 +647,10 @@ def static_group_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.group_norm. This method - simply wraps the function, and so the docstring for ivy.group_norm also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.group_norm. This method simply wraps + the function, and so the docstring for ivy.group_norm also applies to this + method with minimal changes. Parameters ---------- @@ -701,9 +710,10 @@ def group_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.group_norm. This method - simply wraps the function, and so the docstring for ivy.group_norm also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.group_norm. This method simply wraps + the function, and so the docstring for ivy.group_norm also applies to this + method with minimal changes. Parameters ---------- @@ -758,9 +768,10 @@ def static_lp_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.lp_normalize. This method - simply wraps the function, and so the docstring for ivy.lp_normalize - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.lp_normalize. This method simply + wraps the function, and so the docstring for ivy.lp_normalize also applies to + this method with minimal changes. Parameters ---------- @@ -825,9 +836,10 @@ def lp_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.l2_normalize. This - method simply wraps the function, and so the docstring for - ivy.l2_normalize also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.l2_normalize. This method simply + wraps the function, and so the docstring for ivy.l2_normalize also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/random.py b/ivy/data_classes/container/experimental/random.py index 9a991587eba55..7544f92d3fafa 100644 --- a/ivy/data_classes/container/experimental/random.py +++ b/ivy/data_classes/container/experimental/random.py @@ -22,9 +22,10 @@ def static_dirichlet( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.dirichlet. This method - simply wraps the function, and so the docstring for ivy.dirichlet also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.dirichlet. This method simply wraps + the function, and so the docstring for ivy.dirichlet also applies to this method + with minimal changes. Parameters ---------- @@ -88,9 +89,10 @@ def dirichlet( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.dirichlet. This method - simply wraps the function, and so the docstring for ivy.shuffle also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.dirichlet. This method simply wraps + the function, and so the docstring for ivy.shuffle also applies to this method + with minimal changes. Parameters ---------- @@ -156,9 +158,10 @@ def static_beta( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.beta. This method simply - wraps the function, and so the docstring for ivy.beta also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.beta. This method simply wraps the + function, and so the docstring for ivy.beta also applies to this method with + minimal changes. Parameters ---------- @@ -226,9 +229,10 @@ def beta( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.beta. This method - simply wraps the function, and so the docstring for ivy.beta also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.beta. This method simply wraps the + function, and so the docstring for ivy.beta also applies to this method with + minimal changes. Parameters ---------- @@ -295,9 +299,10 @@ def static_poisson( fill_value: Optional[Union[float, int, ivy.Container]] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.poisson. This method - simply wraps the function, and so the docstring for ivy.poisson also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.poisson. This method simply wraps the + function, and so the docstring for ivy.poisson also applies to this method with + minimal changes. Parameters ---------- @@ -364,9 +369,10 @@ def poisson( fill_value: Optional[Union[float, int, ivy.Container]] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.poisson. This method - simply wraps the function, and so the docstring for ivy.poisson also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.poisson. This method simply wraps + the function, and so the docstring for ivy.poisson also applies to this method + with minimal changes. Parameters ---------- @@ -569,9 +575,10 @@ def static_gamma( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ivy.Container static method variant of ivy.gamma. This method simply - wraps the function, and so the docstring for ivy.gamma also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.gamma. This method simply wraps the + function, and so the docstring for ivy.gamma also applies to this method with + minimal changes. Parameters ---------- @@ -639,9 +646,10 @@ def gamma( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ivy.Container method variant of ivy.gamma. This method simply wraps - the function, and so the docstring for ivy.gamma also applies to this - method with minimal changes. + """ + ivy.Container method variant of ivy.gamma. This method simply wraps the + function, and so the docstring for ivy.gamma also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/searching.py b/ivy/data_classes/container/experimental/searching.py index 0886c307e45e0..d261dd6637716 100644 --- a/ivy/data_classes/container/experimental/searching.py +++ b/ivy/data_classes/container/experimental/searching.py @@ -19,9 +19,10 @@ def static_unravel_index( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.unravel_index. This - method simply wraps the function, and so the docstring for - ivy.unravel_index also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.unravel_index. This method simply + wraps the function, and so the docstring for ivy.unravel_index also applies to + this method with minimal changes. Parameters ---------- @@ -66,9 +67,10 @@ def unravel_index( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.unravel_index. This - method simply wraps the function, and so the docstring for - ivy.unravel_index also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.unravel_index. This method simply + wraps the function, and so the docstring for ivy.unravel_index also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/sorting.py b/ivy/data_classes/container/experimental/sorting.py index dc7c74258edb8..a79109ea555e3 100644 --- a/ivy/data_classes/container/experimental/sorting.py +++ b/ivy/data_classes/container/experimental/sorting.py @@ -17,7 +17,8 @@ def static_invert_permutation( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.invert_permutation. + """ + ivy.Container static method variant of ivy.invert_permutation. This method simply wraps the function, and so the docstring for ivy.invert_permutation also applies to this method with minimal @@ -41,7 +42,8 @@ def invert_permutation( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.invert_permutation. + """ + ivy.Container instance method variant of ivy.invert_permutation. This method simply wraps the function, and so the docstring for ivy.invert_permutation also applies to this method with minimal @@ -67,9 +69,10 @@ def static_lexsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.lexsort. This method - simply wraps the function, and so the docstring for ivy.lexsort also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.lexsort. This method simply wraps the + function, and so the docstring for ivy.lexsort also applies to this method with + minimal changes. Parameters ---------- @@ -120,9 +123,10 @@ def lexsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.lexsort. This method - simply wraps the function, and so the docstring for ivy.lexsort also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.lexsort. This method simply wraps + the function, and so the docstring for ivy.lexsort also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/statistical.py b/ivy/data_classes/container/experimental/statistical.py index 09c0e616384b1..d7fa55b44c924 100644 --- a/ivy/data_classes/container/experimental/statistical.py +++ b/ivy/data_classes/container/experimental/statistical.py @@ -28,9 +28,10 @@ def static_histogram( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.. This method - simply wraps the function, and so the docstring for ivy.histogram also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.. This method simply wraps + the function, and so the docstring for ivy.histogram also applies to this method + with minimal changes. Parameters ---------- @@ -134,9 +135,10 @@ def histogram( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.. This - method simply wraps the function, and so the docstring for - ivy.histogram also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.. This method simply + wraps the function, and so the docstring for ivy.histogram also applies to this + method with minimal changes. Parameters ---------- @@ -233,9 +235,10 @@ def static_median( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.median. This method - simply wraps the function, and so the docstring for ivy.median also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.median. This method simply wraps the + function, and so the docstring for ivy.median also applies to this method with + minimal changes. Parameters ---------- @@ -285,9 +288,10 @@ def median( keepdims: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.median. This method - simply wraps the function, and so the docstring for ivy.median also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.median. This method simply wraps + the function, and so the docstring for ivy.median also applies to this method + with minimal changes. Parameters ---------- @@ -336,9 +340,10 @@ def static_nanmean( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.nanmean. This method - simply wraps the function, and so the docstring for ivy.nanmean also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.nanmean. This method simply wraps the + function, and so the docstring for ivy.nanmean also applies to this method with + minimal changes. Parameters ---------- @@ -396,9 +401,10 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.nanmean. This method - simply wraps the function, and so the docstring for ivy.nanmean also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.nanmean. This method simply wraps + the function, and so the docstring for ivy.nanmean also applies to this method + with minimal changes. Parameters ---------- @@ -453,9 +459,10 @@ def _static_nanmin( where: Optional[Union[ivy.Array, ivy.Container]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.nanmin. This method - simply wraps the function, and so the docstring for ivy.nanmin also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.nanmin. This method simply wraps the + function, and so the docstring for ivy.nanmin also applies to this method with + minimal changes. Parameters ---------- @@ -514,9 +521,10 @@ def nanmin( initial: Optional[Union[int, float, complex, ivy.Container]] = None, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.nanmin. This method - simply wraps the function, and so the docstring for ivy.nanmin also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.nanmin. This method simply wraps + the function, and so the docstring for ivy.nanmin also applies to this method + with minimal changes. Parameters ---------- @@ -576,9 +584,10 @@ def static_nanprod( initial: Optional[Union[int, float, complex, ivy.Container]] = 1, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.nanprod. This method - simply wraps the function, and so the docstring for ivy.nanprod also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.nanprod. This method simply wraps the + function, and so the docstring for ivy.nanprod also applies to this method with + minimal changes. Parameters ---------- @@ -642,9 +651,10 @@ def nanprod( initial: Optional[Union[int, float, complex, ivy.Container]] = None, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.nanprod. This method - simply wraps the function, and so the docstring for ivy.nanprod also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.nanprod. This method simply wraps + the function, and so the docstring for ivy.nanprod also applies to this method + with minimal changes. Parameters ---------- @@ -707,9 +717,10 @@ def static_quantile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.quantile. This method - simply wraps the function, and so the docstring for ivy.quantile also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.quantile. This method simply wraps + the function, and so the docstring for ivy.quantile also applies to this method + with minimal changes. Parameters ---------- @@ -831,9 +842,10 @@ def quantile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.quantile. This method - simply wraps the function, and so the docstring for ivy.quantile also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.quantile. This method simply wraps + the function, and so the docstring for ivy.quantile also applies to this method + with minimal changes. Parameters ---------- @@ -954,9 +966,10 @@ def static_corrcoef( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.corrcoef. This method - simply wraps the function, and so the docstring for ivy.corrcoef also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.corrcoef. This method simply wraps + the function, and so the docstring for ivy.corrcoef also applies to this method + with minimal changes. Parameters ---------- @@ -1006,9 +1019,10 @@ def corrcoef( rowvar: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.corrcoef. This method - simply wraps the function, and so the docstring for ivy.corrcoef also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.corrcoef. This method simply wraps + the function, and so the docstring for ivy.corrcoef also applies to this method + with minimal changes. Parameters ---------- @@ -1054,9 +1068,10 @@ def static_nanmedian( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.median. This method - simply wraps the function, and so the docstring for ivy.median also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.median. This method simply wraps the + function, and so the docstring for ivy.median also applies to this method with + minimal changes. Parameters ---------- @@ -1109,9 +1124,10 @@ def nanmedian( overwrite_input: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.nanmedian. This method - simply wraps the function, and so the docstring for ivy.nanmedian also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.nanmedian. This method simply wraps + the function, and so the docstring for ivy.nanmedian also applies to this method + with minimal changes. Parameters ---------- @@ -1177,9 +1193,10 @@ def static_bincount( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.bincount. This method - simply wraps the function, and so the docstring for ivy.bincount also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.bincount. This method simply wraps + the function, and so the docstring for ivy.bincount also applies to this method + with minimal changes. Parameters ---------- @@ -1226,9 +1243,10 @@ def bincount( minlength: Union[int, ivy.Container] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Array instance method variant of ivy.bincount. This method - simply wraps the function, and so the docstring for ivy.bincount also - applies to this method with minimal changes. + """ + ivy.Array instance method variant of ivy.bincount. This method simply wraps the + function, and so the docstring for ivy.bincount also applies to this method with + minimal changes. Parameters ---------- @@ -1266,9 +1284,10 @@ def static_igamma( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.igamma. This method - simply wraps the function, and so the docstring for ivy.igamma also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.igamma. This method simply wraps the + function, and so the docstring for ivy.igamma also applies to this method with + minimal changes. Parameters ---------- @@ -1310,9 +1329,10 @@ def igamma( x: Union[ivy.Container, ivy.Array, ivy.NativeArray], out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.igamma. This method - simply wraps the function, and so the docstring for ivy.igamma also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.igamma. This method simply wraps + the function, and so the docstring for ivy.igamma also applies to this method + with minimal changes. Parameters ---------- @@ -1355,9 +1375,10 @@ def static_cov( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cov. This method simply - wraps the function, and so the docstring for ivy.cov also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.cov. This method simply wraps the + function, and so the docstring for ivy.cov also applies to this method with + minimal changes. Parameters ---------- @@ -1471,9 +1492,10 @@ def cov( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cov. This method simply - wraps the function, and so the docstring for ivy.cov also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cov. This method simply wraps the + function, and so the docstring for ivy.cov also applies to this method with + minimal changes. Parameters ---------- @@ -1572,9 +1594,10 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cummax. This method - simply wraps the function, and so the docstring for ivy.cummax also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cummax. This method simply wraps + the function, and so the docstring for ivy.cummax also applies to this method + with minimal changes. Parameters ---------- @@ -1661,9 +1684,10 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cummin. This method - simply wraps the function, and so the docstring for ivy.cummin also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cummin. This method simply wraps + the function, and so the docstring for ivy.cummin also applies to this method + with minimal changes. Parameters ---------- @@ -1748,9 +1772,10 @@ def _static_cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cummax. This method - simply wraps the function, and so the docstring for ivy.cummax also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.cummax. This method simply wraps the + function, and so the docstring for ivy.cummax also applies to this method with + minimal changes. Parameters ---------- @@ -1837,9 +1862,10 @@ def _static_cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cummin. This method - simply wraps the function, and so the docstring for ivy.cummin also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.cummin. This method simply wraps the + function, and so the docstring for ivy.cummin also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/utility.py b/ivy/data_classes/container/experimental/utility.py index 4218b878b282c..876a9fad339e5 100644 --- a/ivy/data_classes/container/experimental/utility.py +++ b/ivy/data_classes/container/experimental/utility.py @@ -18,10 +18,10 @@ def static_optional_get_element( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.optional_get_element. - This method simply wraps the function, and so the docstring for - ivy.optional_get_element also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.optional_get_element. This method + simply wraps the function, and so the docstring for ivy.optional_get_element + also applies to this method with minimal changes. Parameters ---------- @@ -62,10 +62,10 @@ def optional_get_element( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.optional_get_element. - This method simply wraps the function, and so the docstring for - ivy.optional_get_element also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.optional_get_element. This method + simply wraps the function, and so the docstring for ivy.optional_get_element + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/general.py b/ivy/data_classes/container/general.py index e372a016796d4..dd6d633b5f8ea 100644 --- a/ivy/data_classes/container/general.py +++ b/ivy/data_classes/container/general.py @@ -22,9 +22,10 @@ def _static_is_native_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.is_native_array. This - method simply wraps the function, and so the docstring for - ivy.is_native_array also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.is_native_array. This method simply + wraps the function, and so the docstring for ivy.is_native_array also applies to + this method with minimal changes. Parameters ---------- @@ -80,10 +81,10 @@ def is_native_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.is_native_array. This - method simply wraps the function, and so the docstring for - ivy.ivy.is_native_array also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.is_native_array. This method simply + wraps the function, and so the docstring for ivy.ivy.is_native_array also + applies to this method with minimal changes. Parameters ---------- @@ -139,9 +140,10 @@ def _static_is_ivy_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.is_ivy_array. This method - simply wraps the function, and so the docstring for ivy.is_ivy_array - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.is_ivy_array. This method simply + wraps the function, and so the docstring for ivy.is_ivy_array also applies to + this method with minimal changes. Parameters ---------- @@ -195,10 +197,10 @@ def is_ivy_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.is_native_array. This - method simply wraps the function, and so the docstring for - ivy.ivy.is_native_array also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.is_native_array. This method simply + wraps the function, and so the docstring for ivy.ivy.is_native_array also + applies to this method with minimal changes. Parameters ---------- @@ -252,9 +254,10 @@ def _static_is_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.is_array. This method - simply wraps the function, and so the docstring for ivy.ivy.is_array - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.is_array. This method simply wraps + the function, and so the docstring for ivy.ivy.is_array also applies to this + method with minimal changes. Parameters ---------- @@ -313,9 +316,10 @@ def is_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.is_array. This method - simply wraps the function, and so the docstring for ivy.is_array also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.is_array. This method simply wraps + the function, and so the docstring for ivy.is_array also applies to this method + with minimal changes. Parameters ---------- @@ -373,9 +377,10 @@ def _static_clip_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.clip_vector_norm. This - method simply wraps the function, and so the docstring for - ivy.clip_vector_norm also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.clip_vector_norm. This method + simply wraps the function, and so the docstring for ivy.clip_vector_norm also + applies to this method with minimal changes. Parameters ---------- @@ -444,9 +449,10 @@ def clip_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.clip_vector_norm. This - method simply wraps the function, and so the docstring for - ivy.clip_vector_norm also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.clip_vector_norm. This method + simply wraps the function, and so the docstring for ivy.clip_vector_norm also + applies to this method with minimal changes. Parameters ---------- @@ -517,9 +523,10 @@ def _static_inplace_update( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.inplace_update. This - method simply wraps the function, and so the docstring for - ivy.inplace_update also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.inplace_update. This method simply + wraps the function, and so the docstring for ivy.inplace_update also applies to + this method with minimal changes. Parameters ---------- @@ -585,9 +592,10 @@ def inplace_update( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.inplace_update. This - method simply wraps the function, and so the docstring for - ivy.inplace_update also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.inplace_update. This method simply + wraps the function, and so the docstring for ivy.inplace_update also applies to + this method with minimal changes. Parameters ---------- @@ -658,9 +666,10 @@ def _static_inplace_decrement( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.inplace_decrement. This - method simply wraps the function, and so the docstring for - ivy.inplace_decrement also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.inplace_decrement. This method simply + wraps the function, and so the docstring for ivy.inplace_decrement also applies + to this method with minimal changes. Parameters ---------- @@ -737,9 +746,10 @@ def inplace_decrement( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.inplace_decrement. This - method simply wraps the function, and so the docstring for - ivy.inplace_decrement also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.inplace_decrement. This method + simply wraps the function, and so the docstring for ivy.inplace_decrement also + applies to this method with minimal changes. Parameters ---------- @@ -798,9 +808,10 @@ def _static_inplace_increment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.inplace_increment. This - method simply wraps the function, and so the docstring for - ivy.inplace_increment also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.inplace_increment. This method simply + wraps the function, and so the docstring for ivy.inplace_increment also applies + to this method with minimal changes. Parameters ---------- @@ -877,9 +888,10 @@ def inplace_increment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.inplace_increment. This - method wraps the function, and so the docstring for - ivy.inplace_increment also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.inplace_increment. This method + wraps the function, and so the docstring for ivy.inplace_increment also applies + to this method with minimal changes. Parameters ---------- @@ -937,10 +949,10 @@ def _static_assert_supports_inplace( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.assert_supports_inplace. - This method simply wraps the function, and so the docstring for - ivy.assert_supports_inplace also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.assert_supports_inplace. This method + simply wraps the function, and so the docstring for ivy.assert_supports_inplace + also applies to this method with minimal changes. Parameters ---------- @@ -981,10 +993,10 @@ def assert_supports_inplace( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of - ivy.assert_supports_inplace. This method simply wraps the function, and - so the docstring for ivy.assert_supports_inplace also applies to this - method with minimal changes. + """ + ivy.Container instance method variant of ivy.assert_supports_inplace. This + method simply wraps the function, and so the docstring for + ivy.assert_supports_inplace also applies to this method with minimal changes. Parameters ---------- @@ -1036,9 +1048,10 @@ def _static_all_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.all_equal. This method - simply wraps the function, and so the docstring for ivy.all_equal also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.all_equal. This method simply wraps + the function, and so the docstring for ivy.all_equal also applies to this method + with minimal changes. Parameters ---------- @@ -1113,9 +1126,10 @@ def all_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.all_equal. This method - simply wraps the function, and so the docstring for ivy.all_equal also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.all_equal. This method simply wraps + the function, and so the docstring for ivy.all_equal also applies to this method + with minimal changes. Parameters ---------- @@ -1214,9 +1228,10 @@ def _static_fourier_encode( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.fourier_encode. This - method simply wraps the function, and so the docstring for - ivy.fourier_encode also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.fourier_encode. This method simply + wraps the function, and so the docstring for ivy.fourier_encode also applies to + this method with minimal changes. Parameters ---------- @@ -1305,9 +1320,10 @@ def fourier_encode( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.fourier_encode. This - method simply wraps the function, and so the docstring for - ivy.fourier_encode also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.fourier_encode. This method simply + wraps the function, and so the docstring for ivy.fourier_encode also applies to + this method with minimal changes. Parameters ---------- @@ -1393,9 +1409,10 @@ def _static_gather( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.gather. This method - simply wraps the function, and so the docstring for ivy.gather also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.gather. This method simply wraps the + function, and so the docstring for ivy.gather also applies to this method with + minimal changes. Parameters ---------- @@ -1482,9 +1499,10 @@ def gather( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.gather. This method - simply wraps the function, and so the docstring for ivy.gather also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.gather. This method simply wraps + the function, and so the docstring for ivy.gather also applies to this method + with minimal changes. Parameters ---------- @@ -1668,9 +1686,10 @@ def _static_scatter_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.scatter_nd. This method - simply wraps the function, and so the docstring for ivy.scatter_nd also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.scatter_nd. This method simply wraps + the function, and so the docstring for ivy.scatter_nd also applies to this + method with minimal changes. Parameters ---------- @@ -1763,9 +1782,10 @@ def scatter_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.scatter_nd. This method - simply wraps the function, and so the docstring for ivy.scatter_nd also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.scatter_nd. This method simply + wraps the function, and so the docstring for ivy.scatter_nd also applies to this + method with minimal changes. Parameters ---------- @@ -1857,9 +1877,10 @@ def _static_scatter_flat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.scatter_flat. This method - simply wraps the function, and so the docstring for ivy.scatter_flat - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.scatter_flat. This method simply + wraps the function, and so the docstring for ivy.scatter_flat also applies to + this method with minimal changes. Parameters ---------- @@ -1919,9 +1940,10 @@ def scatter_flat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.scatter_flat. This - method simply wraps the function, and so the docstring for - ivy.scatter_flat also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.scatter_flat. This method simply + wraps the function, and so the docstring for ivy.scatter_flat also applies to + this method with minimal changes. Parameters ---------- @@ -1994,8 +2016,9 @@ def _static_gather_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Gather slices from all container params into a arrays with shape - specified by indices. + """ + Gather slices from all container params into a arrays with shape specified by + indices. Parameters ---------- @@ -2060,9 +2083,10 @@ def gather_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.gather_nd. This method - simply wraps the function, and so the docstring for ivy.gather_nd also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.gather_nd. This method simply wraps + the function, and so the docstring for ivy.gather_nd also applies to this method + with minimal changes. Parameters ---------- @@ -2133,7 +2157,8 @@ def _static_einops_reduce( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """Perform einops reduce operation on each sub array in the container. + """ + Perform einops reduce operation on each sub array in the container. Parameters ---------- @@ -2204,9 +2229,10 @@ def einops_reduce( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ivy.Container instance method variant of ivy.einops_reduce. This - method simply wraps the function, and so the docstring for - ivy.einops_reduce also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.einops_reduce. This method simply + wraps the function, and so the docstring for ivy.einops_reduce also applies to + this method with minimal changes. Parameters ---------- @@ -2286,7 +2312,8 @@ def _static_einops_repeat( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """Perform einops repeat operation on each sub array in the container. + """ + Perform einops repeat operation on each sub array in the container. Parameters ---------- @@ -2355,9 +2382,10 @@ def einops_repeat( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ivy.Container instance method variant of ivy.einops_repeat. This - method simply wraps the function, and so the docstring for - ivy.einops_repeat also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.einops_repeat. This method simply + wraps the function, and so the docstring for ivy.einops_repeat also applies to + this method with minimal changes. Parameters ---------- @@ -2422,9 +2450,10 @@ def _static_value_is_nan( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.value_is_nan. This method - simply wraps the function, and so the docstring for ivy.value_is_nan - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.value_is_nan. This method simply + wraps the function, and so the docstring for ivy.value_is_nan also applies to + this method with minimal changes. Parameters ---------- @@ -2502,9 +2531,10 @@ def value_is_nan( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.value_is_nan. This - method simply wraps the function, and so the docstring for - ivy.value_is_nan also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.value_is_nan. This method simply + wraps the function, and so the docstring for ivy.value_is_nan also applies to + this method with minimal changes. Parameters ---------- @@ -2576,9 +2606,10 @@ def _static_to_numpy( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.to_numpy. This method - simply wraps the function, and so the docstring for ivy.to_numpy also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.to_numpy. This method simply wraps + the function, and so the docstring for ivy.to_numpy also applies to this method + with minimal changes. Parameters ---------- @@ -2646,9 +2677,10 @@ def to_numpy( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.to_numpy. This method - simply wraps the function, and so the docstring for ivy.to_numpy also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.to_numpy. This method simply wraps + the function, and so the docstring for ivy.to_numpy also applies to this method + with minimal changes. Parameters ---------- @@ -2718,9 +2750,10 @@ def _static_to_scalar( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.to_scalar. This method - simply wraps the function, and so the docstring for ivy.to_scalar also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.to_scalar. This method simply wraps + the function, and so the docstring for ivy.to_scalar also applies to this method + with minimal changes. Parameters ---------- @@ -2774,9 +2807,10 @@ def to_scalar( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.to_scalar. This method - simply wraps the function, and so the docstring for ivy.to_scalar also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.to_scalar. This method simply wraps + the function, and so the docstring for ivy.to_scalar also applies to this method + with minimal changes. Parameters ---------- @@ -2833,9 +2867,10 @@ def _static_to_list( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.to_list. This method - simply wraps the function, and so the docstring for ivy.to_list also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.to_list. This method simply wraps the + function, and so the docstring for ivy.to_list also applies to this method with + minimal changes. Parameters ---------- @@ -2885,9 +2920,10 @@ def to_list( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.to_list. This method - simply wraps the function, and so the docstring for ivy.to_list also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.to_list. This method simply wraps + the function, and so the docstring for ivy.to_list also applies to this method + with minimal changes. Parameters ---------- @@ -2942,9 +2978,10 @@ def _static_stable_divide( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.stable_divide. This - method simply wraps the function, and so the docstring for - ivy.stable_divide also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.stable_divide. This method simply + wraps the function, and so the docstring for ivy.stable_divide also applies to + this method with minimal changes. Parameters ---------- @@ -3045,9 +3082,10 @@ def stable_divide( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.stable_divide. This - method simply wraps the function, and so the docstring for - ivy.stable_divide also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.stable_divide. This method simply + wraps the function, and so the docstring for ivy.stable_divide also applies to + this method with minimal changes. Parameters ---------- @@ -3130,9 +3168,10 @@ def _static_stable_pow( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.stable_pow. This method - simply wraps the function, and so the docstring for ivy.stable_pow also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.stable_pow. This method simply wraps + the function, and so the docstring for ivy.stable_pow also applies to this + method with minimal changes. Parameters ---------- @@ -3218,9 +3257,10 @@ def stable_pow( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.stable_pow. This method - simply wraps the function, and so the docstring for ivy.stable_pow also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.stable_pow. This method simply + wraps the function, and so the docstring for ivy.stable_pow also applies to this + method with minimal changes. Parameters ---------- @@ -3307,9 +3347,10 @@ def _static_einops_rearrange( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ivy.Container static method variant of ivy.einops_rearrange. This - method simply wraps the function, and so the docstring for - ivy.einops_rearrange also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.einops_rearrange. This method simply + wraps the function, and so the docstring for ivy.einops_rearrange also applies + to this method with minimal changes. Parameters ---------- @@ -3394,9 +3435,10 @@ def einops_rearrange( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ): - """ivy.Container instance method variant of ivy.einops_rearrange. This - method simply wraps the function, and so the docstring for - ivy.einops_rearrange also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.einops_rearrange. This method + simply wraps the function, and so the docstring for ivy.einops_rearrange also + applies to this method with minimal changes. Parameters ---------- @@ -3481,9 +3523,10 @@ def _static_clip_matrix_norm( p: Union[float, ivy.Container] = 2.0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.clip_matrix_norm. This - method simply wraps the function, and so the docstring for - ivy.clip_matrix_norm also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.clip_matrix_norm. This method simply + wraps the function, and so the docstring for ivy.clip_matrix_norm also applies + to this method with minimal changes. Parameters ---------- @@ -3550,9 +3593,10 @@ def clip_matrix_norm( p: Union[float, ivy.Container] = 2.0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.clip_matrix_norm. This - method simply wraps the function, and so the docstring for - ivy.clip_matrix_norm also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.clip_matrix_norm. This method + simply wraps the function, and so the docstring for ivy.clip_matrix_norm also + applies to this method with minimal changes. Parameters ---------- @@ -3616,10 +3660,10 @@ def _static_supports_inplace_updates( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.supports_inplace_updates. - This method simply wraps the function, and so the docstring for - ivy.supports_inplace_updates also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.supports_inplace_updates. This method + simply wraps the function, and so the docstring for ivy.supports_inplace_updates + also applies to this method with minimal changes. Parameters ---------- @@ -3663,10 +3707,10 @@ def supports_inplace_updates( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of - ivy.supports_inplace_updates. This method simply wraps the static - function, and so the docstring for the static variant also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.supports_inplace_updates. This + method simply wraps the static function, and so the docstring for the static + variant also applies to this method with minimal changes. Parameters ---------- @@ -3733,9 +3777,10 @@ def _static_get_num_dims( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.get_num_dims. This - method simply wraps the function, and so the docstring for - ivy.get_num_dims also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.get_num_dims. This method simply + wraps the function, and so the docstring for ivy.get_num_dims also applies to + this method with minimal changes. Parameters ---------- @@ -3809,9 +3854,10 @@ def get_num_dims( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.get_num_dims. This - method simply wraps the function, and so the docstring for - ivy.get_num_dims also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.get_num_dims. This method simply + wraps the function, and so the docstring for ivy.get_num_dims also applies to + this method with minimal changes. Parameters ---------- @@ -3885,9 +3931,10 @@ def _static_array_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.array_equal. This - method simply wraps the function, and so the docstring for - ivy.array_equal also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.array_equal. This method simply + wraps the function, and so the docstring for ivy.array_equal also applies to + this method with minimal changes. Parameters ---------- @@ -3949,9 +3996,10 @@ def array_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.array_equal. This - method simply wraps the function, and so the docstring for - ivy.array_equal also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.array_equal. This method simply + wraps the function, and so the docstring for ivy.array_equal also applies to + this method with minimal changes. Parameters ---------- @@ -4022,9 +4070,10 @@ def static_isin( assume_unique: Union[bool, ivy.Container] = False, invert: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """Container instance method variant of ivy.isin. This method simply - wraps the function, and so the docstring for ivy.isin also applies to - this method with minimal changes. + """ + Container instance method variant of ivy.isin. This method simply wraps the + function, and so the docstring for ivy.isin also applies to this method with + minimal changes. Parameters ---------- @@ -4071,9 +4120,10 @@ def isin( assume_unique: Union[bool, ivy.Container] = False, invert: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """Container instance method variant of ivy.isin. This method simply - wraps the function, and so the docstring for ivy.isin also applies to - this method with minimal changes. + """ + Container instance method variant of ivy.isin. This method simply wraps the + function, and so the docstring for ivy.isin also applies to this method with + minimal changes. Parameters ---------- @@ -4113,9 +4163,10 @@ def static_itemsize( x: ivy.Container, /, ) -> ivy.Container: - """Container instance method variant of ivy.itemsize. This method - simply wraps the function, and so the docstring for ivy.itemsize also - applies to this method with minimal changes. + """ + Container instance method variant of ivy.itemsize. This method simply wraps the + function, and so the docstring for ivy.itemsize also applies to this method with + minimal changes. Parameters ---------- @@ -4140,9 +4191,10 @@ def itemsize( self: ivy.Container, /, ) -> ivy.Container: - """Container instance method variant of ivy.itemsize. This method - simply wraps the function, and so the docstring for ivy.itemsize also - applies to this method with minimal changes. + """ + Container instance method variant of ivy.itemsize. This method simply wraps the + function, and so the docstring for ivy.itemsize also applies to this method with + minimal changes. Parameters ---------- @@ -4161,9 +4213,10 @@ def static_strides( x: ivy.Container, /, ) -> ivy.Container: - """Container instance method variant of ivy.strides. This method simply - wraps the function, and so the docstring for ivy.strides also applies - to this method with minimal changes. + """ + Container instance method variant of ivy.strides. This method simply wraps the + function, and so the docstring for ivy.strides also applies to this method with + minimal changes. Parameters ---------- @@ -4188,9 +4241,10 @@ def strides( self: ivy.Container, /, ) -> ivy.Container: - """Container instance method variant of ivy.strides. This method simply - wraps the function, and so the docstring for ivy.strides also applies - to this method with minimal changes. + """ + Container instance method variant of ivy.strides. This method simply wraps the + function, and so the docstring for ivy.strides also applies to this method with + minimal changes. Parameters ---------- @@ -4214,9 +4268,10 @@ def _static_exists( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.exists. This method - simply wraps the function, and so the docstring for ivy.exists also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.exists. This method simply wraps + the function, and so the docstring for ivy.exists also applies to this method + with minimal changes. Parameters ---------- @@ -4275,9 +4330,10 @@ def exists( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.exists. This method - simply wraps the function, and so the docstring for ivy.exists also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.exists. This method simply wraps + the function, and so the docstring for ivy.exists also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/gradients.py b/ivy/data_classes/container/gradients.py index a1848f648913f..94a51f311c380 100644 --- a/ivy/data_classes/container/gradients.py +++ b/ivy/data_classes/container/gradients.py @@ -19,9 +19,10 @@ def _static_stop_gradient( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.stop_gradient. This - method simply wraps the function, and so the docstring for - ivy.stop_gradient also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.stop_gradient. This method simply + wraps the function, and so the docstring for ivy.stop_gradient also applies to + this method with minimal changes. Parameters ---------- @@ -96,9 +97,10 @@ def stop_gradient( preserve_type: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.stop_gradient. This - method simply wraps the function, and so the docstring for - ivy.stop_gradient also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.stop_gradient. This method simply + wraps the function, and so the docstring for ivy.stop_gradient also applies to + this method with minimal changes. Parameters ---------- @@ -173,9 +175,10 @@ def adam_step( epsilon: Union[float, ivy.Container] = 1e-7, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.adam_step. This method - simply wraps the function, and so the docstring for ivy.adam_step also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.adam_step. This method simply wraps + the function, and so the docstring for ivy.adam_step also applies to this method + with minimal changes. Parameters ---------- @@ -268,8 +271,9 @@ def optimizer_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Update weights ws of some function, given the true or effective - derivatives of some cost c with respect to ws, [dc/dw for w in ws]. + """ + Update weights ws of some function, given the true or effective derivatives of + some cost c with respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -347,10 +351,10 @@ def gradient_descent_update( stop_gradients: Union[bool, ivy.Container] = True, out: ivy.Container = None, ) -> ivy.Container: - """ivy.Container instance method variant of - ivy.gradient_descent_update. This method simply wraps the function, and - so the docstring for ivy.gradient_descent_update also applies to this - method with minimal changes. + """ + ivy.Container instance method variant of ivy.gradient_descent_update. This + method simply wraps the function, and so the docstring for + ivy.gradient_descent_update also applies to this method with minimal changes. Parameters ---------- @@ -431,9 +435,10 @@ def lars_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """Update weights ws of some function, given the derivatives of some - cost c with respect to ws, [dc/dw for w in ws], by applying Layerwise - Adaptive Rate Scaling (LARS) method. + """ + Update weights ws of some function, given the derivatives of some cost c with + respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive Rate Scaling + (LARS) method. Parameters ---------- @@ -511,8 +516,9 @@ def adam_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Update weights ws of some function, given the derivatives of some - cost c with respect to ws, using ADAM update. `[reference] + """ + Update weights ws of some function, given the derivatives of some cost c with + respect to ws, using ADAM update. `[reference] `_ @@ -631,9 +637,9 @@ def lamb_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Update weights ws of some function, given the derivatives of some - cost c with respect to ws, [dc/dw for w in ws], by applying LAMB - method. + """ + Update weights ws of some function, given the derivatives of some cost c with + respect to ws, [dc/dw for w in ws], by applying LAMB method. Parameters ---------- diff --git a/ivy/data_classes/container/layers.py b/ivy/data_classes/container/layers.py index 6d3e681cfbf2d..aad198392b2e7 100644 --- a/ivy/data_classes/container/layers.py +++ b/ivy/data_classes/container/layers.py @@ -26,9 +26,10 @@ def _static_linear( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.linear. This method - simply wraps the function, and so the docstring for ivy.linear also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.linear. This method simply wraps the + function, and so the docstring for ivy.linear also applies to this method with + minimal changes. Parameters ---------- @@ -119,9 +120,10 @@ def linear( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.linear. This method - simply wraps the function, and so the docstring for ivy.linear also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.linear. This method simply wraps + the function, and so the docstring for ivy.linear also applies to this method + with minimal changes. Parameters ---------- @@ -201,9 +203,10 @@ def _static_dropout( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.dropout. This method - simply wraps the function, and so the docstring for ivy.dropout also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.dropout. This method simply wraps the + function, and so the docstring for ivy.dropout also applies to this method with + minimal changes. Parameters ---------- @@ -288,9 +291,10 @@ def dropout( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.dropout. This method - simply wraps the function, and so the docstring for ivy.dropout also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.dropout. This method simply wraps + the function, and so the docstring for ivy.dropout also applies to this method + with minimal changes. Parameters ---------- @@ -372,9 +376,10 @@ def _static_dropout1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.dropout1d. This method - simply wraps the function, and so the docstring for ivy.dropout1d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.dropout1d. This method simply wraps + the function, and so the docstring for ivy.dropout1d also applies to this method + with minimal changes. Parameters ---------- @@ -443,9 +448,10 @@ def dropout1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.dropout1d. This method - simply wraps the function, and so the docstring for ivy.dropout1d also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.dropout1d. This method simply wraps + the function, and so the docstring for ivy.dropout1d also applies to this method + with minimal changes. Parameters ---------- @@ -514,9 +520,10 @@ def _static_dropout2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.dropout2d. This method - simply wraps the function, and so the docstring for ivy.dropout2d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.dropout2d. This method simply wraps + the function, and so the docstring for ivy.dropout2d also applies to this method + with minimal changes. Parameters ---------- @@ -574,9 +581,10 @@ def dropout2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.dropout2d. This method - simply wraps the function, and so the docstring for ivy.dropout2d also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.dropout2d. This method simply wraps + the function, and so the docstring for ivy.dropout2d also applies to this method + with minimal changes. Parameters ---------- @@ -645,9 +653,10 @@ def _static_dropout3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.dropout3d. This method - simply wraps the function, and so the docstring for ivy.dropout3d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.dropout3d. This method simply wraps + the function, and so the docstring for ivy.dropout3d also applies to this method + with minimal changes. Parameters ---------- @@ -705,9 +714,10 @@ def dropout3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.dropout3d. This method - simply wraps the function, and so the docstring for ivy.dropout3d also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.dropout3d. This method simply wraps + the function, and so the docstring for ivy.dropout3d also applies to this method + with minimal changes. Parameters ---------- @@ -769,10 +779,11 @@ def _static_scaled_dot_product_attention( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of - ivy.scaled_dot_product_attention. This method simply wraps the - function, and so the docstring for ivy.scaled_dot_product_attention - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.scaled_dot_product_attention. This + method simply wraps the function, and so the docstring for + ivy.scaled_dot_product_attention also applies to this method with minimal + changes. Parameters ---------- @@ -891,10 +902,11 @@ def scaled_dot_product_attention( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of - ivy.scaled_dot_product_attention. This method simply wraps the - function, and so the docstring for ivy.scaled_dot_product_attention - also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.scaled_dot_product_attention. This + method simply wraps the function, and so the docstring for + ivy.scaled_dot_product_attention also applies to this method with minimal + changes. Parameters ---------- @@ -1194,9 +1206,10 @@ def _static_conv1d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.conv1d. This method - simply wraps the function, and so the docstring for ivy.conv1d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.conv1d. This method simply wraps the + function, and so the docstring for ivy.conv1d also applies to this method with + minimal changes. Parameters ---------- @@ -1289,9 +1302,10 @@ def conv1d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.conv1d. This method - simply wraps the function, and so the docstring for ivy.conv1d also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.conv1d. This method simply wraps + the function, and so the docstring for ivy.conv1d also applies to this method + with minimal changes. Parameters ---------- @@ -1384,9 +1398,10 @@ def _static_conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.conv2d. This method - simply wraps the function, and so the docstring for ivy.conv2d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.conv2d. This method simply wraps the + function, and so the docstring for ivy.conv2d also applies to this method with + minimal changes. Parameters ---------- @@ -1473,9 +1488,10 @@ def conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of `ivy.conv2d`. This method - simply wraps the function, and so the docstring for `ivy.conv2d` also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of `ivy.conv2d`. This method simply wraps + the function, and so the docstring for `ivy.conv2d` also applies to this method + with minimal changes. Parameters ---------- @@ -1562,9 +1578,10 @@ def _static_conv1d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.conv1d_transpose. This - method simply wraps the function, and so the docstring for - ivy.conv1d_transpose also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.conv1d_transpose. This method simply + wraps the function, and so the docstring for ivy.conv1d_transpose also applies + to this method with minimal changes. Parameters ---------- @@ -1659,9 +1676,10 @@ def conv1d_transpose( bias: Optional[ivy.Container] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container]: - """ivy.Container instance method variant of ivy.conv1d_transpose. This - method simply wraps the function, and so the docstring for - ivy.conv1d_transpose also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.conv1d_transpose. This method + simply wraps the function, and so the docstring for ivy.conv1d_transpose also + applies to this method with minimal changes. Parameters ---------- @@ -1756,9 +1774,10 @@ def _static_conv2d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.conv2d_transpose. This - method simply wraps the function, and so the docstring for ivy.conv2d - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.conv2d_transpose. This method simply + wraps the function, and so the docstring for ivy.conv2d also applies to this + method with minimal changes. Parameters ---------- @@ -1859,9 +1878,10 @@ def conv2d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.conv2d_transpose. This - method simply wraps the function, and so the docstring for ivy.conv2d - also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.conv2d_transpose. This method + simply wraps the function, and so the docstring for ivy.conv2d also applies to + this method with minimal changes. Parameters ---------- @@ -1967,9 +1987,10 @@ def _static_depthwise_conv2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.depthwise_conv2d. This - method simply wraps the function, and so the docstring for - ivy.depthwise_conv2d also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.depthwise_conv2d. This method simply + wraps the function, and so the docstring for ivy.depthwise_conv2d also applies + to this method with minimal changes. Parameters ---------- @@ -2039,9 +2060,10 @@ def depthwise_conv2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.depthwise_conv2d. This - method simply wraps the function, and so the docstring for - ivy.depthwise_conv2d also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.depthwise_conv2d. This method + simply wraps the function, and so the docstring for ivy.depthwise_conv2d also + applies to this method with minimal changes. Parameters ---------- @@ -2110,9 +2132,10 @@ def _static_conv3d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.conv3d. This method - simply wraps the function, and so the docstring for ivy.conv3d also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.conv3d. This method simply wraps the + function, and so the docstring for ivy.conv3d also applies to this method with + minimal changes. Parameters ---------- @@ -2194,9 +2217,10 @@ def conv3d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.conv3d. This method - simply wraps the function, and so the docstring for ivy.conv3d also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.conv3d. This method simply wraps + the function, and so the docstring for ivy.conv3d also applies to this method + with minimal changes. Parameters ---------- @@ -2280,9 +2304,10 @@ def _static_conv3d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.conv3d_transpose. This - method simply wraps the function, and so the docstring for - ivy.conv3d_transpose also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.conv3d_transpose. This method simply + wraps the function, and so the docstring for ivy.conv3d_transpose also applies + to this method with minimal changes. Parameters ---------- @@ -2377,9 +2402,10 @@ def conv3d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.conv3d_transpose. This - method simply wraps the function, and so the docstring for - ivy.conv3d_transpose also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.conv3d_transpose. This method + simply wraps the function, and so the docstring for ivy.conv3d_transpose also + applies to this method with minimal changes. Parameters ---------- @@ -2501,9 +2527,10 @@ def lstm_update( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container instance method variant of ivy.lstm_update. This - method simply wraps the function, and so the docstring for - ivy.lstm_update also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.lstm_update. This method simply + wraps the function, and so the docstring for ivy.lstm_update also applies to + this method with minimal changes. Parameters ---------- @@ -2606,9 +2633,10 @@ def reduce_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.reduce_window. This - method simply wraps the function, and so the docstring for - ivy.reduce_window also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.reduce_window. This method simply + wraps the function, and so the docstring for ivy.reduce_window also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/linear_algebra.py b/ivy/data_classes/container/linear_algebra.py index 464b7be1fff7e..20a30dc92b22e 100644 --- a/ivy/data_classes/container/linear_algebra.py +++ b/ivy/data_classes/container/linear_algebra.py @@ -30,9 +30,10 @@ def _static_matmul( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.matmul. This method - simply wraps the function, and so the docstring for ivy.matul also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.matmul. This method simply wraps the + function, and so the docstring for ivy.matul also applies to this method with + minimal changes. Parameters ---------- @@ -103,9 +104,10 @@ def matmul( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.matmul. This method - simply wraps the function, and so the docstring for ivy.matmul also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.matmul. This method simply wraps + the function, and so the docstring for ivy.matmul also applies to this method + with minimal changes. Parameters ---------- @@ -172,9 +174,10 @@ def _static_cholesky( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cholesky. This method - simply wraps the function, and so the docstring for ivy.cholesky also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.cholesky. This method simply wraps + the function, and so the docstring for ivy.cholesky also applies to this method + with minimal changes. Parameters ---------- @@ -258,9 +261,10 @@ def cholesky( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cholesky. This method - simply wraps the function, and so the docstring for ivy.cholesky also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cholesky. This method simply wraps + the function, and so the docstring for ivy.cholesky also applies to this method + with minimal changes. Parameters ---------- @@ -332,9 +336,10 @@ def _static_cross( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cross. This method simply - wraps the function, and so the docstring for ivy.cross also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.cross. This method simply wraps the + function, and so the docstring for ivy.cross also applies to this method with + minimal changes. Parameters ---------- @@ -417,9 +422,10 @@ def cross( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cross. This method - simply wraps the function, and so the docstring for ivy.cross also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cross. This method simply wraps the + function, and so the docstring for ivy.cross also applies to this method with + minimal changes. Parameters ---------- @@ -539,9 +545,10 @@ def _static_diagonal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.diagonal. This method - simply wraps the function, and so the docstring for ivy.diagonal also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.diagonal. This method simply wraps + the function, and so the docstring for ivy.diagonal also applies to this method + with minimal changes. Parameters ---------- @@ -624,9 +631,10 @@ def diagonal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.diagonal. This method - simply wraps the function, and so the docstring for ivy.diagonal also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.diagonal. This method simply wraps + the function, and so the docstring for ivy.diagonal also applies to this method + with minimal changes. Parameters ---------- @@ -729,9 +737,10 @@ def diag( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.diag. This method - simply wraps the function, and so the docstring for ivy.diag also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.diag. This method simply wraps the + function, and so the docstring for ivy.diag also applies to this method with + minimal changes. Examples -------- @@ -787,9 +796,10 @@ def eigh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.eigh. This method - simply wraps the function, and so the docstring for ivy.eigh also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.eigh. This method simply wraps the + function, and so the docstring for ivy.eigh also applies to this method with + minimal changes. Parameters ---------- @@ -858,9 +868,10 @@ def _static_eigvalsh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.eigvalsh. This method - simply wraps the function, and so the docstring for ivy.eigvalsh also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.eigvalsh. This method simply wraps + the function, and so the docstring for ivy.eigvalsh also applies to this method + with minimal changes. Parameters ---------- @@ -927,9 +938,10 @@ def eigvalsh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.eigvalsh. This method - simply wraps the function, and so the docstring for ivy.eigvalsh also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.eigvalsh. This method simply wraps + the function, and so the docstring for ivy.eigvalsh also applies to this method + with minimal changes. Parameters ---------- @@ -994,9 +1006,10 @@ def _static_inner( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.inner. This method simply - wraps the function, and so the docstring for ivy.inner also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.inner. This method simply wraps the + function, and so the docstring for ivy.inner also applies to this method with + minimal changes. Return the inner product of two vectors ``x1`` and ``x2``. @@ -1066,9 +1079,10 @@ def inner( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.inner. This method - simply wraps the function, and so the docstring for ivy.inner also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.inner. This method simply wraps the + function, and so the docstring for ivy.inner also applies to this method with + minimal changes. Return the inner product of two vectors ``self`` and ``x2``. @@ -1136,9 +1150,10 @@ def _static_inv( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.inv. This method simply - wraps the function, and so the docstring for ivy.inv also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.inv. This method simply wraps the + function, and so the docstring for ivy.inv also applies to this method with + minimal changes. Parameters ---------- @@ -1204,9 +1219,10 @@ def inv( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.inv. This method simply - wraps the function, and so the docstring for ivy.inv also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.inv. This method simply wraps the + function, and so the docstring for ivy.inv also applies to this method with + minimal changes. Parameters ---------- @@ -1268,9 +1284,10 @@ def _static_pinv( rtol: Optional[Union[float, Tuple[float], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container special method variant of ivy.pinv. This method simply - wraps the function, and so the docstring for ivy.pinv also applies to - this method with minimal changes. + """ + ivy.Container special method variant of ivy.pinv. This method simply wraps the + function, and so the docstring for ivy.pinv also applies to this method with + minimal changes. Parameters ---------- @@ -1326,9 +1343,10 @@ def pinv( rtol: Optional[Union[float, Tuple[float], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.pinv. This method - simply wraps the function, and so the docstring for ivy.pinv also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.pinv. This method simply wraps the + function, and so the docstring for ivy.pinv also applies to this method with + minimal changes. Parameters ---------- @@ -1391,9 +1409,10 @@ def _static_matrix_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.matrix_norm. This method - simply wraps the function, and so the docstring for ivy.matrix_norm - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.matrix_norm. This method simply wraps + the function, and so the docstring for ivy.matrix_norm also applies to this + method with minimal changes. Parameters ---------- @@ -1478,9 +1497,10 @@ def matrix_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.matrix_norm. This - method simply wraps the function, and so the docstring for - ivy.matrix_norm also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.matrix_norm. This method simply + wraps the function, and so the docstring for ivy.matrix_norm also applies to + this method with minimal changes. Parameters ---------- @@ -1610,9 +1630,10 @@ def _static_matrix_rank( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.matrix_rank. This method - returns the rank (i.e., number of non-zero singular values) of a matrix - (or a stack of matrices). + """ + ivy.Container static method variant of ivy.matrix_rank. This method returns the + rank (i.e., number of non-zero singular values) of a matrix (or a stack of + matrices). Parameters ---------- @@ -1704,9 +1725,10 @@ def matrix_rank( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.matrix_rank. This - method returns the rank (i.e., number of non-zero singular values) of a - matrix (or a stack of matrices). + """ + ivy.Container instance method variant of ivy.matrix_rank. This method returns + the rank (i.e., number of non-zero singular values) of a matrix (or a stack of + matrices). Parameters ---------- @@ -1793,7 +1815,8 @@ def _static_matrix_transpose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Transpose a matrix (or a stack of matrices) ``x``. + """ + Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1849,7 +1872,8 @@ def matrix_transpose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Transpose a matrix (or a stack of matrices) ``x``. + """ + Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1904,9 +1928,10 @@ def _static_outer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.outer. This method simply - wraps the function, and so the docstring for ivy.outer also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.outer. This method simply wraps the + function, and so the docstring for ivy.outer also applies to this method with + minimal changes. Computes the outer product of two arrays, x1 and x2, by computing the tensor product along the last dimension of both arrays. @@ -1978,7 +2003,8 @@ def outer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """Return the outer product of two arrays or containers. + """ + Return the outer product of two arrays or containers. The instance method implementation of the static method static_outer of the ivy.Container class. It calculates the outer product of two input arrays or @@ -2050,9 +2076,10 @@ def _static_qr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container static method variant of ivy.qr. This method simply - wraps the function, and so the docstring for ivy.qr also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.qr. This method simply wraps the + function, and so the docstring for ivy.qr also applies to this method with + minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -2145,9 +2172,10 @@ def qr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ivy.Container instance method variant of ivy.qr. This method simply - wraps the function, and so the docstring for ivy.qr also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.qr. This method simply wraps the + function, and so the docstring for ivy.qr also applies to this method with + minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -2238,9 +2266,10 @@ def _static_slogdet( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.slogdet. This method - simply wraps the function, and so the docstring for ivy.slogdet also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.slogdet. This method simply wraps the + function, and so the docstring for ivy.slogdet also applies to this method with + minimal changes. Parameters ---------- @@ -2309,9 +2338,10 @@ def slogdet( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.slogdet. This method - simply wraps the function, and so the docstring for ivy.slogdet also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.slogdet. This method simply wraps + the function, and so the docstring for ivy.slogdet also applies to this method + with minimal changes. Parameters ---------- @@ -2428,9 +2458,10 @@ def _static_svd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> Union[ivy.Container, Tuple[ivy.Container, ...]]: - """ivy.Container static method variant of ivy.svd. This method simply - wraps the function, and so the docstring for ivy.svd also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.svd. This method simply wraps the + function, and so the docstring for ivy.svd also applies to this method with + minimal changes. Parameters ---------- @@ -2500,9 +2531,10 @@ def svd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.svd. This method simply - wraps the function, and so the docstring for ivy.svd also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.svd. This method simply wraps the + function, and so the docstring for ivy.svd also applies to this method with + minimal changes. Parameters ---------- @@ -2717,9 +2749,9 @@ def _static_trace( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.trace. This method - Returns the sum along the specified diagonals of a matrix (or a stack - of matrices). + """ + ivy.Container static method variant of ivy.trace. This method Returns the sum + along the specified diagonals of a matrix (or a stack of matrices). Parameters ---------- @@ -2810,9 +2842,9 @@ def trace( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.trace. This method - Returns the sum along the specified diagonals of a matrix (or a stack - of matrices). + """ + ivy.Container instance method variant of ivy.trace. This method Returns the sum + along the specified diagonals of a matrix (or a stack of matrices). Parameters ---------- @@ -2951,9 +2983,10 @@ def _static_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.vector_norm. This method - simply wraps the function, and so the docstring for ivy.vector_norm - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.vector_norm. This method simply wraps + the function, and so the docstring for ivy.vector_norm also applies to this + method with minimal changes. Parameters ---------- @@ -3065,9 +3098,10 @@ def vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - r"""ivy.Container instance method variant of ivy.vector_norm. This - method simply wraps the function, and so the docstring for - ivy.vector_norm also applies to this method with minimal changes. + r""" + ivy.Container instance method variant of ivy.vector_norm. This method simply + wraps the function, and so the docstring for ivy.vector_norm also applies to + this method with minimal changes. Parameters ---------- @@ -3215,9 +3249,10 @@ def _static_vander( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.vander. This method - simply wraps the function, and so the docstring for ivy.vander also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.vander. This method simply wraps the + function, and so the docstring for ivy.vander also applies to this method with + minimal changes. Parameters ---------- @@ -3282,8 +3317,9 @@ def vander( increasing: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.vander. This method - Returns the Vandermonde matrix of the input array. + """ + ivy.Container instance method variant of ivy.vander. This method Returns the + Vandermonde matrix of the input array. Parameters ---------- @@ -3348,10 +3384,10 @@ def static_general_inner_product( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.general_inner_product. - This method simply wraps the function, and so the docstring for - ivy.general_inner_product also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.general_inner_product. This method + simply wraps the function, and so the docstring for ivy.general_inner_product + also applies to this method with minimal changes. Parameters ---------- @@ -3420,7 +3456,8 @@ def general_inner_product( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.general_inner_product. + """ + ivy.Container instance method variant of ivy.general_inner_product. This method simply wraps the function, and so the docstring for ivy.general_inner_product also applies to this method with diff --git a/ivy/data_classes/container/losses.py b/ivy/data_classes/container/losses.py index 60dff4e8e4d2a..4f3b65b47a39f 100644 --- a/ivy/data_classes/container/losses.py +++ b/ivy/data_classes/container/losses.py @@ -22,9 +22,10 @@ def _static_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cross_entropy. This - method simply wraps the function, and so the docstring for - ivy.cross_entropy also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.cross_entropy. This method simply + wraps the function, and so the docstring for ivy.cross_entropy also applies to + this method with minimal changes. Parameters ---------- @@ -112,9 +113,10 @@ def cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cross_entropy. This - method simply wraps the function, and so the docstring for - ivy.cross_entropy also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cross_entropy. This method simply + wraps the function, and so the docstring for ivy.cross_entropy also applies to + this method with minimal changes. Parameters ---------- @@ -191,10 +193,10 @@ def _static_binary_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.binary_cross_entropy. - This method simply wraps the function, and so the docstring for - ivy.binary_cross_entropy also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.binary_cross_entropy. This method + simply wraps the function, and so the docstring for ivy.binary_cross_entropy + also applies to this method with minimal changes. Parameters ---------- @@ -293,10 +295,10 @@ def binary_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.binary_cross_entropy. - This method simply wraps the function, and so the docstring for - ivy.binary_cross_entropy also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.binary_cross_entropy. This method + simply wraps the function, and so the docstring for ivy.binary_cross_entropy + also applies to this method with minimal changes. Parameters ---------- @@ -382,10 +384,10 @@ def _static_sparse_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sparse_cross_entropy. - This method simply wraps the function, and so the docstring for - ivy.sparse_cross_entropy also applies to this method with minimal - changes. + """ + ivy.Container static method variant of ivy.sparse_cross_entropy. This method + simply wraps the function, and so the docstring for ivy.sparse_cross_entropy + also applies to this method with minimal changes. Parameters ---------- @@ -472,10 +474,10 @@ def sparse_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sparse_cross_entropy. - This method simply wraps the function, and so the docstring for - ivy.sparse_cross_entropy also applies to this method with minimal - changes. + """ + ivy.Container instance method variant of ivy.sparse_cross_entropy. This method + simply wraps the function, and so the docstring for ivy.sparse_cross_entropy + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/manipulation.py b/ivy/data_classes/container/manipulation.py index 2b22319bacb04..6a2f768bac8d2 100644 --- a/ivy/data_classes/container/manipulation.py +++ b/ivy/data_classes/container/manipulation.py @@ -32,7 +32,8 @@ def _static_concat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.concat. + """ + ivy.Container static method variant of ivy.concat. This method simply wraps the function, and so the docstring for ivy.concat also applies to this method with minimal changes. @@ -63,7 +64,8 @@ def concat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.concat. + """ + ivy.Container instance method variant of ivy.concat. This method simply wraps the function, and so the docstring for ivy.concat also applies to this method with minimal changes. @@ -93,9 +95,10 @@ def _static_expand_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.expand_dims. This method - simply wraps the function, and so the docstring for ivy.expand_dims - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.expand_dims. This method simply wraps + the function, and so the docstring for ivy.expand_dims also applies to this + method with minimal changes. Parameters ---------- @@ -191,9 +194,10 @@ def expand_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.expand_dims. This - method simply wraps the function, and so the docstring for - ivy.expand_dims also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.expand_dims. This method simply + wraps the function, and so the docstring for ivy.expand_dims also applies to + this method with minimal changes. Parameters ---------- @@ -262,9 +266,10 @@ def _static_split( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container static method variant of ivy.split. This method simply - wraps the function, and so the docstring for ivy.split also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.split. This method simply wraps the + function, and so the docstring for ivy.split also applies to this method with + minimal changes. Parameters ---------- @@ -344,9 +349,10 @@ def split( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ivy.Container instance method variant of ivy.split. This method - simply wraps the function, and so the docstring for ivy.split also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.split. This method simply wraps the + function, and so the docstring for ivy.split also applies to this method with + minimal changes. Parameters ---------- @@ -423,9 +429,10 @@ def _static_permute_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.permute_dims. This method - simply wraps the function, and so the docstring for ivy.permute_dims - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.permute_dims. This method simply + wraps the function, and so the docstring for ivy.permute_dims also applies to + this method with minimal changes. Parameters ---------- @@ -484,9 +491,10 @@ def permute_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.permute_dims. This - method simply wraps the function, and so the docstring for - ivy.permute_dims also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.permute_dims. This method simply + wraps the function, and so the docstring for ivy.permute_dims also applies to + this method with minimal changes. Parameters ---------- @@ -545,9 +553,10 @@ def _static_flip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.flip. This method simply - wraps the function, and so the docstring for ivy.flip also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.flip. This method simply wraps the + function, and so the docstring for ivy.flip also applies to this method with + minimal changes. Parameters ---------- @@ -631,9 +640,10 @@ def flip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.flip. This method - simply wraps the function, and so the docstring for ivy.flip also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.flip. This method simply wraps the + function, and so the docstring for ivy.flip also applies to this method with + minimal changes. Parameters ---------- @@ -719,9 +729,10 @@ def _static_reshape( order: Union[str, ivy.Container] = "C", allowzero: Union[bool, ivy.Container] = True, ) -> ivy.Container: - """ivy.Container static method variant of ivy.reshape. This method - simply wraps the function, and so the docstring for ivy.reshape also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.reshape. This method simply wraps the + function, and so the docstring for ivy.reshape also applies to this method with + minimal changes. Parameters ---------- @@ -836,9 +847,10 @@ def reshape( allowzero: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.reshape. This method - simply wraps the function, and so the docstring for ivy.reshape also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.reshape. This method simply wraps + the function, and so the docstring for ivy.reshape also applies to this method + with minimal changes. Parameters ---------- @@ -944,9 +956,10 @@ def _static_roll( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.roll. This method simply - wraps the function, and so the docstring for ivy.roll also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.roll. This method simply wraps the + function, and so the docstring for ivy.roll also applies to this method with + minimal changes. Parameters ---------- @@ -1035,9 +1048,10 @@ def roll( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.roll. This method - simply wraps the function, and so the docstring for ivy.roll also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.roll. This method simply wraps the + function, and so the docstring for ivy.roll also applies to this method with + minimal changes. Parameters ---------- @@ -1111,9 +1125,10 @@ def _static_squeeze( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.squeeze. This method - simply wraps the function, and so the docstring for ivy.squeeze also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.squeeze. This method simply wraps the + function, and so the docstring for ivy.squeeze also applies to this method with + minimal changes. Parameters ---------- @@ -1192,9 +1207,10 @@ def squeeze( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.squeeze. This method - simply wraps the function, and so the docstring for ivy.squeeze also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.squeeze. This method simply wraps + the function, and so the docstring for ivy.squeeze also applies to this method + with minimal changes. Parameters ---------- @@ -1277,9 +1293,10 @@ def _static_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.stack. This method simply - wraps the function, and so the docstring for ivy.stack also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.stack also applies to this method with + minimal changes. Parameters ---------- @@ -1373,9 +1390,10 @@ def stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.stack. This method - simply wraps the function, and so the docstring for ivy.stack also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.stack. This method simply wraps the + function, and so the docstring for ivy.stack also applies to this method with + minimal changes. Parameters ---------- @@ -1447,9 +1465,10 @@ def _static_repeat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.repeat. This method - simply wraps the function, and so the docstring for ivy.repeat also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.repeat. This method simply wraps the + function, and so the docstring for ivy.repeat also applies to this method with + minimal changes. Examples -------- @@ -1485,9 +1504,10 @@ def repeat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.repeat. This method - simply wraps the function, and so the docstring for ivy.repeat also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.repeat. This method simply wraps + the function, and so the docstring for ivy.repeat also applies to this method + with minimal changes. Parameters ---------- @@ -1541,9 +1561,10 @@ def _static_tile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.tile. This method simply - wraps the function, and so the docstring for ivy.tile also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.tile. This method simply wraps the + function, and so the docstring for ivy.tile also applies to this method with + minimal changes. Parameters ---------- @@ -1596,9 +1617,10 @@ def tile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.tile. This method - simply wraps the function, and so the docstring for ivy.tile also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.tile. This method simply wraps the + function, and so the docstring for ivy.tile also applies to this method with + minimal changes. Parameters ---------- @@ -1648,9 +1670,10 @@ def _static_constant_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.constant_pad. This method - simply wraps the function, and so the docstring for ivy.constant_pad - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.constant_pad. This method simply + wraps the function, and so the docstring for ivy.constant_pad also applies to + this method with minimal changes. Parameters ---------- @@ -1706,9 +1729,10 @@ def constant_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.constant_pad. This - method simply wraps the function, and so the docstring for - ivy.constant_pad also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.constant_pad. This method simply + wraps the function, and so the docstring for ivy.constant_pad also applies to + this method with minimal changes. Parameters ---------- @@ -1763,9 +1787,10 @@ def _static_zero_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.zero_pad. This method - simply wraps the function, and so the docstring for ivy.zero_pad also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.zero_pad. This method simply wraps + the function, and so the docstring for ivy.zero_pad also applies to this method + with minimal changes. Parameters ---------- @@ -1829,9 +1854,10 @@ def zero_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.zero_pad. This method - simply wraps the function, and so the docstring for ivy.zero_pad also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.zero_pad. This method simply wraps + the function, and so the docstring for ivy.zero_pad also applies to this method + with minimal changes. Parameters ---------- @@ -1897,9 +1923,10 @@ def _static_swapaxes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.swapaxes. This method - simply wraps the function, and so the docstring for ivy.swapaxes also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.swapaxes. This method simply wraps + the function, and so the docstring for ivy.swapaxes also applies to this method + with minimal changes. Parameters ---------- @@ -1965,9 +1992,10 @@ def swapaxes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.swapaxes. This method - simply wraps the function, and so the docstring for ivy.swapaxes also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.swapaxes. This method simply wraps + the function, and so the docstring for ivy.swapaxes also applies to this method + with minimal changes. Parameters ---------- @@ -2034,9 +2062,10 @@ def _static_unstack( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.unstack. This method - simply wraps the function, and so the docstring for ivy.unstack also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.unstack. This method simply wraps the + function, and so the docstring for ivy.unstack also applies to this method with + minimal changes. Parameters ---------- @@ -2131,9 +2160,10 @@ def unstack( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.unstack. This method - simply wraps the function, and so the docstring for ivy.unstack also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.unstack. This method simply wraps + the function, and so the docstring for ivy.unstack also applies to this method + with minimal changes. Parameters ---------- @@ -2214,9 +2244,10 @@ def _static_clip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.clip. This method simply - wraps the function, and so the docstring for ivy.clip also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.clip. This method simply wraps the + function, and so the docstring for ivy.clip also applies to this method with + minimal changes. Parameters ---------- @@ -2301,9 +2332,10 @@ def clip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.clip. This method - simply wraps the function, and so the docstring for ivy.clip also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.clip. This method simply wraps the + function, and so the docstring for ivy.clip also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/norms.py b/ivy/data_classes/container/norms.py index 39369ceba4e38..948ff38dfbb94 100644 --- a/ivy/data_classes/container/norms.py +++ b/ivy/data_classes/container/norms.py @@ -21,9 +21,10 @@ def layer_norm( new_std: Union[float, ivy.Container] = 1.0, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.layer_norm. This method - simply wraps the function, and so the docstring for ivy.layer_norm also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.layer_norm. This method simply + wraps the function, and so the docstring for ivy.layer_norm also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/random.py b/ivy/data_classes/container/random.py index 2932594f3fc43..bb7aa8c69dcc6 100644 --- a/ivy/data_classes/container/random.py +++ b/ivy/data_classes/container/random.py @@ -23,9 +23,10 @@ def _static_random_uniform( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.random_uniform. This - method simply wraps the function, and so the docstring for - ivy.random_uniform also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.random_uniform. This method simply + wraps the function, and so the docstring for ivy.random_uniform also applies to + this method with minimal changes. Parameters ---------- @@ -126,9 +127,10 @@ def random_uniform( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.random_uniform. This - method simply wraps the function, and so the docstring for - ivy.random_uniform also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.random_uniform. This method simply + wraps the function, and so the docstring for ivy.random_uniform also applies to + this method with minimal changes. Parameters ---------- @@ -312,9 +314,10 @@ def _static_random_normal( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.random_normal. This - method simply wraps the function, and so the docstring for - ivy.random_normal also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.random_normal. This method simply + wraps the function, and so the docstring for ivy.random_normal also applies to + this method with minimal changes. Parameters ---------- @@ -413,9 +416,10 @@ def random_normal( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.random_normal. This - method simply wraps the function, and so the docstring for - ivy.random_normal also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.random_normal. This method simply + wraps the function, and so the docstring for ivy.random_normal also applies to + this method with minimal changes. Parameters ---------- @@ -600,9 +604,10 @@ def _static_multinomial( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.multinomial. This method - simply wraps the function, and so the docstring for ivy.multinomial - also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.multinomial. This method simply wraps + the function, and so the docstring for ivy.multinomial also applies to this + method with minimal changes. Parameters ---------- @@ -674,9 +679,10 @@ def multinomial( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.multinomial. This - method simply wraps the function, and so the docstring for - ivy.multinomial also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.multinomial. This method simply + wraps the function, and so the docstring for ivy.multinomial also applies to + this method with minimal changes. Parameters ---------- @@ -747,9 +753,10 @@ def _static_randint( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.randint. This method - simply wraps the function, and so the docstring for ivy.randint also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.randint. This method simply wraps the + function, and so the docstring for ivy.randint also applies to this method with + minimal changes. Parameters ---------- @@ -847,9 +854,10 @@ def randint( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.randint. This method - simply wraps the function, and so the docstring for ivy.randint also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.randint. This method simply wraps + the function, and so the docstring for ivy.randint also applies to this method + with minimal changes. Parameters ---------- @@ -1030,9 +1038,10 @@ def _static_shuffle( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.shuffle. This method - simply wraps the function, and so the docstring for ivy.shuffle also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.shuffle. This method simply wraps the + function, and so the docstring for ivy.shuffle also applies to this method with + minimal changes. Parameters ---------- @@ -1096,9 +1105,10 @@ def shuffle( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.shuffle. This method - simply wraps the function, and so the docstring for ivy.shuffle also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.shuffle. This method simply wraps + the function, and so the docstring for ivy.shuffle also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/searching.py b/ivy/data_classes/container/searching.py index d8ceb13e8910c..c007d1f67cc8e 100644 --- a/ivy/data_classes/container/searching.py +++ b/ivy/data_classes/container/searching.py @@ -20,9 +20,10 @@ def _static_argmax( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.argmax. This method - simply wraps the function, and so the docstring for ivy.argmax also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.argmax. This method simply wraps the + function, and so the docstring for ivy.argmax also applies to this method with + minimal changes. Parameters ---------- @@ -80,9 +81,10 @@ def argmax( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.argmax. This method - simply wraps the function, and so the docstring for ivy.argmax also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.argmax. This method simply wraps + the function, and so the docstring for ivy.argmax also applies to this method + with minimal changes. Parameters ---------- @@ -141,9 +143,10 @@ def _static_argmin( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.argmin. This method - simply wraps the function, and so the docstring for ivy.argmin also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.argmin. This method simply wraps the + function, and so the docstring for ivy.argmin also applies to this method with + minimal changes. Parameters ---------- @@ -202,9 +205,10 @@ def argmin( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.argmin. This method - simply wraps the function, and so the docstring for ivy.argmin also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.argmin. This method simply wraps + the function, and so the docstring for ivy.argmin also applies to this method + with minimal changes. Parameters ---------- @@ -271,9 +275,10 @@ def _static_nonzero( size: Optional[Union[int, ivy.Container]] = None, fill_value: Union[Number, ivy.Container] = 0, ) -> ivy.Container: - """ivy.Container static method variant of ivy.nonzero. This method - simply wraps the function, and so the docstring for ivy.nonzero also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.nonzero. This method simply wraps the + function, and so the docstring for ivy.nonzero also applies to this method with + minimal changes. Parameters ---------- @@ -310,9 +315,10 @@ def nonzero( size: Optional[Union[int, ivy.Container]] = None, fill_value: Union[Number, ivy.Container] = 0, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.nonzero. This method - simply wraps the function, and so the docstring for ivy.nonzero also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.nonzero. This method simply wraps + the function, and so the docstring for ivy.nonzero also applies to this method + with minimal changes. Parameters ---------- @@ -350,9 +356,10 @@ def _static_where( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.where. This method simply - wraps the function, and so the docstring for ivy.where also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.where. This method simply wraps the + function, and so the docstring for ivy.where also applies to this method with + minimal changes. Parameters ---------- @@ -395,9 +402,10 @@ def where( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.where. This method - simply wraps the function, and so the docstring for ivy.where also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.where. This method simply wraps the + function, and so the docstring for ivy.where also applies to this method with + minimal changes. Parameters ---------- @@ -444,9 +452,10 @@ def _static_argwhere( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.argwhere. This method - simply wraps the function, and so the docstring for ivy.argwhere also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.argwhere. This method simply wraps + the function, and so the docstring for ivy.argwhere also applies to this method + with minimal changes. Parameters ---------- @@ -509,9 +518,10 @@ def argwhere( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ivy.Container instance method variant of ivy.argwhere. This method - simply wraps the function, and so the docstring for ivy.argwhere also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.argwhere. This method simply wraps + the function, and so the docstring for ivy.argwhere also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/set.py b/ivy/data_classes/container/set.py index 930560637b588..e45c0e748ff86 100644 --- a/ivy/data_classes/container/set.py +++ b/ivy/data_classes/container/set.py @@ -19,9 +19,10 @@ def _static_unique_all( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.unique_all. This method - simply wraps the function, and so the docstring for ivy.unique_all also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.unique_all. This method simply wraps + the function, and so the docstring for ivy.unique_all also applies to this + method with minimal changes. Parameters ---------- @@ -96,9 +97,10 @@ def unique_all( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.unique_all. This method - simply wraps the function, and so the docstring for ivy.unique_all also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.unique_all. This method simply + wraps the function, and so the docstring for ivy.unique_all also applies to this + method with minimal changes. Parameters ---------- @@ -170,9 +172,10 @@ def _static_unique_counts( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.unique_counts. This - method simply wraps the function, and so the docstring for - ivy.unique_counts also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.unique_counts. This method simply + wraps the function, and so the docstring for ivy.unique_counts also applies to + this method with minimal changes. Parameters ---------- @@ -233,9 +236,10 @@ def unique_counts( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.unique_counts. This - method simply wraps the function, and so the docstring for - ivy.unique_counts also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.unique_counts. This method simply + wraps the function, and so the docstring for ivy.unique_counts also applies to + this method with minimal changes. Parameters ---------- @@ -322,8 +326,9 @@ def unique_values( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.unique_values. This - method simply wraps the function and applies it on the container. + """ + ivy.Container instance method variant of ivy.unique_values. This method simply + wraps the function and applies it on the container. Parameters ---------- @@ -399,9 +404,10 @@ def _static_unique_inverse( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container static method variant of ivy.unique_inverse. This - method simply wraps the function, and so the docstring for - ivy.unique_inverse also applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.unique_inverse. This method simply + wraps the function, and so the docstring for ivy.unique_inverse also applies to + this method with minimal changes. Parameters ---------- @@ -463,9 +469,10 @@ def unique_inverse( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.unique_inverse. This - method simply wraps the function, and so the docstring for - ivy.unique_inverse also applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.unique_inverse. This method simply + wraps the function, and so the docstring for ivy.unique_inverse also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/sorting.py b/ivy/data_classes/container/sorting.py index a6409a5f176c8..8b1938b5ad7c8 100644 --- a/ivy/data_classes/container/sorting.py +++ b/ivy/data_classes/container/sorting.py @@ -24,9 +24,10 @@ def _static_argsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.argsort. This method - simply wraps the function, and so the docstring for ivy.argsort also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.argsort. This method simply wraps the + function, and so the docstring for ivy.argsort also applies to this method with + minimal changes. Parameters ---------- @@ -137,9 +138,10 @@ def argsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.argsort. This method - simply wraps the function, and so the docstring for ivy.argsort also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.argsort. This method simply wraps + the function, and so the docstring for ivy.argsort also applies to this method + with minimal changes. Parameters ---------- @@ -220,9 +222,10 @@ def _static_sort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.sort. This method simply - wraps the function, and so the docstring for ivy.sort also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.sort. This method simply wraps the + function, and so the docstring for ivy.sort also applies to this method with + minimal changes. Examples -------- @@ -272,9 +275,10 @@ def sort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.sort. This method - simply wraps the function, and so the docstring for ivy.sort also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.sort. This method simply wraps the + function, and so the docstring for ivy.sort also applies to this method with + minimal changes. Examples -------- @@ -337,9 +341,10 @@ def static_msort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.msort. This method simply - wraps the function, and so the docstring for ivy.msort also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.msort. This method simply wraps the + function, and so the docstring for ivy.msort also applies to this method with + minimal changes. Parameters ---------- @@ -391,9 +396,10 @@ def msort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.msort. This method - simply wraps the function, and so the docstring for ivy.msort also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.msort. This method simply wraps the + function, and so the docstring for ivy.msort also applies to this method with + minimal changes. Parameters ---------- @@ -449,7 +455,8 @@ def _static_searchsorted( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.searchsorted. + """ + ivy.Container static method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal @@ -485,7 +492,8 @@ def searchsorted( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.searchsorted. + """ + ivy.Container instance method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal diff --git a/ivy/data_classes/container/statistical.py b/ivy/data_classes/container/statistical.py index 26db9e83fab4b..f9b36cc105e6a 100644 --- a/ivy/data_classes/container/statistical.py +++ b/ivy/data_classes/container/statistical.py @@ -24,9 +24,10 @@ def _static_min( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ivy.Container static method variant of ivy.min. This method simply - wraps the function, and so the docstring for ivy.min also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.min. This method simply wraps the + function, and so the docstring for ivy.min also applies to this method with + minimal changes. Parameters ---------- @@ -110,9 +111,10 @@ def min( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.min. This method simply - wraps the function, and so the docstring for ivy.min also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.min. This method simply wraps the + function, and so the docstring for ivy.min also applies to this method with + minimal changes. Parameters ---------- @@ -195,9 +197,10 @@ def max( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.max. This method simply - wraps the function, and so the docstring for ivy.max also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.max. This method simply wraps the + function, and so the docstring for ivy.max also applies to this method with + minimal changes. Parameters ---------- @@ -274,9 +277,10 @@ def mean( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.mean. This method - simply wraps the function, and so the docstring for ivy.mean also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.mean. This method simply wraps the + function, and so the docstring for ivy.mean also applies to this method with + minimal changes. Parameters ---------- @@ -408,9 +412,10 @@ def var( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.var. This method simply - wraps the function, and so the docstring for ivy.var also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.var. This method simply wraps the + function, and so the docstring for ivy.var also applies to this method with + minimal changes. Parameters ---------- @@ -525,9 +530,10 @@ def _static_var( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.var. This method simply - wraps the function, and so the docstring for ivy.var also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.var. This method simply wraps the + function, and so the docstring for ivy.var also applies to this method with + minimal changes. Parameters ---------- @@ -596,9 +602,10 @@ def _static_prod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ivy.Container static method variant of ivy.prod. This method simply - wraps the function, and so the docstring for ivy.prod also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.prod. This method simply wraps the + function, and so the docstring for ivy.prod also applies to this method with + minimal changes. Parameters ---------- @@ -734,9 +741,10 @@ def prod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.prod. This method - simply wraps the function, and so the docstring for ivy.prod also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.prod. This method simply wraps the + function, and so the docstring for ivy.prod also applies to this method with + minimal changes. Parameters ---------- @@ -925,9 +933,10 @@ def std( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.std. This method simply - wraps the function, and so the docstring for ivy.std also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.std. This method simply wraps the + function, and so the docstring for ivy.std also applies to this method with + minimal changes. Parameters ---------- @@ -1074,9 +1083,10 @@ def _static_cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cumsum. This method - simply wraps the function, and so the docstring for ivy.cumsum also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.cumsum. This method simply wraps the + function, and so the docstring for ivy.cumsum also applies to this method with + minimal changes. Parameters ---------- @@ -1215,9 +1225,10 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cumsum. This method - simply wraps the function, and so the docstring for ivy.cumsum also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cumsum. This method simply wraps + the function, and so the docstring for ivy.cumsum also applies to this method + with minimal changes. Parameters ---------- @@ -1371,9 +1382,10 @@ def _static_cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.cumprod. This method - simply wraps the function, and so the docstring for ivy.cumprod also - applies to this method with minimal changes. + """ + ivy.Container static method variant of ivy.cumprod. This method simply wraps the + function, and so the docstring for ivy.cumprod also applies to this method with + minimal changes. Parameters ---------- @@ -1462,9 +1474,10 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.cumprod. This method - simply wraps the function, and so the docstring for ivy.cumprod also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.cumprod. This method simply wraps + the function, and so the docstring for ivy.cumprod also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/utility.py b/ivy/data_classes/container/utility.py index 4be1c16810d91..d6298db810436 100644 --- a/ivy/data_classes/container/utility.py +++ b/ivy/data_classes/container/utility.py @@ -23,9 +23,10 @@ def _static_all( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.all. This method simply - wraps the function, and so the docstring for ivy.all also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.all. This method simply wraps the + function, and so the docstring for ivy.all also applies to this method with + minimal changes. Parameters ---------- @@ -107,9 +108,10 @@ def all( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.all. This method simply - wraps the function, and so the docstring for ivy.all also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.all. This method simply wraps the + function, and so the docstring for ivy.all also applies to this method with + minimal changes. Parameters ---------- @@ -191,9 +193,10 @@ def _static_any( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container static method variant of ivy.any. This method simply - wraps the function, and so the docstring for ivy.any also applies to - this method with minimal changes. + """ + ivy.Container static method variant of ivy.any. This method simply wraps the + function, and so the docstring for ivy.any also applies to this method with + minimal changes. Parameters ---------- @@ -275,9 +278,10 @@ def any( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ivy.Container instance method variant of ivy.any. This method simply - wraps the function, and so the docstring for ivy.any also applies to - this method with minimal changes. + """ + ivy.Container instance method variant of ivy.any. This method simply wraps the + function, and so the docstring for ivy.any also applies to this method with + minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/wrapping.py b/ivy/data_classes/container/wrapping.py index 8bbb2b30b5809..c4c500cb8e04b 100644 --- a/ivy/data_classes/container/wrapping.py +++ b/ivy/data_classes/container/wrapping.py @@ -9,7 +9,8 @@ def _wrap_function(function_name: str, static: bool) -> Callable: - """Wrap the function called `function_name`. + """ + Wrap the function called `function_name`. Parameters ---------- @@ -82,8 +83,9 @@ def add_ivy_container_instance_methods( static: Union[bool, ivy.Container] = False, to_ignore: Union[Iterable, ivy.Container] = (), ): - """Loop over all ivy modules such as activations, general, etc. and add the - module functions to ivy container as instance methods using _wrap_function. + """ + Loop over all ivy modules such as activations, general, etc. and add the module + functions to ivy container as instance methods using _wrap_function. Parameters ---------- diff --git a/ivy/data_classes/factorized_tensor/cp_tensor.py b/ivy/data_classes/factorized_tensor/cp_tensor.py index e81c18f929f6e..aff80256786af 100644 --- a/ivy/data_classes/factorized_tensor/cp_tensor.py +++ b/ivy/data_classes/factorized_tensor/cp_tensor.py @@ -74,8 +74,8 @@ def cp_copy(self): )) def mode_dot(self, matrix_or_vector, mode, keep_dim=False, copy=True): - """N-mode product of a CP tensor and a matrix or vector at the - specified mode. + """ + N-mode product of a CP tensor and a matrix or vector at the specified mode. Parameters ---------- @@ -105,7 +105,8 @@ def mode_dot(self, matrix_or_vector, mode, keep_dim=False, copy=True): ) def norm(self): - """Return the l2 norm of a CP tensor. + """ + Return the l2 norm of a CP tensor. Parameters ---------- @@ -127,7 +128,8 @@ def norm(self): return ivy.CPTensor.cp_norm(self) def normalize(self, inplace=True): - """Normalize the factors to unit length. + """ + Normalize the factors to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are normalized to unit Euclidean length @@ -175,7 +177,8 @@ def n_param(self): # ---------------# @staticmethod def validate_cp_tensor(cp_tensor): - """Validate a cp_tensor in the form (weights, factors) + """ + Validate a cp_tensor in the form (weights, factors) Return the rank and shape of the validated tensor @@ -234,8 +237,9 @@ def validate_cp_tensor(cp_tensor): @staticmethod def cp_n_param(tensor_shape, rank, weights=False): - """Return number of parameters of a CP decomposition for a given `rank` - and full `tensor_shape`. + """ + Return number of parameters of a CP decomposition for a given `rank` and full + `tensor_shape`. Parameters ---------- @@ -258,7 +262,8 @@ def cp_n_param(tensor_shape, rank, weights=False): @staticmethod def validate_cp_rank(tensor_shape, rank="same", rounding="round"): - """Return the rank of a CP Decomposition. + """ + Return the rank of a CP Decomposition. Parameters ---------- @@ -301,7 +306,8 @@ def validate_cp_rank(tensor_shape, rank="same", rounding="round"): @staticmethod def cp_normalize(cp_tensor): - """Return cp_tensor with factors normalised to unit length. + """ + Return cp_tensor with factors normalised to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are @@ -349,10 +355,10 @@ def cp_normalize(cp_tensor): @staticmethod def cp_flip_sign(cp_tensor, mode=0, func=None): - """Return cp_tensor with factors flipped to have positive signs. The - sign of a given column is determined by `func`, which is the mean by - default. Any negative signs are assigned to the mode indicated by - `mode`. + """ + Return cp_tensor with factors flipped to have positive signs. The sign of a + given column is determined by `func`, which is the mean by default. Any negative + signs are assigned to the mode indicated by `mode`. Parameters ---------- @@ -404,7 +410,8 @@ def cp_flip_sign(cp_tensor, mode=0, func=None): @staticmethod def cp_lstsq_grad(cp_tensor, tensor, return_loss=False, mask=None): - r"""Compute (for a third-order tensor) + r""" + Compute (for a third-order tensor) .. math:: @@ -465,7 +472,8 @@ def cp_lstsq_grad(cp_tensor, tensor, return_loss=False, mask=None): @staticmethod def cp_to_tensor(cp_tensor, mask=None): - """Turn the Khatri-product of matrices into a full tensor. + """ + Turn the Khatri-product of matrices into a full tensor. ``factor_matrices = [|U_1, ... U_n|]`` becomes a tensor shape ``(U[1].shape[0], U[2].shape[0], ... U[-1].shape[0])`` @@ -522,7 +530,8 @@ def cp_to_tensor(cp_tensor, mask=None): @staticmethod def cp_to_unfolded(cp_tensor, mode): - """Turn the khatri-product of matrices into an unfolded tensor. + """ + Turn the khatri-product of matrices into an unfolded tensor. turns ``factors = [|U_1, ... U_n|]`` into a mode-`mode` unfolding of the tensor @@ -562,7 +571,8 @@ def cp_to_unfolded(cp_tensor, mode): @staticmethod def cp_to_vec(cp_tensor): - """Turn the khatri-product of matrices into a vector. + """ + Turn the khatri-product of matrices into a vector. (the tensor ``factors = [|U_1, ... U_n|]`` is converted into a raveled mode-0 unfolding) @@ -587,8 +597,8 @@ def cp_to_vec(cp_tensor): @staticmethod def cp_mode_dot(cp_tensor, matrix_or_vector, mode, keep_dim=False, copy=False): - """N-mode product of a CP tensor and a matrix or vector at the - specified mode. + """ + N-mode product of a CP tensor and a matrix or vector at the specified mode. Parameters ---------- @@ -659,7 +669,8 @@ def cp_mode_dot(cp_tensor, matrix_or_vector, mode, keep_dim=False, copy=False): @staticmethod def cp_norm(cp_tensor): - """Return the l2 norm of a CP tensor. + """ + Return the l2 norm of a CP tensor. Parameters ---------- @@ -751,7 +762,8 @@ def cp_norm(cp_tensor): @staticmethod def unfolding_dot_khatri_rao(x, cp_tensor, mode): - """Mode-n unfolding times khatri-rao product of factors. + """ + Mode-n unfolding times khatri-rao product of factors. Parameters ---------- diff --git a/ivy/data_classes/factorized_tensor/parafac2_tensor.py b/ivy/data_classes/factorized_tensor/parafac2_tensor.py index 78d07a91ff6ce..76dd4be2288ec 100644 --- a/ivy/data_classes/factorized_tensor/parafac2_tensor.py +++ b/ivy/data_classes/factorized_tensor/parafac2_tensor.py @@ -90,7 +90,8 @@ def n_param(self): @classmethod def from_CPTensor(cls, cp_tensor, parafac2_tensor_ok=False): - """Create a Parafac2Tensor from a CPTensor. + """ + Create a Parafac2Tensor from a CPTensor. Parameters ---------- @@ -123,8 +124,9 @@ def from_CPTensor(cls, cp_tensor, parafac2_tensor_ok=False): # ---------------# @staticmethod def validate_parafac2_tensor(parafac2_tensor): - """Validate a parafac2_tensor in the form (weights, factors) Return the - rank and shape of the validated tensor. + """ + Validate a parafac2_tensor in the form (weights, factors) Return the rank and + shape of the validated tensor. Parameters ---------- @@ -208,7 +210,8 @@ def validate_parafac2_tensor(parafac2_tensor): @staticmethod def parafac2_normalise(parafac2_tensor): - """Return parafac2_tensor with factors normalised to unit length. + """ + Return parafac2_tensor with factors normalised to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are normalized to unit Euclidean length @@ -264,7 +267,8 @@ def parafac2_normalise(parafac2_tensor): @staticmethod def apply_parafac2_projections(parafac2_tensor): - """Apply the projection matrices to the evolving factor. + """ + Apply the projection matrices to the evolving factor. Parameters ---------- @@ -293,8 +297,8 @@ def apply_parafac2_projections(parafac2_tensor): @staticmethod def parafac2_to_slice(parafac2_tensor, slice_idx, validate=True): - """Generate a single slice along the first mode from the PARAFAC2 - tensor. + """ + Generate a single slice along the first mode from the PARAFAC2 tensor. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -358,7 +362,8 @@ def parafac2_to_slice(parafac2_tensor, slice_idx, validate=True): @staticmethod def parafac2_to_slices(parafac2_tensor, validate=True): - """Generate all slices along the first mode from a PARAFAC2 tensor. + """ + Generate all slices along the first mode from a PARAFAC2 tensor. Generates a list of all slices from a PARAFAC2 tensor. A list is returned since the tensor might have varying size along the second mode. To return @@ -427,7 +432,8 @@ def parafac2_to_slices(parafac2_tensor, validate=True): @staticmethod def parafac2_to_tensor(parafac2_tensor): - """Construct a full tensor from a PARAFAC2 decomposition. + """ + Construct a full tensor from a PARAFAC2 decomposition. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -488,8 +494,9 @@ def parafac2_to_tensor(parafac2_tensor): @staticmethod def parafac2_to_unfolded(parafac2_tensor, mode): - """Construct an unfolded tensor from a PARAFAC2 decomposition. Uneven - slices are padded by zeros. + """ + Construct an unfolded tensor from a PARAFAC2 decomposition. Uneven slices are + padded by zeros. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -540,8 +547,9 @@ def parafac2_to_unfolded(parafac2_tensor, mode): @staticmethod def parafac2_to_vec(parafac2_tensor): - """Construct a vectorized tensor from a PARAFAC2 decomposition. Uneven - slices are padded by zeros. + """ + Construct a vectorized tensor from a PARAFAC2 decomposition. Uneven slices are + padded by zeros. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by diff --git a/ivy/data_classes/factorized_tensor/tt_tensor.py b/ivy/data_classes/factorized_tensor/tt_tensor.py index c226155527441..14fb3f81a88a2 100644 --- a/ivy/data_classes/factorized_tensor/tt_tensor.py +++ b/ivy/data_classes/factorized_tensor/tt_tensor.py @@ -106,7 +106,8 @@ def validate_tt_tensor(tt_tensor): @staticmethod def tt_to_tensor(factors): - """Return the full tensor whose TT decomposition is given by 'factors'. + """ + Return the full tensor whose TT decomposition is given by 'factors'. Re-assembles 'factors', which represent a tensor in TT/Matrix-Product-State format into the corresponding full tensor @@ -137,8 +138,8 @@ def tt_to_tensor(factors): @staticmethod def tt_to_unfolded(factors, mode): - """Return the unfolding matrix of a tensor given in TT (or Tensor- - Train) format. + """ + Return the unfolding matrix of a tensor given in TT (or Tensor- Train) format. Reassembles a full tensor from 'factors' and returns its unfolding matrix with mode given by 'mode' @@ -159,8 +160,9 @@ def tt_to_unfolded(factors, mode): @staticmethod def tt_to_vec(factors): - """Return the tensor defined by its TT format ('factors') into its - vectorized format. + """ + Return the tensor defined by its TT format ('factors') into its vectorized + format. Parameters ---------- @@ -176,8 +178,9 @@ def tt_to_vec(factors): @staticmethod def _tt_n_param(tensor_shape, rank): - """Return the number of parameters of a MPS decomposition for a given - `rank` and full `tensor_shape`. + """ + Return the number of parameters of a MPS decomposition for a given `rank` and + full `tensor_shape`. Parameters ---------- @@ -205,7 +208,8 @@ def validate_tt_rank( rounding="round", allow_overparametrization=True, ): - """Return the rank of a TT Decomposition. + """ + Return the rank of a TT Decomposition. Parameters ---------- @@ -329,8 +333,9 @@ def validate_tt_rank( @staticmethod def pad_tt_rank(factor_list, n_padding=1, pad_boundaries=False): - """Pad the factors of a Tensor-Train so as to increase its rank without - changing its reconstruction. + """ + Pad the factors of a Tensor-Train so as to increase its rank without changing + its reconstruction. The tensor-train (ring) will be padded with 0s to increase its rank only but not the underlying tensor it represents. diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index 6f3b991d81d73..6ba49d03d86ea 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -227,7 +227,8 @@ def _build_view(original, view, fn, args, kwargs, index=None): def _check_in_nested_sequence(sequence, value=None, _type=None): - """Check `sequence` for either a `value` or a value of type `_type`. + """ + Check `sequence` for either a `value` or a value of type `_type`. Helper to recursively check if a N-level nested `sequence` contains either a `value` or contains a value of type `_type` and return a @@ -267,7 +268,8 @@ def _get_preferred_device(args, kwargs): def handle_array_function(fn): - """Wrap a function `fn` to be passed to array_function method. + """ + Wrap a function `fn` to be passed to array_function method. Wrap a function to extract the relevant argument types to be passed to array_function method. @@ -378,9 +380,10 @@ def _handle_array_like_without_promotion(*args, **kwargs): def inputs_to_native_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_native_arrays(*args, **kwargs): - """Convert all `ivy.Array` instances in both the positional and keyword - arguments into `ivy.NativeArray` instances, and then calls the function - with the updated arguments. + """ + Convert all `ivy.Array` instances in both the positional and keyword arguments + into `ivy.NativeArray` instances, and then calls the function with the updated + arguments. Parameters ---------- @@ -417,9 +420,10 @@ def _inputs_to_native_arrays(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays(*args, **kwargs): - """Convert all `ivy.NativeArray` instances in both the positional and - keyword arguments into `ivy.Array` instances, and then calls the - function with the updated arguments. + """ + Convert all `ivy.NativeArray` instances in both the positional and keyword + arguments into `ivy.Array` instances, and then calls the function with the + updated arguments. Parameters ---------- @@ -483,7 +487,8 @@ def _outputs_to_ivy_shapes(*args, **kwargs): def to_native_shapes_and_back(fn: Callable) -> Callable: - """Make `fn` receive `ivy.NativeShape` and return `ivy.Shape`. + """ + Make `fn` receive `ivy.NativeShape` and return `ivy.Shape`. Wrap `fn` so that input shapes are all converted to `ivy.NativeShape` instances and return shapes are all converted to @@ -495,8 +500,9 @@ def to_native_shapes_and_back(fn: Callable) -> Callable: def outputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_ivy_arrays(*args, **kwargs): - """Call the function, and then converts all `ivy.NativeArray` instances - in the function return into `ivy.Array` instances. + """ + Call the function, and then converts all `ivy.NativeArray` instances in the + function return into `ivy.Array` instances. Parameters ---------- @@ -524,8 +530,9 @@ def _outputs_to_ivy_arrays(*args, **kwargs): def output_to_native_arrays(fn: Callable) -> Callable: - """Call the function, and then converts all `ivy.Array` instances in the - function return into `ivy.NativeArray` instances. + """ + Call the function, and then converts all `ivy.Array` instances in the function + return into `ivy.NativeArray` instances. Parameters ---------- @@ -550,7 +557,8 @@ def _output_to_native_arrays(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """Make `fn` receive `ivy.Array` and return `ivy.NativeArray`. + """ + Make `fn` receive `ivy.Array` and return `ivy.NativeArray`. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ivy.NativeArray` @@ -560,7 +568,8 @@ def to_ivy_arrays_and_back(fn: Callable) -> Callable: def to_native_arrays_and_back(fn: Callable) -> Callable: - """Make `fn` receive `ivy.NativeArray` and return `ivy.Array`. + """ + Make `fn` receive `ivy.NativeArray` and return `ivy.Array`. Wrap `fn` so that input arrays are all converted to `ivy.NativeArray` instances and return arrays are all converted to @@ -570,7 +579,8 @@ def to_native_arrays_and_back(fn: Callable) -> Callable: def frontend_outputs_to_ivy_arrays(fn: Callable) -> Callable: - """Wrap `fn` and convert all frontend arrays in its return to ivy arrays. + """ + Wrap `fn` and convert all frontend arrays in its return to ivy arrays. Used in cases when a frontend function receives a callable (frontend function) argument. To be able to use that callable in a composition @@ -590,7 +600,8 @@ def _outputs_to_ivy_arrays(*args, **kwargs): def handle_view(fn: Callable) -> Callable: - """Wrap `fn` and performs view handling if copy is False. + """ + Wrap `fn` and performs view handling if copy is False. Used for functional backends (Jax and TensorFlow). Checks if the first arg is a view or original array by checking if the ._base @@ -621,7 +632,8 @@ def _handle_view(*args, **kwargs): def handle_view_indexing(fn: Callable) -> Callable: - """Wrap `fn` and performs view handling specifically for indexing. + """ + Wrap `fn` and performs view handling specifically for indexing. As with NumPy it returns a copy if advanced indexing is performed. Used for functional backends (Jax and TensorFlow). Checks if the @@ -664,8 +676,8 @@ def _convert_numpy_arrays_to_backend_specific(*args): def handle_numpy_arrays_in_specific_backend(fn: Callable) -> Callable: - """Wrap `fn` and converts all `numpy.ndarray` inputs to `torch.Tensor` - instances. + """ + Wrap `fn` and converts all `numpy.ndarray` inputs to `torch.Tensor` instances. Used for functional backends (PyTorch). Converts all `numpy.ndarray` inputs to `torch.Tensor` instances. @@ -688,8 +700,9 @@ def _handle_numpy_array_in_torch(*args, **kwargs): def infer_dtype(fn: Callable) -> Callable: @functools.wraps(fn) def _infer_dtype(*args, dtype=None, **kwargs): - """Determine the correct `dtype`, and then calls the function with the - `dtype` passed explicitly. + """ + Determine the correct `dtype`, and then calls the function with the `dtype` + passed explicitly. Parameters ---------- @@ -725,7 +738,8 @@ def _infer_dtype(*args, dtype=None, **kwargs): def handle_device(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_device(*args, **kwargs): - """Move all array inputs of the function to `ivy.default_device()`. + """ + Move all array inputs of the function to `ivy.default_device()`. Parameters ---------- @@ -779,8 +793,9 @@ def handle_out_argument(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_out_argument(*args, out=None, **kwargs): - """Call `fn` with the `out` argument handled correctly for performing - an inplace update. + """ + Call `fn` with the `out` argument handled correctly for performing an inplace + update. Parameters ---------- @@ -872,9 +887,10 @@ def handle_nestable(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_nestable(*args, **kwargs): - """Call `fn` with the *nestable* property of the function correctly - handled. This means mapping the function to the container leaves if any - containers are passed in the input. + """ + Call `fn` with the *nestable* property of the function correctly handled. This + means mapping the function to the container leaves if any containers are passed + in the input. Parameters ---------- @@ -915,9 +931,10 @@ def cont_fn(*args, **kwargs): def handle_ragged(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_ragged(*args, **kwargs): - """Call `fn` with the *ragged* property of the function correctly - handled. This means mapping the function to the RaggedArray arrays if - any RaggedArrays are passed in the input. + """ + Call `fn` with the *ragged* property of the function correctly handled. This + means mapping the function to the RaggedArray arrays if any RaggedArrays are + passed in the input. Parameters ---------- @@ -975,7 +992,8 @@ def _handle_partial_mixed_function(*args, **kwargs): def temp_asarray_wrapper(fn: Callable) -> Callable: @functools.wraps(fn) def _temp_asarray_wrapper(*args, **kwargs): - """Convert `Tensor` into `ivy.Array` instances. + """ + Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -1008,8 +1026,9 @@ def _to_ivy_array(x): def download_cython_wrapper_wrapper(fn: Callable) -> Callable: @functools.wraps(fn) def _download_cython_wrapper_wrapper(*args, **kwargs): - """Wrap the function to download compiled cython wrapper for the - function and re-wraps it with the downloaded wrapper. + """ + Wrap the function to download compiled cython wrapper for the function and re- + wraps it with the downloaded wrapper. Download the compiled cython wrapper by calling ivy.wrappers.get_wrapper(func_name: str) and then wrap the @@ -1031,11 +1050,12 @@ def _download_cython_wrapper_wrapper(*args, **kwargs): def _wrap_function( key: str, to_wrap: Callable, original: Callable, compositional: bool = False ) -> Callable: - """Apply wrapping to backend implementation `to_wrap` if the original - implementation `original` is also wrapped, and if `to_wrap` is not already - wrapped. Attributes `handle_nestable` etc are set during wrapping, hence - indicate to us whether a certain function has been wrapped or not. Also - handles wrapping of the `linalg` namespace. + """ + Apply wrapping to backend implementation `to_wrap` if the original implementation + `original` is also wrapped, and if `to_wrap` is not already wrapped. Attributes + `handle_nestable` etc are set during wrapping, hence indicate to us whether a + certain function has been wrapped or not. Also handles wrapping of the `linalg` + namespace. Parameters ---------- @@ -1242,8 +1262,8 @@ def _dtype_from_version(dic, version): def _versioned_attribute_factory(attribute_function, base): class VersionedAttributes(base): - """Class which add versioned attributes to a class, inheriting from - `base`. + """ + Class which add versioned attributes to a class, inheriting from `base`. Create a class which inherits `base` this way if isinstance is called on an instance of the class, it will return True if @@ -1272,7 +1292,8 @@ def __bool__(self): def _dtype_device_wrapper_creator(attrib, t): - """Create a wrapper for a dtype or device attribute. + """ + Create a wrapper for a dtype or device attribute. The wrapper returns the correct dtype or device for the current version of the backend. @@ -1372,8 +1393,8 @@ def _nest_has_nans(x): def handle_nans(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_nans(*args, **kwargs): - """Check for the existence of nans in all arrays in the `args` and - `kwargs`. + """ + Check for the existence of nans in all arrays in the `args` and `kwargs`. The presence of nans is then handled depending on the enabled `nan_policy`. @@ -1427,8 +1448,9 @@ def _handle_complex_input( complex_mode: Literal["split", "magnitude", "jax"] = "jax", **kwargs, ): - """Check whether the first positional argument is an array of complex - type, and if so handle it according to the provided `complex_mode`. + """ + Check whether the first positional argument is an array of complex type, and if + so handle it according to the provided `complex_mode`. The options are: `"jax"` (default): emulate the behaviour of the JAX framework. If the function @@ -1555,9 +1577,10 @@ def _handle_complex_input( def handle_backend_invalid(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_backend_invalid(*args, **kwargs): - """Check if any of the arguments (or nested arguments) passed to the - function are instances of ivy.Array or ivy.NativeArray. If so, it - returns the function. If not, it raises an InvalidBackendException. + """ + Check if any of the arguments (or nested arguments) passed to the function are + instances of ivy.Array or ivy.NativeArray. If so, it returns the function. If + not, it raises an InvalidBackendException. Parameters ---------- diff --git a/ivy/functional/backends/jax/activations.py b/ivy/functional/backends/jax/activations.py index cdb9340436cf6..5f163f85fe385 100644 --- a/ivy/functional/backends/jax/activations.py +++ b/ivy/functional/backends/jax/activations.py @@ -1,5 +1,4 @@ -"""Collection of Jax activation functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Jax activation functions, wrapped to fit Ivy syntax and signature.""" # global diff --git a/ivy/functional/backends/jax/device.py b/ivy/functional/backends/jax/device.py index f21d9aa0cb66a..e12164e617440 100644 --- a/ivy/functional/backends/jax/device.py +++ b/ivy/functional/backends/jax/device.py @@ -1,5 +1,4 @@ -"""Collection of Jax device functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Jax device functions, wrapped to fit Ivy syntax and signature.""" # global import os diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index a21e94b23fc12..7382466218be1 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -1,5 +1,4 @@ -"""Collection of Jax general functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Jax general functions, wrapped to fit Ivy syntax and signature.""" # global import jax diff --git a/ivy/functional/backends/jax/gradients.py b/ivy/functional/backends/jax/gradients.py index 5e96bdd28c101..13ee80730c2b4 100644 --- a/ivy/functional/backends/jax/gradients.py +++ b/ivy/functional/backends/jax/gradients.py @@ -1,5 +1,4 @@ -"""Collection of Jax gradient functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Jax gradient functions, wrapped to fit Ivy syntax and signature.""" # global import jax diff --git a/ivy/functional/backends/jax/layers.py b/ivy/functional/backends/jax/layers.py index 78a72fb2fb85b..37bd852c7c3a6 100644 --- a/ivy/functional/backends/jax/layers.py +++ b/ivy/functional/backends/jax/layers.py @@ -1,5 +1,4 @@ -"""Collection of Jax network layers, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Jax network layers, wrapped to fit Ivy syntax and signature.""" # global import jax.lax as jlax diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index c2e98759fe2c4..bc09814ff8b58 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -1,5 +1,4 @@ -"""Collection of Jax random functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Jax random functions, wrapped to fit Ivy syntax and signature.""" # global import jax diff --git a/ivy/functional/backends/mxnet/activations.py b/ivy/functional/backends/mxnet/activations.py index b72a333da33f1..96bd23c3ca96f 100644 --- a/ivy/functional/backends/mxnet/activations.py +++ b/ivy/functional/backends/mxnet/activations.py @@ -1,4 +1,5 @@ -"""MXNet activation functions. +""" +MXNet activation functions. Collection of MXNet activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/mxnet/device.py b/ivy/functional/backends/mxnet/device.py index 1064e52b7aa21..bb9874bcca80d 100644 --- a/ivy/functional/backends/mxnet/device.py +++ b/ivy/functional/backends/mxnet/device.py @@ -1,4 +1,5 @@ -"""MXNet device functions. +""" +MXNet device functions. Collection of MXNet general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/mxnet/gradients.py b/ivy/functional/backends/mxnet/gradients.py index 203640b7df2ef..97577e8634e6f 100644 --- a/ivy/functional/backends/mxnet/gradients.py +++ b/ivy/functional/backends/mxnet/gradients.py @@ -1,5 +1,4 @@ -"""Collection of MXNet gradient functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of MXNet gradient functions, wrapped to fit Ivy syntax and signature.""" # global from typing import Sequence, Union diff --git a/ivy/functional/backends/mxnet/layers.py b/ivy/functional/backends/mxnet/layers.py index 2450a2555131b..5bb1ed3d5a26f 100644 --- a/ivy/functional/backends/mxnet/layers.py +++ b/ivy/functional/backends/mxnet/layers.py @@ -1,5 +1,4 @@ -"""Collection of MXNet network layers, wrapped to fit Ivy syntax and -signature.""" +"""Collection of MXNet network layers, wrapped to fit Ivy syntax and signature.""" # global import mxnet as mx diff --git a/ivy/functional/backends/mxnet/random.py b/ivy/functional/backends/mxnet/random.py index 033a6b26cce5d..875fc1ce304cb 100644 --- a/ivy/functional/backends/mxnet/random.py +++ b/ivy/functional/backends/mxnet/random.py @@ -1,4 +1,5 @@ -"""MXNet random functions. +""" +MXNet random functions. Collection of MXNet random functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/numpy/activations.py b/ivy/functional/backends/numpy/activations.py index 714056b4b34c0..cb9f698df3d39 100644 --- a/ivy/functional/backends/numpy/activations.py +++ b/ivy/functional/backends/numpy/activations.py @@ -1,5 +1,4 @@ -"""Collection of Numpy activation functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Numpy activation functions, wrapped to fit Ivy syntax and signature.""" # global from typing import Optional, Union, Literal diff --git a/ivy/functional/backends/numpy/device.py b/ivy/functional/backends/numpy/device.py index b173e50154f92..d636feb8d8f25 100644 --- a/ivy/functional/backends/numpy/device.py +++ b/ivy/functional/backends/numpy/device.py @@ -1,5 +1,4 @@ -"""Collection of Numpy general functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Numpy general functions, wrapped to fit Ivy syntax and signature.""" # global import os diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index 7c73a37ba78ca..fa72a2bd0164b 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -1,5 +1,4 @@ -"""Collection of Numpy general functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Numpy general functions, wrapped to fit Ivy syntax and signature.""" # global from typing import Optional, Union, Sequence, Callable, Tuple diff --git a/ivy/functional/backends/numpy/gradients.py b/ivy/functional/backends/numpy/gradients.py index d6ba1e9b55bd7..1f930d0ebe687 100644 --- a/ivy/functional/backends/numpy/gradients.py +++ b/ivy/functional/backends/numpy/gradients.py @@ -1,5 +1,4 @@ -"""Collection of NumPy gradient functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of NumPy gradient functions, wrapped to fit Ivy syntax and signature.""" # global import logging diff --git a/ivy/functional/backends/numpy/helpers.py b/ivy/functional/backends/numpy/helpers.py index 965bb5067baca..b5ae02d3a09f0 100644 --- a/ivy/functional/backends/numpy/helpers.py +++ b/ivy/functional/backends/numpy/helpers.py @@ -4,7 +4,8 @@ def _scalar_output_to_0d_array(function: Callable) -> Callable: - """Convert scalar outputs to 0d arrays. + """ + Convert scalar outputs to 0d arrays. Sometimes NumPy functions return scalars e.g. `np.add` does when the inputs are both 0 dimensional. diff --git a/ivy/functional/backends/numpy/layers.py b/ivy/functional/backends/numpy/layers.py index 5fe2e909e5e76..d6d4ebc27b20a 100644 --- a/ivy/functional/backends/numpy/layers.py +++ b/ivy/functional/backends/numpy/layers.py @@ -1,5 +1,4 @@ -"""Collection of Numpy network layers, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Numpy network layers, wrapped to fit Ivy syntax and signature.""" # global import numpy as np diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index 4d3daa4a00c6e..eb0859f706ffb 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -1,5 +1,4 @@ -"""Collection of Numpy random functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Numpy random functions, wrapped to fit Ivy syntax and signature.""" # global import numpy as np diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index 59c421f43ae6b..8182b0ef2263a 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/ivy/functional/backends/paddle/activations.py @@ -1,4 +1,5 @@ -"""Paddle activation functions. +""" +Paddle activation functions. Collection of Paddle activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/paddle/device.py b/ivy/functional/backends/paddle/device.py index b1120da1d5657..0270ccd9d1d5b 100644 --- a/ivy/functional/backends/paddle/device.py +++ b/ivy/functional/backends/paddle/device.py @@ -1,5 +1,4 @@ -"""Collection of Paddle general functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Paddle general functions, wrapped to fit Ivy syntax and signature.""" # global import os diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 1d9802da6c154..0cba9b3ce312b 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -748,7 +748,8 @@ def _EvaluatePolynomial(x, coefficients): def _is_scalar(x): - """Determines if the given tensor is a scalar. + """ + Determines if the given tensor is a scalar. Args ---- diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 8bdb2a2a86cbc..f21d14595f180 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -1,5 +1,4 @@ -"""Collection of Paddle general functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Paddle general functions, wrapped to fit Ivy syntax and signature.""" # global from numbers import Number diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index c39ef078758b1..349b8218996ad 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -1,5 +1,4 @@ -"""Collection of Paddle gradient functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Paddle gradient functions, wrapped to fit Ivy syntax and signature.""" # global diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index ad78d3d041b50..4798e13e3f64f 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -1,5 +1,4 @@ -"""Collection of Paddle network layers, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Paddle network layers, wrapped to fit Ivy syntax and signature.""" from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/paddle/random.py b/ivy/functional/backends/paddle/random.py index aa16a3d9d1666..1c156fd300172 100644 --- a/ivy/functional/backends/paddle/random.py +++ b/ivy/functional/backends/paddle/random.py @@ -1,5 +1,4 @@ -"""Collection of Paddle random functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of Paddle random functions, wrapped to fit Ivy syntax and signature.""" # global import paddle diff --git a/ivy/functional/backends/tensorflow/activations.py b/ivy/functional/backends/tensorflow/activations.py index 5b757031a48c5..2a9797f11897d 100644 --- a/ivy/functional/backends/tensorflow/activations.py +++ b/ivy/functional/backends/tensorflow/activations.py @@ -1,4 +1,5 @@ -"""TensorFlow activation functions. +""" +TensorFlow activation functions. Collection of TensorFlow activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/device.py b/ivy/functional/backends/tensorflow/device.py index dd7c4cea4f6c9..bec64860d54a4 100644 --- a/ivy/functional/backends/tensorflow/device.py +++ b/ivy/functional/backends/tensorflow/device.py @@ -1,4 +1,5 @@ -"""Tensorflow device functions. +""" +Tensorflow device functions. Collection of TensorFlow general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 70db8f5b6d040..7a018f41c9197 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -1,4 +1,5 @@ -"""Tensorflow general functions. +""" +Tensorflow general functions. Collection of TensorFlow general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/gradients.py b/ivy/functional/backends/tensorflow/gradients.py index da688a2dd71f5..d548e21bc7738 100644 --- a/ivy/functional/backends/tensorflow/gradients.py +++ b/ivy/functional/backends/tensorflow/gradients.py @@ -1,4 +1,5 @@ -"""Tensorflow gradient functions. +""" +Tensorflow gradient functions. Collection of TensorFlow gradient functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index d1e6c2043cd5b..3b1489bf8e787 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -1,5 +1,4 @@ -"""Collection of TensorFlow network layers, wrapped to fit Ivy syntax and -signature.""" +"""Collection of TensorFlow network layers, wrapped to fit Ivy syntax and signature.""" # global from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/tensorflow/random.py b/ivy/functional/backends/tensorflow/random.py index dcb320508614d..22a91745a912d 100644 --- a/ivy/functional/backends/tensorflow/random.py +++ b/ivy/functional/backends/tensorflow/random.py @@ -1,4 +1,5 @@ -"""TensorFlow random functions. +""" +TensorFlow random functions. Collection of TensorFlow random functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py index edfe28faa07db..50b592d5d9587 100644 --- a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py @@ -118,8 +118,9 @@ def nanmedian( def _nanmedian_helper(input, axis=None, keepdims=False): - """The approach to Handle Nans in single dimensional plus multi-dimensional - inputs are composed on two-parts. + """ + The approach to Handle Nans in single dimensional plus multi-dimensional inputs are + composed on two-parts. PART 1: In this part, you have axis=None, it means we have to work on flattened data, we don't need to work on different axis.there are two cases here diff --git a/ivy/functional/backends/torch/activations.py b/ivy/functional/backends/torch/activations.py index e341d123ec230..b2dd68bd04177 100644 --- a/ivy/functional/backends/torch/activations.py +++ b/ivy/functional/backends/torch/activations.py @@ -1,4 +1,5 @@ -"""PyTorch activation functions. +""" +PyTorch activation functions. Collection of PyTorch activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/torch/device.py b/ivy/functional/backends/torch/device.py index 4fdfb8ce1c035..59d35e007d109 100644 --- a/ivy/functional/backends/torch/device.py +++ b/ivy/functional/backends/torch/device.py @@ -1,5 +1,4 @@ -"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and signature.""" import inspect diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 2fb22fc355458..304f84f356143 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -1,5 +1,4 @@ -"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and signature.""" # global from functools import reduce as _reduce diff --git a/ivy/functional/backends/torch/gradients.py b/ivy/functional/backends/torch/gradients.py index 207794f8c4eab..3434409fa0509 100644 --- a/ivy/functional/backends/torch/gradients.py +++ b/ivy/functional/backends/torch/gradients.py @@ -1,5 +1,4 @@ -"""Collection of PyTorch gradient functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of PyTorch gradient functions, wrapped to fit Ivy syntax and signature.""" # global import torch diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index 2a7640b33db3f..754c8c63d23b3 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -1,5 +1,4 @@ -"""Collection of PyTorch network layers, wrapped to fit Ivy syntax and -signature.""" +"""Collection of PyTorch network layers, wrapped to fit Ivy syntax and signature.""" from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index efc61ba4c52a1..8dd695838b8c6 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -1,5 +1,4 @@ -"""Collection of PyTorch random functions, wrapped to fit Ivy syntax and -signature.""" +"""Collection of PyTorch random functions, wrapped to fit Ivy syntax and signature.""" # global import torch diff --git a/ivy/functional/frontends/jax/numpy/__init__.py b/ivy/functional/frontends/jax/numpy/__init__.py index 4b8a28a0a6ed9..6972b2d115109 100644 --- a/ivy/functional/frontends/jax/numpy/__init__.py +++ b/ivy/functional/frontends/jax/numpy/__init__.py @@ -390,8 +390,8 @@ def promote_types_jax( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """Promote the datatypes type1 and type2, returning the data type they - promote to. + """ + Promote the datatypes type1 and type2, returning the data type they promote to. Parameters ---------- @@ -424,8 +424,9 @@ def promote_types_of_jax_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """Promote the dtype of the given native array inputs to a common dtype - based on type promotion rules. + """ + Promote the dtype of the given native array inputs to a common dtype based on type + promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index 864119a245bc0..3f770c6dfcde0 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -345,8 +345,8 @@ def interpolate( def kl_div(logits, labels, reduction="mean"): - """Computes the Kullback-Leibler (KL) Divergence between the logits and the - labels. + """ + Computes the Kullback-Leibler (KL) Divergence between the logits and the labels. Parameters ---------- diff --git a/ivy/functional/frontends/mxnet/func_wrapper.py b/ivy/functional/frontends/mxnet/func_wrapper.py index 6b8880d6f149e..434e5755a7f11 100644 --- a/ivy/functional/frontends/mxnet/func_wrapper.py +++ b/ivy/functional/frontends/mxnet/func_wrapper.py @@ -61,7 +61,8 @@ def _handle_mxnet_out(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_mxnet(*args, **kwargs): - """Convert `ndarray.NDArray` into `ivy.Array` instances. + """ + Convert `ndarray.NDArray` into `ivy.Array` instances. Convert all `ndarray.NDArray` instances in both the positional and keyword arguments into `ivy.Array` instances, and then calls @@ -83,7 +84,8 @@ def _inputs_to_ivy_arrays_mxnet(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_mxnet(*args, **kwargs): - """Convert `ivy.Array` into `ndarray.NDArray` instances. + """ + Convert `ivy.Array` into `ndarray.NDArray` instances. Call the function, and then converts all `ivy.Array` instances in the function return into `ndarray.NDArray` instances. @@ -99,7 +101,8 @@ def _outputs_to_frontend_arrays_mxnet(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """Wrap `fn` so it receives and returns `ivy.Array` instances. + """ + Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray.NDArray` diff --git a/ivy/functional/frontends/mxnet/numpy/__init__.py b/ivy/functional/frontends/mxnet/numpy/__init__.py index 1f8fb0f1393f8..a3b0c6fab40a1 100644 --- a/ivy/functional/frontends/mxnet/numpy/__init__.py +++ b/ivy/functional/frontends/mxnet/numpy/__init__.py @@ -104,8 +104,8 @@ def promote_types_mxnet( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """Promote the datatypes type1 and type2, returning the data type they - promote to. + """ + Promote the datatypes type1 and type2, returning the data type they promote to. Parameters ---------- @@ -132,8 +132,9 @@ def promote_types_of_mxnet_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """Promote the dtype of the given native array inputs to a common dtype - based on type promotion rules. + """ + Promote the dtype of the given native array inputs to a common dtype based on type + promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/numpy/__init__.py b/ivy/functional/frontends/numpy/__init__.py index 9cdf0c1278021..8d2eac7018fd3 100644 --- a/ivy/functional/frontends/numpy/__init__.py +++ b/ivy/functional/frontends/numpy/__init__.py @@ -435,8 +435,9 @@ def promote_types_of_numpy_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """Promote the dtype of the given ivy array inputs to a common dtype based - on numpy type promotion rules. + """ + Promote the dtype of the given ivy array inputs to a common dtype based on numpy + type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/numpy/func_wrapper.py b/ivy/functional/frontends/numpy/func_wrapper.py index 91df6184aa626..d1d4df7a8fa1b 100644 --- a/ivy/functional/frontends/numpy/func_wrapper.py +++ b/ivy/functional/frontends/numpy/func_wrapper.py @@ -227,9 +227,9 @@ def _to_ivy_array(x): def from_zero_dim_arrays_to_scalar(fn: Callable) -> Callable: @functools.wraps(fn) def _from_zero_dim_arrays_to_scalar(*args, **kwargs): - """Call the function, and then convert all 0 dimensional array - instances in the function to float numbers if out argument is not - provided. + """ + Call the function, and then convert all 0 dimensional array instances in the + function to float numbers if out argument is not provided. Parameters ---------- @@ -282,7 +282,8 @@ def _from_zero_dim_arrays_to_scalar(*args, **kwargs): def handle_numpy_casting(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_numpy_casting(*args, casting="same_kind", dtype=None, **kwargs): - """Check numpy casting type. + """ + Check numpy casting type. Parameters ---------- @@ -343,8 +344,8 @@ def _handle_numpy_casting(*args, casting="same_kind", dtype=None, **kwargs): def handle_numpy_casting_special(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_numpy_casting_special(*args, casting="same_kind", dtype=None, **kwargs): - """Check numpy casting type for special cases where output must be type - bool. + """ + Check numpy casting type for special cases where output must be type bool. Parameters ---------- @@ -432,9 +433,10 @@ def _handle_numpy_out(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_np(*args, **kwargs): - """Convert all `ndarray` instances in both the positional and keyword - arguments into `ivy.Array` instances, and then call the function with - the updated arguments. + """ + Convert all `ndarray` instances in both the positional and keyword arguments + into `ivy.Array` instances, and then call the function with the updated + arguments. Parameters ---------- @@ -461,8 +463,9 @@ def _inputs_to_ivy_arrays_np(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays(*args, order="K", **kwargs): - """Call the function, and then convert all `ivy.Array` instances - returned by the function into `ndarray` instances. + """ + Call the function, and then convert all `ivy.Array` instances returned by the + function into `ndarray` instances. Returns ------- @@ -524,7 +527,8 @@ def _outputs_to_frontend_arrays(*args, order="K", **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """Wrap `fn` so it receives and returns `ivy.Array` instances. + """ + Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray` instances. diff --git a/ivy/functional/frontends/numpy/statistics/order_statistics.py b/ivy/functional/frontends/numpy/statistics/order_statistics.py index 63209ffe912fa..1484182c4f62a 100644 --- a/ivy/functional/frontends/numpy/statistics/order_statistics.py +++ b/ivy/functional/frontends/numpy/statistics/order_statistics.py @@ -11,7 +11,8 @@ def _cpercentile(N, percent, key=lambda x: x): - """Find the percentile of a list of values. + """ + Find the percentile of a list of values. @parameter N - is a list of values. Note N MUST BE already sorted. @parameter percent - a float value from 0.0 to 1.0. diff --git a/ivy/functional/frontends/onnx/__init__.py b/ivy/functional/frontends/onnx/__init__.py index 46a5fb5daad61..0c0b59d24c907 100644 --- a/ivy/functional/frontends/onnx/__init__.py +++ b/ivy/functional/frontends/onnx/__init__.py @@ -191,8 +191,8 @@ def promote_types_onnx( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """Promote the datatypes type1 and type2, returning the data type they - promote to. + """ + Promote the datatypes type1 and type2, returning the data type they promote to. Parameters ---------- @@ -219,8 +219,9 @@ def promote_types_of_onnx_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """Promote the dtype of the given native array inputs to a common dtype - based on type promotion rules. + """ + Promote the dtype of the given native array inputs to a common dtype based on type + promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/onnx/func_wrapper.py b/ivy/functional/frontends/onnx/func_wrapper.py index 2bd6adaa3cb1e..fb60b19615381 100644 --- a/ivy/functional/frontends/onnx/func_wrapper.py +++ b/ivy/functional/frontends/onnx/func_wrapper.py @@ -49,7 +49,8 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_onnx(*args, **kwargs): - """Convert `Tensor` into `ivy.Array` instances. + """ + Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then calls the @@ -70,7 +71,8 @@ def _inputs_to_ivy_arrays_onnx(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_onnx(*args, **kwargs): - """Convert `ivy.Array` into `Tensor` instances. + """ + Convert `ivy.Array` into `Tensor` instances. Call the function, and then converts all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -87,7 +89,8 @@ def _outputs_to_frontend_arrays_onnx(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """Wrap `fn` so it receives and returns `ivy.Array` instances. + """ + Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray.NDArray` diff --git a/ivy/functional/frontends/paddle/__init__.py b/ivy/functional/frontends/paddle/__init__.py index 58ae61580f139..be293ee475839 100644 --- a/ivy/functional/frontends/paddle/__init__.py +++ b/ivy/functional/frontends/paddle/__init__.py @@ -156,8 +156,8 @@ def promote_types_paddle( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """Promote the datatypes type1 and type2, returning the data type they - promote to. + """ + Promote the datatypes type1 and type2, returning the data type they promote to. Parameters ---------- @@ -184,8 +184,9 @@ def promote_types_of_paddle_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """Promote the dtype of the given native array inputs to a common dtype - based on type promotion rules. + """ + Promote the dtype of the given native array inputs to a common dtype based on type + promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index bc72bd9aa7df1..5ea418f5153e6 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -97,8 +97,8 @@ def fftshift(x, axes=None, name=None): ) @to_ivy_arrays_and_back def hfft(x, n=None, axes=-1, norm="backward", name=None): - """Compute the FFT of a signal that has Hermitian symmetry, resulting in a - real spectrum.""" + """Compute the FFT of a signal that has Hermitian symmetry, resulting in a real + spectrum.""" # Determine the input shape and axis length input_shape = x.shape input_len = input_shape[axes] diff --git a/ivy/functional/frontends/paddle/func_wrapper.py b/ivy/functional/frontends/paddle/func_wrapper.py index 4bc7db1821eb0..c8c9e13acb0e0 100644 --- a/ivy/functional/frontends/paddle/func_wrapper.py +++ b/ivy/functional/frontends/paddle/func_wrapper.py @@ -41,7 +41,8 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def new_fn(*args, **kwargs): - """Convert `Tensor` into `ivy.Array` instances. + """ + Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -63,7 +64,8 @@ def new_fn(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def new_fn(*args, **kwargs): - """Convert `ivy.Array` into `Tensor` instances. + """ + Convert `ivy.Array` into `Tensor` instances. Call the function, and then convert all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -87,7 +89,8 @@ def new_fn(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """Wrap `fn` so it receives and returns `ivy.Array` instances. + """ + Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `Tensor` instances. diff --git a/ivy/functional/frontends/tensorflow/__init__.py b/ivy/functional/frontends/tensorflow/__init__.py index fb8077c3672b7..8f41d31818161 100644 --- a/ivy/functional/frontends/tensorflow/__init__.py +++ b/ivy/functional/frontends/tensorflow/__init__.py @@ -53,9 +53,10 @@ @handle_exceptions def check_tensorflow_casting(x1, x2): - """Check whether the two arguments provided in the function have the same - dtype, unless one of them is an array_like or scalar, where it gets casted - to the other input's dtype. + """ + Check whether the two arguments provided in the function have the same dtype, unless + one of them is an array_like or scalar, where it gets casted to the other input's + dtype. Parameters ---------- diff --git a/ivy/functional/frontends/tensorflow/func_wrapper.py b/ivy/functional/frontends/tensorflow/func_wrapper.py index a25c8418885e2..c72ff5565a19d 100644 --- a/ivy/functional/frontends/tensorflow/func_wrapper.py +++ b/ivy/functional/frontends/tensorflow/func_wrapper.py @@ -37,7 +37,8 @@ def _to_ivy_array(x): # update kwargs dictionary keys helper def _update_kwarg_keys(kwargs: Dict, to_update: Dict) -> Dict: - """Update the key-word only arguments dictionary. + """ + Update the key-word only arguments dictionary. Parameters ---------- @@ -99,9 +100,10 @@ def _handle_tf_dtype(*args, dtype=None, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_tf(*args, **kwargs): - """Convert all `TensorFlow.Tensor` instances in both the positional and - keyword arguments into `ivy.Array` instances, and then call the - function with the updated arguments. + """ + Convert all `TensorFlow.Tensor` instances in both the positional and keyword + arguments into `ivy.Array` instances, and then call the function with the + updated arguments. Parameters ---------- @@ -140,10 +142,10 @@ def _inputs_to_ivy_arrays_tf(*args, **kwargs): def map_raw_ops_alias( alias: callable, kwargs_to_update: Optional[Dict] = None ) -> callable: - """Map the raw_ops function with its respective frontend alias function, as - the implementations of raw_ops is way similar to that of frontend - functions, except that only arguments are passed as key-word only in - raw_ops functions. + """ + Map the raw_ops function with its respective frontend alias function, as the + implementations of raw_ops is way similar to that of frontend functions, except that + only arguments are passed as key-word only in raw_ops functions. Parameters ---------- @@ -197,8 +199,9 @@ def _wraped_fn(**kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_tf(*args, **kwargs): - """Call the function, and then convert all `tensorflow.Tensor` - instances in the function return into `ivy.Array` instances. + """ + Call the function, and then convert all `tensorflow.Tensor` instances in the + function return into `ivy.Array` instances. Parameters ---------- diff --git a/ivy/functional/frontends/tensorflow/variable.py b/ivy/functional/frontends/tensorflow/variable.py index bf6feeedde71d..d1c757e19fb9a 100644 --- a/ivy/functional/frontends/tensorflow/variable.py +++ b/ivy/functional/frontends/tensorflow/variable.py @@ -277,14 +277,12 @@ def indices(self): @property def dense_shape(self): - """A 1-D `Tensor` containing the shape of the corresponding dense - tensor.""" + """A 1-D `Tensor` containing the shape of the corresponding dense tensor.""" return self._dense_shape @property def device(self): - """The name of the device on which `values` will be produced, or - `None`.""" + """The name of the device on which `values` will be produced, or `None`.""" return self.values.device @property diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index d502cb7e90d50..e871198f0a823 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -191,8 +191,8 @@ def promote_types_torch( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """Promote the datatypes type1 and type2, returning the data type they - promote to. + """ + Promote the datatypes type1 and type2, returning the data type they promote to. Parameters ---------- @@ -221,8 +221,9 @@ def promote_types_of_torch_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """Promote the dtype of the given native array inputs to a common dtype - based on type promotion rules. + """ + Promote the dtype of the given native array inputs to a common dtype based on type + promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/torch/func_wrapper.py b/ivy/functional/frontends/torch/func_wrapper.py index c7df1998d4faa..c79cdd9782ceb 100644 --- a/ivy/functional/frontends/torch/func_wrapper.py +++ b/ivy/functional/frontends/torch/func_wrapper.py @@ -131,7 +131,8 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_torch(*args, **kwargs): - """Convert `Tensor` into `ivy.Array` instances. + """ + Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -168,7 +169,8 @@ def wrapper(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def outputs_to_frontend_arrays_torch(*args, **kwargs): - """Convert `ivy.Array` into `Tensor` instances. + """ + Convert `ivy.Array` into `Tensor` instances. Call the function, and then convert all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -265,7 +267,8 @@ def outputs_to_native_arrays_torch(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """Wrap `fn` so it receives and returns `ivy.Array` instances. + """ + Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `Tensor` instances. @@ -274,7 +277,8 @@ def to_ivy_arrays_and_back(fn: Callable) -> Callable: def to_ivy_shape(fn: Callable) -> Callable: - """Wrap `fn` so it receives `ivy.Shape` instances. + """ + Wrap `fn` so it receives `ivy.Shape` instances. Wrap `fn` so that any `torch_frontend.Size` arguments are converted to `ivy.Shape` instances. diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 86dd7263f24b1..341bebad429ad 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -277,7 +277,8 @@ def atan2(self, other): return torch_frontend.atan2(self, other) def view(self, *args, size=None): - """Reshape Tensor. + """ + Reshape Tensor. possible arguments are either: - size diff --git a/ivy/functional/frontends/xgboost/core.py b/ivy/functional/frontends/xgboost/core.py index c5404abf5d839..8e8dbf9b557f4 100644 --- a/ivy/functional/frontends/xgboost/core.py +++ b/ivy/functional/frontends/xgboost/core.py @@ -123,8 +123,9 @@ def __init__(self, params=None, cache=None, model_file=None, compile=False): self._comp_binary_prediction(self.gbm.obj, cache[1]) def update(self, dtrain, dlabel, iteration, fobj=None): - """Update for one iteration, with objective function calculated - internally. This function should not be called directly by users. + """ + Update for one iteration, with objective function calculated internally. This + function should not be called directly by users. Parameters ---------- @@ -155,10 +156,11 @@ def predict( iteration_range=(0, 0), strict_shape=False, ): - """Predict with data. The full model will be used unless - `iteration_range` is specified, meaning user have to either slice the - model or use the ``best_iteration`` attribute to get prediction from - best model returned from early stopping. + """ + Predict with data. The full model will be used unless `iteration_range` is + specified, meaning user have to either slice the model or use the + ``best_iteration`` attribute to get prediction from best model returned from + early stopping. Parameters ---------- diff --git a/ivy/functional/frontends/xgboost/linear/updater_coordinate.py b/ivy/functional/frontends/xgboost/linear/updater_coordinate.py index 7b7c08a64e716..284fc2f5a64a0 100644 --- a/ivy/functional/frontends/xgboost/linear/updater_coordinate.py +++ b/ivy/functional/frontends/xgboost/linear/updater_coordinate.py @@ -8,15 +8,15 @@ def coordinate_updater(gpair, data, lr, weight, n_feat, n_iter, reg_alpha, reg_lambda): - """Implements one step of coordinate descent. The original optimizer - implements parallel calculations. The below code is an approximation of the - original one, but rather than computing the update direction for a single - parameter at a time using a for loop and cumulative gradients, it does the - update in parallel by means of matrix-vector multiplications. Given that - xgboost's updater is non-deterministic, the approximated and original - implementations converge to pretty the same optima, resulting in metrics' - values(accuracy, f1-score) differing at a level of 0.001(for separate runs - metrics may end up being the same). + """ + Implements one step of coordinate descent. The original optimizer implements + parallel calculations. The below code is an approximation of the original one, but + rather than computing the update direction for a single parameter at a time using a + for loop and cumulative gradients, it does the update in parallel by means of + matrix-vector multiplications. Given that xgboost's updater is non-deterministic, + the approximated and original implementations converge to pretty the same optima, + resulting in metrics' values(accuracy, f1-score) differing at a level of 0.001(for + separate runs metrics may end up being the same). Parameters ---------- diff --git a/ivy/functional/frontends/xgboost/sklearn.py b/ivy/functional/frontends/xgboost/sklearn.py index 3b80f8d6fa1fe..e2edeecb81802 100644 --- a/ivy/functional/frontends/xgboost/sklearn.py +++ b/ivy/functional/frontends/xgboost/sklearn.py @@ -98,8 +98,9 @@ def __sklearn_is_fitted__(self): return hasattr(self, "_Booster") def get_booster(self): - """Get the underlying xgboost Booster of this model. This will raise an - exception when fit was not called. + """ + Get the underlying xgboost Booster of this model. This will raise an exception + when fit was not called. Returns ------- @@ -175,7 +176,8 @@ def fit( feature_weights=None, callbacks=None, ): - """Fit gradient boosting model. + """ + Fit gradient boosting model. Note that calling ``fit()`` multiple times will cause the model object to be re-fit from scratch. To resume training from a previous checkpoint, explicitly diff --git a/ivy/functional/frontends/xgboost/training.py b/ivy/functional/frontends/xgboost/training.py index cc67edb9f478d..cc727add4c5a6 100644 --- a/ivy/functional/frontends/xgboost/training.py +++ b/ivy/functional/frontends/xgboost/training.py @@ -18,7 +18,8 @@ def train( callbacks=None, custom_metric=None, ): - """Train a booster with given parameters. + """ + Train a booster with given parameters. Parameters ---------- diff --git a/ivy/functional/ivy/activations.py b/ivy/functional/ivy/activations.py index 8d3803b6c0777..2468219b98cde 100644 --- a/ivy/functional/ivy/activations.py +++ b/ivy/functional/ivy/activations.py @@ -48,7 +48,8 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the Gaussian error linear unit (GELU) activation function. + """ + Apply the Gaussian error linear unit (GELU) activation function. Parameters ---------- @@ -137,7 +138,8 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the leaky rectified linear unit function element-wise. + """ + Apply the leaky rectified linear unit function element-wise. If the input is complex, then by default each element is scaled by `alpha` if either its real part is strictly negative or if its real part is zero and its @@ -216,7 +218,8 @@ def log_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the log_softmax function element-wise. + """ + Apply the log_softmax function element-wise. Parameters ---------- @@ -311,7 +314,8 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the rectified linear unit function element-wise. + """ + Apply the rectified linear unit function element-wise. If the input is complex, then by default each element is set to zero if either its real part is strictly negative or if its real part is zero and its @@ -382,7 +386,8 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the sigmoid function element-wise. + """ + Apply the sigmoid function element-wise. Parameters ---------- @@ -468,7 +473,8 @@ def softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the softmax function element-wise. + """ + Apply the softmax function element-wise. Parameters ---------- @@ -565,7 +571,8 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the softplus function element-wise. + """ + Apply the softplus function element-wise. If the input is complex, then by default we apply the softplus operation `log(1+ exp(x))` to each element @@ -633,7 +640,8 @@ def softsign( /, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the softsign function element-wise. + """ + Apply the softsign function element-wise. Parameters ---------- @@ -675,7 +683,8 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the mish activation function element-wise. + """ + Apply the mish activation function element-wise. Parameters ---------- @@ -750,7 +759,8 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the hardswish activation function element-wise. + """ + Apply the hardswish activation function element-wise. Parameters ---------- diff --git a/ivy/functional/ivy/control_flow_ops.py b/ivy/functional/ivy/control_flow_ops.py index 7537d6c202408..57a496e2c9b5c 100644 --- a/ivy/functional/ivy/control_flow_ops.py +++ b/ivy/functional/ivy/control_flow_ops.py @@ -17,9 +17,10 @@ def if_else( orelse_fn: Callable, vars: Dict[str, Union[ivy.Array, ivy.NativeArray]], ) -> Any: - """Take a condition function and two functions as input. If the condition - is True, the first function is executed and its result is returned. - Otherwise, the second function is executed and its result is returned. + """ + Take a condition function and two functions as input. If the condition is True, the + first function is executed and its result is returned. Otherwise, the second + function is executed and its result is returned. Parameters ---------- @@ -74,9 +75,9 @@ def while_loop( body_fn: Callable, vars: Dict[str, Union[ivy.Array, ivy.NativeArray]], ) -> Any: - """Take a test function, a body function and a set of variables as input. - The body function is executed repeatedly while the test function returns - True. + """ + Take a test function, a body function and a set of variables as input. The body + function is executed repeatedly while the test function returns True. Parameters ---------- @@ -126,8 +127,9 @@ def for_loop( body_fn: Callable, vars: Iterable[Union[ivy.Array, ivy.NativeArray]], ): - """Loops over an iterable, passing the current iteration along with a tuple - of variables into the provided body function. + """ + Loops over an iterable, passing the current iteration along with a tuple of + variables into the provided body function. Parameters ---------- diff --git a/ivy/functional/ivy/creation.py b/ivy/functional/ivy/creation.py index c032bc3b69134..44c9f370b04ed 100644 --- a/ivy/functional/ivy/creation.py +++ b/ivy/functional/ivy/creation.py @@ -44,9 +44,10 @@ def _asarray_handle_nestable(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_handle_nestable_wrapper(*args, **kwargs): - """Call `fn` with the *nestable* property of the function correctly - handled. This means mapping the function to the container leaves if any - containers are passed in the input. + """ + Call `fn` with the *nestable* property of the function correctly handled. This + means mapping the function to the container leaves if any containers are passed + in the input. Parameters ---------- @@ -135,9 +136,9 @@ def _remove_np_bfloat16(obj): def _asarray_to_native_arrays_and_back(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_to_native_arrays_and_back_wrapper(*args, dtype=None, **kwargs): - """Wrap `fn` so that input arrays are all converted to - `ivy.NativeArray` instances and return arrays are all converted to - `ivy.Array` instances. + """ + Wrap `fn` so that input arrays are all converted to `ivy.NativeArray` instances + and return arrays are all converted to `ivy.Array` instances. This wrapper is specifically for the backend implementations of asarray. @@ -159,9 +160,10 @@ def _asarray_to_native_arrays_and_back_wrapper(*args, dtype=None, **kwargs): def _asarray_infer_dtype(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_infer_dtype_wrapper(*args, dtype=None, **kwargs): - """Determine the correct `dtype`, and then calls the function with the - `dtype` passed explicitly. This wrapper is specifically for the backend - implementations of asarray. + """ + Determine the correct `dtype`, and then calls the function with the `dtype` + passed explicitly. This wrapper is specifically for the backend implementations + of asarray. Parameters ---------- @@ -216,9 +218,10 @@ def _infer_dtype(obj): def _asarray_infer_device(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_infer_device_wrapper(*args, device=None, **kwargs): - """Determine the correct `device`, and then calls the function with the - `device` passed explicitly. This wrapper is specifically for the - backend implementations of asarray. + """ + Determine the correct `device`, and then calls the function with the `device` + passed explicitly. This wrapper is specifically for the backend implementations + of asarray. Parameters ---------- @@ -296,8 +299,9 @@ def arange( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return evenly spaced values within a given interval, with the spacing - being specified. + """ + Return evenly spaced values within a given interval, with the spacing being + specified. Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function @@ -407,7 +411,8 @@ def asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Convert the input to an array. + """ + Convert the input to an array. Parameters ---------- @@ -492,7 +497,8 @@ def zeros( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array having a specified ``shape`` and filled with zeros. + """ + Return a new array having a specified ``shape`` and filled with zeros. Parameters ---------- @@ -556,7 +562,8 @@ def ones( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array having a specified ``shape`` and filled with ones. + """ + Return a new array having a specified ``shape`` and filled with ones. .. note:: @@ -654,8 +661,9 @@ def full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array filled with ``fill_value`` and having the same - ``shape`` as an input array ``x`` . + """ + Return a new array filled with ``fill_value`` and having the same ``shape`` as an + input array ``x`` . Parameters ---------- @@ -761,8 +769,9 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array filled with ones and having the same shape as an - input array ``x``. + """ + Return a new array filled with ones and having the same shape as an input array + ``x``. .. note:: @@ -880,8 +889,9 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array filled with zeros and having the same ``shape`` as an - input array ``x``. + """ + Return a new array filled with zeros and having the same ``shape`` as an input array + ``x``. Parameters ---------- @@ -992,8 +1002,8 @@ def tril( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the lower triangular part of a matrix (or a stack of matrices) - ``x``. + """ + Return the lower triangular part of a matrix (or a stack of matrices) ``x``. .. note:: @@ -1048,8 +1058,8 @@ def triu( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the upper triangular part of a matrix (or a stack of matrices) - ``x``. + """ + Return the upper triangular part of a matrix (or a stack of matrices) ``x``. .. note:: @@ -1106,7 +1116,8 @@ def empty( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array of given shape and type, filled with zeros. + """ + Return a new array of given shape and type, filled with zeros. Parameters ---------- @@ -1156,7 +1167,8 @@ def empty_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return an uninitialized array with the same shape as an input array x. + """ + Return an uninitialized array with the same shape as an input array x. Parameters ---------- @@ -1210,8 +1222,8 @@ def eye( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a two-dimensional array with ones on the k diagonal and zeros - elsewhere. + """ + Return a two-dimensional array with ones on the k diagonal and zeros elsewhere. Parameters ---------- @@ -1353,8 +1365,8 @@ def linspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Generate a certain number of evenly-spaced values in an interval along a - given axis. + """ + Generate a certain number of evenly-spaced values in an interval along a given axis. See :math:`arange` that allows to specify the step size of evenly spaced values in an interval. @@ -1456,7 +1468,8 @@ def meshgrid( indexing: str = "xy", out: Optional[ivy.Array] = None, ) -> List[ivy.Array]: - """Return coordinate matrices from coordinate vectors. + """ + Return coordinate matrices from coordinate vectors. Parameters ---------- @@ -1580,8 +1593,8 @@ def full( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array having a specified ``shape`` and filled with - ``fill_value``. + """ + Return a new array having a specified ``shape`` and filled with ``fill_value``. Parameters ---------- @@ -1683,7 +1696,8 @@ def full( def to_dlpack( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ): - """Return PyCapsule Object. + """ + Return PyCapsule Object. Parameters ---------- @@ -1722,8 +1736,9 @@ def to_dlpack( def from_dlpack( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """Return a new array containing the data from another (array) object with - a ``__dlpack__`` method or PyCapsule Object. + """ + Return a new array containing the data from another (array) object with a + ``__dlpack__`` method or PyCapsule Object. Parameters ---------- @@ -1779,7 +1794,8 @@ def copy_array( to_ivy_array: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Copy an array. + """ + Copy an array. Parameters ---------- @@ -1884,7 +1900,8 @@ def native_array( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.NativeArray: - """Convert the input to a native array. + """ + Convert the input to a native array. Parameters ---------- @@ -1948,9 +1965,9 @@ def one_hot( device: Union[ivy.Device, ivy.NativeDevice] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a one-hot array. The locations represented by indices in the - parameter indices take value on_value, while all other locations take value - off_value. + """ + Return a one-hot array. The locations represented by indices in the parameter + indices take value on_value, while all other locations take value off_value. Parameters ---------- @@ -2064,8 +2081,9 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Generate a certain number of evenly-spaced values in log space, in an - interval along a given axis. + """ + Generate a certain number of evenly-spaced values in log space, in an interval along + a given axis. Parameters ---------- @@ -2168,7 +2186,8 @@ def frombuffer( count: Optional[int] = -1, offset: Optional[int] = 0, ) -> ivy.Array: - r"""Interpret a buffer as a 1-dimensional array. + r""" + Interpret a buffer as a 1-dimensional array. .. note:: Note that either of the following must be true: @@ -2233,16 +2252,16 @@ def triu_indices( *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Tuple[ivy.Array]: - """Return the indices of the upper triangular part of a row by col matrix - in a 2-by-N shape (tuple of two N dimensional arrays), where the first row - contains row coordinates of all indices and the second row contains column - coordinates. Indices are ordered based on rows and then columns. The upper - triangular part of the matrix is defined as the elements on and above the - diagonal. The argument k controls which diagonal to consider. If k = 0, - all elements on and above the main diagonal are retained. A positive value - excludes just as many diagonals above the main diagonal, and similarly a - negative value includes just as many diagonals below the main diagonal. The - main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, + """ + Return the indices of the upper triangular part of a row by col matrix in a 2-by-N + shape (tuple of two N dimensional arrays), where the first row contains row + coordinates of all indices and the second row contains column coordinates. Indices + are ordered based on rows and then columns. The upper triangular part of the matrix + is defined as the elements on and above the diagonal. The argument k controls which + diagonal to consider. If k = 0, all elements on and above the main diagonal are + retained. A positive value excludes just as many diagonals above the main diagonal, + and similarly a negative value includes just as many diagonals below the main + diagonal. The main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, n_cols}−1]. Notes diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index 5e418ff22ec49..e6a9f835c49b3 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -290,8 +290,8 @@ def astype( copy: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Copy an array to a specified data type irrespective of :ref:`type- - promotion` rules. + """ + Copy an array to a specified data type irrespective of :ref:`type- promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -390,7 +390,8 @@ def astype( @handle_array_function @handle_device def broadcast_arrays(*arrays: Union[ivy.Array, ivy.NativeArray]) -> List[ivy.Array]: - """Broadcasts one or more arrays against one another. + """ + Broadcasts one or more arrays against one another. Parameters ---------- @@ -477,7 +478,8 @@ def broadcast_to( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Broadcasts an array to a specified shape. + """ + Broadcasts an array to a specified shape. Parameters ---------- @@ -545,8 +547,9 @@ def can_cast( to: ivy.Dtype, /, ) -> bool: - """Determine if one data type can be cast to another data type according to - :ref:`type- promotion` rules. + """ + Determine if one data type can be cast to another data type according to :ref:`type- + promotion` rules. Parameters ---------- @@ -619,7 +622,8 @@ def finfo( type: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray], /, ) -> Finfo: - """Machine limits for floating-point data types. + """ + Machine limits for floating-point data types. Parameters ---------- @@ -706,7 +710,8 @@ def iinfo( type: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray], /, ) -> Iinfo: - """Machine limits for integer data types. + """ + Machine limits for integer data types. Parameters ---------- @@ -782,8 +787,9 @@ def iinfo( def result_type( *arrays_and_dtypes: Union[ivy.Array, ivy.NativeArray, ivy.Dtype] ) -> ivy.Dtype: - """Return the dtype that results from applying the type promotion rules - (see :ref:`type-promotion`) to the arguments. + """ + Return the dtype that results from applying the type promotion rules (see + :ref:`type-promotion`) to the arguments. .. note:: If provided mixed dtypes (e.g., integer and floating-point), the returned dtype @@ -936,7 +942,8 @@ def __exit__(self, exc_type, exc_val, exc_tb): @handle_exceptions def dtype_bits(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str], /) -> int: - """Get the number of bits used for representing the input data type. + """ + Get the number of bits used for representing the input data type. Parameters ---------- @@ -971,7 +978,8 @@ def dtype_bits(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str], /) -> int: @handle_exceptions def is_hashable_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: - """Check if the given data type is hashable or not. + """ + Check if the given data type is hashable or not. Parameters ---------- @@ -996,7 +1004,8 @@ def is_hashable_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: @handle_exceptions def as_ivy_dtype(dtype_in: Union[ivy.Dtype, str], /) -> ivy.Dtype: - """Convert native data type to string representation. + """ + Convert native data type to string representation. Parameters ---------- @@ -1013,7 +1022,8 @@ def as_ivy_dtype(dtype_in: Union[ivy.Dtype, str], /) -> ivy.Dtype: @handle_exceptions def as_native_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> ivy.NativeDtype: - """Convert data type string representation to native data type. + """ + Convert data type string representation to native data type. Parameters ---------- @@ -1049,7 +1059,8 @@ def _check_complex128(input) -> bool: @handle_exceptions def closest_valid_dtype(type: Union[ivy.Dtype, str, None], /) -> Union[ivy.Dtype, str]: - """Determine the closest valid datatype to the datatype passed as input. + """ + Determine the closest valid datatype to the datatype passed as input. Parameters ---------- @@ -1186,7 +1197,8 @@ def default_float_dtype( def infer_default_dtype( dtype: Union[ivy.Dtype, ivy.NativeDtype, str], as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """Summary. + """ + Summary. Parameters ---------- @@ -1642,7 +1654,8 @@ def default_complex_dtype( def dtype( x: Union[ivy.Array, ivy.NativeArray], *, as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """Get the data type for input array x. + """ + Get the data type for input array x. Parameters ---------- @@ -1686,10 +1699,10 @@ def dtype( @handle_exceptions @handle_nestable def function_supported_dtypes(fn: Callable, recurse: bool = True) -> Union[Tuple, dict]: - """Return the supported data types of the current backend's function. The - function returns a dict containing the supported dtypes for the - compositional and primary implementations in case of partial mixed - functions. + """ + Return the supported data types of the current backend's function. The function + returns a dict containing the supported dtypes for the compositional and primary + implementations in case of partial mixed functions. Parameters ---------- @@ -1737,10 +1750,10 @@ def function_supported_dtypes(fn: Callable, recurse: bool = True) -> Union[Tuple def function_unsupported_dtypes( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """Return the unsupported data types of the current backend's function. The - function returns a dict containing the unsupported dtypes for the - compositional and primary implementations in case of partial mixed - functions. + """ + Return the unsupported data types of the current backend's function. The function + returns a dict containing the unsupported dtypes for the compositional and primary + implementations in case of partial mixed functions. Parameters ---------- @@ -1786,8 +1799,8 @@ def function_unsupported_dtypes( @handle_exceptions def invalid_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str, None], /) -> bool: - """Determine whether the provided data type is not support by the current - framework. + """ + Determine whether the provided data type is not support by the current framework. Parameters ---------- @@ -1825,7 +1838,8 @@ def is_bool_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """Determine whether the input data type is a bool data type. + """ + Determine whether the input data type is a bool data type. Parameters ---------- @@ -1864,7 +1878,8 @@ def is_int_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """Determine whether the input data type is an int data type. + """ + Determine whether the input data type is an int data type. Parameters ---------- @@ -1939,7 +1954,8 @@ def nested_fun(x): @handle_exceptions def check_float(x: Any) -> bool: - """Check if the input is a float or a float-like object. + """ + Check if the input is a float or a float-like object. Parameters ---------- @@ -1961,7 +1977,8 @@ def is_float_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """Determine whether the input data type is a float dtype. + """ + Determine whether the input data type is a float dtype. Parameters ---------- @@ -2009,7 +2026,8 @@ def is_uint_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """Determine whether the input data type is a uint dtype. + """ + Determine whether the input data type is a uint dtype. Parameters ---------- @@ -2056,7 +2074,8 @@ def is_complex_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """Determine whether the input data type is a complex dtype. + """ + Determine whether the input data type is a complex dtype. Parameters ---------- @@ -2104,8 +2123,8 @@ def promote_types( *, array_api_promotion: bool = False, ) -> ivy.Dtype: - """Promote the datatypes type1 and type2, returning the data type they - promote to. + """ + Promote the datatypes type1 and type2, returning the data type they promote to. Parameters ---------- @@ -2139,7 +2158,8 @@ def _promote(query): @handle_exceptions def set_default_dtype(dtype: Union[ivy.Dtype, ivy.NativeDtype, str], /): - """Set the datatype `dtype` as default data type. + """ + Set the datatype `dtype` as default data type. Parameters ---------- @@ -2174,7 +2194,8 @@ def set_default_dtype(dtype: Union[ivy.Dtype, ivy.NativeDtype, str], /): @handle_exceptions def set_default_float_dtype(float_dtype: Union[ivy.Dtype, str], /): - """Set the 'float_dtype' as the default data type. + """ + Set the 'float_dtype' as the default data type. Parameters ---------- @@ -2201,7 +2222,8 @@ def set_default_float_dtype(float_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_int_dtype(int_dtype: Union[ivy.Dtype, str], /): - """Set the 'int_dtype' as the default data type. + """ + Set the 'int_dtype' as the default data type. Parameters ---------- @@ -2228,7 +2250,8 @@ def set_default_int_dtype(int_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_uint_dtype(uint_dtype: Union[ivy.Dtype, str], /): - """Set the uint dtype to be default. + """ + Set the uint dtype to be default. Parameters ---------- @@ -2253,7 +2276,8 @@ def set_default_uint_dtype(uint_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_complex_dtype(complex_dtype: Union[ivy.Dtype, str], /): - """Set the 'complex_dtype' as the default data type. + """ + Set the 'complex_dtype' as the default data type. Parameters ---------- @@ -2284,8 +2308,9 @@ def type_promote_arrays( x2: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple: - """Type promote the input arrays, returning new arrays with the shared - correct data type. + """ + Type promote the input arrays, returning new arrays with the shared correct data + type. Parameters ---------- @@ -2305,7 +2330,8 @@ def type_promote_arrays( @handle_exceptions def unset_default_dtype(): - """Reset the current default dtype to the previous state. + """ + Reset the current default dtype to the previous state. Examples -------- @@ -2329,7 +2355,8 @@ def unset_default_dtype(): @handle_exceptions def unset_default_float_dtype(): - """Reset the current default float dtype to the previous state. + """ + Reset the current default float dtype to the previous state. Examples -------- @@ -2349,7 +2376,8 @@ def unset_default_float_dtype(): @handle_exceptions def unset_default_int_dtype(): - """Reset the current default int dtype to the previous state. + """ + Reset the current default int dtype to the previous state. Examples -------- @@ -2368,7 +2396,8 @@ def unset_default_int_dtype(): @handle_exceptions def unset_default_uint_dtype(): - """Reset the current default uint dtype to the previous state. + """ + Reset the current default uint dtype to the previous state. Examples -------- @@ -2387,7 +2416,8 @@ def unset_default_uint_dtype(): @handle_exceptions def unset_default_complex_dtype(): - """Reset the current default complex dtype to the previous state. + """ + Reset the current default complex dtype to the previous state. Examples -------- @@ -2407,8 +2437,8 @@ def unset_default_complex_dtype(): @handle_exceptions def valid_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str, None], /) -> bool: - """Determine whether the provided data type is supported by the current - framework. + """ + Determine whether the provided data type is supported by the current framework. Parameters ---------- @@ -2447,8 +2477,9 @@ def promote_types_of_inputs( *, array_api_promotion: bool = False, ) -> Tuple[ivy.NativeArray, ivy.NativeArray]: - """Promote the dtype of the given native array inputs to a common dtype - based on type promotion rules. + """ + Promote the dtype of the given native array inputs to a common dtype based on type + promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an @@ -2496,7 +2527,8 @@ def _get_target_dtype(scalar, arr): @handle_exceptions def is_native_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: - """Determine whether the input dtype is a Native dtype. + """ + Determine whether the input dtype is a Native dtype. Parameters ---------- diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index 9187040ad1ffc..d02cbf35ee381 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -59,7 +59,8 @@ def __init__( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> None: - """Initialize the DefaultDevice class. + """ + Initialize the DefaultDevice class. Parameters ---------- @@ -75,7 +76,8 @@ def __init__( self._dev = device def __enter__(self): - """Enter the runtime context related to the specified device. + """ + Enter the runtime context related to the specified device. Returns ------- @@ -101,7 +103,8 @@ def __exit__( exc_val: Optional[Type[BaseException]], exc_tb: Optional[types.TracebackType], ) -> Union[ivy.Device, str]: - """Exit the runtime context related to the specified device. + """ + Exit the runtime context related to the specified device. Parameters ---------- @@ -175,7 +178,8 @@ def get_all_ivy_arrays_on_dev( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> ivy.Container: - """Get all ivy arrays which are currently alive on the specified device. + """ + Get all ivy arrays which are currently alive on the specified device. Parameters ---------- @@ -210,8 +214,8 @@ def get_all_ivy_arrays_on_dev( @handle_exceptions def num_ivy_arrays_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> int: - """Return the number of arrays which are currently alive on the specified - device. + """ + Return the number of arrays which are currently alive on the specified device. Parameters ---------- @@ -252,8 +256,9 @@ def print_all_ivy_arrays_on_dev( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, attr_only: bool = True, ) -> None: - """Print the shape and dtype for all ivy arrays which are currently alive - on the specified device. + """ + Print the shape and dtype for all ivy arrays which are currently alive on the + specified device. Parameters ---------- @@ -290,8 +295,9 @@ def print_all_ivy_arrays_on_dev( @handle_exceptions def set_soft_device_mode(mode: bool) -> None: - """Set the mode of whether to move input arrays to `ivy.default_device()` - before performing an operation. + """ + Set the mode of whether to move input arrays to `ivy.default_device()` before + performing an operation. Parameter --------- @@ -315,8 +321,9 @@ def set_soft_device_mode(mode: bool) -> None: @handle_exceptions def unset_soft_device_mode() -> None: - """Reset the mode of moving input arrays to `ivy.default_device()` before - performing an operation. + """ + Reset the mode of moving input arrays to `ivy.default_device()` before performing an + operation. Examples -------- @@ -344,7 +351,8 @@ def unset_soft_device_mode() -> None: def dev( x: Union[ivy.Array, ivy.NativeArray], /, *, as_native: bool = False ) -> Union[ivy.Device, ivy.NativeDevice]: - """Get the native device handle for input array x. + """ + Get the native device handle for input array x. Parameters ---------- @@ -382,7 +390,8 @@ def dev( @handle_exceptions def as_ivy_dev(device: Union[ivy.Device, str], /) -> ivy.Device: - """Convert device to string representation. + """ + Convert device to string representation. Parameters ---------- @@ -405,7 +414,8 @@ def as_ivy_dev(device: Union[ivy.Device, str], /) -> ivy.Device: @handle_exceptions def as_native_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> ivy.NativeDevice: - """Convert device string representation to native device type. + """ + Convert device string representation to native device type. Parameters ---------- @@ -449,7 +459,8 @@ def as_native_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> ivy.NativeD @handle_exceptions def clear_cached_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: - """Clear memory cache on target device. + """ + Clear memory cache on target device. Parameters ---------- @@ -468,8 +479,9 @@ def clear_cached_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> N @handle_exceptions def total_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> float: - """Get the total amount of memory (in GB) for a given device string. In - case of CPU, the total RAM is returned. + """ + Get the total amount of memory (in GB) for a given device string. In case of CPU, + the total RAM is returned. Parameters ---------- @@ -511,8 +523,9 @@ def used_mem_on_dev( *, process_specific: bool = False, ) -> float: - """Get the used memory (in GB) for a given device string. In case of CPU, - the used RAM is returned. + """ + Get the used memory (in GB) for a given device string. In case of CPU, the used RAM + is returned. Parameters ---------- @@ -570,8 +583,9 @@ def percent_used_mem_on_dev( *, process_specific: bool = False, ) -> float: - """Get the percentage used memory for a given device string. In case of - CPU, the used RAM is returned. + """ + Get the percentage used memory for a given device string. In case of CPU, the used + RAM is returned. Parameters ---------- @@ -631,7 +645,8 @@ def dev_util( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> float: - """Get the current utilization (%) for a given device. + """ + Get the current utilization (%) for a given device. Parameters ---------- @@ -673,7 +688,8 @@ def dev_util( @handle_exceptions def gpu_is_available() -> bool: - """Determine whether a GPU is available to use, with the backend framework. + """ + Determine whether a GPU is available to use, with the backend framework. Returns ------- @@ -690,7 +706,8 @@ def gpu_is_available() -> bool: @handle_exceptions def num_cpu_cores(*, logical: bool = True) -> int: - """Determine the number of cores available in the cpu. + """ + Determine the number of cores available in the cpu. Parameters ---------- @@ -715,7 +732,8 @@ def num_cpu_cores(*, logical: bool = True) -> int: @handle_exceptions def num_gpus() -> int: - """Determine the number of available GPUs, with the backend framework. + """ + Determine the number of available GPUs, with the backend framework. Returns ------- @@ -732,7 +750,8 @@ def num_gpus() -> int: @handle_exceptions def tpu_is_available() -> bool: - """Determine whether a TPU is available to use, with the backend framework. + """ + Determine whether a TPU is available to use, with the backend framework. Returns ------- @@ -760,11 +779,12 @@ def default_device( item: Optional[Union[list, tuple, dict, ivy.Array, ivy.NativeArray]] = None, as_native: Optional[bool] = None, ) -> Union[ivy.Device, ivy.NativeDevice]: - """Return the input device or the default device. If the as_native flag is - set, the device will be converted to a native device. If the item is - provided, the item's device is returned. If the device is not provided, the - last default device is returned. If a default device has not been set, the - first gpu is returned if available, otherwise the cpu is returned. + """ + Return the input device or the default device. If the as_native flag is set, the + device will be converted to a native device. If the item is provided, the item's + device is returned. If the device is not provided, the last default device is + returned. If a default device has not been set, the first gpu is returned if + available, otherwise the cpu is returned. Parameters ---------- @@ -826,7 +846,8 @@ def default_device( @handle_exceptions def set_default_device(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: - """Set the default device to given device instance. + """ + Set the default device to given device instance. Parameters ---------- @@ -857,7 +878,8 @@ def set_default_device(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: @handle_exceptions def unset_default_device() -> None: - """Reset the default device to "cpu". + """ + Reset the default device to "cpu". Examples -------- @@ -890,8 +912,8 @@ def to_device( stream: Optional[Union[int, Any]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Move the input array x to the desired device, specified by device - string. + """ + Move the input array x to the desired device, specified by device string. Parameters ---------- @@ -931,8 +953,9 @@ def split_factor( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, /, ) -> float: - """Get a device's global split factor, which can be used to scale the - device's batch splitting chunk sizes across the codebase. + """ + Get a device's global split factor, which can be used to scale the device's batch + splitting chunk sizes across the codebase. If the global split factor is set for a given device, returns the split factor value for the device from the split factors dictionary @@ -968,8 +991,9 @@ def split_factor( def set_split_factor( factor: float, /, *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None ) -> None: - """Set the global split factor for a given device, which can be used to - scale batch splitting chunk sizes for the device across the codebase. + """ + Set the global split factor for a given device, which can be used to scale batch + splitting chunk sizes for the device across the codebase. Parameters ---------- @@ -1026,9 +1050,10 @@ def split_func_call( stop_gradients: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Call a function by splitting its inputs along a given axis, and calling - the function in chunks, rather than feeding the entire input array at once. - This can be useful to reduce memory usage of the device the arrays are on. + """ + Call a function by splitting its inputs along a given axis, and calling the function + in chunks, rather than feeding the entire input array at once. This can be useful to + reduce memory usage of the device the arrays are on. Parameters ---------- @@ -1201,10 +1226,10 @@ def _get_devices(fn: Callable, complement: bool = True) -> Tuple: def function_supported_devices( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """Return the supported devices of the current backend's function. The - function returns a dict containing the supported devices for the - compositional and primary implementations in case of partial mixed - functions. + """ + Return the supported devices of the current backend's function. The function returns + a dict containing the supported devices for the compositional and primary + implementations in case of partial mixed functions. Parameters ---------- @@ -1253,10 +1278,10 @@ def function_supported_devices( def function_unsupported_devices( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """Return the unsupported devices of the current backend's function. The - function returns a dict containing the unsupported devices for the - compositional and primary implementations in case of partial mixed - functions. + """ + Return the unsupported devices of the current backend's function. The function + returns a dict containing the unsupported devices for the compositional and primary + implementations in case of partial mixed functions. Parameters ---------- @@ -1302,7 +1327,8 @@ def function_unsupported_devices( class Profiler(abc.ABC): - """The profiler class is used to profile the execution of some code. + """ + The profiler class is used to profile the execution of some code. Parameters ---------- @@ -1315,7 +1341,8 @@ def __init__(self, save_dir: str): @abc.abstractmethod def start(self): - """Start the profiler. + """ + Start the profiler. This should be called before the code to be profiled. """ @@ -1323,7 +1350,8 @@ def start(self): @abc.abstractmethod def stop(self): - """Stop the profiler. + """ + Stop the profiler. This should be called after the code to be profiled. """ diff --git a/ivy/functional/ivy/elementwise.py b/ivy/functional/ivy/elementwise.py index 7997380dec22b..f5468af97cfa7 100644 --- a/ivy/functional/ivy/elementwise.py +++ b/ivy/functional/ivy/elementwise.py @@ -36,9 +36,10 @@ def abs( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: # noqa - """Calculate the absolute value for each element ``x_i`` of the input array - ``x`` (i.e., the element-wise result has the same magnitude as the - respective element in ``x`` but has positive sign). + """ + Calculate the absolute value for each element ``x_i`` of the input array ``x`` + (i.e., the element-wise result has the same magnitude as the respective element in + ``x`` but has positive sign). .. note:: For signed integer data types, the absolute value of the minimum representable @@ -139,10 +140,10 @@ def acos( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation of the principal - value of the inverse cosine, having domain [-1, +1] and codomain [+0, +π], - for each element x_i of the input array x. Each element-wise result is - expressed in radians. + """ + Calculate an implementation-dependent approximation of the principal value of the + inverse cosine, having domain [-1, +1] and codomain [+0, +π], for each element x_i + of the input array x. Each element-wise result is expressed in radians. **Special cases** @@ -249,9 +250,10 @@ def acosh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to the inverse - hyperbolic cosine, having domain ``[+1, +infinity]`` and codomain ``[+0, - +infinity]``, for each element ``x_i`` of the input array ``x``. + """ + Calculate an implementation-dependent approximation to the inverse hyperbolic + cosine, having domain ``[+1, +infinity]`` and codomain ``[+0, +infinity]``, for each + element ``x_i`` of the input array ``x``. **Special cases** @@ -359,8 +361,9 @@ def add( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the sum for each element ``x1_i`` of the input array ``x1`` - with the respective element ``x2_i`` of the input array ``x2``. + """ + Calculate the sum for each element ``x1_i`` of the input array ``x1`` with the + respective element ``x2_i`` of the input array ``x2``. **Special cases** @@ -508,10 +511,11 @@ def asin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation of the principal - value of the inverse sine, having domain ``[-1, +1]`` and codomain ``[-π/2, - +π/2]`` for each element ``x_i`` of the input array ``x``. Each element- - wise result is expressed in radians. + """ + Calculate an implementation-dependent approximation of the principal value of the + inverse sine, having domain ``[-1, +1]`` and codomain ``[-π/2, +π/2]`` for each + element ``x_i`` of the input array ``x``. Each element- wise result is expressed in + radians. **Special cases** @@ -596,10 +600,10 @@ def asinh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to the inverse - hyperbolic sine, having domain ``[-infinity, +infinity]`` and codomain - ``[-infinity, +infinity]``, for each element ``x_i`` in the input array - ``x``. + """ + Calculate an implementation-dependent approximation to the inverse hyperbolic sine, + having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, + for each element ``x_i`` in the input array ``x``. **Special cases** @@ -705,10 +709,11 @@ def atan( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation of the principal - value of the inverse tangent, having domain ``[-infinity, +infinity]`` and - codomain ``[-π/2, +π/2]``, for each element ``x_i`` of the input array - ``x``. Each element-wise result is expressed in radians. + """ + Calculate an implementation-dependent approximation of the principal value of the + inverse tangent, having domain ``[-infinity, +infinity]`` and codomain ``[-π/2, + +π/2]``, for each element ``x_i`` of the input array ``x``. Each element-wise result + is expressed in radians. **Special cases** @@ -789,17 +794,17 @@ def atan2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation of the inverse - tangent of the quotient ``x1/x2``, having domain ``[-infinity, +infinity] - x. [-infinity, +infinity]`` (where the ``x`` notation denotes the set of - ordered pairs of elements ``(x1_i, x2_i)``) and codomain ``[-π, +π]``, for - each pair of elements ``(x1_i, x2_i)`` of the input arrays ``x1`` and - ``x2``, respectively. Each element-wise result is expressed in radians. The - mathematical signs of ``x1_i and x2_i`` determine the quadrant of each - element-wise result. The quadrant (i.e., branch) is chosen such that each - element-wise result is the signed angle in radians between the ray ending - at the origin and passing through the point ``(1,0)`` and the ray ending at - the origin and passing through the point ``(x2_i, x1_i)``. + """ + Calculate an implementation-dependent approximation of the inverse tangent of the + quotient ``x1/x2``, having domain ``[-infinity, +infinity] x. [-infinity, + +infinity]`` (where the ``x`` notation denotes the set of ordered pairs of elements + ``(x1_i, x2_i)``) and codomain ``[-π, +π]``, for each pair of elements ``(x1_i, + x2_i)`` of the input arrays ``x1`` and ``x2``, respectively. Each element-wise + result is expressed in radians. The mathematical signs of ``x1_i and x2_i`` + determine the quadrant of each element-wise result. The quadrant (i.e., branch) is + chosen such that each element-wise result is the signed angle in radians between the + ray ending at the origin and passing through the point ``(1,0)`` and the ray ending + at the origin and passing through the point ``(x2_i, x1_i)``. **Special cases** @@ -965,8 +970,8 @@ def atanh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array with the inverse hyperbolic tangent of the elements - of ``x``. + """ + Return a new array with the inverse hyperbolic tangent of the elements of ``x``. Parameters ---------- @@ -1068,9 +1073,10 @@ def bitwise_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the bitwise AND of the underlying binary representation of each - element ``x1_i`` of the input array ``x1`` with the respective element - ``x2_i`` of the input array ``x2``. + """ + Compute the bitwise AND of the underlying binary representation of each element + ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input + array ``x2``. Parameters ---------- @@ -1161,8 +1167,8 @@ def bitwise_invert( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Inverts (flips) each bit for each element ``x_i`` of the input array - ``x``. + """ + Inverts (flips) each bit for each element ``x_i`` of the input array ``x``. Parameters ---------- @@ -1239,9 +1245,10 @@ def bitwise_left_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Shifts the bits of each element ``x1_i`` of the input array ``x1`` to - the left by appending ``x2_i`` (i.e., the respective element in the input - array ``x2``) zeros to the right of ``x1_i``. + """ + Shifts the bits of each element ``x1_i`` of the input array ``x1`` to the left by + appending ``x2_i`` (i.e., the respective element in the input array ``x2``) zeros to + the right of ``x1_i``. Parameters ---------- @@ -1289,9 +1296,10 @@ def bitwise_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the bitwise OR of the underlying binary representation of each - element ``x1_i`` of the input array ``x1`` with the respective element - ``x2_i`` of the input array ``x2``. + """ + Compute the bitwise OR of the underlying binary representation of each element + ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input + array ``x2``. Parameters ---------- @@ -1377,9 +1385,9 @@ def bitwise_right_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Shifts the bits of each element ``x1_i`` of the input array ``x1`` to - the right according to the respective element ``x2_i`` of the input array - ``x2``. + """ + Shifts the bits of each element ``x1_i`` of the input array ``x1`` to the right + according to the respective element ``x2_i`` of the input array ``x2``. .. note:: This operation must be an arithmetic shift (i.e., sign-propagating) and thus @@ -1493,9 +1501,10 @@ def bitwise_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the bitwise XOR of the underlying binary representation of each - element ``x1_i`` of the input array ``x1`` with the respective element - ``x2_i`` of the input array ``x2``. + """ + Compute the bitwise XOR of the underlying binary representation of each element + ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input + array ``x2``. Parameters ---------- @@ -1597,9 +1606,9 @@ def ceil( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Round each element ``x_i`` of the input array ``x`` to the smallest - (i.e., closest to ``-infinity``) integer-valued number that is not less - than ``x_i``. + """ + Round each element ``x_i`` of the input array ``x`` to the smallest (i.e., closest + to ``-infinity``) integer-valued number that is not less than ``x_i``. **Special cases** @@ -1688,10 +1697,10 @@ def cos( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to the cosine, - having domain ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for - each element ``x_i`` of the input array ``x``. Each element ``x_i`` is - assumed to be expressed in radians. + """ + Calculate an implementation-dependent approximation to the cosine, having domain + ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each element ``x_i`` of + the input array ``x``. Each element ``x_i`` is assumed to be expressed in radians. **Special cases** @@ -1775,9 +1784,10 @@ def cosh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to the hyperbolic - cosine, having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, - +infinity]``, for each element ``x_i`` in the input array ``x``. + """ + Calculate an implementation-dependent approximation to the hyperbolic cosine, having + domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, for each + element ``x_i`` in the input array ``x``. **Special cases** @@ -1894,8 +1904,9 @@ def divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Calculate the division for each element x1_i of the input array x1 with - the respective element x2_i of the input array x2. + r""" + Calculate the division for each element x1_i of the input array x1 with the + respective element x2_i of the input array x2. **Special Cases** @@ -2085,8 +2096,9 @@ def equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the truth value of x1_i == x2_i for each element x1_i of the - input array x1 with the respective element x2_i of the input array x2. + """ + Compute the truth value of x1_i == x2_i for each element x1_i of the input array x1 + with the respective element x2_i of the input array x2. Parameters ---------- @@ -2201,11 +2213,11 @@ def exp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to the exponential - function, having domain ``[-infinity, +infinity]`` and codomain ``[+0, - +infinity]``, for each element ``x_i`` of the input array ``x`` (``e`` - raised to the power of ``x_i``, where ``e`` is the base of the natural - logarithm). + """ + Calculate an implementation-dependent approximation to the exponential function, + having domain ``[-infinity, +infinity]`` and codomain ``[+0, +infinity]``, for each + element ``x_i`` of the input array ``x`` (``e`` raised to the power of ``x_i``, + where ``e`` is the base of the natural logarithm). .. note:: For complex floating-point operands, ``exp(conj(x))`` must @@ -2340,8 +2352,9 @@ def imag( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the imaginary part of a complex number for each element ``x_i`` - of the input array ``val``. + """ + Return the imaginary part of a complex number for each element ``x_i`` of the input + array ``val``. Parameters ---------- @@ -2393,7 +2406,8 @@ def angle( deg: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate Element-wise the angle for an array of complex numbers(x+yj). + """ + Calculate Element-wise the angle for an array of complex numbers(x+yj). Parameters ---------- @@ -2436,7 +2450,8 @@ def gcd( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the greatest common divisor of |x1| and |x2|. + """ + Return the greatest common divisor of |x1| and |x2|. Parameters ---------- @@ -2477,7 +2492,8 @@ def exp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate 2**p for all p in the input array. + """ + Calculate 2**p for all p in the input array. Parameters ---------- @@ -2517,9 +2533,10 @@ def expm1( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to ``exp(x)-1``, - having domain ``[-infinity, +infinity]`` and codomain ``[-1, +infinity]``, - for each element ``x_i`` of the input array ``x``. + """ + Calculate an implementation-dependent approximation to ``exp(x)-1``, having domain + ``[-infinity, +infinity]`` and codomain ``[-1, +infinity]``, for each element + ``x_i`` of the input array ``x``. .. note:: The purpose of this function is to calculate ``exp(x)-1.0`` more accurately when @@ -2643,9 +2660,9 @@ def floor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Round each element ``x_i`` of the input array ``x`` to the greatest - (i.e., closest to ``+infinity``) integer-valued number that is not greater - than ``x_i``. + """ + Round each element ``x_i`` of the input array ``x`` to the greatest (i.e., closest + to ``+infinity``) integer-valued number that is not greater than ``x_i``. **Special cases** @@ -2734,10 +2751,10 @@ def floor_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Round the result of dividing each element x1_i of the input array x1 by - the respective element x2_i of the input array x2 to the greatest (i.e., - closest to +infinity) integer-value number that is not greater than the - division result. + r""" + Round the result of dividing each element x1_i of the input array x1 by the + respective element x2_i of the input array x2 to the greatest (i.e., closest to + +infinity) integer-value number that is not greater than the division result. .. note:: For input arrays which promote to an integer data type, @@ -2932,9 +2949,10 @@ def fmin( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Compute the element-wise minimums of two arrays. Differs from - ivy.minimum in the case where one of the elements is NaN. ivy.minimum - returns the NaN element while ivy.fmin returns the non-NaN element. + """ + Compute the element-wise minimums of two arrays. Differs from ivy.minimum in the + case where one of the elements is NaN. ivy.minimum returns the NaN element while + ivy.fmin returns the non-NaN element. Parameters ---------- @@ -2979,8 +2997,9 @@ def greater( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the truth value of x1_i < x2_i for each element x1_i of the - input array x1 with the respective element x2_i of the input array x2. + """ + Compute the truth value of x1_i < x2_i for each element x1_i of the input array x1 + with the respective element x2_i of the input array x2. Parameters ---------- @@ -3079,8 +3098,9 @@ def greater_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the truth value of x1_i >= x2_i for each element x1_i of the - input array x1 with the respective element x2_i of the input array x2. + """ + Compute the truth value of x1_i >= x2_i for each element x1_i of the input array x1 + with the respective element x2_i of the input array x2. Parameters ---------- @@ -3165,8 +3185,9 @@ def less_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the truth value of x1_i <= x2_i for each element x1_i of the - input array x1 with the respective element x2_i of the input array x2. + """ + Compute the truth value of x1_i <= x2_i for each element x1_i of the input array x1 + with the respective element x2_i of the input array x2. Parameters ---------- @@ -3251,8 +3272,9 @@ def multiply( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Calculate the product for each element x1_i of the input array x1 with - the respective element x2_i of the input array x2. + r""" + Calculate the product for each element x1_i of the input array x1 with the + respective element x2_i of the input array x2. .. note:: Floating-point multiplication is not always associative due to finite precision. @@ -3436,8 +3458,9 @@ def isfinite( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Test each element ``x_i`` of the input array ``x`` to determine if - finite (i.e., not ``NaN`` and not equal to positive or negative infinity). + """ + Test each element ``x_i`` of the input array ``x`` to determine if finite (i.e., not + ``NaN`` and not equal to positive or negative infinity). Parameters ---------- @@ -3535,8 +3558,9 @@ def isinf( detect_negative: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Test each element x_i of the input array x to determine if equal to - positive or negative infinity. + """ + Test each element x_i of the input array x to determine if equal to positive or + negative infinity. Parameters ---------- @@ -3657,8 +3681,9 @@ def isnan( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Test each element ``x_i`` of the input array ``x`` to determine whether - the element is ``NaN``. + """ + Test each element ``x_i`` of the input array ``x`` to determine whether the element + is ``NaN``. Parameters ---------- @@ -3766,9 +3791,9 @@ def less( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the truth value of ``x1_i < x2_i`` for each element ``x1_i`` of - the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """ + Compute the truth value of ``x1_i < x2_i`` for each element ``x1_i`` of the input + array ``x1`` with the respective element ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -3856,10 +3881,10 @@ def log( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to the natural (base - ``e``) logarithm, having domain ``[0, +infinity]`` and codomain - ``[-infinity, +infinity]``, for each element ``x_i`` of the input array - ``x``. + """ + Calculate an implementation-dependent approximation to the natural (base ``e``) + logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, + for each element ``x_i`` of the input array ``x``. **Special cases** @@ -3957,9 +3982,10 @@ def log10( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Calculate an implementation-dependent approximation to the base ``10`` - logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, - +infinity]``, for each element ``x_i`` of the input array ``x``. + r""" + Calculate an implementation-dependent approximation to the base ``10`` logarithm, + having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, for each + element ``x_i`` of the input array ``x``. **Special cases** @@ -4051,8 +4077,9 @@ def log1p( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to log(1+x), where - log refers to the natural (base e) logarithm. + """ + Calculate an implementation-dependent approximation to log(1+x), where log refers to + the natural (base e) logarithm. .. note:: The purpose of this function is to calculate ``log(1+x)`` more accurately @@ -4169,9 +4196,10 @@ def log2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Calculate an implementation-dependent approximation to the base ``2`` - logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, - +infinity]``, for each element ``x_i`` of the input array ``x``. + r""" + Calculate an implementation-dependent approximation to the base ``2`` logarithm, + having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, for each + element ``x_i`` of the input array ``x``. **Special cases** @@ -4266,9 +4294,10 @@ def logaddexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the logarithm of the sum of exponentiations ``log(exp(x1) + - exp(x2))`` for each element ``x1_i`` of the input array ``x1`` with the - respective element ``x2_i`` of the input array ``x2``. + """ + Calculate the logarithm of the sum of exponentiations ``log(exp(x1) + exp(x2))`` for + each element ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` + of the input array ``x2``. **Special cases** @@ -4366,7 +4395,8 @@ def logaddexp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate log2(2**x1 + 2**x2). + """ + Calculate log2(2**x1 + 2**x2). Parameters ---------- @@ -4409,8 +4439,9 @@ def logical_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the logical AND for each element x1_i of the input array x1 with - the respective element x2_i of the input array x2. + """ + Compute the logical AND for each element x1_i of the input array x1 with the + respective element x2_i of the input array x2. Parameters ---------- @@ -4509,8 +4540,8 @@ def logical_not( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the logical NOT for each element ``x_i`` of the input array - ``x``. + """ + Compute the logical NOT for each element ``x_i`` of the input array ``x``. .. note:: While this specification recommends that this function only accept input arrays @@ -4607,8 +4638,9 @@ def logical_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the logical OR for each element ``x1_i`` of the input array - ``x1`` with the respective element ``x2_i`` of the input array ``x2``. + """ + Compute the logical OR for each element ``x1_i`` of the input array ``x1`` with the + respective element ``x2_i`` of the input array ``x2``. .. note:: While this specification recommends that this function only accept input arrays @@ -4698,9 +4730,10 @@ def logical_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the bitwise XOR of the underlying binary representation of each - element ``x1_i`` of the input array ``x1`` with the respective element - ``x2_i`` of the input array ``x2``. + """ + Compute the bitwise XOR of the underlying binary representation of each element + ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input + array ``x2``. Parameters ---------- @@ -4799,9 +4832,9 @@ def nan_to_num( neginf: Optional[Union[float, int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Replace NaN with zero and infinity with large finite numbers (default - behaviour) or with the numbers defined by the user using the nan, posinf - and/or neginf keywords. + """ + Replace NaN with zero and infinity with large finite numbers (default behaviour) or + with the numbers defined by the user using the nan, posinf and/or neginf keywords. Parameters ---------- @@ -4858,7 +4891,8 @@ def negative( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array with the negative value of each element in ``x``. + """ + Return a new array with the negative value of each element in ``x``. .. note:: For signed integer data types, the numerical negative of @@ -4944,9 +4978,9 @@ def not_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the truth value of ``x1_i != x2_i`` for each element ``x1_i`` of - the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """ + Compute the truth value of ``x1_i != x2_i`` for each element ``x1_i`` of the input + array ``x1`` with the respective element ``x2_i`` of the input array ``x2``. **Special Cases** @@ -5127,7 +5161,8 @@ def positive( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array with the positive value of each element in ``x``. + """ + Return a new array with the positive value of each element in ``x``. Parameters ---------- @@ -5203,10 +5238,11 @@ def pow( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation of exponentiation by - raising each element ``x1_i`` (the base) of the input array ``x1`` to the - power of ``x2_i`` (the exponent), where ``x2_i`` is the corresponding - element of the input array ``x2``. + """ + Calculate an implementation-dependent approximation of exponentiation by raising + each element ``x1_i`` (the base) of the input array ``x1`` to the power of ``x2_i`` + (the exponent), where ``x2_i`` is the corresponding element of the input array + ``x2``. **Special cases** @@ -5348,10 +5384,11 @@ def real( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Test each element ``x_i`` of the input array ``x`` to take only real - part from it. Returns a float array, where it only contains . If element - has complex type with zero complex part, the return value will be that - element, else it only returns real part. + """ + Test each element ``x_i`` of the input array ``x`` to take only real part from it. + Returns a float array, where it only contains . If element has complex type with + zero complex part, the return value will be that element, else it only returns real + part. Parameters ---------- @@ -5420,8 +5457,9 @@ def remainder( modulus: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the remainder of division for each element ``x1_i`` of the input - array ``x1`` and the respective element ``x2_i`` of the input array ``x2``. + """ + Return the remainder of division for each element ``x1_i`` of the input array ``x1`` + and the respective element ``x2_i`` of the input array ``x2``. .. note:: This function is equivalent to the Python modulus operator ``x1_i % x2_i``. For @@ -5549,8 +5587,9 @@ def round( decimals: Optional[int] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Round each element ``x_i`` of the input array ``x`` to the nearest - integer-valued number. + """ + Round each element ``x_i`` of the input array ``x`` to the nearest integer-valued + number. .. note:: For complex floating-point operands, real and imaginary components @@ -5670,8 +5709,9 @@ def sign( np_variant: Optional[bool] = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Return an indication of the sign of a number for each element ``x_i`` of - the input array ``x``. + r""" + Return an indication of the sign of a number for each element ``x_i`` of the input + array ``x``. The sign function (also known as the **signum function**) of a number :math:`x_{i}` is defined as @@ -5778,10 +5818,10 @@ def sin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Calculate an implementation-dependent approximation to the sine, having - domain ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each - element ``x_i`` of the input array ``x``. Each element ``x_i`` is assumed - to be expressed in radians. + r""" + Calculate an implementation-dependent approximation to the sine, having domain + ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each element ``x_i`` of + the input array ``x``. Each element ``x_i`` is assumed to be expressed in radians. .. note:: The sine is an entire function on the complex plane and has no branch cuts. @@ -5873,9 +5913,10 @@ def sinh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Calculate an implementation-dependent approximation to the hyperbolic - sine, having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, - +infinity]``, for each element ``x_i`` of the input array ``x``. + r""" + Calculate an implementation-dependent approximation to the hyperbolic sine, having + domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, for each + element ``x_i`` of the input array ``x``. .. math:: \operatorname{sinh}(x) = \frac{e^x - e^{-x}}{2} @@ -5996,10 +6037,11 @@ def sqrt( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Calculate the square root, having domain ``[0, +infinity]`` and codomain - ``[0, +infinity]``, for each element ``x_i`` of the input array ``x``. - After rounding, each result must be indistinguishable from the infinitely - precise result (as required by IEEE 754). + r""" + Calculate the square root, having domain ``[0, +infinity]`` and codomain ``[0, + +infinity]``, for each element ``x_i`` of the input array ``x``. After rounding, + each result must be indistinguishable from the infinitely precise result (as + required by IEEE 754). .. note:: After rounding, each result must be indistinguishable @@ -6127,7 +6169,8 @@ def square( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Each element ``x_i`` of the input array ``x``. + """ + Each element ``x_i`` of the input array ``x``. Parameters ---------- @@ -6201,8 +6244,9 @@ def subtract( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the difference for each element ``x1_i`` of the input array - ``x1`` with the respective element ``x2_i`` of the input array ``x2``. + """ + Calculate the difference for each element ``x1_i`` of the input array ``x1`` with + the respective element ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -6370,9 +6414,10 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation to the hyperbolic - tangent, having domain ``[-infinity, +infinity]`` and codomain ``[-1, - +1]``, for each element ``x_i`` of the input array ``x``. + """ + Calculate an implementation-dependent approximation to the hyperbolic tangent, + having domain ``[-infinity, +infinity]`` and codomain ``[-1, +1]``, for each element + ``x_i`` of the input array ``x``. **Special cases** @@ -6512,7 +6557,8 @@ def trapz( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Integrate along the given axis using the composite trapezoidal rule. + """ + Integrate along the given axis using the composite trapezoidal rule. If x is provided, the integration happens in sequence along its elements - they are not sorted.. @@ -6569,8 +6615,9 @@ def trunc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Round each element x_i of the input array x to the integer-valued number - that is closest to but no greater than x_i. + """ + Round each element x_i of the input array x to the integer-valued number that is + closest to but no greater than x_i. **Special cases** @@ -6661,7 +6708,8 @@ def erf( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Gauss error function of ``x`` element-wise. + """ + Compute the Gauss error function of ``x`` element-wise. Parameters ---------- @@ -6724,7 +6772,8 @@ def maximum( use_where: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the max of x1 and x2 (i.e. x1 > x2 ? x1 : x2) element-wise. + """ + Return the max of x1 and x2 (i.e. x1 > x2 ? x1 : x2) element-wise. Parameters ---------- @@ -6815,7 +6864,8 @@ def minimum( use_where: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the min of x1 and x2 (i.e. x1 < x2 ? x1 : x2) element-wise. + """ + Return the min of x1 and x2 (i.e. x1 < x2 ? x1 : x2) element-wise. Parameters ---------- @@ -6905,7 +6955,8 @@ def reciprocal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a new array with the reciprocal of each element in ``x``. + """ + Return a new array with the reciprocal of each element in ``x``. Parameters ---------- @@ -6943,7 +6994,8 @@ def deg2rad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Convert the input from degrees to radians. + """ + Convert the input from degrees to radians. Parameters ---------- @@ -7021,7 +7073,8 @@ def rad2deg( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Convert the input from radians to degrees. + """ + Convert the input from radians to degrees. Parameters ---------- @@ -7098,8 +7151,9 @@ def trunc_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Perform element-wise integer division of the inputs rounding the results - towards zero. + """ + Perform element-wise integer division of the inputs rounding the results towards + zero. Parameters ---------- @@ -7158,10 +7212,11 @@ def isreal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Test each element ``x_i`` of the input array ``x`` to determine whether - the element is real number. Returns a bool array, where True if input - element is real. If element has complex type with zero complex part, the - return value for that element is True. + """ + Test each element ``x_i`` of the input array ``x`` to determine whether the element + is real number. Returns a bool array, where True if input element is real. If + element has complex type with zero complex part, the return value for that element + is True. Parameters ---------- @@ -7223,7 +7278,8 @@ def fmod( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Compute the element-wise remainder of divisions of two arrays. + """ + Compute the element-wise remainder of divisions of two arrays. Parameters ---------- @@ -7266,7 +7322,8 @@ def lcm( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the element-wise least common multiple (LCM) of x1 and x2. + """ + Compute the element-wise least common multiple (LCM) of x1 and x2. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/activations.py b/ivy/functional/ivy/experimental/activations.py index f9788a93ffadf..1b1fda6b32a08 100644 --- a/ivy/functional/ivy/experimental/activations.py +++ b/ivy/functional/ivy/experimental/activations.py @@ -53,7 +53,8 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the logit of x. + """ + Compute the logit of x. logit(x) = log(x / (1 - x)). @@ -106,7 +107,8 @@ def prelu( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Prelu takes input data (Array) and slope array as input, + """ + Prelu takes input data (Array) and slope array as input, and produces one output data (array) where the function f(x) = slope * x for x < 0, f(x) = x for x >= 0., is applied @@ -163,7 +165,8 @@ def thresholded_relu( threshold: Union[int, float] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the rectified linear unit function with custom threshold. + """ + Apply the rectified linear unit function with custom threshold. Parameters ---------- @@ -247,7 +250,8 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the rectified linear unit 6 function element-wise. + """ + Apply the rectified linear unit 6 function element-wise. Parameters ---------- @@ -302,7 +306,8 @@ def logsigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply element-wise Log-sigmoid of x. + """ + Apply element-wise Log-sigmoid of x. logsigmoid(x) = log(1 / (1 + exp(-x)). @@ -356,7 +361,8 @@ def logsigmoid( def selu( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """Apply the scaled exponential linear unit function element-wise. + """ + Apply the scaled exponential linear unit function element-wise. Parameters ---------- @@ -414,7 +420,8 @@ def selu( def silu( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """Apply the silu function element-wise. + """ + Apply the silu function element-wise. Parameters ---------- @@ -466,7 +473,8 @@ def elu( alpha: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the elu unit function element-wise. + """ + Apply the elu unit function element-wise. Parameters ---------- @@ -528,7 +536,8 @@ def hardtanh( min_val: float = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the hardtanh unit function element-wise. + """ + Apply the hardtanh unit function element-wise. Parameters ---------- @@ -587,7 +596,8 @@ def hardtanh( def tanhshrink( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """Apply the tanhshrink function element-wise. + """ + Apply the tanhshrink function element-wise. Parameters ---------- @@ -640,7 +650,8 @@ def softshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the softshrink function element-wise. + """ + Apply the softshrink function element-wise. Parameters ---------- @@ -727,7 +738,8 @@ def threshold( value: float, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the threshold function element-wise. + """ + Apply the threshold function element-wise. Parameters ---------- @@ -786,8 +798,9 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the Continuously Differentiable Exponential Linear Unit (CELU) - activation function to each element of the input. + """ + Apply the Continuously Differentiable Exponential Linear Unit (CELU) activation + function to each element of the input. Parameters ---------- @@ -848,7 +861,8 @@ def scaled_tanh( beta: float = 0.67, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the scaled hyperbolic tangent (tanh) activation. + """ + Compute the scaled hyperbolic tangent (tanh) activation. The scaled tanh activation function is defined as: out = alpha * tanh(beta * x) @@ -926,7 +940,8 @@ def hardshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply the hardshrink function element-wise. + """ + Apply the hardshrink function element-wise. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/creation.py b/ivy/functional/ivy/experimental/creation.py index f1871a3098b28..ff9ed655f1592 100644 --- a/ivy/functional/ivy/experimental/creation.py +++ b/ivy/functional/ivy/experimental/creation.py @@ -33,8 +33,9 @@ def vorbis_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return an array that contains a vorbis power complementary window of - size window_length. + """ + Return an array that contains a vorbis power complementary window of size + window_length. Parameters ---------- @@ -75,8 +76,9 @@ def hann_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Generate a Hann window. The Hanning window is a taper formed by using a - weighted cosine. + """ + Generate a Hann window. The Hanning window is a taper formed by using a weighted + cosine. Parameters ---------- @@ -123,8 +125,8 @@ def kaiser_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Kaiser window with window length window_length and shape - beta. + """ + Compute the Kaiser window with window length window_length and shape beta. Parameters ---------- @@ -170,8 +172,9 @@ def kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Kaiser bessel derived window with window length - window_length and shape beta. + """ + Compute the Kaiser bessel derived window with window length window_length and shape + beta. Parameters ---------- @@ -223,7 +226,8 @@ def hamming_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Hamming window with window length window_length. + """ + Compute the Hamming window with window length window_length. Parameters ---------- @@ -288,16 +292,16 @@ def tril_indices( *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Tuple[ivy.Array, ...]: - """Return the indices of the lower triangular part of a row by col matrix - in a 2-by-N shape (tuple of two N dimensional arrays), where the first row - contains row coordinates of all indices and the second row contains column - coordinates. Indices are ordered based on rows and then columns. The lower - triangular part of the matrix is defined as the elements on and below the - diagonal. The argument k controls which diagonal to consider. If k = 0, - all elements on and below the main diagonal are retained. A positive value - excludes just as many diagonals below the main diagonal, and similarly a - negative value includes just as many diagonals above the main diagonal. The - main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, + """ + Return the indices of the lower triangular part of a row by col matrix in a 2-by-N + shape (tuple of two N dimensional arrays), where the first row contains row + coordinates of all indices and the second row contains column coordinates. Indices + are ordered based on rows and then columns. The lower triangular part of the matrix + is defined as the elements on and below the diagonal. The argument k controls which + diagonal to consider. If k = 0, all elements on and below the main diagonal are + retained. A positive value excludes just as many diagonals below the main diagonal, + and similarly a negative value includes just as many diagonals above the main + diagonal. The main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, n_cols}−1]. Notes @@ -386,9 +390,10 @@ def eye_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a 2D array filled with ones on the k diagonal and zeros - elsewhere. having the same ``shape`` as the first and last dim of input - array ``x``. input array ``x`` should to be 2D. + """ + Return a 2D array filled with ones on the k diagonal and zeros elsewhere. having the + same ``shape`` as the first and last dim of input array ``x``. input array ``x`` + should to be 2D. Parameters ---------- @@ -478,7 +483,8 @@ def _iter_product(*args, repeat=1): def ndenumerate( input: Iterable, ) -> Generator: - """Multidimensional index iterator. + """ + Multidimensional index iterator. Parameters ---------- @@ -517,7 +523,8 @@ def _ndenumerate(input): def ndindex( shape: Tuple, ) -> Generator: - """Multidimensional index iterator. + """ + Multidimensional index iterator. Parameters ---------- @@ -550,7 +557,8 @@ def indices( dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, sparse: bool = False, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """Return an array representing the indices of a grid. + """ + Return an array representing the indices of a grid. Parameters ---------- @@ -610,8 +618,9 @@ def unsorted_segment_min( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """Compute the minimum along segments of an array. Segments are defined by - an integer array of segment IDs. + """ + Compute the minimum along segments of an array. Segments are defined by an integer + array of segment IDs. Note ---- @@ -649,8 +658,9 @@ def unsorted_segment_sum( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """Compute the sum of elements along segments of an array. Segments are - defined by an integer array of segment IDs. + """ + Compute the sum of elements along segments of an array. Segments are defined by an + integer array of segment IDs. Parameters ---------- @@ -688,10 +698,10 @@ def blackman_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Generate a Blackman window. The Blackman window is a taper formed by - using the first three terms of a summation of cosines. It was designed to - have close to the minimal leakage possible. It is close to optimal, only - slightly worse than a Kaiser window. + """ + Generate a Blackman window. The Blackman window is a taper formed by using the first + three terms of a summation of cosines. It was designed to have close to the minimal + leakage possible. It is close to optimal, only slightly worse than a Kaiser window. Parameters ---------- @@ -737,7 +747,8 @@ def random_tucker( seed: Optional[int] = None, non_negative: Optional[bool] = False, ) -> Union[ivy.TuckerTensor, ivy.Array]: - """Generate a random Tucker tensor. + """ + Generate a random Tucker tensor. Parameters ---------- @@ -806,7 +817,8 @@ def random_cp( seed: Optional[int] = None, normalise_factors: Optional[bool] = True, ) -> Union[ivy.CPTensor, ivy.Array]: - """Generate a random CP tensor. + """ + Generate a random CP tensor. Parameters ---------- @@ -860,7 +872,8 @@ def random_tr( full: Optional[bool] = False, seed: Optional[int] = None, ) -> Union[ivy.TRTensor, ivy.Array]: - """Generate a random TR tensor. + """ + Generate a random TR tensor. Parameters ---------- @@ -918,7 +931,8 @@ def random_parafac2( seed: Optional[int] = None, normalise_factors: Optional[bool] = True, ) -> Union[ivy.Parafac2Tensor, ivy.Array]: - """Generate a random PARAFAC2 tensor. + """ + Generate a random PARAFAC2 tensor. Parameters ---------- @@ -974,7 +988,8 @@ def random_tt( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, seed: Optional[int] = None, ) -> Union[ivy.TTTensor, ivy.Array]: - """Generate a random TT/MPS tensor. + """ + Generate a random TT/MPS tensor. Parameters ---------- @@ -1083,10 +1098,10 @@ def mel_weight_matrix( lower_edge_hertz: float = 0.0, upper_edge_hertz: float = 3000.0, ): - """Generate a MelWeightMatrix that can be used to re-weight a Tensor - containing a linearly sampled frequency spectra (from DFT or STFT) into - num_mel_bins frequency information based on the [lower_edge_hertz, - upper_edge_hertz] + """ + Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a + linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins frequency + information based on the [lower_edge_hertz, upper_edge_hertz] range on the mel scale. This function defines the mel scale in terms of a frequency in hertz according to the following formula: mel(f) = 2595 * log10(1 + f/700) @@ -1134,8 +1149,9 @@ def unsorted_segment_mean( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """Compute the mean of elements along segments of an array. Segments are - defined by an integer array of segment IDs. + """ + Compute the mean of elements along segments of an array. Segments are defined by an + integer array of segment IDs. Parameters ---------- @@ -1168,7 +1184,8 @@ def polyval( coeffs: Union[ivy.Array, ivy.NativeArray], x: Union[ivy.Array, ivy.NativeArray], ): - """Evaluate and return a polynomial at specific given values. + """ + Evaluate and return a polynomial at specific given values. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/elementwise.py b/ivy/functional/ivy/experimental/elementwise.py index 83025fd5dd56f..09a208c346a5b 100644 --- a/ivy/functional/ivy/experimental/elementwise.py +++ b/ivy/functional/ivy/experimental/elementwise.py @@ -32,7 +32,8 @@ def amax( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the maximum value of the input array ``x``. + """ + Calculate the maximum value of the input array ``x``. .. note:: ``amax`` is an alias of ``max`` and both function @@ -148,7 +149,8 @@ def amin( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the minimum value of the input array ``x``. + """ + Calculate the minimum value of the input array ``x``. .. note:: ``amin`` is an alias of ``min`` and both function @@ -263,8 +265,8 @@ def lgamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the natural logarithm of the absolute value of the gamma - function on x. + """ + Compute the natural logarithm of the absolute value of the gamma function on x. Parameters ---------- @@ -314,11 +316,11 @@ def sinc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate an implementation-dependent approximation of the principal - value of the normalized sinc function, having domain ``(-infinity, - +infinity)`` and codomain ``[-0.217234, 1]``, for each element ``x_i`` of - the input array ``x``. Each element ``x_i`` is assumed to be expressed in - radians. + """ + Calculate an implementation-dependent approximation of the principal value of the + normalized sinc function, having domain ``(-infinity, +infinity)`` and codomain + ``[-0.217234, 1]``, for each element ``x_i`` of the input array ``x``. Each element + ``x_i`` is assumed to be expressed in radians. **Special cases** @@ -391,9 +393,10 @@ def fmax( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Compute the element-wise maximums of two arrays. Differs from - ivy.maximum in the case where one of the elements is NaN. ivy.maximum - returns the NaN element while ivy.fmax returns the non-NaN element. + """ + Compute the element-wise maximums of two arrays. Differs from ivy.maximum in the + case where one of the elements is NaN. ivy.maximum returns the NaN element while + ivy.fmax returns the non-NaN element. Parameters ---------- @@ -436,10 +439,11 @@ def float_power( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Raise each base in x1 to the positionally-corresponding power in x2. x1 - and x2 must be broadcastable to the same shape. This differs from the power - function in that integers, float16, and float32 are promoted to floats with - a minimum precision of float64 so that the result is always inexact. + """ + Raise each base in x1 to the positionally-corresponding power in x2. x1 and x2 must + be broadcastable to the same shape. This differs from the power function in that + integers, float16, and float32 are promoted to floats with a minimum precision of + float64 so that the result is always inexact. Parameters ---------- @@ -484,8 +488,9 @@ def copysign( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """Change the signs of x1 to match x2 x1 and x2 must be broadcastable to a - common shape. + """ + Change the signs of x1 to match x2 x1 and x2 must be broadcastable to a common + shape. Parameters ---------- @@ -533,7 +538,8 @@ def count_nonzero( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """Count the number of non-zero values in the array a. + """ + Count the number of non-zero values in the array a. Parameters ---------- @@ -592,8 +598,9 @@ def nansum( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the sum of array elements over a given axis treating Not a - Numbers (NaNs) as zero. + """ + Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as + zero. Parameters ---------- @@ -650,8 +657,8 @@ def isclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a boolean array where two arrays are element-wise equal within a - tolerance. + """ + Return a boolean array where two arrays are element-wise equal within a tolerance. The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(b)) and the absolute difference @@ -711,7 +718,8 @@ def signbit( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return element-wise True where signbit is set (less than zero). + """ + Return element-wise True where signbit is set (less than zero). Parameters ---------- @@ -747,7 +755,8 @@ def hypot( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Return the hypotenuse given the two sides of a right angle triangle. + """ + Return the hypotenuse given the two sides of a right angle triangle. Parameters ---------- @@ -787,7 +796,8 @@ def diff( append: Optional[Union[ivy.Array, ivy.NativeArray, int, list, tuple]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the n-th discrete difference along the given axis. + """ + Return the n-th discrete difference along the given axis. Parameters ---------- @@ -842,8 +852,9 @@ def allclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> bool: - """Return a True if the two arrays are element-wise equal within given - tolerance; otherwise False. + """ + Return a True if the two arrays are element-wise equal within given tolerance; + otherwise False. The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(x2)) and the absolute difference @@ -912,8 +923,9 @@ def fix( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Round an array of floats element-wise to nearest integer towards zero. - The rounded values are returned as floats. + """ + Round an array of floats element-wise to nearest integer towards zero. The rounded + values are returned as floats. Parameters ---------- @@ -951,7 +963,8 @@ def nextafter( *, out: Optional[ivy.Array] = None, ) -> bool: - """Return the next floating-point value after x1 towards x2, element-wise. + """ + Return the next floating-point value after x1 towards x2, element-wise. Parameters ---------- @@ -992,8 +1005,9 @@ def zeta( *, out: Optional[ivy.Array] = None, ) -> bool: - """Compute the Hurwitz zeta function elementwisely with each pair of floats - in two arrays. + """ + Compute the Hurwitz zeta function elementwisely with each pair of floats in two + arrays. Parameters ---------- @@ -1035,7 +1049,8 @@ def gradient( edge_order: int = 1, axis: Optional[Union[int, list, tuple]] = None, ) -> Union[ivy.Array, List[ivy.Array]]: - """Calculate gradient of x with respect to (w.r.t.) spacing. + """ + Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -1113,7 +1128,8 @@ def xlogy( *, out: Optional[ivy.Array] = None, ) -> bool: - """Compute x*log(y) element-wise so that the result is 0 if x = 0. + """ + Compute x*log(y) element-wise so that the result is 0 if x = 0. Parameters ---------- @@ -1157,8 +1173,9 @@ def binarizer( threshold: float = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Map the values of the input tensor to either 0 or 1, element-wise, based - on the outcome of a comparison against a threshold value. + """ + Map the values of the input tensor to either 0 or 1, element-wise, based on the + outcome of a comparison against a threshold value. Parameters ---------- @@ -1198,8 +1215,8 @@ def conj( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the complex conjugate for each element ``x_i`` of the input array - ``x``. + """ + Return the complex conjugate for each element ``x_i`` of the input array ``x``. For complex number of the form @@ -1282,7 +1299,8 @@ def ldexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return x1 * (2**x2), element-wise. + """ + Return x1 * (2**x2), element-wise. Parameters ---------- @@ -1324,8 +1342,8 @@ def lerp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a linear interpolation of two arrays start (given by input) and - end. + """ + Return a linear interpolation of two arrays start (given by input) and end. based on a scalar or array weight. input + weight * (end - input), element-wise. @@ -1451,7 +1469,8 @@ def frexp( *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """Decompose the elements of x into mantissa and twos exponent. + """ + Decompose the elements of x into mantissa and twos exponent. Parameters ---------- @@ -1487,7 +1506,8 @@ def modf( *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """Decompose the elements of x into fractional and integral parts. + """ + Decompose the elements of x into fractional and integral parts. Parameters ---------- @@ -1521,7 +1541,8 @@ def digamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the logarithmic derivative of the gamma function at x. + """ + Compute the logarithmic derivative of the gamma function at x. Note ---- @@ -1561,8 +1582,9 @@ def sparsify_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Zeros out all elements in the tensor except `card` elements with maximum - absolute values. + """ + Zeros out all elements in the tensor except `card` elements with maximum absolute + values. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/general.py b/ivy/functional/ivy/experimental/general.py index 144f10256c7be..cef0bc2091951 100644 --- a/ivy/functional/ivy/experimental/general.py +++ b/ivy/functional/ivy/experimental/general.py @@ -39,8 +39,8 @@ def reduce( axes: Union[int, Sequence[int]] = 0, keepdims: bool = False, ) -> ivy.Array: - """Reduces the input array's dimensions by applying a function along one or - more axes. + """ + Reduces the input array's dimensions by applying a function along one or more axes. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/gradients.py b/ivy/functional/ivy/experimental/gradients.py index 126a219d890f5..8c5466de75168 100644 --- a/ivy/functional/ivy/experimental/gradients.py +++ b/ivy/functional/ivy/experimental/gradients.py @@ -3,7 +3,8 @@ def bind_custom_gradient_function(func, custom_grad_func): - """Bind a custom gradient function to a function. + """ + Bind a custom gradient function to a function. Parameters ---------- @@ -22,7 +23,8 @@ def bind_custom_gradient_function(func, custom_grad_func): def vjp(func, *primals): - """Compute a (reverse-mode) vector-Jacobian product of `func`. + """ + Compute a (reverse-mode) vector-Jacobian product of `func`. Parameters ---------- @@ -41,7 +43,8 @@ def vjp(func, *primals): def jvp(func, primals, tangents): - """Compute a (forward-mode) Jacobian-vector product of `func`. + """ + Compute a (forward-mode) Jacobian-vector product of `func`. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 5f629ef41f639..cbda5a5f07232 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -43,7 +43,8 @@ def max_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 1-D max pool given 3-D input x. + """ + Compute a 1-D max pool given 3-D input x. Parameters ---------- @@ -130,7 +131,8 @@ def max_pool2d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 2-D max pool given 4-D input x. + """ + Compute a 2-D max pool given 4-D input x. Parameters ---------- @@ -217,7 +219,8 @@ def max_pool3d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 3-D max pool given 5-D input x. + """ + Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -303,7 +306,8 @@ def avg_pool1d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 1-D avg pool given 3-D input x. + """ + Compute a 1-D avg pool given 3-D input x. Parameters ---------- @@ -385,7 +389,8 @@ def avg_pool2d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 2-D average pool given 4-D input x. + """ + Compute a 2-D average pool given 4-D input x. Parameters ---------- @@ -472,7 +477,8 @@ def avg_pool3d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 3-D avg pool given 5-D input x. + """ + Compute a 3-D avg pool given 5-D input x. Parameters ---------- @@ -559,7 +565,8 @@ def pool( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Perform an N-D pooling operation. + """ + Perform an N-D pooling operation. Parameters ---------- @@ -634,7 +641,8 @@ def dct( norm: Optional[Literal["ortho"]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Compute the 1D Discrete Cosine Transformation of a given signal. + """ + Compute the 1D Discrete Cosine Transformation of a given signal. Parameters ---------- @@ -744,7 +752,8 @@ def idct( norm: Optional[Literal["ortho"]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Compute the 1D Inverse Discrete Cosine Transformation of a given signal. + """ + Compute the 1D Inverse Discrete Cosine Transformation of a given signal. Parameters ---------- @@ -867,8 +876,9 @@ def fft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Compute the one dimensional discrete Fourier transform given input at - least 1-D input x. + r""" + Compute the one dimensional discrete Fourier transform given input at least 1-D + input x. Parameters ---------- @@ -936,10 +946,11 @@ def dropout1d( data_format: str = "NWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Randomly zero out entire channels with probability prob using samples - from a Bernoulli distribution and the remaining channels are scaled by - (1/1-prob). In this case, dropout1d performs a channel-wise dropout but - assumes a channel is a 1D feature map. + """ + Randomly zero out entire channels with probability prob using samples from a + Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this + case, dropout1d performs a channel-wise dropout but assumes a channel is a 1D + feature map. Parameters ---------- @@ -1011,10 +1022,11 @@ def dropout2d( data_format: str = "NHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Randomly zero out entire channels with probability prob using samples - from a Bernoulli distribution and the remaining channels are scaled by - (1/1-prob). In this case, dropout2d performs a channel-wise dropout but - assumes a channel is a 2D feature map. + """ + Randomly zero out entire channels with probability prob using samples from a + Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this + case, dropout2d performs a channel-wise dropout but assumes a channel is a 2D + feature map. Parameters ---------- @@ -1076,10 +1088,11 @@ def dropout3d( data_format: str = "NDHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Randomly zero out entire channels with probability prob using samples - from a Bernoulli distribution and the remaining channels are scaled by - (1/1-prob). In this case, dropout3d performs a channel-wise dropout but - assumes a channel is a 1D feature map. + """ + Randomly zero out entire channels with probability prob using samples from a + Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this + case, dropout3d performs a channel-wise dropout but assumes a channel is a 1D + feature map. Parameters ---------- @@ -1126,8 +1139,9 @@ def ifft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Compute the one dimensional discrete Fourier transform given input at - least 1-D input x. + r""" + Compute the one dimensional discrete Fourier transform given input at least 1-D + input x. Parameters ---------- @@ -1194,7 +1208,8 @@ def embedding( max_norm: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Embeds a given tensor of indices using a given tensor of weights. + """ + Embeds a given tensor of indices using a given tensor of weights. Parameters ---------- @@ -1247,7 +1262,8 @@ def dft( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the discrete Fourier transform of input. + """ + Compute the discrete Fourier transform of input. Parameters ---------- @@ -1758,8 +1774,9 @@ def interpolate( antialias: bool = False, # ToDo: add support for antialias out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Down/up samples the input to the given size. The algorithm used for - interpolation is determined by mode. + """ + Down/up samples the input to the given size. The algorithm used for interpolation is + determined by mode. Parameters ---------- @@ -2099,8 +2116,9 @@ def adaptive_max_pool2d( input: Union[ivy.Array, ivy.NativeArray], output_size: Union[Sequence[int], int], ): - """Apply a 2D adaptive maximum pooling over an input signal composed of - several input planes. + """ + Apply a 2D adaptive maximum pooling over an input signal composed of several input + planes. Parameters ---------- @@ -2191,8 +2209,9 @@ def adaptive_avg_pool1d( input: Union[ivy.Array, ivy.NativeArray], output_size: int, ) -> ivy.Array: - """Apply a 1D adaptive average pooling over an input signal composed of - several input planes. + """ + Apply a 1D adaptive average pooling over an input signal composed of several input + planes. Parameters ---------- @@ -2276,8 +2295,9 @@ def adaptive_avg_pool2d( *, data_format: str = "NHWC", ) -> ivy.Array: - """Apply a 2D adaptive average pooling over an input signal composed of - several input planes. + """ + Apply a 2D adaptive average pooling over an input signal composed of several input + planes. Parameters ---------- @@ -2510,7 +2530,8 @@ def sliding_window( dilation: Union[int, Tuple[int, int]] = 1, padding: Union[str, int, Tuple[int, int]] = "VALID", ) -> ivy.Array: - """Slide a window of specified dimension over all elements of an array. + """ + Slide a window of specified dimension over all elements of an array. Parameters ---------- @@ -2642,7 +2663,8 @@ def reduce_window( base_dilation: Union[int, Sequence[int]] = 1, window_dilation: Union[int, Sequence[int]] = 1, ) -> ivy.Array: - """Apply a reduction function to all elements in each window of an array. + """ + Apply a reduction function to all elements in each window of an array. Parameters ---------- @@ -2718,7 +2740,8 @@ def fft2( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Compute the 2-dimensional discrete Fourier Transform. + r""" + Compute the 2-dimensional discrete Fourier Transform. Parameters ---------- @@ -2794,7 +2817,8 @@ def ifftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Compute the N-dimensional inverse discrete Fourier Transform. + r""" + Compute the N-dimensional inverse discrete Fourier Transform. Parameters ---------- @@ -2878,8 +2902,8 @@ def rfft( norm: Literal["backward", "ortho", "forward"] = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the one-dimensional discrete Fourier transform for real-valued - input. + """ + Compute the one-dimensional discrete Fourier transform for real-valued input. .. note:: Applying the one-dimensional inverse discrete Fourier transform for @@ -2987,7 +3011,8 @@ def rfftn( norm: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the N-dimensional discrete Fourier Transform for real input. + """ + Compute the N-dimensional discrete Fourier Transform for real input. Parameters ---------- @@ -3078,7 +3103,8 @@ def stft( name: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Container static method variant of ivy.stft. + """ + ivy.Container static method variant of ivy.stft. This method simply wraps the function, and so the docstring for ivy.stft also applies to this method with minimal changes. @@ -3171,8 +3197,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Array: - """Compute a 1-D max unpooling given the 1-D pooled input x and its - indices. + """ + Compute a 1-D max unpooling given the 1-D pooled input x and its indices. Parameters ---------- @@ -3265,7 +3291,8 @@ def rnn( zero_output_for_mask: bool = False, return_all_outputs: bool = True, ): - """Iterate over the time dimension of a tensor. + """ + Iterate over the time dimension of a tensor. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index dd0685bead55b..c84cbfd841d05 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -41,8 +41,8 @@ def eigh_tridiagonal( ] = None, tol: Optional[float] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array]]: - """Compute the eigenvalues and eigenvectors of a Hermitian tridiagonal - matrix. + """ + Compute the eigenvalues and eigenvectors of a Hermitian tridiagonal matrix. Parameters ---------- @@ -180,7 +180,8 @@ def diagflat( num_cols: int = -1, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """Return a two-dimensional array with the flattened input as a diagonal. + """ + Return a two-dimensional array with the flattened input as a diagonal. Parameters ---------- @@ -242,8 +243,9 @@ def kron( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Kronecker product, a composite array made of blocks of the - second array scaled by the first. + """ + Compute the Kronecker product, a composite array made of blocks of the second array + scaled by the first. Parameters ---------- @@ -283,7 +285,8 @@ def matrix_exp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the matrix exponential of a square matrix. + """ + Compute the matrix exponential of a square matrix. Parameters ---------- @@ -387,7 +390,8 @@ def eigvals( x: Union[ivy.Array, ivy.NativeArray], /, ) -> ivy.Array: - """Compute eigenvalues of x. Returns a set of eigenvalues. + """ + Compute eigenvalues of x. Returns a set of eigenvalues. Parameters ---------- @@ -433,7 +437,8 @@ def adjoint( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the complex conjugate transpose of x. + """ + Compute the complex conjugate transpose of x. Parameters ---------- @@ -477,8 +482,8 @@ def solve_triangular( unit_diagonal: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the unique solution to the triangular system of linear equations - AX = B. + """ + Return the unique solution to the triangular system of linear equations AX = B. Parameters ---------- @@ -535,8 +540,9 @@ def multi_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the dot product of two or more matrices in a single function - call, while selecting the fastest evaluation order. + """ + Compute the dot product of two or more matrices in a single function call, while + selecting the fastest evaluation order. Parameters ---------- @@ -595,7 +601,8 @@ def cond( p: Optional[Union[int, float, str]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the condition number of x. + """ + Compute the condition number of x. Parameters ---------- @@ -642,7 +649,8 @@ def kronecker( reverse: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Kronecker product of a list of matrices. + """ + Kronecker product of a list of matrices. Parameters ---------- @@ -692,7 +700,8 @@ def khatri_rao( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Khatri-Rao product of a sequence of matrices. + """ + Khatri-Rao product of a sequence of matrices. This can be seen as a column-wise kronecker product. If one matrix only is given, that matrix is directly returned. @@ -796,7 +805,8 @@ def mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """N-mode product of a tensor and a matrix or vector at the specified mode. + """ + N-mode product of a tensor and a matrix or vector at the specified mode. Parameters ---------- @@ -889,8 +899,8 @@ def multi_mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""N-mode product of a tensor and several matrices or vectors over several - modes. + r""" + N-mode product of a tensor and several matrices or vectors over several modes. Parameters ---------- @@ -958,7 +968,8 @@ def multi_mode_dot( def _svd_checks(x, n_eigenvecs=None): - """Run common checks to all of the SVD methods. + """ + Run common checks to all of the SVD methods. Parameters ---------- @@ -1009,10 +1020,11 @@ def svd_flip( /, u_based_decision: Optional[bool] = True, ) -> Tuple[ivy.Array, ivy.Array]: - """Sign correction to ensure deterministic output from SVD. Adjusts the - columns of u and the rows of v such that the loadings in the columns in u - that are largest in absolute value are always positive. This function is - borrowed from scikit- learn/utils/extmath.py. + """ + Sign correction to ensure deterministic output from SVD. Adjusts the columns of u + and the rows of v such that the loadings in the columns in u that are largest in + absolute value are always positive. This function is borrowed from scikit- + learn/utils/extmath.py. Parameters ---------- @@ -1079,8 +1091,9 @@ def make_svd_non_negative( *, nntype: Optional[Literal["nndsvd", "nndsvda"]] = "nndsvd", ) -> Tuple[ivy.Array, ivy.Array]: - """Use NNDSVD method to transform SVD results into a non-negative form. - This method leads to more efficient solving with NNMF [1]. + """ + Use NNDSVD method to transform SVD results into a non-negative form. This method + leads to more efficient solving with NNMF [1]. Parameters ---------- @@ -1170,7 +1183,8 @@ def truncated_svd( compute_uv: bool = True, n_eigenvecs: Optional[int] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array, ivy.Array]]: - """Compute a truncated SVD on `x` using the standard SVD. + """ + Compute a truncated SVD on `x` using the standard SVD. Parameters ---------- @@ -1214,7 +1228,8 @@ def tensor_train( svd: Optional[Literal["truncated_svd"]] = "truncated_svd", verbose: Optional[bool] = False, ) -> ivy.TTTensor: - """TT decomposition via recursive SVD. + """ + TT decomposition via recursive SVD. Decomposes the input into a sequence of order-3 tensors (factors) Also known as Tensor-Train decomposition [1]_ @@ -1344,11 +1359,11 @@ def initialize_tucker( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, svd_mask_repeats: Optional[int] = 5, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """Initialize core and factors used in `tucker`. The type of initialization - is set using `init`. If `init == 'random'` then initialize factor matrices - using `random_state`. If `init == 'svd'` then initialize the `m`th factor - matrix using the `rank` left singular vectors of the `m`th unfolding of the - input tensor. + """ + Initialize core and factors used in `tucker`. The type of initialization is set + using `init`. If `init == 'random'` then initialize factor matrices using + `random_state`. If `init == 'svd'` then initialize the `m`th factor matrix using the + `rank` left singular vectors of the `m`th unfolding of the input tensor. Parameters ---------- @@ -1460,7 +1475,8 @@ def partial_tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """Partial tucker decomposition via Higher Order Orthogonal Iteration (HOI) + """ + Partial tucker decomposition via Higher Order Orthogonal Iteration (HOI) Decomposes `tensor` into a Tucker decomposition exclusively along the provided modes. @@ -1608,7 +1624,8 @@ def tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ): - """Tucker decomposition via Higher Order Orthogonal Iteration (HOI) + """ + Tucker decomposition via Higher Order Orthogonal Iteration (HOI) Decomposes `tensor` into a Tucker decomposition: ``tensor = [| core; factors[0], ...factors[-1] |]`` [1]_ @@ -1744,9 +1761,10 @@ def tt_matrix_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the full tensor whose TT-Matrix decomposition is given by - 'factors' Re- assembles 'factors', which represent a tensor in TT-Matrix - format into the corresponding full tensor. + """ + Return the full tensor whose TT-Matrix decomposition is given by 'factors' Re- + assembles 'factors', which represent a tensor in TT-Matrix format into the + corresponding full tensor. Parameters ---------- @@ -1814,9 +1832,10 @@ def dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the dot product between two arrays `a` and `b` using the current - backend's implementation. The dot product is defined as the sum of the - element-wise product of the input arrays. + """ + Compute the dot product between two arrays `a` and `b` using the current backend's + implementation. The dot product is defined as the sum of the element-wise product of + the input arrays. Parameters ---------- @@ -1874,7 +1893,8 @@ def general_inner_product( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Generalised inner products between tensors. + """ + Generalised inner products between tensors. Takes the inner product between the last (respectively first) `n_modes` of `a` (respectively `b`) @@ -1963,7 +1983,8 @@ def higher_order_moment( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Higher-Order Moment. + """ + Compute the Higher-Order Moment. Parameters ---------- @@ -2010,7 +2031,8 @@ def batched_outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a generalized outer product of the tensors. + """ + Return a generalized outer product of the tensors. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/losses.py b/ivy/functional/ivy/experimental/losses.py index 394863b5ddc26..bbe41582b354a 100644 --- a/ivy/functional/ivy/experimental/losses.py +++ b/ivy/functional/ivy/experimental/losses.py @@ -28,13 +28,13 @@ def log_poisson_loss( reduction: str = "none", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the log-likelihood loss between the prediction and the target - under the assumption that the target has a Poisson distribution. Caveat: By - default, this is not the exact loss, but the loss minus a constant term - [log(z!)]. That has no effect for optimization, but does not play well with - relative loss comparisons. To compute an approximation of the log factorial - term, specify ``compute_full_loss=True`` to enable Stirling's - Approximation. + """ + Compute the log-likelihood loss between the prediction and the target under the + assumption that the target has a Poisson distribution. Caveat: By default, this is + not the exact loss, but the loss minus a constant term [log(z!)]. That has no effect + for optimization, but does not play well with relative loss comparisons. To compute + an approximation of the log factorial term, specify ``compute_full_loss=True`` to + enable Stirling's Approximation. Parameters ---------- @@ -169,8 +169,8 @@ def huber_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Huber loss (smooth L1 loss) between true and predicted - values. + """ + Compute the Huber loss (smooth L1 loss) between true and predicted values. Parameters ---------- @@ -234,7 +234,8 @@ def smooth_l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the smooth L1 loss between two input tensors. + """ + Compute the smooth L1 loss between two input tensors. Parameters ---------- @@ -362,8 +363,8 @@ def soft_margin_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the soft-margin hinge loss between predicted scores and true - binary labels. + """ + Compute the soft-margin hinge loss between predicted scores and true binary labels. Parameters ---------- @@ -423,7 +424,8 @@ def kl_div( log_target=False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Kullback-Leibler divergence loss between two input tensors + """ + Compute the Kullback-Leibler divergence loss between two input tensors (conventionally, probability distributions). Parameters @@ -509,7 +511,8 @@ def poisson_nll_loss( eps: float = 1e-8, reduction: str = "mean", ) -> ivy.Array: - r"""Compute the Poisson Negative Log Likelihood Loss. + r""" + Compute the Poisson Negative Log Likelihood Loss. This function calculates the negative log likelihood loss between the `input` and `target`under the assumption that @@ -584,9 +587,9 @@ def hinge_embedding_loss( margin: float = 1.0, reduction: str = "mean", ) -> ivy.Array: - r"""Measures loss from input `x` and label `y` with values 1 or -1. It - evaluates if two inputs are similar or not, often used for embedding or - semi-supervised learning. + r""" + Measures loss from input `x` and label `y` with values 1 or -1. It evaluates if two + inputs are similar or not, often used for embedding or semi-supervised learning. Loss for the `n`-th sample: .. math:: diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index 8fe94fbf57f2b..3f3fd22d9c0cf 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -103,10 +103,10 @@ def flatten( order: Optional[str] = "C", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Flattens input by reshaping it into a one-dimensional tensor. If - start_dim or end_dim are passed, only dimensions starting with start_dim - and ending with end_dim are flattened. The order of elements in input is - unchanged. + """ + Flattens input by reshaping it into a one-dimensional tensor. If start_dim or + end_dim are passed, only dimensions starting with start_dim and ending with end_dim + are flattened. The order of elements in input is unchanged. Parameters ---------- @@ -260,7 +260,8 @@ def moveaxis( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Move axes of an array to new positions.. + """ + Move axes of an array to new positions.. Parameters ---------- @@ -309,7 +310,8 @@ def heaviside( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Heaviside step function for each element in x1. + """ + Compute the Heaviside step function for each element in x1. Parameters ---------- @@ -357,9 +359,9 @@ def flipud( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Flip array in the up/down direction. Flip the entries in each column in - the up/down direction. Rows are preserved, but appear in a different order - than before. + """ + Flip array in the up/down direction. Flip the entries in each column in the up/down + direction. Rows are preserved, but appear in a different order than before. Parameters ---------- @@ -401,7 +403,8 @@ def vstack( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """Stack arrays in sequence vertically (row wise). + """ + Stack arrays in sequence vertically (row wise). Parameters ---------- @@ -445,7 +448,8 @@ def hstack( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """Stack arrays in sequence horizotally (column wise). + """ + Stack arrays in sequence horizotally (column wise). Parameters ---------- @@ -491,8 +495,9 @@ def rot90( axes: Tuple[int, int] = (0, 1), out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Rotate an array by 90 degrees in the plane specified by axes. Rotation - direction is from the first towards the second axis. + """ + Rotate an array by 90 degrees in the plane specified by axes. Rotation direction is + from the first towards the second axis. Parameters ---------- @@ -578,8 +583,8 @@ def top_k( sorted: bool = True, out: Optional[tuple] = None, ) -> Tuple[ivy.Array, ivy.NativeArray]: - """Return the `k` largest elements of the given input array along a given - axis. + """ + Return the `k` largest elements of the given input array along a given axis. Parameters ---------- @@ -657,9 +662,10 @@ def fliplr( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Flip array in the left/right direction. Flip the entries in each column - in the left/right direction. Columns are preserved, but appear in a - different order than before. + """ + Flip array in the left/right direction. Flip the entries in each column in the + left/right direction. Columns are preserved, but appear in a different order than + before. Parameters ---------- @@ -702,7 +708,8 @@ def i0( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the Bessel i0 function of x element-wise. + """ + Compute the Bessel i0 function of x element-wise. Parameters ---------- @@ -1046,7 +1053,8 @@ def pad( reflect_type: Literal["even", "odd"] = "even", **kwargs: Optional[Any], ) -> ivy.Array: - """Pad an array. + """ + Pad an array. Parameters ---------- @@ -1285,7 +1293,8 @@ def vsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """Split an array vertically into multiple sub-arrays. + """ + Split an array vertically into multiple sub-arrays. Parameters ---------- @@ -1335,7 +1344,8 @@ def dsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """Split an array into multiple sub-arrays along the 3rd axis. + """ + Split an array into multiple sub-arrays along the 3rd axis. Parameters ---------- @@ -1385,9 +1395,9 @@ def atleast_1d( *arys: Union[ivy.Array, ivy.NativeArray, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """Convert inputs to arrays with at least one dimension. Scalar inputs are - converted to 1-dimensional arrays, whilst higher-dimensional inputs are - preserved. + """ + Convert inputs to arrays with at least one dimension. Scalar inputs are converted to + 1-dimensional arrays, whilst higher-dimensional inputs are preserved. Parameters ---------- @@ -1430,7 +1440,8 @@ def dstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Stack arrays in sequence depth wise (along third axis). + """ + Stack arrays in sequence depth wise (along third axis). Parameters ---------- @@ -1470,9 +1481,9 @@ def atleast_2d( *arys: Union[ivy.Array, ivy.NativeArray], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """Convert inputs to arrays with at least two dimension. Scalar inputs are - converted to 2-dimensional arrays, whilst higher-dimensional inputs are - preserved. + """ + Convert inputs to arrays with at least two dimension. Scalar inputs are converted to + 2-dimensional arrays, whilst higher-dimensional inputs are preserved. Parameters ---------- @@ -1516,9 +1527,9 @@ def atleast_3d( *arys: Union[ivy.Array, ivy.NativeArray, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """Convert inputs to arrays with at least three dimension. Scalar inputs - are converted to 3-dimensional arrays, whilst higher-dimensional inputs are - preserved. + """ + Convert inputs to arrays with at least three dimension. Scalar inputs are converted + to 3-dimensional arrays, whilst higher-dimensional inputs are preserved. Parameters ---------- @@ -1577,7 +1588,8 @@ def take_along_axis( mode: str = "fill", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Take values from the input array by matching 1d index and data slices. + """ + Take values from the input array by matching 1d index and data slices. Parameters ---------- @@ -1627,7 +1639,8 @@ def hsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """Split an array into multiple sub-arrays horizontally. + """ + Split an array into multiple sub-arrays horizontally. Parameters ---------- @@ -1673,7 +1686,8 @@ def hsplit( @handle_exceptions @inputs_to_native_shapes def broadcast_shapes(*shapes: Union[List[int], List[Tuple]]) -> Tuple[int]: - """Broadcasts shapes. + """ + Broadcasts shapes. Parameters ---------- @@ -1714,8 +1728,8 @@ def expand( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Broadcast the input Array following the given shape and the broadcast - rule. + """ + Broadcast the input Array following the given shape and the broadcast rule. Parameters ---------- @@ -1756,8 +1770,9 @@ def put_along_axis( mode: Literal["sum", "min", "max", "mul", "mean", "replace"] = "replace", out: Optional[ivy.Array] = None, ) -> None: - """Put values into the input array by matching 1d index and data slices - along a specified axis. + """ + Put values into the input array by matching 1d index and data slices along a + specified axis. Parameters ---------- @@ -1850,7 +1865,8 @@ def as_strided( strides: Sequence[int], /, ) -> ivy.Array: - """Create a copy of the input array with the given shape and strides. + """ + Create a copy of the input array with the given shape and strides. Parameters ---------- @@ -1931,7 +1947,8 @@ def concat_from_sequence( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Concatenate a sequence of arrays along a new or an existing axis. + """ + Concatenate a sequence of arrays along a new or an existing axis. Parameters ---------- @@ -2037,7 +2054,8 @@ def associative_scan( reverse: bool = False, axis: int = 0, ) -> ivy.Array: - """Perform an associative scan over the given array. + """ + Perform an associative scan over the given array. Parameters ---------- @@ -2122,8 +2140,9 @@ def unique_consecutive( Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray], ]: - """Eliminates all but the first element from every consecutive group of - equivalent elements in ``x``. + """ + Eliminates all but the first element from every consecutive group of equivalent + elements in ``x``. Parameters ---------- @@ -2169,7 +2188,8 @@ def fill_diagonal( *, wrap: bool = False, ) -> Union[ivy.Array, ivy.NativeArray]: - """Fill the main diagonal of the given array of any dimensionality.. + """ + Fill the main diagonal of the given array of any dimensionality.. Parameters ---------- @@ -2235,7 +2255,8 @@ def unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the mode-`mode` unfolding of `tensor` with modes starting at `0`. + """ + Return the mode-`mode` unfolding of `tensor` with modes starting at `0`. Parameters ---------- @@ -2268,9 +2289,9 @@ def fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Refolds the mode-`mode` unfolding into a tensor of shape `shape` In - other words, refolds the n-mode unfolded tensor into the original tensor of - the specified shape. + """ + Refolds the mode-`mode` unfolding into a tensor of shape `shape` In other words, + refolds the n-mode unfolded tensor into the original tensor of the specified shape. Parameters ---------- @@ -2310,11 +2331,11 @@ def partial_unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Partial unfolding of a tensor while ignoring the specified number of - dimensions at the beginning and the end. For instance, if the first - dimension of the tensor is the number of samples, to unfold each sample, - set skip_begin=1. This would, for each i in ``range(tensor.shape[0])``, - unfold ``tensor[i, ...]``. + """ + Partial unfolding of a tensor while ignoring the specified number of dimensions at + the beginning and the end. For instance, if the first dimension of the tensor is the + number of samples, to unfold each sample, set skip_begin=1. This would, for each i + in ``range(tensor.shape[0])``, unfold ``tensor[i, ...]``. Parameters ---------- @@ -2367,7 +2388,8 @@ def partial_fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Re-folds a partially unfolded tensor. + """ + Re-folds a partially unfolded tensor. Parameters ---------- @@ -2409,8 +2431,9 @@ def partial_tensor_to_vec( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Partial vectorization of a tensor while ignoring the specified dimension - at the beginning and the end. + """ + Partial vectorization of a tensor while ignoring the specified dimension at the + beginning and the end. Parameters ---------- @@ -2453,7 +2476,8 @@ def partial_vec_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Refolds a partially vectorised tensor into a full one. + """ + Refolds a partially vectorised tensor into a full one. Parameters ---------- @@ -2488,7 +2512,8 @@ def matricize( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Matricizes the given tensor. + """ + Matricizes the given tensor. Parameters ---------- @@ -2545,7 +2570,8 @@ def soft_thresholding( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Soft-thresholding operator. + """ + Soft-thresholding operator. sign(tensor) * max[abs(tensor) - threshold, 0] @@ -2605,7 +2631,8 @@ def choose( out: None = None, mode: Union[str, None] = None, ) -> ivy.Array: - """Take values from the input array by matching 1d index and data slices. + """ + Take values from the input array by matching 1d index and data slices. Parameters ---------- @@ -2651,7 +2678,8 @@ def column_stack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Create a new array by horizontally stacking the arrays in arrays. + """ + Create a new array by horizontally stacking the arrays in arrays. Equivalent to `ivy.hstack(arrays)`, except each zero or one dimensional array `x` in arrays is first reshaped into a `(x.size(), 1)` column @@ -2723,7 +2751,8 @@ def take( fill_value: Optional[Number] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return elements of an array along an axis. + """ + Return elements of an array along an axis. .. note:: Conceptually, take(x, indices, axis=3) is equivalent to x[:,:,:,indices,...]; @@ -2830,9 +2859,10 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ivy.Container instance method variant of ivy.trim_zeros. This method - simply wraps the function, and so the docstring for ivy.trim_zeros also - applies to this method with minimal changes. + """ + ivy.Container instance method variant of ivy.trim_zeros. This method simply wraps + the function, and so the docstring for ivy.trim_zeros also applies to this method + with minimal changes. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/norms.py b/ivy/functional/ivy/experimental/norms.py index 5418c3fb50df8..236e0deb967d7 100644 --- a/ivy/functional/ivy/experimental/norms.py +++ b/ivy/functional/ivy/experimental/norms.py @@ -120,11 +120,11 @@ def local_response_norm( data_format: Optional[Literal["NHWC", "NCHW"]] = "NHWC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> ivy.Array: - """Apply local response normalization across the channels of a 4D input - array. The 4-D array is treated as a 3-D array of 1-D vectors (along the - channel dimension), and each vector is normalized independently. Within a - given vector, each component is divided by the squared sum of the - neighbouring components. + """ + Apply local response normalization across the channels of a 4D input array. The 4-D + array is treated as a 3-D array of 1-D vectors (along the channel dimension), and + each vector is normalized independently. Within a given vector, each component is + divided by the squared sum of the neighbouring components. Parameters ---------- @@ -453,8 +453,8 @@ def group_norm( data_format: Optional[str] = "NSC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply group normalization to the input array and returns the normalized - input. + """ + Apply group normalization to the input array and returns the normalized input. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/random.py b/ivy/functional/ivy/experimental/random.py index e2fc3828473dc..5a653147a385a 100644 --- a/ivy/functional/ivy/experimental/random.py +++ b/ivy/functional/ivy/experimental/random.py @@ -29,10 +29,11 @@ def dirichlet( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Draw size samples of dimension k from a Dirichlet distribution. A - Dirichlet- distributed random variable can be seen as a multivariate - generalization of a Beta distribution. The Dirichlet distribution is a - conjugate prior of a multinomial distribution in Bayesian inference. + """ + Draw size samples of dimension k from a Dirichlet distribution. A Dirichlet- + distributed random variable can be seen as a multivariate generalization of a Beta + distribution. The Dirichlet distribution is a conjugate prior of a multinomial + distribution in Bayesian inference. Parameters ---------- @@ -98,8 +99,8 @@ def beta( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return an array filled with random values sampled from a beta - distribution. + """ + Return an array filled with random values sampled from a beta distribution. Parameters ---------- @@ -153,8 +154,8 @@ def gamma( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return an array filled with random values sampled from a gamma - distribution. + """ + Return an array filled with random values sampled from a gamma distribution. Parameters ---------- @@ -204,7 +205,8 @@ def poisson( fill_value: Optional[Union[int, float]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Draws samples from a poisson distribution. + """ + Draws samples from a poisson distribution. Parameters ---------- @@ -274,8 +276,9 @@ def bernoulli( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Draws samples from Bernoulli distribution parameterized by probs or - logits (but not both) + """ + Draws samples from Bernoulli distribution parameterized by probs or logits (but not + both) Parameters ---------- diff --git a/ivy/functional/ivy/experimental/searching.py b/ivy/functional/ivy/experimental/searching.py index 69c7045f95e42..25c8928a55f9e 100644 --- a/ivy/functional/ivy/experimental/searching.py +++ b/ivy/functional/ivy/experimental/searching.py @@ -23,8 +23,8 @@ def unravel_index( *, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array]: - """Convert a flat index or array of flat indices into a tuple of coordinate - arrays. + """ + Convert a flat index or array of flat indices into a tuple of coordinate arrays. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/sorting.py b/ivy/functional/ivy/experimental/sorting.py index 0d170828570eb..0d2d18ddf3c88 100644 --- a/ivy/functional/ivy/experimental/sorting.py +++ b/ivy/functional/ivy/experimental/sorting.py @@ -22,7 +22,8 @@ def invert_permutation( x: Union[ivy.Array, ivy.NativeArray, list, tuple], /, ) -> ivy.Array: - """Compute the inverse of an index permutation. + """ + Compute the inverse of an index permutation. Parameters ---------- @@ -61,11 +62,11 @@ def lexsort( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Perform an indirect stable sort with an array of keys in ascending - order, with the last key used as primary sort order, second-to-last for - secondary, and so on. Each row of the key must have the same length, which - will also be the length of the returned array of integer indices, which - describes the sort order. + """ + Perform an indirect stable sort with an array of keys in ascending order, with the + last key used as primary sort order, second-to-last for secondary, and so on. Each + row of the key must have the same length, which will also be the length of the + returned array of integer indices, which describes the sort order. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/statistical.py b/ivy/functional/ivy/experimental/statistical.py index bf69d12cd5cf2..ce8ecd50e4693 100644 --- a/ivy/functional/ivy/experimental/statistical.py +++ b/ivy/functional/ivy/experimental/statistical.py @@ -38,7 +38,8 @@ def histogram( density: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the histogram of the array ``a``. + """ + Compute the histogram of the array ``a``. .. note:: Given bins = [c0, ..., cK], defining intervals I0 = [c0, c1), I1 = [c1, c2), @@ -164,7 +165,8 @@ def median( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the median along the specified axis. + """ + Compute the median along the specified axis. Parameters ---------- @@ -211,7 +213,8 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the mean of all non-NaN elements along the specified dimensions. + """ + Compute the mean of all non-NaN elements along the specified dimensions. Parameters ---------- @@ -266,7 +269,8 @@ def nanmin( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return minimum of an array or minimum along an axis, ignoring any NaNs. + """ + Return minimum of an array or minimum along an axis, ignoring any NaNs. Parameters ---------- @@ -329,8 +333,9 @@ def nanprod( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the product of array elements over a given axis treating Not a - Numbers (NaNs) as ones. + """ + Compute the product of array elements over a given axis treating Not a Numbers + (NaNs) as ones. Parameters ---------- @@ -394,7 +399,8 @@ def quantile( interpolation: str = "linear", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the q-th quantile of the data along the specified axis. + """ + Compute the q-th quantile of the data along the specified axis. Parameters ---------- @@ -496,9 +502,10 @@ def nanmedian( overwrite_input: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ivy.Array instance method variant of ivy.nanmedian. This method simply - wraps the function, and so the docstring for ivy.nanmedian also applies to - this method with minimal changes. + """ + ivy.Array instance method variant of ivy.nanmedian. This method simply wraps the + function, and so the docstring for ivy.nanmedian also applies to this method with + minimal changes. Parameters ---------- @@ -567,7 +574,8 @@ def bincount( minlength: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Count the number of occurrences of each value in an integer array. + """ + Count the number of occurrences of each value in an integer array. Parameters ---------- @@ -609,7 +617,8 @@ def igamma( x: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """Compute the regularized lower gamma function of ``a`` and ``x``. + """ + Compute the regularized lower gamma function of ``a`` and ``x``. Parameters ---------- @@ -653,7 +662,8 @@ def cov( aweights: Optional[ivy.Array] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ) -> ivy.Array: - """Compute the covariance of matrix x1, or variables x1 and x2. + """ + Compute the covariance of matrix x1, or variables x1 and x2. Parameters ---------- @@ -796,9 +806,9 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a tuple containing the cumulative maximum of elements of input - along the given axis and index location of each maximum value found along - the given axis. + """ + Return a tuple containing the cumulative maximum of elements of input along the + given axis and index location of each maximum value found along the given axis. Parameters ---------- @@ -897,7 +907,8 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the cumulative minimum of the elements along a given axis. + """ + Return the cumulative minimum of the elements along a given axis. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/utility.py b/ivy/functional/ivy/experimental/utility.py index f16428089885c..e33383151b01c 100644 --- a/ivy/functional/ivy/experimental/utility.py +++ b/ivy/functional/ivy/experimental/utility.py @@ -16,10 +16,11 @@ def optional_get_element( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """If the input is a tensor or sequence type, it returns the input. If the - input is an optional type, it outputs the element in the input. It is an - error if the input is an empty optional-type (i.e. does not have an - element) and the behavior is undefined in this case. + """ + If the input is a tensor or sequence type, it returns the input. If the input is an + optional type, it outputs the element in the input. It is an error if the input is + an empty optional-type (i.e. does not have an element) and the behavior is undefined + in this case. Parameters ---------- diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index ab09c25b25d43..22beed2e3cc2d 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -94,9 +94,9 @@ def __exit__(self, exc_type, exc_val, exc_tb): @handle_exceptions def set_precise_mode(mode: bool) -> None: - """Set the mode of whether to use a promotion table that avoids any - precision loss or a compute efficient table that avoids most wider-than- - necessary promotions. + """ + Set the mode of whether to use a promotion table that avoids any precision loss or a + compute efficient table that avoids most wider-than- necessary promotions. Parameter --------- @@ -122,9 +122,9 @@ def set_precise_mode(mode: bool) -> None: @handle_exceptions def unset_precise_mode() -> None: - """Reset the mode of whether to use a promotion table that avoids any - precision loss or a compute efficient table that avoids most wider-than- - necessary promotions. + """ + Reset the mode of whether to use a promotion table that avoids any precision loss or + a compute efficient table that avoids most wider-than- necessary promotions. Examples -------- @@ -187,7 +187,8 @@ def get_referrers_recursive( seen_set: Optional[set] = None, local_set: Optional[set] = None, ) -> ivy.Container: - """Recursively retrieve referrers for an object. + """ + Recursively retrieve referrers for an object. This function recursively fetches referrers for the specified `item` up to a given `max_depth`. @@ -284,7 +285,8 @@ def get_referrers_recursive_inner(): def is_native_array( x: Union[ivy.Array, ivy.NativeArray], /, *, exclusive: bool = False ) -> bool: - """Determine whether the input x is an :class:`ivy.NativeArray` instance. + """ + Determine whether the input x is an :class:`ivy.NativeArray` instance. Parameters ---------- @@ -320,7 +322,8 @@ def is_native_array( def is_ivy_array( x: Union[ivy.Array, ivy.NativeArray], /, *, exclusive: Optional[bool] = False ) -> bool: - """Determine whether the input x is a valid Ivy Array. + """ + Determine whether the input x is a valid Ivy Array. Parameters ---------- @@ -351,7 +354,8 @@ def is_ivy_array( @handle_exceptions @handle_backend_invalid def is_array(x: Any, /, *, exclusive: bool = False) -> bool: - """Determine whether the input x is either an Ivy Array or a Native Array. + """ + Determine whether the input x is either an Ivy Array or a Native Array. Parameters ---------- @@ -387,7 +391,8 @@ def is_array(x: Any, /, *, exclusive: bool = False) -> bool: @handle_exceptions def is_ivy_container(x: Any, /) -> bool: - """Determine whether the input x is an Ivy Container. + """ + Determine whether the input x is an Ivy Container. Parameters ---------- @@ -417,8 +422,9 @@ def is_ivy_container(x: Any, /) -> bool: @handle_exceptions def set_array_mode(mode: bool) -> None: - """Set the mode of whether to convert inputs to ivy.NativeArray, then - convert outputs back to ivy.Array. + """ + Set the mode of whether to convert inputs to ivy.NativeArray, then convert outputs + back to ivy.Array. It Stops the conversion of ivy.NativeArray to ivy.Array in the case when it is set to False. @@ -446,8 +452,9 @@ def set_array_mode(mode: bool) -> None: @handle_exceptions def unset_array_mode() -> None: - """Reset the mode of converting inputs to ivy.NativeArray, then converting - outputs back to ivy.Array to the previous state. + """ + Reset the mode of converting inputs to ivy.NativeArray, then converting outputs back + to ivy.Array to the previous state. Examples -------- @@ -471,7 +478,8 @@ def unset_array_mode() -> None: @handle_exceptions def set_nestable_mode(mode: bool) -> None: - """Set the mode of whether to check if function inputs are ivy.Container. + """ + Set the mode of whether to check if function inputs are ivy.Container. Parameter --------- @@ -496,8 +504,9 @@ def set_nestable_mode(mode: bool) -> None: @handle_exceptions def unset_nestable_mode() -> None: - """Reset the mode of whether to check if function inputs are ivy.Container - to the previous state. + """ + Reset the mode of whether to check if function inputs are ivy.Container to the + previous state. Examples -------- @@ -523,9 +532,9 @@ def unset_nestable_mode() -> None: @handle_exceptions def set_exception_trace_mode(mode: Literal["ivy", "full", "frontend"]) -> None: - """Set the mode of whether to show frontend-truncated exception stack - traces, ivy- truncated exception stack traces or full exception stack - traces. + """ + Set the mode of whether to show frontend-truncated exception stack traces, ivy- + truncated exception stack traces or full exception stack traces. Parameter --------- @@ -553,7 +562,8 @@ def set_exception_trace_mode(mode: Literal["ivy", "full", "frontend"]) -> None: @handle_exceptions def unset_exception_trace_mode() -> None: - """Reset the trace mode to the previously set mode. + """ + Reset the trace mode to the previously set mode. Examples -------- @@ -581,8 +591,8 @@ def unset_exception_trace_mode() -> None: @handle_exceptions def set_show_func_wrapper_trace_mode(mode: bool) -> None: - """Set the mode of whether to show the full stack trace with function - wrapping traces. + """ + Set the mode of whether to show the full stack trace with function wrapping traces. Parameter --------- @@ -607,8 +617,9 @@ def set_show_func_wrapper_trace_mode(mode: bool) -> None: @handle_exceptions def unset_show_func_wrapper_trace_mode() -> None: - """Reset the mode of whether to show the full stack trace with function - wrapping traces. + """ + Reset the mode of whether to show the full stack trace with function wrapping + traces. Examples -------- @@ -643,7 +654,8 @@ def array_equal( x1: Union[ivy.Array, ivy.NativeArray], /, ) -> bool: - """Determine whether two input arrays are equal across all elements. + """ + Determine whether two input arrays are equal across all elements. Parameters ---------- @@ -687,7 +699,8 @@ def array_equal( def all_equal( *xs: Iterable[Any], equality_matrix: bool = False ) -> Union[bool, ivy.Array, ivy.NativeArray]: - """Determine whether the inputs are all equal. + """ + Determine whether the inputs are all equal. Parameters ---------- @@ -780,7 +793,8 @@ def all_equal( def to_numpy( x: Union[ivy.Array, ivy.NativeArray], /, *, copy: bool = True ) -> np.ndarray: - """Convert an array into a numpy array. + """ + Convert an array into a numpy array. Parameters ---------- @@ -850,7 +864,8 @@ def isscalar(x: Any, /) -> bool: @handle_array_function @handle_device def to_scalar(x: Union[ivy.Array, ivy.NativeArray], /) -> Number: - """Convert an array with a single element into a scalar. + """ + Convert an array with a single element into a scalar. Parameters ---------- @@ -906,7 +921,8 @@ def to_scalar(x: Union[ivy.Array, ivy.NativeArray], /) -> Number: @handle_array_function @handle_device def to_list(x: Union[ivy.Array, ivy.NativeArray], /) -> List: - """Create a (possibly nested) list from input array. + """ + Create a (possibly nested) list from input array. Parameters ---------- @@ -983,7 +999,8 @@ def clip_vector_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Clips (limits) the vector p-norm of an array. + """ + Clips (limits) the vector p-norm of an array. Parameters ---------- @@ -1082,7 +1099,8 @@ def clip_matrix_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Clips (limits) the matrix norm of an array. + """ + Clips (limits) the matrix norm of an array. Parameters ---------- @@ -1165,7 +1183,8 @@ def fourier_encode( concat: bool = True, flatten: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Tuple]: - """Pad an array with fourier encodings. + """ + Pad an array with fourier encodings. Parameters ---------- @@ -1265,7 +1284,8 @@ def value_is_nan( *, include_infs: bool = True, ) -> bool: - """Determine whether the single valued array or scalar is of nan type. + """ + Determine whether the single valued array or scalar is of nan type. Parameters ---------- @@ -1323,8 +1343,9 @@ def value_is_nan( def has_nans( x: Union[ivy.Array, ivy.NativeArray], /, *, include_infs: bool = True ) -> bool: - """Determine whether the array contains any nans, as well as infs or -infs - if specified. + """ + Determine whether the array contains any nans, as well as infs or -infs if + specified. Parameters ---------- @@ -1383,7 +1404,8 @@ def has_nans( @handle_exceptions def exists(x: Any, /) -> bool: - """Check as to whether the input is None or not. + """ + Check as to whether the input is None or not. Parameters ---------- @@ -1464,7 +1486,8 @@ def default( rev: bool = False, with_callable: bool = False, ) -> Any: - """Return x provided it exists (is not None), else returns default value. + """ + Return x provided it exists (is not None), else returns default value. Parameters ---------- @@ -1555,7 +1578,8 @@ def default( @handle_exceptions def to_ivy_shape(shape: Union[ivy.Shape, ivy.NativeShape]) -> ivy.Shape: - """Return the input shape in ivy.Shape form. + """ + Return the input shape in ivy.Shape form. Parameters ---------- @@ -1576,7 +1600,8 @@ def to_ivy_shape(shape: Union[ivy.Shape, ivy.NativeShape]) -> ivy.Shape: def to_native_shape( shape: Union[ivy.Array, ivy.Shape, ivy.NativeShape, tuple, int, list] ) -> ivy.NativeShape: - """Return the input shape in its native backend framework form. + """ + Return the input shape in its native backend framework form. Parameters ---------- @@ -1618,8 +1643,9 @@ def to_native_shape( @handle_exceptions @handle_nestable def try_else_none(fn: Callable, *args: Any, **kwargs: Any) -> Union[Callable, None]: - """Try and return the function, otherwise return None if an exception was - raised during function execution. + """ + Try and return the function, otherwise return None if an exception was raised during + function execution. Parameters ---------- @@ -1662,7 +1688,8 @@ def try_else_none(fn: Callable, *args: Any, **kwargs: Any) -> Union[Callable, No @handle_exceptions def arg_names(receiver): - """Get the expected keyword arguments for a function or class constructor. + """ + Get the expected keyword arguments for a function or class constructor. Parameters ---------- @@ -1692,7 +1719,8 @@ def arg_names(receiver): def match_kwargs( kwargs: Dict, *receivers: Iterable[Callable], allow_duplicates: bool = False ) -> Union[List[Dict], Dict]: - """Match keyword arguments to either class or function receivers. + """ + Match keyword arguments to either class or function receivers. Parameters ---------- @@ -1738,7 +1766,8 @@ def match_kwargs( @handle_exceptions def cache_fn(func: Callable) -> Callable: - """Cache function outputs. + """ + Cache function outputs. A decorator to wrap a function, such that computed outputs are cached to avoid recalculating them later. @@ -1791,7 +1820,8 @@ def cached_fn(*args, **kwargs): @handle_exceptions def current_backend_str() -> Union[str, None]: - """Return framework string. + """ + Return framework string. Returns ------- @@ -1817,7 +1847,8 @@ def einops_rearrange( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """Perform einops rearrange operation on input array x. + """ + Perform einops rearrange operation on input array x. Parameters ---------- @@ -1952,7 +1983,8 @@ def einops_reduce( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """Perform einops reduce operation on input array x. + """ + Perform einops reduce operation on input array x. Parameters ---------- @@ -2028,7 +2060,8 @@ def einops_repeat( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """Perform einops repeat operation on input array x. + """ + Perform einops repeat operation on input array x. Parameters ---------- @@ -2088,8 +2121,8 @@ def einops_repeat( @handle_exceptions @handle_array_function def set_min_denominator(val: float) -> None: - """Set the global minimum denominator used by ivy for numerically stable - division. + """ + Set the global minimum denominator used by ivy for numerically stable division. Parameters ---------- @@ -2115,8 +2148,9 @@ def set_min_denominator(val: float) -> None: @handle_exceptions def unset_min_denominator() -> None: - """Reset the global minimum denominator used by ivy for numerically stable - division to the previous value. + """ + Reset the global minimum denominator used by ivy for numerically stable division to + the previous value. Examples -------- @@ -2142,8 +2176,8 @@ def unset_min_denominator() -> None: @handle_exceptions @handle_array_function def set_min_base(val: float) -> None: - """Set the global minimum base used by ivy for numerically stable power - raising. + """ + Set the global minimum base used by ivy for numerically stable power raising. Parameters ---------- @@ -2179,8 +2213,9 @@ def set_min_base(val: float) -> None: @handle_exceptions def unset_min_base() -> None: - """Reset the global minimum base used by ivy for numerically stable power - raising to the previous value. + """ + Reset the global minimum base used by ivy for numerically stable power raising to + the previous value. Examples -------- @@ -2212,8 +2247,9 @@ def stable_divide( *, min_denominator: Union[Number, ivy.Array, ivy.NativeArray] = None, ) -> Union[Number, ivy.Array]: - """Divide the numerator by the denominator, with min denominator added to - the denominator for numerical stability. + """ + Divide the numerator by the denominator, with min denominator added to the + denominator for numerical stability. Parameters ---------- @@ -2311,8 +2347,9 @@ def stable_pow( *, min_base: Optional[float] = None, ) -> Any: - """Raise the base by the power, with ivy.min_base added to the base when - exponent > 1 for numerical stability. + """ + Raise the base by the power, with ivy.min_base added to the base when exponent > 1 + for numerical stability. Parameters ---------- @@ -2400,7 +2437,8 @@ def stable_pow( @handle_exceptions def get_all_arrays_in_memory() -> List[Union[ivy.Array, ivy.NativeArray]]: - """Get all arrays which are currently alive. + """ + Get all arrays which are currently alive. Returns ------- @@ -2435,7 +2473,8 @@ def get_all_arrays_in_memory() -> List[Union[ivy.Array, ivy.NativeArray]]: @handle_exceptions def num_arrays_in_memory() -> int: - """Return the number of arrays which are currently alive. + """ + Return the number of arrays which are currently alive. Returns ------- @@ -2458,7 +2497,8 @@ def num_arrays_in_memory() -> int: @handle_exceptions def print_all_arrays_in_memory(): - """Print all native Ivy arrays in memory to the console. + """ + Print all native Ivy arrays in memory to the console. Gets all the native Ivy arrays which are currently alive(in the garbage collector) from get_all_arrays_in_memory() function and @@ -2474,7 +2514,8 @@ def print_all_arrays_in_memory(): @handle_exceptions @handle_array_function def set_queue_timeout(timeout: float): - """Set a timeout value (in seconds) for the global queue. + """ + Set a timeout value (in seconds) for the global queue. Set the global queue timeout value (in seconds) Default value without this function being called is 15 seconds. @@ -2505,7 +2546,8 @@ def set_queue_timeout(timeout: float): @handle_exceptions def unset_queue_timeout() -> None: - """Reset the global queue timeout value (in seconds) to the previous state. + """ + Reset the global queue timeout value (in seconds) to the previous state. Examples -------- @@ -2530,7 +2572,8 @@ def unset_queue_timeout() -> None: @handle_exceptions def set_tmp_dir(tmp_dr: str) -> None: - """Set the directory for saving temporary files. + """ + Set the directory for saving temporary files. Parameters ---------- @@ -2556,7 +2599,8 @@ def set_tmp_dir(tmp_dr: str) -> None: @handle_exceptions def unset_tmp_dir() -> None: - """Reset the directory for saving temporary files to the previous value. + """ + Reset the directory for saving temporary files to the previous value. Examples -------- @@ -2578,7 +2622,8 @@ def unset_tmp_dir() -> None: @handle_exceptions def container_types(): - """Summary. + """ + Summary. Returns ------- @@ -2595,8 +2640,8 @@ def container_types(): @handle_exceptions def inplace_arrays_supported() -> bool: - """Determine whether inplace arrays are supported for the current backend - framework. + """ + Determine whether inplace arrays are supported for the current backend framework. Returns ------- @@ -2608,8 +2653,8 @@ def inplace_arrays_supported() -> bool: @handle_exceptions def inplace_variables_supported() -> bool: - """Determine whether inplace variables are supported for the current - backend framework. + """ + Determine whether inplace variables are supported for the current backend framework. Returns ------- @@ -2624,7 +2669,8 @@ def inplace_variables_supported() -> bool: @inputs_to_native_arrays @handle_array_function def supports_inplace_updates(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """Return if in-place operations are supported for x's data type. + """ + Return if in-place operations are supported for x's data type. Determine whether in-place operations are supported for x's data type, by the current backend framework setting. @@ -2690,7 +2736,8 @@ def supports_inplace_updates(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: @inputs_to_native_arrays @handle_array_function def assert_supports_inplace(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """Assert that inplace operations are supported for x. + """ + Assert that inplace operations are supported for x. Parameters ---------- @@ -2762,7 +2809,8 @@ def get_item( *, copy: Optional[bool] = None, ) -> ivy.Array: - """Gather slices from x according to query array, identical to x[query]. + """ + Gather slices from x according to query array, identical to x[query]. Parameters ---------- @@ -2831,8 +2879,8 @@ def set_item( *, copy: Optional[bool] = False, ) -> ivy.Array: - """Replace slices of x (defined by query) with val, identical to x[query] = - val. + """ + Replace slices of x (defined by query) with val, identical to x[query] = val. Parameters ---------- @@ -2959,7 +3007,8 @@ def inplace_update( ensure_in_backend: bool = False, keep_input_dtype: bool = False, ) -> ivy.Array: - """Perform in-place update for the input array. + """ + Perform in-place update for the input array. This will always be performed on ivy.Array instances pass in the input, and will also be performed on the native array classes in the backend when the backend @@ -3055,7 +3104,8 @@ def inplace_update( @handle_exceptions def set_inplace_mode(mode: str = "lenient") -> None: - """Set the memory management behavior for in-place updates in Ivy. + """ + Set the memory management behavior for in-place updates in Ivy. By default, Ivy creates new arrays in the backend for in-place updates. However, this behavior can be controlled by the user @@ -3102,8 +3152,9 @@ def set_inplace_mode(mode: str = "lenient") -> None: @handle_exceptions def unset_inplace_mode() -> None: - """Reset the memory management behavior for in-place updates in Ivy to the - previous state. + """ + Reset the memory management behavior for in-place updates in Ivy to the previous + state. Examples -------- @@ -3132,7 +3183,8 @@ def inplace_decrement( x: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """Perform in-place decrement for the input array. + """ + Perform in-place decrement for the input array. Parameters ---------- @@ -3203,7 +3255,8 @@ def inplace_increment( x: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """Perform in-place increment for the input array. + """ + Perform in-place increment for the input array. Parameters ---------- @@ -3267,7 +3320,8 @@ def scatter_flat( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Scatter flat updates into a new flat array according to flat indices. + """ + Scatter flat updates into a new flat array according to flat indices. Parameters ---------- @@ -3356,7 +3410,8 @@ def scatter_nd( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Scatter updates into a new array according to indices. + """ + Scatter updates into a new array according to indices. Parameters ---------- @@ -3462,7 +3517,8 @@ def gather( batch_dims: int = 0, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Gather slices from params at axis according to indices. + """ + Gather slices from params at axis according to indices. Parameters ---------- @@ -3572,7 +3628,8 @@ def gather_nd( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Gather slices from params into a array with shape specified by indices. + """ + Gather slices from params into a array with shape specified by indices. Parameters ---------- @@ -3639,7 +3696,8 @@ def gather_nd( @handle_nestable @handle_array_function def multiprocessing(context: Optional[str] = None): - """Return backend-specific multiprocessing module. + """ + Return backend-specific multiprocessing module. Parameters ---------- @@ -3698,7 +3756,8 @@ def shape( *, as_array: bool = False, ) -> Union[ivy.Shape, ivy.NativeShape]: - """Return the shape of the array ``x``. + """ + Return the shape of the array ``x``. Parameters ---------- @@ -3732,7 +3791,8 @@ def shape( @handle_exceptions def set_shape_array_mode(mode: bool) -> None: - """Set the mode of returning shape as ivy.Array to the given mode instance. + """ + Set the mode of returning shape as ivy.Array to the given mode instance. Parameter --------- @@ -3757,7 +3817,8 @@ def set_shape_array_mode(mode: bool) -> None: @handle_exceptions def unset_shape_array_mode() -> None: - """Reset the mode of returning shape as ivy.Array to the previous state. + """ + Reset the mode of returning shape as ivy.Array to the previous state. Examples -------- @@ -3785,7 +3846,8 @@ def unset_shape_array_mode() -> None: def get_num_dims( x: Union[ivy.Array, ivy.NativeArray], /, *, as_array: bool = False ) -> int: - """Return the number of dimensions of the array x. + """ + Return the number of dimensions of the array x. Parameters ---------- @@ -3833,8 +3895,9 @@ def get_num_dims( @handle_exceptions def arg_info(fn: Callable, *, name: Optional[str] = None, idx: Optional[int] = None): - """Return the index and `inspect.Parameter` representation of the specified - argument. In the form of a dict with keys "idx" and "param". + """ + Return the index and `inspect.Parameter` representation of the specified argument. + In the form of a dict with keys "idx" and "param". Parameters ---------- @@ -4046,10 +4109,11 @@ def _get_devices_and_dtypes(fn, recurse=True, complement=True): @handle_exceptions @handle_nestable def function_supported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> Dict: - """Return the supported combination of devices and dtypes of the current - backend's function. The function returns a dict containing the supported - combination of devices and dtypes of the primary and compositional - implementations in case of partial mixed functions. + """ + Return the supported combination of devices and dtypes of the current backend's + function. The function returns a dict containing the supported combination of + devices and dtypes of the primary and compositional implementations in case of + partial mixed functions. Parameters ---------- @@ -4094,10 +4158,11 @@ def function_supported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> @handle_exceptions @handle_nestable def function_unsupported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> Dict: - """Return the unsupported combination of devices and dtypes of the current - backend's function. The function returns a dict containing the unsupported - combination of devices and dtypes of the primary and compositional - implementations in case of partial mixed functions. + """ + Return the unsupported combination of devices and dtypes of the current backend's + function. The function returns a dict containing the unsupported combination of + devices and dtypes of the primary and compositional implementations in case of + partial mixed functions. Parameters ---------- @@ -4143,7 +4208,8 @@ def vmap( in_axes: Union[int, Sequence[int], Sequence[None]] = 0, out_axes: int = 0, ) -> Callable: - """Vectorizing map. Creates a function which maps func over argument axes. + """ + Vectorizing map. Creates a function which maps func over argument axes. Parameters ---------- @@ -4208,7 +4274,8 @@ def isin( assume_unique: bool = False, invert: bool = False, ) -> ivy.Array: - """Test if each element of elements is in test_elements. + """ + Test if each element of elements is in test_elements. Parameters ---------- @@ -4255,7 +4322,8 @@ def itemsize( x: Union[ivy.Array, ivy.NativeArray], /, ) -> int: - """Return the size of the input array's elements. + """ + Return the size of the input array's elements. Parameters ---------- @@ -4287,7 +4355,8 @@ def strides( x: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple[int]: - """Return the input array's strides across each dimension. + """ + Return the input array's strides across each dimension. Parameters ---------- @@ -4318,7 +4387,8 @@ def strides( def is_ivy_nested_array(x: Any, /) -> bool: - """Determine whether the input x is an Ivy Nested Array. + """ + Determine whether the input x is an Ivy Nested Array. Parameters ---------- diff --git a/ivy/functional/ivy/gradients.py b/ivy/functional/ivy/gradients.py index 8e1a162112909..6740e800462a4 100644 --- a/ivy/functional/ivy/gradients.py +++ b/ivy/functional/ivy/gradients.py @@ -27,8 +27,7 @@ def _get_duplicate_index_chains(xs): - """Generate a list of duplicate index chains for a given nested - structure.""" + """Generate a list of duplicate index chains for a given nested structure.""" duplicate_index_chains = () if isinstance(xs, ivy.Container): duplicate_index_chains = xs.cont_duplicate_array_keychains() @@ -38,8 +37,7 @@ def _get_duplicate_index_chains(xs): def _arrays_to_float_variables(xs, xs_grad_idxs=None): - """Convert all required arrays to float variables for gradient - calculation.""" + """Convert all required arrays to float variables for gradient calculation.""" def inner_fn(x): if ivy.is_array(x, exclusive=True): @@ -105,7 +103,8 @@ def map_fn(x): def _get_required_float_variables(xs, xs_grad_idxs): - """Convert all required arrays to float variables for gradient calculation. + """ + Convert all required arrays to float variables for gradient calculation. Also, returns a list of duplicate index chains for the nested structure. @@ -128,8 +127,7 @@ def _get_required_float_variables(xs, xs_grad_idxs): def _get_native_variables_and_indices(x, reshape=True, idxs=None, create_var=False): - """Extract all relevant results from the output nested structure of a - function.""" + """Extract all relevant results from the output nested structure of a function.""" def map_fn(x_): if ivy.is_array(x_): @@ -169,8 +167,7 @@ def map_fn(x_): def _set_duplicates(xs, duplicate_index_chains): - """Set the duplicates in the nested structure to have the same - reference.""" + """Set the duplicates in the nested structure to have the same reference.""" originals = list( map( lambda key_chains: [key_chains[0]] * (len(key_chains) - 1), @@ -236,7 +233,8 @@ def _stop_grad_and_index(func_ret, retain_grads, grads): def _process_func_ret_and_grads(func_ret, grads, retain_grads): - """Stop gradients propagation. + """ + Stop gradients propagation. Set the gradients of non-finite values to zero, and stopping gradient propagation of the function results. @@ -274,7 +272,8 @@ def _non_finite_to_zero(xs): def _flatten_containers(inputs): - """Flatten containers into a single tuple of arrays. + """ + Flatten containers into a single tuple of arrays. Returns a flattened tuple of arrays and the indices of the arrays in the original containers. @@ -339,7 +338,8 @@ def _is_variable(x, exclusive=False, to_ignore=None) -> bool: def _variable_data( x: Union[ivy.Array, ivy.NativeArray] ) -> Union[ivy.Array, ivy.NativeArray]: - """Get the contents of the input. + """ + Get the contents of the input. Parameters ---------- @@ -373,7 +373,8 @@ def stop_gradient( preserve_type: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Stop gradient computation. + """ + Stop gradient computation. Parameters ---------- @@ -449,9 +450,9 @@ def execute_with_gradients( xs_grad_idxs: Sequence[Sequence[Union[str, int]]] = ((0,),), ret_grad_idxs: Sequence[Sequence[Union[str, int]]] = ((0,),), ) -> Tuple[ivy.Array, ivy.Array]: - """Call function func with input of xs variables, and return the function - result func_ret and the gradients of each output variable w.r.t each input - variable, + """ + Call function func with input of xs variables, and return the function result + func_ret and the gradients of each output variable w.r.t each input variable, Parameters ---------- @@ -527,7 +528,8 @@ def execute_with_gradients( @handle_exceptions def value_and_grad(func: Callable) -> Callable: - """Create a function that evaluates both func and the gradient of func. + """ + Create a function that evaluates both func and the gradient of func. Parameters ---------- @@ -560,7 +562,8 @@ def value_and_grad(func: Callable) -> Callable: @handle_exceptions def jac(func: Callable) -> Callable: - """Call function func, and return func's Jacobian partial derivatives. + """ + Call function func, and return func's Jacobian partial derivatives. Parameters ---------- @@ -593,7 +596,8 @@ def jac(func: Callable) -> Callable: @handle_exceptions def grad(func: Callable, argnums: Union[int, Sequence[int]] = 0) -> Callable: - """Call function func, and return func's gradients. + """ + Call function func, and return func's gradients. Parameters ---------- @@ -643,8 +647,9 @@ def adam_step( epsilon: float = 1e-7, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """Compute adam step delta, given the derivatives of some cost c with - respect to weights ws, using ADAM update. `[reference] + """ + Compute adam step delta, given the derivatives of some cost c with respect to + weights ws, using ADAM update. `[reference] `_ @@ -793,8 +798,9 @@ def optimizer_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Update weights ws of some function, given the true or effective - derivatives of some cost c with respect to ws, [dc/dw for w in ws]. + """ + Update weights ws of some function, given the true or effective derivatives of some + cost c with respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -915,8 +921,9 @@ def gradient_descent_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Update weights ws of some function, given the derivatives of some cost c - with respect to ws, [dc/dw for w in ws]. + """ + Update weights ws of some function, given the derivatives of some cost c with + respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -1008,9 +1015,10 @@ def lars_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Update weights ws of some function, given the derivatives of some cost c - with respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive - Rate Scaling (LARS) method. + """ + Update weights ws of some function, given the derivatives of some cost c with + respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive Rate Scaling + (LARS) method. Parameters ---------- @@ -1112,8 +1120,9 @@ def adam_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """Update weights ws of some function, given the derivatives of some cost c - with respect to ws, using ADAM update. `[reference] + """ + Update weights ws of some function, given the derivatives of some cost c with + respect to ws, using ADAM update. `[reference] `_ @@ -1278,8 +1287,9 @@ def lamb_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """Update weights ws of some function, given the derivatives of some cost c - with respect to ws, [dc/dw for w in ws], by applying LAMB method. + """ + Update weights ws of some function, given the derivatives of some cost c with + respect to ws, [dc/dw for w in ws], by applying LAMB method. Parameters ---------- diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 741aba99eaf5d..cafe906734776 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -44,9 +44,10 @@ def _in_projection( w, b=None, ): - """Projects query, key and value efficiently, depending on whether we are - doing self- attention (query is key is value) or cross-attention (key is - value) or an attention where query, key and value are all different. + """ + Projects query, key and value efficiently, depending on whether we are doing self- + attention (query is key is value) or cross-attention (key is value) or an attention + where query, key and value are all different. it is only used in multi_head_attention layer. @@ -263,7 +264,8 @@ def dropout( noise_shape: Optional[Sequence[int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Randomly setting a fraction of input tensor to zeroes with probability. + """ + Randomly setting a fraction of input tensor to zeroes with probability. `prob` at each update during training time to prevent possible overfitting. The inputs not set to 0 are scaled up `1 / (1 - prob)` by default, so that @@ -447,7 +449,8 @@ def scaled_dot_product_attention( training: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply scaled dot product attention to inputs x using optional mask. + """ + Apply scaled dot product attention to inputs x using optional mask. Parameters ---------- @@ -748,20 +751,20 @@ def multi_head_attention( training: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """Apply multi-head attention to inputs x. This is an implementation of - multi-headed attention as described in the paper "Attention is all you - Need" (Vaswani et al., 2017). If `query`, `key`, `value` are the same, then - this is self-attention. Each timestep in `query` attends to the - corresponding sequence in `key`, and returns a fixed-width vector. This - layer first projects `query`, `key` and `value`. These are (effectively) a - list of tensors of length `num_attention_heads`, where the corresponding - shapes are `(batch_size, , key_dim)`, `(batch_size, + """ + Apply multi-head attention to inputs x. This is an implementation of multi-headed + attention as described in the paper "Attention is all you Need" (Vaswani et al., + 2017). If `query`, `key`, `value` are the same, then this is self-attention. Each + timestep in `query` attends to the corresponding sequence in `key`, and returns a + fixed-width vector. This layer first projects `query`, `key` and `value`. These are + (effectively) a list of tensors of length `num_attention_heads`, where the + corresponding shapes are `(batch_size, , key_dim)`, `(batch_size, , key_dim)`, `(batch_size, , - value_dim)`. Then, the query and key tensors are dot-producted and scaled. - These are softmaxed to obtain attention probabilities. The value tensors - are then interpolated by these probabilities, then concatenated back to a - single tensor. Finally, the result tensor with the last dimension as - value_dim can take a linear projection and return. + value_dim)`. Then, the query and key tensors are dot-producted and scaled. These are + softmaxed to obtain attention probabilities. The value tensors are then interpolated + by these probabilities, then concatenated back to a single tensor. Finally, the + result tensor with the last dimension as value_dim can take a linear projection and + return. Parameters ---------- @@ -1020,7 +1023,8 @@ def conv1d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 1-D convolution given 3-D input x and filters arrays. + """ + Compute a 1-D convolution given 3-D input x and filters arrays. Parameters ---------- @@ -1130,8 +1134,8 @@ def conv1d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 1-D transpose convolution given 3-D input x and filters - arrays. + """ + Compute a 1-D transpose convolution given 3-D input x and filters arrays. Parameters ---------- @@ -1280,7 +1284,8 @@ def conv2d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 2-D convolution given 4-D input x and filters arrays. + """ + Compute a 2-D convolution given 4-D input x and filters arrays. Parameters ---------- @@ -1420,8 +1425,8 @@ def conv2d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 2-D transpose convolution given 4-D input x and filters - arrays. + """ + Compute a 2-D transpose convolution given 4-D input x and filters arrays. Parameters ---------- @@ -1557,8 +1562,8 @@ def depthwise_conv2d( dilations: Union[int, Tuple[int, int]] = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 2-D depthwise convolution given 4-D input ``x`` and filters - arrays. + """ + Compute a 2-D depthwise convolution given 4-D input ``x`` and filters arrays. Parameters ---------- @@ -1699,7 +1704,8 @@ def conv3d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 3-D convolution given 5-D input x and filters arrays. + """ + Compute a 3-D convolution given 5-D input x and filters arrays. Parameters ---------- @@ -1820,8 +1826,8 @@ def conv3d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 3-D transpose convolution given 5-D input x and filters - arrays. + """ + Compute a 3-D transpose convolution given 5-D input x and filters arrays. Parameters ---------- @@ -1964,8 +1970,9 @@ def conv_general_dilated( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 1-D, 2-D, and 3-D convolution given 3-D, 4-D and 5-D input x - respectively and filters arrays. + """ + Compute a 1-D, 2-D, and 3-D convolution given 3-D, 4-D and 5-D input x respectively + and filters arrays. Parameters ---------- @@ -2048,8 +2055,9 @@ def conv_general_transpose( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 1-D, 2-D, and 3-D transpose convolution given 3-D, 4-D and 5-D - input x respectively and filters arrays. + """ + Compute a 1-D, 2-D, and 3-D transpose convolution given 3-D, 4-D and 5-D input x + respectively and filters arrays. Parameters ---------- @@ -2189,8 +2197,9 @@ def conv( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute a 1-D, 2-D, and 3-D transpose or dilated convolution given 3-D, - 4-D and 5-D input x respectively and filters arrays. + """ + Compute a 1-D, 2-D, and 3-D transpose or dilated convolution given 3-D, 4-D and 5-D + input x respectively and filters arrays. Parameters ---------- @@ -2288,8 +2297,8 @@ def lstm_update( recurrent_bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, time_major: bool = False, ) -> Tuple[ivy.Array, Tuple[ivy.Array, ivy.Array]]: - """Perform long-short term memory update by unrolling time dimension of - input array. + """ + Perform long-short term memory update by unrolling time dimension of input array. Parameters ---------- @@ -2530,7 +2539,8 @@ def _get_x_data_format(dims: int = 2, data_format: str = "channel_first"): def _get_num_padded_values(i, p, n, k, s): - """Get number of padded values in a specific window. + """ + Get number of padded values in a specific window. Parameters ---------- diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index 8831c28b7b64a..bd3c643f7e763 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -39,7 +39,8 @@ def cholesky( upper: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the cholesky decomposition of the x matrix. + """ + Compute the cholesky decomposition of the x matrix. Parameters ---------- @@ -182,7 +183,8 @@ def cross( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return cross product of 3-element vectors. + """ + Return cross product of 3-element vectors. If x1 and x2 are multi- dimensional arrays (i.e., both have a rank greater than 1), then the cross- product of each pair of corresponding 3-element vectors is @@ -281,8 +283,8 @@ def cross( def det( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """Return the determinant of a square matrix (or a stack of square - matrices)``x``. + """ + Return the determinant of a square matrix (or a stack of square matrices)``x``. Parameters ---------- @@ -361,8 +363,8 @@ def diagonal( axis2: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the specified diagonals of a matrix (or a stack of matrices) - ``x``. + """ + Return the specified diagonals of a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -538,9 +540,10 @@ def eig( *, out: Optional[ivy.Array] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray]]: - """Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack - of symmetric matrices) ``x``, where ``Q`` is an orthogonal matrix (or a - stack of matrices) and ``L`` is a vector (or a stack of vectors). + """ + Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack of symmetric + matrices) ``x``, where ``Q`` is an orthogonal matrix (or a stack of matrices) and + ``L`` is a vector (or a stack of vectors). .. note:: The function ``eig`` currently behaves like ``eigh``, as @@ -591,9 +594,10 @@ def eigh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray]]: - r"""Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack - of symmetric matrices) ``x``, where ``Q`` is an orthogonal matrix (or a - stack of matrices) and ``L`` is a vector (or a stack of vectors). + r""" + Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack of symmetric + matrices) ``x``, where ``Q`` is an orthogonal matrix (or a stack of matrices) and + ``L`` is a vector (or a stack of vectors). .. note:: The function ``eig`` will be added in a future version of the specification, as @@ -703,8 +707,8 @@ def eigvalsh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the eigenvalues of a symmetric matrix (or a stack of symmetric - matrices) x. + """ + Return the eigenvalues of a symmetric matrix (or a stack of symmetric matrices) x. .. note:: The function ``eig`` will be added in a future version of the specification, as @@ -811,7 +815,8 @@ def inner( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the inner product of two vectors ``x1`` and ``x2``. + """ + Return the inner product of two vectors ``x1`` and ``x2``. Parameters ---------- @@ -889,8 +894,9 @@ def inv( adjoint: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the multiplicative inverse of a square matrix (or a stack of - square matrices) ``x``. + """ + Return the multiplicative inverse of a square matrix (or a stack of square matrices) + ``x``. Parameters ---------- @@ -986,7 +992,8 @@ def matmul( adjoint_b: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the matrix product. + """ + Compute the matrix product. Parameters ---------- @@ -1146,7 +1153,8 @@ def matrix_norm( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the matrix p-norm. + """ + Compute the matrix p-norm. Parameters ---------- @@ -1301,8 +1309,8 @@ def matrix_norm( def matrix_power( x: Union[ivy.Array, ivy.NativeArray], n: int, /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """Raise a square matrix (or a stack of square matrices) x to an integer - power n. + """ + Raise a square matrix (or a stack of square matrices) x to an integer power n. Parameters ---------- @@ -1408,8 +1416,9 @@ def matrix_rank( hermitian: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the rank (i.e., number of non-zero singular values) of a matrix - (or a stack of matrices). + """ + Return the rank (i.e., number of non-zero singular values) of a matrix (or a stack + of matrices). Parameters ---------- @@ -1521,7 +1530,8 @@ def matrix_transpose( conjugate: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Transposes a matrix (or a stack of matrices) ``x``. + """ + Transposes a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1610,7 +1620,8 @@ def outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the outer product of two vectors ``x1`` and ``x2``. + """ + Return the outer product of two vectors ``x1`` and ``x2``. Parameters ---------- @@ -1700,8 +1711,9 @@ def pinv( rtol: Optional[Union[float, Tuple[float]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the (Moore-Penrose) pseudo-inverse of a matrix (or a stack of - matrices) ``x``. + """ + Return the (Moore-Penrose) pseudo-inverse of a matrix (or a stack of matrices) + ``x``. Parameters ---------- @@ -1775,9 +1787,10 @@ def qr( mode: str = "reduced", out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """Return the qr decomposition x = QR of a full column rank matrix (or a - stack of matrices), where Q is an orthonormal matrix (or a stack of - matrices) and R is an upper-triangular matrix (or a stack of matrices). + """ + Return the qr decomposition x = QR of a full column rank matrix (or a stack of + matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an + upper-triangular matrix (or a stack of matrices). Parameters ---------- @@ -1995,8 +2008,9 @@ def solve( adjoint: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the solution x to the system of linear equations represented by - the well- determined (i.e., full rank) linear matrix equation Ax = B. + """ + Return the solution x to the system of linear equations represented by the well- + determined (i.e., full rank) linear matrix equation Ax = B. Parameters ---------- @@ -2124,11 +2138,11 @@ def svd( compute_uv: bool = True, full_matrices: bool = True, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """Return a singular value decomposition A = USVh of a matrix (or a stack - of matrices) ``x``, where ``U`` is a matrix (or a stack of matrices) with - orthonormal columns, ``S`` is a vector of non-negative numbers (or stack of - vectors), and ``Vh`` is a matrix (or a stack of matrices) with orthonormal - rows. + """ + Return a singular value decomposition A = USVh of a matrix (or a stack of matrices) + ``x``, where ``U`` is a matrix (or a stack of matrices) with orthonormal columns, + ``S`` is a vector of non-negative numbers (or stack of vectors), and ``Vh`` is a + matrix (or a stack of matrices) with orthonormal rows. Parameters ---------- @@ -2256,7 +2270,8 @@ def svdvals( driver: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the singular values of a matrix (or a stack of matrices) ``x``. + """ + Return the singular values of a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -2398,7 +2413,8 @@ def tensordot( axes: Union[int, Tuple[List[int], List[int]]] = 2, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a tensor contraction of x1 and x2 over specific axes. + """ + Return a tensor contraction of x1 and x2 over specific axes. .. note:: If either ``x1`` or ``x2`` has a complex floating-point data type, neither @@ -2498,8 +2514,9 @@ def trace( axis2: int = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the sum along the specified diagonals of a matrix (or a stack of - matrices) ``x``. + """ + Return the sum along the specified diagonals of a matrix (or a stack of matrices) + ``x``. **Special cases** @@ -2682,7 +2699,8 @@ def vecdot( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the (vector) dot product of two arrays. + """ + Compute the (vector) dot product of two arrays. Parameters ---------- @@ -2780,7 +2798,8 @@ def vector_norm( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r"""Compute the vector norm of a vector (or batch of vectors) ``x``. + r""" + Compute the vector norm of a vector (or batch of vectors) ``x``. Parameters ---------- @@ -2925,8 +2944,9 @@ def diag( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the specified diagonals of the input array, or an array with the - input array's elements as diagonals. + """ + Return the specified diagonals of the input array, or an array with the input + array's elements as diagonals. Parameters ---------- @@ -3009,11 +3029,11 @@ def vander( increasing: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Generate a Vandermonde matrix. The columns of the output matrix are - elementwise powers of the input vector x^{(N-1)}, x^{(N-2)}, ..., x^0x. If - increasing is True, the order of the columns is reversed x^0, x^1, ..., - x^{(N-1)}. Such a matrix with a geometric progression in each row is named - for Alexandre-Theophile Vandermonde. + """ + Generate a Vandermonde matrix. The columns of the output matrix are elementwise + powers of the input vector x^{(N-1)}, x^{(N-2)}, ..., x^0x. If increasing is True, + the order of the columns is reversed x^0, x^1, ..., x^{(N-1)}. Such a matrix with a + geometric progression in each row is named for Alexandre-Theophile Vandermonde. Parameters ---------- diff --git a/ivy/functional/ivy/losses.py b/ivy/functional/ivy/losses.py index 8310df572f06c..bd9cd0c77c5be 100644 --- a/ivy/functional/ivy/losses.py +++ b/ivy/functional/ivy/losses.py @@ -44,7 +44,8 @@ def cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute cross-entropy between predicted and true discrete distributions. + """ + Compute cross-entropy between predicted and true discrete distributions. Parameters ---------- @@ -101,7 +102,8 @@ def binary_cross_entropy( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute the binary cross entropy loss. + """ + Compute the binary cross entropy loss. Parameters ---------- @@ -279,7 +281,8 @@ def sparse_cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Compute sparse cross entropy between logits and labels. + """ + Compute sparse cross entropy between logits and labels. Parameters ---------- diff --git a/ivy/functional/ivy/manipulation.py b/ivy/functional/ivy/manipulation.py index a039a9159e3a0..318c663b739b7 100644 --- a/ivy/functional/ivy/manipulation.py +++ b/ivy/functional/ivy/manipulation.py @@ -54,7 +54,8 @@ def concat( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Join a sequence of arrays along an existing axis. + """ + Join a sequence of arrays along an existing axis. Parameters ---------- @@ -113,8 +114,9 @@ def expand_dims( axis: Union[int, Sequence[int]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Expand the shape of an array by inserting a new axis (dimension) of size - one at the position specified by axis. + """ + Expand the shape of an array by inserting a new axis (dimension) of size one at the + position specified by axis. Parameters ---------- @@ -250,8 +252,9 @@ def flip( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Reverses the order of elements in an array along the given axis. The - shape of the array must be preserved. + """ + Reverses the order of elements in an array along the given axis. The shape of the + array must be preserved. Parameters ---------- @@ -344,7 +347,8 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Permutes the axes (dimensions) of an array x. + """ + Permutes the axes (dimensions) of an array x. Parameters ---------- @@ -446,7 +450,8 @@ def reshape( allowzero: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Give a new shape to an array without changing its data. + """ + Give a new shape to an array without changing its data. Parameters ---------- @@ -569,10 +574,10 @@ def roll( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, ivy.Container]: - """Roll array elements along a specified axis. Array elements that roll - beyond the last position are re-introduced at the first position. Array - elements that roll beyond the first position are re-introduced at the last - position. + """ + Roll array elements along a specified axis. Array elements that roll beyond the last + position are re-introduced at the first position. Array elements that roll beyond + the first position are re-introduced at the last position. Parameters ---------- @@ -683,7 +688,8 @@ def squeeze( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Remove singleton dimensions (axes) from x. + """ + Remove singleton dimensions (axes) from x. Parameters ---------- @@ -775,7 +781,8 @@ def stack( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Join a sequence of arrays along a new axis. + """ + Join a sequence of arrays along a new axis. Parameters ---------- @@ -862,7 +869,8 @@ def clip( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Clips (limits) the values in an array. + """ + Clips (limits) the values in an array. Given an interval, values outside the interval are clipped to the interval edges (element-wise). For example, if an interval of [0, 1] is specified, values smaller @@ -989,7 +997,8 @@ def constant_pad( value: Number = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Pad an array with a constant value. + """ + Pad an array with a constant value. Parameters ---------- @@ -1085,7 +1094,8 @@ def repeat( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Repeat values along a given dimension. + """ + Repeat values along a given dimension. Parameters ---------- @@ -1160,7 +1170,8 @@ def split( axis: int = 0, with_remainder: bool = False, ) -> List[ivy.Array]: - """Split an array into multiple sub-arrays. + """ + Split an array into multiple sub-arrays. Parameters ---------- @@ -1245,7 +1256,8 @@ def swapaxes( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Interchange two axes of an array. + """ + Interchange two axes of an array. Parameters ---------- @@ -1352,7 +1364,8 @@ def tile( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Construct an array by repeating x the number of times given by reps. + """ + Construct an array by repeating x the number of times given by reps. Parameters ---------- @@ -1434,7 +1447,8 @@ def unstack( axis: int = 0, keepdims: bool = False, ) -> List[ivy.Array]: - """Unpacks the given dimension of a rank-R array into rank-(R-1) arrays. + """ + Unpacks the given dimension of a rank-R array into rank-(R-1) arrays. Parameters ---------- @@ -1528,7 +1542,8 @@ def zero_pad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Pad an array with zeros. + """ + Pad an array with zeros. Parameters ---------- diff --git a/ivy/functional/ivy/meta.py b/ivy/functional/ivy/meta.py index 5b3151c9accc6..7ba70923ae8e6 100644 --- a/ivy/functional/ivy/meta.py +++ b/ivy/functional/ivy/meta.py @@ -26,7 +26,8 @@ def _compute_cost_and_update_grads( batched, num_tasks, ): - """Compute cost and update gradients. + """ + Compute cost and update gradients. This function computes the cost and updates gradients for optimization. @@ -473,7 +474,8 @@ def fomaml_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """Perform step of first order MAML. + """ + Perform step of first order MAML. Parameters ---------- @@ -588,7 +590,8 @@ def reptile_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """Perform a step of Reptile. + """ + Perform a step of Reptile. Parameters ---------- @@ -737,7 +740,8 @@ def maml_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """Perform step of vanilla second order MAML. + """ + Perform step of vanilla second order MAML. Parameters ---------- diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index e0e97a718cda6..a44b3e20dcb80 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -20,8 +20,8 @@ def index_nest( index: Union[List[int], Tuple[int], Iterable[int]], /, ) -> Any: - """Index a nested object, using a tuple of indices or keys in the case of - dicts. + """ + Index a nested object, using a tuple of indices or keys in the case of dicts. Parameters ---------- @@ -92,7 +92,8 @@ def index_nest( @handle_exceptions def prune_nest_at_index(nest: Iterable, index: Tuple, /) -> None: - """Prune a nested object at a specified index. + """ + Prune a nested object at a specified index. Parameters ---------- @@ -116,7 +117,8 @@ def set_nest_at_index( shallow: bool = True, _result: Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """Set the value of a nested item at a specified index. + """ + Set the value of a nested item at a specified index. Parameters ---------- @@ -215,8 +217,8 @@ def set_nest_at_index( @handle_exceptions def insert_into_nest_at_index(nest: Iterable, index: Tuple, value) -> None: - """Recursively inserts a value into a nested data structure at a specified - index. + """ + Recursively inserts a value into a nested data structure at a specified index. This function traverses a nested data structure and inserts the provided `value` at the specified `index`. @@ -275,7 +277,8 @@ def map_nest_at_index( shallow: bool = True, _result: Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """Map a function to the value of a nested item at a specified index. + """ + Map a function to the value of a nested item at a specified index. Parameters ---------- @@ -379,8 +382,9 @@ def multi_index_nest( indices: Iterable[Iterable[int]], /, ) -> Iterable[Any]: - """Repeatedly index a nested object, using a tuple of tuples of indices or - keys in the case of dicts. + """ + Repeatedly index a nested object, using a tuple of tuples of indices or keys in the + case of dicts. Parameters ---------- @@ -445,7 +449,8 @@ def multi_index_nest( @handle_exceptions def prune_nest_at_indices(nest: Iterable, indices: Tuple, /) -> None: - """Prune a nested object at specified indices. + """ + Prune a nested object at specified indices. Parameters ---------- @@ -471,8 +476,8 @@ def set_nest_at_indices( /, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """Set the value of a nested item at specified indices with specified - values. + """ + Set the value of a nested item at specified indices with specified values. Parameters ---------- @@ -549,8 +554,8 @@ def set_nest_at_indices( @handle_exceptions def insert_into_nest_at_indices(nest: Iterable, indices: Tuple, values, /) -> None: - """Insert a value into the nested item at specified indices with specified - values. + """ + Insert a value into the nested item at specified indices with specified values. Parameters ---------- @@ -578,7 +583,8 @@ def map_nest_at_indices( /, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """Map a function to the values of a nested item at the specified indices. + """ + Map a function to the values of a nested item at the specified indices. Parameters ---------- @@ -662,8 +668,9 @@ def nested_argwhere( _base: bool = True, stop_after_n_found: Optional[int] = None, ) -> Union[Iterable, bool]: - """Check the leaf nodes of nested x via function fn, and returns all nest - indices where the method evaluates as True. + """ + Check the leaf nodes of nested x via function fn, and returns all nest indices where + the method evaluates as True. Parameters ---------- @@ -813,7 +820,8 @@ def all_nested_indices( _index: Optional[Union[int, Sequence[int]]] = None, _base: bool = True, ) -> List: - """Return indices of all the elements in nest. + """ + Return indices of all the elements in nest. Parameters ---------- @@ -908,7 +916,8 @@ def map( unique: Optional[Dict[str, Iterable[Any]]] = None, mean: bool = False, ) -> List: - """Apply a function on each item of an iterable x. + """ + Apply a function on each item of an iterable x. Parameters ---------- @@ -1018,9 +1027,10 @@ def nested_map( _dict_check_fn: Optional[Callable] = None, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, Iterable, Dict]: - """Apply a function on x in a nested manner, whereby all dicts, lists and - tuples are traversed to their lowest leaves before applying the method and - returning x. If x is not nested, the method is applied to x directly. + """ + Apply a function on x in a nested manner, whereby all dicts, lists and tuples are + traversed to their lowest leaves before applying the method and returning x. If x is + not nested, the method is applied to x directly. Parameters ---------- @@ -1232,8 +1242,9 @@ def nested_any( check_nests: bool = False, _base: bool = True, ) -> bool: - """Check the leaf nodes of nest x via function fn, and returns True if any - evaluate to True, else False. + """ + Check the leaf nodes of nest x via function fn, and returns True if any evaluate to + True, else False. Parameters ---------- @@ -1277,8 +1288,9 @@ def copy_nest( include_derived: bool = False, to_mutable: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """Copy a nest deeply, but without copying leaves of the nest, only the - nest lists, tuples and dicts are copied. + """ + Copy a nest deeply, but without copying leaves of the nest, only the nest lists, + tuples and dicts are copied. Parameters ---------- @@ -1379,8 +1391,9 @@ def nested_multi_map( config=None, to_ivy=True, ): - """Apply function to all array values from a collection of identically - structured ivy arrays. + """ + Apply function to all array values from a collection of identically structured ivy + arrays. Parameters ---------- @@ -1528,9 +1541,10 @@ def _found_in_index_chains(this_index_chain, index_chains): @handle_exceptions def duplicate_array_index_chains(nest: Union[ivy.Array, ivy.NativeArray, Iterable]): - """Group all unique index chains in a nest. This function is useful for - finding all unique index chains in a nest, and then duplicating the values - at those index chains for functional frameworks. + """ + Group all unique index chains in a nest. This function is useful for finding all + unique index chains in a nest, and then duplicating the values at those index chains + for functional frameworks. Parameters ---------- @@ -1558,7 +1572,8 @@ def duplicate_array_index_chains(nest: Union[ivy.Array, ivy.NativeArray, Iterabl def prune_empty(nest): - """Prune empty nests from a nest. + """ + Prune empty nests from a nest. Parameters ---------- diff --git a/ivy/functional/ivy/norms.py b/ivy/functional/ivy/norms.py index 8812b94cc8a00..0af316281855b 100644 --- a/ivy/functional/ivy/norms.py +++ b/ivy/functional/ivy/norms.py @@ -32,7 +32,8 @@ def layer_norm( new_std: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Apply Layer Normalization over a mini-batch of inputs. + """ + Apply Layer Normalization over a mini-batch of inputs. Parameters ---------- diff --git a/ivy/functional/ivy/random.py b/ivy/functional/ivy/random.py index ca9510b0a0179..23949e11ba77a 100644 --- a/ivy/functional/ivy/random.py +++ b/ivy/functional/ivy/random.py @@ -106,10 +106,11 @@ def random_uniform( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Draws samples from a uniform distribution. Samples are uniformly - distributed over the half-open interval ``[low, high)`` (includes ``low``, - but excludes ``high``). In other words, any value within the given interval - is equally likely to be drawn by uniform. + """ + Draws samples from a uniform distribution. Samples are uniformly distributed over + the half-open interval ``[low, high)`` (includes ``low``, but excludes ``high``). In + other words, any value within the given interval is equally likely to be drawn by + uniform. Parameters ---------- @@ -221,7 +222,8 @@ def random_normal( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Draws samples from a normal distribution. + """ + Draws samples from a normal distribution. Parameters ---------- @@ -332,10 +334,10 @@ def multinomial( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Draws samples from a multinomial distribution. Specifically, returns a - tensor where each row contains num_samples indices sampled from the - multinomial probability distribution located in the corresponding row of - tensor input. + """ + Draws samples from a multinomial distribution. Specifically, returns a tensor where + each row contains num_samples indices sampled from the multinomial probability + distribution located in the corresponding row of tensor input. Parameters ---------- @@ -442,8 +444,9 @@ def randint( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return an array filled with random integers generated uniformly between - low (inclusive) and high (exclusive). + """ + Return an array filled with random integers generated uniformly between low + (inclusive) and high (exclusive). Parameters ---------- @@ -505,7 +508,8 @@ def randint( @handle_exceptions @handle_nestable def seed(*, seed_value: int = 0) -> None: - """Set the seed for random number generation. + """ + Set the seed for random number generation. Parameters ---------- @@ -535,7 +539,8 @@ def shuffle( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Shuffles the given array along a given axis. + """ + Shuffles the given array along a given axis. Parameters ---------- diff --git a/ivy/functional/ivy/searching.py b/ivy/functional/ivy/searching.py index 0faf2e0efd258..ae440f221d0d8 100644 --- a/ivy/functional/ivy/searching.py +++ b/ivy/functional/ivy/searching.py @@ -39,9 +39,10 @@ def argmax( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the indices of the maximum values along a specified axis. When - the maximum value occurs multiple times, only the indices corresponding to - the first occurrence are returned. + """ + Return the indices of the maximum values along a specified axis. When the maximum + value occurs multiple times, only the indices corresponding to the first occurrence + are returned. Parameters ---------- @@ -155,9 +156,10 @@ def argmin( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the indices of the minimum values along a specified axis. When - the minimum value occurs multiple times, only the indices corresponding to - the first occurrence are returned. + """ + Return the indices of the minimum values along a specified axis. When the minimum + value occurs multiple times, only the indices corresponding to the first occurrence + are returned. Parameters ---------- @@ -262,7 +264,8 @@ def nonzero( size: Optional[int] = None, fill_value: Number = 0, ) -> Union[Tuple[ivy.Array], ivy.Array]: - """Return the indices of the array elements which are non-zero. + """ + Return the indices of the array elements which are non-zero. .. note:: If ``x`` has a complex floating-point data type, non-zero elements @@ -398,7 +401,8 @@ def where( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return elements chosen from x or y depending on condition. + """ + Return elements chosen from x or y depending on condition. Parameters ---------- @@ -481,7 +485,8 @@ def argwhere( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the indices of all non-zero elements of the input array. + """ + Return the indices of all non-zero elements of the input array. Parameters ---------- diff --git a/ivy/functional/ivy/set.py b/ivy/functional/ivy/set.py index 10ae870d1b89a..0c0d916b24cc4 100644 --- a/ivy/functional/ivy/set.py +++ b/ivy/functional/ivy/set.py @@ -38,10 +38,10 @@ def unique_all( Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray], ]: - """Return the unique elements of an input array ``x``, the first occurring - indices for each unique element in ``x``, the indices from the set of - unique elements that reconstruct ``x``, and the corresponding counts for - each unique element in ``x``. + """ + Return the unique elements of an input array ``x``, the first occurring indices for + each unique element in ``x``, the indices from the set of unique elements that + reconstruct ``x``, and the corresponding counts for each unique element in ``x``. .. admonition:: Data-dependent output shape :class: important @@ -161,8 +161,9 @@ def unique_inverse( *, axis: Optional[int] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray]]: - """Return the unique elements of an input array ``x``, and the indices from - the set of unique elements that reconstruct ``x``. + """ + Return the unique elements of an input array ``x``, and the indices from the set of + unique elements that reconstruct ``x``. .. admonition:: Data-dependent output shape :class: important @@ -275,7 +276,8 @@ def unique_values( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the unique elements of an input array ``x``. + """ + Return the unique elements of an input array ``x``. .. admonition:: Data-dependent output shape :class: important @@ -365,8 +367,9 @@ def unique_counts( x: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple[Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray]]: - """Return the unique elements of an input array ``x`` and the corresponding - counts for each unique element in ``x``. + """ + Return the unique elements of an input array ``x`` and the corresponding counts for + each unique element in ``x``. .. admonition:: Data-dependent output shape :class: important diff --git a/ivy/functional/ivy/sorting.py b/ivy/functional/ivy/sorting.py index 7e3e7daaac313..fe073103f1541 100644 --- a/ivy/functional/ivy/sorting.py +++ b/ivy/functional/ivy/sorting.py @@ -36,7 +36,8 @@ def argsort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the indices that sort an array ``x`` along a specified axis. + """ + Return the indices that sort an array ``x`` along a specified axis. Parameters ---------- @@ -156,7 +157,8 @@ def sort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a sorted copy of an array. + """ + Return a sorted copy of an array. Parameters ---------- @@ -257,7 +259,8 @@ def msort( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return a copy of an array sorted along the first axis. + """ + Return a copy of an array sorted along the first axis. Parameters ---------- @@ -305,7 +308,8 @@ def searchsorted( ret_dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the indices of the inserted elements in a sorted array. + """ + Return the indices of the inserted elements in a sorted array. Parameters ---------- diff --git a/ivy/functional/ivy/statistical.py b/ivy/functional/ivy/statistical.py index e6d80c8809c49..2b8321c71682d 100644 --- a/ivy/functional/ivy/statistical.py +++ b/ivy/functional/ivy/statistical.py @@ -52,7 +52,8 @@ def min( where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the minimum value of the input array ``x``. + """ + Calculate the minimum value of the input array ``x``. .. note:: When the number of elements over which to compute the minimum value is zero, the @@ -167,7 +168,8 @@ def max( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the maximum value of the input array ``x``. + """ + Calculate the maximum value of the input array ``x``. .. note:: When the number of elements over which to compute the maximum value is zero, the @@ -277,7 +279,8 @@ def mean( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the arithmetic mean of the input array ``x``. + """ + Calculate the arithmetic mean of the input array ``x``. **Special Cases** @@ -389,7 +392,8 @@ def prod( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the product of input array x elements. + """ + Calculate the product of input array x elements. **Special Cases** @@ -524,7 +528,8 @@ def std( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the standard deviation of the input array ``x``. + """ + Calculate the standard deviation of the input array ``x``. **Special Cases** @@ -662,7 +667,8 @@ def sum( keepdims: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the sum of the input array x. + """ + Calculate the sum of the input array x. **Special Cases** @@ -802,7 +808,8 @@ def var( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Calculate the variance of the input array x. + """ + Calculate the variance of the input array x. **Special Cases** @@ -918,7 +925,8 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the cumulative sum of the elements along a given axis. + """ + Return the cumulative sum of the elements along a given axis. Parameters ---------- @@ -1063,7 +1071,8 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Return the cumulative product of the elements along a given axis. + """ + Return the cumulative product of the elements along a given axis. Parameters ---------- @@ -1195,8 +1204,9 @@ def einsum( *operands: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Sum the product of the elements of the input operands along dimensions - specified using a notation based on the Einstein summation convention. + """ + Sum the product of the elements of the input operands along dimensions specified + using a notation based on the Einstein summation convention. Parameters ---------- diff --git a/ivy/functional/ivy/utility.py b/ivy/functional/ivy/utility.py index d323e0f91cda5..09bd432b60291 100644 --- a/ivy/functional/ivy/utility.py +++ b/ivy/functional/ivy/utility.py @@ -33,8 +33,8 @@ def all( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Test whether all input array elements evaluate to ``True`` along a - specified axis. + """ + Test whether all input array elements evaluate to ``True`` along a specified axis. .. note:: Positive infinity, negative infinity, and NaN must evaluate to ``True``. @@ -147,8 +147,8 @@ def any( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """Test whether any input array element evaluates to ``True`` along a - specified axis. + """ + Test whether any input array element evaluates to ``True`` along a specified axis. .. note:: Positive infinity, negative infinity, and NaN must evaluate to ``True``. diff --git a/ivy/stateful/activations.py b/ivy/stateful/activations.py index 65d158af4b6cc..ae3991c099122 100644 --- a/ivy/stateful/activations.py +++ b/ivy/stateful/activations.py @@ -13,7 +13,8 @@ def __init__( approximate: bool = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """Apply the GELU activation function. + """ + Apply the GELU activation function. Parameters ---------- @@ -28,7 +29,8 @@ def __init__( Module.__init__(self) def _forward(self, x): - """Perform forward pass of the GELU activation. + """ + Perform forward pass of the GELU activation. Parameters ---------- @@ -56,7 +58,8 @@ def __init__(self): Module.__init__(self) def _forward(self, inputs): - """Perform forward pass of the GEGLU activation. + """ + Perform forward pass of the GEGLU activation. Parameters ---------- @@ -77,7 +80,8 @@ def __init__( self, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """Apply the RELU activation function. + """ + Apply the RELU activation function. Parameters ---------- @@ -113,7 +117,8 @@ def __init__( alpha: float = 0.2, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """Apply the LEAKY RELU activation function. + """ + Apply the LEAKY RELU activation function. Parameters ---------- @@ -156,7 +161,8 @@ def __init__( axis: Optional[int] = -1, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """Apply the LOG SOFTMAX activation function. + """ + Apply the LOG SOFTMAX activation function. Parameters ---------- @@ -195,7 +201,8 @@ def __init__( axis: int = -1, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """Apply the SOFTMAX activation function. + """ + Apply the SOFTMAX activation function. Parameters ---------- @@ -307,7 +314,8 @@ def _forward(self, x): class Sigmoid(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """Apply the SIGMOID activation function. + """ + Apply the SIGMOID activation function. Parameter ---------- @@ -339,7 +347,8 @@ def _extra_repr(self) -> str: class Tanh(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """Apply the TANH activation function. + """ + Apply the TANH activation function. Parameters ---------- @@ -371,7 +380,8 @@ def _extra_repr(self) -> str: class ReLU6(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """Apply the TANH activation function. + """ + Apply the TANH activation function. Parameters ---------- @@ -403,7 +413,8 @@ def _extra_repr(self) -> str: class Hardswish(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """Apply the HARDSWISH activation function. + """ + Apply the HARDSWISH activation function. Parameters ---------- @@ -439,7 +450,8 @@ def __init__( eps=None, complex_mode="jax", ): - """Apply the LOGIT activation function. + """ + Apply the LOGIT activation function. Parameters ---------- @@ -552,7 +564,8 @@ def _extra_repr(self) -> str: class LogSigmoid(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """Apply the LogSigmoid activation function. + """ + Apply the LogSigmoid activation function. Parameter ---------- diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index 834096133f581..1f91646840b5f 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -21,8 +21,9 @@ def to_ivy_module( devices=None, inplace_update=False, ): - """Convert an instance of a trainable module from a native framework into a - trainable ivy.Module instance. + """ + Convert an instance of a trainable module from a native framework into a trainable + ivy.Module instance. Parameters ---------- @@ -75,7 +76,8 @@ def from_haiku_module( device=None, devices=None, ): - """Convert a Haiku module instance to an Ivy module instance. + """ + Convert a Haiku module instance to an Ivy module instance. Parameters ---------- @@ -168,7 +170,8 @@ def from_flax_module( device=None, devices=None, ): - """Convert a Flax module instance to an Ivy module instance. + """ + Convert a Flax module instance to an Ivy module instance. Parameters ---------- @@ -257,7 +260,8 @@ def from_keras_module( device=None, devices=None, ): - """Convert a Keras module instance to an Ivy module instance. + """ + Convert a Keras module instance to an Ivy module instance. Parameters ---------- @@ -319,7 +323,8 @@ def from_paddle_module( device=None, devices=None, ): - """Convert a Paddle layer instance to an Ivy module instance. + """ + Convert a Paddle layer instance to an Ivy module instance. Parameters ---------- @@ -375,7 +380,8 @@ def from_torch_module( devices=None, inplace_update=False, ): - """Convert a Torch module instance to an Ivy module instance. + """ + Convert a Torch module instance to an Ivy module instance. Parameters ---------- @@ -434,8 +440,8 @@ def from_torch_module( ) def to_keras_module(self): - """Convert a `ivy.Module` module instance to a `tf.keras.Model` - instance. + """ + Convert a `ivy.Module` module instance to a `tf.keras.Model` instance. Returns ------- diff --git a/ivy/stateful/helpers.py b/ivy/stateful/helpers.py index c62ea0bea79f1..675b30a70c496 100644 --- a/ivy/stateful/helpers.py +++ b/ivy/stateful/helpers.py @@ -19,8 +19,8 @@ def _find_variables( without_initialisation=False, _visited=None, ): - """Find all internal variables in obj. Return empty Container if obj is - None. + """ + Find all internal variables in obj. Return empty Container if obj is None. Parameters ---------- @@ -100,10 +100,10 @@ def _build_and_return_v(self, *args, **kwargs): @staticmethod def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): - """Extract the variables from the variables container v using the key - orig_key_chain and reinstantiate the duplicate variables that were - removed by _remove_duplicate_variables in their correct locations using - keychain_mappings. + """ + Extract the variables from the variables container v using the key + orig_key_chain and reinstantiate the duplicate variables that were removed by + _remove_duplicate_variables in their correct locations using keychain_mappings. Parameters ---------- @@ -137,7 +137,8 @@ def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): @staticmethod def _remove_duplicate_variables(vs, created, /): - """Remove duplicate variables in `vs` referring to `created`. + """ + Remove duplicate variables in `vs` referring to `created`. Parameters ---------- @@ -181,9 +182,10 @@ def found_dup_callback(x, kc): def _wrap_call_methods( self, keychain_mappings, /, *, key="", obj=None, _visited=None ): - """Wrap the call methods of the Module object by looping over all the - items within the module, wrapping the __call__ methods of all - submodules using _fn_with_var_arg. + """ + Wrap the call methods of the Module object by looping over all the items within + the module, wrapping the __call__ methods of all submodules using + _fn_with_var_arg. Parameters ---------- @@ -240,8 +242,8 @@ def _wrap_call_methods( return def _call(self, *args, v=None, buffers=None, **kwargs): - """Compute forward pass of the layer, treating layer instance as - callable function. + """ + Compute forward pass of the layer, treating layer instance as callable function. Parameters ---------- @@ -335,7 +337,8 @@ def _fn_with_var_arg_wrapper( return fn(*a, **kw, v=v) def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): - """Extract variables from `v_fn` and use it as inputs for `fn`. + """ + Extract variables from `v_fn` and use it as inputs for `fn`. Use `v_fn` to extract the variables and use the extracted variables as inputs to the call function fn of the module. @@ -351,9 +354,9 @@ def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): return _fn_with_var_arg_wrapper def _convert_tensors_to_numpy(self): - """Recursively traverses the module_dict attribute of a Module object - and converts every container containing tensors to numpy using the - to_numpy() method. + """ + Recursively traverses the module_dict attribute of a Module object and converts + every container containing tensors to numpy using the to_numpy() method. Returns ------- @@ -366,9 +369,9 @@ def _convert_tensors_to_numpy(self): self.v = self.v.to_numpy() def _convert_numpy_to_tensors(self): - """Recursively traverses the module_dict attribute of a Module object - and converts every container containing tensors to numpy using the - to_numpy() method. + """ + Recursively traverses the module_dict attribute of a Module object and converts + every container containing tensors to numpy using the to_numpy() method. Returns ------- diff --git a/ivy/stateful/initializers.py b/ivy/stateful/initializers.py index 5f2f0a7907add..1481fce608f80 100644 --- a/ivy/stateful/initializers.py +++ b/ivy/stateful/initializers.py @@ -12,7 +12,8 @@ class Initializer(abc.ABC): - """An initializer for internal variables for a layer. + """ + An initializer for internal variables for a layer. A neuron is a function of the form `a = g(z)`, where `g` is the activation functions and `z = w_1x_1 + w_2x_2 + ... + w_nx_n` where the @@ -30,7 +31,8 @@ def create_variables( fan_in: Optional[float] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ) -> ivy.Array: - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -57,8 +59,8 @@ def create_variables( class Constant(Initializer): def __init__(self, constant: float): - """Constant initializer, will fill in all values with the value of - `constant`. + """ + Constant initializer, will fill in all values with the value of `constant`. Parameters ---------- @@ -98,9 +100,9 @@ def __init__(self): class Uniform(Initializer): def __init__(self, numerator, fan_mode, power, gain): - """Initialize based on a uniform distribution, will fill in all values - with values drawn from a uniform (all values have an equal probability) - distribution. + """ + Initialize based on a uniform distribution, will fill in all values with values + drawn from a uniform (all values have an equal probability) distribution. with range `[-wlim, wlim]` (endpoints included) with `wlim` being calculated as `gain * (numerator / fan)**power`. This distribution helps with issues when @@ -139,7 +141,8 @@ def __init__(self, numerator, fan_mode, power, gain): def create_variables( self, var_shape, device, fan_out=None, fan_in=None, dtype=None ): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -212,8 +215,8 @@ def create_variables( class GlorotUniform(Uniform): def __init__(self): - """Initialize Glorot uniform, also known as the Xavier uniform - initializer. + """ + Initialize Glorot uniform, also known as the Xavier uniform initializer. It draws values from a uniform distribution `[-limit, limit]` where `limit = sqrt(6 / (fan_in + fan_out))` where `fan_in` and `fan_out` are the @@ -224,7 +227,8 @@ def __init__(self): class FirstLayerSiren(Uniform): def __init__(self): - """Initialize Siren uniform for the first layer. + """ + Initialize Siren uniform for the first layer. It draws values from a uniform distribution `[-limit, limit]` where `limit=fan_in` where `fan_in` is the number of input @@ -235,7 +239,8 @@ def __init__(self): class Siren(Uniform): def __init__(self, w0=30): - """Initialize Siren uniform initializer for the first layer. + """ + Initialize Siren uniform initializer for the first layer. It draws values from a uniform distribution `[-limit, limit]` where `limit=sqrt(6 / fan_in) / w0` where `fan_in` is the number @@ -250,7 +255,8 @@ def __init__(self, w0=30): class KaimingNormal(Initializer): def __init__(self, mean=0, fan_mode="fan_in"): - """Initialize Kaiming normal, also known as He Initialization. + """ + Initialize Kaiming normal, also known as He Initialization. It is an method for initializing layers that takes into account the non-linearity of activation functions. It uses a normal distribution centered @@ -286,7 +292,8 @@ def create_variables( negative_slope=0.0, dtype=None, ): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -362,7 +369,8 @@ def create_variables( class RandomNormal(Initializer): def __init__(self, mean=0.0, stddev=0.05, seed=None): - """Initialize with Random Normal Distribution. + """ + Initialize with Random Normal Distribution. It draws values from a Random Normal Distribution with given mean and standard deviation. @@ -386,7 +394,8 @@ def create_variables( device=None, dtype=None, ): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- diff --git a/ivy/stateful/layers.py b/ivy/stateful/layers.py index e2cad240cccf8..0fb5d4adcca41 100644 --- a/ivy/stateful/layers.py +++ b/ivy/stateful/layers.py @@ -28,11 +28,11 @@ def __init__( v=None, dtype=None, ): - """Linear layer, also referred to as dense or fully connected. The - layer receives tensors with input_channels last dimension and returns a - new tensor with output_channels last dimension, following matrix - multiplication with the weight matrix and addition with the bias - vector. + """ + Linear layer, also referred to as dense or fully connected. The layer receives + tensors with input_channels last dimension and returns a new tensor with + output_channels last dimension, following matrix multiplication with the weight + matrix and addition with the bias vector. Parameters ---------- @@ -66,7 +66,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -102,7 +103,8 @@ def _create_variables(self, device=None, dtype=None): return v def _forward(self, x): - """Perform forward pass of the Linear layer. + """ + Perform forward pass of the Linear layer. Parameters ---------- @@ -136,9 +138,9 @@ def __init__( dtype=None, training: bool = True, ): - """Dropout layer. The layer randomly zeroes some of the elements of the - input tensor with probability p using samples from a Bernoull - distribution. + """ + Dropout layer. The layer randomly zeroes some of the elements of the input + tensor with probability p using samples from a Bernoull distribution. Parameters ---------- @@ -157,7 +159,8 @@ def __init__( Module.__init__(self, device=None, v=None, dtype=dtype, training=training) def _create_variables(self, device, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -171,7 +174,8 @@ def _create_variables(self, device, dtype=None): return {} def _forward(self, inputs, dtype=None): - """Perform forward pass of the Linear layer. + """ + Perform forward pass of the Linear layer. Parameters ---------- @@ -222,7 +226,8 @@ def __init__( dtype=None, training=True, ): - """Multi Head Attention layer. + """ + Multi Head Attention layer. Parameters ---------- @@ -387,7 +392,8 @@ def _forward( return_attention_weights=False, average_attention_weights=True, ): - """Perform forward pass of the MultiHeadAttention layer. + """ + Perform forward pass of the MultiHeadAttention layer. Parameters ---------- @@ -479,7 +485,8 @@ def __init__( v=None, dtype=None, ): - """1D convolutional layer. + """ + 1D convolutional layer. Parameters ---------- @@ -531,7 +538,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -567,7 +575,8 @@ def _create_variables(self, device=None, dtype=None): return v def _forward(self, inputs): - """Perform forward pass of the Conv1D layer. + """ + Perform forward pass of the Conv1D layer. Parameters ---------- @@ -622,7 +631,8 @@ def __init__( v=None, dtype=None, ): - """1D transpose convolutional layer. + """ + 1D transpose convolutional layer. Parameters ---------- @@ -677,7 +687,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -713,7 +724,8 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """Perform forward pass of the Conv1DTranspose layer. + """ + Perform forward pass of the Conv1DTranspose layer. Parameters ---------- @@ -770,7 +782,8 @@ def __init__( v=None, dtype=None, ): - """2D convolutional layer. + """ + 2D convolutional layer. Parameters ---------- @@ -824,7 +837,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -860,7 +874,8 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """Perform forward pass of the Conv2D layer. + """ + Perform forward pass of the Conv2D layer. Parameters ---------- @@ -915,7 +930,8 @@ def __init__( v=None, dtype=None, ): - """2D convolutional transpose layer. + """ + 2D convolutional transpose layer. Parameters ---------- @@ -972,7 +988,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -1008,7 +1025,8 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """Perform forward pass of the Conv2DTranspose layer. + """ + Perform forward pass of the Conv2DTranspose layer. Parameters ---------- @@ -1064,7 +1082,8 @@ def __init__( v=None, dtype=None, ): - """Depthwise 2D convolutional layer. + """ + Depthwise 2D convolutional layer. Parameters ---------- @@ -1115,7 +1134,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -1151,7 +1171,8 @@ def _create_variables(self, device, dtype): return v def _forward(self, inputs): - """Perform forward pass of the DepthwiseConv2D layer. + """ + Perform forward pass of the DepthwiseConv2D layer. Parameters ---------- @@ -1205,7 +1226,8 @@ def __init__( v=None, dtype=None, ): - """3D convolutional layer. + """ + 3D convolutional layer. Parameters ---------- @@ -1259,7 +1281,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -1295,7 +1318,8 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """Perform forward pass of the Conv3D layer. + """ + Perform forward pass of the Conv3D layer. Parameters ---------- @@ -1351,7 +1375,8 @@ def __init__( v=None, dtype=None, ): - """3D convolutional transpose layer. + """ + 3D convolutional transpose layer. Parameters ---------- @@ -1409,7 +1434,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -1445,7 +1471,8 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """Perform forward pass of the Conv3DTranspose layer. + """ + Perform forward pass of the Conv3DTranspose layer. Parameters ---------- @@ -1503,7 +1530,8 @@ def __init__( v=None, dtype=None, ): - """LSTM layer, which is a set of stacked lstm cells. + """ + LSTM layer, which is a set of stacked lstm cells. Parameters ---------- @@ -1543,8 +1571,8 @@ def __init__( # Public # def get_initial_state(self, batch_shape, dtype=None): - """Get the initial state of the hidden and cell states, if not provided - explicitly. + """ + Get the initial state of the hidden and cell states, if not provided explicitly. Parameters ---------- @@ -1569,7 +1597,8 @@ def get_initial_state(self, batch_shape, dtype=None): # Overridden def _create_variables(self, device=None, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -1627,7 +1656,8 @@ def _create_variables(self, device=None, dtype=None): @handle_nestable def _forward(self, inputs, initial_state=None): - """Perform forward pass of the LSTM layer. + """ + Perform forward pass of the LSTM layer. Parameters ---------- @@ -1696,7 +1726,8 @@ def __init__( v=None, dtype=None, ): - """Class for applying Max Pooling over a mini-batch of inputs. + """ + Class for applying Max Pooling over a mini-batch of inputs. Parameters ---------- @@ -1716,7 +1747,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -1755,7 +1787,8 @@ def __init__( v=None, dtype=None, ): - """Class for applying Average Pooling over a mini-batch of inputs. + """ + Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -1775,7 +1808,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -1814,7 +1848,8 @@ def __init__( v=None, dtype=None, ): - """Class for applying Max Pooling over a mini-batch of inputs. + """ + Class for applying Max Pooling over a mini-batch of inputs. Parameters ---------- @@ -1834,7 +1869,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -1872,7 +1908,8 @@ def __init__( device=None, dtype=None, ): - """Class for applying 3D Max Pooling over 5D inputs. + """ + Class for applying 3D Max Pooling over 5D inputs. Parameters ---------- @@ -1890,7 +1927,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -1929,7 +1967,8 @@ def __init__( ceil_mode=False, divisor_override=None, ): - """Class for applying Average Pooling over a mini-batch of inputs. + """ + Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -1959,7 +1998,8 @@ def __init__( Module.__init__(self) def _forward(self, x): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -2005,8 +2045,8 @@ def __init__( device=None, dtype=None, ): - """Class for applying a 2D adaptive average pooling over mini-batch of - inputs. + """ + Class for applying a 2D adaptive average pooling over mini-batch of inputs. Parameters ---------- @@ -2022,7 +2062,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -2051,8 +2092,8 @@ def __init__( dtype=None, ): # TODO: add data_format param - """Class for applying a 1D adaptive average pooling over mini-batch of - inputs. + """ + Class for applying a 1D adaptive average pooling over mini-batch of inputs. Parameters ---------- @@ -2066,7 +2107,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -2100,7 +2142,8 @@ def __init__( device=None, dtype=None, ): - """Class for applying FFT to input. + """ + Class for applying FFT to input. Parameters ---------- @@ -2120,7 +2163,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -2159,7 +2203,8 @@ def __init__( *, data_format="NWC", ): - """Class for applying Average Pooling over a mini-batch of inputs. + """ + Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -2179,7 +2224,8 @@ def __init__( Module.__init__(self) def _forward(self, inputs): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -2216,8 +2262,8 @@ def __init__( device=None, dtype=None, ): - """Class for applying the Discrete Cosine Transform over mini-batch of - inputs. + """ + Class for applying the Discrete Cosine Transform over mini-batch of inputs. Parameters ---------- @@ -2242,7 +2288,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -2290,9 +2337,10 @@ def __init__( v=None, dtype=None, ): - """Class for embedding indices into a dense representation. The - Embedding layer is a simple lookup table for dense vectors. It's - typically used to store word embeddings and query them using indices. + """ + Class for embedding indices into a dense representation. The Embedding layer is + a simple lookup table for dense vectors. It's typically used to store word + embeddings and query them using indices. Parameters ---------- @@ -2323,7 +2371,8 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """Create internal variables for the layer. + """ + Create internal variables for the layer. Parameters ---------- @@ -2353,7 +2402,8 @@ def _pad_embd(self, indices, embd): return ivy.where(mask, mask_val, embd) def _forward(self, indices): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -2380,8 +2430,9 @@ def _extra_repr(self): class Identity(Module): def __init__(self): - """Identity layer. The layer is argument insensitive and returns the - input argument as output when called. + """ + Identity layer. The layer is argument insensitive and returns the input argument + as output when called. It's typically used as a placeholder when no operation is to be performed. It doesn't have any learnable parameter. @@ -2389,7 +2440,8 @@ def __init__(self): Module.__init__(self) def _forward(self, x): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- @@ -2418,7 +2470,8 @@ def __init__( device=None, dtype=None, ): - """Class for applying IFFT to input. + """ + Class for applying IFFT to input. Parameters ---------- @@ -2444,7 +2497,8 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """Forward pass of the layer. + """ + Forward pass of the layer. Parameters ---------- diff --git a/ivy/stateful/losses.py b/ivy/stateful/losses.py index 77a47b94a0d1e..1970659dd3be1 100644 --- a/ivy/stateful/losses.py +++ b/ivy/stateful/losses.py @@ -21,7 +21,8 @@ def __init__( def _forward( self, true, pred, *, compute_full_loss=None, axis=None, reduction=None ): - """Perform forward pass of the Log Poisson Loss. + """ + Perform forward pass of the Log Poisson Loss. true input array containing true labels. @@ -73,7 +74,8 @@ def __init__( Module.__init__(self) def _forward(self, true, pred, *, axis=None, epsilon=None, reduction=None): - """Perform forward pass of the Cross Entropy Loss. + """ + Perform forward pass of the Cross Entropy Loss. true input array containing true labels. diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 12a16f95f39dc..11e3a9838fda8 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -53,8 +53,9 @@ def __init__( device=None, **kwargs, ): - """Initialize Ivy layer, which is a stateful object consisting of - trainable variables. + """ + Initialize Ivy layer, which is a stateful object consisting of trainable + variables. Parameters ---------- @@ -159,7 +160,8 @@ def build( dynamic_backend=None, **kwargs, ): - """Build the internal layers and variables for this module. + """ + Build the internal layers and variables for this module. Parameters ---------- @@ -302,8 +304,9 @@ def trace_graph( kwargs: Optional[Dict] = None, **trace_kwargs, ): - """Trace the `ivy.Module`'s `_unified_ivy_graph` or `_call` method to - the target backend. + """ + Trace the `ivy.Module`'s `_unified_ivy_graph` or `_call` method to the target + backend. Parameters ---------- @@ -336,7 +339,8 @@ def trace_graph( self._lazy_traced = False def register_buffer(self, name, value): - """Register a buffer. + """ + Register a buffer. Parameters ---------- @@ -351,7 +355,8 @@ def register_buffer(self, name, value): super().__setattr__(name, value) def register_parameter(self, name, value): - """Register a parameter. + """ + Register a parameter. Parameters ---------- @@ -413,7 +418,8 @@ def show_graph( ) def save_weights(self, weights_path, /): - """Save the weights on the Module. + """ + Save the weights on the Module. Parameters ---------- @@ -428,7 +434,8 @@ def save_weights(self, weights_path, /): self.v.cont_to_disk_as_hdf5(weights_path) def save(self, filename): - """Save the module object to disk using pickle. + """ + Save the module object to disk using pickle. Parameters ---------- @@ -444,7 +451,8 @@ def save(self, filename): @staticmethod def load(filename): - """Load a module object from disk using pickle. + """ + Load a module object from disk using pickle. Parameters ---------- @@ -472,7 +480,8 @@ def __call__( buffers=None, **kwargs, ): - """Forward an input through current module. + """ + Forward an input through current module. Parameters ---------- @@ -569,8 +578,9 @@ def __repr__(self): # -----------------------------------# def _create_variables(self, *, device=None, dtype=None): - """Create internal trainable variables, and return as arbitrary nested - dict. Overridable. + """ + Create internal trainable variables, and return as arbitrary nested dict. + Overridable. Parameters ---------- @@ -587,8 +597,8 @@ def _create_variables(self, *, device=None, dtype=None): return {} def _build(self, *args, **kwargs) -> bool: - """Build the internal layers and variables for this module. - Overridable. + """ + Build the internal layers and variables for this module. Overridable. Returns ------- @@ -600,8 +610,8 @@ def _build(self, *args, **kwargs) -> bool: return True def _forward(self, *args, **kwargs): - """Forward pass of the layer, called after handling the optional input - variables. + """ + Forward pass of the layer, called after handling the optional input variables. Raises ------ @@ -610,7 +620,8 @@ def _forward(self, *args, **kwargs): raise ivy.utils.exceptions.IvyNotImplementedException def _extra_repr(self) -> str: - """Set the extra representation of the module. + """ + Set the extra representation of the module. To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line @@ -651,8 +662,7 @@ def buffers(self): @property def state_dict(self): - """Return the state_dict which is a collection of the variables and - buffers.""" + """Return the state_dict which is a collection of the variables and buffers.""" return {**self.v, **self.buffers} @property diff --git a/ivy/stateful/norms.py b/ivy/stateful/norms.py index 5c8e3c44a53b5..9e68fe433651e 100644 --- a/ivy/stateful/norms.py +++ b/ivy/stateful/norms.py @@ -19,7 +19,8 @@ def __init__( v=None, dtype=None, ): - """Class for applying Layer Normalization over a mini-batch of inputs. + """ + Class for applying Layer Normalization over a mini-batch of inputs. Parameters ---------- @@ -67,7 +68,8 @@ def _create_variables(self, device=None, dtype=None): return {} def _forward(self, inputs): - """Perform forward pass of the LayerNorm layer. + """ + Perform forward pass of the LayerNorm layer. Parameters ---------- @@ -111,7 +113,8 @@ def __init__( dtype=None, training=True, ): - """Class for applying Layer Normalization over a mini-batch of inputs. + """ + Class for applying Layer Normalization over a mini-batch of inputs. Parameters ---------- @@ -181,7 +184,8 @@ def _create_variables(self, device=None, dtype=None): return {} def _forward(self, inputs): - """Perform forward pass of the BatchNorm layer. + """ + Perform forward pass of the BatchNorm layer. Parameters ---------- diff --git a/ivy/stateful/optimizers.py b/ivy/stateful/optimizers.py index dafc66d90fbc3..9670c4e5aef7a 100644 --- a/ivy/stateful/optimizers.py +++ b/ivy/stateful/optimizers.py @@ -24,8 +24,8 @@ def __init__( fallback_to_non_traced: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """Construct a general Optimizer. This is an abstract class, and must - be derived. + """ + Construct a general Optimizer. This is an abstract class, and must be derived. Parameters ---------- @@ -70,9 +70,9 @@ def __init__( @abc.abstractmethod def _step(self, v: ivy.Container, grads: ivy.Container): - """Update nested variables container v from update step, using nested - grads container. Override this abstract method with child class custom - implementation. + """ + Update nested variables container v from update step, using nested grads + container. Override this abstract method with child class custom implementation. Parameters ---------- @@ -93,7 +93,8 @@ def _step(self, v: ivy.Container, grads: ivy.Container): def _step_fn( self, v: ivy.Container, grads: ivy.Container, ignore_missing: bool = False ): - """Call the custom child step function implementation. + """ + Call the custom child step function implementation. Parameters ---------- @@ -117,7 +118,8 @@ def _step_fn( @abc.abstractmethod def set_state(self, state: ivy.Container): - """Set state of the optimizer. + """ + Set state of the optimizer. Parameters ---------- @@ -131,8 +133,8 @@ def set_state(self, state: ivy.Container): def step( self, v: ivy.Container, grads: ivy.Container, ignore_missing: bool = False ): - """Update nested variables container v from overridden private - self._step. + """ + Update nested variables container v from overridden private self._step. Parameters ---------- @@ -167,7 +169,8 @@ def __init__( stop_gradients: bool = True, trace_on_next_step: bool = False, ): - """Construct a Stochastic-Gradient-Descent (SGD) optimizer. + """ + Construct a Stochastic-Gradient-Descent (SGD) optimizer. Parameters ---------- @@ -191,8 +194,9 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """Update nested variables container v by gradient descent step, using - nested gradients container. + """ + Update nested variables container v by gradient descent step, using nested + gradients container. Parameters ---------- @@ -214,7 +218,8 @@ def _step(self, v: ivy.Container, grads: ivy.Container): ) def set_state(self, state: ivy.Container): - """Set state of the optimizer. + """ + Set state of the optimizer. Parameters ---------- @@ -237,7 +242,8 @@ def __init__( stop_gradients: bool = True, trace_on_next_step: bool = False, ): - """Construct a Layer-wise Adaptive Rate Scaling (LARS) optimizer. + """ + Construct a Layer-wise Adaptive Rate Scaling (LARS) optimizer. Parameters ---------- @@ -264,8 +270,9 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """Update nested variables container v by gradient descent step, using - nested gradients container. + """ + Update nested variables container v by gradient descent step, using nested + gradients container. Parameters ---------- @@ -288,7 +295,8 @@ def _step(self, v: ivy.Container, grads: ivy.Container): ) def set_state(self, state: ivy.Container): - """Set state of the optimizer. + """ + Set state of the optimizer. Parameters ---------- @@ -314,7 +322,8 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """Construct an ADAM optimizer. + """ + Construct an ADAM optimizer. Parameters ---------- @@ -356,8 +365,9 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """Update nested variables container v by Adam update step, using - nested grads container. + """ + Update nested variables container v by Adam update step, using nested grads + container. Parameters ---------- @@ -391,7 +401,8 @@ def _step(self, v: ivy.Container, grads: ivy.Container): return new_v def set_state(self, state: ivy.Container): - """Set state of the optimizer. + """ + Set state of the optimizer. Parameters ---------- @@ -419,7 +430,8 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """Construct an ADAMW optimizer. + """ + Construct an ADAMW optimizer. Parameters ---------- @@ -461,8 +473,9 @@ def __init__( ) def _step(self, v: ivy.Container, grads: ivy.Container): - """Update nested variables container v by AdamW update step, using - nested grads container. + """ + Update nested variables container v by AdamW update step, using nested grads + container. Parameters ---------- @@ -497,7 +510,8 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """Construct an LAMB optimizer. + """ + Construct an LAMB optimizer. Parameters ---------- @@ -544,8 +558,9 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """Update nested variables container v by LAMB update step, using - nested grads container. + """ + Update nested variables container v by LAMB update step, using nested grads + container. Parameters ---------- @@ -581,7 +596,8 @@ def _step(self, v: ivy.Container, grads: ivy.Container): return new_v def set_state(self, state: ivy.Container): - """Set state of the optimizer. + """ + Set state of the optimizer. Parameters ---------- diff --git a/ivy/stateful/sequential.py b/ivy/stateful/sequential.py index 08bf1a1f56465..3656b1f3b24af 100644 --- a/ivy/stateful/sequential.py +++ b/ivy/stateful/sequential.py @@ -16,8 +16,9 @@ def __init__( v: Optional[Union[ivy.Array, ivy.NativeArray]] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ): - """Initialize a sequential container. Modules will be added to it in - the order they are passed in the constructor. + """ + Initialize a sequential container. Modules will be added to it in the order they + are passed in the constructor. Parameters ---------- @@ -48,7 +49,8 @@ def __iter__(self): return iter(self._submodules) def _forward(self, inputs): - """Perform forward pass of the Sequential container. + """ + Perform forward pass of the Sequential container. Parameters ---------- diff --git a/ivy/utils/_importlib.py b/ivy/utils/_importlib.py index 01247a3bd719f..1eaecd962124e 100644 --- a/ivy/utils/_importlib.py +++ b/ivy/utils/_importlib.py @@ -74,7 +74,8 @@ def _from_import(name: str, package=None, mod_globals=None, from_list=(), level= def _absolute_import(name: str, asname=None, mod_globals=None): - """Handle absolute import statement :param name: + """ + Handle absolute import statement :param name: :return: """ diff --git a/ivy/utils/backend/ast_helpers.py b/ivy/utils/backend/ast_helpers.py index 8e5b2b54c6634..795dc94e67931 100644 --- a/ivy/utils/backend/ast_helpers.py +++ b/ivy/utils/backend/ast_helpers.py @@ -156,7 +156,8 @@ def _create_attrs_from_node(node, attrs=()): def _create_node(stmnt: str): - """Create an AST node from a given statement. + """ + Create an AST node from a given statement. Parameters ---------- diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 04974f0557488..576b9a3b6cf34 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -75,7 +75,8 @@ def _get_backend_for_arg(arg_module_name): def _determine_backend_from_args(args): - """Return the appropriate Ivy backend, given some arguments. + """ + Return the appropriate Ivy backend, given some arguments. Parameters ---------- @@ -120,8 +121,9 @@ def _determine_backend_from_args(args): def set_backend_to_specific_version(backend): - """Update the backend dict to make the original function name point to the - version specific one. + """ + Update the backend dict to make the original function name point to the version + specific one. Parameters ---------- @@ -144,8 +146,8 @@ def set_backend_to_specific_version(backend): def current_backend(*args, **kwargs): - """Return the current backend. Priorities: global_backend > argument's - backend. + """ + Return the current backend. Priorities: global_backend > argument's backend. Parameters ---------- @@ -326,7 +328,8 @@ def _map_fn(x): @prevent_access_locally def set_backend(backend: str, dynamic: bool = False): - """Set `backend` to be the global backend. + """ + Set `backend` to be the global backend. Will also convert all Array and Container objects to the new backend if `dynamic` = True @@ -390,7 +393,8 @@ def set_backend(backend: str, dynamic: bool = False): def set_numpy_backend(): - """Set NumPy to be the global backend. + """ + Set NumPy to be the global backend. equivalent to `ivy.set_backend("numpy")`. """ # noqa @@ -398,7 +402,8 @@ def set_numpy_backend(): def set_jax_backend(): - """Set JAX to be the global backend. + """ + Set JAX to be the global backend. equivalent to `ivy.set_backend("jax")`. """ # noqa @@ -406,7 +411,8 @@ def set_jax_backend(): def set_tensorflow_backend(): - """Set TensorFlow to be the global backend. + """ + Set TensorFlow to be the global backend. equivalent to `ivy.set_backend("tensorflow")`. """ @@ -414,7 +420,8 @@ def set_tensorflow_backend(): def set_torch_backend(): - """Set torch to be the global backend. + """ + Set torch to be the global backend. equivalent to `ivy.set_backend("torch")`. """ # noqa @@ -422,7 +429,8 @@ def set_torch_backend(): def set_paddle_backend(): - """Set paddle to be the global backend. + """ + Set paddle to be the global backend. equivalent to `ivy.set_backend("paddle")`. """ # noqa @@ -430,7 +438,8 @@ def set_paddle_backend(): def set_mxnet_backend(): - """Set MXNet to be the global backend. + """ + Set MXNet to be the global backend. equivalent to `ivy.set_backend("mx")`. """ # noqa @@ -439,9 +448,10 @@ def set_mxnet_backend(): @prevent_access_locally def previous_backend(): - """Unset the current global backend, and adjusts the ivy dict such that - either a previously set global backend is then used as the backend, - otherwise we return to Ivy's implementations. + """ + Unset the current global backend, and adjusts the ivy dict such that either a + previously set global backend is then used as the backend, otherwise we return to + Ivy's implementations. Returns ------- diff --git a/ivy/utils/einsum_parser.py b/ivy/utils/einsum_parser.py index 697e47d39494b..b7b20b89fc22c 100644 --- a/ivy/utils/einsum_parser.py +++ b/ivy/utils/einsum_parser.py @@ -12,7 +12,8 @@ def is_valid_einsum_char(x: str) -> bool: - """Check if the character ``x`` is valid for numpy einsum. **Examples:** + """ + Check if the character ``x`` is valid for numpy einsum. **Examples:** ```python is_valid_einsum_char("a") @@ -26,7 +27,8 @@ def is_valid_einsum_char(x: str) -> bool: def has_valid_einsum_chars_only(einsum_str: str) -> bool: # [x] - """Check if ``einsum_str`` contains only valid characters for numpy einsum. + """ + Check if ``einsum_str`` contains only valid characters for numpy einsum. **Examples:** ```python @@ -68,7 +70,8 @@ def get_symbol(i: int) -> str: def gen_unused_symbols(used: str, n: int) -> Iterator[str]: - """Generate ``n`` symbols that are not already in ``used``. + """ + Generate ``n`` symbols that are not already in ``used``. **Examples:** ```python @@ -87,9 +90,9 @@ def gen_unused_symbols(used: str, n: int) -> Iterator[str]: def find_output_str(subscripts: str) -> str: - """Find the output string for the inputs ``subscripts`` under canonical - einstein summation rules.That is, repeated indices are summed over by - default. + """ + Find the output string for the inputs ``subscripts`` under canonical einstein + summation rules.That is, repeated indices are summed over by default. Examples -------- @@ -111,8 +114,9 @@ def find_output_str(subscripts: str) -> str: def find_output_shape( inputs: List[str], shapes: List[TensorShapeType], output: str ) -> TensorShapeType: - """Find the output shape for given inputs, shapes and output string, taking - into account broadcasting. + """ + Find the output shape for given inputs, shapes and output string, taking into + account broadcasting. Examples -------- @@ -134,7 +138,8 @@ def find_output_shape( def possibly_convert_to_numpy(x: Any) -> Any: # possibly convert to native - """Convert things without a 'shape' to ndarrays, but leave everything else. + """ + Convert things without a 'shape' to ndarrays, but leave everything else. Examples -------- @@ -164,8 +169,8 @@ def possibly_convert_to_numpy(x: Any) -> Any: # possibly convert to native def convert_subscripts(old_sub: List[Any], symbol_map: Dict[Any, Any]) -> str: - """Convert user custom subscripts list to subscript string according to - `symbol_map`. + """ + Convert user custom subscripts list to subscript string according to `symbol_map`. Examples -------- @@ -219,9 +224,9 @@ def convert_interleaved_input( def legalise_einsum_expr(*operands: Any) -> str: - """Reproduction of einsum c side einsum parsing in python. **Parameters:** - Intakes the same inputs as `contract_path`, but NOT the keyword args. The - only. + """ + Reproduction of einsum c side einsum parsing in python. **Parameters:** Intakes the + same inputs as `contract_path`, but NOT the keyword args. The only. supported keyword argument is: - **shapes** - *(bool, optional)* Whether diff --git a/ivy/utils/einsum_path_helpers.py b/ivy/utils/einsum_path_helpers.py index 465a0122e695e..c42ce79ebe5e3 100644 --- a/ivy/utils/einsum_path_helpers.py +++ b/ivy/utils/einsum_path_helpers.py @@ -11,7 +11,8 @@ def flop_count(idx_contraction, inner, num_terms, size_dictionary): - """Compute the number of FLOPS in the contraction. + """ + Compute the number of FLOPS in the contraction. Parameters ---------- @@ -46,8 +47,8 @@ def flop_count(idx_contraction, inner, num_terms, size_dictionary): def compute_size_by_dict(indices, idx_dict): - """Compute the product of the elements in indices based on the dictionary - idx_dict. + """ + Compute the product of the elements in indices based on the dictionary idx_dict. Parameters ---------- @@ -73,7 +74,8 @@ def compute_size_by_dict(indices, idx_dict): def find_contraction(positions, input_sets, output_set): - """Find the contraction for a given set of input and output sets. + """ + Find the contraction for a given set of input and output sets. Parameters ---------- @@ -129,9 +131,10 @@ def find_contraction(positions, input_sets, output_set): def optimal_path(input_sets, output_set, idx_dict, memory_limit): - """Compute all possible pair contractions, sieves the results based on - ``memory_limit`` and returns the lowest cost path. This algorithm scales - factorial with respect to the elements in the list ``input_sets``. + """ + Compute all possible pair contractions, sieves the results based on ``memory_limit`` + and returns the lowest cost path. This algorithm scales factorial with respect to + the elements in the list ``input_sets``. Parameters ---------- @@ -201,8 +204,9 @@ def optimal_path(input_sets, output_set, idx_dict, memory_limit): def parse_possible_contraction( positions, input_sets, output_set, idx_dict, memory_limit, path_cost, naive_cost ): - """Compute the cost (removed size + flops) and resultant indices for - performing the contraction specified by ``positions``. + """ + Compute the cost (removed size + flops) and resultant indices for performing the + contraction specified by ``positions``. Parameters ---------- @@ -257,9 +261,9 @@ def parse_possible_contraction( def update_other_results(results, best): - """Update the positions and provisional input_sets of ``results`` based on - performing the contraction result ``best``. Remove any involving the - tensors contracted. + """ + Update the positions and provisional input_sets of ``results`` based on performing + the contraction result ``best``. Remove any involving the tensors contracted. Parameters ---------- @@ -295,12 +299,12 @@ def update_other_results(results, best): def greedy_path(input_sets, output_set, idx_dict, memory_limit): - """Find the path by contracting the best pair until the input list is - exhausted. The best pair is found by minimizing the tuple - ``(-prod(indices_removed), cost)``. What this amounts to is prioritizing - matrix multiplication or inner product operations, then Hadamard like - operations, and finally outer operations. Outer products are limited by - ``memory_limit``. This algorithm scales cubically with respect to the + """ + Find the path by contracting the best pair until the input list is exhausted. The + best pair is found by minimizing the tuple ``(-prod(indices_removed), cost)``. What + this amounts to is prioritizing matrix multiplication or inner product operations, + then Hadamard like operations, and finally outer operations. Outer products are + limited by ``memory_limit``. This algorithm scales cubically with respect to the number of elements in the list ``input_sets``. Parameters @@ -407,8 +411,8 @@ def greedy_path(input_sets, output_set, idx_dict, memory_limit): def can_dot(inputs, result, idx_removed): - """Check if we can use BLAS (np.tensordot) call and its beneficial to do - so. + """ + Check if we can use BLAS (np.tensordot) call and its beneficial to do so. Parameters ---------- @@ -510,7 +514,8 @@ def can_dot(inputs, result, idx_removed): def parse_einsum_input(operands, subscripts=None): - """Reproduction of einsum c side einsum parsing in python. + """ + Reproduction of einsum c side einsum parsing in python. Returns ------- diff --git a/ivy/utils/exceptions.py b/ivy/utils/exceptions.py index d8f35b27a5b0e..32d12b647b075 100644 --- a/ivy/utils/exceptions.py +++ b/ivy/utils/exceptions.py @@ -141,7 +141,8 @@ def _get_traces(curr_obj, area, local_dict, target_name): def _check_if_path_found(path, full_path): - """Check if the path is found in the full path. + """ + Check if the path is found in the full path. Parameters ---------- @@ -159,7 +160,8 @@ def _check_if_path_found(path, full_path): def _configure_stack_trace(traceback): - """Configure the stack trace to be displayed in the console. + """ + Configure the stack trace to be displayed in the console. Parameters ---------- @@ -199,7 +201,8 @@ def _configure_stack_trace(traceback): def _add_native_error(default): - """Append the native error to the message if it exists. + """ + Append the native error to the message if it exists. Parameters ---------- @@ -332,7 +335,8 @@ def __init__(self, *messages, include_backend=False): def handle_exceptions(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_exceptions(*args, **kwargs): - """Catch all exceptions and raise them in IvyException. + """ + Catch all exceptions and raise them in IvyException. Parameters ---------- diff --git a/ivy/utils/inspection.py b/ivy/utils/inspection.py index 77feceb756833..2fa60f6f9d839 100644 --- a/ivy/utils/inspection.py +++ b/ivy/utils/inspection.py @@ -90,8 +90,9 @@ def _get_array_idxs(typ, idx_so_far=None): def fn_array_spec(fn): - """Return a specification of the function, indicating all arguments which - include arrays, and the indexes of these. + """ + Return a specification of the function, indicating all arguments which include + arrays, and the indexes of these. Parameters ---------- diff --git a/ivy/utils/logging.py b/ivy/utils/logging.py index 977f3add6f5ec..498424a976cb4 100644 --- a/ivy/utils/logging.py +++ b/ivy/utils/logging.py @@ -7,7 +7,8 @@ def set_logging_mode(mode): - """Set the current logging mode for Ivy. + """ + Set the current logging mode for Ivy. Possible modes are 'DEBUG', 'INFO', 'WARNING', 'ERROR'. """ @@ -21,8 +22,7 @@ def set_logging_mode(mode): def unset_logging_mode(): - """Remove the most recently set logging mode, returning to the previous - one.""" + """Remove the most recently set logging mode, returning to the previous one.""" if len(logging_mode_stack) > 1: # Remove the current mode logging_mode_stack.pop() diff --git a/ivy/utils/profiler.py b/ivy/utils/profiler.py index 05b7d016a3a16..c168b1ce7253e 100644 --- a/ivy/utils/profiler.py +++ b/ivy/utils/profiler.py @@ -9,7 +9,8 @@ class Profiler(cProfile.Profile): - """A Profiler class that allows code profiling. + """ + A Profiler class that allows code profiling. Attributes ---------- diff --git a/ivy_tests/test_docstrings.py b/ivy_tests/test_docstrings.py index 0f582920243ef..af4fae58af2b9 100644 --- a/ivy_tests/test_docstrings.py +++ b/ivy_tests/test_docstrings.py @@ -51,7 +51,8 @@ def trim(*, docstring): def check_docstring_examples_run( *, fn, from_container=False, from_array=False, num_sig_fig=2 ): - """Performs docstring tests for a given function. + """ + Performs docstring tests for a given function. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/assertions.py b/ivy_tests/test_ivy/helpers/assertions.py index b2403339f7b5f..539d01b0d9243 100644 --- a/ivy_tests/test_ivy/helpers/assertions.py +++ b/ivy_tests/test_ivy/helpers/assertions.py @@ -18,8 +18,9 @@ def assert_all_close( atol=1e-08, ground_truth_backend="TensorFlow", ): - """Match the ret_np and ret_from_gt_np inputs element-by-element to ensure - that they are the same. + """ + Match the ret_np and ret_from_gt_np inputs element-by-element to ensure that they + are the same. Parameters ---------- @@ -76,8 +77,9 @@ def assert_same_type_and_shape(values, this_key_chain=None): def assert_same_type(ret_from_target, ret_from_gt, backend_to_test, gt_backend): - """Assert that the return types from the target and ground truth frameworks - are the same. + """ + Assert that the return types from the target and ground truth frameworks are the + same. checks with a string comparison because with_backend returns different objects. Doesn't check recursively. @@ -106,8 +108,8 @@ def value_test( backend: str, ground_truth_backend="TensorFlow", ): - """Perform a value test for matching the arrays in ret_np_flat and - ret_from_np_gt_flat. + """ + Perform a value test for matching the arrays in ret_np_flat and ret_from_np_gt_flat. Parameters ---------- @@ -182,8 +184,9 @@ def value_test( def check_unsupported_dtype(*, fn, input_dtypes, all_as_kwargs_np): - """Check whether a function does not support the input data types or the - output data type. + """ + Check whether a function does not support the input data types or the output data + type. Parameters ---------- @@ -226,7 +229,8 @@ def check_unsupported_dtype(*, fn, input_dtypes, all_as_kwargs_np): def check_unsupported_device(*, fn, input_device, all_as_kwargs_np): - """Check whether a function does not support a given device. + """ + Check whether a function does not support a given device. Parameters ---------- @@ -264,7 +268,8 @@ def check_unsupported_device(*, fn, input_device, all_as_kwargs_np): def check_unsupported_device_and_dtype(*, fn, device, input_dtypes, all_as_kwargs_np): - """Check whether a function does not support a given device or data types. + """ + Check whether a function does not support a given device or data types. Parameters ---------- @@ -299,7 +304,8 @@ def check_unsupported_device_and_dtype(*, fn, device, input_dtypes, all_as_kwarg def test_unsupported_function(*, fn, args, kwargs): - """Test a function with an unsupported datatype to raise an exception. + """ + Test a function with an unsupported datatype to raise an exception. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index ae7abf618aed0..01c4199e85ca4 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -76,8 +76,9 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non def _find_instance_in_args(backend: str, args, array_indices, mask): - """Find the first element in the arguments that is considered to be an - instance of Array or Container class. + """ + Find the first element in the arguments that is considered to be an instance of + Array or Container class. Parameters ---------- @@ -419,8 +420,9 @@ def test_function( return_flat_np_arrays: bool = False, **all_as_kwargs_np, ): - """Test a function that consumes (or returns) arrays for the current - backend by comparing the result with numpy. + """ + Test a function that consumes (or returns) arrays for the current backend by + comparing the result with numpy. Parameters ---------- @@ -756,8 +758,9 @@ def test_frontend_function( test_values: bool = True, **all_as_kwargs_np, ): - """Test a frontend function for the current backend by comparing the result - with the function in the associated framework. + """ + Test a frontend function for the current backend by comparing the result with the + function in the associated framework. Parameters ---------- @@ -1636,8 +1639,9 @@ def test_method( on_device: str, return_flat_np_arrays: bool = False, ): - """Test a class-method that consumes (or returns) arrays for the current - backend by comparing the result with numpy. + """ + Test a class-method that consumes (or returns) arrays for the current backend by + comparing the result with numpy. Parameters ---------- @@ -1940,8 +1944,9 @@ def test_frontend_method( tolerance_dict: Optional[dict] = None, test_values: Union[bool, str] = True, ): - """Test a class-method that consumes (or returns) arrays for the current - backend by comparing the result with numpy. + """ + Test a class-method that consumes (or returns) arrays for the current backend by + comparing the result with numpy. Parameters ---------- @@ -2277,7 +2282,8 @@ def _get_framework_atol(atols: dict, current_fw: str): def _get_nested_np_arrays(nest): - """Search for a NumPy arrays in a nest. + """ + Search for a NumPy arrays in a nest. Parameters ---------- @@ -2307,7 +2313,8 @@ def create_args_kwargs( test_flags: Union[pf.FunctionTestFlags, pf.MethodTestFlags], on_device, ): - """Create arguments and keyword-arguments for the function to test. + """ + Create arguments and keyword-arguments for the function to test. Parameters ---------- @@ -2378,7 +2385,8 @@ def wrap_frontend_function_args(argument): def kwargs_to_args_n_kwargs(*, num_positional_args, kwargs): - """Split the kwargs into args and kwargs. + """ + Split the kwargs into args and kwargs. The first num_positional_args ported to args. """ @@ -2464,7 +2472,8 @@ def flatten_frontend_to_np(*, backend: str, ret): def get_ret_and_flattened_np_array( backend_to_test: str, fn, *args, test_trace=False, precision_mode=False, **kwargs ): - """Run func with args and kwargs. + """ + Run func with args and kwargs. Return the result along with its flattened version. """ diff --git a/ivy_tests/test_ivy/helpers/globals.py b/ivy_tests/test_ivy/helpers/globals.py index d1a4fb6e83791..e311696ce72ac 100644 --- a/ivy_tests/test_ivy/helpers/globals.py +++ b/ivy_tests/test_ivy/helpers/globals.py @@ -1,5 +1,6 @@ -"""A state holder for testing, this is only intended to hold and store testing -data to be used by the test helpers to prune unsupported data. +""" +A state holder for testing, this is only intended to hold and store testing data to be +used by the test helpers to prune unsupported data. Should not be used inside any of the test functions. """ @@ -59,8 +60,7 @@ class TestData: class InterruptedTest(BaseException): - """Indicate that a test tried to write global attributes while a test is - running.""" + """Indicate that a test tried to write global attributes while a test is running.""" def __init__(self, test_interrupted): super().__init__(f"{test_interrupted} was interrupted during execution.") diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py index a0d522617220d..0de8cfe26b10c 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py @@ -23,7 +23,8 @@ def array_bools( draw, *, size=st.shared(number_helpers.ints(min_value=1, max_value=4), key="size") ): - """Draws a list of booleans with a given size. + """ + Draws a list of booleans with a given size. Parameters ---------- @@ -73,7 +74,8 @@ def array_bools( def list_of_size(*, x, size): - """Return a list of the given length with elements drawn randomly from x. + """ + Return a list of the given length with elements drawn randomly from x. Parameters ---------- @@ -155,7 +157,8 @@ def lists( max_size=None, size_bounds=None, ): - """Draws a list with a random bounded size from the data-set x. + """ + Draws a list with a random bounded size from the data-set x. Parameters ---------- @@ -310,8 +313,8 @@ def dtype_and_values( array_api_dtypes=False, shape_key="shape", ): - """Draws a list of arrays with elements from the given corresponding data - types. + """ + Draws a list of arrays with elements from the given corresponding data types. Parameters ---------- @@ -574,8 +577,9 @@ def dtype_values_axis( force_tuple_axis=False, ret_shape=False, ): - """Draws a list of arrays with elements from the given data type, and a - random axis of the arrays. + """ + Draws a list of arrays with elements from the given data type, and a random axis of + the arrays. Parameters ---------- @@ -813,9 +817,10 @@ def array_indices_axis( indices_same_dims=False, valid_bounds=True, ): - """Generate two arrays x & indices, the values in the indices array are - indices of the array x. Draws an integers randomly from the minimum and - maximum number of positional arguments a given function can take. + """ + Generate two arrays x & indices, the values in the indices array are indices of the + array x. Draws an integers randomly from the minimum and maximum number of + positional arguments a given function can take. Parameters ---------- @@ -1041,9 +1046,10 @@ def array_indices_put_along_axis( values=None, values_dtypes=get_dtypes("valid"), ): - """Generate two arrays x & indices, the values in the indices array are - indices of the array x. Draws an integers randomly from the minimum and - maximum number of positional arguments a given function can take. + """ + Generate two arrays x & indices, the values in the indices array are indices of the + array x. Draws an integers randomly from the minimum and maximum number of + positional arguments a given function can take. Parameters ---------- @@ -1232,7 +1238,8 @@ def arrays_and_axes( return_dtype=False, force_int_axis=False, ): - """Generate a list of arrays and axes. + """ + Generate a list of arrays and axes. Parameters ---------- @@ -1401,8 +1408,8 @@ def array_values( small_abs_safety_factor=1.1, safety_factor_scale="linear", ): - """Draws a list (of lists) of a given shape containing values of a given - data type. + """ + Draws a list (of lists) of a given shape containing values of a given data type. Parameters ---------- @@ -2168,10 +2175,11 @@ def create_concatenable_arrays_dtypes( dtypes, common_shape=None, ): - """Draws a random number of arrays with concatenable or stackable - dimensions. Arrays have same number of dimensions, but their shape can - differ along a specified dimension (concat_dim). If concat_dim is None, - arrays have the same shape. Dtypes of arrays can differ. + """ + Draws a random number of arrays with concatenable or stackable dimensions. Arrays + have same number of dimensions, but their shape can differ along a specified + dimension (concat_dim). If concat_dim is None, arrays have the same shape. Dtypes of + arrays can differ. Parameters ---------- @@ -2234,9 +2242,10 @@ def create_concatenable_arrays_dtypes( # helpers for tests (core and frontend) related to solve function @st.composite def get_first_solve_batch_matrix(draw, choose_adjoint=False): - """Generate non-singular left hand side of equation system possibly with a - single batch dimension at the beginning. Use get_second_solve_batch_matrix - to get the right hand side. + """ + Generate non-singular left hand side of equation system possibly with a single batch + dimension at the beginning. Use get_second_solve_batch_matrix to get the right hand + side. Parameters ---------- @@ -2293,9 +2302,10 @@ def get_first_solve_batch_matrix(draw, choose_adjoint=False): @st.composite def get_second_solve_batch_matrix(draw, allow_simplified=True, choose_side=False): - """Generate right hand side of equation system. Possible with a batch - dimension and possibly with several columns of values. Use - get_first_solve_batch_matrix to generate the left hand side. + """ + Generate right hand side of equation system. Possible with a batch dimension and + possibly with several columns of values. Use get_first_solve_batch_matrix to + generate the left hand side. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py index 08838b35ae4e7..31742e5519501 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py @@ -113,10 +113,10 @@ def get_dtypes( key=None, prune_function=True, ): - """Draws a valid dtypes for the test function. For frontend tests, it draws - the data types from the intersection between backend framework data types - and frontend framework dtypes, otherwise, draws it from backend framework - data types. + """ + Draws a valid dtypes for the test function. For frontend tests, it draws the data + types from the intersection between backend framework data types and frontend + framework dtypes, otherwise, draws it from backend framework data types. Parameters ---------- @@ -262,7 +262,8 @@ def array_dtypes( shared_dtype=False, array_api_dtypes=False, ): - """Draws a list of data types. + """ + Draws a list of data types. Parameters ---------- @@ -362,7 +363,8 @@ def array_dtypes( @st.composite def get_castable_dtype(draw, available_dtypes, dtype: str, x: Optional[list] = None): - """Draws castable dtypes for the given dtype based on the current backend. + """ + Draws castable dtypes for the given dtype based on the current backend. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 13369be1461dd..7662f4d2753f5 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -14,7 +14,8 @@ def matrix_is_stable(x, cond_limit=30): - """Check if a matrix is numerically stable or not. + """ + Check if a matrix is numerically stable or not. Used to avoid numerical instabilities in further computationally heavy calculations. @@ -61,7 +62,8 @@ def apply_safety_factor( large_abs_safety_factor=1.1, safety_factor_scale="linear", ): - """Apply safety factor scaling to numeric data type. + """ + Apply safety factor scaling to numeric data type. Parameters ---------- @@ -223,8 +225,8 @@ def two_broadcastable_shapes(draw): # https://github.com/data-apis/array-api-tests/array_api_tests/test_manipulation_functions.py @st.composite def reshape_shapes(draw, *, shape): - """Draws a random shape with the same number of elements as the given - shape. + """ + Draws a random shape with the same number of elements as the given shape. Parameters ---------- @@ -252,7 +254,8 @@ def reshape_shapes(draw, *, shape): # taken from https://github.com/HypothesisWorks/hypothesis/issues/1115 @st.composite def subsets(draw, *, elements): - """Draws a subset of elements from the given elements. + """ + Draws a subset of elements from the given elements. Parameters ---------- @@ -279,9 +282,10 @@ def get_shape( min_dim_size=1, max_dim_size=10, ): - """Draws a tuple of integers drawn randomly from [min_dim_size, - max_dim_size] of size drawn from min_num_dims to max_num_dims. Useful for - randomly drawing the shape of an array. + """ + Draws a tuple of integers drawn randomly from [min_dim_size, max_dim_size] of size + drawn from min_num_dims to max_num_dims. Useful for randomly drawing the shape of an + array. Parameters ---------- @@ -327,8 +331,9 @@ def get_shape( @st.composite def get_mean_std(draw, *, dtype): - """Draws two integers representing the mean and standard deviation for a - given data type. + """ + Draws two integers representing the mean and standard deviation for a given data + type. Parameters ---------- @@ -350,8 +355,8 @@ def get_mean_std(draw, *, dtype): @st.composite def get_bounds(draw, *, dtype): - """Draws two numbers; low and high, for a given data type such that low < - high. + """ + Draws two numbers; low and high, for a given data type such that low < high. Parameters ---------- @@ -397,7 +402,8 @@ def get_axis( force_tuple=False, force_int=False, ): - """Draws one or more axis for the given shape. + """ + Draws one or more axis for the given shape. Parameters ---------- @@ -511,7 +517,8 @@ def x_and_filters( depthwise=False, mixed_fn_compos=True, ): - """Draws a random x and filters for a convolution. + """ + Draws a random x and filters for a convolution. Parameters ---------- @@ -607,8 +614,8 @@ def x_and_filters( @st.composite def embedding_helper(draw, mixed_fn_compos=True): - """Obtain weights for embeddings, the corresponding indices, the padding - indices. + """ + Obtain weights for embeddings, the corresponding indices, the padding indices. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py index 71832e0cc3ff9..55e07e3dd7442 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py @@ -31,8 +31,9 @@ def floats( safety_factor_scale="linear", mixed_fn_compos=True, ): - """Draws an arbitrarily sized list of floats with a safety factor applied - to avoid values being generated at the edge of a dtype limit. + """ + Draws an arbitrarily sized list of floats with a safety factor applied to avoid + values being generated at the edge of a dtype limit. Parameters ---------- @@ -155,7 +156,8 @@ def ints( safety_factor_scale=None, mixed_fn_compos=True, ): - """Draws an integer with a safety factor if specified. + """ + Draws an integer with a safety factor if specified. Parameters ---------- @@ -219,7 +221,8 @@ def number( safety_factor_scale="linear", mixed_fn_compos=True, ): - """Draws integers or floats with a safety factor applied to values. + """ + Draws integers or floats with a safety factor applied to values. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index 6c76e6e9f645a..41b2e4d268b01 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -60,8 +60,9 @@ def _get_runtime_flag_value(flag): @st.composite def num_positional_args_method(draw, *, method): - """Draws an integers randomly from the minimum and maximum number of - positional arguments a given method can take. + """ + Draws an integers randomly from the minimum and maximum number of positional + arguments a given method can take. Parameters ---------- @@ -91,8 +92,9 @@ def num_positional_args_method(draw, *, method): @st.composite def num_positional_args(draw, *, fn_name: Optional[str] = None): - """Draws an integers randomly from the minimum and maximum number of - positional arguments a given function can take. + """ + Draws an integers randomly from the minimum and maximum number of positional + arguments a given function can take. Parameters ---------- @@ -157,7 +159,8 @@ def num_positional_args_helper(fn_name, backend): def _import_fn(fn_tree: str): - """Import a function from function tree string. + """ + Import a function from function tree string. Parameters ---------- @@ -207,7 +210,8 @@ def _get_method_supported_devices_dtypes_helper( def _get_method_supported_devices_dtypes( method_name: str, class_module: str, class_name: str ): - """Get supported devices and data types for a method in Ivy API. + """ + Get supported devices and data types for a method in Ivy API. Parameters ---------- @@ -273,7 +277,8 @@ def _get_supported_devices_dtypes_helper( def _get_supported_devices_dtypes(fn_name: str, fn_module: str): - """Get supported devices and data types for a function in Ivy API. + """ + Get supported devices and data types for a function in Ivy API. Parameters ---------- @@ -341,7 +346,8 @@ def handle_test( test_cython_wrapper=BuiltCythonWrapperStrategy, **_given_kwargs, ): - """Test wrapper for Ivy functions. + """ + Test wrapper for Ivy functions. The wrapper sets the required test globals and creates test flags strategies. @@ -484,7 +490,8 @@ def handle_frontend_test( precision_mode=BuiltPrecisionModeStrategy, **_given_kwargs, ): - """Test wrapper for Ivy frontend functions. + """ + Test wrapper for Ivy frontend functions. The wrapper sets the required test globals and creates test flags strategies. @@ -634,7 +641,8 @@ def handle_method( method_container_flags=BuiltContainerStrategy, **_given_kwargs, ): - """Test wrapper for Ivy methods. + """ + Test wrapper for Ivy methods. The wrapper sets the required test globals and creates test flags strategies. @@ -752,7 +760,8 @@ def handle_frontend_method( generate_frontend_arrays=BuiltFrontendArrayStrategy, **_given_kwargs, ): - """Test wrapper for Ivy frontends methods. + """ + Test wrapper for Ivy frontends methods. The wrapper sets the required test globals and creates test flags strategies. diff --git a/ivy_tests/test_ivy/test_frontends/__init__.py b/ivy_tests/test_ivy/test_frontends/__init__.py index e58ceb7d6761a..ebabc54c49ebc 100644 --- a/ivy_tests/test_ivy/test_frontends/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/__init__.py @@ -1,6 +1,6 @@ class NativeClass: - """An empty class to represent a class that only exist in a specific - framework. + """ + An empty class to represent a class that only exist in a specific framework. Attributes ---------- @@ -9,7 +9,8 @@ class NativeClass: """ def __init__(self, native_class): - """Construct the native class object. + """ + Construct the native class object. Parameters ---------- diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py index fb081e1cd406a..f367dadb14dbc 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py @@ -268,8 +268,8 @@ def test_jax_eig( ): dtype, x = dtype_and_x x = np.array(x[0], dtype=dtype[0]) - """Make symmetric positive-definite since ivy does not support complex data - dtypes currently.""" + """Make symmetric positive-definite since ivy does not support complex data dtypes + currently.""" x = np.matmul(x.T, x) + np.identity(x.shape[0]) * 1e-3 ret, frontend_ret = helpers.test_frontend_function( diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py b/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py index 6ede0631199e7..57785e80fa6bb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py @@ -6,8 +6,7 @@ def convnumpy(argument): - """Convert NativeClass in argument to ivy frontend counterpart for - numpy.""" + """Convert NativeClass in argument to ivy frontend counterpart for numpy.""" if isinstance(argument, NativeClass): return numpy_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py index d7287dc70ec57..878ed7e54c44d 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py @@ -27,8 +27,8 @@ def _array_and_axes_permute_helper( max_dim_size, allow_none=False, ): - """Return array, its dtype and either the random permutation of its axes or - None. + """ + Return array, its dtype and either the random permutation of its axes or None. Parameters ---------- @@ -276,8 +276,9 @@ def dtypes_values_casting_dtype( # ufunc num_positional_args helper @st.composite def get_num_positional_args_ufunc(draw, *, fn_name=None): - """Draws data randomly from numbers between nin and nargs where nin and - nargs are properties of the given ufunc. + """ + Draws data randomly from numbers between nin and nargs where nin and nargs are + properties of the given ufunc. Parameters ---------- diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py index 498c71af9b446..d4015efc19a21 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py @@ -41,8 +41,8 @@ def test_numpy_eig( ): dtype, x = dtype_and_x x = np.array(x[0], dtype=dtype[0]) - """Make symmetric positive-definite since ivy does not support complex data - dtypes currently.""" + """Make symmetric positive-definite since ivy does not support complex data dtypes + currently.""" x = np.matmul(x.T, x) + np.identity(x.shape[0]) * 1e-3 ret, frontend_ret = helpers.test_frontend_function( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py b/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py index 5b086cc0e5096..a2500afb3e86a 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py @@ -6,8 +6,7 @@ def convpaddle(argument): - """Convert NativeClass in argument to ivy frontend counter part for - paddle.""" + """Convert NativeClass in argument to ivy frontend counter part for paddle.""" if isinstance(argument, NativeClass): return paddle_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py b/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py index 85480fbc9a089..3b53dda915477 100644 --- a/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py @@ -5,8 +5,7 @@ def convscipy(argument): - """Convert NativeClass in argument to ivy frontend counterpart for - scipy.""" + """Convert NativeClass in argument to ivy frontend counterpart for scipy.""" if isinstance(argument, NativeClass): return scipy_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py index 2b7118d75a902..58227bfafc4e0 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py @@ -6,8 +6,7 @@ def convtensor(argument): - """Convert NativeClass in argument to ivy frontend counterpart for - tensorflow.""" + """Convert NativeClass in argument to ivy frontend counterpart for tensorflow.""" if isinstance(argument, NativeClass): return tensorflow_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index cb35f859a3cbe..101f6f349a4b7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -121,9 +121,8 @@ def _get_shared_dtype(draw): @st.composite def _get_splits(draw, as_list=False): - """Generate valid splits, either by generating an integer that evenly - divides the axis or a list of splits that sum to the length of the axis - being split.""" + """Generate valid splits, either by generating an integer that evenly divides the + axis or a list of splits that sum to the length of the axis being split.""" shape = draw(st.shared(helpers.get_shape(min_num_dims=1), key="value_shape")) axis = draw( st.shared(helpers.get_axis(shape=shape, force_int=True), key="target_axis") diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py b/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py index 3187545f1376e..aac6f175aa7c1 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py @@ -6,8 +6,7 @@ def convtorch(argument): - """Convert NativeClass in argument to ivy frontend counterpart for - torch.""" + """Convert NativeClass in argument to ivy frontend counterpart for torch.""" if isinstance(argument, NativeClass): return torch_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 3c8a75dbe9702..e0bbdb8e72e88 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -541,8 +541,7 @@ def test_torch_eigvals( test_values=False, ) """In "ret" we have out eigenvalues calculated with our backend and in - "frontend_ret" are our eigenvalues calculated with the specified - frontend.""" + "frontend_ret" are our eigenvalues calculated with the specified frontend.""" """ Depending on the chosen framework there may be small differences between our diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py index 6745c947a6d5e..e76b88adddc49 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py @@ -152,9 +152,8 @@ def _get_splits( allow_array_indices=True, is_mod_split=False, ): - """Generate valid splits, either by generating an integer that evenly - divides the axis or a list of splits that sum to the length of the axis - being split.""" + """Generate valid splits, either by generating an integer that evenly divides the + axis or a list of splits that sum to the length of the axis being split.""" shape = draw( st.shared(helpers.get_shape(min_num_dims=min_num_dims), key="value_shape") ) diff --git a/ivy_tests/test_ivy/test_misc/test_array.py b/ivy_tests/test_ivy/test_misc/test_array.py index 3098bceadf03c..12553cf4da570 100644 --- a/ivy_tests/test_ivy/test_misc/test_array.py +++ b/ivy_tests/test_ivy/test_misc/test_array.py @@ -2257,8 +2257,7 @@ def __ivy_array_function__(self, func, types, args, kwargs): return HANDLED_FUNCTIONS[func](*args, **kwargs) def implements(ivy_function): - """Register an __ivy_array_function__ implementation for MyArray - objects.""" + """Register an __ivy_array_function__ implementation for MyArray objects.""" def decorator(func): HANDLED_FUNCTIONS[ivy_function] = func diff --git a/scripts/eager_mode_benchmark/benchmark.py b/scripts/eager_mode_benchmark/benchmark.py index 77b839bc3f647..ba568a18de238 100644 --- a/scripts/eager_mode_benchmark/benchmark.py +++ b/scripts/eager_mode_benchmark/benchmark.py @@ -104,8 +104,9 @@ def eager_benchmark( kwargs: Optional[Dict[str, Any]] = None, output_path="./report.csv", ): - """Benchmark the function or module passed in input on the required - backends and devices. + """ + Benchmark the function or module passed in input on the required backends and + devices. Parameters ---------- @@ -279,7 +280,8 @@ def visualize_speed_up( backends: Union[List[str], str] = "all", labels: Optional[Union[List[str], str]] = None, ): - """Visualize the speed up results stored in the csv. + """ + Visualize the speed up results stored in the csv. Parameters ---------- From 207dec0cee120a5898749d7b3f7b984341fff313 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 5 Jan 2024 20:15:13 +0000 Subject: [PATCH 509/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/__init__.py | 27 +- ivy/compiler/compiler.py | 10 +- ivy/compiler/replace_with.py | 9 +- ivy/data_classes/array/activations.py | 55 +- ivy/data_classes/array/array.py | 126 +- ivy/data_classes/array/conversions.py | 44 +- ivy/data_classes/array/creation.py | 91 +- ivy/data_classes/array/data_type.py | 54 +- ivy/data_classes/array/device.py | 14 +- ivy/data_classes/array/elementwise.py | 520 ++++----- .../array/experimental/activations.py | 93 +- .../array/experimental/creation.py | 55 +- .../array/experimental/elementwise.py | 197 ++-- .../array/experimental/general.py | 7 +- ivy/data_classes/array/experimental/layers.py | 113 +- .../array/experimental/linear_algebra.py | 166 ++- ivy/data_classes/array/experimental/losses.py | 52 +- .../array/experimental/manipulation.py | 218 ++-- ivy/data_classes/array/experimental/norms.py | 30 +- ivy/data_classes/array/experimental/random.py | 21 +- .../array/experimental/searching.py | 7 +- .../array/experimental/sorting.py | 7 +- .../array/experimental/statistical.py | 91 +- .../array/experimental/utility.py | 9 +- ivy/data_classes/array/general.py | 227 ++-- ivy/data_classes/array/gradients.py | 50 +- ivy/data_classes/array/layers.py | 102 +- ivy/data_classes/array/linear_algebra.py | 116 +- ivy/data_classes/array/losses.py | 23 +- ivy/data_classes/array/manipulation.py | 112 +- ivy/data_classes/array/norms.py | 7 +- ivy/data_classes/array/random.py | 35 +- ivy/data_classes/array/searching.py | 35 +- ivy/data_classes/array/set.py | 21 +- ivy/data_classes/array/sorting.py | 24 +- ivy/data_classes/array/statistical.py | 59 +- ivy/data_classes/array/utility.py | 14 +- ivy/data_classes/array/wrapping.py | 13 +- ivy/data_classes/container/activations.py | 126 +- ivy/data_classes/container/base.py | 356 +++--- ivy/data_classes/container/container.py | 95 +- ivy/data_classes/container/conversions.py | 15 +- ivy/data_classes/container/creation.py | 91 +- ivy/data_classes/container/data_type.py | 117 +- ivy/data_classes/container/device.py | 28 +- ivy/data_classes/container/elementwise.py | 1040 +++++++---------- .../container/experimental/activations.py | 184 ++- .../container/experimental/creation.py | 171 ++- .../container/experimental/elementwise.py | 373 +++--- .../container/experimental/general.py | 14 +- .../container/experimental/layers.py | 237 ++-- .../container/experimental/linear_algebra.py | 299 +++-- .../container/experimental/losses.py | 114 +- .../container/experimental/manipulation.py | 407 +++---- .../container/experimental/norms.py | 84 +- .../container/experimental/random.py | 56 +- .../container/experimental/searching.py | 14 +- .../container/experimental/sorting.py | 20 +- .../container/experimental/statistical.py | 182 ++- .../container/experimental/utility.py | 16 +- ivy/data_classes/container/general.py | 430 +++---- ivy/data_classes/container/gradients.py | 52 +- ivy/data_classes/container/layers.py | 200 ++-- ivy/data_classes/container/linear_algebra.py | 261 ++--- ivy/data_classes/container/losses.py | 46 +- ivy/data_classes/container/manipulation.py | 216 ++-- ivy/data_classes/container/norms.py | 7 +- ivy/data_classes/container/random.py | 70 +- ivy/data_classes/container/searching.py | 70 +- ivy/data_classes/container/set.py | 47 +- ivy/data_classes/container/sorting.py | 48 +- ivy/data_classes/container/statistical.py | 91 +- ivy/data_classes/container/utility.py | 28 +- ivy/data_classes/container/wrapping.py | 8 +- .../factorized_tensor/cp_tensor.py | 54 +- .../factorized_tensor/parafac2_tensor.py | 34 +- .../factorized_tensor/tt_tensor.py | 25 +- ivy/func_wrapper.py | 121 +- ivy/functional/backends/jax/activations.py | 3 +- ivy/functional/backends/jax/device.py | 3 +- ivy/functional/backends/jax/general.py | 3 +- ivy/functional/backends/jax/gradients.py | 3 +- ivy/functional/backends/jax/layers.py | 3 +- ivy/functional/backends/jax/random.py | 3 +- ivy/functional/backends/mxnet/activations.py | 3 +- ivy/functional/backends/mxnet/device.py | 3 +- ivy/functional/backends/mxnet/gradients.py | 3 +- ivy/functional/backends/mxnet/layers.py | 3 +- ivy/functional/backends/mxnet/random.py | 3 +- ivy/functional/backends/numpy/activations.py | 3 +- ivy/functional/backends/numpy/device.py | 3 +- ivy/functional/backends/numpy/general.py | 3 +- ivy/functional/backends/numpy/gradients.py | 3 +- ivy/functional/backends/numpy/helpers.py | 3 +- ivy/functional/backends/numpy/layers.py | 3 +- ivy/functional/backends/numpy/random.py | 3 +- ivy/functional/backends/paddle/activations.py | 3 +- ivy/functional/backends/paddle/device.py | 3 +- .../paddle/experimental/elementwise.py | 3 +- ivy/functional/backends/paddle/general.py | 3 +- ivy/functional/backends/paddle/gradients.py | 3 +- ivy/functional/backends/paddle/layers.py | 3 +- ivy/functional/backends/paddle/random.py | 3 +- .../backends/tensorflow/activations.py | 3 +- ivy/functional/backends/tensorflow/device.py | 3 +- ivy/functional/backends/tensorflow/general.py | 3 +- .../backends/tensorflow/gradients.py | 3 +- ivy/functional/backends/tensorflow/layers.py | 3 +- ivy/functional/backends/tensorflow/random.py | 3 +- .../experimental/statistical.py | 5 +- ivy/functional/backends/torch/activations.py | 3 +- ivy/functional/backends/torch/device.py | 3 +- ivy/functional/backends/torch/general.py | 3 +- ivy/functional/backends/torch/gradients.py | 3 +- ivy/functional/backends/torch/layers.py | 3 +- ivy/functional/backends/torch/random.py | 3 +- .../frontends/jax/numpy/__init__.py | 9 +- .../mindspore/ops/function/nn_func.py | 4 +- .../frontends/mxnet/func_wrapper.py | 9 +- .../frontends/mxnet/numpy/__init__.py | 9 +- ivy/functional/frontends/numpy/__init__.py | 5 +- .../frontends/numpy/func_wrapper.py | 28 +- .../numpy/statistics/order_statistics.py | 3 +- ivy/functional/frontends/onnx/__init__.py | 9 +- ivy/functional/frontends/onnx/func_wrapper.py | 9 +- ivy/functional/frontends/paddle/__init__.py | 9 +- ivy/functional/frontends/paddle/fft.py | 4 +- .../frontends/paddle/func_wrapper.py | 9 +- .../frontends/tensorflow/__init__.py | 7 +- .../frontends/tensorflow/func_wrapper.py | 23 +- .../frontends/tensorflow/variable.py | 6 +- ivy/functional/frontends/torch/__init__.py | 9 +- .../frontends/torch/func_wrapper.py | 12 +- ivy/functional/frontends/torch/tensor.py | 3 +- ivy/functional/frontends/xgboost/core.py | 14 +- .../xgboost/linear/updater_coordinate.py | 18 +- ivy/functional/frontends/xgboost/sklearn.py | 8 +- ivy/functional/frontends/xgboost/training.py | 3 +- ivy/functional/ivy/activations.py | 30 +- ivy/functional/ivy/control_flow_ops.py | 18 +- ivy/functional/ivy/creation.py | 133 +-- ivy/functional/ivy/data_type.py | 136 +-- ivy/functional/ivy/device.py | 136 +-- ivy/functional/ivy/elementwise.py | 435 +++---- .../ivy/experimental/activations.py | 47 +- ivy/functional/ivy/experimental/creation.py | 107 +- .../ivy/experimental/elementwise.py | 116 +- ivy/functional/ivy/experimental/general.py | 4 +- ivy/functional/ivy/experimental/gradients.py | 9 +- ivy/functional/ivy/experimental/layers.py | 119 +- .../ivy/experimental/linear_algebra.py | 108 +- ivy/functional/ivy/experimental/losses.py | 37 +- .../ivy/experimental/manipulation.py | 162 ++- ivy/functional/ivy/experimental/norms.py | 14 +- ivy/functional/ivy/experimental/random.py | 25 +- ivy/functional/ivy/experimental/searching.py | 4 +- ivy/functional/ivy/experimental/sorting.py | 13 +- .../ivy/experimental/statistical.py | 45 +- ivy/functional/ivy/experimental/utility.py | 9 +- ivy/functional/ivy/general.py | 288 ++--- ivy/functional/ivy/gradients.py | 74 +- ivy/functional/ivy/layers.py | 86 +- ivy/functional/ivy/linear_algebra.py | 120 +- ivy/functional/ivy/losses.py | 9 +- ivy/functional/ivy/manipulation.py | 57 +- ivy/functional/ivy/meta.py | 12 +- ivy/functional/ivy/nest.py | 79 +- ivy/functional/ivy/norms.py | 3 +- ivy/functional/ivy/random.py | 31 +- ivy/functional/ivy/searching.py | 23 +- ivy/functional/ivy/set.py | 21 +- ivy/functional/ivy/sorting.py | 12 +- ivy/functional/ivy/statistical.py | 32 +- ivy/functional/ivy/utility.py | 8 +- ivy/stateful/activations.py | 39 +- ivy/stateful/converters.py | 24 +- ivy/stateful/helpers.py | 41 +- ivy/stateful/initializers.py | 41 +- ivy/stateful/layers.py | 200 ++-- ivy/stateful/losses.py | 6 +- ivy/stateful/module.py | 50 +- ivy/stateful/norms.py | 12 +- ivy/stateful/optimizers.py | 72 +- ivy/stateful/sequential.py | 8 +- ivy/utils/_importlib.py | 3 +- ivy/utils/backend/ast_helpers.py | 3 +- ivy/utils/backend/handler.py | 40 +- ivy/utils/einsum_parser.py | 33 +- ivy/utils/einsum_path_helpers.py | 47 +- ivy/utils/exceptions.py | 12 +- ivy/utils/inspection.py | 5 +- ivy/utils/logging.py | 6 +- ivy/utils/profiler.py | 3 +- ivy_tests/test_docstrings.py | 3 +- ivy_tests/test_ivy/helpers/assertions.py | 28 +- .../test_ivy/helpers/function_testing.py | 37 +- ivy_tests/test_ivy/helpers/globals.py | 8 +- .../hypothesis_helpers/array_helpers.py | 62 +- .../hypothesis_helpers/dtype_helpers.py | 14 +- .../hypothesis_helpers/general_helpers.py | 39 +- .../hypothesis_helpers/number_helpers.py | 11 +- ivy_tests/test_ivy/helpers/testing_helpers.py | 31 +- ivy_tests/test_ivy/test_frontends/__init__.py | 7 +- .../test_jax/test_numpy/test_linalg.py | 4 +- .../test_frontends/test_numpy/__init__.py | 3 +- .../test_frontends/test_numpy/helpers.py | 9 +- .../test_linalg/test_matrix_eigenvalues.py | 4 +- .../test_frontends/test_paddle/__init__.py | 3 +- .../test_frontends/test_scipy/__init__.py | 3 +- .../test_tensorflow/__init__.py | 3 +- .../test_tensorflow/test_raw_ops.py | 5 +- .../test_frontends/test_torch/__init__.py | 3 +- .../test_frontends/test_torch/test_linalg.py | 3 +- .../test_core/test_manipulation.py | 5 +- ivy_tests/test_ivy/test_misc/test_array.py | 3 +- scripts/eager_mode_benchmark/benchmark.py | 8 +- 216 files changed, 5290 insertions(+), 7240 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index a748c51e37c44..620bc5860fbd5 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -1016,8 +1016,7 @@ def vec_sig_fig(x, sig_fig=3): def set_array_significant_figures(sig_figs): - """ - Summary. + """Summary. Parameters ---------- @@ -1057,8 +1056,7 @@ def _assert_array_decimal_values_formatting(dec_vals): def set_array_decimal_values(dec_vals): - """ - Summary. + """Summary. Parameters ---------- @@ -1084,8 +1082,7 @@ def unset_array_decimal_values(): def set_warning_level(warn_level): - """ - Summary. + """Summary. Parameters ---------- @@ -1117,8 +1114,7 @@ def warn(warning_message, stacklevel=0): def set_nan_policy(warn_level): - """ - Summary. + """Summary. Parameters ---------- @@ -1151,7 +1147,8 @@ def unset_nan_policy(): def set_dynamic_backend(flag): # noqa: D209 - """Set the global dynamic backend setting to the provided flag (True or False)""" + """Set the global dynamic backend setting to the provided flag (True or + False)""" global dynamic_backend_stack if flag not in [True, False]: raise ValueError("dynamic_backend must be a boolean value (True or False)") @@ -1160,8 +1157,7 @@ def set_dynamic_backend(flag): # noqa: D209 def unset_dynamic_backend(): - """ - Remove the current dynamic backend setting. + """Remove the current dynamic backend setting. Also restore the previous setting (if any) """ @@ -1179,8 +1175,7 @@ def unset_dynamic_backend(): @handle_exceptions def set_cython_wrappers_mode(flag: bool = True) -> None: - """ - Set the mode of whether to use cython wrappers for functions. + """Set the mode of whether to use cython wrappers for functions. Parameter --------- @@ -1506,8 +1501,7 @@ def __init__(self): self.logging_mode_stack.append(logging.WARNING) def set_logging_mode(self, mode): - """ - Set the current logging mode for Ivy. + """Set the current logging mode for Ivy. Possible modes are 'DEBUG', 'INFO', 'WARNING', 'ERROR'. """ @@ -1520,7 +1514,8 @@ def set_logging_mode(self, mode): self.logging_mode_stack.append(mode) def unset_logging_mode(self): # noqa: D209 - """Remove the most recently set logging mode, returning to the previous one.""" + """Remove the most recently set logging mode, returning to the previous + one.""" if len(self.logging_mode_stack) > 1: # Remove the current mode self.logging_mode_stack.pop() diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 083e4da28e1d3..535e749daff4b 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,8 @@ def trace_graph( params_v=None, v=None ): - """ - Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -137,9 +137,9 @@ def transpile( params_v=None, v=None ): - """ - Transpiles Callable objects passed as arguments. If args and kwargs are specified, - transpilation is performed eagerly, otherwise, transpilation will happen lazily. + """Transpiles Callable objects passed as arguments. If args and kwargs are + specified, transpilation is performed eagerly, otherwise, transpilation + will happen lazily. Parameters ---------- diff --git a/ivy/compiler/replace_with.py b/ivy/compiler/replace_with.py index 51af07f192249..2bfdd8140b7b5 100644 --- a/ivy/compiler/replace_with.py +++ b/ivy/compiler/replace_with.py @@ -6,8 +6,7 @@ def replace_with(new_func): - """ - Decorate a function/method/attribute to be replaced by another. + """Decorate a function/method/attribute to be replaced by another. Parameters ---------- @@ -43,7 +42,8 @@ def decorator(original_func): class ReplaceFunction(ast.NodeTransformer): - """AST Node Transformer to replace function calls, methods, and attributes.""" + """AST Node Transformer to replace function calls, methods, and + attributes.""" def visit_Attribute(self, node): if ( @@ -69,7 +69,8 @@ def visit_Call(self, node): def transform_function(func): - """Transform the function by replacing its calls based on the replace_map.""" + """Transform the function by replacing its calls based on the + replace_map.""" source = inspect.getsource(func) tree = ast.parse(source) transformed_tree = ReplaceFunction().visit(tree) diff --git a/ivy/data_classes/array/activations.py b/ivy/data_classes/array/activations.py index 950dd0512b6f7..6fcdafe056a19 100644 --- a/ivy/data_classes/array/activations.py +++ b/ivy/data_classes/array/activations.py @@ -17,10 +17,9 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.relu. This method simply wraps the - function, and so the docstring for ivy.relu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.relu. This method simply + wraps the function, and so the docstring for ivy.relu also applies to + this method with minimal changes. Parameters ---------- @@ -55,10 +54,9 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.leaky_relu. This method simply wraps - the function, and so the docstring for ivy.leaky_relu also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.leaky_relu. This method + simply wraps the function, and so the docstring for ivy.leaky_relu also + applies to this method with minimal changes. Parameters ---------- @@ -97,10 +95,9 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gelu. This method simply wraps the - function, and so the docstring for ivy.gelu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.gelu. This method simply + wraps the function, and so the docstring for ivy.gelu also applies to + this method with minimal changes. Parameters ---------- @@ -138,8 +135,7 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sigmoid. + """ivy.Array instance method variant of ivy.sigmoid. This method simply wraps the function, and so the docstring for ivy.sigmoid also applies to this method with minimal changes. @@ -178,10 +174,9 @@ def softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.softmax. This method simply wraps the - function, and so the docstring for ivy.softmax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.softmax. This method simply + wraps the function, and so the docstring for ivy.softmax also applies + to this method with minimal changes. Parameters ---------- @@ -219,10 +214,9 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.softplus. This method simply wraps the - function, and so the docstring for ivy.softplus also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.softplus. This method + simply wraps the function, and so the docstring for ivy.softplus also + applies to this method with minimal changes. Parameters ---------- @@ -276,10 +270,9 @@ def log_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log_softmax. This method simply wraps - the function, and so the docstring for ivy.log_softmax also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.log_softmax. This method + simply wraps the function, and so the docstring for ivy.log_softmax + also applies to this method with minimal changes. Parameters ---------- @@ -324,10 +317,9 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.mish. This method simply wraps the - function, and so the docstring for ivy.mish also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.mish. This method simply + wraps the function, and so the docstring for ivy.mish also applies to + this method with minimal changes. Parameters ---------- @@ -356,8 +348,7 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the hardswish activation function element-wise. + """Apply the hardswish activation function element-wise. Parameters ---------- diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index eb76a03676aab..7794ebee4d7d9 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -232,8 +232,7 @@ def device(self) -> ivy.Device: @property def mT(self) -> ivy.Array: - """ - Transpose of a matrix (or a stack of matrices). + """Transpose of a matrix (or a stack of matrices). Returns ------- @@ -290,8 +289,7 @@ def strides(self) -> Optional[int]: @property def T(self) -> ivy.Array: - """ - Transpose of the array. + """Transpose of the array. Returns ------- @@ -309,8 +307,7 @@ def base(self) -> ivy.Array: @property def real(self) -> ivy.Array: - """ - Real part of the array. + """Real part of the array. Returns ------- @@ -323,8 +320,7 @@ def real(self) -> ivy.Array: @property def imag(self) -> ivy.Array: - """ - Imaginary part of the array. + """Imaginary part of the array. Returns ------- @@ -485,10 +481,9 @@ def __neg__(self): return ivy.negative(self._data) def __pow__(self, power): - """ - ivy.Array special method variant of ivy.pow. This method simply wraps the - function, and so the docstring for ivy.pow also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.pow. This method simply + wraps the function, and so the docstring for ivy.pow also applies to + this method with minimal changes. Parameters ---------- @@ -527,10 +522,9 @@ def __ipow__(self, power): return ivy.pow(self._data, power) def __add__(self, other): - """ - ivy.Array special method variant of ivy.add. This method simply wraps the - function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.add. This method simply + wraps the function, and so the docstring for ivy.add also applies to + this method with minimal changes. Parameters ---------- @@ -557,10 +551,9 @@ def __add__(self, other): return ivy.add(self._data, other) def __radd__(self, other): - """ - ivy.Array reverse special method variant of ivy.add. This method simply wraps - the function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Array reverse special method variant of ivy.add. This method + simply wraps the function, and so the docstring for ivy.add also + applies to this method with minimal changes. Parameters ---------- @@ -590,10 +583,9 @@ def __iadd__(self, other): return ivy.add(self._data, other) def __sub__(self, other): - """ - ivy.Array special method variant of ivy.subtract. This method simply wraps the - function, and so the docstring for ivy.subtract also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.subtract. This method simply + wraps the function, and so the docstring for ivy.subtract also applies + to this method with minimal changes. Parameters ---------- @@ -622,10 +614,9 @@ def __sub__(self, other): return ivy.subtract(self._data, other) def __rsub__(self, other): - """ - ivy.Array reverse special method variant of ivy.subtract. This method simply - wraps the function, and so the docstring for ivy.subtract also applies to this - method with minimal changes. + """ivy.Array reverse special method variant of ivy.subtract. This + method simply wraps the function, and so the docstring for ivy.subtract + also applies to this method with minimal changes. Parameters ---------- @@ -679,10 +670,9 @@ def __rdivmod__(self, other): return ivy.divide(other, self._data), ivy.remainder(other, self._data) def __truediv__(self, other): - """ - ivy.Array reverse special method variant of ivy.divide. This method simply wraps - the function, and so the docstring for ivy.divide also applies to this method - with minimal changes. + """ivy.Array reverse special method variant of ivy.divide. This method + simply wraps the function, and so the docstring for ivy.divide also + applies to this method with minimal changes. Parameters ---------- @@ -733,10 +723,9 @@ def __imatmul__(self, other): return ivy.matmul(self._data, other) def __abs__(self): - """ - ivy.Array special method variant of ivy.abs. This method simply wraps the - function, and so the docstring for ivy.abs also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.abs. This method simply + wraps the function, and so the docstring for ivy.abs also applies to + this method with minimal changes. Parameters ---------- @@ -809,10 +798,9 @@ def __dlpack_device__(self): return self._data.__dlpack_device__() def __lt__(self, other): - """ - ivy.Array special method variant of ivy.less. This method simply wraps the - function, and so the docstring for ivy.less also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.less. This method simply + wraps the function, and so the docstring for ivy.less also applies to + this method with minimal changes. Parameters ---------- @@ -839,10 +827,9 @@ def __lt__(self, other): return ivy.less(self._data, other) def __le__(self, other): - """ - ivy.Array special method variant of ivy.less_equal. This method simply wraps the - function, and so the docstring for ivy.less_equal also applies to this method - with minimal changes. + """ivy.Array special method variant of ivy.less_equal. This method + simply wraps the function, and so the docstring for ivy.less_equal also + applies to this method with minimal changes. Parameters ---------- @@ -869,10 +856,9 @@ def __le__(self, other): return ivy.less_equal(self._data, other) def __eq__(self, other): - """ - ivy.Array special method variant of ivy.equal. This method simply wraps the - function, and so the docstring for ivy.equal also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.equal. This method simply + wraps the function, and so the docstring for ivy.equal also applies to + this method with minimal changes. Parameters ---------- @@ -907,10 +893,9 @@ def __eq__(self, other): return ivy.equal(self._data, other) def __ne__(self, other): - """ - ivy.Array special method variant of ivy.not_equal. This method simply wraps the - function, and so the docstring for ivy.not_equal also applies to this method - with minimal changes. + """ivy.Array special method variant of ivy.not_equal. This method + simply wraps the function, and so the docstring for ivy.not_equal also + applies to this method with minimal changes. Parameters ---------- @@ -945,10 +930,9 @@ def __ne__(self, other): return ivy.not_equal(self._data, other) def __gt__(self, other): - """ - ivy.Array special method variant of ivy.greater. This method simply wraps the - function, and so the docstring for ivy.greater also applies to this method with - minimal changes. + """ivy.Array special method variant of ivy.greater. This method simply + wraps the function, and so the docstring for ivy.greater also applies + to this method with minimal changes. Parameters ---------- @@ -992,10 +976,9 @@ def __gt__(self, other): return ivy.greater(self._data, other) def __ge__(self, other): - """ - ivy.Array special method variant of ivy.greater_equal. This method simply wraps - the function, and so the docstring for ivy.bitwise_xor also applies to this - method with minimal changes. + """ivy.Array special method variant of ivy.greater_equal. This method + simply wraps the function, and so the docstring for ivy.bitwise_xor + also applies to this method with minimal changes. Parameters ---------- @@ -1060,10 +1043,9 @@ def __invert__(self): return ivy.bitwise_invert(self._data) def __xor__(self, other): - """ - ivy.Array special method variant of ivy.bitwise_xor. This method simply wraps - the function, and so the docstring for ivy.bitwise_xor also applies to this - method with minimal changes. + """ivy.Array special method variant of ivy.bitwise_xor. This method + simply wraps the function, and so the docstring for ivy.bitwise_xor + also applies to this method with minimal changes. Parameters ---------- @@ -1118,10 +1100,10 @@ def __ilshift__(self, other): return ivy.bitwise_left_shift(self._data, other) def __rshift__(self, other): - """ - ivy.Array special method variant of ivy.bitwise_right_shift. This method simply - wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Array special method variant of ivy.bitwise_right_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- @@ -1151,10 +1133,10 @@ def __rshift__(self, other): return ivy.bitwise_right_shift(self._data, other) def __rrshift__(self, other): - """ - ivy.Array reverse special method variant of ivy.bitwise_right_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Array reverse special method variant of ivy.bitwise_right_shift. + This method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/array/conversions.py b/ivy/data_classes/array/conversions.py index 988286408e763..67898f34951cd 100644 --- a/ivy/data_classes/array/conversions.py +++ b/ivy/data_classes/array/conversions.py @@ -1,5 +1,4 @@ -""" -Ivy wrapping functions for conversions. +"""Ivy wrapping functions for conversions. Collection of Ivy functions for wrapping functions to accept and return ivy.Array instances. @@ -141,10 +140,10 @@ def to_ivy( nested: bool = False, include_derived: Optional[Dict[str, bool]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """ - Return the input array converted to an ivy.Array instance if it is a native array - type, otherwise the input is returned unchanged. If nested is set, the check is - applied to all nested leafs of tuples, lists and dicts contained within x. + """Return the input array converted to an ivy.Array instance if it is a + native array type, otherwise the input is returned unchanged. If nested is + set, the check is applied to all nested leafs of tuples, lists and dicts + contained within x. Parameters ---------- @@ -173,9 +172,8 @@ def args_to_ivy( include_derived: Optional[Dict[str, bool]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """ - Return args and keyword args in their ivy.Array or form for all nested instances, - otherwise the arguments are returned unchanged. + """Return args and keyword args in their ivy.Array or form for all nested + instances, otherwise the arguments are returned unchanged. Parameters ---------- @@ -205,10 +203,10 @@ def to_native( cont_inplace: bool = False, to_ignore: Optional[Union[type, Tuple[type]]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """ - Return the input item in its native backend framework form if it is an ivy.Array - instance, otherwise the input is returned unchanged. If nested is set, the check is - applied to all nested leaves of tuples, lists and dicts contained within ``x``. + """Return the input item in its native backend framework form if it is an + ivy.Array instance, otherwise the input is returned unchanged. If nested is + set, the check is applied to all nested leaves of tuples, lists and dicts + contained within ``x``. Parameters ---------- @@ -248,9 +246,9 @@ def args_to_native( to_ignore: Optional[Union[type, Tuple[type]]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """ - Return args and keyword args in their native backend framework form for all nested - ivy.Array instances, otherwise the arguments are returned unchanged. + """Return args and keyword args in their native backend framework form for + all nested ivy.Array instances, otherwise the arguments are returned + unchanged. Parameters ---------- @@ -296,11 +294,10 @@ def to_new_backend( cont_inplace: bool = False, to_ignore: Optional[Union[type, Tuple[type]]] = None, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """ - Return the input array converted to new backend framework form if it is an - `ivy.Array`, `ivy.NativeArray` or NativeVariable instance. If nested is set, the - check is applied to all nested leaves of tuples, lists and dicts contained within - ``x``. + """Return the input array converted to new backend framework form if it is + an `ivy.Array`, `ivy.NativeArray` or NativeVariable instance. If nested is + set, the check is applied to all nested leaves of tuples, lists and dicts + contained within ``x``. Parameters ---------- @@ -347,9 +344,8 @@ def args_to_new_backend( to_ignore: Optional[Union[type, Tuple[type]]] = None, **kwargs: Dict[str, Any], ) -> Tuple[Iterable[Any], Dict[str, Any]]: - """ - Return args and keyword args in the new current backend framework for all nested - ivy.Array, ivy.NativeArray or NativeVariable instances. + """Return args and keyword args in the new current backend framework for + all nested ivy.Array, ivy.NativeArray or NativeVariable instances. Parameters ---------- diff --git a/ivy/data_classes/array/creation.py b/ivy/data_classes/array/creation.py index 94e2ab7a096d3..6486096f38b13 100644 --- a/ivy/data_classes/array/creation.py +++ b/ivy/data_classes/array/creation.py @@ -21,10 +21,9 @@ def asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.asarray. This method simply wraps the - function, and so the docstring for ivy.asarray also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.asarray. This method simply + wraps the function, and so the docstring for ivy.asarray also applies + to this method with minimal changes. Parameters ---------- @@ -87,10 +86,9 @@ def full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.full_like. This method simply wraps the - function, and so the docstring for ivy.full_like also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.full_like. This method + simply wraps the function, and so the docstring for ivy.full_like also + applies to this method with minimal changes. Parameters ---------- @@ -151,10 +149,9 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ones_like. This method simply wraps the - function, and so the docstring for ivy.ones_like also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.ones_like. This method + simply wraps the function, and so the docstring for ivy.ones_like also + applies to this method with minimal changes. Parameters ---------- @@ -185,10 +182,9 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.zeros_like. This method simply wraps - the function, and so the docstring for ivy.zeros_like also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.zeros_like. This method + simply wraps the function, and so the docstring for ivy.zeros_like also + applies to this method with minimal changes. Parameters ---------- @@ -214,10 +210,9 @@ def zeros_like( def tril( self: ivy.Array, /, *, k: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tril. This method simply wraps the - function, and so the docstring for ivy.tril also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tril. This method simply + wraps the function, and so the docstring for ivy.tril also applies to + this method with minimal changes. Parameters ---------- @@ -245,10 +240,9 @@ def tril( def triu( self: ivy.Array, /, *, k: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.triu. This method simply wraps the - function, and so the docstring for ivy.triu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.triu. This method simply + wraps the function, and so the docstring for ivy.triu also applies to + this method with minimal changes. Parameters ---------- @@ -281,10 +275,9 @@ def empty_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.empty_like. This method simply wraps - the function, and so the docstring for ivy.empty_like also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.empty_like. This method + simply wraps the function, and so the docstring for ivy.empty_like also + applies to this method with minimal changes. Parameters ---------- @@ -315,10 +308,9 @@ def meshgrid( sparse: bool = False, indexing: str = "xy", ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.meshgrid. This method simply wraps the - function, and so the docstring for ivy.meshgrid also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.meshgrid. This method + simply wraps the function, and so the docstring for ivy.meshgrid also + applies to this method with minimal changes. Parameters ---------- @@ -351,10 +343,9 @@ def from_dlpack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.from_dlpack. This method simply wraps - the function, and so the docstring for ivy.from_dlpack also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.from_dlpack. This method + simply wraps the function, and so the docstring for ivy.from_dlpack + also applies to this method with minimal changes. Parameters ---------- @@ -381,10 +372,9 @@ def copy_array( to_ivy_array: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.copy_array. This method simply wraps - the function, and so the docstring for ivy.copy_array also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.copy_array. This method + simply wraps the function, and so the docstring for ivy.copy_array also + applies to this method with minimal changes. Parameters ---------- @@ -412,10 +402,9 @@ def native_array( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.NativeArray: - """ - ivy.Array instance method variant of ivy.native_array. This method simply wraps - the function, and so the docstring for ivy.native_array also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.native_array. This method + simply wraps the function, and so the docstring for ivy.native_array + also applies to this method with minimal changes. Parameters ---------- @@ -445,10 +434,9 @@ def one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.one_hot. This method simply wraps the - function, and so the docstring for ivy.one_hot also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.one_hot. This method simply + wraps the function, and so the docstring for ivy.one_hot also applies + to this method with minimal changes. Parameters ---------- @@ -549,10 +537,9 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logspace. This method simply wraps the - function, and so the docstring for ivy.logspace also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.logspace. This method + simply wraps the function, and so the docstring for ivy.logspace also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/data_type.py b/ivy/data_classes/array/data_type.py index 01cdedea04c58..afaaade47303c 100644 --- a/ivy/data_classes/array/data_type.py +++ b/ivy/data_classes/array/data_type.py @@ -18,9 +18,8 @@ def astype( copy: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Copy an array to a specified data type irrespective of :ref:`type- promotion` - rules. + """Copy an array to a specified data type irrespective of :ref:`type- + promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -69,10 +68,10 @@ def astype( def broadcast_arrays( self: ivy.Array, *arrays: Union[ivy.Array, ivy.NativeArray] ) -> List[ivy.Array]: - """ - `ivy.Array` instance method variant of `ivy.broadcast_arrays`. This method - simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also - applies to this method with minimal changes. + """`ivy.Array` instance method variant of `ivy.broadcast_arrays`. This + method simply wraps the function, and so the docstring for + `ivy.broadcast_arrays` also applies to this method with minimal + changes. Parameters ---------- @@ -113,10 +112,9 @@ def broadcast_arrays( def broadcast_to( self: ivy.Array, /, shape: Tuple[int, ...], *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - `ivy.Array` instance method variant of `ivy.broadcast_to`. This method simply - wraps the function, and so the docstring for `ivy.broadcast_to` also applies to - this method with minimal changes. + """`ivy.Array` instance method variant of `ivy.broadcast_to`. This + method simply wraps the function, and so the docstring for + `ivy.broadcast_to` also applies to this method with minimal changes. Parameters ---------- @@ -146,10 +144,9 @@ def broadcast_to( return ivy.broadcast_to(self._data, shape=shape, out=out) def can_cast(self: ivy.Array, to: ivy.Dtype) -> bool: - """ - `ivy.Array` instance method variant of `ivy.can_cast`. This method simply wraps - the function, and so the docstring for `ivy.can_cast` also applies to this - method with minimal changes. + """`ivy.Array` instance method variant of `ivy.can_cast`. This method + simply wraps the function, and so the docstring for `ivy.can_cast` also + applies to this method with minimal changes. Parameters ---------- @@ -179,9 +176,8 @@ def can_cast(self: ivy.Array, to: ivy.Dtype) -> bool: def dtype( self: ivy.Array, as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """ - `ivy.Array` instance method variant of `ivy.dtype`. This method helps to get the - data type of the array. + """`ivy.Array` instance method variant of `ivy.dtype`. This method + helps to get the data type of the array. Parameters ---------- @@ -212,8 +208,7 @@ def dtype( return ivy.dtype(self._data, as_native=as_native) def finfo(self: ivy.Array, /) -> Finfo: - """ - Array instance method variant of `ivy.finfo`. + """Array instance method variant of `ivy.finfo`. Parameters ---------- @@ -235,10 +230,9 @@ def finfo(self: ivy.Array, /) -> Finfo: return ivy.finfo(self._data) def iinfo(self: ivy.Array, /) -> Iinfo: - """ - `ivy.Array` instance method variant of `ivy.iinfo`. This method simply wraps the - function, and so the docstring for `ivy.iinfo` also applies to this method with - minimal changes. + """`ivy.Array` instance method variant of `ivy.iinfo`. This method + simply wraps the function, and so the docstring for `ivy.iinfo` also + applies to this method with minimal changes. Parameters ---------- @@ -267,9 +261,8 @@ def is_bool_dtype(self: ivy.Array) -> bool: return ivy.is_bool_dtype(self._data) def is_float_dtype(self: ivy.Array) -> bool: - """ - `ivy.Array` instance method variant of `ivy.is_float_dtype`. This method simply - checks to see if the array is of type `float`. + """`ivy.Array` instance method variant of `ivy.is_float_dtype`. This + method simply checks to see if the array is of type `float`. Parameters ---------- @@ -303,10 +296,9 @@ def result_type( self: ivy.Array, *arrays_and_dtypes: Union[ivy.Array, ivy.NativeArray, ivy.Dtype], ) -> ivy.Dtype: - """ - `ivy.Array` instance method variant of `ivy.result_type`. This method simply - wraps the function, and so the docstring for `ivy.result_type` also applies to - this method with minimal changes. + """`ivy.Array` instance method variant of `ivy.result_type`. This + method simply wraps the function, and so the docstring for + `ivy.result_type` also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/device.py b/ivy/data_classes/array/device.py index f0eb01d3b048f..18ac9887abd27 100644 --- a/ivy/data_classes/array/device.py +++ b/ivy/data_classes/array/device.py @@ -12,10 +12,9 @@ class _ArrayWithDevice(abc.ABC): def dev( self: ivy.Array, *, as_native: bool = False ) -> Union[ivy.Device, ivy.NativeDevice]: - """ - ivy.Array instance method variant of ivy.dev. This method simply wraps the - function, and so the docstring for ivy.dev also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dev. This method simply + wraps the function, and so the docstring for ivy.dev also applies to + this method with minimal changes. Parameters ---------- @@ -40,10 +39,9 @@ def to_device( stream: Optional[Union[int, Any]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.to_device. This method simply wraps the - function, and so the docstring for ivy.to_device also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.to_device. This method + simply wraps the function, and so the docstring for ivy.to_device also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/elementwise.py b/ivy/data_classes/array/elementwise.py index f33601eac27da..b8de2d75e91ad 100644 --- a/ivy/data_classes/array/elementwise.py +++ b/ivy/data_classes/array/elementwise.py @@ -14,10 +14,9 @@ def abs( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: # noqa - """ - ivy.Array instance method variant of ivy.abs. This method simply wraps the - function, and so the docstring for ivy.abs also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.abs. This method simply + wraps the function, and so the docstring for ivy.abs also applies to + this method with minimal changes. Parameters ---------- @@ -43,10 +42,9 @@ def abs( return ivy.abs(self, out=out) def acosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.acosh. This method simply wraps the - function, and so the docstring for ivy.acosh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.acosh. This method simply + wraps the function, and so the docstring for ivy.acosh also applies to + this method with minimal changes. Parameters ---------- @@ -74,10 +72,9 @@ def acosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.acosh(self._data, out=out) def acos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.acos. This method simply wraps the - function, and so the docstring for ivy.acos also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.acos. This method simply + wraps the function, and so the docstring for ivy.acos also applies to + this method with minimal changes. Parameters ---------- @@ -110,10 +107,9 @@ def add( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.add. This method simply wraps the - function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.add. This method simply + wraps the function, and so the docstring for ivy.add also applies to + this method with minimal changes. Parameters ---------- @@ -151,10 +147,9 @@ def add( return ivy.add(self._data, x2, alpha=alpha, out=out) def asin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.asin. This method simply wraps the - function, and so the docstring for ivy.asin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.asin. This method simply + wraps the function, and so the docstring for ivy.asin also applies to + this method with minimal changes. Parameters ---------- @@ -188,10 +183,9 @@ def asin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.asin(self._data, out=out) def asinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.asinh. This method simply wraps the - function, and so the docstring for ivy.asinh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.asinh. This method simply + wraps the function, and so the docstring for ivy.asinh also applies to + this method with minimal changes. Parameters ---------- @@ -219,10 +213,9 @@ def asinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.asinh(self._data, out=out) def atan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.atan. This method simply wraps the - function, and so the docstring for ivy.atan also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.atan. This method simply + wraps the function, and so the docstring for ivy.atan also applies to + this method with minimal changes. Parameters ---------- @@ -254,10 +247,9 @@ def atan2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.atan2. This method simply wraps the - function, and so the docstring for ivy.atan2 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.atan2. This method simply + wraps the function, and so the docstring for ivy.atan2 also applies to + this method with minimal changes. Parameters ---------- @@ -329,10 +321,9 @@ def atan2( return ivy.atan2(self._data, x2, out=out) def atanh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.atanh. This method simply wraps the - function, and so the docstring for ivy.atanh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.atanh. This method simply + wraps the function, and so the docstring for ivy.atanh also applies to + this method with minimal changes. Parameters ---------- @@ -366,10 +357,9 @@ def bitwise_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_and. This method simply wraps - the function, and so the docstring for ivy.bitwise_and also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_and. This method + simply wraps the function, and so the docstring for ivy.bitwise_and + also applies to this method with minimal changes. Parameters ---------- @@ -412,10 +402,10 @@ def bitwise_left_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_left_shift. This method simply - wraps the function, and so the docstring for ivy.bitwise_left_shift also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_left_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_left_shift also applies to this method with minimal + changes. Parameters ---------- @@ -441,10 +431,9 @@ def bitwise_left_shift( def bitwise_invert( self: ivy.Array, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_invert. This method simply - wraps the function, and so the docstring for ivy.bitiwse_invert also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_invert. This method + simply wraps the function, and so the docstring for ivy.bitiwse_invert + also applies to this method with minimal changes. Parameters ---------- @@ -482,10 +471,9 @@ def bitwise_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_or. This method simply wraps - the function, and so the docstring for ivy.bitwise_or also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_or. This method + simply wraps the function, and so the docstring for ivy.bitwise_or also + applies to this method with minimal changes. Parameters ---------- @@ -521,10 +509,10 @@ def bitwise_right_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_right_shift. This method simply - wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_right_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- @@ -562,10 +550,9 @@ def bitwise_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bitwise_xor. This method simply wraps - the function, and so the docstring for ivy.bitwise_xor also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.bitwise_xor. This method + simply wraps the function, and so the docstring for ivy.bitwise_xor + also applies to this method with minimal changes. Parameters ---------- @@ -597,10 +584,9 @@ def bitwise_xor( return ivy.bitwise_xor(self._data, x2, out=out) def ceil(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ceil. This method simply wraps the - function, and so the docstring for ivy.ceil also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.ceil. This method simply + wraps the function, and so the docstring for ivy.ceil also applies to + this method with minimal changes. Parameters ---------- @@ -626,10 +612,9 @@ def ceil(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.ceil(self._data, out=out) def cos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cos. This method simply wraps the - function, and so the docstring for ivy.cos also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cos. This method simply + wraps the function, and so the docstring for ivy.cos also applies to + this method with minimal changes. Parameters ---------- @@ -670,10 +655,9 @@ def cos(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.cos(self._data, out=out) def cosh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cosh. This method simply wraps the - function, and so the docstring for ivy.cosh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cosh. This method simply + wraps the function, and so the docstring for ivy.cosh also applies to + this method with minimal changes. Parameters ---------- @@ -711,10 +695,9 @@ def divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.divide. This method simply wraps the - function, and so the docstring for ivy.divide also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.divide. This method simply + wraps the function, and so the docstring for ivy.divide also applies to + this method with minimal changes. Parameters ---------- @@ -762,10 +745,9 @@ def equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.equal. This method simply wraps the - function, and so the docstring for ivy.equal also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.equal. This method simply + wraps the function, and so the docstring for ivy.equal also applies to + this method with minimal changes. Parameters ---------- @@ -825,10 +807,9 @@ def equal( return ivy.equal(self._data, x2, out=out) def exp(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.exp. This method simply wraps the - function, and so the docstring for ivy.exp also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.exp. This method simply + wraps the function, and so the docstring for ivy.exp also applies to + this method with minimal changes. Parameters ---------- @@ -854,10 +835,9 @@ def exp(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.exp(self._data, out=out) def expm1(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.expm1. This method simply wraps the - function, and so the docstring for ivy.expm1 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.expm1. This method simply + wraps the function, and so the docstring for ivy.expm1 also applies to + this method with minimal changes. Parameters ---------- @@ -890,10 +870,9 @@ def expm1(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.expm1(self._data, out=out) def floor(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.floor. This method simply wraps the - function, and so the docstring for ivy.floor also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.floor. This method simply + wraps the function, and so the docstring for ivy.floor also applies to + this method with minimal changes. Parameters ---------- @@ -925,10 +904,9 @@ def floor_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.floor_divide. This method simply wraps - the function, and so the docstring for ivy.floor_divide also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.floor_divide. This method + simply wraps the function, and so the docstring for ivy.floor_divide + also applies to this method with minimal changes. Parameters ---------- @@ -976,10 +954,9 @@ def fmin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fmin. This method simply wraps the - function, and so the docstring for ivy.fmin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fmin. This method simply + wraps the function, and so the docstring for ivy.fmin also applies to + this method with minimal changes. Parameters ---------- @@ -1016,10 +993,9 @@ def greater( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.greater. This method simply wraps the - function, and so the docstring for ivy.greater also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.greater. This method simply + wraps the function, and so the docstring for ivy.greater also applies + to this method with minimal changes. Parameters ---------- @@ -1056,10 +1032,9 @@ def greater_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.greater_equal. This method simply wraps - the function, and so the docstring for ivy.greater_equal also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.greater_equal. This method + simply wraps the function, and so the docstring for ivy.greater_equal + also applies to this method with minimal changes. Parameters ---------- @@ -1090,10 +1065,9 @@ def greater_equal( return ivy.greater_equal(self._data, x2, out=out) def isfinite(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isfinite. This method simply wraps the - function, and so the docstring for ivy.isfinite also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isfinite. This method + simply wraps the function, and so the docstring for ivy.isfinite also + applies to this method with minimal changes. Parameters ---------- @@ -1126,10 +1100,9 @@ def isinf( detect_negative: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isinf. This method simply wraps the - function, and so the docstring for ivy.isinf also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isinf. This method simply + wraps the function, and so the docstring for ivy.isinf also applies to + this method with minimal changes. Parameters ---------- @@ -1184,10 +1157,9 @@ def isinf( ) def isnan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isnan. This method simply wraps the - function, and so the docstring for ivy.isnan also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isnan. This method simply + wraps the function, and so the docstring for ivy.isnan also applies to + this method with minimal changes. Parameters ---------- @@ -1245,10 +1217,9 @@ def less( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.less. This method simply wraps the - function, and so the docstring for ivy.less also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.less. This method simply + wraps the function, and so the docstring for ivy.less also applies to + this method with minimal changes. Parameters ---------- @@ -1285,10 +1256,9 @@ def less_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.less_equal. This method simply wraps - the function, and so the docstring for ivy.less_equal also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.less_equal. This method + simply wraps the function, and so the docstring for ivy.less_equal also + applies to this method with minimal changes. Parameters ---------- @@ -1340,10 +1310,9 @@ def less_equal( return ivy.less_equal(self._data, x2, out=out) def log(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log. This method simply wraps the - function, and so the docstring for ivy.log also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.log. This method simply + wraps the function, and so the docstring for ivy.log also applies to + this method with minimal changes. Parameters ---------- @@ -1384,10 +1353,9 @@ def log(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log(self._data, out=out) def log1p(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log1p. This method simply wraps the - function, and so the docstring for ivy.log1p also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.log1p. This method simply + wraps the function, and so the docstring for ivy.log1p also applies to + this method with minimal changes. Parameters ---------- @@ -1419,10 +1387,9 @@ def log1p(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log1p(self._data, out=out) def log2(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log2. This method simply wraps the - function, and so the docstring for ivy.log2 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.log2. This method simply + wraps the function, and so the docstring for ivy.log2 also applies to + this method with minimal changes. Parameters ---------- @@ -1463,10 +1430,9 @@ def log2(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.log2(self._data, out=out) def log10(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log10. This method simply wraps the - function, and so the docstring for ivy.log10 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.log10. This method simply + wraps the function, and so the docstring for ivy.log10 also applies to + this method with minimal changes. Parameters ---------- @@ -1513,10 +1479,9 @@ def logaddexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logaddexp. This method simply wraps the - function, and so the docstring for ivy.logaddexp also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.logaddexp. This method + simply wraps the function, and so the docstring for ivy.logaddexp also + applies to this method with minimal changes. Parameters ---------- @@ -1554,10 +1519,9 @@ def logaddexp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logaddexp2. This method simply wraps - the function, and so the docstring for ivy.logaddexp2 also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logaddexp2. This method + simply wraps the function, and so the docstring for ivy.logaddexp2 also + applies to this method with minimal changes. Parameters ---------- @@ -1588,10 +1552,9 @@ def logical_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logical_and. This method simply wraps - the function, and so the docstring for ivy.logical_and also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logical_and. This method + simply wraps the function, and so the docstring for ivy.logical_and + also applies to this method with minimal changes. Parameters ---------- @@ -1624,10 +1587,9 @@ def logical_and( return ivy.logical_and(self._data, x2, out=out) def logical_not(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logical_not. This method simply wraps - the function, and so the docstring for ivy.logical_not also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logical_not. This method + simply wraps the function, and so the docstring for ivy.logical_not + also applies to this method with minimal changes. Parameters ---------- @@ -1664,10 +1626,9 @@ def logical_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logical_or. This method simply wraps - the function, and so the docstring for ivy.logical_or also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logical_or. This method + simply wraps the function, and so the docstring for ivy.logical_or also + applies to this method with minimal changes. Parameters ---------- @@ -1716,10 +1677,9 @@ def logical_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logical_xor. This method simply wraps - the function, and so the docstring for ivy.logical_xor also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logical_xor. This method + simply wraps the function, and so the docstring for ivy.logical_xor + also applies to this method with minimal changes. Parameters ---------- @@ -1756,10 +1716,9 @@ def multiply( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.multiply. This method simply wraps the - function, and so the docstring for ivy.multiply also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.multiply. This method + simply wraps the function, and so the docstring for ivy.multiply also + applies to this method with minimal changes. Parameters ---------- @@ -1808,10 +1767,9 @@ def maximum( use_where: bool = True, out: Optional[ivy.Array] = None, ): - """ - ivy.Array instance method variant of ivy.maximum. This method simply wraps the - function, and so the docstring for ivy.maximum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.maximum. This method simply + wraps the function, and so the docstring for ivy.maximum also applies + to this method with minimal changes. Parameters ---------- @@ -1867,10 +1825,9 @@ def minimum( use_where: bool = True, out: Optional[ivy.Array] = None, ): - """ - ivy.Array instance method variant of ivy.minimum. This method simply wraps the - function, and so the docstring for ivy.minimum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.minimum. This method simply + wraps the function, and so the docstring for ivy.minimum also applies + to this method with minimal changes. Parameters ---------- @@ -1919,10 +1876,9 @@ def minimum( return ivy.minimum(self, x2, use_where=use_where, out=out) def negative(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.negative. This method simply wraps the - function, and so the docstring for ivy.negative also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.negative. This method + simply wraps the function, and so the docstring for ivy.negative also + applies to this method with minimal changes. Parameters ---------- @@ -1969,10 +1925,9 @@ def not_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.not_equal. This method simply wraps the - function, and so the docstring for ivy.not_equal also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.not_equal. This method + simply wraps the function, and so the docstring for ivy.not_equal also + applies to this method with minimal changes. Parameters ---------- @@ -2031,10 +1986,9 @@ def not_equal( return ivy.not_equal(self._data, x2, out=out) def positive(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.positive. This method simply wraps the - function, and so the docstring for ivy.positive also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.positive. This method + simply wraps the function, and so the docstring for ivy.positive also + applies to this method with minimal changes. Parameters ---------- @@ -2081,10 +2035,9 @@ def pow( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.pow. This method simply wraps the - function, and so the docstring for ivy.pow also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.pow. This method simply + wraps the function, and so the docstring for ivy.pow also applies to + this method with minimal changes. Parameters ---------- @@ -2124,10 +2077,9 @@ def pow( return ivy.pow(self._data, x2, out=out) def real(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.real. This method simply wraps the - function, and so the docstring for ivy.real also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.real. This method simply + wraps the function, and so the docstring for ivy.real also applies to + this method with minimal changes. Parameters ---------- @@ -2160,10 +2112,9 @@ def remainder( modulus: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.remainder. This method simply wraps the - function, and so the docstring for ivy.remainder also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.remainder. This method + simply wraps the function, and so the docstring for ivy.remainder also + applies to this method with minimal changes. Parameters ---------- @@ -2211,10 +2162,9 @@ def remainder( def round( self: ivy.Array, *, decimals: int = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.round. This method simply wraps the - function, and so the docstring for ivy.round also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.round. This method simply + wraps the function, and so the docstring for ivy.round also applies to + this method with minimal changes. Parameters ---------- @@ -2266,10 +2216,9 @@ def sign( np_variant: Optional[bool] = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sign. This method simply wraps the - function, and so the docstring for ivy.sign also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sign. This method simply + wraps the function, and so the docstring for ivy.sign also applies to + this method with minimal changes. Parameters ---------- @@ -2306,10 +2255,9 @@ def sign( return ivy.sign(self._data, np_variant=np_variant, out=out) def sin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sin. This method simply wraps the - function, and so the docstring for ivy.sin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sin. This method simply + wraps the function, and so the docstring for ivy.sin also applies to + this method with minimal changes. Parameters ---------- @@ -2337,10 +2285,9 @@ def sin(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.sin(self._data, out=out) def sinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sinh. This method simply wraps the - function, and so the docstring for ivy.sinh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sinh. This method simply + wraps the function, and so the docstring for ivy.sinh also applies to + this method with minimal changes. Parameters ---------- @@ -2372,10 +2319,9 @@ def sinh(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.sinh(self._data, out=out) def square(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.square. This method simply wraps the - function, and so the docstring for ivy.square also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.square. This method simply + wraps the function, and so the docstring for ivy.square also applies to + this method with minimal changes. Parameters ---------- @@ -2409,10 +2355,9 @@ def square(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.square(self._data, out=out) def sqrt(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sqrt. This method simply wraps the - function, and so the docstring for ivy.sqrt also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sqrt. This method simply + wraps the function, and so the docstring for ivy.sqrt also applies to + this method with minimal changes. Parameters ---------- @@ -2449,10 +2394,9 @@ def subtract( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.subtract. This method simply wraps the - function, and so the docstring for ivy.subtract also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.subtract. This method + simply wraps the function, and so the docstring for ivy.subtract also + applies to this method with minimal changes. Parameters ---------- @@ -2499,10 +2443,9 @@ def trapz( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trapz. This method simply wraps the - function, and so the docstring for ivy.trapz also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.trapz. This method simply + wraps the function, and so the docstring for ivy.trapz also applies to + this method with minimal changes. Parameters ---------- @@ -2543,10 +2486,9 @@ def trapz( return ivy.trapz(self._data, x=x, dx=dx, axis=axis, out=out) def tan(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tan. This method simply wraps the - function, and so the docstring for ivy.tan also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tan. This method simply + wraps the function, and so the docstring for ivy.tan also applies to + this method with minimal changes. Parameters ---------- @@ -2579,10 +2521,9 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tanh. This method simply wraps the - function, and so the docstring for ivy.tanh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tanh. This method simply + wraps the function, and so the docstring for ivy.tanh also applies to + this method with minimal changes. Parameters ---------- @@ -2613,10 +2554,9 @@ def tanh( return ivy.tanh(self._data, complex_mode=complex_mode, out=out) def trunc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trunc. This method simply wraps the - function, and so the docstring for ivy.trunc also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.trunc. This method simply + wraps the function, and so the docstring for ivy.trunc also applies to + this method with minimal changes. Parameters ---------- @@ -2642,10 +2582,9 @@ def trunc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.trunc(self._data, out=out) def erf(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.erf. This method simply wraps the - function, and so the docstring for ivy.erf also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.erf. This method simply + wraps the function, and so the docstring for ivy.erf also applies to + this method with minimal changes. Parameters ---------- @@ -2674,10 +2613,9 @@ def exp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.exp2. This method simply wraps the - function, and so the docstring for ivy.exp2 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.exp2. This method simply + wraps the function, and so the docstring for ivy.exp2 also applies to + this method with minimal changes. Parameters ---------- @@ -2709,10 +2647,9 @@ def gcd( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gcd. This method simply wraps the - function, and so the docstring for ivy.gcd also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.gcd. This method simply + wraps the function, and so the docstring for ivy.gcd also applies to + this method with minimal changes. Parameters ---------- @@ -2750,10 +2687,9 @@ def nan_to_num( neginf: Optional[Union[float, int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nan_to_num. This method simply wraps - the function, and so the docstring for ivy.nan_to_num also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.nan_to_num. This method + simply wraps the function, and so the docstring for ivy.nan_to_num also + applies to this method with minimal changes. Parameters ---------- @@ -2801,10 +2737,9 @@ def imag( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.imag. This method simply wraps the - function, and so the docstring for ivy.imag also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.imag. This method simply + wraps the function, and so the docstring for ivy.imag also applies to + this method with minimal changes. Parameters ---------- @@ -2837,10 +2772,9 @@ def angle( deg: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.angle. This method simply wraps the - function, and so the docstring for ivy.angle also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.angle. This method simply + wraps the function, and so the docstring for ivy.angle also applies to + this method with minimal changes. Parameters ---------- @@ -2878,10 +2812,9 @@ def reciprocal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.reciprocal.This method simply wraps the - function, and so the docstring for ivy.reciprocal also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.reciprocal.This method + simply wraps the function, and so the docstring for ivy.reciprocal also + applies to this method with minimal changes. Parameters ---------- @@ -2906,10 +2839,9 @@ def reciprocal( return ivy.reciprocal(self._data, out=out) def deg2rad(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.deg2rad. This method simply wraps the - function, and so the docstring for ivy.deg2rad also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.deg2rad. This method simply + wraps the function, and so the docstring for ivy.deg2rad also applies + to this method with minimal changes. Parameters ---------- @@ -2936,10 +2868,9 @@ def deg2rad(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.deg2rad(self._data, out=out) def rad2deg(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.rad2deg. This method simply wraps the - function, and so the docstring for ivy.rad2deg also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.rad2deg. This method simply + wraps the function, and so the docstring for ivy.rad2deg also applies + to this method with minimal changes. Parameters ---------- @@ -2972,10 +2903,9 @@ def trunc_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trunc_divide. This method simply wraps - the function, and so the docstring for ivy.trunc_divide also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.trunc_divide. This method + simply wraps the function, and so the docstring for ivy.trunc_divide + also applies to this method with minimal changes. Parameters ---------- @@ -3009,10 +2939,9 @@ def trunc_divide( return ivy.trunc_divide(self._data, x2, out=out) def isreal(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isreal. This method simply wraps the - function, and so the docstring for ivy.isreal also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isreal. This method simply + wraps the function, and so the docstring for ivy.isreal also applies to + this method with minimal changes. Parameters ---------- @@ -3040,10 +2969,9 @@ def isreal(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: def lcm( self: ivy.Array, x2: ivy.Array, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lcm. This method simply wraps the - function, and so the docstring for ivy.lcm also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.lcm. This method simply + wraps the function, and so the docstring for ivy.lcm also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/activations.py b/ivy/data_classes/array/experimental/activations.py index 24e38a9dc52ff..6e44b4240c190 100644 --- a/ivy/data_classes/array/experimental/activations.py +++ b/ivy/data_classes/array/experimental/activations.py @@ -15,10 +15,9 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logit. This method simply wraps the - function, and so the docstring for ivy.logit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.logit. This method simply + wraps the function, and so the docstring for ivy.logit also applies to + this method with minimal changes. Parameters ---------- @@ -60,10 +59,9 @@ def thresholded_relu( threshold: Union[int, float] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.thresholded_relu. This method simply - wraps the function, and so the docstring for ivy.thresholded_relu also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.thresholded_relu. This + method simply wraps the function, and so the docstring for + ivy.thresholded_relu also applies to this method with minimal changes. Parameters ---------- @@ -97,8 +95,7 @@ def prelu( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Prelu takes input data (Array) and slope array as input, + """Prelu takes input data (Array) and slope array as input, and produces one output data (array) where the function f(x) = slope * x for x < 0, f(x) = x for x >= 0., is applied @@ -130,8 +127,7 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the rectified linear unit 6 function element-wise. + """Apply the rectified linear unit 6 function element-wise. Parameters ---------- @@ -171,10 +167,9 @@ def logsigmoid( self: ivy.Array, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.logsigmoid. This method simply wraps - the function, and so the docstring for ivy.logsigmoid also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.logsigmoid. This method + simply wraps the function, and so the docstring for ivy.logsigmoid also + applies to this method with minimal changes. Parameters ---------- @@ -203,8 +198,7 @@ def logsigmoid( return ivy.logsigmoid(self._data, complex_mode=complex_mode) def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - Apply the scaled exponential linear unit function element-wise. + """Apply the scaled exponential linear unit function element-wise. Parameters ---------- @@ -240,10 +234,9 @@ def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.selu(self._data, out=out) def silu(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.silu. This method simply wraps the - function, and so the docstring for ivy.silu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.silu. This method simply + wraps the function, and so the docstring for ivy.silu also applies to + this method with minimal changes. Parameters ---------- @@ -269,10 +262,9 @@ def elu( alpha: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Ivy.Array instance method variant of ivy.elu. This method simply wraps the - function, and so the docstring for ivy.elu also applies to this method with - minimal. + """Ivy.Array instance method variant of ivy.elu. This method simply + wraps the function, and so the docstring for ivy.elu also applies to + this method with minimal. Parameters ---------- @@ -306,10 +298,9 @@ def hardtanh( min_val: float = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.hardtanh. This method simply wraps the - function, and so the docstring for ivy.hardtanh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.hardtanh. This method + simply wraps the function, and so the docstring for ivy.hardtanh also + applies to this method with minimal changes. Parameters ---------- @@ -339,10 +330,9 @@ def hardtanh( return ivy.hardtanh(self._data, min_val=min_val, max_val=max_val, out=out) def tanhshrink(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tanhshrink. This method simply wraps - the function, and so the docstring for ivy.tanhshrink also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.tanhshrink. This method + simply wraps the function, and so the docstring for ivy.tanhshrink also + applies to this method with minimal changes. Parameters ---------- @@ -369,10 +359,9 @@ def threshold( value: Union[int, float], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.threshold. This method simply wraps the - function, and so the docstring for ivy.threshold also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.threshold. This method + simply wraps the function, and so the docstring for ivy.threshold also + applies to this method with minimal changes. Parameters ---------- @@ -407,10 +396,9 @@ def softshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.softshrink. This method simply wraps - the function, and so the docstring for ivy.softshrink also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.softshrink. This method + simply wraps the function, and so the docstring for ivy.softshrink also + applies to this method with minimal changes. Parameters ---------- @@ -448,10 +436,9 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.celu. This method simply wraps the - function, and so the docstring for ivy.celu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.celu. This method simply + wraps the function, and so the docstring for ivy.celu also applies to + this method with minimal changes. Parameters ---------- @@ -488,10 +475,9 @@ def scaled_tanh( beta: float = 0.67, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.scaled_tanh. This method simply wraps - the function, and so the docstring for ivy.scaled_tanh also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.scaled_tanh. This method + simply wraps the function, and so the docstring for ivy.scaled_tanh + also applies to this method with minimal changes. Parameters ---------- @@ -537,10 +523,9 @@ def hardshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.hardshrink. This method simply wraps - the function, and so the docstring for ivy.hardshrink also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.hardshrink. This method + simply wraps the function, and so the docstring for ivy.hardshrink also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/creation.py b/ivy/data_classes/array/experimental/creation.py index 6d814ee70f85b..62ab0e9f1744d 100644 --- a/ivy/data_classes/array/experimental/creation.py +++ b/ivy/data_classes/array/experimental/creation.py @@ -16,10 +16,9 @@ def eye_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.eye_like. This method simply wraps the - function, and so the docstring for ivy.eye_like also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.eye_like. This method + simply wraps the function, and so the docstring for ivy.eye_like also + applies to this method with minimal changes. Parameters ---------- @@ -60,10 +59,10 @@ def unsorted_segment_min( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - r""" - ivy.Array instance method variant of ivy.unsorted_segment_min. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_min - also applies to this method with minimal changes. + r"""ivy.Array instance method variant of ivy.unsorted_segment_min. This + method simply wraps the function, and so the docstring for + ivy.unsorted_segment_min also applies to this method with minimal + changes. Note ---- @@ -97,10 +96,10 @@ def unsorted_segment_sum( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - r""" - ivy.Array instance method variant of ivy.unsorted_segment_sum. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_sum - also applies to this method with minimal changes. + r"""ivy.Array instance method variant of ivy.unsorted_segment_sum. This + method simply wraps the function, and so the docstring for + ivy.unsorted_segment_sum also applies to this method with minimal + changes. Parameters ---------- @@ -133,10 +132,9 @@ def blackman_window( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.blackman_window. This method simply - wraps the function, and so the docstring for ivy.blackman_window also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.blackman_window. This + method simply wraps the function, and so the docstring for + ivy.blackman_window also applies to this method with minimal changes. Parameters ---------- @@ -181,10 +179,9 @@ def trilu( upper: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trilu. This method simply wraps the - function, and so the docstring for ivy.trilu also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.trilu. This method simply + wraps the function, and so the docstring for ivy.trilu also applies to + this method with minimal changes. Parameters ---------- @@ -220,10 +217,10 @@ def mel_weight_matrix( lower_edge_hertz: Optional[Union[float, ivy.Array]] = 0.0, upper_edge_hertz: Optional[Union[float, ivy.Array]] = 3000.0, ): - """ - Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a - linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins - frequency information based on the [lower_edge_hertz, upper_edge_hertz] + """Generate a MelWeightMatrix that can be used to re-weight a Tensor + containing a linearly sampled frequency spectra (from DFT or STFT) into + num_mel_bins frequency information based on the [lower_edge_hertz, + upper_edge_hertz] range on the mel scale. This function defines the mel scale in terms of a frequency in hertz according to the following @@ -270,8 +267,8 @@ def unsorted_segment_mean( segment_ids: ivy.Array, num_segments: Union[int, ivy.Array], ) -> ivy.Array: - """ - Compute the mean of values in the array 'self' based on segment identifiers. + """Compute the mean of values in the array 'self' based on segment + identifiers. Parameters ---------- @@ -318,9 +315,9 @@ def polyval( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.Array: - """ - ivy.Array instance method of polyval. This method simply wraps the function, and so - the docstring for ivy.polyval also applies to this method with minimal changes. + """ivy.Array instance method of polyval. This method simply wraps the + function, and so the docstring for ivy.polyval also applies to this method + with minimal changes. Evaluate and return a polynomial at specific given values. diff --git a/ivy/data_classes/array/experimental/elementwise.py b/ivy/data_classes/array/experimental/elementwise.py index 31e4245b01f15..f48d1b303fc55 100644 --- a/ivy/data_classes/array/experimental/elementwise.py +++ b/ivy/data_classes/array/experimental/elementwise.py @@ -16,10 +16,9 @@ def amax( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.amax. This method simply wraps the - function, and so the docstring for ivy.amax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.amax. This method simply + wraps the function, and so the docstring for ivy.amax also applies to + this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def amin( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.amin. This method simply wraps the - function, and so the docstring for ivy.amin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.amin. This method simply + wraps the function, and so the docstring for ivy.amin also applies to + this method with minimal changes. Parameters ---------- @@ -133,10 +131,9 @@ def amin( return ivy.amin(self._data, axis=axis, keepdims=keepdims, out=out) def lgamma(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lgamma. This method simply wraps the - function, and so the docstring for ivy.lgamma also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.lgamma. This method simply + wraps the function, and so the docstring for ivy.lgamma also applies to + this method with minimal changes. Parameters ---------- @@ -168,10 +165,9 @@ def lgamma(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: return ivy.lgamma(self._data, out=out) def sinc(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sinc. This method simply wraps the - function, and so the docstring for ivy.sinc also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sinc. This method simply + wraps the function, and so the docstring for ivy.sinc also applies to + this method with minimal changes. Parameters ---------- @@ -205,10 +201,9 @@ def fmod( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fmod. This method simply wraps the - function, and so the docstring for ivy.fmod also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fmod. This method simply + wraps the function, and so the docstring for ivy.fmod also applies to + this method with minimal changes. Parameters ---------- @@ -245,10 +240,9 @@ def fmax( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fmax. This method simply wraps the - function, and so the docstring for ivy.fmax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fmax. This method simply + wraps the function, and so the docstring for ivy.fmax also applies to + this method with minimal changes. Parameters ---------- @@ -285,10 +279,9 @@ def float_power( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.float_power. This method simply wraps - the function, and so the docstring for ivy.float_power also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.float_power. This method + simply wraps the function, and so the docstring for ivy.float_power + also applies to this method with minimal changes. Parameters ---------- @@ -326,10 +319,9 @@ def copysign( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.copysign. This method simply wraps the - function, and so the docstring for ivy.copysign also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.copysign. This method + simply wraps the function, and so the docstring for ivy.copysign also + applies to this method with minimal changes. Parameters ---------- @@ -367,10 +359,9 @@ def count_nonzero( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.count_nonzero. This method simply wraps - the function, and so the docstring for ivy.count_nonzero also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.count_nonzero. This method + simply wraps the function, and so the docstring for ivy.count_nonzero + also applies to this method with minimal changes. Parameters ---------- @@ -421,10 +412,9 @@ def nansum( keepdims: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nansum. This method simply wraps the - function, and so the docstring for ivy.nansum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nansum. This method simply + wraps the function, and so the docstring for ivy.nansum also applies to + this method with minimal changes. Parameters ---------- @@ -473,10 +463,9 @@ def isclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isclose. This method simply wraps the - function, and so the docstring for ivy.isclose also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isclose. This method simply + wraps the function, and so the docstring for ivy.isclose also applies + to this method with minimal changes. Parameters ---------- @@ -528,10 +517,9 @@ def signbit( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.signbit. This method simply wraps the - function, and so the docstring for ivy.signbit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.signbit. This method simply + wraps the function, and so the docstring for ivy.signbit also applies + to this method with minimal changes. Parameters ---------- @@ -560,10 +548,9 @@ def hypot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.hypot. This method simply wraps the - function, and so the docstring for ivy.hypot also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.hypot. This method simply + wraps the function, and so the docstring for ivy.hypot also applies to + this method with minimal changes. Parameters ---------- @@ -600,10 +587,9 @@ def allclose( equal_nan: bool = False, out: Optional[ivy.Container] = None, ) -> bool: - """ - ivy.Array instance method variant of ivy.allclose. This method simply wraps the - function, and so the docstring for ivy.allclose also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.allclose. This method + simply wraps the function, and so the docstring for ivy.allclose also + applies to this method with minimal changes. Parameters ---------- @@ -662,10 +648,9 @@ def diff( append: Optional[Union[ivy.Array, ivy.NativeArray, int, list, tuple]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.diff. This method simply wraps the - function, and so the docstring for ivy.diff also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.diff. This method simply + wraps the function, and so the docstring for ivy.diff also applies to + this method with minimal changes. Parameters ---------- @@ -705,10 +690,9 @@ def fix( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fix. This method simply wraps the - function, and so the docstring for ivy.fix also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fix. This method simply + wraps the function, and so the docstring for ivy.fix also applies to + this method with minimal changes. Parameters ---------- @@ -738,10 +722,9 @@ def nextafter( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nextafter. This method simply wraps the - function, and so the docstring for ivy.nextafter also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.nextafter. This method + simply wraps the function, and so the docstring for ivy.nextafter also + applies to this method with minimal changes. Parameters ---------- @@ -774,10 +757,9 @@ def zeta( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.zeta. This method simply wraps the - function, and so the docstring for ivy.zeta also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.zeta. This method simply + wraps the function, and so the docstring for ivy.zeta also applies to + this method with minimal changes. Parameters ---------- @@ -812,8 +794,7 @@ def gradient( edge_order: int = 1, axis: Optional[Union[int, list, tuple]] = None, ) -> Union[ivy.Array, List[ivy.Array]]: - """ - Calculate gradient of x with respect to (w.r.t.) spacing. + """Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -885,10 +866,9 @@ def xlogy( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.xlogy. This method simply wraps the - function, and so the docstring for ivy.xlogy also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.xlogy. This method simply + wraps the function, and so the docstring for ivy.xlogy also applies to + this method with minimal changes. Parameters ---------- @@ -922,9 +902,8 @@ def xlogy( def binarizer( self: ivy.Array, /, *, threshold: float = 0, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Map the values of the input tensor to either 0 or 1, element-wise, based on the - outcome of a comparison against a threshold value. + """Map the values of the input tensor to either 0 or 1, element-wise, + based on the outcome of a comparison against a threshold value. Parameters ---------- @@ -945,10 +924,9 @@ def binarizer( return ivy.binarizer(self._data, threshold=threshold, out=out) def conj(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.conj. This method simply wraps the - function, and so the docstring for ivy.conj also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.conj. This method simply + wraps the function, and so the docstring for ivy.conj also applies to + this method with minimal changes. Parameters ---------- @@ -980,10 +958,9 @@ def lerp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lerp. This method simply wraps the - function, and so the docstring for ivy.lerp also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.lerp. This method simply + wraps the function, and so the docstring for ivy.lerp also applies to + this method with minimal changes. Parameters ---------- @@ -1021,10 +998,9 @@ def ldexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ldexp. This method simply wraps the - function, and so the docstring for ivy.ldexp also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.ldexp. This method simply + wraps the function, and so the docstring for ivy.ldexp also applies to + this method with minimal changes. Parameters ---------- @@ -1053,10 +1029,9 @@ def ldexp( def frexp( self: ivy.Array, /, *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.frexp. This method simply wraps the - function, and so the docstring for ivy.frexp also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.frexp. This method simply + wraps the function, and so the docstring for ivy.frexp also applies to + this method with minimal changes. Parameters ---------- @@ -1082,10 +1057,9 @@ def frexp( def modf( self: ivy.Array, /, *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.modf. This method simply wraps the - function, and so the docstring for ivy.modf also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.modf. This method simply + wraps the function, and so the docstring for ivy.modf also applies to + this method with minimal changes. Parameters ---------- @@ -1114,10 +1088,9 @@ def digamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.digamma. This method simply wraps the - function, and so the docstring for ivy.digamma also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.digamma. This method simply + wraps the function, and so the docstring for ivy.digamma also applies + to this method with minimal changes. Note ---- @@ -1152,10 +1125,9 @@ def sparsify_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array class method variant of ivy.sparsify_tensor. This method simply wraps - the function, and so the docstring for ivy.sparsify_tensor also applies to this - method with minimal changes. + """ivy.Array class method variant of ivy.sparsify_tensor. This method + simply wraps the function, and so the docstring for ivy.sparsify_tensor + also applies to this method with minimal changes. Parameters ---------- @@ -1195,10 +1167,9 @@ def erfc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.erfc. This method simply wraps the - function, and so the docstring for ivy.erfc also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.erfc. This method simply + wraps the function, and so the docstring for ivy.erfc also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/general.py b/ivy/data_classes/array/experimental/general.py index d07f50f94981c..c51957e6b51bb 100644 --- a/ivy/data_classes/array/experimental/general.py +++ b/ivy/data_classes/array/experimental/general.py @@ -16,10 +16,9 @@ def reduce( axes: Union[int, Sequence[int]] = 0, keepdims: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.reduce. This method simply wraps the - function, and so the docstring for ivy.reduce also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.reduce. This method simply + wraps the function, and so the docstring for ivy.reduce also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/layers.py b/ivy/data_classes/array/experimental/layers.py index 3c9513e22d960..257b29e8d766e 100644 --- a/ivy/data_classes/array/experimental/layers.py +++ b/ivy/data_classes/array/experimental/layers.py @@ -19,10 +19,9 @@ def max_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.max_pool1d`. This method simply wraps - the function, and so the docstring for `ivy.max_pool1d` also applies to this - method with minimal changes. + """ivy.Array instance method variant of `ivy.max_pool1d`. This method + simply wraps the function, and so the docstring for `ivy.max_pool1d` + also applies to this method with minimal changes. Parameters ---------- @@ -87,10 +86,9 @@ def max_pool2d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.max_pool2d`. This method simply wraps - the function, and so the docstring for `ivy.max_pool2d` also applies to this - method with minimal changes. + """ivy.Array instance method variant of `ivy.max_pool2d`. This method + simply wraps the function, and so the docstring for `ivy.max_pool2d` + also applies to this method with minimal changes. Parameters ---------- @@ -166,8 +164,7 @@ def max_pool3d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D max pool given 5-D input x. + """Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -231,10 +228,9 @@ def avg_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.avg_pool1d`. This method simply wraps - the function, and so the docstring for `ivy.avg_pool1d` also applies to this - method with minimal changes. + """ivy.Array instance method variant of `ivy.avg_pool1d`. This method + simply wraps the function, and so the docstring for `ivy.avg_pool1d` + also applies to this method with minimal changes. Parameters ---------- @@ -300,10 +296,9 @@ def avg_pool2d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.avg_pool2d`. This method simply wraps - the function, and so the docstring for `ivy.avg_pool2d` also applies to this - method with minimal changes. + """ivy.Array instance method variant of `ivy.avg_pool2d`. This method + simply wraps the function, and so the docstring for `ivy.avg_pool2d` + also applies to this method with minimal changes. Parameters ---------- @@ -377,8 +372,7 @@ def avg_pool3d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D max pool given 5-D input x. + """Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -443,10 +437,9 @@ def dct( norm: Optional[Literal["ortho"]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dct. This method simply wraps the - function, and so the docstring for ivy.dct also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dct. This method simply + wraps the function, and so the docstring for ivy.dct also applies to + this method with minimal changes. Parameters ---------- @@ -492,10 +485,9 @@ def idct( norm: Optional[Literal["ortho"]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.idct. This method simply wraps the - function, and so the docstring for ivy.idct also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.idct. This method simply + wraps the function, and so the docstring for ivy.idct also applies to + this method with minimal changes. Parameters ---------- @@ -541,10 +533,9 @@ def fft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ifft. This method simply wraps the - function, and so the docstring for ivy.ifft also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.ifft. This method simply + wraps the function, and so the docstring for ivy.ifft also applies to + this method with minimal changes. Parameters ---------- @@ -597,10 +588,9 @@ def ifft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.ifft. This method simply wraps the - function, and so the docstring for ivy.ifft also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.ifft. This method simply + wraps the function, and so the docstring for ivy.ifft also applies to + this method with minimal changes. Parameters ---------- @@ -666,8 +656,7 @@ def dft( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the discrete Fourier transform of input. + """Compute the discrete Fourier transform of input. Parameters ---------- @@ -751,8 +740,7 @@ def interpolate( antialias: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Down/up samples the input to the given size. The algorithm used for + """Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -811,9 +799,8 @@ def adaptive_avg_pool1d( self: ivy.Array, output_size: int, ) -> ivy.Array: - """ - Apply a 1D adaptive average pooling over an input signal composed of several - input planes. + """Apply a 1D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -841,9 +828,8 @@ def adaptive_avg_pool2d( *, data_format: str = "NHWC", ) -> ivy.Array: - """ - Apply a 2D adaptive average pooling over an input signal composed of several - input planes. + """Apply a 2D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -869,9 +855,8 @@ def adaptive_max_pool2d( self: ivy.Array, output_size: Union[Sequence[int], int], ) -> ivy.Array: - """ - Apply a 2D adaptive maximum pooling over an input signal composed of several - input planes. + """Apply a 2D adaptive maximum pooling over an input signal composed of + several input planes. Parameters ---------- @@ -904,8 +889,8 @@ def reduce_window( base_dilation: Union[int, Sequence[int]] = 1, window_dilation: Union[int, Sequence[int]] = 1, ) -> ivy.Array: - """ - Apply a reduction function to all elements in each window of an array. + """Apply a reduction function to all elements in each window of an + array. Parameters ---------- @@ -961,8 +946,7 @@ def fft2( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the 2-dimensional discrete Fourier Transform. + """Compute the 2-dimensional discrete Fourier Transform. Parameters ---------- @@ -1026,8 +1010,7 @@ def ifftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the N-dimensional inverse discrete Fourier Transform. + """Compute the N-dimensional inverse discrete Fourier Transform. Parameters ---------- @@ -1099,10 +1082,9 @@ def rfft( norm: Literal["backward", "ortho", "forward"] = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.rfft. This method simply wraps the - function, and so the docstring for ivy.rfft also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.rfft. This method simply + wraps the function, and so the docstring for ivy.rfft also applies to + this method with minimal changes. Parameters ---------- @@ -1154,8 +1136,7 @@ def rfftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the n-dimensional discrete Fourier Transform. + """Compute the n-dimensional discrete Fourier Transform. Parameters ---------- @@ -1190,8 +1171,7 @@ def stft( name: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Short-time Fourier Transform of signals. + """Compute the Short-time Fourier Transform of signals. Parameters ---------- @@ -1243,8 +1223,7 @@ def sliding_window( dilation: Union[int, Tuple[int, int]] = 1, padding: Union[str, int, Sequence[Tuple[int, int]]] = "VALID", ) -> ivy.Array: - """ - Slide a window of specified dimension over all elements of an array. + """Slide a window of specified dimension over all elements of an array. Parameters ---------- @@ -1299,8 +1278,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Array: - """ - Compute a 1-D max unpooling given the 1-D pooled input x and its indices. + """Compute a 1-D max unpooling given the 1-D pooled input x and its + indices. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/linear_algebra.py b/ivy/data_classes/array/experimental/linear_algebra.py index 7a8a99d3f288d..09ff0484e31ea 100644 --- a/ivy/data_classes/array/experimental/linear_algebra.py +++ b/ivy/data_classes/array/experimental/linear_algebra.py @@ -19,10 +19,9 @@ def eigh_tridiagonal( ] = None, tol: Optional[float] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array]]: - """ - ivy.Array instance method variant of ivy.eigh_tridiagonal. This method simply - wraps the function, and so the docstring for ivy.eigh_tridiagonal also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.eigh_tridiagonal. This + method simply wraps the function, and so the docstring for + ivy.eigh_tridiagonal also applies to this method with minimal changes. Parameters ---------- @@ -89,10 +88,9 @@ def diagflat( num_cols: int = -1, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.diagflat. This method simply wraps the - function, and so the docstring for ivy.diagflat also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.diagflat. This method + simply wraps the function, and so the docstring for ivy.diagflat also + applies to this method with minimal changes. Examples -------- @@ -119,10 +117,9 @@ def kron( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.kron. This method simply wraps the - function, and so the docstring for ivy.kron also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.kron. This method simply + wraps the function, and so the docstring for ivy.kron also applies to + this method with minimal changes. Examples -------- @@ -134,10 +131,9 @@ def kron( return ivy.kron(self._data, b, out=out) def matrix_exp(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.kron. This method simply wraps the - function, and so the docstring for ivy.matrix_exp also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.kron. This method simply + wraps the function, and so the docstring for ivy.matrix_exp also + applies to this method with minimal changes. Examples -------- @@ -157,10 +153,9 @@ def eig( self: ivy.Array, /, ) -> Tuple[ivy.Array, ...]: - """ - ivy.Array instance method variant of ivy.eig. This method simply wraps the - function, and so the docstring for ivy.eig also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.eig. This method simply + wraps the function, and so the docstring for ivy.eig also applies to + this method with minimal changes. Examples -------- @@ -178,10 +173,9 @@ def eigvals( self: ivy.Array, /, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.eigvals. This method simply wraps the - function, and so the docstring for ivy.eigvals also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.eigvals. This method simply + wraps the function, and so the docstring for ivy.eigvals also applies + to this method with minimal changes. Examples -------- @@ -197,10 +191,9 @@ def adjoint( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.adjoint. This method simply wraps the - function, and so the docstring for ivy.adjoint also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.adjoint. This method simply + wraps the function, and so the docstring for ivy.adjoint also applies + to this method with minimal changes. Examples -------- @@ -223,10 +216,9 @@ def multi_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.multi_dot. This method simply wraps the - function, and so the docstring for ivy.multi_dot also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.multi_dot. This method + simply wraps the function, and so the docstring for ivy.multi_dot also + applies to this method with minimal changes. Examples -------- @@ -242,10 +234,9 @@ def multi_dot( def cond( self: ivy.Array, /, *, p: Optional[Union[int, float, str]] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cond. This method simply wraps the - function, and so the docstring for ivy.cond also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cond. This method simply + wraps the function, and so the docstring for ivy.cond also applies to + this method with minimal changes. Examples -------- @@ -268,10 +259,9 @@ def mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.mode_dot. This method simply wraps the - function, and so the docstring for ivy.mode_dot also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.mode_dot. This method + simply wraps the function, and so the docstring for ivy.mode_dot also + applies to this method with minimal changes. Parameters ---------- @@ -310,10 +300,9 @@ def multi_mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - ivy.Array instance method variant of ivy.multi_mode_dot. This method simply - wraps the function, and so the docstring for ivy.multi_mode_dot also applies to - this method with minimal changes. + r"""ivy.Array instance method variant of ivy.multi_mode_dot. This method + simply wraps the function, and so the docstring for ivy.multi_mode_dot + also applies to this method with minimal changes. Parameters ---------- @@ -357,10 +346,9 @@ def svd_flip( /, u_based_decision: Optional[bool] = True, ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.svd_flip. This method simply wraps the - function, and so the docstring for ivy.svd_flip also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.svd_flip. This method + simply wraps the function, and so the docstring for ivy.svd_flip also + applies to this method with minimal changes. Parameters ---------- @@ -388,10 +376,10 @@ def make_svd_non_negative( *, nntype: Optional[Literal["nndsvd", "nndsvda"]] = "nndsvd", ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.make_svd_non_negative. This method - simply wraps the function, and so the docstring for ivy.make_svd_non_negative - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.make_svd_non_negative. This + method simply wraps the function, and so the docstring for + ivy.make_svd_non_negative also applies to this method with minimal + changes. Parameters ---------- @@ -418,10 +406,9 @@ def tensor_train( svd: Optional[Literal["truncated_svd"]] = "truncated_svd", verbose: Optional[bool] = False, ) -> ivy.TTTensor: - """ - ivy.Array instance method variant of ivy.tensor_train. This method simply wraps - the function, and so the docstring for ivy.tensor_train also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.tensor_train. This method + simply wraps the function, and so the docstring for ivy.tensor_train + also applies to this method with minimal changes. Parameters ---------- @@ -448,10 +435,10 @@ def truncated_svd( compute_uv: bool = True, n_eigenvecs: Optional[int] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array, ivy.Array]]: - """ - ivy.Array instance method variant of ivy.make_svd_non_negative. This method - simply wraps the function, and so the docstring for ivy.make_svd_non_negative - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.make_svd_non_negative. This + method simply wraps the function, and so the docstring for + ivy.make_svd_non_negative also applies to this method with minimal + changes. Parameters ---------- @@ -487,10 +474,9 @@ def initialize_tucker( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, svd_mask_repeats: Optional[int] = 5, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ - ivy.Array instance method variant of ivy.initialize_tucker. This method simply - wraps the function, and so the docstring for ivy.initialize_tucker also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.initialize_tucker. This + method simply wraps the function, and so the docstring for + ivy.initialize_tucker also applies to this method with minimal changes. Parameters ---------- @@ -553,10 +539,9 @@ def partial_tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ - ivy.Array instance method variant of ivy.partial_tucker. This method simply - wraps the function, and so the docstring for ivy.partial_tucker also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.partial_tucker. This method + simply wraps the function, and so the docstring for ivy.partial_tucker + also applies to this method with minimal changes. Parameters ---------- @@ -635,10 +620,9 @@ def tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ): - """ - ivy.Array instance method variant of ivy.tucker. This method simply wraps the - function, and so the docstring for ivy.tucker also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tucker. This method simply + wraps the function, and so the docstring for ivy.tucker also applies to + this method with minimal changes. Parameters ---------- @@ -713,10 +697,10 @@ def tt_matrix_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Ivy.Array instance method variant of ivy.tt_matrix_to_tensor. This method simply - wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also - applies to this method with minimal changes. + """Ivy.Array instance method variant of ivy.tt_matrix_to_tensor. This + method simply wraps the function, and so the docstring for + ivy.tt_matrix_to_tensor also applies to this method with minimal + changes. Parameters ---------- @@ -766,10 +750,9 @@ def dot( *, out: Optional[ivy.Array] = None, ): - """ - Compute the dot product between two arrays `a` and `b` using the current - backend's implementation. The dot product is defined as the sum of the element- - wise product of the input arrays. + """Compute the dot product between two arrays `a` and `b` using the + current backend's implementation. The dot product is defined as the sum + of the element- wise product of the input arrays. Parameters ---------- @@ -820,10 +803,10 @@ def general_inner_product( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.general_inner_product. This method - simply wraps the function, and so the docstring for ivy.general_inner_product - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.general_inner_product. This + method simply wraps the function, and so the docstring for + ivy.general_inner_product also applies to this method with minimal + changes. Parameters ---------- @@ -875,10 +858,10 @@ def higher_order_moment( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.higher_order_moment. This method simply - wraps the function, and so the docstring for ivy.higher_order_moment also - applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.higher_order_moment. This + method simply wraps the function, and so the docstring for + ivy.higher_order_moment also applies to this method with minimal + changes. Parameters ---------- @@ -916,10 +899,9 @@ def batched_outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Ivy Array instance method variant of ivy.batched_outer. This method simply wraps - the function, and so the docstring for ivy.batched_outer also applies to this - method with minimal changes. + """Ivy Array instance method variant of ivy.batched_outer. This method + simply wraps the function, and so the docstring for ivy.batched_outer + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/losses.py b/ivy/data_classes/array/experimental/losses.py index 94c60683bd2e5..e06132caf1638 100644 --- a/ivy/data_classes/array/experimental/losses.py +++ b/ivy/data_classes/array/experimental/losses.py @@ -15,10 +15,9 @@ def l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.l1_loss. This method simply wraps the - function, and so the docstring for ivy.l1_loss also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.l1_loss. This method simply + wraps the function, and so the docstring for ivy.l1_loss also applies + to this method with minimal changes. Parameters ---------- @@ -59,10 +58,9 @@ def log_poisson_loss( reduction: str = "none", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.log_poisson_loss. This method simply - wraps the function, and so the docstring for ivy.l1_loss also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.log_poisson_loss. This + method simply wraps the function, and so the docstring for ivy.l1_loss + also applies to this method with minimal changes. Parameters ---------- @@ -122,10 +120,9 @@ def huber_loss( delta: Optional[float] = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of huber_loss. This method simply wraps the - function, and so the docstring for huber_loss also applies to this method with - minimal changes. + """ivy.Array instance method variant of huber_loss. This method simply + wraps the function, and so the docstring for huber_loss also applies to + this method with minimal changes. Parameters ---------- @@ -170,10 +167,9 @@ def smooth_l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy. smooth_l1_loss. This method simply - wraps the function, and so the docstring for ivy.smooth_l1_loss also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy. smooth_l1_loss. This + method simply wraps the function, and so the docstring for + ivy.smooth_l1_loss also applies to this method with minimal changes. Parameters ---------- @@ -218,10 +214,9 @@ def soft_margin_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.soft_margin_loss. This method simply - wraps the function, and so the docstring for ivy.soft_margin_loss also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.soft_margin_loss. This + method simply wraps the function, and so the docstring for + ivy.soft_margin_loss also applies to this method with minimal changes. Parameters ---------- @@ -261,10 +256,9 @@ def kl_div( log_target=False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.kl_div. This method simply wraps the - function, and so the docstring for ivy.kl_div also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.kl_div. This method simply + wraps the function, and so the docstring for ivy.kl_div also applies to + this method with minimal changes. Parameters ---------- @@ -308,8 +302,7 @@ def poisson_nll_loss( eps: float = 1e-8, reduction: str = "mean", ) -> ivy.Array: - r""" - Compute the Poisson Negative Log Likelihood Loss. + r"""Compute the Poisson Negative Log Likelihood Loss. This function calculates the negative log likelihood loss between the `input` and `target`under the assumption that @@ -380,10 +373,9 @@ def hinge_embedding_loss( margin: float = 1.0, reduction: str = "mean", ) -> ivy.Array: - r""" - Measures loss from input `x` and label `y` with values 1 or -1. It evaluates if - two inputs are similar or not, often used for embedding or semi-supervised - learning. + r"""Measures loss from input `x` and label `y` with values 1 or -1. It + evaluates if two inputs are similar or not, often used for embedding or + semi-supervised learning. Loss for the `n`-th sample: .. math:: diff --git a/ivy/data_classes/array/experimental/manipulation.py b/ivy/data_classes/array/experimental/manipulation.py index f7027eafa78ab..013af82658b0a 100644 --- a/ivy/data_classes/array/experimental/manipulation.py +++ b/ivy/data_classes/array/experimental/manipulation.py @@ -29,10 +29,9 @@ def moveaxis( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.moveaxis. This method simply wraps the - function, and so the docstring for ivy.unstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.moveaxis. This method + simply wraps the function, and so the docstring for ivy.unstack also + applies to this method with minimal changes. Parameters ---------- @@ -74,10 +73,9 @@ def heaviside( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.heaviside. This method simply wraps the - function, and so the docstring for ivy.heaviside also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.heaviside. This method + simply wraps the function, and so the docstring for ivy.heaviside also + applies to this method with minimal changes. Parameters ---------- @@ -116,10 +114,9 @@ def flipud( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.flipud. This method simply wraps the - function, and so the docstring for ivy.flipud also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.flipud. This method simply + wraps the function, and so the docstring for ivy.flipud also applies to + this method with minimal changes. Parameters ---------- @@ -160,10 +157,9 @@ def vstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.vstack. This method simply wraps the - function, and so the docstring for ivy.vstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.vstack. This method simply + wraps the function, and so the docstring for ivy.vstack also applies to + this method with minimal changes. Examples -------- @@ -192,10 +188,9 @@ def hstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.hstack. This method simply wraps the - function, and so the docstring for ivy.hstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.hstack. This method simply + wraps the function, and so the docstring for ivy.hstack also applies to + this method with minimal changes. Examples -------- @@ -222,10 +217,9 @@ def rot90( axes: Tuple[int, int] = (0, 1), out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.rot90. This method simply wraps the - function, and so the docstring for ivy.rot90 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.rot90. This method simply + wraps the function, and so the docstring for ivy.rot90 also applies to + this method with minimal changes. Parameters ---------- @@ -284,10 +278,9 @@ def top_k( sorted: bool = True, out: Optional[tuple] = None, ) -> Tuple[ivy.Array, ivy.NativeArray]: - """ - ivy.Array instance method variant of ivy.top_k. This method simply wraps the - function, and so the docstring for ivy.top_k also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.top_k. This method simply + wraps the function, and so the docstring for ivy.top_k also applies to + this method with minimal changes. Parameters ---------- @@ -329,10 +322,9 @@ def fliplr( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fliplr. This method simply wraps the - function, and so the docstring for ivy.fliplr also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fliplr. This method simply + wraps the function, and so the docstring for ivy.fliplr also applies to + this method with minimal changes. Parameters ---------- @@ -369,10 +361,9 @@ def i0( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.i0. This method simply wraps the - function, and so the docstring for ivy.i0 also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.i0. This method simply + wraps the function, and so the docstring for ivy.i0 also applies to + this method with minimal changes. Parameters ---------- @@ -404,10 +395,9 @@ def flatten( order: str = "C", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.flatten. This method simply wraps the - function, and so the docstring for ivy.flatten also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.flatten. This method simply + wraps the function, and so the docstring for ivy.flatten also applies + to this method with minimal changes. Parameters ---------- @@ -540,8 +530,7 @@ def pad( out: Optional[ivy.Array] = None, **kwargs: Optional[Any], ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.pad. + """ivy.Array instance method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -566,10 +555,9 @@ def vsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.vsplit. This method simply wraps the - function, and so the docstring for ivy.vsplit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.vsplit. This method simply + wraps the function, and so the docstring for ivy.vsplit also applies to + this method with minimal changes. Parameters ---------- @@ -613,10 +601,9 @@ def dsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.dsplit. This method simply wraps the - function, and so the docstring for ivy.dsplit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dsplit. This method simply + wraps the function, and so the docstring for ivy.dsplit also applies to + this method with minimal changes. Parameters ---------- @@ -659,10 +646,9 @@ def atleast_1d( *arys: Union[ivy.Array, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.atleast_1d. This method simply wraps - the function, and so the docstring for ivy.atleast_1d also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.atleast_1d. This method + simply wraps the function, and so the docstring for ivy.atleast_1d also + applies to this method with minimal changes. Parameters ---------- @@ -702,10 +688,9 @@ def dstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dstack. This method simply wraps the - function, and so the docstring for ivy.dstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dstack. This method simply + wraps the function, and so the docstring for ivy.dstack also applies to + this method with minimal changes. Examples -------- @@ -730,10 +715,9 @@ def atleast_2d( *arys: ivy.Array, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.atleast_2d. This method simply wraps - the function, and so the docstring for ivy.atleast_2d also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.atleast_2d. This method + simply wraps the function, and so the docstring for ivy.atleast_2d also + applies to this method with minimal changes. Parameters ---------- @@ -769,10 +753,9 @@ def atleast_3d( *arys: Union[ivy.Array, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.atleast_3d. This method simply wraps - the function, and so the docstring for ivy.atleast_3d also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.atleast_3d. This method + simply wraps the function, and so the docstring for ivy.atleast_3d also + applies to this method with minimal changes. Parameters ---------- @@ -816,10 +799,9 @@ def take_along_axis( mode: str = "fill", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.take_along_axis. This method simply - wraps the function, and so the docstring for ivy.take_along_axis also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.take_along_axis. This + method simply wraps the function, and so the docstring for + ivy.take_along_axis also applies to this method with minimal changes. Parameters ---------- @@ -858,10 +840,9 @@ def hsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.hsplit. This method simply wraps the - function, and so the docstring for ivy.hsplit also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.hsplit. This method simply + wraps the function, and so the docstring for ivy.hsplit also applies to + this method with minimal changes. Parameters ---------- @@ -913,8 +894,8 @@ def expand( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Broadcast the input Array following the given shape and the broadcast rule. + """Broadcast the input Array following the given shape and the + broadcast rule. Parameters ---------- @@ -945,8 +926,7 @@ def as_strided( strides: Sequence[int], /, ) -> ivy.Array: - """ - Create a copy of the input array with the given shape and strides. + """Create a copy of the input array with the given shape and strides. Parameters ---------- @@ -977,8 +957,7 @@ def concat_from_sequence( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Concatenate a sequence of arrays along a new or an existing axis. + """Concatenate a sequence of arrays along a new or an existing axis. Parameters ---------- @@ -1025,8 +1004,7 @@ def associative_scan( reverse: bool = False, axis: int = 0, ) -> ivy.Array: - """ - Perform an associative scan over the given array. + """Perform an associative scan over the given array. Parameters ---------- @@ -1052,8 +1030,7 @@ def unique_consecutive( *, axis: Optional[int] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.unique_consecutive. + """ivy.Array instance method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -1068,8 +1045,7 @@ def fill_diagonal( *, wrap: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fill_diag. + """ivy.Array instance method variant of ivy.fill_diag. This method simply wraps the function, and so the docstring for ivy.fill_diag also applies to this method with minimal changes. @@ -1086,8 +1062,7 @@ def take( fill_value: Optional[Number] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.take. + """ivy.Array instance method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -1165,8 +1140,7 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trim_zeros. + """ivy.Array instance method variant of ivy.trim_zeros. This method simply wraps the function, and so the docstring for ivy.trim_zeros also applies to this method with minimal changes. @@ -1206,10 +1180,9 @@ def unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.unfold. This method simply wraps the - function, and so the docstring for ivy.unfold also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.unfold. This method simply + wraps the function, and so the docstring for ivy.unfold also applies to + this method with minimal changes. Parameters ---------- @@ -1235,10 +1208,9 @@ def fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.fold. This method simply wraps the - function, and so the docstring for ivy.fold also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.fold. This method simply + wraps the function, and so the docstring for ivy.fold also applies to + this method with minimal changes. Parameters ---------- @@ -1268,10 +1240,9 @@ def partial_unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.partial_unfold. This method simply - wraps the function, and so the docstring for ivy.partial_unfold also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.partial_unfold. This method + simply wraps the function, and so the docstring for ivy.partial_unfold + also applies to this method with minimal changes. Parameters ---------- @@ -1311,10 +1282,9 @@ def partial_fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.partial_fold. This method simply wraps - the function, and so the docstring for ivy.partial_fold also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.partial_fold. This method + simply wraps the function, and so the docstring for ivy.partial_fold + also applies to this method with minimal changes. Parameters ---------- @@ -1343,10 +1313,10 @@ def partial_tensor_to_vec( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.partial_tensor_to_vec. This method - simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.partial_tensor_to_vec. This + method simply wraps the function, and so the docstring for + ivy.partial_tensor_to_vec also applies to this method with minimal + changes. Parameters ---------- @@ -1374,10 +1344,10 @@ def partial_vec_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.partial_vec_to_tensor. This method - simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.partial_vec_to_tensor. This + method simply wraps the function, and so the docstring for + ivy.partial_vec_to_tensor also applies to this method with minimal + changes. Parameters ---------- @@ -1405,10 +1375,9 @@ def matricize( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.matricize. This method simply wraps the - function, and so the docstring for ivy.matricize also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.matricize. This method + simply wraps the function, and so the docstring for ivy.matricize also + applies to this method with minimal changes. Parameters ---------- @@ -1435,10 +1404,9 @@ def soft_thresholding( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.soft_thresholding. This method simply - wraps the function, and so the docstring for ivy.soft_thresholding also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.soft_thresholding. This + method simply wraps the function, and so the docstring for + ivy.soft_thresholding also applies to this method with minimal changes. Parameters ---------- @@ -1465,8 +1433,7 @@ def column_stack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.column_stack. + """ivy.Array instance method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -1504,8 +1471,7 @@ def put_along_axis( mode: Literal["sum", "min", "max", "mul", "mean", "replace"] = "replace", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.put_along_axis. + """ivy.Array instance method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal diff --git a/ivy/data_classes/array/experimental/norms.py b/ivy/data_classes/array/experimental/norms.py index 916c63a32a521..6d8be11765f95 100644 --- a/ivy/data_classes/array/experimental/norms.py +++ b/ivy/data_classes/array/experimental/norms.py @@ -12,8 +12,7 @@ def l1_normalize( axis: Optional[Union[int, Tuple[int, ...]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Normalize the array to have unit L1 norm. + """Normalize the array to have unit L1 norm. Parameters ---------- @@ -46,8 +45,7 @@ def l2_normalize( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Normalize the array to have unit L2 norm. + """Normalize the array to have unit L2 norm. Parameters ---------- @@ -89,10 +87,9 @@ def batch_norm( data_format: str = "NSC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.batch_norm. This method simply wraps - the function, and so the docstring for ivy.batch_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.batch_norm. This method + simply wraps the function, and so the docstring for ivy.batch_norm also + applies to this method with minimal changes. Parameters ---------- @@ -160,10 +157,9 @@ def instance_norm( data_format: str = "NSC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.instance_norm. This method simply wraps - the function, and so the docstring for ivy.instance_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.instance_norm. This method + simply wraps the function, and so the docstring for ivy.instance_norm + also applies to this method with minimal changes. Parameters ---------- @@ -226,10 +222,9 @@ def group_norm( data_format: Optional[str] = "NSC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.group_norm. This method simply wraps - the function, and so the docstring for ivy.group_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.group_norm. This method + simply wraps the function, and so the docstring for ivy.group_norm also + applies to this method with minimal changes. Parameters ---------- @@ -277,8 +272,7 @@ def lp_normalize( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Normalize the array to have Lp norm. + """Normalize the array to have Lp norm. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/random.py b/ivy/data_classes/array/experimental/random.py index cd067cd304ba2..8c5f407e350e0 100644 --- a/ivy/data_classes/array/experimental/random.py +++ b/ivy/data_classes/array/experimental/random.py @@ -16,10 +16,9 @@ def dirichlet( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dirichlet. This method simply wraps the - function, and so the docstring for ivy.shuffle also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dirichlet. This method + simply wraps the function, and so the docstring for ivy.shuffle also + applies to this method with minimal changes. Parameters ---------- @@ -71,10 +70,9 @@ def beta( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.beta. This method simply wraps the - function, and so the docstring for ivy.beta also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.beta. This method simply + wraps the function, and so the docstring for ivy.beta also applies to + this method with minimal changes. Parameters ---------- @@ -122,10 +120,9 @@ def gamma( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gamma. This method simply wraps the - function, and so the docstring for ivy.gamma also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.gamma. This method simply + wraps the function, and so the docstring for ivy.gamma also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/searching.py b/ivy/data_classes/array/experimental/searching.py index 6dc82e7b1716a..99b5925179417 100644 --- a/ivy/data_classes/array/experimental/searching.py +++ b/ivy/data_classes/array/experimental/searching.py @@ -14,10 +14,9 @@ def unravel_index( *, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array]: - """ - ivy.Array instance method variant of ivy.unravel_index. This method simply wraps - the function, and so the docstring for ivy.unravel_index also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.unravel_index. This method + simply wraps the function, and so the docstring for ivy.unravel_index + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/sorting.py b/ivy/data_classes/array/experimental/sorting.py index e3aa93f401e0b..a073f02fd812e 100644 --- a/ivy/data_classes/array/experimental/sorting.py +++ b/ivy/data_classes/array/experimental/sorting.py @@ -15,10 +15,9 @@ def lexsort( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lexsort. This method simply wraps the - function, and so the docstring for ivy.lexsort also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.lexsort. This method simply + wraps the function, and so the docstring for ivy.lexsort also applies + to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/statistical.py b/ivy/data_classes/array/experimental/statistical.py index d206ff796fae0..8b8570f8d885d 100644 --- a/ivy/data_classes/array/experimental/statistical.py +++ b/ivy/data_classes/array/experimental/statistical.py @@ -21,10 +21,9 @@ def histogram( density: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.histogram. This method simply wraps the - function, and so the docstring for ivy.histogram also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.histogram. This method + simply wraps the function, and so the docstring for ivy.histogram also + applies to this method with minimal changes. Parameters ---------- @@ -97,10 +96,9 @@ def median( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.median. This method simply wraps the - function, and so the docstring for ivy.median also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.median. This method simply + wraps the function, and so the docstring for ivy.median also applies to + this method with minimal changes. Parameters ---------- @@ -139,10 +137,9 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanmean. This method simply wraps the - function, and so the docstring for ivy.nanmean also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nanmean. This method simply + wraps the function, and so the docstring for ivy.nanmean also applies + to this method with minimal changes. Parameters ---------- @@ -190,10 +187,9 @@ def nanmin( where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanmin. This method simply wraps the - function, and so the docstring for ivy.min also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nanmin. This method simply + wraps the function, and so the docstring for ivy.min also applies to + this method with minimal changes. Parameters ---------- @@ -246,10 +242,9 @@ def nanprod( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanprod. This method simply wraps the - function, and so the docstring for ivy.prod also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nanprod. This method simply + wraps the function, and so the docstring for ivy.prod also applies to + this method with minimal changes. Parameters ---------- @@ -305,10 +300,9 @@ def quantile( interpolation: str = "linear", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.quantile. This method simply wraps the - function, and so the docstring for ivy.quantile also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.quantile. This method + simply wraps the function, and so the docstring for ivy.quantile also + applies to this method with minimal changes. Parameters ---------- @@ -389,10 +383,9 @@ def corrcoef( rowvar: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.corrcoef. This method simply wraps the - function, and so the docstring for ivy.corrcoef also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.corrcoef. This method + simply wraps the function, and so the docstring for ivy.corrcoef also + applies to this method with minimal changes. Parameters ---------- @@ -433,10 +426,9 @@ def nanmedian( overwrite_input: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanmedian. This method simply wraps the - function, and so the docstring for ivy.nanmedian also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.nanmedian. This method + simply wraps the function, and so the docstring for ivy.nanmedian also + applies to this method with minimal changes. Parameters ---------- @@ -496,10 +488,9 @@ def bincount( minlength: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.bincount. This method simply wraps the - function, and so the docstring for ivy.bincount also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.bincount. This method + simply wraps the function, and so the docstring for ivy.bincount also + applies to this method with minimal changes. Parameters ---------- @@ -542,10 +533,9 @@ def igamma( x: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.igamma. This method simply wraps the - function, and so the docstring for ivy.igamma also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.igamma. This method simply + wraps the function, and so the docstring for ivy.igamma also applies to + this method with minimal changes. Parameters ---------- @@ -587,10 +577,9 @@ def cov( aweights: Optional[ivy.Array] = None, dtype: Optional[type] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cov. This method simply wraps the - function, and so the docstring for ivy.cov also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cov. This method simply + wraps the function, and so the docstring for ivy.cov also applies to + this method with minimal changes. Parameters ---------- @@ -672,10 +661,9 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cummax. This method simply wraps the - function, and so the docstring for ivy.cummax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cummax. This method simply + wraps the function, and so the docstring for ivy.cummax also applies to + this method with minimal changes. Parameters ---------- @@ -742,10 +730,9 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cummin. This method simply wraps the - function, and so the docstring for ivy.cummin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cummin. This method simply + wraps the function, and so the docstring for ivy.cummin also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/experimental/utility.py b/ivy/data_classes/array/experimental/utility.py index 46aaccd3510ad..d8f8c8e8554c1 100644 --- a/ivy/data_classes/array/experimental/utility.py +++ b/ivy/data_classes/array/experimental/utility.py @@ -13,11 +13,10 @@ def optional_get_element( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - If the input is a tensor or sequence type, it returns the input. If the input is - an optional type, it outputs the element in the input. It is an error if the - input is an empty optional-type (i.e. does not have an element) and the behavior - is undefined in this case. + """If the input is a tensor or sequence type, it returns the input. If + the input is an optional type, it outputs the element in the input. It + is an error if the input is an empty optional-type (i.e. does not have + an element) and the behavior is undefined in this case. Parameters ---------- diff --git a/ivy/data_classes/array/general.py b/ivy/data_classes/array/general.py index 87d5bae046c94..8aa3194c8caf2 100644 --- a/ivy/data_classes/array/general.py +++ b/ivy/data_classes/array/general.py @@ -17,10 +17,9 @@ def is_native_array( *, exclusive: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.is_native_array. This method simply - wraps the function, and so the docstring for ivy.is_native_array also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.is_native_array. This + method simply wraps the function, and so the docstring for + ivy.is_native_array also applies to this method with minimal changes. Parameters ---------- @@ -45,10 +44,9 @@ def is_native_array( return ivy.is_native_array(self, exclusive=exclusive) def is_ivy_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: - """ - ivy.Array instance method variant of ivy.is_ivy_array. This method simply wraps - the function, and so the docstring for ivy.is_ivy_array also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.is_ivy_array. This method + simply wraps the function, and so the docstring for ivy.is_ivy_array + also applies to this method with minimal changes. Parameters ---------- @@ -73,10 +71,9 @@ def is_ivy_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: return ivy.is_ivy_array(self, exclusive=exclusive) def is_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: - """ - ivy.Array instance method variant of ivy.is_array. This method simply wraps the - function, and so the docstring for ivy.is_array also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.is_array. This method + simply wraps the function, and so the docstring for ivy.is_array also + applies to this method with minimal changes. Parameters ---------- @@ -100,10 +97,9 @@ def is_array(self: ivy.Array, /, *, exclusive: bool = False) -> bool: return ivy.is_array(self, exclusive=exclusive) def is_ivy_container(self: ivy.Array) -> bool: - """ - ivy.Array instance method variant of ivy.is_ivy_container. This method simply - wraps the function, and so the docstring for ivy.is_ivy_container also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.is_ivy_container. This + method simply wraps the function, and so the docstring for + ivy.is_ivy_container also applies to this method with minimal changes. Parameters ---------- @@ -126,10 +122,9 @@ def is_ivy_container(self: ivy.Array) -> bool: def all_equal( self: ivy.Array, *x2: Iterable[Any], equality_matrix: bool = False ) -> Union[bool, ivy.Array, ivy.NativeArray]: - """ - ivy.Array instance method variant of ivy.all_equal. This method simply wraps the - function, and so the docstring for ivy.all_equal also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.all_equal. This method + simply wraps the function, and so the docstring for ivy.all_equal also + applies to this method with minimal changes. Parameters ---------- @@ -168,10 +163,9 @@ def all_equal( return ivy.all_equal(*arrays, equality_matrix=equality_matrix) def has_nans(self: ivy.Array, /, *, include_infs: bool = True): - """ - ivy.Array instance method variant of ivy.has_nans. This method simply wraps the - function, and so the docstring for ivy.has_nans also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.has_nans. This method + simply wraps the function, and so the docstring for ivy.has_nans also + applies to this method with minimal changes. Parameters ---------- @@ -204,10 +198,9 @@ def gather( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gather. This method simply wraps the - function, and so the docstring for ivy.gather also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.gather. This method simply + wraps the function, and so the docstring for ivy.gather also applies to + this method with minimal changes. Parameters ---------- @@ -277,8 +270,7 @@ def scatter_nd( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Scatter updates into an array according to indices. + """Scatter updates into an array according to indices. Parameters ---------- @@ -331,10 +323,9 @@ def gather_nd( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gather_nd. This method simply wraps the - function, and so the docstring for ivy.gather_nd also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.gather_nd. This method + simply wraps the function, and so the docstring for ivy.gather_nd also + applies to this method with minimal changes. Parameters ---------- @@ -371,10 +362,9 @@ def einops_rearrange( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.einops_rearrange. This method simply - wraps the function, and so the docstring for ivy.einops_rearrange also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.einops_rearrange. This + method simply wraps the function, and so the docstring for + ivy.einops_rearrange also applies to this method with minimal changes. Parameters ---------- @@ -433,10 +423,9 @@ def einops_reduce( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.einops_reduce. This method simply wraps - the function, and so the docstring for ivy.einops_reduce also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.einops_reduce. This method + simply wraps the function, and so the docstring for ivy.einops_reduce + also applies to this method with minimal changes. Parameters ---------- @@ -495,10 +484,9 @@ def einops_repeat( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.einops_repeat. This method simply wraps - the function, and so the docstring for ivy.einops_repeat also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.einops_repeat. This method + simply wraps the function, and so the docstring for ivy.einops_repeat + also applies to this method with minimal changes. Parameters ---------- @@ -540,10 +528,9 @@ def einops_repeat( return ivy.einops_repeat(self._data, pattern, out=out, **axes_lengths) def to_numpy(self: ivy.Array, /, *, copy: bool = True) -> np.ndarray: - """ - ivy.Array instance method variant of ivy.to_numpy. This method simply wraps the - function, and so the docstring for ivy.to_numpy also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.to_numpy. This method + simply wraps the function, and so the docstring for ivy.to_numpy also + applies to this method with minimal changes. Parameters ---------- @@ -576,10 +563,9 @@ def to_numpy(self: ivy.Array, /, *, copy: bool = True) -> np.ndarray: return ivy.to_numpy(self, copy=copy) def to_list(self: ivy.Array, /) -> List: - """ - ivy.Array instance method variant of ivy.to_list. This method simply wraps the - function, and so the docstring for ivy.to_list also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.to_list. This method simply + wraps the function, and so the docstring for ivy.to_list also applies + to this method with minimal changes. Parameters ---------- @@ -605,9 +591,8 @@ def to_list(self: ivy.Array, /) -> List: def to_file( self: ivy.Array, fid: Union[str, bytes, int], sep: str = "", format_: str = "%s" ) -> None: - """ - ivy.Array instance method variant of to_file. Write array to a file as text or - binary. The data is always written in 'C' order. + """ivy.Array instance method variant of to_file. Write array to a file + as text or binary. The data is always written in 'C' order. Parameters ---------- @@ -640,10 +625,10 @@ def to_file( return ivy.to_file(self, fid, sep, format_) def supports_inplace_updates(self: ivy.Array, /) -> bool: - """ - ivy.Array instance method variant of ivy.supports_inplace_updates. This method - simply wraps the function, and so the docstring for ivy.supports_inplace_updates - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.supports_inplace_updates. + This method simply wraps the function, and so the docstring for + ivy.supports_inplace_updates also applies to this method with minimal + changes. Parameters ---------- @@ -677,10 +662,9 @@ def supports_inplace_updates(self: ivy.Array, /) -> bool: def inplace_decrement( self: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray] ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.inplace_decrement. This method simply - wraps the function, and so the docstring for ivy.inplace_decrement also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.inplace_decrement. This + method simply wraps the function, and so the docstring for + ivy.inplace_decrement also applies to this method with minimal changes. Parameters ---------- @@ -719,10 +703,9 @@ def stable_divide( Union[Number, ivy.Array, ivy.NativeArray, ivy.Container] ] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.stable_divide. This method simply wraps - the function, and so the docstring for ivy.stable_divide also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.stable_divide. This method + simply wraps the function, and so the docstring for ivy.stable_divide + also applies to this method with minimal changes. Parameters ---------- @@ -770,10 +753,9 @@ def clip_vector_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.clip_vector_norm. This method simply - wraps the function, and so the docstring for ivy.clip_vector_norm also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.clip_vector_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_vector_norm also applies to this method with minimal changes. Parameters ---------- @@ -805,10 +787,9 @@ def clip_vector_norm( return ivy.clip_vector_norm(self, max_norm, p=p, out=out) def array_equal(self: ivy.Array, x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """ - ivy.Array instance method variant of ivy.array_equal. This method simply wraps - the function, and so the docstring for ivy.array_equal also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.array_equal. This method + simply wraps the function, and so the docstring for ivy.array_equal + also applies to this method with minimal changes. Parameters ---------- @@ -845,10 +826,10 @@ def array_equal(self: ivy.Array, x: Union[ivy.Array, ivy.NativeArray], /) -> boo return ivy.array_equal(self, x) def assert_supports_inplace(self: ivy.Array, /) -> bool: - """ - ivy.Array instance method variant of ivy.assert_supports_inplace. This method - simply wraps the function, and so the docstring for ivy.assert_supports_inplace - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.assert_supports_inplace. + This method simply wraps the function, and so the docstring for + ivy.assert_supports_inplace also applies to this method with minimal + changes. Parameters ---------- @@ -879,10 +860,9 @@ def assert_supports_inplace(self: ivy.Array, /) -> bool: return ivy.assert_supports_inplace(self) def to_scalar(self: ivy.Array) -> Number: - """ - ivy.Array instance method variant of ivy.to_scalar. This method simply wraps the - function, and so the docstring for ivy.to_scalar also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.to_scalar. This method + simply wraps the function, and so the docstring for ivy.to_scalar also + applies to this method with minimal changes. Parameters ---------- @@ -915,10 +895,9 @@ def fourier_encode( concat: bool = True, flatten: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Tuple]: - """ - ivy.Array instance method variant of ivy.fourier_encode. This method simply - wraps the function, and so the docstring for ivy.fourier_encode also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.fourier_encode. This method + simply wraps the function, and so the docstring for ivy.fourier_encode + also applies to this method with minimal changes. Parameters ---------- @@ -979,10 +958,9 @@ def fourier_encode( ) def value_is_nan(self: ivy.Array, /, *, include_infs: bool = True) -> bool: - """ - ivy.Array instance method variant of ivy.value_is_nan. This method simply wraps - the function, and so the docstring for ivy.value_is_nan also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.value_is_nan. This method + simply wraps the function, and so the docstring for ivy.value_is_nan + also applies to this method with minimal changes. Parameters ---------- @@ -1023,10 +1001,9 @@ def value_is_nan(self: ivy.Array, /, *, include_infs: bool = True) -> bool: return ivy.value_is_nan(self, include_infs=include_infs) def exists(self: ivy.Array, /) -> bool: - """ - ivy.Array instance method variant of ivy.exists. This method simply wraps the - function, and so the docstring for ivy.exists also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.exists. This method simply + wraps the function, and so the docstring for ivy.exists also applies to + this method with minimal changes. Parameters ---------- @@ -1061,10 +1038,9 @@ def default( rev: bool = False, with_callable: bool = False, ) -> Any: - """ - ivy.Array instance method variant of ivy.default. This method simply wraps the - function, and so the docstring for ivy.default also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.default. This method simply + wraps the function, and so the docstring for ivy.default also applies + to this method with minimal changes. Parameters ---------- @@ -1107,10 +1083,9 @@ def stable_pow( *, min_base: Optional[float] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.stable_pow. This method simply wraps - the function, and so the docstring for ivy.stable_pow also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.stable_pow. This method + simply wraps the function, and so the docstring for ivy.stable_pow also + applies to this method with minimal changes. Parameters ---------- @@ -1152,10 +1127,9 @@ def inplace_update( ensure_in_backend: bool = False, keep_input_dtype: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.inplace_update. This method simply - wraps the function, and so the docstring for ivy.inplace_update also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.inplace_update. This method + simply wraps the function, and so the docstring for ivy.inplace_update + also applies to this method with minimal changes. Parameters ---------- @@ -1220,10 +1194,9 @@ def inplace_update( def inplace_increment( self: ivy.Array, val: Union[ivy.Array, ivy.NativeArray] ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.inplace_increment. This method wraps - the function, and so the docstring for ivy.inplace_increment also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.inplace_increment. This + method wraps the function, and so the docstring for + ivy.inplace_increment also applies to this method with minimal changes. Parameters ---------- @@ -1261,10 +1234,9 @@ def clip_matrix_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.clip_matrix_norm. This method simply - wraps the function, and so the docstring for ivy.clip_matrix_norm also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.clip_matrix_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_matrix_norm also applies to this method with minimal changes. Parameters ---------- @@ -1303,10 +1275,9 @@ def scatter_flat( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.scatter_flat. This method simply wraps - the function, and so the docstring for ivy.scatter_flat also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.scatter_flat. This method + simply wraps the function, and so the docstring for ivy.scatter_flat + also applies to this method with minimal changes. Parameters ---------- @@ -1351,10 +1322,9 @@ def scatter_flat( return ivy.scatter_flat(self, updates, size=size, reduction=reduction, out=out) def get_num_dims(self: ivy.Array, /, *, as_array: bool = False) -> int: - """ - ivy.Array instance method variant of ivy.shape. This method simply wraps the - function, and so the docstring for ivy.shape also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.shape. This method simply + wraps the function, and so the docstring for ivy.shape also applies to + this method with minimal changes. Parameters ---------- @@ -1396,10 +1366,9 @@ def isin( assume_unique: bool = False, invert: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.isin. This method simply wraps the - function, and so the docstring for ivy.isin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.isin. This method simply + wraps the function, and so the docstring for ivy.isin also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/gradients.py b/ivy/data_classes/array/gradients.py index 3f0cb0fda507f..bb0b7164d95d4 100644 --- a/ivy/data_classes/array/gradients.py +++ b/ivy/data_classes/array/gradients.py @@ -16,10 +16,9 @@ def stop_gradient( preserve_type: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.stop_gradient. This method simply wraps - the function, and so the docstring for ivy.stop_gradient also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.stop_gradient. This method + simply wraps the function, and so the docstring for ivy.stop_gradient + also applies to this method with minimal changes. Parameters ---------- @@ -58,10 +57,9 @@ def adam_step( epsilon: float = 1e-7, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.adam_step. This method simply wraps the - function, and so the docstring for ivy.adam_step also applies to this method - with minimal changes. + """ivy.Array instance method variant of ivy.adam_step. This method + simply wraps the function, and so the docstring for ivy.adam_step also + applies to this method with minimal changes. Parameters ---------- @@ -116,10 +114,9 @@ def optimizer_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.optimizer_update. This method simply - wraps the function, and so the docstring for ivy.optimizer_update also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.optimizer_update. This + method simply wraps the function, and so the docstring for + ivy.optimizer_update also applies to this method with minimal changes. Parameters ---------- @@ -165,10 +162,10 @@ def gradient_descent_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.gradient_descent_update. This method - simply wraps the function, and so the docstring for ivy.gradient_descent_update - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.gradient_descent_update. + This method simply wraps the function, and so the docstring for + ivy.gradient_descent_update also applies to this method with minimal + changes. Parameters ---------- @@ -222,10 +219,9 @@ def lars_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lars_update. This method simply wraps - the function, and so the docstring for ivy.lars_update also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.lars_update. This method + simply wraps the function, and so the docstring for ivy.lars_update + also applies to this method with minimal changes. Parameters ---------- @@ -288,10 +284,9 @@ def adam_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.adam_update. This method simply wraps - the function, and so the docstring for ivy.adam_update also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.adam_update. This method + simply wraps the function, and so the docstring for ivy.adam_update + also applies to this method with minimal changes. Parameters ---------- @@ -376,10 +371,9 @@ def lamb_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.lamb_update. This method simply wraps - the function, and so the docstring for ivy.lamb_update also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.lamb_update. This method + simply wraps the function, and so the docstring for ivy.lamb_update + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/layers.py b/ivy/data_classes/array/layers.py index f4c42a5d6de6d..3ecec50f7bc0e 100644 --- a/ivy/data_classes/array/layers.py +++ b/ivy/data_classes/array/layers.py @@ -20,10 +20,9 @@ def linear( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.linear. This method simply wraps the - function, and so the docstring for ivy.linear also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.linear. This method simply + wraps the function, and so the docstring for ivy.linear also applies to + this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def dropout( noise_shape: Optional[Sequence[int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dropout. This method simply wraps the - function, and so the docstring for ivy.dropout also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dropout. This method simply + wraps the function, and so the docstring for ivy.dropout also applies + to this method with minimal changes. Parameters ---------- @@ -157,10 +155,9 @@ def dropout1d( data_format: str = "NWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dropout1d. This method simply wraps the - function, and so the docstring for ivy.droput1d also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dropout1d. This method + simply wraps the function, and so the docstring for ivy.droput1d also + applies to this method with minimal changes. Parameters ---------- @@ -205,10 +202,9 @@ def dropout2d( data_format: str = "NHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dropout2d. This method simply wraps the - function, and so the docstring for ivy.droput1d also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dropout2d. This method + simply wraps the function, and so the docstring for ivy.droput1d also + applies to this method with minimal changes. Parameters ---------- @@ -254,10 +250,9 @@ def dropout3d( data_format: str = "NDHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.dropout3d. This method simply wraps the - function, and so the docstring for ivy.droput3d also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.dropout3d. This method + simply wraps the function, and so the docstring for ivy.droput3d also + applies to this method with minimal changes. Parameters ---------- @@ -299,11 +294,10 @@ def scaled_dot_product_attention( training: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.scaled_dot_product_attention. This - method simply wraps the function, and so the docstring for - ivy.scaled_dot_product_attention also applies to this method with minimal - changes. + """ivy.Array instance method variant of + ivy.scaled_dot_product_attention. This method simply wraps the + function, and so the docstring for ivy.scaled_dot_product_attention + also applies to this method with minimal changes. Parameters ---------- @@ -463,10 +457,9 @@ def conv1d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.conv1d. This method simply wraps the - function, and so the docstring for ivy.conv1d also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.conv1d. This method simply + wraps the function, and so the docstring for ivy.conv1d also applies to + this method with minimal changes. Parameters ---------- @@ -536,10 +529,9 @@ def conv1d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.conv1d_transpose. This method simply - wraps the function, and so the docstring for ivy.conv1d_transpose also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.conv1d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv1d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -610,10 +602,9 @@ def depthwise_conv2d( dilations: Union[int, Tuple[int], Tuple[int, int]] = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.depthwise_conv2d. This method simply - wraps the function, and so the docstring for ivy.depthwise_conv2d also applies - to this method with minimal changes. + """ivy.Array instance method variant of ivy.depthwise_conv2d. This + method simply wraps the function, and so the docstring for + ivy.depthwise_conv2d also applies to this method with minimal changes. Parameters ---------- @@ -671,10 +662,9 @@ def conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.conv2d`. This method simply wraps the - function, and so the docstring for `ivy.conv2d` also applies to this method with - minimal changes. + """ivy.Array instance method variant of `ivy.conv2d`. This method + simply wraps the function, and so the docstring for `ivy.conv2d` also + applies to this method with minimal changes. Parameters ---------- @@ -750,10 +740,10 @@ def conv2d_transpose( out: Optional[ivy.Array] = None, bias: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.conv2d_transpose`. This method simply - wraps the function, and so the docstring for `ivy.conv2d_transpose` also applies - to this method with minimal changes. + """ivy.Array instance method variant of `ivy.conv2d_transpose`. This + method simply wraps the function, and so the docstring for + `ivy.conv2d_transpose` also applies to this method with minimal + changes. Parameters ---------- @@ -824,10 +814,9 @@ def conv3d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.conv3d`. This method simply wraps the - function, and so the docstring for `ivy.conv3d` also applies to this method with - minimal changes. + """ivy.Array instance method variant of `ivy.conv3d`. This method + simply wraps the function, and so the docstring for `ivy.conv3d` also + applies to this method with minimal changes. Parameters ---------- @@ -896,10 +885,10 @@ def conv3d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of `ivy.conv3d_transpose`. This method simply - wraps the function, and so the docstring for `ivy.conv3d_transpose` also applies - to this method with minimal changes. + """ivy.Array instance method variant of `ivy.conv3d_transpose`. This + method simply wraps the function, and so the docstring for + `ivy.conv3d_transpose` also applies to this method with minimal + changes. Parameters ---------- @@ -968,10 +957,9 @@ def lstm_update( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, recurrent_bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.lstm_update. This method simply wraps - the function, and so the docstring for ivy.lstm_update also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.lstm_update. This method + simply wraps the function, and so the docstring for ivy.lstm_update + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/linear_algebra.py b/ivy/data_classes/array/linear_algebra.py index a25df9d4cabb7..025932fa11f0c 100644 --- a/ivy/data_classes/array/linear_algebra.py +++ b/ivy/data_classes/array/linear_algebra.py @@ -21,10 +21,9 @@ def matmul( adjoint_b: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.matmul. This method simply wraps the - function, and so the docstring for ivy.matmul also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.matmul. This method simply + wraps the function, and so the docstring for ivy.matmul also applies to + this method with minimal changes. Parameters ---------- @@ -82,10 +81,9 @@ def cholesky( upper: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cholesky. This method simply wraps the - function, and so the docstring for ivy.cholesky also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cholesky. This method + simply wraps the function, and so the docstring for ivy.cholesky also + applies to this method with minimal changes. Parameters ---------- @@ -135,10 +133,9 @@ def cross( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cross. This method simply wraps the - function, and so the docstring for ivy.cross also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cross. This method simply + wraps the function, and so the docstring for ivy.cross also applies to + this method with minimal changes. Parameters ---------- @@ -194,10 +191,9 @@ def diagonal( axis2: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.diagonal. This method simply wraps the - function, and so the docstring for ivy.diagonal also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.diagonal. This method + simply wraps the function, and so the docstring for ivy.diagonal also + applies to this method with minimal changes. Parameters ---------- @@ -274,10 +270,9 @@ def diag( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.diag. This method simply wraps the - function, and so the docstring for ivy.diag also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.diag. This method simply + wraps the function, and so the docstring for ivy.diag also applies to + this method with minimal changes. Examples -------- @@ -313,10 +308,9 @@ def eigvalsh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.eigvalsh. This method simply wraps the - function, and so the docstring for ivy.eigvalsh also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.eigvalsh. This method + simply wraps the function, and so the docstring for ivy.eigvalsh also + applies to this method with minimal changes. Parameters ---------- @@ -362,8 +356,7 @@ def inner( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the inner product of two vectors ``self`` and ``x2``. + """Return the inner product of two vectors ``self`` and ``x2``. Parameters ---------- @@ -421,10 +414,9 @@ def inner( def inv( self: ivy.Array, /, *, adjoint: bool = False, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.inv. This method simply wraps the - function, and so the docstring for ivy.inv also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.inv. This method simply + wraps the function, and so the docstring for ivy.inv also applies to + this method with minimal changes. Parameters ---------- @@ -463,10 +455,9 @@ def matrix_norm( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.matrix_norm. This method simply wraps - the function, and so the docstring for ivy.matrix_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.matrix_norm. This method + simply wraps the function, and so the docstring for ivy.matrix_norm + also applies to this method with minimal changes. Parameters ---------- @@ -525,10 +516,9 @@ def matrix_rank( hermitian: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.matrix_rank. This method returns the - rank (i.e., number of non-zero singular values) of a matrix (or a stack of - matrices). + """ivy.Array instance method variant of ivy.matrix_rank. This method + returns the rank (i.e., number of non-zero singular values) of a matrix + (or a stack of matrices). Parameters ---------- @@ -599,8 +589,7 @@ def matrix_rank( def matrix_transpose( self: ivy.Array, /, *, conjugate: bool = False, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Transpose a matrix (or a stack of matrices) ``x``. + """Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -637,8 +626,7 @@ def outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the outer product between two arrays. + """Compute the outer product between two arrays. Parameters ---------- @@ -674,10 +662,9 @@ def pinv( rtol: Optional[Union[float, Tuple[float]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.pinv. This method simply wraps the - function, and so the docstring for ivy.pinv also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.pinv. This method simply + wraps the function, and so the docstring for ivy.pinv also applies to + this method with minimal changes. Parameters ---------- @@ -719,10 +706,9 @@ def qr( mode: str = "reduced", out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.qr. This method simply wraps the - function, and so the docstring for ivy.qr also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.qr. This method simply + wraps the function, and so the docstring for ivy.qr also applies to + this method with minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -779,10 +765,9 @@ def qr( def slogdet( self: ivy.Array, ) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.slogdet. This method simply wraps the - function, and so the docstring for ivy.slogdet also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.slogdet. This method simply + wraps the function, and so the docstring for ivy.slogdet also applies + to this method with minimal changes. Parameters ---------- @@ -836,10 +821,9 @@ def svd( compute_uv: bool = True, full_matrices: bool = True, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """ - ivy.Array instance method variant of ivy.svf. This method simply wraps the - function, and so the docstring for ivy.svd also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.svf. This method simply + wraps the function, and so the docstring for ivy.svd also applies to + this method with minimal changes. Parameters ---------- @@ -924,9 +908,9 @@ def trace( axis2: int = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.trace. This method Returns the sum - along the specified diagonals of a matrix (or a stack of matrices). + """ivy.Array instance method variant of ivy.trace. This method Returns + the sum along the specified diagonals of a matrix (or a stack of + matrices). Parameters ---------- @@ -996,9 +980,8 @@ def vector_norm( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.vector_norm. This method computes the - vector norm of a vector (or batch of vectors). + """ivy.Array instance method variant of ivy.vector_norm. This method + computes the vector norm of a vector (or batch of vectors). Parameters ---------- @@ -1089,9 +1072,8 @@ def vander( increasing: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.vander. This method Returns the - Vandermonde matrix of the input array. + """ivy.Array instance method variant of ivy.vander. This method Returns + the Vandermonde matrix of the input array. Parameters ---------- diff --git a/ivy/data_classes/array/losses.py b/ivy/data_classes/array/losses.py index 214c05ac5a189..b11f9d9399e3b 100644 --- a/ivy/data_classes/array/losses.py +++ b/ivy/data_classes/array/losses.py @@ -17,10 +17,9 @@ def cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cross_entropy. This method simply wraps - the function, and so the docstring for ivy.cross_entropy also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.cross_entropy. This method + simply wraps the function, and so the docstring for ivy.cross_entropy + also applies to this method with minimal changes. Parameters ---------- @@ -69,10 +68,10 @@ def binary_cross_entropy( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.binary_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.binary_cross_entropy - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.binary_cross_entropy. This + method simply wraps the function, and so the docstring for + ivy.binary_cross_entropy also applies to this method with minimal + changes. Parameters ---------- @@ -134,10 +133,10 @@ def sparse_cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sparse_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.sparse_cross_entropy - also applies to this method with minimal changes. + """ivy.Array instance method variant of ivy.sparse_cross_entropy. This + method simply wraps the function, and so the docstring for + ivy.sparse_cross_entropy also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/array/manipulation.py b/ivy/data_classes/array/manipulation.py index b2a4abb98243a..231a356ca6be4 100644 --- a/ivy/data_classes/array/manipulation.py +++ b/ivy/data_classes/array/manipulation.py @@ -32,10 +32,9 @@ def concat( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.concat. This method simply wraps the - function, and so the docstring for ivy.concat also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.concat. This method simply + wraps the function, and so the docstring for ivy.concat also applies to + this method with minimal changes. Parameters ---------- @@ -69,10 +68,9 @@ def expand_dims( axis: Union[int, Sequence[int]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.expand_dims. This method simply wraps - the function, and so the docstring for ivy.expand_dims also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.expand_dims. This method + simply wraps the function, and so the docstring for ivy.expand_dims + also applies to this method with minimal changes. Parameters ---------- @@ -116,10 +114,9 @@ def flip( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.flip. This method simply wraps the - function, and so the docstring for ivy.flip also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.flip. This method simply + wraps the function, and so the docstring for ivy.flip also applies to + this method with minimal changes. Parameters ---------- @@ -170,10 +167,9 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.permute_dims. This method simply wraps - the function, and so the docstring for ivy.permute_dims also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.permute_dims. This method + simply wraps the function, and so the docstring for ivy.permute_dims + also applies to this method with minimal changes. Parameters ---------- @@ -229,10 +225,9 @@ def reshape( allowzero: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.reshape. This method simply wraps the - function, and so the docstring for ivy.reshape also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.reshape. This method simply + wraps the function, and so the docstring for ivy.reshape also applies + to this method with minimal changes. Parameters ---------- @@ -297,10 +292,9 @@ def roll( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.roll. This method simply wraps the - function, and so the docstring for ivy.roll also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.roll. This method simply + wraps the function, and so the docstring for ivy.roll also applies to + this method with minimal changes. Parameters ---------- @@ -354,10 +348,9 @@ def squeeze( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.squeeze. This method simply wraps the - function, and so the docstring for ivy.squeeze also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.squeeze. This method simply + wraps the function, and so the docstring for ivy.squeeze also applies + to this method with minimal changes. Parameters ---------- @@ -403,10 +396,9 @@ def stack( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.stack also applies to + this method with minimal changes. Parameters ---------- @@ -454,10 +446,9 @@ def clip( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.clip. This method simply wraps the - function, and so the docstring for ivy.clip also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.clip. This method simply + wraps the function, and so the docstring for ivy.clip also applies to + this method with minimal changes. Parameters ---------- @@ -494,10 +485,9 @@ def constant_pad( value: Number = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.constant_pad. This method simply wraps - the function, and so the docstring for ivy.constant_pad also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.constant_pad. This method + simply wraps the function, and so the docstring for ivy.constant_pad + also applies to this method with minimal changes. Parameters ---------- @@ -536,10 +526,9 @@ def repeat( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.repeat. This method simply wraps the - function, and so the docstring for ivy.repeat also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.repeat. This method simply + wraps the function, and so the docstring for ivy.repeat also applies to + this method with minimal changes. Parameters ---------- @@ -581,10 +570,9 @@ def split( axis: int = 0, with_remainder: bool = False, ) -> List[ivy.Array]: - """ - ivy.Array instance method variant of ivy.split. This method simply wraps the - function, and so the docstring for ivy.split also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.split. This method simply + wraps the function, and so the docstring for ivy.split also applies to + this method with minimal changes. Parameters ---------- @@ -636,10 +624,9 @@ def swapaxes( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.swap_axes. This method simply wraps the - function, and so the docstring for ivy.split also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.swap_axes. This method + simply wraps the function, and so the docstring for ivy.split also + applies to this method with minimal changes. Parameters ---------- @@ -692,10 +679,9 @@ def tile( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.tile. This method simply wraps the - function, and so the docstring for ivy.tile also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.tile. This method simply + wraps the function, and so the docstring for ivy.tile also applies to + this method with minimal changes. Parameters ---------- @@ -738,10 +724,9 @@ def unstack( axis: int = 0, keepdims: bool = False, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.unstack. This method simply wraps the - function, and so the docstring for ivy.unstack also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.unstack. This method simply + wraps the function, and so the docstring for ivy.unstack also applies + to this method with minimal changes. Parameters ---------- @@ -786,10 +771,9 @@ def zero_pad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.zero_pad. This method simply wraps the - function, and so the docstring for ivy.zero_pad also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.zero_pad. This method + simply wraps the function, and so the docstring for ivy.zero_pad also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/norms.py b/ivy/data_classes/array/norms.py index 3c66c85517c20..d3116b4d0cf43 100644 --- a/ivy/data_classes/array/norms.py +++ b/ivy/data_classes/array/norms.py @@ -20,10 +20,9 @@ def layer_norm( new_std: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.layer_norm. This method simply wraps - the function, and so the docstring for ivy.layer_norm also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.layer_norm. This method + simply wraps the function, and so the docstring for ivy.layer_norm also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/random.py b/ivy/data_classes/array/random.py index 047386ee6779f..2835b7690c798 100644 --- a/ivy/data_classes/array/random.py +++ b/ivy/data_classes/array/random.py @@ -18,10 +18,9 @@ def random_uniform( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.random_uniform. This method simply - wraps the function, and so the docstring for ivy.random_uniform also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.random_uniform. This method + simply wraps the function, and so the docstring for ivy.random_uniform + also applies to this method with minimal changes. Parameters ---------- @@ -117,10 +116,9 @@ def random_normal( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.random_normal. This method simply wraps - the function, and so the docstring for ivy.random_normal also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.random_normal. This method + simply wraps the function, and so the docstring for ivy.random_normal + also applies to this method with minimal changes. Parameters ---------- @@ -215,10 +213,9 @@ def multinomial( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.multinomial. This method simply wraps - the function, and so the docstring for ivy.multinomial also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.multinomial. This method + simply wraps the function, and so the docstring for ivy.multinomial + also applies to this method with minimal changes. Parameters ---------- @@ -269,10 +266,9 @@ def randint( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.randint. This method simply wraps the - function, and so the docstring for ivy.randint also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.randint. This method simply + wraps the function, and so the docstring for ivy.randint also applies + to this method with minimal changes. Parameters ---------- @@ -363,10 +359,9 @@ def shuffle( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.shuffle. This method simply wraps the - function, and so the docstring for ivy.shuffle also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.shuffle. This method simply + wraps the function, and so the docstring for ivy.shuffle also applies + to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/searching.py b/ivy/data_classes/array/searching.py index 15537fa4b2005..527132b4248fa 100644 --- a/ivy/data_classes/array/searching.py +++ b/ivy/data_classes/array/searching.py @@ -18,10 +18,9 @@ def argmax( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, int]: - """ - ivy.Array instance method variant of ivy.argmax. This method simply wraps the - function, and so the docstring for ivy.argmax also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.argmax. This method simply + wraps the function, and so the docstring for ivy.argmax also applies to + this method with minimal changes. Parameters ---------- @@ -94,10 +93,9 @@ def argmin( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, int]: - """ - ivy.Array instance method variant of ivy.argmin. This method simply wraps the - function, and so the docstring for ivy.argmin also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.argmin. This method simply + wraps the function, and so the docstring for ivy.argmin also applies to + this method with minimal changes. Parameters ---------- @@ -162,10 +160,9 @@ def nonzero( size: Optional[int] = None, fill_value: Number = 0, ) -> Union[Tuple[ivy.Array], ivy.Array]: - """ - ivy.Array instance method variant of ivy.nonzero. This method simply wraps the - function, and so the docstring for ivy.nonzero also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nonzero. This method simply + wraps the function, and so the docstring for ivy.nonzero also applies + to this method with minimal changes. Parameters ---------- @@ -202,10 +199,9 @@ def where( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.where. This method simply wraps the - function, and so the docstring for ivy.where also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.where. This method simply + wraps the function, and so the docstring for ivy.where also applies to + this method with minimal changes. Parameters ---------- @@ -238,10 +234,9 @@ def where( return ivy.where(self._data, x1._data, x2._data, out=out) def argwhere(self: ivy.Array, *, out: Optional[ivy.Array] = None) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.argwhere. This method simply wraps the - function, and so the docstring for ivy.argwhere also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.argwhere. This method + simply wraps the function, and so the docstring for ivy.argwhere also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/set.py b/ivy/data_classes/array/set.py index cde03cfce2555..83e2aefdfbc67 100644 --- a/ivy/data_classes/array/set.py +++ b/ivy/data_classes/array/set.py @@ -8,10 +8,9 @@ class _ArrayWithSet(abc.ABC): def unique_counts(self: ivy.Array) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.unique_counts. This method simply wraps - the function, and so the docstring for ivy.unique_counts also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.unique_counts. This method + simply wraps the function, and so the docstring for ivy.unique_counts + also applies to this method with minimal changes. Parameters ---------- @@ -108,10 +107,9 @@ def unique_all( axis: Optional[int] = None, by_value: bool = True, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.unique_all. This method simply wraps - the function, and so the docstring for ivy.unique_all also applies to this - method with minimal changes. + """ivy.Array instance method variant of ivy.unique_all. This method + simply wraps the function, and so the docstring for ivy.unique_all also + applies to this method with minimal changes. Parameters ---------- @@ -146,10 +144,9 @@ def unique_all( return ivy.unique_all(self._data, axis=axis, by_value=by_value) def unique_inverse(self: ivy.Array) -> Tuple[ivy.Array, ivy.Array]: - """ - ivy.Array instance method variant of ivy.unique_inverse. This method simply - wraps the function, and so the docstring for ivy.unique_inverse also applies to - this method with minimal changes. + """ivy.Array instance method variant of ivy.unique_inverse. This method + simply wraps the function, and so the docstring for ivy.unique_inverse + also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/sorting.py b/ivy/data_classes/array/sorting.py index ceb6cfddd0566..b32929c132296 100644 --- a/ivy/data_classes/array/sorting.py +++ b/ivy/data_classes/array/sorting.py @@ -17,10 +17,9 @@ def argsort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.argsort. This method simply wraps the - function, and so the docstring for ivy.argsort also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.argsort. This method simply + wraps the function, and so the docstring for ivy.argsort also applies + to this method with minimal changes. Parameters ---------- @@ -76,10 +75,9 @@ def sort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.sort. This method simply wraps the - function, and so the docstring for ivy.sort also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.sort. This method simply + wraps the function, and so the docstring for ivy.sort also applies to + this method with minimal changes. Examples -------- @@ -103,10 +101,9 @@ def msort( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.msort. This method simply wraps the - function, and so the docstring for ivy.msort also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.msort. This method simply + wraps the function, and so the docstring for ivy.msort also applies to + this method with minimal changes. Parameters ---------- @@ -141,8 +138,7 @@ def searchsorted( ret_dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.searchsorted. + """ivy.Array instance method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal diff --git a/ivy/data_classes/array/statistical.py b/ivy/data_classes/array/statistical.py index 08f98dd2860ee..b07294c52696e 100644 --- a/ivy/data_classes/array/statistical.py +++ b/ivy/data_classes/array/statistical.py @@ -19,8 +19,7 @@ def min( where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the minimum value of the input array ``x``. + """Calculate the minimum value of the input array ``x``. Parameters ---------- @@ -93,10 +92,9 @@ def max( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.max. This method simply wraps the - function, and so the docstring for ivy.max also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.max. This method simply + wraps the function, and so the docstring for ivy.max also applies to + this method with minimal changes. Parameters ---------- @@ -156,10 +154,9 @@ def mean( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.mean. This method simply wraps the - function, and so the docstring for ivy.mean also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.mean. This method simply + wraps the function, and so the docstring for ivy.mean also applies to + this method with minimal changes. **Special Cases** @@ -244,10 +241,9 @@ def var( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.var. This method simply wraps the - function, and so the docstring for ivy.var also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.var. This method simply + wraps the function, and so the docstring for ivy.var also applies to + this method with minimal changes. **Special Cases** @@ -330,10 +326,9 @@ def prod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.array instance method variant of ivy.prod. This method simply wraps the - function, and so the docstring for ivy.prod also applies to this method with - minimal changes. + """ivy.array instance method variant of ivy.prod. This method simply + wraps the function, and so the docstring for ivy.prod also applies to + this method with minimal changes. Parameters ---------- @@ -416,10 +411,9 @@ def std( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.array instance method variant of ivy.std. This method simply wraps the - function, and so the docstring for ivy.std also applies to this method with - minimal changes. + """ivy.array instance method variant of ivy.std. This method simply + wraps the function, and so the docstring for ivy.std also applies to + this method with minimal changes. Parameters ---------- @@ -511,10 +505,9 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cumsum. This method simply wraps the - function, and so the docstring for ivy.cumsum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cumsum. This method simply + wraps the function, and so the docstring for ivy.cumsum also applies to + this method with minimal changes. Parameters ---------- @@ -586,10 +579,9 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.cumprod. This method simply wraps the - function, and so the docstring for ivy.cumprod also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.cumprod. This method simply + wraps the function, and so the docstring for ivy.cumprod also applies + to this method with minimal changes. Parameters ---------- @@ -657,10 +649,9 @@ def einsum( *operands: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.einsum. This method simply wraps the - function, and so the docstring for ivy.einsum also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.einsum. This method simply + wraps the function, and so the docstring for ivy.einsum also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/utility.py b/ivy/data_classes/array/utility.py index 089b99918be1b..a711dfd46f1f8 100644 --- a/ivy/data_classes/array/utility.py +++ b/ivy/data_classes/array/utility.py @@ -15,10 +15,9 @@ def all( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.all. This method simply wraps the - function, and so the docstring for ivy.all also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.all. This method simply + wraps the function, and so the docstring for ivy.all also applies to + this method with minimal changes. Parameters ---------- @@ -76,10 +75,9 @@ def any( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.any. This method simply wraps the - function, and so the docstring for ivy.any also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.any. This method simply + wraps the function, and so the docstring for ivy.any also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/array/wrapping.py b/ivy/data_classes/array/wrapping.py index 74105ef566edc..f79ad5a07191a 100644 --- a/ivy/data_classes/array/wrapping.py +++ b/ivy/data_classes/array/wrapping.py @@ -9,8 +9,7 @@ def _wrap_function(function_name: str) -> Callable: - """ - Wrap the function called `function_name`. + """Wrap the function called `function_name`. Parameters ---------- @@ -33,9 +32,8 @@ def _wrap_function(function_name: str) -> Callable: """ def new_function(self, *args, **kwargs): - """ - Add the data of the current array from which the instance function is invoked as - the first arg parameter or kwarg parameter. + """Add the data of the current array from which the instance function + is invoked as the first arg parameter or kwarg parameter. Return the new function with the name function_name and the new args variable or kwargs as the new inputs. @@ -63,9 +61,8 @@ def new_function(self, *args, **kwargs): def add_ivy_array_instance_methods( cls: Type[ivy.Array], modules: List[ModuleType], to_ignore: Iterable = () ): - """ - Loop over all ivy modules such as activations, general, etc. and add the module - functions to ivy arrays as instance methods using _wrap_function. + """Loop over all ivy modules such as activations, general, etc. and add the + module functions to ivy arrays as instance methods using _wrap_function. Parameters ---------- diff --git a/ivy/data_classes/container/activations.py b/ivy/data_classes/container/activations.py index 9d5883bd1d213..c8499ef9d6f91 100644 --- a/ivy/data_classes/container/activations.py +++ b/ivy/data_classes/container/activations.py @@ -21,10 +21,9 @@ def _static_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.relu. This method simply wraps the - function, and so the docstring for ivy.relu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.relu. This method simply + wraps the function, and so the docstring for ivy.relu also applies to + this method with minimal changes. Parameters ---------- @@ -86,10 +85,9 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.relu. This method simply wraps the - function, and so the docstring for ivy.relu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.relu. This method + simply wraps the function, and so the docstring for ivy.relu also + applies to this method with minimal changes. Parameters ---------- @@ -152,10 +150,9 @@ def _static_leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.leaky_relu. This method simply wraps - the function, and so the docstring for ivy.leaky_relu also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.leaky_relu. This method + simply wraps the function, and so the docstring for ivy.leaky_relu also + applies to this method with minimal changes. Parameters ---------- @@ -220,10 +217,9 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.leaky_relu. This method simply - wraps the function, and so the docstring for ivy.leaky_relu also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.leaky_relu. This method + simply wraps the function, and so the docstring for ivy.leaky_relu also + applies to this method with minimal changes. Parameters ---------- @@ -288,10 +284,9 @@ def _static_gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.gelu. This method simply wraps the - function, and so the docstring for ivy.gelu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.gelu. This method simply + wraps the function, and so the docstring for ivy.gelu also applies to + this method with minimal changes. Parameters ---------- @@ -355,10 +350,9 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gelu. This method simply wraps the - function, and so the docstring for ivy.gelu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.gelu. This method + simply wraps the function, and so the docstring for ivy.gelu also + applies to this method with minimal changes. Parameters ---------- @@ -422,10 +416,9 @@ def _static_sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sigmoid. This method simply wraps the - function, and so the docstring for ivy.sigmoid also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sigmoid. This method + simply wraps the function, and so the docstring for ivy.sigmoid also + applies to this method with minimal changes. Parameters ---------- @@ -486,10 +479,9 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sigmoid. This method simply wraps - the function, and so the docstring for ivy.sigmoid also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.sigmoid. This method + simply wraps the function, and so the docstring for ivy.sigmoid also + applies to this method with minimal changes. Parameters ---------- @@ -551,10 +543,9 @@ def _static_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.softmax. This method simply wraps the - function, and so the docstring for ivy.softmax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.softmax. This method + simply wraps the function, and so the docstring for ivy.softmax also + applies to this method with minimal changes. Parameters ---------- @@ -619,10 +610,9 @@ def softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.softmax. This method simply wraps - the function, and so the docstring for ivy.softmax also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.softmax. This method + simply wraps the function, and so the docstring for ivy.softmax also + applies to this method with minimal changes. Parameters ---------- @@ -688,10 +678,9 @@ def _static_softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.softplus. This method simply wraps - the function, and so the docstring for ivy.softplus also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.softplus. This method + simply wraps the function, and so the docstring for ivy.softplus also + applies to this method with minimal changes. Parameters ---------- @@ -767,10 +756,9 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.softplus. This method simply wraps - the function, and so the docstring for ivy.softplus also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.softplus. This method + simply wraps the function, and so the docstring for ivy.softplus also + applies to this method with minimal changes. Parameters ---------- @@ -844,10 +832,9 @@ def _static_log_softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log_softmax. This method simply wraps - the function, and so the docstring for ivy.log_softmax also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.log_softmax. This method + simply wraps the function, and so the docstring for ivy.log_softmax + also applies to this method with minimal changes. Parameters ---------- @@ -919,10 +906,9 @@ def log_softmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container instance method variant of ivy.log_softmax. This method simply - wraps the function, and so the docstring for ivy.log_softmax also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.log_softmax. This + method simply wraps the function, and so the docstring for + ivy.log_softmax also applies to this method with minimal changes. Parameters ---------- @@ -993,10 +979,9 @@ def _static_mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.mish. This method simply wraps the - function, and so the docstring for ivy.mish also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.mish. This method simply + wraps the function, and so the docstring for ivy.mish also applies to + this method with minimal changes. Parameters ---------- @@ -1058,10 +1043,9 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.mish. This method simply wraps the - function, and so the docstring for ivy.mish also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.mish. This method + simply wraps the function, and so the docstring for ivy.mish also + applies to this method with minimal changes. Parameters ---------- @@ -1123,10 +1107,9 @@ def _static_hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hardswish. This method simply wraps - the function, and so the docstring for ivy.hardswish also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.hardswish. This method + simply wraps the function, and so the docstring for ivy.hardswish also + applies to this method with minimal changes. Parameters ---------- @@ -1188,10 +1171,9 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hardswish. This method simply wraps - the function, and so the docstring for ivy.hardswish also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.hardswish. This method + simply wraps the function, and so the docstring for ivy.hardswish also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index 69dfdd6944781..b782245f53dae 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -72,8 +72,7 @@ def __init__( build_callable=False, **kwargs, ): - """ - Initialize container object from input dict representation. + """Initialize container object from input dict representation. Parameters ---------- @@ -272,9 +271,8 @@ def map_fn(vals, _): @staticmethod def cont_handle_inplace(ret, out): - """ - Return an inplace update of out, provided it is not None, by updating with the - values in ret. + """Return an inplace update of out, provided it is not None, by + updating with the values in ret. Parameters ---------- @@ -295,8 +293,7 @@ def cont_handle_inplace(ret, out): @staticmethod def cont_list_join(containers, config=None): - """ - Join containers of lists together along the specified dimension. + """Join containers of lists together along the specified dimension. Parameters ---------- @@ -328,8 +325,7 @@ def cont_list_join(containers, config=None): @staticmethod def cont_list_stack(containers, dim, config=None): - """ - List stack containers together along the specified dimension. + """List stack containers together along the specified dimension. Parameters ---------- @@ -379,9 +375,8 @@ def _cont_mean_unify(containers, device, _=None, _1=None): @staticmethod def cont_unify(containers, device, mode, axis=0): - """ - Unify a list of containers, on arbitrary devices, to a single container on the - specified device. + """Unify a list of containers, on arbitrary devices, to a single + container on the specified device. Parameters ---------- @@ -407,9 +402,8 @@ def cont_unify(containers, device, mode, axis=0): @staticmethod def cont_combine(*containers, config=None): - """ - Combine keys and values in a sequence of containers, with priority given to the - right-most container in the case of duplicates. + """Combine keys and values in a sequence of containers, with priority + given to the right-most container in the case of duplicates. Parameters ---------- @@ -466,10 +460,9 @@ def cont_diff( detect_shape_diffs=True, config=None, ): - """ - Compare keys and values in a sequence of containers, returning the single shared - values where they are the same, and new nested sub-dicts with all values where - they are different. + """Compare keys and values in a sequence of containers, returning the + single shared values where they are the same, and new nested sub-dicts + with all values where they are different. Parameters ---------- @@ -613,10 +606,9 @@ def cont_structural_diff( detect_shape_diffs=True, config=None, ): - """ - Compare keys and shapes in a sequence of containers, returning the single shared - values where they are the same, and new nested sub-dicts with all values where - they are different. + """Compare keys and shapes in a sequence of containers, returning the + single shared values where they are the same, and new nested sub-dicts + with all values where they are different. Parameters ---------- @@ -666,8 +658,7 @@ def cont_multi_map( map_nests=False, assert_identical=False, ): - """ - Apply function to all array values from a collection of containers. + """Apply function to all array values from a collection of containers. Parameters ---------- @@ -786,8 +777,7 @@ def _found_in_key_chains(this_key_chain, key_chains): @staticmethod def cont_common_key_chains(containers): - """ - Return the key-chains common across all containers. + """Return the key-chains common across all containers. Parameters ---------- @@ -816,9 +806,8 @@ def cont_identical( key_chain="", assert_and_assign=False, ): - """ - Return a single boolean as to whether the input containers have identical key- - chains and data types. + """Return a single boolean as to whether the input containers have + identical key- chains and data types. Parameters ---------- @@ -930,9 +919,8 @@ def cont_assert_identical( to_apply=True, partial=False, ): - """ - Assert whether the input containers are identical. Otherwise, the diff is shown - in an exception. + """Assert whether the input containers are identical. Otherwise, the + diff is shown in an exception. Parameters ---------- @@ -983,9 +971,8 @@ def cont_identical_structure( key_chain="", assert_and_assign=False, ): - """ - Return a single boolean as to whether the input containers have identical - structure. + """Return a single boolean as to whether the input containers have + identical structure. Parameters ---------- @@ -1038,9 +1025,8 @@ def cont_assert_identical_structure( partial=False, assert_and_assign=False, ): - """ - Assert whether the input containers have identical structure. Otherwise, the - diff is shown in an exception. + """Assert whether the input containers have identical structure. + Otherwise, the diff is shown in an exception. Parameters ---------- @@ -1080,9 +1066,8 @@ def cont_assert_identical_structure( @staticmethod def cont_identical_configs(containers): - """ - Return a single boolean as to whether the input containers all have identical - configs. + """Return a single boolean as to whether the input containers all have + identical configs. Parameters ---------- @@ -1098,9 +1083,9 @@ def cont_identical_configs(containers): @staticmethod def cont_identical_array_shapes(containers, exclusive=False): - """ - Determine whether all of the containers have identical number of arrays and - identical array shapes, regardless of their key-chain structures. + """Determine whether all of the containers have identical number of + arrays and identical array shapes, regardless of their key-chain + structures. Parameters ---------- @@ -1142,9 +1127,8 @@ def cont_load(filepath, format="h5py"): def cont_from_disk_as_hdf5( h5_obj_or_filepath, slice_obj=slice(None), alphabetical_keys=True, ivyh=None ): - """ - Load container object from disk, as an h5py file, at the specified hdf5 - filepath. + """Load container object from disk, as an h5py file, at the specified + hdf5 filepath. Parameters ---------- @@ -1193,8 +1177,7 @@ def cont_from_disk_as_hdf5( @staticmethod def cont_from_disk_as_pickled(pickle_filepath, ivyh=None): - """ - Load container object from disk at the specified pickle filepath. + """Load container object from disk at the specified pickle filepath. Parameters ---------- @@ -1216,9 +1199,9 @@ def cont_from_disk_as_pickled(pickle_filepath, ivyh=None): @staticmethod def cont_from_disk_as_json(json_filepath, ivyh=None): - """ - Load container object from disk at the specified json filepath. If some objects - were not json-able during saving, then they will be loaded as strings. + """Load container object from disk at the specified json filepath. If + some objects were not json-able during saving, then they will be loaded + as strings. Parameters ---------- @@ -1237,8 +1220,7 @@ def cont_from_disk_as_json(json_filepath, ivyh=None): @staticmethod def h5_file_size(h5_obj_or_filepath): - """ - Get file size of h5 file contents. + """Get file size of h5 file contents. Parameters ---------- @@ -1279,9 +1261,8 @@ def h5_file_size(h5_obj_or_filepath): @staticmethod def shuffle_h5_file(h5_obj_or_filepath, seed_value=0): - """ - Shuffle entries in all datasets of h5 file, such that they are still aligned - along axis 0. + """Shuffle entries in all datasets of h5 file, such that they are still + aligned along axis 0. Parameters ---------- @@ -1320,8 +1301,7 @@ def shuffle_h5_file(h5_obj_or_filepath, seed_value=0): @staticmethod def cont_reduce(containers, reduction, config=None): - """ - Reduce containers. + """Reduce containers. Parameters ---------- @@ -1363,8 +1343,7 @@ def cont_reduce(containers, reduction, config=None): def cont_flatten_key_chain( key_chain, replacement="__", above_height=None, below_depth=None ): - """ - Summary. + """Summary. Parameters ---------- @@ -1400,8 +1379,7 @@ def cont_flatten_key_chain( @staticmethod def cont_trim_key(key, max_length): - """ - Summary. Returns a trimmed key with a maximum length of max_length. + """Summary. Returns a trimmed key with a maximum length of max_length. Parameters ---------- @@ -1641,9 +1619,8 @@ def cont_update_config(self, **config): def cont_inplace_update( self, dict_in: Union[ivy.Container, dict], **config ) -> ivy.Container: - """ - Update the contents of this container inplace, using either a new dict or - container. + """Update the contents of this container inplace, using either a new + dict or container. Parameters ---------- @@ -1695,8 +1672,8 @@ def cont_all_true( prune_unapplied=False, map_sequences=False, ): - """ - Determine whether all the entries in the container boolean evaluate to True. + """Determine whether all the entries in the container boolean evaluate + to True. Parameters ---------- @@ -1740,8 +1717,8 @@ def cont_all_false( prune_unapplied=False, map_sequences=False, ): - """ - Determine whether all the entries in the container boolean evaluate to False. + """Determine whether all the entries in the container boolean evaluate + to False. Parameters ---------- @@ -1778,8 +1755,7 @@ def cont_all_false( ) def cont_slice_via_key(self, slice_key): - """ - Get slice of container, based on key. + """Get slice of container, based on key. Parameters ---------- @@ -1808,8 +1784,7 @@ def cont_as_bools( prune_unapplied=False, map_sequences=False, ): - """ - Return boolean evaluation for all nested items in the container. + """Return boolean evaluation for all nested items in the container. Parameters ---------- @@ -1848,8 +1823,7 @@ def _ret_bool(x): ) def cont_unstack_conts(self, axis, keepdims=False, dim_size=None): - """ - Unstack containers along specified dimension. + """Unstack containers along specified dimension. Parameters ---------- @@ -1892,8 +1866,7 @@ def split_conts( prune_unapplied=False, map_sequences=False, ): - """ - Split a container into multiple sub-containers. + """Split a container into multiple sub-containers. The function does that by splitting their constituent arrays. @@ -1948,9 +1921,8 @@ def split_conts( ).cont_unstack_conts(0, dim_size=dim_size) def cont_num_arrays(self, exclusive=False): - """ - Compute the number of arrays present at the leaf nodes, including variables by - default. + """Compute the number of arrays present at the leaf nodes, including + variables by default. Parameters ---------- @@ -1965,9 +1937,8 @@ def cont_num_arrays(self, exclusive=False): ) def cont_size_ordered_arrays(self, exclusive=False): - """ - Return a container with keychains mapped to flat keys, and arrays given in order - of smallest to largest. + """Return a container with keychains mapped to flat keys, and arrays + given in order of smallest to largest. Parameters ---------- @@ -2002,8 +1973,8 @@ def cont_save(self, filepath, format="h5py"): def cont_to_disk_as_hdf5( self, h5_obj_or_filepath, starting_index=0, mode="a", max_batch_size=None ): - """ - Save container object to disk, as an h5py file, at the specified filepath. + """Save container object to disk, as an h5py file, at the specified + filepath. Parameters ---------- @@ -2062,8 +2033,8 @@ def cont_to_disk_as_hdf5( ) def cont_to_disk_as_pickled(self, pickle_filepath): - """ - Save container object to disk, as an pickled file, at the specified filepath. + """Save container object to disk, as an pickled file, at the specified + filepath. Parameters ---------- @@ -2092,8 +2063,8 @@ def cont_to_jsonable(self, return_dict=None): return return_dict def cont_to_disk_as_json(self, json_filepath): - """ - Save container object to disk, as an json file, at the specified filepath. + """Save container object to disk, as an json file, at the specified + filepath. Parameters ---------- @@ -2113,8 +2084,7 @@ def cont_to_nested_list(self): return return_list def cont_to_raw(self): - """ - Convert container to its original form. + """Convert container to its original form. Returns ------- @@ -2136,8 +2106,7 @@ def cont_to_raw(self): return return_item def cont_to_dict(self): - """ - Summary. + """Summary. Returns ------- @@ -2231,8 +2200,7 @@ def cont_to_iterator_keys( yield kc def cont_to_flat_list(self): - """ - Summary. + """Summary. Returns ------- @@ -2242,9 +2210,8 @@ def cont_to_flat_list(self): return [item for key, item in self.cont_to_iterator()] def cont_from_flat_list(self, flat_list): - """ - Return new container object with the same hierarchy, but with values replaced - from flat list. + """Return new container object with the same hierarchy, but with values + replaced from flat list. Parameters ---------- @@ -2265,9 +2232,8 @@ def cont_from_flat_list(self, flat_list): return ivy.Container(new_dict, **self._config) def cont_has_key(self, query_key): - """ - Determine whether container object has specified key somewhere in the nested - structure. + """Determine whether container object has specified key somewhere in + the nested structure. Parameters ---------- @@ -2300,8 +2266,7 @@ def map_fn(x, kc): return has_key def cont_has_key_chain(self, key_chain): - """ - Determine whether container object has specified key-chain. + """Determine whether container object has specified key-chain. Parameters ---------- @@ -2323,8 +2288,7 @@ def cont_has_key_chain(self, key_chain): return True def cont_find_sub_container(self, sub_cont_to_find, partial=False): - """ - Find the sub-container in the current container if it exists. + """Find the sub-container in the current container if it exists. Parameters ---------- @@ -2355,9 +2319,8 @@ def _check_sub_cont(sub_cont, kc): return key_chain_found def cont_contains_sub_container(self, sub_cont, partial=False): - """ - Determine whether the current container contains the sub-container, with - matching structure and array values. + """Determine whether the current container contains the sub-container, + with matching structure and array values. Parameters ---------- @@ -2374,9 +2337,8 @@ def cont_contains_sub_container(self, sub_cont, partial=False): return isinstance(self.cont_find_sub_container(sub_cont, partial), str) def cont_assert_contains_sub_container(self, sub_cont, partial=False): - """ - Assert that the current container contains the sub-container, otherwise - exception raised with the diff printed to screen. + """Assert that the current container contains the sub-container, + otherwise exception raised with the diff printed to screen. Parameters ---------- @@ -2405,8 +2367,8 @@ def cont_assert_contains_sub_container(self, sub_cont, partial=False): def cont_find_sub_structure( self, sub_struc_to_find, check_shapes=True, partial=False ): - """ - Find the sub-container structure in the current container if it exists. + """Find the sub-container structure in the current container if it + exists. Parameters ---------- @@ -2450,8 +2412,8 @@ def _check_sub_cont(sub_cont, kc): return key_chain_found def cont_contains_sub_structure(self, sub_cont, check_shapes=True, partial=False): - """ - Determine whether the current container contains the sub-container structure. + """Determine whether the current container contains the sub-container + structure. Parameters ---------- @@ -2470,9 +2432,8 @@ def cont_contains_sub_structure(self, sub_cont, check_shapes=True, partial=False def cont_assert_contains_sub_structure( self, sub_cont, check_shapes=True, partial=False ): - """ - Assert that the current container contains the sub-container structure, - otherwise exception raised with the diff printed to screen. + """Assert that the current container contains the sub-container + structure, otherwise exception raised with the diff printed to screen. Parameters ---------- @@ -2510,8 +2471,8 @@ def cont_assert_contains_sub_structure( def cont_at_keys( self, queries, ignore_none=True, containing=False, ignore_key_errors=False ): - """ - Query container object at specified keys, either as list or nested dict. + """Query container object at specified keys, either as list or nested + dict. Parameters ---------- @@ -2554,8 +2515,7 @@ def map_fn(x, kc): ) def cont_at_key_chain(self, key_chain, ignore_key_errors=False): - """ - Query container object at a specified key-chain. + """Query container object at a specified key-chain. Parameters ---------- @@ -2581,8 +2541,8 @@ def cont_at_key_chain(self, key_chain, ignore_key_errors=False): return ret def cont_at_key_chains(self, key_chains, ignore_none=True, ignore_key_errors=False): - """ - Query container object at specified key-chains, either as list or nested dict. + """Query container object at specified key-chains, either as list or + nested dict. Parameters ---------- @@ -2647,8 +2607,7 @@ def cont_key_chains_containing(self, sub_str, include_empty=False): ] def cont_set_at_keys(self, target_dict): - """ - Set values of container object at specified keys. + """Set values of container object at specified keys. Parameters ---------- @@ -2671,8 +2630,7 @@ def cont_set_at_keys(self, target_dict): return ivy.Container(return_dict, **self._config) def cont_set_at_key_chain(self, key_chain, val, inplace=False): - """ - Set value of container object at a specified key-chain. + """Set value of container object at a specified key-chain. Parameters ---------- @@ -2702,8 +2660,7 @@ def cont_set_at_key_chain(self, key_chain, val, inplace=False): return cont def cont_overwrite_at_key_chain(self, key_chain, val, inplace=False): - """ - Overwrite value of container object at a specified key-chain. + """Overwrite value of container object at a specified key-chain. Parameters ---------- @@ -2747,8 +2704,7 @@ def cont_overwrite_at_key_chain(self, key_chain, val, inplace=False): return cont def cont_set_at_key_chains(self, target_dict, return_dict=None, inplace=False): - """ - Set values of container object at specified key-chains. + """Set values of container object at specified key-chains. Parameters ---------- @@ -2779,8 +2735,7 @@ def cont_set_at_key_chains(self, target_dict, return_dict=None, inplace=False): def cont_overwrite_at_key_chains( self, target_dict, return_dict=None, inplace=False ): - """ - Overwrite values of container object at specified key-chains. + """Overwrite values of container object at specified key-chains. Parameters ---------- @@ -2820,8 +2775,7 @@ def cont_overwrite_at_key_chains( return return_dict def cont_prune_keys(self, query_keys, ignore_none=True): - """ - Recursively prune set of keys. + """Recursively prune set of keys. Parameters ---------- @@ -2861,8 +2815,7 @@ def map_fn(x, kc): return self.cont_prune_key_chains(key_chains_to_prune) def cont_prune_key_chain(self, key_chain): - """ - Recursively prune chain of keys, specified as 'key1/key2/key3/...'. + """Recursively prune chain of keys, specified as 'key1/key2/key3/...'. Parameters ---------- @@ -2896,8 +2849,7 @@ def cont_prune_key_chain(self, key_chain): return ivy.Container(out_dict, **self._config) def cont_prune_key_chains(self, key_chains, ignore_none=True): - """ - Recursively prune set of key chains. + """Recursively prune set of key chains. Parameters ---------- @@ -2926,8 +2878,7 @@ def cont_prune_key_chains(self, key_chains, ignore_none=True): ) def cont_format_key_chains(self, format_fn): - """ - Format all key-chains, using the formatting function. + """Format all key-chains, using the formatting function. Parameters ---------- @@ -2952,9 +2903,8 @@ def cont_sort_by_key(self): return ivy.Container(new_dict, **self._config) def cont_prune_empty(self, keep_nones=False, base=True): - """ - Recursively prunes empty keys from the container dict structure. Returns None if - the entire container is empty. + """Recursively prunes empty keys from the container dict structure. + Returns None if the entire container is empty. Parameters ---------- @@ -2983,9 +2933,8 @@ def cont_prune_empty(self, keep_nones=False, base=True): return def cont_prune_key_from_key_chains(self, absolute=None, containing=None): - """ - Recursively prune absolute key or key containing a certain substring from all - key chains. + """Recursively prune absolute key or key containing a certain substring + from all key chains. Parameters ---------- @@ -3025,9 +2974,8 @@ def cont_prune_key_from_key_chains(self, absolute=None, containing=None): return out_cont def cont_prune_keys_from_key_chains(self, absolute=None, containing=None): - """ - Recursively prune absolute keys or keys containing certain substrings from all - key chains. + """Recursively prune absolute keys or keys containing certain + substrings from all key chains. Parameters ---------- @@ -3073,9 +3021,9 @@ def cont_prune_keys_from_key_chains(self, absolute=None, containing=None): def cont_restructure_key_chains( self, keychain_mapping, keep_orig=True, replace=True ): - """ - Create a new container with the same contents, but a new key-chain structure. - Given by the mapping with keys as old key-chains and values as new key-chains. + """Create a new container with the same contents, but a new key-chain + structure. Given by the mapping with keys as old key-chains and values + as new key-chains. Parameters ---------- @@ -3097,10 +3045,9 @@ def cont_restructure_key_chains( return new_cont def cont_restructure(self, mapping, keep_orig=True, replace=True): - """ - Create a new container with the same contents, but a new key-chain structure, - and transposes and/or reshaped arrays. Given by the mapping with keys as old - key-chains and values as new key-chains. + """Create a new container with the same contents, but a new key-chain + structure, and transposes and/or reshaped arrays. Given by the mapping + with keys as old key-chains and values as new key-chains. Parameters ---------- @@ -3136,8 +3083,7 @@ def cont_restructure(self, mapping, keep_orig=True, replace=True): def cont_flatten_key_chains( self, include_empty=False, above_height=None, below_depth=None ): - """ - Summary. + """Summary. Parameters ---------- @@ -3159,8 +3105,7 @@ def cont_flatten_key_chains( ) def cont_copy(self): - """ - Create a copy of this container. + """Create a copy of this container. Returns ------- @@ -3169,8 +3114,7 @@ def cont_copy(self): return ivy.Container(self.cont_to_dict(), **self._config) def cont_deep_copy(self): - """ - Create a deep copy (copying all internal tensors) of this container. + """Create a deep copy (copying all internal tensors) of this container. return: A deep copy of the container """ @@ -3193,8 +3137,7 @@ def cont_map( inplace=False, key_chain="", ): - """ - Apply function to all array values of container. + """Apply function to all array values of container. Parameters ---------- @@ -3269,8 +3212,7 @@ def cont_map_sub_conts( key_chain="", include_self=True, ): - """ - Apply function to all sub-contains in the container. + """Apply function to all sub-contains in the container. Parameters ---------- @@ -3332,9 +3274,8 @@ def to_list(x, _=""): return self.cont_map(to_list) def cont_reshape_like(self, target_dict, leading_shape=None, return_cont=None): - """ - Set shapes of container entries to shapes specified by new container with the - same key structure. + """Set shapes of container entries to shapes specified by new container + with the same key structure. Parameters ---------- @@ -3365,9 +3306,8 @@ def cont_reshape_like(self, target_dict, leading_shape=None, return_cont=None): return ivy.Container(return_cont, **self._config) def cont_create_if_absent(self, key, value, inplace=True): - """ - Add a key to the container with corresponding value, if it is not already - present. otherwise, do nothing. + """Add a key to the container with corresponding value, if it is not + already present. otherwise, do nothing. Parameters ---------- @@ -3382,8 +3322,8 @@ def cont_create_if_absent(self, key, value, inplace=True): self.cont_set_at_key_chain(key, value, inplace) def cont_if_exists(self, key): - """ - Return the sub-container at the following key if it exists, otherwise None. + """Return the sub-container at the following key if it exists, + otherwise None. Parameters ---------- @@ -3395,8 +3335,7 @@ def cont_if_exists(self, key): return def cont_try_kc(self, key): - """ - Try the following key or key chain, returning self if not present. + """Try the following key or key chain, returning self if not present. Parameters ---------- @@ -3408,8 +3347,7 @@ def cont_try_kc(self, key): return self def cont_cutoff_at_depth(self, depth_cutoff, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3434,8 +3372,7 @@ def _maybe_cutoff(cont, kc): return ret def cont_cutoff_at_height(self, height_cutoff, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3474,8 +3411,7 @@ def _cont_slice_keys(self, key_slice): return ret.cont_at_key_chains(desired_keys) def cont_slice_keys(self, key_slice, all_depths=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3506,8 +3442,7 @@ def _fn(cont, kc): return self._cont_slice_keys(key_slice) def cont_with_print_limit(self, print_limit, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3528,8 +3463,7 @@ def _update_print_limit(cont, _): # noinspection PyTypeChecker def cont_remove_print_limit(self, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3539,8 +3473,7 @@ def cont_remove_print_limit(self, inplace=False): return self.cont_with_print_limit(None, inplace) def cont_with_key_length_limit(self, key_length_limit, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3560,8 +3493,7 @@ def _update_key_length_limit(cont, _): return ret def cont_remove_key_length_limit(self, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3571,8 +3503,7 @@ def cont_remove_key_length_limit(self, inplace=False): return self.cont_with_key_length_limit(None, inplace) def cont_with_print_indent(self, print_indent, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3592,8 +3523,7 @@ def _update_print_indent(cont, _): return ret def cont_with_print_line_spacing(self, print_line_spacing, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3613,8 +3543,7 @@ def _update_print_line_spacing(cont, _): return ret def cont_with_default_key_color(self, default_key_color, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3634,8 +3563,7 @@ def _update_default_key_color(cont, _): return ret def cont_with_ivy_backend(self, ivy_backend: str, inplace=False): - """ - Summary. + """Summary. Parameters ---------- @@ -3658,8 +3586,7 @@ def cont_show(self): # noinspection PyUnresolvedReferences def cont_show_sub_container(self, sub_cont_or_keychain): - """ - Summary. + """Summary. Parameters ---------- @@ -4049,8 +3976,7 @@ def _get_queue_item(self, query): return combined_cont[shifted_query] def __getitem__(self, query): - """ - Get slice, key or key chain of container object. + """Get slice, key or key chain of container object. Parameters ---------- @@ -4091,8 +4017,7 @@ def __getitem__(self, query): return ret def __setitem__(self, query, val): - """ - Set key or key chain of container object. + """Set key or key chain of container object. Parameters ---------- @@ -4201,8 +4126,7 @@ def _cont_ivy(self, local_ivy): @property def cont_shape(self): - """ - The shape of the arrays in the container. + """The shape of the arrays in the container. None is placed in indices which are not consistent across arrays. @@ -4211,8 +4135,7 @@ def cont_shape(self): @property def cont_dtype(self): - """ - The dtype of the arrays in the container. + """The dtype of the arrays in the container. None is returned if the dtypes are not consistent. """ @@ -4220,8 +4143,7 @@ def cont_dtype(self): @property def cont_shapes(self): - """ - The shapes of each array in the container. + """The shapes of each array in the container. None is placed in leaf entries without a shape attribute. """ @@ -4229,8 +4151,7 @@ def cont_shapes(self): @property def cont_dev(self): - """ - The device to which the arrays in the container belong. + """The device to which the arrays in the container belong. None returned if the devices are not consistent. """ @@ -4238,8 +4159,7 @@ def cont_dev(self): @property def cont_dev_str(self): - """ - The device to which the arrays in the container belong. + """The device to which the arrays in the container belong. None returned if the devices are not consistent. """ diff --git a/ivy/data_classes/container/container.py b/ivy/data_classes/container/container.py index cc7d4fcf1b6dc..2c430ec1d3426 100644 --- a/ivy/data_classes/container/container.py +++ b/ivy/data_classes/container/container.py @@ -141,9 +141,9 @@ def __neg__(self): return self.cont_map(lambda x, kc: -x, map_sequences=True) def __pow__(self, power): - """ - ivy.Container special method for the power operator, calling - :code:`operator.pow` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the power operator, calling + :code:`operator.pow` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -196,9 +196,9 @@ def __ipow__(self, power): return self.cont_map(lambda x, _: operator.ipow(x, power), map_sequences=True) def __add__(self, other): - """ - ivy.Container special method for the add operator, calling :code:`operator.add` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the add operator, calling + :code:`operator.add` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -261,9 +261,9 @@ def __add__(self, other): ) def __radd__(self, other): - """ - ivy.Container reverse special method for the add operator, calling - :code:`operator.add` for each of the corresponding leaves of the two containers. + """ivy.Container reverse special method for the add operator, calling + :code:`operator.add` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -300,9 +300,9 @@ def __iadd__(self, other): ) def __sub__(self, other): - """ - ivy.Container special method for the subtract operator, calling - :code:`operator.sub` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the subtract operator, calling + :code:`operator.sub` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -370,9 +370,9 @@ def __isub__(self, other): ) def __rsub__(self, other): - """ - ivy.Container reverse special method for the subtract operator, calling - :code:`operator.sub` for each of the corresponding leaves of the two containers. + """ivy.Container reverse special method for the subtract operator, + calling :code:`operator.sub` for each of the corresponding leaves of + the two containers. Parameters ---------- @@ -448,10 +448,9 @@ def __rdivmod__(self, other): ) def __truediv__(self, other): - """ - ivy.Container special method for the divide operator, calling - :code:`operator.truediv` for each of the corresponding leaves of the two - containers. + """ivy.Container special method for the divide operator, calling + :code:`operator.truediv` for each of the corresponding leaves of the + two containers. Parameters ---------- @@ -564,9 +563,9 @@ def __imatmul__(self, other): ) def __abs__(self): - """ - ivy.Container special method for the abs operator, calling :code:`operator.abs` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the abs operator, calling + :code:`operator.abs` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -594,9 +593,9 @@ def __abs__(self): return self.cont_map(lambda x, kc: operator.abs(x), map_sequences=True) def __lt__(self, other): - """ - ivy.Container special method for the less operator, calling :code:`operator.lt` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the less operator, calling + :code:`operator.lt` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -632,9 +631,9 @@ def __lt__(self, other): return self.cont_map(lambda x, kc: x < other, map_sequences=True) def __le__(self, other): - """ - ivy.Container special method for the less_equal operator, calling - :code:`operator.le` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the less_equal operator, calling + :code:`operator.le` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -670,9 +669,9 @@ def __le__(self, other): return self.cont_map(lambda x, kc: x <= other, map_sequences=True) def __eq__(self, other): - """ - ivy.Container special method for the equal operator, calling :code:`operator.eq` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the equal operator, calling + :code:`operator.eq` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -732,9 +731,9 @@ def __eq__(self, other): return self.cont_map(lambda x, kc: x == other, map_sequences=True) def __ne__(self, other): - """ - ivy.Container special method for the not_equal operator, calling - :code:`operator.ne` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the not_equal operator, calling + :code:`operator.ne` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -794,9 +793,9 @@ def __ne__(self, other): return self.cont_map(lambda x, kc: x != other, map_sequences=True) def __gt__(self, other): - """ - ivy.Container special method for the greater operator, calling - :code:`operator.gt` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the greater operator, calling + :code:`operator.gt` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -832,9 +831,9 @@ def __gt__(self, other): return self.cont_map(lambda x, kc: x > other, map_sequences=True) def __ge__(self, other): - """ - ivy.Container special method for the greater_equal operator, calling - :code:`operator.ge` for each of the corresponding leaves of the two containers. + """ivy.Container special method for the greater_equal operator, calling + :code:`operator.ge` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -905,9 +904,9 @@ def __invert__(self): return self.cont_map(lambda x, kc: operator.not_(x), map_sequences=True) def __xor__(self, other): - """ - ivy.Container special method for the ge operator, calling :code:`operator.ge` - for each of the corresponding leaves of the two containers. + """ivy.Container special method for the ge operator, calling + :code:`operator.ge` for each of the corresponding leaves of the two + containers. Parameters ---------- @@ -980,8 +979,7 @@ def __ilshift__(self, other): ) def __rshift__(self, other): - """ - ivy.Container special method for the right shift operator, calling + """ivy.Container special method for the right shift operator, calling :code:`operator.rshift` for each of the corresponding leaves of the two containers. @@ -1049,10 +1047,9 @@ def __rshift__(self, other): ) def __rrshift__(self, other): - """ - ivy.Container reverse special method for the right shift operator, calling - :code:`operator.rshift` for each of the corresponding leaves of the two - containers. + """ivy.Container reverse special method for the right shift operator, + calling :code:`operator.rshift` for each of the corresponding leaves of + the two containers. Parameters ---------- diff --git a/ivy/data_classes/container/conversions.py b/ivy/data_classes/container/conversions.py index 00cdf6cdcfef8..f57bc6b58b2c8 100644 --- a/ivy/data_classes/container/conversions.py +++ b/ivy/data_classes/container/conversions.py @@ -1,5 +1,4 @@ -""" -Ivy wrapping functions for conversions. +"""Ivy wrapping functions for conversions. Collection of Ivy functions for wrapping functions to accept and return ivy.Array instances. @@ -26,8 +25,7 @@ def _static_to_native( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_native. + """ivy.Container static method variant of ivy.to_native. This method simply wraps the function, and so the docstring for ivy.to_native also applies to this method with minimal changes. @@ -86,8 +84,7 @@ def to_native( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_native. + """ivy.Container instance method variant of ivy.to_native. This method simply wraps the function, and so the docstring for ivy.to_native also applies to this method with minimal changes. @@ -146,8 +143,7 @@ def _static_to_ivy( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_ivy. + """ivy.Container static method variant of ivy.to_ivy. This method simply wraps the function, and so the docstring for ivy.to_ivy also applies to this method with minimal changes. @@ -207,8 +203,7 @@ def to_ivy( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_ivy. + """ivy.Container instance method variant of ivy.to_ivy. This method simply wraps the function, and so the docstring for ivy.to_ivy also applies to this method with minimal changes. diff --git a/ivy/data_classes/container/creation.py b/ivy/data_classes/container/creation.py index 83ec6aafc6884..f66a19fc9d2b0 100644 --- a/ivy/data_classes/container/creation.py +++ b/ivy/data_classes/container/creation.py @@ -59,10 +59,9 @@ def _static_asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.asarray. This method simply wraps the - function, and so the docstring for ivy.asarray also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.asarray. This method + simply wraps the function, and so the docstring for ivy.asarray also + applies to this method with minimal changes. Parameters ---------- @@ -257,10 +256,9 @@ def _static_full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.full_like. This method simply wraps - the function, and so the docstring for ivy.full_like also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.full_like. This method + simply wraps the function, and so the docstring for ivy.full_like also + applies to this method with minimal changes. Parameters ---------- @@ -343,10 +341,9 @@ def full_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.full_like. This method simply wraps - the function, and so the docstring for ivy.full_like also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.full_like. This method + simply wraps the function, and so the docstring for ivy.full_like also + applies to this method with minimal changes. Parameters ---------- @@ -428,10 +425,9 @@ def _static_ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.ones_like. This method simply wraps - the function, and so the docstring for ivy.ones_like also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.ones_like. This method + simply wraps the function, and so the docstring for ivy.ones_like also + applies to this method with minimal changes. Parameters ---------- @@ -487,10 +483,9 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.ones_like. This method simply wraps - the function, and so the docstring for ivy.ones_like also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.ones_like. This method + simply wraps the function, and so the docstring for ivy.ones_like also + applies to this method with minimal changes. Parameters ---------- @@ -546,10 +541,9 @@ def _static_zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.zeros_like. This method simply wraps - the function, and so the docstring for ivy.zeros_like also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.zeros_like. This method + simply wraps the function, and so the docstring for ivy.zeros_like also + applies to this method with minimal changes. Parameters ---------- @@ -605,10 +599,9 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.zeros_like. This method simply - wraps the function, and so the docstring for ivy.zeros_like also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.zeros_like. This method + simply wraps the function, and so the docstring for ivy.zeros_like also + applies to this method with minimal changes. Parameters ---------- @@ -1081,10 +1074,9 @@ def _static_logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logspace. This method simply wraps - the function, and so the docstring for ivy.logspace also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.logspace. This method + simply wraps the function, and so the docstring for ivy.logspace also + applies to this method with minimal changes. Parameters ---------- @@ -1164,10 +1156,9 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logspace. This method simply wraps - the function, and so the docstring for ivy.logspace also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.logspace. This method + simply wraps the function, and so the docstring for ivy.logspace also + applies to this method with minimal changes. Parameters ---------- @@ -1266,10 +1257,9 @@ def _static_one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.one_hot. This method simply wraps the - function, and so the docstring for ivy.one_hot also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.one_hot. This method + simply wraps the function, and so the docstring for ivy.one_hot also + applies to this method with minimal changes. Parameters ---------- @@ -1366,10 +1356,9 @@ def one_hot( device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.one_hot. This method simply wraps - the function, and so the docstring for ivy.one_hot also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.one_hot. This method + simply wraps the function, and so the docstring for ivy.one_hot also + applies to this method with minimal changes. Parameters ---------- @@ -1463,10 +1452,9 @@ def static_frombuffer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container static method variant of ivy.frombuffer. This method simply wraps - the function, and so the docstring for ivy.frombuffer also applies to this - method with minimal changes. + r"""ivy.Container static method variant of ivy.frombuffer. This method + simply wraps the function, and so the docstring for ivy.frombuffer also + applies to this method with minimal changes. Parameters ---------- @@ -1543,10 +1531,9 @@ def frombuffer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.frombuffer. This method simply - wraps the function, and so the docstring for ivy.frombuffer also applies to this - method with minimal changes. + r"""ivy.Container instance method variant of ivy.frombuffer. This method + simply wraps the function, and so the docstring for ivy.frombuffer also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/data_type.py b/ivy/data_classes/container/data_type.py index c8d7533d64006..7e45fe10c6b7d 100644 --- a/ivy/data_classes/container/data_type.py +++ b/ivy/data_classes/container/data_type.py @@ -22,9 +22,8 @@ def _static_astype( copy: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Copy an array to a specified data type irrespective of :ref:`type- promotion` - rules. + """Copy an array to a specified data type irrespective of :ref:`type- + promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -93,9 +92,8 @@ def astype( copy: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Copy an array to a specified data type irrespective of :ref:`type- promotion` - rules. + """Copy an array to a specified data type irrespective of :ref:`type- + promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -162,10 +160,10 @@ def _static_broadcast_arrays( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.broadcast_arrays`. This method - simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also - applies to this method with minimal changes. + """`ivy.Container` static method variant of `ivy.broadcast_arrays`. + This method simply wraps the function, and so the docstring for + `ivy.broadcast_arrays` also applies to this method with minimal + changes. Parameters ---------- @@ -238,10 +236,10 @@ def broadcast_arrays( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.broadcast_arrays`. This method - simply wraps the function, and so the docstring for `ivy.broadcast_arrays` also - applies to this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.broadcast_arrays`. + This method simply wraps the function, and so the docstring for + `ivy.broadcast_arrays` also applies to this method with minimal + changes. Parameters ---------- @@ -315,10 +313,9 @@ def _static_broadcast_to( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.broadcast_to`. This method simply - wraps the function, and so the docstring for `ivy.broadcast_to` also applies to - this method with minimal changes. + """`ivy.Container` static method variant of `ivy.broadcast_to`. This + method simply wraps the function, and so the docstring for + `ivy.broadcast_to` also applies to this method with minimal changes. Parameters ---------- @@ -373,10 +370,9 @@ def broadcast_to( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.broadcast_to`. This method - simply wraps the function, and so the docstring for `ivy.broadcast_to` also - applies to this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.broadcast_to`. This + method simply wraps the function, and so the docstring for + `ivy.broadcast_to` also applies to this method with minimal changes. Parameters ---------- @@ -428,10 +424,9 @@ def _static_can_cast( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.can_cast`. This method simply - wraps the function, and so the docstring for `ivy.can_cast` also applies to this - method with minimal changes. + """`ivy.Container` static method variant of `ivy.can_cast`. This method + simply wraps the function, and so the docstring for `ivy.can_cast` also + applies to this method with minimal changes. Parameters ---------- @@ -488,10 +483,9 @@ def can_cast( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.can_cast`. This method simply - wraps the function, and so the docstring for `ivy.can_cast` also applies to this - method with minimal changes. + """`ivy.Container` instance method variant of `ivy.can_cast`. This + method simply wraps the function, and so the docstring for + `ivy.can_cast` also applies to this method with minimal changes. Parameters ---------- @@ -679,8 +673,7 @@ def _static_finfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.finfo`. + """`ivy.Container` static method variant of `ivy.finfo`. Parameters ---------- @@ -725,8 +718,7 @@ def finfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.finfo`. + """`ivy.Container` instance method variant of `ivy.finfo`. Parameters ---------- @@ -770,10 +762,9 @@ def _static_iinfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.iinfo`. This method simply wraps - the function, and so the docstring for `ivy.iinfo` also applies to this method - with minimal changes. + """`ivy.Container` static method variant of `ivy.iinfo`. This method + simply wraps the function, and so the docstring for `ivy.iinfo` also + applies to this method with minimal changes. Parameters ---------- @@ -830,10 +821,9 @@ def iinfo( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.iinfo`. This method simply wraps - the function, and so the docstring for `ivy.iinfo` also applies to this method - with minimal changes. + """`ivy.Container` instance method variant of `ivy.iinfo`. This method + simply wraps the function, and so the docstring for `ivy.iinfo` also + applies to this method with minimal changes. Parameters ---------- @@ -932,10 +922,9 @@ def _static_is_float_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `is_float_dtype`. This method simply - wraps this function, so the docstring of `is_float_dtype` roughly applies to - this method. + """`ivy.Container` static method variant of `is_float_dtype`. This + method simply wraps this function, so the docstring of `is_float_dtype` + roughly applies to this method. Parameters ---------- @@ -1003,10 +992,9 @@ def is_float_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.is_float_dtype`. This method - simply wraps the function, and so the docstring for `ivy.is_float_dtype` also - applies to this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.is_float_dtype`. + This method simply wraps the function, and so the docstring for + `ivy.is_float_dtype` also applies to this method with minimal changes. Parameters ---------- @@ -1143,10 +1131,9 @@ def _static_is_complex_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `is_complex_dtype`. This method simply - wraps this function, so the docstring of `is_complex_dtype` roughly applies to - this method. + """`ivy.Container` static method variant of `is_complex_dtype`. This + method simply wraps this function, so the docstring of + `is_complex_dtype` roughly applies to this method. Parameters ---------- @@ -1202,10 +1189,10 @@ def is_complex_dtype( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.is_complex_dtype`. This method - simply wraps the function, and so the docstring for `ivy.is_complex_dtype` also - applies to this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.is_complex_dtype`. + This method simply wraps the function, and so the docstring for + `ivy.is_complex_dtype` also applies to this method with minimal + changes. Parameters ---------- @@ -1263,10 +1250,9 @@ def _static_result_type( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` static method variant of `ivy.result_type`. This method simply - wraps the function, and so the docstring for `ivy.result_type` also applies to - this method with minimal changes. + """`ivy.Container` static method variant of `ivy.result_type`. This + method simply wraps the function, and so the docstring for + `ivy.result_type` also applies to this method with minimal changes. Parameters ---------- @@ -1319,10 +1305,9 @@ def result_type( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - `ivy.Container` instance method variant of `ivy.result_type`. This method simply - wraps the function, and so the docstring for `ivy.result_type` also applies to - this method with minimal changes. + """`ivy.Container` instance method variant of `ivy.result_type`. This + method simply wraps the function, and so the docstring for + `ivy.result_type` also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/device.py b/ivy/data_classes/container/device.py index 3960c59d83f1f..9012fd4f4e989 100644 --- a/ivy/data_classes/container/device.py +++ b/ivy/data_classes/container/device.py @@ -13,10 +13,9 @@ class _ContainerWithDevice(ContainerBase): def _static_dev( x: ivy.Container, /, *, as_native: Union[bool, ivy.Container] = False ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dev. This method simply wraps the - function, and so the docstring for ivy.dev also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.dev. This method simply + wraps the function, and so the docstring for ivy.dev also applies to + this method with minimal changes. Examples -------- @@ -35,10 +34,9 @@ def _static_dev( def dev( self: ivy.Container, as_native: Union[bool, ivy.Container] = False ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dev. This method simply wraps the - function, and so the docstring for ivy.dev also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.dev. This method simply + wraps the function, and so the docstring for ivy.dev also applies to + this method with minimal changes. Parameters ---------- @@ -74,10 +72,9 @@ def _static_to_device( stream: Optional[Union[int, Any, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_device. This method simply wraps - the function, and so the docstring for ivy.to_device also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_device. This method + simply wraps the function, and so the docstring for ivy.to_device also + applies to this method with minimal changes. Parameters ---------- @@ -141,10 +138,9 @@ def to_device( stream: Optional[Union[int, Any, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_device. This method simply wraps - the function, and so the docstring for ivy.to_device also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_device. This method + simply wraps the function, and so the docstring for ivy.to_device also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/elementwise.py b/ivy/data_classes/container/elementwise.py index c52a3f42ba646..8932ae067e331 100644 --- a/ivy/data_classes/container/elementwise.py +++ b/ivy/data_classes/container/elementwise.py @@ -18,10 +18,9 @@ def _static_abs( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: # noqa - """ - ivy.Container static method variant of ivy.abs. This method simply wraps the - function, and so the docstring for ivy.abs also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.abs. This method simply + wraps the function, and so the docstring for ivy.abs also applies to + this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def abs( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.abs. This method simply wraps the - function, and so the docstring for ivy.abs also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.abs. This method simply + wraps the function, and so the docstring for ivy.abs also applies to + this method with minimal changes. Parameters ---------- @@ -140,10 +138,9 @@ def _static_acosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cosh. This method simply wraps the - function, and so the docstring for ivy.cosh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cosh. This method simply + wraps the function, and so the docstring for ivy.cosh also applies to + this method with minimal changes. Parameters ---------- @@ -202,10 +199,9 @@ def acosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.acosh. This method simply wraps the - function, and so the docstring for ivy.acosh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.acosh. This method + simply wraps the function, and so the docstring for ivy.acosh also + applies to this method with minimal changes. Parameters ---------- @@ -265,10 +261,9 @@ def _static_acos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.acos. This method simply wraps the - function, and so the docstring for ivy.acos also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.acos. This method simply + wraps the function, and so the docstring for ivy.acos also applies to + this method with minimal changes. Parameters ---------- @@ -329,10 +324,9 @@ def _static_add( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.add. This method simply wraps the - function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.add. This method simply + wraps the function, and so the docstring for ivy.add also applies to + this method with minimal changes. Parameters ---------- @@ -428,10 +422,9 @@ def acos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.acos. This method simply wraps the - function, and so the docstring for ivy.acos also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.acos. This method + simply wraps the function, and so the docstring for ivy.acos also + applies to this method with minimal changes. Parameters ---------- @@ -490,10 +483,9 @@ def add( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.add. This method simply wraps the - function, and so the docstring for ivy.add also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.add. This method simply + wraps the function, and so the docstring for ivy.add also applies to + this method with minimal changes. Parameters ---------- @@ -569,10 +561,9 @@ def _static_asin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.asin. This method simply wraps the - function, and so the docstring for ivy.asin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.asin. This method simply + wraps the function, and so the docstring for ivy.asin also applies to + this method with minimal changes. Parameters ---------- @@ -640,10 +631,9 @@ def asin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.asin. This method simply wraps the - function, and so the docstring for ivy.asin also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.asin. This method + simply wraps the function, and so the docstring for ivy.asin also + applies to this method with minimal changes. Parameters ---------- @@ -712,10 +702,9 @@ def _static_asinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.asinh. This method simply wraps the - function, and so the docstring for ivy.asinh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.asinh. This method simply + wraps the function, and so the docstring for ivy.asinh also applies to + this method with minimal changes. Parameters ---------- @@ -774,10 +763,9 @@ def asinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.asinh. This method simply wraps the - function, and so the docstring for ivy.asinh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.asinh. This method + simply wraps the function, and so the docstring for ivy.asinh also + applies to this method with minimal changes. Parameters ---------- @@ -837,10 +825,9 @@ def _static_atan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.atan. This method simply wraps the - function, and so the docstring for ivy.atan also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.atan. This method simply + wraps the function, and so the docstring for ivy.atan also applies to + this method with minimal changes. Parameters ---------- @@ -897,10 +884,9 @@ def atan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.atan. This method simply wraps the - function, and so the docstring for ivy.atan also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.atan. This method + simply wraps the function, and so the docstring for ivy.atan also + applies to this method with minimal changes. Parameters ---------- @@ -959,10 +945,9 @@ def _static_atan2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.atan2. This method simply wraps the - function, and so the docstring for ivy.atan2 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.atan2. This method simply + wraps the function, and so the docstring for ivy.atan2 also applies to + this method with minimal changes. Parameters ---------- @@ -1040,10 +1025,9 @@ def atan2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.atan2. This method simply wraps the - function, and so the docstring for ivy.atan2 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.atan2. This method + simply wraps the function, and so the docstring for ivy.atan2 also + applies to this method with minimal changes. Parameters ---------- @@ -1119,10 +1103,9 @@ def _static_atanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.atanh. This method simply wraps the - function, and so the docstring for ivy.atanh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.atanh. This method simply + wraps the function, and so the docstring for ivy.atanh also applies to + this method with minimal changes. Parameters ---------- @@ -1180,10 +1163,9 @@ def atanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.atanh. This method simply wraps the - function, and so the docstring for ivy.atanh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.atanh. This method + simply wraps the function, and so the docstring for ivy.atanh also + applies to this method with minimal changes. Parameters ---------- @@ -1243,10 +1225,9 @@ def _static_bitwise_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_and. This method simply wraps - the function, and so the docstring for ivy.bitwise_and also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_and. This method + simply wraps the function, and so the docstring for ivy.bitwise_and + also applies to this method with minimal changes. Parameters ---------- @@ -1328,10 +1309,9 @@ def bitwise_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_and. This method simply - wraps the function, and so the docstring for ivy.bitwise_and also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_and. This + method simply wraps the function, and so the docstring for + ivy.bitwise_and also applies to this method with minimal changes. Parameters ---------- @@ -1397,10 +1377,10 @@ def _static_bitwise_left_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_left_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_left_shift also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_left_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_left_shift also applies to this method with minimal + changes. Parameters ---------- @@ -1455,10 +1435,10 @@ def bitwise_left_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_left_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_left_shift also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_left_shift. + This method simply wraps the function, and so the docstring for + ivy.bitwise_left_shift also applies to this method with minimal + changes. Parameters ---------- @@ -1511,10 +1491,9 @@ def _static_bitwise_invert( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_invert. This method simply - wraps the function, and so the docstring for ivy.bitwise_invert also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_invert. This + method simply wraps the function, and so the docstring for + ivy.bitwise_invert also applies to this method with minimal changes. Parameters ---------- @@ -1578,10 +1557,9 @@ def bitwise_invert( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_invert. This method simply - wraps the function, and so the docstring for ivy.bitwise_invert also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_invert. This + method simply wraps the function, and so the docstring for + ivy.bitwise_invert also applies to this method with minimal changes. Parameters ---------- @@ -1648,10 +1626,9 @@ def _static_cos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cos. This method simply wraps the - function, and so the docstring for ivy.cos also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cos. This method simply + wraps the function, and so the docstring for ivy.cos also applies to + this method with minimal changes. Parameters ---------- @@ -1711,10 +1688,9 @@ def cos( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cos. This method simply wraps the - function, and so the docstring for ivy.cos also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cos. This method simply + wraps the function, and so the docstring for ivy.cos also applies to + this method with minimal changes. Parameters ---------- @@ -1776,10 +1752,9 @@ def _static_bitwise_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_or. This method simply wraps - the function, and so the docstring for ivy.bitwise_or also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_or. This method + simply wraps the function, and so the docstring for ivy.bitwise_or also + applies to this method with minimal changes. Parameters ---------- @@ -1853,10 +1828,9 @@ def bitwise_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_or. This method simply - wraps the function, and so the docstring for ivy.bitwise_or also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_or. This method + simply wraps the function, and so the docstring for ivy.bitwise_or also + applies to this method with minimal changes. Parameters ---------- @@ -1920,10 +1894,10 @@ def _static_bitwise_right_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_right_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_right_shift. This + method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- @@ -2001,10 +1975,10 @@ def bitwise_right_shift( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_right_shift. This method - simply wraps the function, and so the docstring for ivy.bitwise_right_shift also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_right_shift. + This method simply wraps the function, and so the docstring for + ivy.bitwise_right_shift also applies to this method with minimal + changes. Parameters ---------- @@ -2068,10 +2042,9 @@ def _static_bitwise_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bitwise_xor. This method simply wraps - the function, and so the docstring for ivy.bitwise_xor also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.bitwise_xor. This method + simply wraps the function, and so the docstring for ivy.bitwise_xor + also applies to this method with minimal changes. Parameters ---------- @@ -2137,10 +2110,9 @@ def bitwise_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.bitwise_xor. This method simply - wraps the function, and so the docstring for ivy.bitwise_xor also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.bitwise_xor. This + method simply wraps the function, and so the docstring for + ivy.bitwise_xor also applies to this method with minimal changes. Parameters ---------- @@ -2205,10 +2177,9 @@ def _static_ceil( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.ceil. This method simply wraps the - function, and so the docstring for ivy.ceil also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.ceil. This method simply + wraps the function, and so the docstring for ivy.ceil also applies to + this method with minimal changes. Parameters ---------- @@ -2265,10 +2236,9 @@ def ceil( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.ceil. This method simply wraps the - function, and so the docstring for ivy.ceil also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.ceil. This method + simply wraps the function, and so the docstring for ivy.ceil also + applies to this method with minimal changes. Parameters ---------- @@ -2326,10 +2296,9 @@ def _static_cosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cosh. This method simply wraps the - function, and so the docstring for ivy.cosh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cosh. This method simply + wraps the function, and so the docstring for ivy.cosh also applies to + this method with minimal changes. Parameters ---------- @@ -2399,10 +2368,9 @@ def cosh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cosh. This method simply wraps the - function, and so the docstring for ivy.cosh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cosh. This method + simply wraps the function, and so the docstring for ivy.cosh also + applies to this method with minimal changes. Parameters ---------- @@ -2474,10 +2442,9 @@ def _static_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.divide. This method simply wraps the - function, and so the docstring for ivy.divide also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.divide. This method + simply wraps the function, and so the docstring for ivy.divide also + applies to this method with minimal changes. Parameters ---------- @@ -2544,10 +2511,9 @@ def divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.divide. This method simply wraps - the function, and so the docstring for ivy.divide also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.divide. This method + simply wraps the function, and so the docstring for ivy.divide also + applies to this method with minimal changes. Parameters ---------- @@ -2626,10 +2592,9 @@ def _static_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.equal. This method simply wraps the - function, and so the docstring for ivy.equal also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.equal. This method simply + wraps the function, and so the docstring for ivy.equal also applies to + this method with minimal changes. Parameters ---------- @@ -2695,10 +2660,9 @@ def equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.equal. This method simply wraps the - function, and so the docstring for ivy.equal also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.equal. This method + simply wraps the function, and so the docstring for ivy.equal also + applies to this method with minimal changes. Parameters ---------- @@ -2776,10 +2740,9 @@ def static_nan_to_num( neginf: Optional[Union[float, int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nan_to_num. This method simply wraps - the function, and so the docstring for ivy.nan_to_num also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.nan_to_num. This method + simply wraps the function, and so the docstring for ivy.nan_to_num also + applies to this method with minimal changes. Parameters ---------- @@ -2841,10 +2804,9 @@ def nan_to_num( neginf: Optional[Union[float, int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nan_to_num. This method simply - wraps the function, and so the docstring for ivy.nan_to_num also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.nan_to_num. This method + simply wraps the function, and so the docstring for ivy.nan_to_num also + applies to this method with minimal changes. Parameters ---------- @@ -2899,10 +2861,9 @@ def static_imag( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.imag. This method simply wraps the - function, and so the docstring for ivy.imag also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.imag. This method simply + wraps the function, and so the docstring for ivy.imag also applies to + this method with minimal changes. Parameters ---------- @@ -2948,10 +2909,9 @@ def imag( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.imag. This method simply wraps the - function, and so the docstring for ivy.imag also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.imag. This method + simply wraps the function, and so the docstring for ivy.imag also + applies to this method with minimal changes. Parameters ---------- @@ -2995,10 +2955,9 @@ def static_angle( deg: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.angle. This method simply wraps the - function, and so the docstring for ivy.angle also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.angle. This method simply + wraps the function, and so the docstring for ivy.angle also applies to + this method with minimal changes. Parameters ---------- @@ -3056,10 +3015,9 @@ def angle( deg: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.angle. This method simply wraps the - function, and so the docstring for ivy.angle also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.angle. This method + simply wraps the function, and so the docstring for ivy.angle also + applies to this method with minimal changes. Parameters ---------- @@ -3113,10 +3071,9 @@ def static_gcd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.gcd. This method simply wraps the - function, and so the docstring for ivy.gcd also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.gcd. This method simply + wraps the function, and so the docstring for ivy.gcd also applies to + this method with minimal changes. Parameters ---------- @@ -3162,10 +3119,9 @@ def gcd( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gcd. This method simply wraps the - function, and so the docstring for ivy.gcd also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.gcd. This method simply + wraps the function, and so the docstring for ivy.gcd also applies to + this method with minimal changes. Parameters ---------- @@ -3206,10 +3162,9 @@ def static_exp2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.exp2. This method simply wraps the - function, and so the docstring for ivy.exp2 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.exp2. This method simply + wraps the function, and so the docstring for ivy.exp2 also applies to + this method with minimal changes. Parameters ---------- @@ -3250,10 +3205,9 @@ def exp2( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.exp2. This method simply wraps the - function, and so the docstring for ivy.exp2 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.exp2. This method + simply wraps the function, and so the docstring for ivy.exp2 also + applies to this method with minimal changes. Parameters ---------- @@ -3291,10 +3245,9 @@ def _static_exp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.exp. This method simply wraps the - function, and so the docstring for ivy.exp also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.exp. This method simply + wraps the function, and so the docstring for ivy.exp also applies to + this method with minimal changes. Parameters ---------- @@ -3351,10 +3304,9 @@ def exp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.exp. This method simply wraps the - function, and so the docstring for ivy.exp also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.exp. This method simply + wraps the function, and so the docstring for ivy.exp also applies to + this method with minimal changes. Parameters ---------- @@ -3412,10 +3364,9 @@ def _static_expm1( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.expm1. This method simply wraps - thefunction, and so the docstring for ivy.expm1 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.expm1. This method simply + wraps thefunction, and so the docstring for ivy.expm1 also applies to + this method with minimal changes. Parameters ---------- @@ -3473,10 +3424,9 @@ def expm1( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.expm1. This method simply wraps the - function, and so the docstring for ivy.expm1 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.expm1. This method + simply wraps the function, and so the docstring for ivy.expm1 also + applies to this method with minimal changes. Parameters ---------- @@ -3543,10 +3493,9 @@ def _static_floor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.floor. This method simply wraps - thefunction, and so the docstring for ivy.floor also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.floor. This method simply + wraps thefunction, and so the docstring for ivy.floor also applies to + this method with minimal changes. Parameters ---------- @@ -3603,10 +3552,9 @@ def floor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.floor. This method simply wraps the - function, and so the docstring for ivy.floor also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.floor. This method + simply wraps the function, and so the docstring for ivy.floor also + applies to this method with minimal changes. Parameters ---------- @@ -3665,10 +3613,9 @@ def _static_floor_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.floor_divide. This method simply - wraps the function, and so the docstring for ivy.floor_divide also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.floor_divide. This method + simply wraps the function, and so the docstring for ivy.floor_divide + also applies to this method with minimal changes. Parameters ---------- @@ -3746,10 +3693,9 @@ def floor_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.floor_divide. This method simply - wraps the function, and so the docstring for ivy.floor_divide also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.floor_divide. This + method simply wraps the function, and so the docstring for + ivy.floor_divide also applies to this method with minimal changes. Parameters ---------- @@ -3828,10 +3774,9 @@ def static_fmin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fmin. This method simply wraps the - function, and so the docstring for ivy.fmin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fmin. This method simply + wraps the function, and so the docstring for ivy.fmin also applies to + this method with minimal changes. Parameters ---------- @@ -3877,10 +3822,9 @@ def fmin( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fmin. This method simply wraps the - function, and so the docstring for ivy.fmin also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fmin. This method + simply wraps the function, and so the docstring for ivy.fmin also + applies to this method with minimal changes. Parameters ---------- @@ -3922,10 +3866,9 @@ def _static_greater( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.greater. This method simply wraps the - function, and so the docstring for ivy.greater also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.greater. This method + simply wraps the function, and so the docstring for ivy.greater also + applies to this method with minimal changes. Parameters ---------- @@ -3991,10 +3934,9 @@ def greater( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.greater. This method simply wraps - the function, and so the docstring for ivy.greater also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.greater. This method + simply wraps the function, and so the docstring for ivy.greater also + applies to this method with minimal changes. Parameters ---------- @@ -4060,10 +4002,9 @@ def _static_greater_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.greater_equal. This method simply - wraps the function, and so the docstring for ivy.greater_equal also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.greater_equal. This + method simply wraps the function, and so the docstring for + ivy.greater_equal also applies to this method with minimal changes. Parameters ---------- @@ -4129,10 +4070,9 @@ def greater_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.greater_equal. This method simply - wraps the function, and so the docstring for ivy.greater_equal also applies to - this metho with minimal changes. + """ivy.Container instance method variant of ivy.greater_equal. This + method simply wraps the function, and so the docstring for + ivy.greater_equal also applies to this metho with minimal changes. Parameters ---------- @@ -4197,10 +4137,9 @@ def _static_isfinite( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isfinite. This method simply wraps - the function, and so the docstring for ivy.isfinite also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.isfinite. This method + simply wraps the function, and so the docstring for ivy.isfinite also + applies to this method with minimal changes. Parameters ---------- @@ -4258,10 +4197,9 @@ def isfinite( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isfinite. This method simply wraps - the function, and so the docstring for ivy.isfinite also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.isfinite. This method + simply wraps the function, and so the docstring for ivy.isfinite also + applies to this method with minimal changes. Parameters ---------- @@ -4322,10 +4260,9 @@ def _static_isinf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isinf. This method simply wraps the - function, and so the docstring for ivy.isinf also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.isinf. This method simply + wraps the function, and so the docstring for ivy.isinf also applies to + this method with minimal changes. Parameters ---------- @@ -4393,10 +4330,9 @@ def isinf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isinf. This method simply wraps the - function, and so the docstring for ivy.isinf also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.isinf. This method + simply wraps the function, and so the docstring for ivy.isinf also + applies to this method with minimal changes. Parameters ---------- @@ -4463,10 +4399,9 @@ def _static_isnan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isnan. This method simply wraps the - function, and so the docstring for ivy.isnan also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.isnan. This method simply + wraps the function, and so the docstring for ivy.isnan also applies to + this method with minimal changes. Parameters ---------- @@ -4526,10 +4461,9 @@ def isnan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isnan. This method simply wraps the - function, and so the docstring for ivy.isnan also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.isnan. This method + simply wraps the function, and so the docstring for ivy.isnan also + applies to this method with minimal changes. Parameters ---------- @@ -4589,10 +4523,9 @@ def _static_less( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.less. This method simply wraps the - function, and so the docstring for ivy.less also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.less. This method simply + wraps the function, and so the docstring for ivy.less also applies to + this method with minimal changes. Parameters ---------- @@ -4658,10 +4591,9 @@ def less( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.less. This method simply wraps the - function, and so the docstring for ivy.less also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.less. This method + simply wraps the function, and so the docstring for ivy.less also + applies to this method with minimal changes. Parameters ---------- @@ -4727,10 +4659,9 @@ def _static_less_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.less_equal. This method simply wraps - the function, and so the docstring for ivy.less_equal also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.less_equal. This method + simply wraps the function, and so the docstring for ivy.less_equal also + applies to this method with minimal changes. Parameters ---------- @@ -4796,10 +4727,9 @@ def less_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.less_equal. This method simply - wraps the function, and so the docstring for ivy.less_equal also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.less_equal. This method + simply wraps the function, and so the docstring for ivy.less_equal also + applies to this method with minimal changes. Parameters ---------- @@ -4875,10 +4805,9 @@ def _static_log( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log. This method simply wraps the - function, and so the docstring for ivy.log also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.log. This method simply + wraps the function, and so the docstring for ivy.log also applies to + this method with minimal changes. Parameters ---------- @@ -4940,10 +4869,9 @@ def log( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log. This method simply wraps the - function, and so the docstring for ivy.log also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.log. This method simply + wraps the function, and so the docstring for ivy.log also applies to + this method with minimal changes. Parameters ---------- @@ -5006,10 +4934,9 @@ def _static_log1p( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log1p. This method simply wraps the - function, and so the docstring for ivy.log1p also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.log1p. This method simply + wraps the function, and so the docstring for ivy.log1p also applies to + this method with minimal changes. Parameters ---------- @@ -5074,10 +5001,9 @@ def log1p( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log1p. This method simply wraps the - function, and so the docstring for ivy.log1p also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.log1p. This method + simply wraps the function, and so the docstring for ivy.log1p also + applies to this method with minimal changes. Parameters ---------- @@ -5136,10 +5062,9 @@ def _static_log2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log2. This method simply wraps the - function, and so the docstring for ivy.log2 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.log2. This method simply + wraps the function, and so the docstring for ivy.log2 also applies to + this method with minimal changes. Parameters ---------- @@ -5201,10 +5126,9 @@ def log2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log2. This method simply wraps the - function, and so the docstring for ivy.log2 also applies to this metho with - minimal changes. + """ivy.Container instance method variant of ivy.log2. This method + simply wraps the function, and so the docstring for ivy.log2 also + applies to this metho with minimal changes. Parameters ---------- @@ -5267,10 +5191,9 @@ def _static_log10( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log10. This method simply wraps the - function, and so the docstring for ivy.log10 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.log10. This method simply + wraps the function, and so the docstring for ivy.log10 also applies to + this method with minimal changes. Parameters ---------- @@ -5332,10 +5255,9 @@ def log10( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log10. This method simply wraps the - function, and so the docstring for ivy.log10 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.log10. This method + simply wraps the function, and so the docstring for ivy.log10 also + applies to this method with minimal changes. Parameters ---------- @@ -5399,10 +5321,9 @@ def _static_logaddexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.greater_equal. This method simply - wraps the function, and so the docstring for ivy.greater_equal also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.greater_equal. This + method simply wraps the function, and so the docstring for + ivy.greater_equal also applies to this method with minimal changes. Parameters ---------- @@ -5471,10 +5392,9 @@ def logaddexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.greater_equal. This method simply - wraps the function, and so the docstring for ivy.greater_equal also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.greater_equal. This + method simply wraps the function, and so the docstring for + ivy.greater_equal also applies to this method with minimal changes. Parameters ---------- @@ -5543,10 +5463,9 @@ def static_logaddexp2( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logaddexp2. This method simply wraps - the function, and so the docstring for ivy.logaddexp2 also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logaddexp2. This method + simply wraps the function, and so the docstring for ivy.logaddexp2 also + applies to this method with minimal changes. Parameters ---------- @@ -5592,10 +5511,9 @@ def logaddexp2( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logaddexp2. This method simply - wraps the function, and so the docstring for ivy.logaddexp2 also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.logaddexp2. This method + simply wraps the function, and so the docstring for ivy.logaddexp2 also + applies to this method with minimal changes. Parameters ---------- @@ -5637,10 +5555,9 @@ def _static_logical_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logical_and. This method simply wraps - the function, and so the docstring for ivy.logical_and also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logical_and. This method + simply wraps the function, and so the docstring for ivy.logical_and + also applies to this method with minimal changes. Parameters ---------- @@ -5725,10 +5642,9 @@ def logical_and( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logical_and. This method simply - wraps the function, and so the docstring for ivy.logical_and also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.logical_and. This + method simply wraps the function, and so the docstring for + ivy.logical_and also applies to this method with minimal changes. Parameters ---------- @@ -5811,10 +5727,9 @@ def _static_logical_not( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logical_not. This method simply wraps - the function, and so the docstring for ivy.logical_not also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logical_not. This method + simply wraps the function, and so the docstring for ivy.logical_not + also applies to this method with minimal changes. Parameters ---------- @@ -5871,10 +5786,9 @@ def logical_not( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logical_not. This method simply - wraps the function, and so the docstring for ivy.logical_not also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.logical_not. This + method simply wraps the function, and so the docstring for + ivy.logical_not also applies to this method with minimal changes. Parameters ---------- @@ -5942,10 +5856,9 @@ def _static_logical_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logical_or. This method simply wraps - the function, and so the docstring for ivy.logical_or also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logical_or. This method + simply wraps the function, and so the docstring for ivy.logical_or also + applies to this method with minimal changes. Parameters ---------- @@ -6011,10 +5924,9 @@ def logical_or( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logical_or. This method simply - wraps the function, and so the docstring for ivy.logical_or also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.logical_or. This method + simply wraps the function, and so the docstring for ivy.logical_or also + applies to this method with minimal changes. Parameters ---------- @@ -6091,10 +6003,9 @@ def _static_logical_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logical_xor. This method simply wraps - the function, and so the docstring for ivy.logical_xor also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logical_xor. This method + simply wraps the function, and so the docstring for ivy.logical_xor + also applies to this method with minimal changes. Parameters ---------- @@ -6171,10 +6082,9 @@ def logical_xor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logical_xor. This method simply - wraps the function, and so the docstring for ivy.logical_xor also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.logical_xor. This + method simply wraps the function, and so the docstring for + ivy.logical_xor also applies to this method with minimal changes. Parameters ---------- @@ -6238,10 +6148,9 @@ def _static_multiply( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.multiply. This method simply wraps - the function, and so the docstring for ivy.multiply also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.multiply. This method + simply wraps the function, and so the docstring for ivy.multiply also + applies to this method with minimal changes. Parameters ---------- @@ -6310,10 +6219,9 @@ def multiply( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.multiply. This method simply wraps - the function, and so the docstring for ivy.multiply also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.multiply. This method + simply wraps the function, and so the docstring for ivy.multiply also + applies to this method with minimal changes. Parameters ---------- @@ -6393,10 +6301,9 @@ def _static_negative( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.negative. This method simply wraps - the function, and so the docstring for ivy.negative also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.negative. This method + simply wraps the function, and so the docstring for ivy.negative also + applies to this method with minimal changes. Parameters ---------- @@ -6455,10 +6362,9 @@ def negative( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.negative. This method simply wraps - the function, and so the docstring for ivy.negative also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.negative. This method + simply wraps the function, and so the docstring for ivy.negative also + applies to this method with minimal changes. Parameters ---------- @@ -6519,10 +6425,9 @@ def _static_not_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.not_equal. This method simply wraps - the function, and so the docstring for ivy.not_equal also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.not_equal. This method + simply wraps the function, and so the docstring for ivy.not_equal also + applies to this method with minimal changes. Parameters ---------- @@ -6588,10 +6493,9 @@ def not_equal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.not_equal. This method simply wraps - the function, and so the docstring for ivy.not_equal also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.not_equal. This method + simply wraps the function, and so the docstring for ivy.not_equal also + applies to this method with minimal changes. Parameters ---------- @@ -6667,10 +6571,9 @@ def _static_positive( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.positive. This method simply wraps - the function, and so the docstring for ivy.positive also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.positive. This method + simply wraps the function, and so the docstring for ivy.positive also + applies to this method with minimal changes. Parameters ---------- @@ -6729,10 +6632,9 @@ def positive( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.positive. This method simply wraps - the function, and so the docstring for ivy.positive also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.positive. This method + simply wraps the function, and so the docstring for ivy.positive also + applies to this method with minimal changes. Parameters ---------- @@ -6793,10 +6695,9 @@ def _static_pow( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.pow. This method simply wraps the - function, and so the docstring for ivy.pow also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.pow. This method simply + wraps the function, and so the docstring for ivy.pow also applies to + this method with minimal changes. Parameters ---------- @@ -6861,10 +6762,9 @@ def pow( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.pow. This method simply wraps the - function, and so the docstring for ivy.pow also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.pow. This method simply + wraps the function, and so the docstring for ivy.pow also applies to + this method with minimal changes. Parameters ---------- @@ -6928,10 +6828,9 @@ def static_real( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.real. This method simply wraps the - function, and so the docstring for ivy.real also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.real. This method simply + wraps the function, and so the docstring for ivy.real also applies to + this method with minimal changes. Parameters ---------- @@ -6990,10 +6889,9 @@ def real( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.real. This method simply wraps the - function, and so the docstring for ivy.real also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.real. This method + simply wraps the function, and so the docstring for ivy.real also + applies to this method with minimal changes. Parameters ---------- @@ -7055,10 +6953,9 @@ def _static_remainder( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.remainder. This method simply wraps - the function, and so the docstring for ivy.remainder also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.remainder. This method + simply wraps the function, and so the docstring for ivy.remainder also + applies to this method with minimal changes. Parameters ---------- @@ -7151,10 +7048,9 @@ def remainder( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.remainder. This method simply wraps - the function, and so the docstring for ivy.remainder also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.remainder. This method + simply wraps the function, and so the docstring for ivy.remainder also + applies to this method with minimal changes. Parameters ---------- @@ -7246,10 +7142,9 @@ def _static_round( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.round. This method simply wraps - thevfunction, and so the docstring for ivy.round also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.round. This method simply + wraps thevfunction, and so the docstring for ivy.round also applies to + this method with minimal changes. Parameters ---------- @@ -7312,10 +7207,9 @@ def round( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.round. This method simply wraps the - function, and so the docstring for ivy.round also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.round. This method + simply wraps the function, and so the docstring for ivy.round also + applies to this method with minimal changes. Parameters ---------- @@ -7379,10 +7273,9 @@ def _static_sign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sign. This method simply wraps the - function, and so the docstring for ivy.sign also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sign. This method simply + wraps the function, and so the docstring for ivy.sign also applies to + this method with minimal changes. Parameters ---------- @@ -7441,10 +7334,9 @@ def sign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sign. This method simply wraps the - function, and so the docstring for ivy.sign also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sign. This method + simply wraps the function, and so the docstring for ivy.sign also + applies to this method with minimal changes. Parameters ---------- @@ -7505,10 +7397,9 @@ def _static_sin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sin. This method simply wraps the - function, and so the docstring for ivy.sin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sin. This method simply + wraps the function, and so the docstring for ivy.sin also applies to + this method with minimal changes. Parameters ---------- @@ -7567,10 +7458,9 @@ def sin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sin. This method simply wraps the - function, and so the docstring for ivy.sin also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sin. This method simply + wraps the function, and so the docstring for ivy.sin also applies to + this method with minimal changes. Parameters ---------- @@ -7630,10 +7520,9 @@ def _static_sinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sinh. This method simply wraps the - function, and so the docstring for ivy.sinh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sinh. This method simply + wraps the function, and so the docstring for ivy.sinh also applies to + this method with minimal changes. Parameters ---------- @@ -7701,10 +7590,9 @@ def sinh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sinh. This method simply wraps the - function, and so the docstring for ivy.sinh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sinh. This method + simply wraps the function, and so the docstring for ivy.sinh also + applies to this method with minimal changes. Parameters ---------- @@ -7773,10 +7661,9 @@ def _static_square( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.square. This method simply wraps the - function, and so the docstring for ivy.square also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.square. This method + simply wraps the function, and so the docstring for ivy.square also + applies to this method with minimal changes. Parameters ---------- @@ -7833,10 +7720,9 @@ def square( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.square. This method simply wraps - the function, and so the docstring for ivy.square also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.square. This method + simply wraps the function, and so the docstring for ivy.square also + applies to this method with minimal changes. Parameters ---------- @@ -7894,10 +7780,9 @@ def _static_sqrt( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sqrt. This method simply wraps the - function, and so the docstring for ivy.sqrt also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sqrt. This method simply + wraps the function, and so the docstring for ivy.sqrt also applies to + this method with minimal changes. Parameters ---------- @@ -7957,10 +7842,9 @@ def sqrt( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sqrt. This method simply wraps the - function, and so the docstring for ivy.sqrt also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sqrt. This method + simply wraps the function, and so the docstring for ivy.sqrt also + applies to this method with minimal changes. Parameters ---------- @@ -8023,10 +7907,9 @@ def _static_subtract( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.subtract. This method simply wraps - the function, and so the docstring for ivy.subtract also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.subtract. This method + simply wraps the function, and so the docstring for ivy.subtract also + applies to this method with minimal changes. Parameters ---------- @@ -8103,10 +7986,9 @@ def subtract( alpha: Optional[Union[int, float, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.subtract. This method simply wraps - the function, and so the docstring for ivy.subtract also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.subtract. This method + simply wraps the function, and so the docstring for ivy.subtract also + applies to this method with minimal changes. Parameters ---------- @@ -8181,10 +8063,9 @@ def _static_tan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tan. This method simply wraps the - function, and so the docstring for ivy.tan also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tan. This method simply + wraps the function, and so the docstring for ivy.tan also applies to + this method with minimal changes. Parameters ---------- @@ -8242,10 +8123,9 @@ def tan( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tan. This method simply wraps the - function, and so the docstring for ivy.tan also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.tan. This method simply + wraps the function, and so the docstring for ivy.tan also applies to + this method with minimal changes. Parameters ---------- @@ -8305,10 +8185,9 @@ def _static_tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tanh. This method simply wraps the - function, and so the docstring for ivy.tanh also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tanh. This method simply + wraps the function, and so the docstring for ivy.tanh also applies to + this method with minimal changes. Parameters ---------- @@ -8371,10 +8250,9 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tanh. This method simply wraps the - function, and so the docstring for ivy.tanh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.tanh. This method + simply wraps the function, and so the docstring for ivy.tanh also + applies to this method with minimal changes. Parameters ---------- @@ -8438,10 +8316,9 @@ def _static_trunc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trunc. This method simply wraps the - function, and so the docstring for ivy.trunc also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.trunc. This method simply + wraps the function, and so the docstring for ivy.trunc also applies to + this method with minimal changes. Parameters ---------- @@ -8500,10 +8377,9 @@ def trunc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.trunc. This method simply wraps the - function, and so the docstring for ivy.trunc also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.trunc. This method + simply wraps the function, and so the docstring for ivy.trunc also + applies to this method with minimal changes. Parameters ---------- @@ -8561,10 +8437,9 @@ def _static_erf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.erf. This method simply wraps the - function, and so the docstring for ivy.erf also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.erf. This method simply + wraps the function, and so the docstring for ivy.erf also applies to + this method with minimal changes. Parameters ---------- @@ -8620,10 +8495,9 @@ def erf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.erf. This method simply wraps - thefunction, and so the docstring for ivy.erf also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.erf. This method simply + wraps thefunction, and so the docstring for ivy.erf also applies to + this method with minimal changes. Parameters ---------- @@ -8682,10 +8556,9 @@ def _static_minimum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.minimum. This method simply wraps the - function, and so the docstring for ivy.minimum also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.minimum. This method + simply wraps the function, and so the docstring for ivy.minimum also + applies to this method with minimal changes. Parameters ---------- @@ -8755,10 +8628,9 @@ def minimum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.minimum. This method simply wraps - the function, and so the docstring for ivy.minimum also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.minimum. This method + simply wraps the function, and so the docstring for ivy.minimum also + applies to this method with minimal changes. Parameters ---------- @@ -8828,10 +8700,9 @@ def _static_maximum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.maximum. This method simply wraps the - function, and so the docstring for ivy.maximum also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.maximum. This method + simply wraps the function, and so the docstring for ivy.maximum also + applies to this method with minimal changes. Parameters ---------- @@ -8906,10 +8777,9 @@ def maximum( use_where: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.maximum. This method simply wraps - the function, and so the docstring for ivy.maximum also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.maximum. This method + simply wraps the function, and so the docstring for ivy.maximum also + applies to this method with minimal changes. Parameters ---------- @@ -8982,10 +8852,9 @@ def _static_reciprocal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.reciprocal. This method simply wraps - the function, and so the docstring for ivy.reciprocal also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.reciprocal. This method + simply wraps the function, and so the docstring for ivy.reciprocal also + applies to this method with minimal changes. Parameters ---------- @@ -9040,10 +8909,9 @@ def reciprocal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.reciprocal. This method simply - wraps the function, and so the docstring for ivy.reciprocal also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.reciprocal. This method + simply wraps the function, and so the docstring for ivy.reciprocal also + applies to this method with minimal changes. Parameters ---------- @@ -9099,10 +8967,9 @@ def _static_deg2rad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.deg2rad. This method simply wraps the - function, and so the docstring for ivy.deg2rad also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.deg2rad. This method + simply wraps the function, and so the docstring for ivy.deg2rad also + applies to this method with minimal changes. Parameters ---------- @@ -9158,10 +9025,9 @@ def deg2rad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.deg2rad. This method simply wraps - the function, and so the docstring for ivy.deg2rad also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.deg2rad. This method + simply wraps the function, and so the docstring for ivy.deg2rad also + applies to this method with minimal changes. Parameters ---------- @@ -9220,10 +9086,9 @@ def _static_rad2deg( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rad2deg. This method simply wraps the - function, and so the docstring for ivy.rad2deg also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.rad2deg. This method + simply wraps the function, and so the docstring for ivy.rad2deg also + applies to this method with minimal changes. Parameters ---------- @@ -9279,10 +9144,9 @@ def rad2deg( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.rad2deg. This method simply wraps - the function, and so the docstring for ivy.rad2deg also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.rad2deg. This method + simply wraps the function, and so the docstring for ivy.rad2deg also + applies to this method with minimal changes. Parameters ---------- @@ -9342,10 +9206,9 @@ def _static_trunc_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trunc_divide. This method simply - wraps the function, and so the docstring for ivy.trunc_divide also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.trunc_divide. This method + simply wraps the function, and so the docstring for ivy.trunc_divide + also applies to this method with minimal changes. Parameters ---------- @@ -9412,10 +9275,9 @@ def trunc_divide( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.trunc_divide. This method simply - wraps the function, and so the docstring for ivy.trunc_divide also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.trunc_divide. This + method simply wraps the function, and so the docstring for + ivy.trunc_divide also applies to this method with minimal changes. Parameters ---------- @@ -9482,10 +9344,9 @@ def _static_isreal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isreal. This method simply wraps the - function, and so the docstring for ivy.isreal also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.isreal. This method + simply wraps the function, and so the docstring for ivy.isreal also + applies to this method with minimal changes. Parameters ---------- @@ -9543,10 +9404,9 @@ def isreal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isreal. This method simply wraps - the function, and so the docstring for ivy.isreal also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.isreal. This method + simply wraps the function, and so the docstring for ivy.isreal also + applies to this method with minimal changes. Parameters ---------- @@ -9608,10 +9468,9 @@ def _static_trapz( axis: Union[int, ivy.Container] = -1, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trapz. This method simply wraps the - function, and so the docstring for ivy.trapz also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.trapz. This method simply + wraps the function, and so the docstring for ivy.trapz also applies to + this method with minimal changes. Parameters ---------- @@ -9666,10 +9525,9 @@ def trapz( axis: Union[int, ivy.Container] = -1, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.trapz. This method simply wraps the - function, and so the docstring for ivy.trapz also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.trapz. This method + simply wraps the function, and so the docstring for ivy.trapz also + applies to this method with minimal changes. Parameters ---------- @@ -9716,10 +9574,9 @@ def _static_lcm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.lcm. This method simply wraps the - function, and so the docstring for ivy.lcm also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.lcm. This method simply + wraps the function, and so the docstring for ivy.lcm also applies to + this method with minimal changes. Parameters ---------- @@ -9769,10 +9626,9 @@ def lcm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.lcm. This method simply wraps the - function, and so the docstring for ivy.lcm also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.lcm. This method simply + wraps the function, and so the docstring for ivy.lcm also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/activations.py b/ivy/data_classes/container/experimental/activations.py index 1d1cb87018641..e42c7d270d00c 100644 --- a/ivy/data_classes/container/experimental/activations.py +++ b/ivy/data_classes/container/experimental/activations.py @@ -16,10 +16,9 @@ def static_logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logit. This method simply wraps the - function, and so the docstring for ivy.logit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.logit. This method simply + wraps the function, and so the docstring for ivy.logit also applies to + this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.logit. This method simply wraps the - function, and so the docstring for ivy.logit also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.logit. This method + simply wraps the function, and so the docstring for ivy.logit also + applies to this method with minimal changes. Parameters ---------- @@ -138,10 +136,9 @@ def static_thresholded_relu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.thresholded_relu. This method simply - wraps the function, and so the docstring for ivy.thresholded_relu also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.thresholded_relu. This + method simply wraps the function, and so the docstring for + ivy.thresholded_relu also applies to this method with minimal changes. Parameters ---------- @@ -202,10 +199,9 @@ def thresholded_relu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.thresholded_relu. This method - simply wraps the function, and so the docstring for ivy.thresholded_relu also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.thresholded_relu. This + method simply wraps the function, and so the docstring for + ivy.thresholded_relu also applies to this method with minimal changes. Parameters ---------- @@ -332,10 +328,9 @@ def static_relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.relu6. This method simply wraps the - function, and so the docstring for ivy.relu6 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.relu6. This method simply + wraps the function, and so the docstring for ivy.relu6 also applies to + this method with minimal changes. Parameters ---------- @@ -398,10 +393,9 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.relu6. This method simply wraps the - function, and so the docstring for ivy.relu6 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.relu6. This method + simply wraps the function, and so the docstring for ivy.relu6 also + applies to this method with minimal changes. Parameters ---------- @@ -463,10 +457,9 @@ def static_logsigmoid( map_sequences: Union[bool, ivy.Container] = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.logsigmoid. This method simply wraps - the function, and so the docstring for ivy.logsigmoid also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.logsigmoid. This method + simply wraps the function, and so the docstring for ivy.logsigmoid also + applies to this method with minimal changes. Parameters ---------- @@ -533,8 +526,7 @@ def logsigmoid( map_sequences: Union[bool, ivy.Container] = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ) -> ivy.Container: - """ - Apply element-wise Log-sigmoid of x i.e. log(1 / (1 + exp(-x)). + """Apply element-wise Log-sigmoid of x i.e. log(1 / (1 + exp(-x)). Parameters ---------- @@ -579,10 +571,9 @@ def static_selu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.selu. This method simply wraps the - function, and so the docstring for ivy.selu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.selu. This method simply + wraps the function, and so the docstring for ivy.selu also applies to + this method with minimal changes. Parameters ---------- @@ -639,10 +630,9 @@ def selu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.selu. This method simply wraps the - function, and so the docstring for ivy.selu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.selu. This method + simply wraps the function, and so the docstring for ivy.selu also + applies to this method with minimal changes. Parameters ---------- @@ -699,10 +689,9 @@ def _static_silu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.silu. This method simply wraps the - function, and so the docstring for ivy.silu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.silu. This method simply + wraps the function, and so the docstring for ivy.silu also applies to + this method with minimal changes. Parameters ---------- @@ -759,10 +748,9 @@ def silu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.silu. This method simply wraps the - function, and so the docstring for ivy.silu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.silu. This method + simply wraps the function, and so the docstring for ivy.silu also + applies to this method with minimal changes. Parameters ---------- @@ -820,10 +808,9 @@ def _static_elu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.elu. This method simply wraps the - function, and so the docstring for ivy.elu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.elu. This method simply + wraps the function, and so the docstring for ivy.elu also applies to + this method with minimal changes. Parameters ---------- @@ -883,10 +870,9 @@ def elu( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.elu. This method simply wraps the - function, and so the docstring for ivy.elu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.elu. This method simply + wraps the function, and so the docstring for ivy.elu also applies to + this method with minimal changes. Parameters ---------- @@ -947,10 +933,9 @@ def _static_hardtanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hardtanh.This method simply wrap the - function,the docstring for ivy.hardtanh also applies to this method with minimal - changes. + """ivy.Container static method variant of ivy.hardtanh.This method + simply wrap the function,the docstring for ivy.hardtanh also applies to + this method with minimal changes. Parameters ---------- @@ -1014,10 +999,9 @@ def hardtanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hardtanh.This method simply wraps - the function, so the docstring for ivy.elu also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.hardtanh.This method + simply wraps the function, so the docstring for ivy.elu also applies to + this method with minimal changes. Parameters ---------- @@ -1079,10 +1063,9 @@ def _static_tanhshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tanhshrink. This method simply wraps - the function, and so the docstring for ivy.tanhshrink also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.tanhshrink. This method + simply wraps the function, and so the docstring for ivy.tanhshrink also + applies to this method with minimal changes. Parameters ---------- @@ -1139,10 +1122,9 @@ def tanhshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tanhshrink. This method simply - wraps the function, and so the docstring for ivy.tanhshrink also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.tanhshrink. This method + simply wraps the function, and so the docstring for ivy.tanhshrink also + applies to this method with minimal changes. Parameters ---------- @@ -1201,10 +1183,9 @@ def _static_threshold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.threshold. This method simply wraps - the function, and so the docstring for ivy.threshold also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.threshold. This method + simply wraps the function, and so the docstring for ivy.threshold also + applies to this method with minimal changes. Parameters ---------- @@ -1267,10 +1248,9 @@ def threshold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.threshold. This method simply wraps - the function, and so the docstring for ivy.threshold also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.threshold. This method + simply wraps the function, and so the docstring for ivy.threshold also + applies to this method with minimal changes. Parameters ---------- @@ -1332,10 +1312,9 @@ def _static_softshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.softshrink. This method simply wraps - the function, and so the docstring for ivy.softshrink also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.softshrink. This method + simply wraps the function, and so the docstring for ivy.softshrink also + applies to this method with minimal changes. Parameters ---------- @@ -1393,8 +1372,7 @@ def softshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Apply the soft shrinkage function element-wise. + """Apply the soft shrinkage function element-wise. Parameters ---------- @@ -1454,10 +1432,9 @@ def _static_celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.celu. This method simply wraps the - function, and so the docstring for ivy.celu also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.celu. This method simply + wraps the function, and so the docstring for ivy.celu also applies to + this method with minimal changes. Parameters ---------- @@ -1522,10 +1499,9 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.leaky_relu. This method simply - wraps the function, and so the docstring for ivy.leaky_relu also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.leaky_relu. This method + simply wraps the function, and so the docstring for ivy.leaky_relu also + applies to this method with minimal changes. Parameters ---------- @@ -1591,10 +1567,9 @@ def _static_scaled_tanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.scaled_tanh. This method simply wraps - the function, and so the docstring for ivy.scaled_tanh also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.scaled_tanh. This method + simply wraps the function, and so the docstring for ivy.scaled_tanh + also applies to this method with minimal changes. Parameters ---------- @@ -1678,10 +1653,9 @@ def scaled_tanh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.scaled_tanh. This method - simplywraps the function, and so the docstring for ivy.scaled_tanh also applies - to this method with minimal changes. + """ivy.Container instance method variant of ivy.scaled_tanh. This + method simplywraps the function, and so the docstring for + ivy.scaled_tanh also applies to this method with minimal changes. Parameters ---------- @@ -1761,10 +1735,9 @@ def _static_hardshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hardshrink. This method simply wraps - the function, and so the docstring for ivy.hardshrink also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.hardshrink. This method + simply wraps the function, and so the docstring for ivy.hardshrink also + applies to this method with minimal changes. Parameters ---------- @@ -1819,8 +1792,7 @@ def hardshrink( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Apply the hard shrinkage function element-wise. + """Apply the hard shrinkage function element-wise. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/creation.py b/ivy/data_classes/container/experimental/creation.py index fc861420bc843..e563d358474c2 100644 --- a/ivy/data_classes/container/experimental/creation.py +++ b/ivy/data_classes/container/experimental/creation.py @@ -19,10 +19,9 @@ def static_hann_window( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hann_window. This method simply wraps - the function, and so the docstring for ivy.hann_window also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.hann_window. This method + simply wraps the function, and so the docstring for ivy.hann_window + also applies to this method with minimal changes. Parameters ---------- @@ -71,10 +70,9 @@ def hann_window( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hann_window. This method simply - wraps the function, and so the docstring for ivy.hann_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.hann_window. This + method simply wraps the function, and so the docstring for + ivy.hann_window also applies to this method with minimal changes. Parameters ---------- @@ -119,10 +117,9 @@ def static_kaiser_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.kaiser_window. This method simply - wraps the function, and so the docstring for ivy.kaiser_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.kaiser_window. This + method simply wraps the function, and so the docstring for + ivy.kaiser_window also applies to this method with minimal changes. Parameters ---------- @@ -177,10 +174,9 @@ def kaiser_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.kaiser_window. This method simply - wraps the function, and so the docstring for ivy.kaiser_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.kaiser_window. This + method simply wraps the function, and so the docstring for + ivy.kaiser_window also applies to this method with minimal changes. Parameters ---------- @@ -235,11 +231,10 @@ def static_kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.kaiser_bessel_derived_window. This - method simply wraps the function, and so the docstring for - ivy.kaiser_bessel_derived_window also applies to this method with minimal - changes. + """ivy.Container static method variant of + ivy.kaiser_bessel_derived_window. This method simply wraps the + function, and so the docstring for ivy.kaiser_bessel_derived_window + also applies to this method with minimal changes. Parameters ---------- @@ -294,11 +289,10 @@ def kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.kaiser_bessel_derived_window. This - method simply wraps the function, and so the docstring for - ivy.kaiser_bessel_derived_window also applies to this method with minimal - changes. + """ivy.Container instance method variant of + ivy.kaiser_bessel_derived_window. This method simply wraps the + function, and so the docstring for ivy.kaiser_bessel_derived_window + also applies to this method with minimal changes. Parameters ---------- @@ -355,10 +349,9 @@ def static_hamming_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hamming_window. This method simply - wraps the function, and so the docstring for ivy.hamming_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.hamming_window. This + method simply wraps the function, and so the docstring for + ivy.hamming_window also applies to this method with minimal changes. Parameters ---------- @@ -417,10 +410,9 @@ def hamming_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hamming_window. This method simply - wraps the function, and so the docstring for ivy.hamming_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.hamming_window. This + method simply wraps the function, and so the docstring for + ivy.hamming_window also applies to this method with minimal changes. Parameters ---------- @@ -468,10 +460,9 @@ def static_vorbis_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.vorbis_window. This method simply - wraps the function, and so the docstring for ivy.vorbis_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.vorbis_window. This + method simply wraps the function, and so the docstring for + ivy.vorbis_window also applies to this method with minimal changes. Parameters ---------- @@ -520,10 +511,9 @@ def vorbis_window( dtype: Optional[Union[ivy.Array, ivy.NativeArray, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.vorbis_window. This method simply - wraps the function, and so the docstring for ivy.vorbis_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.vorbis_window. This + method simply wraps the function, and so the docstring for + ivy.vorbis_window also applies to this method with minimal changes. Parameters ---------- @@ -623,10 +613,9 @@ def static_eye_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.eye_like. This method simply wraps - the function, and so the docstring for ivy.eye_like also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.eye_like. This method + simply wraps the function, and so the docstring for ivy.eye_like also + applies to this method with minimal changes. Parameters ---------- @@ -700,10 +689,9 @@ def eye_like( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eye_like. This method simply wraps - the function, and so the docstring for ivy.eye_like also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.eye_like. This method + simply wraps the function, and so the docstring for ivy.eye_like also + applies to this method with minimal changes. Parameters ---------- @@ -775,10 +763,10 @@ def static_unsorted_segment_min( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.unsorted_segment_min. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_min - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.unsorted_segment_min. + This method simply wraps the function, and so the docstring for + ivy.unsorted_segment_min also applies to this method with minimal + changes. Note ---- @@ -830,10 +818,10 @@ def unsorted_segment_min( segment_ids: ivy.Container, num_segments: Union[int, ivy.Container], ): - r""" - ivy.Container instance method variant of ivy.unsorted_segment_min. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_min - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.unsorted_segment_min. + This method simply wraps the function, and so the docstring for + ivy.unsorted_segment_min also applies to this method with minimal + changes. Note ---- @@ -875,10 +863,10 @@ def static_unsorted_segment_sum( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.unsorted_segment_sum. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_sum - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.unsorted_segment_sum. + This method simply wraps the function, and so the docstring for + ivy.unsorted_segment_sum also applies to this method with minimal + changes. Parameters ---------- @@ -925,10 +913,10 @@ def unsorted_segment_sum( segment_ids: ivy.Container, num_segments: Union[int, ivy.Container], ): - r""" - ivy.Container instance method variant of ivy.unsorted_segment_sum. This method - simply wraps the function, and so the docstring for ivy.unsorted_segment_sum - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.unsorted_segment_sum. + This method simply wraps the function, and so the docstring for + ivy.unsorted_segment_sum also applies to this method with minimal + changes. Parameters ---------- @@ -966,10 +954,9 @@ def static_blackman_window( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.blackman_window. This method simply - wraps the function, and so the docstring for ivy.blackman_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.blackman_window. This + method simply wraps the function, and so the docstring for + ivy.blackman_window also applies to this method with minimal changes. Parameters ---------- @@ -1018,10 +1005,9 @@ def blackman_window( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.blackman_window. This method simply - wraps the function, and so the docstring for ivy.blackman_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.blackman_window. This + method simply wraps the function, and so the docstring for + ivy.blackman_window also applies to this method with minimal changes. Parameters ---------- @@ -1114,10 +1100,9 @@ def static_mel_weight_matrix( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.mel_weight_matrix. This method - simply wraps the function, and so the docstring for ivy.mel_weight_matrix also - applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.mel_weight_matrix. This + method simply wraps the function, and so the docstring for + ivy.mel_weight_matrix also applies to this method with minimal changes. Parameters ---------- @@ -1169,10 +1154,9 @@ def mel_weight_matrix( lower_edge_hertz: Optional[float] = 0.0, upper_edge_hertz: Optional[float] = 3000.0, ): - r""" - ivy.Container instance method variant of ivy.mel_weight_matrix. This method - simply wraps the function, and so the docstring for ivy.mel_weight_matrix also - applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.mel_weight_matrix. This + method simply wraps the function, and so the docstring for + ivy.mel_weight_matrix also applies to this method with minimal changes. Parameters ---------- @@ -1211,8 +1195,8 @@ def static_unsorted_segment_mean( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Compute the mean of values in the input data based on segment identifiers. + """Compute the mean of values in the input data based on segment + identifiers. Parameters ---------- @@ -1257,9 +1241,8 @@ def unsorted_segment_mean( segment_ids: Union[ivy.Array, ivy.Container], num_segments: Union[int, ivy.Container], ) -> ivy.Container: - """ - Compute the mean of values in the input array or container based on segment - identifiers. + """Compute the mean of values in the input array or container based on + segment identifiers. Parameters ---------- @@ -1318,10 +1301,9 @@ def static_polyval( prune_unapplied: bool = False, map_sequences: bool = False, ) -> ivy.Container: - r""" - ivy.Container static method variant of ivy.polyval. This method simply wraps the - function, and so the docstring for ivy.polyval also applies to this method with - minimal changes. + r"""ivy.Container static method variant of ivy.polyval. This method + simply wraps the function, and so the docstring for ivy.polyval also + applies to this method with minimal changes. Evaluate and return a polynomial at specific given values. @@ -1365,10 +1347,9 @@ def polyval( coeffs: ivy.Container, x: ivy.Container, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.polyval. This method simply wraps - the function, and so the docstring for ivy.polyval also applies to this method - with minimal changes. + r"""ivy.Container instance method variant of ivy.polyval. This method + simply wraps the function, and so the docstring for ivy.polyval also + applies to this method with minimal changes. Evaluate and return a polynomial at specific given values. diff --git a/ivy/data_classes/container/experimental/elementwise.py b/ivy/data_classes/container/experimental/elementwise.py index 45cf7674adbb0..939c32874fc50 100644 --- a/ivy/data_classes/container/experimental/elementwise.py +++ b/ivy/data_classes/container/experimental/elementwise.py @@ -21,10 +21,9 @@ def static_amax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.amax. This method simply wraps the - function, and so the docstring for ivy.amax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.amax. This method simply + wraps the function, and so the docstring for ivy.amax also applies to + this method with minimal changes. Parameters ---------- @@ -117,10 +116,9 @@ def amax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.amax. This method simply wraps the - function, and so the docstring for ivy.amax also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.amax. This method + simply wraps the function, and so the docstring for ivy.amax also + applies to this method with minimal changes. Parameters ---------- @@ -213,10 +211,9 @@ def static_amin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.amin. This method simply wraps the - function, and so the docstring for ivy.amin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.amin. This method simply + wraps the function, and so the docstring for ivy.amin also applies to + this method with minimal changes. Parameters ---------- @@ -308,10 +305,9 @@ def amin( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.amin. This method simply wraps the - function, and so the docstring for ivy.amin also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.amin. This method + simply wraps the function, and so the docstring for ivy.amin also + applies to this method with minimal changes. Parameters ---------- @@ -401,10 +397,9 @@ def static_sinc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sinc. This method simply wraps the - function, and so the docstring for ivy.sinc also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sinc. This method simply + wraps the function, and so the docstring for ivy.sinc also applies to + this method with minimal changes. Parameters ---------- @@ -463,10 +458,9 @@ def sinc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sinc. This method simply wraps the - function, and so the docstring for ivy.sinc also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sinc. This method + simply wraps the function, and so the docstring for ivy.sinc also + applies to this method with minimal changes. Parameters ---------- @@ -527,10 +521,9 @@ def static_fmod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fmod. This method simply wraps the - function, and so the docstring for ivy.fmod also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fmod. This method simply + wraps the function, and so the docstring for ivy.fmod also applies to + this method with minimal changes. Parameters ---------- @@ -576,10 +569,9 @@ def fmod( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fmod. This method simply wraps the - function, and so the docstring for ivy.fmod also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fmod. This method + simply wraps the function, and so the docstring for ivy.fmod also + applies to this method with minimal changes. Parameters ---------- @@ -621,10 +613,9 @@ def static_fmax( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fmax. This method simply wraps the - function, and so the docstring for ivy.fmax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fmax. This method simply + wraps the function, and so the docstring for ivy.fmax also applies to + this method with minimal changes. Parameters ---------- @@ -670,10 +661,9 @@ def fmax( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fmax. This method simply wraps the - function, and so the docstring for ivy.fmax also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fmax. This method + simply wraps the function, and so the docstring for ivy.fmax also + applies to this method with minimal changes. Parameters ---------- @@ -715,10 +705,9 @@ def static_float_power( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.float_power. This method simply wraps - the function, and so the docstring for ivy.float_power also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.float_power. This method + simply wraps the function, and so the docstring for ivy.float_power + also applies to this method with minimal changes. Parameters ---------- @@ -764,10 +753,9 @@ def float_power( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.float_power. This method simply - wraps the function, and so the docstring for ivy.float_power also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.float_power. This + method simply wraps the function, and so the docstring for + ivy.float_power also applies to this method with minimal changes. Parameters ---------- @@ -809,10 +797,9 @@ def static_copysign( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.copysign. This method simply wraps - the function, and so the docstring for ivy.copysign also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.copysign. This method + simply wraps the function, and so the docstring for ivy.copysign also + applies to this method with minimal changes. Parameters ---------- @@ -863,10 +850,9 @@ def copysign( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.copysign. This method simply wraps - the function, and so the docstring for ivy.copysign also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.copysign. This method + simply wraps the function, and so the docstring for ivy.copysign also + applies to this method with minimal changes. Parameters ---------- @@ -915,10 +901,9 @@ def static_count_nonzero( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.count_nonzero. This method simply - wraps the function, and so the docstring for ivy.count_nonzero also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.count_nonzero. This + method simply wraps the function, and so the docstring for + ivy.count_nonzero also applies to this method with minimal changes. Parameters ---------- @@ -1005,10 +990,9 @@ def count_nonzero( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.count_nonzero. This method simply - wraps the function, and so the docstring for ivy.count_nonzero also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.count_nonzero. This + method simply wraps the function, and so the docstring for + ivy.count_nonzero also applies to this method with minimal changes. Parameters ---------- @@ -1096,10 +1080,9 @@ def static_nansum( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nansum. This method simply wraps the - function, and so the docstring for ivy.nansum also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nansum. This method + simply wraps the function, and so the docstring for ivy.nansum also + applies to this method with minimal changes. Parameters ---------- @@ -1167,10 +1150,9 @@ def nansum( keepdims: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nansum. This method simply wraps - the function, and so the docstring for ivy.nansum also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nansum. This method + simply wraps the function, and so the docstring for ivy.nansum also + applies to this method with minimal changes. Parameters ---------- @@ -1230,10 +1212,9 @@ def static_isclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.isclose. This method simply wraps the - function, and so the docstring for ivy.isclose also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.isclose. This method + simply wraps the function, and so the docstring for ivy.isclose also + applies to this method with minimal changes. Parameters ---------- @@ -1329,10 +1310,9 @@ def isclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.isclose. This method simply wraps - the function, and so the docstring for ivy.isclose also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.isclose. This method + simply wraps the function, and so the docstring for ivy.isclose also + applies to this method with minimal changes. Parameters ---------- @@ -1424,10 +1404,9 @@ def static_signbit( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.signbit. This method simply wraps the - function, and so the docstring for ivy.signbit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.signbit. This method + simply wraps the function, and so the docstring for ivy.signbit also + applies to this method with minimal changes. Parameters ---------- @@ -1467,10 +1446,9 @@ def signbit( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.signbit. This method simply wraps - the function, and so the docstring for ivy.signbit also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.signbit. This method + simply wraps the function, and so the docstring for ivy.signbit also + applies to this method with minimal changes. Parameters ---------- @@ -1508,10 +1486,9 @@ def static_hypot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hypot. This method simply wraps the - function, and so the docstring for ivy.hypot also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.hypot. This method simply + wraps the function, and so the docstring for ivy.hypot also applies to + this method with minimal changes. Parameters ---------- @@ -1573,10 +1550,9 @@ def hypot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hypot. This method simply wraps the - function, and so the docstring for ivy.hypot also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.hypot. This method + simply wraps the function, and so the docstring for ivy.hypot also + applies to this method with minimal changes. Parameters ---------- @@ -1641,10 +1617,9 @@ def static_allclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.allclose. This method simply wraps - the function, and so the docstring for ivy.allclose also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.allclose. This method + simply wraps the function, and so the docstring for ivy.allclose also + applies to this method with minimal changes. Parameters ---------- @@ -1732,10 +1707,9 @@ def allclose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.allclose. This method simply wraps - the function, and so the docstring for ivy.allclose also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.allclose. This method + simply wraps the function, and so the docstring for ivy.allclose also + applies to this method with minimal changes. Parameters ---------- @@ -1825,10 +1799,9 @@ def static_diff( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.diff. This method simply wraps the - function, and so the docstring for ivy.diff also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.diff. This method simply + wraps the function, and so the docstring for ivy.diff also applies to + this method with minimal changes. Parameters ---------- @@ -1902,10 +1875,9 @@ def diff( ] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diff. This method simply wraps the - function, and so the docstring for ivy.diff also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.diff. This method + simply wraps the function, and so the docstring for ivy.diff also + applies to this method with minimal changes. Parameters ---------- @@ -1955,10 +1927,9 @@ def static_fix( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fix. This method simply wraps the - function, and so the docstring for ivy.fix also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fix. This method simply + wraps the function, and so the docstring for ivy.fix also applies to + this method with minimal changes. Parameters ---------- @@ -1999,10 +1970,9 @@ def fix( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fix. This method simply wraps the - function, and so the docstring for ivy.fix also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fix. This method simply + wraps the function, and so the docstring for ivy.fix also applies to + this method with minimal changes. Parameters ---------- @@ -2041,10 +2011,9 @@ def static_nextafter( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nextafter. This method simply wraps - the function, and so the docstring for ivy.nextafter also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.nextafter. This method + simply wraps the function, and so the docstring for ivy.nextafter also + applies to this method with minimal changes. Parameters ---------- @@ -2107,10 +2076,9 @@ def nextafter( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nextafter. This method simply wraps - the function, and so the docstring for ivy.nextafter also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nextafter. This method + simply wraps the function, and so the docstring for ivy.nextafter also + applies to this method with minimal changes. Parameters ---------- @@ -2173,10 +2141,9 @@ def static_zeta( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.zeta. This method simply wraps the - function, and so the docstring for ivy.zeta also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.zeta. This method simply + wraps the function, and so the docstring for ivy.zeta also applies to + this method with minimal changes. Parameters ---------- @@ -2238,10 +2205,9 @@ def zeta( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.zeta. This method simply wraps the - function, and so the docstring for ivy.zeta also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.zeta. This method + simply wraps the function, and so the docstring for ivy.zeta also + applies to this method with minimal changes. Parameters ---------- @@ -2324,8 +2290,7 @@ def gradient( edge_order: Union[int, ivy.Container] = 1, axis: Optional[Union[int, list, tuple, ivy.Container]] = None, ) -> ivy.Container: - """ - Calculate gradient of x with respect to (w.r.t.) spacing. + """Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -2465,10 +2430,9 @@ def static_xlogy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.xlogy. This method simply wraps the - function, and so the docstring for ivy.xlogy also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.xlogy. This method simply + wraps the function, and so the docstring for ivy.xlogy also applies to + this method with minimal changes. Parameters ---------- @@ -2531,10 +2495,9 @@ def xlogy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.xlogy. This method simply wraps the - function, and so the docstring for ivy.xlogy also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.xlogy. This method + simply wraps the function, and so the docstring for ivy.xlogy also + applies to this method with minimal changes. Parameters ---------- @@ -2597,9 +2560,8 @@ def static_binarizer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Map the values of the input tensor to either 0 or 1, element-wise, based on the - outcome of a comparison against a threshold value. + """Map the values of the input tensor to either 0 or 1, element-wise, + based on the outcome of a comparison against a threshold value. Parameters ---------- @@ -2649,9 +2611,8 @@ def binarizer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Map the values of the input tensor to either 0 or 1, element-wise, based on the - outcome of a comparison against a threshold value. + """Map the values of the input tensor to either 0 or 1, element-wise, + based on the outcome of a comparison against a threshold value. Parameters ---------- @@ -2699,10 +2660,9 @@ def static_conj( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conj. This method simply wraps the - function, and so the docstring for ivy.conj also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.conj. This method simply + wraps the function, and so the docstring for ivy.conj also applies to + this method with minimal changes. Parameters ---------- @@ -2762,10 +2722,9 @@ def conj( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conj. This method simply wraps the - function, and so the docstring for ivy.conj also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.conj. This method + simply wraps the function, and so the docstring for ivy.conj also + applies to this method with minimal changes. Parameters ---------- @@ -2826,10 +2785,9 @@ def static_ldexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.ldexp. This method simply wraps the - function, and so the docstring for ivy.ldexp also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.ldexp. This method simply + wraps the function, and so the docstring for ivy.ldexp also applies to + this method with minimal changes. Parameters ---------- @@ -2886,10 +2844,9 @@ def ldexp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.ldexp. This method simply wraps the - function, and so the docstring for ivy.ldexp also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.ldexp. This method + simply wraps the function, and so the docstring for ivy.ldexp also + applies to this method with minimal changes. Parameters ---------- @@ -2931,10 +2888,9 @@ def static_lerp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.lerp. This method simply wraps the - function, and so the docstring for ivy.lerp also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.lerp. This method simply + wraps the function, and so the docstring for ivy.lerp also applies to + this method with minimal changes. Parameters ---------- @@ -3007,10 +2963,9 @@ def lerp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.lerp. This method simply wraps the - function, and so the docstring for ivy.lerp also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.lerp. This method + simply wraps the function, and so the docstring for ivy.lerp also + applies to this method with minimal changes. Parameters ---------- @@ -3053,10 +3008,9 @@ def static_frexp( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.frexp. This method simply wraps the - function, and so the docstring for ivy.frexp also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.frexp. This method simply + wraps the function, and so the docstring for ivy.frexp also applies to + this method with minimal changes. Parameters ---------- @@ -3107,10 +3061,9 @@ def frexp( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.frexp. This method simply wraps the - function, and so the docstring for ivy.frexp also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.frexp. This method + simply wraps the function, and so the docstring for ivy.frexp also + applies to this method with minimal changes. Parameters ---------- @@ -3148,10 +3101,9 @@ def static_modf( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.modf. This method simply wraps the - function, and so the docstring for ivy.modf also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.modf. This method simply + wraps the function, and so the docstring for ivy.modf also applies to + this method with minimal changes. Parameters ---------- @@ -3204,10 +3156,9 @@ def modf( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.modf. This method simply wraps the - function, and so the docstring for ivy.modf also applies to this method with - minimal changes. + r"""ivy.Container instance method variant of ivy.modf. This method + simply wraps the function, and so the docstring for ivy.modf also + applies to this method with minimal changes. Parameters ---------- @@ -3246,10 +3197,9 @@ def static_digamma( map_sequences: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.digamma. This method simply wraps the - function, and so the docstring for ivy.digamma also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.digamma. This method + simply wraps the function, and so the docstring for ivy.digamma also + applies to this method with minimal changes. Note ---- @@ -3309,10 +3259,9 @@ def digamma( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.digamma. This method simply wraps - the function, and so the docstring for ivy.digamma also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.digamma. This method + simply wraps the function, and so the docstring for ivy.digamma also + applies to this method with minimal changes. Note ---- @@ -3372,10 +3321,9 @@ def static_sparsify_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sparsify_tensor. This method simply - wraps the function, and so the docstring for ivy.sparsify_tensor also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.sparsify_tensor. This + method simply wraps the function, and so the docstring for + ivy.sparsify_tensor also applies to this method with minimal changes. Parameters ---------- @@ -3437,8 +3385,7 @@ def sparsify_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sparsify_tensor. + """ivy.Container instance method variant of ivy.sparsify_tensor. This method simply wraps the function, and so the docstring for ivy.sparsify_tensor also applies to this method with minimal @@ -3465,10 +3412,9 @@ def static_erfc( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.erfc. This method simply wraps the - function, and so the docstring for ivy.erfc also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.erfc. This method simply + wraps the function, and so the docstring for ivy.erfc also applies to + this method with minimal changes. Parameters ---------- @@ -3518,10 +3464,9 @@ def erfc( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.erfc. This method simply wraps the - function, and so the docstring for ivy.erfc also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.erfc. This method + simply wraps the function, and so the docstring for ivy.erfc also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/general.py b/ivy/data_classes/container/experimental/general.py index af380102a50ce..e44bc1fc8e506 100644 --- a/ivy/data_classes/container/experimental/general.py +++ b/ivy/data_classes/container/experimental/general.py @@ -21,10 +21,9 @@ def _static_reduce( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.reduce. This method simply wraps the - function, and so the docstring for ivy.reduce also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.reduce. This method + simply wraps the function, and so the docstring for ivy.reduce also + applies to this method with minimal changes. Parameters ---------- @@ -95,10 +94,9 @@ def reduce( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.reduce. This method simply wraps - the function, and so the docstring for ivy.reduce also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.reduce. This method + simply wraps the function, and so the docstring for ivy.reduce also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/layers.py b/ivy/data_classes/container/experimental/layers.py index 1d22b10c04f52..ebbb6ed120669 100644 --- a/ivy/data_classes/container/experimental/layers.py +++ b/ivy/data_classes/container/experimental/layers.py @@ -24,10 +24,9 @@ def static_max_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_pool1d. This method simply wraps - the function, and so the docstring for ivy.max_pool1d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.max_pool1d. This method + simply wraps the function, and so the docstring for ivy.max_pool1d also + applies to this method with minimal changes. Parameters ---------- @@ -101,10 +100,9 @@ def max_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.max_pool1d`. This method simply - wraps the function, and so the docstring for `ivy.max_pool1d` also applies to - this method with minimal changes. + """ivy.Container instance method variant of `ivy.max_pool1d`. This + method simply wraps the function, and so the docstring for + `ivy.max_pool1d` also applies to this method with minimal changes. Parameters ---------- @@ -178,10 +176,9 @@ def static_max_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_pool2dd. This method simply wraps - the function, and so the docstring for ivy.max_pool2d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.max_pool2dd. This method + simply wraps the function, and so the docstring for ivy.max_pool2d also + applies to this method with minimal changes. Parameters ---------- @@ -253,10 +250,9 @@ def max_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.max_pool2d`. This method simply - wraps the function, and so the docstring for `ivy.max_pool2d` also applies to - this method with minimal changes. + """ivy.Container instance method variant of `ivy.max_pool2d`. This + method simply wraps the function, and so the docstring for + `ivy.max_pool2d` also applies to this method with minimal changes. Parameters ---------- @@ -332,10 +328,9 @@ def static_max_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_pool3d. This method simply wraps - the function, and so the docstring for ivy.max_pool3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.max_pool3d. This method + simply wraps the function, and so the docstring for ivy.max_pool3d also + applies to this method with minimal changes. Parameters ---------- @@ -410,10 +405,9 @@ def max_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_pool3d. This method simply wraps - the function, and so the docstring for ivy.max_pool3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.max_pool3d. This method + simply wraps the function, and so the docstring for ivy.max_pool3d also + applies to this method with minimal changes. Parameters ---------- @@ -485,10 +479,9 @@ def static_avg_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.avg_pool1d. This method simply wraps - the function, and so the docstring for ivy.avg_pool1d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.avg_pool1d. This method + simply wraps the function, and so the docstring for ivy.avg_pool1d also + applies to this method with minimal changes. Parameters ---------- @@ -561,10 +554,9 @@ def avg_pool1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.avg_pool1d`. This method simply - wraps the function, and so the docstring for `ivy.avg_pool1d` also applies to - this method with minimal changes. + """ivy.Container instance method variant of `ivy.avg_pool1d`. This + method simply wraps the function, and so the docstring for + `ivy.avg_pool1d` also applies to this method with minimal changes. Parameters ---------- @@ -638,10 +630,9 @@ def static_avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.avg_pool2d. This method simply wraps - the function, and so the docstring for ivy.avg_pool2d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.avg_pool2d. This method + simply wraps the function, and so the docstring for ivy.avg_pool2d also + applies to this method with minimal changes. Parameters ---------- @@ -718,10 +709,9 @@ def avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.avg_pool2d`. This method simply - wraps the function, and so the docstring for `ivy.avg_pool2d` also applies to - this method with minimal changes. + """ivy.Container instance method variant of `ivy.avg_pool2d`. This + method simply wraps the function, and so the docstring for + `ivy.avg_pool2d` also applies to this method with minimal changes. Parameters ---------- @@ -798,10 +788,9 @@ def static_avg_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.avg_pool3d. This method simply wraps - the function, and so the docstring for ivy.avg_pool3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.avg_pool3d. This method + simply wraps the function, and so the docstring for ivy.avg_pool3d also + applies to this method with minimal changes. Parameters ---------- @@ -879,10 +868,9 @@ def avg_pool3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.avg_pool3d. This method simply wraps - the function, and so the docstring for ivy.avg_pool3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.avg_pool3d. This method + simply wraps the function, and so the docstring for ivy.avg_pool3d also + applies to this method with minimal changes. Parameters ---------- @@ -959,10 +947,9 @@ def static_dct( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dct. This method simply wraps the - function, and so the docstring for ivy.dct also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.dct. This method simply + wraps the function, and so the docstring for ivy.dct also applies to + this method with minimal changes. Parameters ---------- @@ -1035,10 +1022,9 @@ def dct( norm: Optional[Union[Literal["ortho"], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dct. This method simply wraps the - function, and so the docstring for ivy.dct also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.dct. This method simply + wraps the function, and so the docstring for ivy.dct also applies to + this method with minimal changes. Parameters ---------- @@ -1095,10 +1081,9 @@ def static_idct( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.idct. This method simply wraps the - function, and so the docstring for ivy.idct also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.idct. This method simply + wraps the function, and so the docstring for ivy.idct also applies to + this method with minimal changes. Parameters ---------- @@ -1173,10 +1158,9 @@ def idct( norm: Optional[Union[Literal["ortho"], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.idct. This method simply wraps the - function, and so the docstring for ivy.idct also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.idct. This method + simply wraps the function, and so the docstring for ivy.idct also + applies to this method with minimal changes. Parameters ---------- @@ -1232,10 +1216,9 @@ def _static_fft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fft. This method simply wraps the - function, and so the docstring for ivy.fft also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fft. This method simply + wraps the function, and so the docstring for ivy.fft also applies to + this method with minimal changes. Parameters ---------- @@ -1304,10 +1287,9 @@ def fft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fft. This method simply wraps the - function, and so the docstring for ivy.fft also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.fft. This method simply + wraps the function, and so the docstring for ivy.fft also applies to + this method with minimal changes. Parameters ---------- @@ -1375,10 +1357,9 @@ def static_ifft( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.ifft. This method simply wraps the - function, and so the docstring for ivy.ifft also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.ifft. This method simply + wraps the function, and so the docstring for ivy.ifft also applies to + this method with minimal changes. Parameters ---------- @@ -1442,10 +1423,9 @@ def ifft( n: Optional[Union[int, Tuple[int], ivy.Container]] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ): - """ - ivy.Container instance method variant of ivy.ifft. This method simply wraps the - function, and so the docstring for ivy.ifft also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.ifft. This method + simply wraps the function, and so the docstring for ivy.ifft also + applies to this method with minimal changes. Parameters ---------- @@ -1666,8 +1646,7 @@ def static_interpolate( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Down/up samples the input to the given size. The algorithm used for + """Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -1755,8 +1734,7 @@ def interpolate( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Down/up samples the input to the given size. The algorithm used for + """Down/up samples the input to the given size. The algorithm used for interpolation is determined by mode. Parameters @@ -1825,10 +1803,10 @@ def static_adaptive_avg_pool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.adaptive_avg_pool1d. This method - simply wraps the function, and so the docstring for ivy.adaptive_avg_pool1d also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.adaptive_avg_pool1d. This + method simply wraps the function, and so the docstring for + ivy.adaptive_avg_pool1d also applies to this method with minimal + changes. Parameters ---------- @@ -1863,9 +1841,8 @@ def adaptive_avg_pool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Apply a 1D adaptive average pooling over an input signal composed of several - input planes. + """Apply a 1D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -1899,10 +1876,10 @@ def static_adaptive_avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, data_format: str = "NHWC", ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.adaptive_avg_pool2d. This method - simply wraps the function, and so the docstring for ivy.adaptive_avg_pool2d also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.adaptive_avg_pool2d. This + method simply wraps the function, and so the docstring for + ivy.adaptive_avg_pool2d also applies to this method with minimal + changes. Parameters ---------- @@ -1940,9 +1917,8 @@ def adaptive_avg_pool2d( map_sequences: Union[bool, ivy.Container] = False, data_format: str = "NHWC", ) -> ivy.Container: - """ - Apply a 2D adaptive average pooling over an input signal composed of several - input planes. + """Apply a 2D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -1977,10 +1953,10 @@ def static_adaptive_max_pool2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.adaptive_max_pool2d. This method - simply wraps the function, and so the docstring for ivy.adaptive_max_pool2d also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.adaptive_max_pool2d. This + method simply wraps the function, and so the docstring for + ivy.adaptive_max_pool2d also applies to this method with minimal + changes. Parameters ---------- @@ -2015,9 +1991,8 @@ def adaptive_max_pool2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Apply a 2D adaptive maximum pooling over an input signal composed of several - input planes. + """Apply a 2D adaptive maximum pooling over an input signal composed of + several input planes. Parameters ---------- @@ -2052,8 +2027,7 @@ def static_ifftn( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.ifftn. + """ivy.Container static method variant of ivy.ifftn. This method simply wraps the function, and so the docstring for ivy.ifftn also applies to this method with minimal changes. @@ -2111,8 +2085,7 @@ def ifftn( norm: Union[str, ivy.Container] = "backward", out: Optional[Union[ivy.Array, ivy.Container]] = None, ): - """ - ivy.Container static method variant of ivy.ifftn. + """ivy.Container static method variant of ivy.ifftn. This method simply wraps the function, and so the docstring for ivy.ifftn also applies to this method with minimal changes. @@ -2196,8 +2169,7 @@ def static_rfft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rfft. + """ivy.Container static method variant of ivy.rfft. This method simply wraps the function, and so the docstring for ivy.rfft also applies to this method with minimal changes. @@ -2286,10 +2258,9 @@ def rfft( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ): - """ - ivy.Container instance method variant of ivy.rfft. This method simply wraps the - function, and so the docstring for ivy.rfft also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.rfft. This method + simply wraps the function, and so the docstring for ivy.rfft also + applies to this method with minimal changes. Parameters ---------- @@ -2372,8 +2343,7 @@ def static_rfftn( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rfftn. + """ivy.Container static method variant of ivy.rfftn. This method simply wraps the function, and so the docstring for ivy.rfftn also applies to this method with minimal changes. @@ -2437,8 +2407,7 @@ def rfftn( norm: Union[str, ivy.Container] = "backward", out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - Compute the n-dimensional discrete Fourier Transform for real input. + """Compute the n-dimensional discrete Fourier Transform for real input. Parameters ---------- @@ -2485,8 +2454,7 @@ def static_stft( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stft. + """ivy.Container static method variant of ivy.stft. This method simply wraps the function, and so the docstring for ivy.stft also applies to this method with minimal changes. @@ -2550,8 +2518,7 @@ def stft( name: Optional[Union[str, ivy.Container]] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - Compute the Short-time Fourier Transform of signals. + """Compute the Short-time Fourier Transform of signals. Parameters ---------- @@ -2608,10 +2575,9 @@ def _static_sliding_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sliding_window. This method simply - wraps the function, and so the docstring for ivy.sliding_window also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.sliding_window. This + method simply wraps the function, and so the docstring for + ivy.sliding_window also applies to this method with minimal changes. Parameters ---------- @@ -2690,10 +2656,9 @@ def sliding_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sliding_window. This method simply - wraps the function, and so the docstring for ivy.sliding_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.sliding_window. This + method simply wraps the function, and so the docstring for + ivy.sliding_window also applies to this method with minimal changes. Parameters ---------- @@ -2769,8 +2734,7 @@ def static_max_unpool1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.max_unpool1d. + """ivy.Container static method variant of ivy.max_unpool1d. Parameters ---------- @@ -2829,8 +2793,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Container: - """ - Compute a 1-D max unpooling given the 1-D pooled input x and its indices. + """Compute a 1-D max unpooling given the 1-D pooled input x and its + indices. Parameters ---------- @@ -2879,8 +2843,7 @@ def static_rnn( zero_output_for_mask: bool = False, return_all_outputs: bool = True, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rnn. + """ivy.Container static method variant of ivy.rnn. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/linear_algebra.py b/ivy/data_classes/container/experimental/linear_algebra.py index b3fa46889d2d2..697d0ef749e52 100644 --- a/ivy/data_classes/container/experimental/linear_algebra.py +++ b/ivy/data_classes/container/experimental/linear_algebra.py @@ -24,10 +24,9 @@ def static_eigh_tridiagonal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container]]: - """ - ivy.Container static method variant of ivy.eigh_tridiagonal. This method simply - wraps the function, and so the docstring for ivy.eigh_tridiagonal also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.eigh_tridiagonal. This + method simply wraps the function, and so the docstring for + ivy.eigh_tridiagonal also applies to this method with minimal changes. Parameters ---------- @@ -118,10 +117,9 @@ def eigh_tridiagonal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container]]: - """ - ivy.Container instance method variant of ivy.eigh_tridiagonal. This method - simply wraps the function, and so the docstring for ivy.eigh_tridiagonal also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.eigh_tridiagonal. This + method simply wraps the function, and so the docstring for + ivy.eigh_tridiagonal also applies to this method with minimal changes. Parameters ---------- @@ -236,10 +234,9 @@ def diagflat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diagflat. This method simply wraps - the function, and so the docstring for ivy.diagflat also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.diagflat. This method + simply wraps the function, and so the docstring for ivy.diagflat also + applies to this method with minimal changes. Examples -------- @@ -277,10 +274,9 @@ def static_kron( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.kron. This method simply wraps the - function, and so the docstring for ivy.kron also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.kron. This method simply + wraps the function, and so the docstring for ivy.kron also applies to + this method with minimal changes. Parameters ---------- @@ -329,10 +325,9 @@ def kron( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.kron. This method simply wraps the - function, and so the docstring for ivy.kron also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.kron. This method + simply wraps the function, and so the docstring for ivy.kron also + applies to this method with minimal changes. Examples -------- @@ -379,10 +374,9 @@ def matrix_exp( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diagflat. This method simply wraps - the function, and so the docstring for ivy.diagflat also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.diagflat. This method + simply wraps the function, and so the docstring for ivy.diagflat also + applies to this method with minimal changes. Examples -------- @@ -413,10 +407,9 @@ def static_eig( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.eig. This method simply wraps the - function, and so the docstring for ivy.eig also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.eig. This method simply + wraps the function, and so the docstring for ivy.eig also applies to + this method with minimal changes. Parameters ---------- @@ -466,10 +459,9 @@ def eig( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eig. This method simply wraps the - function, and so the docstring for ivy.eig also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.eig. This method simply + wraps the function, and so the docstring for ivy.eig also applies to + this method with minimal changes. Parameters ---------- @@ -519,10 +511,9 @@ def static_eigvals( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.eigvals. This method simply wraps the - function, and so the docstring for ivy.eigvals also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.eigvals. This method + simply wraps the function, and so the docstring for ivy.eigvals also + applies to this method with minimal changes. Parameters ---------- @@ -566,10 +557,9 @@ def eigvals( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eigvals. This method simply wraps - the function, and so the docstring for ivy.eigvals also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.eigvals. This method + simply wraps the function, and so the docstring for ivy.eigvals also + applies to this method with minimal changes. Parameters ---------- @@ -612,10 +602,9 @@ def static_adjoint( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.adjoint. This method simply wraps the - function, and so the docstring for ivy.adjoint also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.adjoint. This method + simply wraps the function, and so the docstring for ivy.adjoint also + applies to this method with minimal changes. Parameters ---------- @@ -661,10 +650,9 @@ def adjoint( to_apply: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """ - ivy.Container instance method variant of ivy.adjoint. This method simply wraps - the function, and so the docstring for ivy.adjoint also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.adjoint. This method + simply wraps the function, and so the docstring for ivy.adjoint also + applies to this method with minimal changes. Examples -------- @@ -692,10 +680,9 @@ def static_multi_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.multi_dot. This method simply wraps - the function, and so the docstring for ivy.multi_dot also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.multi_dot. This method + simply wraps the function, and so the docstring for ivy.multi_dot also + applies to this method with minimal changes. Parameters ---------- @@ -750,10 +737,9 @@ def multi_dot( map_sequences: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.multi_dot. This method simply wraps - the function, and so the docstring for ivy.multi_dot also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.multi_dot. This method + simply wraps the function, and so the docstring for ivy.multi_dot also + applies to this method with minimal changes. Examples -------- @@ -792,10 +778,9 @@ def static_cond( p: Optional[Union[int, float, None, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.cond. This method simply wraps the - function, and so the docstring for ivy.cond also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cond. This method simply + wraps the function, and so the docstring for ivy.cond also applies to + this method with minimal changes. Parameters ---------- @@ -837,10 +822,9 @@ def cond( map_sequences: Union[bool, ivy.Container] = False, p: Optional[Union[int, float, None, ivy.Container]] = None, ): - """ - ivy.Container instance method variant of ivy.cond. This method simply wraps the - function, and so the docstring for ivy.cond also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cond. This method + simply wraps the function, and so the docstring for ivy.cond also + applies to this method with minimal changes. Parameters ---------- @@ -900,10 +884,9 @@ def static_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.mode_dot. This method simply wraps - the function, and so the docstring for ivy.mode_dot also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.mode_dot. This method + simply wraps the function, and so the docstring for ivy.mode_dot also + applies to this method with minimal changes. Parameters ---------- @@ -956,10 +939,9 @@ def mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container instance method variant of ivy.mode_dot. This method simply wraps - the function, and so the docstring for ivy.mode_dot also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.mode_dot. This method + simply wraps the function, and so the docstring for ivy.mode_dot also + applies to this method with minimal changes. Parameters ---------- @@ -1013,10 +995,9 @@ def static_multi_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.multi_mode_dot. This method simply - wraps the function, and so the docstring for ivy.multi_mode_dot also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.multi_mode_dot. This + method simply wraps the function, and so the docstring for + ivy.multi_mode_dot also applies to this method with minimal changes. Parameters ---------- @@ -1073,10 +1054,9 @@ def multi_mode_dot( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.multi_mode_dot. This method simply - wraps the function, and so the docstring for ivy.multi_mode_dot also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.multi_mode_dot. This + method simply wraps the function, and so the docstring for + ivy.multi_mode_dot also applies to this method with minimal changes. Parameters ---------- @@ -1130,10 +1110,9 @@ def static_svd_flip( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.svd_flip. This method simply wraps - the function, and so the docstring for ivy.svd_flip also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.svd_flip. This method + simply wraps the function, and so the docstring for ivy.svd_flip also + applies to this method with minimal changes. Parameters ---------- @@ -1172,10 +1151,9 @@ def svd_flip( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.svd_flip. This method simply wraps - the function, and so the docstring for ivy.svd_flip applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.svd_flip. This method + simply wraps the function, and so the docstring for ivy.svd_flip + applies to this method with minimal changes. Parameters ---------- @@ -1216,10 +1194,10 @@ def static_make_svd_non_negative( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.make_svd_non_negative. This method - simply wraps the function, and so the docstring for ivy.make_svd_non_negative - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.make_svd_non_negative. + This method simply wraps the function, and so the docstring for + ivy.make_svd_non_negative also applies to this method with minimal + changes. Parameters ---------- @@ -1263,10 +1241,9 @@ def make_svd_non_negative( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.make_svd_non_negative. This method - simply wraps the function, and so the docstring for ivy.make_svd_non_negative - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.make_svd_non_negative. + This method simply wraps the function, and so the docstring for + ivy.make_svd_non_negative applies to this method with minimal changes. Parameters ---------- @@ -1309,10 +1286,9 @@ def static_tensor_train( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.tensor_train. This method simply - wraps the function, and so the docstring for ivy.tensor_train also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.tensor_train. This method + simply wraps the function, and so the docstring for ivy.tensor_train + also applies to this method with minimal changes. Parameters ---------- @@ -1349,10 +1325,9 @@ def tensor_train( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container instance method variant of ivy.tensor_train. This method simply - wraps the function, and so the docstring for ivy.tensor_train also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.tensor_train. This + method simply wraps the function, and so the docstring for + ivy.tensor_train also applies to this method with minimal changes. Parameters ---------- @@ -1388,10 +1363,9 @@ def static_truncated_svd( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container, ivy.Container]]: - """ - ivy.Container static method variant of ivy.truncated_svd. This method simply - wraps the function, and so the docstring for ivy.truncated_svd also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.truncated_svd. This + method simply wraps the function, and so the docstring for + ivy.truncated_svd also applies to this method with minimal changes. Parameters ---------- @@ -1435,10 +1409,9 @@ def truncated_svd( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Container, Tuple[ivy.Container, ivy.Container, ivy.Container]]: - """ - ivy.Container instance method variant of ivy.truncated_svd. This method simply - wraps the function, and so the docstring for ivy.truncated_svd also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.truncated_svd. This + method simply wraps the function, and so the docstring for + ivy.truncated_svd also applies to this method with minimal changes. Parameters ---------- @@ -1490,10 +1463,9 @@ def static_initialize_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.initialize_tucker. This method simply - wraps the function, and so the docstring for ivy.initialize_tucker also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.initialize_tucker. This + method simply wraps the function, and so the docstring for + ivy.initialize_tucker also applies to this method with minimal changes. Parameters ---------- @@ -1564,10 +1536,9 @@ def initialize_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container instance method variant of ivy.initialize_tucker. This method - simply wraps the function, and so the docstring for ivy.initialize_tucker also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.initialize_tucker. This + method simply wraps the function, and so the docstring for + ivy.initialize_tucker also applies to this method with minimal changes. Parameters ---------- @@ -1641,10 +1612,9 @@ def static_partial_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.partial_tucker. This method simply - wraps the function, and so the docstring for ivy.partial_tucker also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.partial_tucker. This + method simply wraps the function, and so the docstring for + ivy.partial_tucker also applies to this method with minimal changes. Parameters ---------- @@ -1719,10 +1689,9 @@ def partial_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.partial_tucker. This method simply - wraps the function, and so the docstring for ivy.partial_tucker also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.partial_tucker. This + method simply wraps the function, and so the docstring for + ivy.partial_tucker also applies to this method with minimal changes. Parameters ---------- @@ -1797,10 +1766,9 @@ def static_tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.tucker. This method simply wraps the - function, and so the docstring for ivy.tucker also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tucker. This method + simply wraps the function, and so the docstring for ivy.tucker also + applies to this method with minimal changes. Parameters ---------- @@ -1895,10 +1863,9 @@ def tucker( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, Sequence[ivy.Container]]: - """ - ivy.Container static method variant of ivy.tucker. This method simply wraps the - function, and so the docstring for ivy.tucker also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tucker. This method + simply wraps the function, and so the docstring for ivy.tucker also + applies to this method with minimal changes. Parameters ---------- @@ -1982,10 +1949,9 @@ def static_dot( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Array, ivy.Container]: - """ - Compute the dot product between two arrays `a` and `b` using the current - backend's implementation. The dot product is defined as the sum of the element- - wise product of the input arrays. + """Compute the dot product between two arrays `a` and `b` using the + current backend's implementation. The dot product is defined as the sum + of the element- wise product of the input arrays. Parameters ---------- @@ -2048,10 +2014,9 @@ def dot( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Union[ivy.Array, ivy.Container]: - """ - Compute the dot product between two arrays `a` and `b` using the current - backend's implementation. The dot product is defined as the sum of the element- - wise product of the input arrays. + """Compute the dot product between two arrays `a` and `b` using the + current backend's implementation. The dot product is defined as the sum + of the element- wise product of the input arrays. Parameters ---------- @@ -2113,10 +2078,10 @@ def static_tt_matrix_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tt_matrix_to_tensor. This method - simply wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.tt_matrix_to_tensor. This + method simply wraps the function, and so the docstring for + ivy.tt_matrix_to_tensor also applies to this method with minimal + changes. Parameters ---------- @@ -2180,10 +2145,10 @@ def tt_matrix_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tt_matrix_to_tensor. This method - simply wraps the function, and so the docstring for ivy.tt_matrix_to_tensor also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.tt_matrix_to_tensor. + This method simply wraps the function, and so the docstring for + ivy.tt_matrix_to_tensor also applies to this method with minimal + changes. Parameters ---------- @@ -2248,10 +2213,10 @@ def static_higher_order_moment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.higher_order_moment. This method - simply wraps the function, and so the docstring for ivy.higher_order_moment also - applies to this method with minimal changes. + """ivy.Container static method variant of ivy.higher_order_moment. This + method simply wraps the function, and so the docstring for + ivy.higher_order_moment also applies to this method with minimal + changes. Parameters ---------- @@ -2290,10 +2255,10 @@ def higher_order_moment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.higher_order_moment. This method - simply wraps the function, and so the docstring for ivy.higher_order_moment also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.higher_order_moment. + This method simply wraps the function, and so the docstring for + ivy.higher_order_moment also applies to this method with minimal + changes. Parameters ---------- @@ -2343,10 +2308,9 @@ def static_batched_outer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.batched_outer. This method simply - wraps the function, and so the docstring for ivy.batched_outer also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.batched_outer. This + method simply wraps the function, and so the docstring for + ivy.batched_outer also applies to this method with minimal changes. Parameters ---------- @@ -2403,10 +2367,9 @@ def batched_outer( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.batched_outer. This method simply - wraps the function, and so the docstring for ivy.batched_outer also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.batched_outer. This + method simply wraps the function, and so the docstring for + ivy.batched_outer also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/losses.py b/ivy/data_classes/container/experimental/losses.py index cbd27d371dc1d..26fc89086aadc 100644 --- a/ivy/data_classes/container/experimental/losses.py +++ b/ivy/data_classes/container/experimental/losses.py @@ -20,10 +20,9 @@ def _static_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.l1_loss. This method simply wraps the - function, and so the docstring for ivy.l1_loss also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.l1_loss. This method + simply wraps the function, and so the docstring for ivy.l1_loss also + applies to this method with minimal changes. Parameters ---------- @@ -103,10 +102,9 @@ def l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.l1_loss. This method simply wraps - the function, and so the docstring for ivy.l1_loss also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.l1_loss. This method + simply wraps the function, and so the docstring for ivy.l1_loss also + applies to this method with minimal changes. Parameters ---------- @@ -175,10 +173,9 @@ def _static_log_poisson_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.log_poisson_loss. This method simply - wraps the function, and so the docstring for ivy.log_poisson_loss also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.log_poisson_loss. This + method simply wraps the function, and so the docstring for + ivy.log_poisson_loss also applies to this method with minimal changes. Parameters ---------- @@ -269,10 +266,9 @@ def log_poisson_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.log_poisson_loss. This method - simply wraps the function, and so the docstring for ivy.log_poisson_loss also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.log_poisson_loss. This + method simply wraps the function, and so the docstring for + ivy.log_poisson_loss also applies to this method with minimal changes. Parameters ---------- @@ -349,10 +345,9 @@ def _static_smooth_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.smooth_l1_loss. This method simply - wraps the function, and so the docstring for ivy. smooth_l1_loss also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.smooth_l1_loss. This + method simply wraps the function, and so the docstring for ivy. + smooth_l1_loss also applies to this method with minimal changes. Parameters ---------- @@ -439,10 +434,9 @@ def smooth_l1_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.smooth_l1_loss. This method simply - wraps the function, and so the docstring for ivy. smooth_l1_loss also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.smooth_l1_loss. This + method simply wraps the function, and so the docstring for ivy. + smooth_l1_loss also applies to this method with minimal changes. Parameters ---------- @@ -518,10 +512,9 @@ def _static_huber_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of huber_loss. This method simply wraps the - function, and so the docstring for huber_loss also applies to this method with - minimal changes. + """ivy.Container static method variant of huber_loss. This method + simply wraps the function, and so the docstring for huber_loss also + applies to this method with minimal changes. Parameters ---------- @@ -608,10 +601,9 @@ def huber_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of huber_loss. This method simply wraps - the function, and so the docstring for huber_loss also applies to this method - with minimal changes. + """ivy.Container instance method variant of huber_loss. This method + simply wraps the function, and so the docstring for huber_loss also + applies to this method with minimal changes. Parameters ---------- @@ -683,10 +675,9 @@ def _static_soft_margin_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.soft_margin_loss. This method simply - wraps the function, and so the docstring for ivy.soft_margin_loss also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.soft_margin_loss. This + method simply wraps the function, and so the docstring for + ivy.soft_margin_loss also applies to this method with minimal changes. # Insert the docstring here @@ -742,10 +733,9 @@ def soft_margin_loss( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.soft_margin_loss. This method - simply wraps the function, and so the docstring for ivy.soft_margin_loss also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.soft_margin_loss. This + method simply wraps the function, and so the docstring for + ivy.soft_margin_loss also applies to this method with minimal changes. # Insert the docstring here @@ -802,10 +792,9 @@ def _static_kl_div( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.kl_div. This method simply wraps the - function, and so the docstring for ivy.kl_div also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.kl_div. This method + simply wraps the function, and so the docstring for ivy.kl_div also + applies to this method with minimal changes. Parameters ---------- @@ -861,10 +850,9 @@ def kl_div( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.kl_div. This method simply wraps - the function, and so the docstring for ivy.kl_div also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.kl_div. This method + simply wraps the function, and so the docstring for ivy.kl_div also + applies to this method with minimal changes. Parameters ---------- @@ -920,10 +908,9 @@ def _static_poisson_nll_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container static method variant of ivy.poisson_nll_loss. This method - simplywraps the function, and so the docstring for ivy.poisson_nll_loss also - applies to this method with minimal changes. + r"""ivy.Container static method variant of ivy.poisson_nll_loss. This + method simplywraps the function, and so the docstring for + ivy.poisson_nll_loss also applies to this method with minimal changes. Parameters ---------- @@ -1026,10 +1013,9 @@ def poisson_nll_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.poisson_nll_loss. This method - simply wraps the function, and so the docstring for ivy. poisson_nll_loss also - applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.poisson_nll_loss. This + method simply wraps the function, and so the docstring for ivy. + poisson_nll_loss also applies to this method with minimal changes. Parameters ---------- @@ -1116,10 +1102,10 @@ def _static_hinge_embedding_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container static method variant of ivy.hinge_embedding_loss. This method - simplywraps the function, and so the docstring for ivy.hinge_embedding_loss also - applies to this method with minimal changes. + r"""ivy.Container static method variant of ivy.hinge_embedding_loss. + This method simplywraps the function, and so the docstring for + ivy.hinge_embedding_loss also applies to this method with minimal + changes. Parameters ---------- @@ -1215,10 +1201,10 @@ def hinge_embedding_loss( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.hinge_embedding_loss. This method - simply wraps the function, and so the docstring for ivy.hinge_embedding_loss - also applies to this method with minimal changes. + r"""ivy.Container instance method variant of ivy.hinge_embedding_loss. + This method simply wraps the function, and so the docstring for + ivy.hinge_embedding_loss also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/manipulation.py b/ivy/data_classes/container/experimental/manipulation.py index 0621ae4be3267..20e72671746e1 100644 --- a/ivy/data_classes/container/experimental/manipulation.py +++ b/ivy/data_classes/container/experimental/manipulation.py @@ -33,10 +33,9 @@ def static_moveaxis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.moveaxis. This method simply wraps - the function, and so the docstring for ivy.moveaxis also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.moveaxis. This method + simply wraps the function, and so the docstring for ivy.moveaxis also + applies to this method with minimal changes. Parameters ---------- @@ -94,10 +93,9 @@ def moveaxis( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.moveaxis. This method simply wraps - the function, and so the docstring for ivy.flatten also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.moveaxis. This method + simply wraps the function, and so the docstring for ivy.flatten also + applies to this method with minimal changes. Parameters ---------- @@ -147,10 +145,9 @@ def static_heaviside( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.heaviside. This method simply wraps - the function, and so the docstring for ivy.heaviside also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.heaviside. This method + simply wraps the function, and so the docstring for ivy.heaviside also + applies to this method with minimal changes. Parameters ---------- @@ -195,10 +192,9 @@ def heaviside( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.heaviside. This method simply wraps - the function, and so the docstring for ivy.heaviside also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.heaviside. This method + simply wraps the function, and so the docstring for ivy.heaviside also + applies to this method with minimal changes. Parameters ---------- @@ -239,10 +235,9 @@ def static_flipud( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.flipud. This method simply wraps the - function, and so the docstring for ivy.flipud also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.flipud. This method + simply wraps the function, and so the docstring for ivy.flipud also + applies to this method with minimal changes. Parameters ---------- @@ -297,10 +292,9 @@ def flipud( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.flipud. This method simply wraps - the function, and so the docstring for ivy.flipud also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.flipud. This method + simply wraps the function, and so the docstring for ivy.flipud also + applies to this method with minimal changes. Parameters ---------- @@ -353,10 +347,9 @@ def vstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method + simply wraps the function, and so the docstring for ivy.stack also + applies to this method with minimal changes. Examples -------- @@ -397,10 +390,9 @@ def static_vstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.vstack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.vstack also applies to + this method with minimal changes. Examples -------- @@ -442,10 +434,9 @@ def hstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.hstack. This method simply wraps - the function, and so the docstring for ivy.hstack also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.hstack. This method + simply wraps the function, and so the docstring for ivy.hstack also + applies to this method with minimal changes. Examples -------- @@ -484,10 +475,9 @@ def static_hstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.hstack. This method simply wraps the - function, and so the docstring for ivy.hstack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.hstack. This method + simply wraps the function, and so the docstring for ivy.hstack also + applies to this method with minimal changes. Examples -------- @@ -522,10 +512,9 @@ def static_rot90( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rot90. This method simply wraps the - function, and so the docstring for ivy.rot90 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.rot90. This method simply + wraps the function, and so the docstring for ivy.rot90 also applies to + this method with minimal changes. Parameters ---------- @@ -597,10 +586,9 @@ def rot90( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.rot90. This method simply wraps the - function, and so the docstring for ivy.rot90 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.rot90. This method simply + wraps the function, and so the docstring for ivy.rot90 also applies to + this method with minimal changes. Parameters ---------- @@ -672,10 +660,9 @@ def static_top_k( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[Tuple[ivy.Container, ivy.Container], ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.top_k. This method simply wraps the - function, and so the docstring for ivy.top_k also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.top_k. This method simply + wraps the function, and so the docstring for ivy.top_k also applies to + this method with minimal changes. Parameters ---------- @@ -755,10 +742,9 @@ def top_k( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.top_k. This method simply wraps the - function, and so the docstring for ivy.top_k also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.top_k. This method + simply wraps the function, and so the docstring for ivy.top_k also + applies to this method with minimal changes. Parameters ---------- @@ -832,10 +818,9 @@ def static_fliplr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fliplr. This method simply wraps the - function, and so the docstring for ivy.fliplr also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.fliplr. This method + simply wraps the function, and so the docstring for ivy.fliplr also + applies to this method with minimal changes. Parameters ---------- @@ -900,10 +885,9 @@ def fliplr( copy: Optional[Union[bool, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fliplr. This method simply wraps - the function, and so the docstring for ivy.fliplr also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.fliplr. This method + simply wraps the function, and so the docstring for ivy.fliplr also + applies to this method with minimal changes. Parameters ---------- @@ -953,10 +937,9 @@ def static_i0( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.i0. This method simply wraps the - function, and so the docstring for ivy.i0 also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.i0. This method simply + wraps the function, and so the docstring for ivy.i0 also applies to + this method with minimal changes. Parameters ---------- @@ -998,10 +981,9 @@ def i0( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.i0. This method simply wraps the - function, and so the docstring for ivy.i0 also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.i0. This method simply + wraps the function, and so the docstring for ivy.i0 also applies to + this method with minimal changes. Parameters ---------- @@ -1044,10 +1026,9 @@ def static_flatten( order: Union[str, ivy.Container] = "C", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.flatten. This method simply wraps the - function, and so the docstring for ivy.flatten also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.flatten. This method + simply wraps the function, and so the docstring for ivy.flatten also + applies to this method with minimal changes. Parameters ---------- @@ -1124,10 +1105,9 @@ def flatten( order: Union[str, ivy.Container] = "C", out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.flatten. This method simply wraps - the function, and so the docstring for ivy.flatten also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.flatten. This method + simply wraps the function, and so the docstring for ivy.flatten also + applies to this method with minimal changes. Parameters ---------- @@ -1220,8 +1200,7 @@ def static_pad( out: Optional[ivy.Container] = None, **kwargs: Optional[Union[Any, ivy.Container]], ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.pad. + """ivy.Container static method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -1277,8 +1256,7 @@ def pad( out: Optional[ivy.Container] = None, **kwargs: Optional[Union[Any, ivy.Container]], ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.pad. + """ivy.Container instance method variant of ivy.pad. This method simply wraps the function, and so the docstring for ivy.pad also applies to this method with minimal changes. @@ -1313,10 +1291,9 @@ def static_vsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.vsplit. This method simply wraps the - function, and so the docstring for ivy.vsplit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.vsplit. This method + simply wraps the function, and so the docstring for ivy.vsplit also + applies to this method with minimal changes. Parameters ---------- @@ -1399,10 +1376,9 @@ def vsplit( *, copy: Optional[Union[bool, ivy.Container]] = None, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.vsplit. This method simply wraps - the function, and so the docstring for ivy.vsplit also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.vsplit. This method + simply wraps the function, and so the docstring for ivy.vsplit also + applies to this method with minimal changes. Parameters ---------- @@ -1471,10 +1447,9 @@ def static_dsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.dsplit. This method simply wraps the - function, and so the docstring for ivy.dsplit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.dsplit. This method + simply wraps the function, and so the docstring for ivy.dsplit also + applies to this method with minimal changes. Parameters ---------- @@ -1555,10 +1530,9 @@ def dsplit( *, copy: Optional[Union[bool, ivy.Container]] = None, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.dsplit. This method simply wraps - the function, and so the docstring for ivy.dsplit also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dsplit. This method + simply wraps the function, and so the docstring for ivy.dsplit also + applies to this method with minimal changes. Parameters ---------- @@ -1620,10 +1594,9 @@ def static_atleast_1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.atleast_1d. This method simply wraps - the function, and so the docstring for ivy.atleast_1d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.atleast_1d. This method + simply wraps the function, and so the docstring for ivy.atleast_1d also + applies to this method with minimal changes. Parameters ---------- @@ -1684,10 +1657,9 @@ def atleast_1d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.atleast_1d. This method simply - wraps the function, and so the docstring for ivy.atleast_1d also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.atleast_1d. This method + simply wraps the function, and so the docstring for ivy.atleast_1d also + applies to this method with minimal changes. Parameters ---------- @@ -1761,10 +1733,9 @@ def dstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method + simply wraps the function, and so the docstring for ivy.stack also + applies to this method with minimal changes. Examples -------- @@ -1805,10 +1776,9 @@ def static_dstack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.dstack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.dstack also applies to + this method with minimal changes. Examples -------- @@ -1842,10 +1812,9 @@ def static_atleast_2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.atleast_2d. This method simply wraps - the function, and so the docstring for ivy.atleast_2d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.atleast_2d. This method + simply wraps the function, and so the docstring for ivy.atleast_2d also + applies to this method with minimal changes. Parameters ---------- @@ -1906,10 +1875,9 @@ def atleast_2d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.atleast_2d. This method simply - wraps the function, and so the docstring for ivy.atleast_2d also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.atleast_2d. This method + simply wraps the function, and so the docstring for ivy.atleast_2d also + applies to this method with minimal changes. Parameters ---------- @@ -1978,10 +1946,9 @@ def static_atleast_3d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.atleast_3d. This method simply wraps - the function, and so the docstring for ivy.atleast_3d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.atleast_3d. This method + simply wraps the function, and so the docstring for ivy.atleast_3d also + applies to this method with minimal changes. Parameters ---------- @@ -2046,10 +2013,9 @@ def atleast_3d( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.atleast_3d. This method simply - wraps the function, and so the docstring for ivy.atleast_3d also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.atleast_3d. This method + simply wraps the function, and so the docstring for ivy.atleast_3d also + applies to this method with minimal changes. Parameters ---------- @@ -2118,10 +2084,9 @@ def static_take_along_axis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.take_along_axis. This method simply - wraps the function, and so the docstring for ivy.take_along_axis also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.take_along_axis. This + method simply wraps the function, and so the docstring for + ivy.take_along_axis also applies to this method with minimal changes. Parameters ---------- @@ -2192,10 +2157,9 @@ def take_along_axis( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.take_along_axis. This method simply - wraps the function, and so the docstring for ivy.take_along_axis also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.take_along_axis. This + method simply wraps the function, and so the docstring for + ivy.take_along_axis also applies to this method with minimal changes. Parameters ---------- @@ -2268,10 +2232,9 @@ def static_hsplit( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.hsplit. This method simply wraps the - function, and so the docstring for ivy.hsplit also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.hsplit. This method + simply wraps the function, and so the docstring for ivy.hsplit also + applies to this method with minimal changes. Parameters ---------- @@ -2345,10 +2308,9 @@ def hsplit( copy: Optional[Union[bool, ivy.Container]] = None, /, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.hsplit. This method simply wraps - the function, and so the docstring for ivy.hsplit also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.hsplit. This method + simply wraps the function, and so the docstring for ivy.hsplit also + applies to this method with minimal changes. Parameters ---------- @@ -2405,10 +2367,9 @@ def static_broadcast_shapes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.broadcast_shapes. This method simply - wraps the function, and so the docstring for ivy.hsplit also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.broadcast_shapes. This + method simply wraps the function, and so the docstring for ivy.hsplit + also applies to this method with minimal changes. Parameters ---------- @@ -2462,10 +2423,9 @@ def broadcast_shapes( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.broadcast_shapes. This method - simply wraps the function, and so the docstring for ivy.broadcast_shapes also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.broadcast_shapes. This + method simply wraps the function, and so the docstring for + ivy.broadcast_shapes also applies to this method with minimal changes. Parameters ---------- @@ -2602,10 +2562,9 @@ def static_as_strided( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.as_strided. This method simply - wraps the function, and so the docstring for ivy.as_strided also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.as_strided. This method + simply wraps the function, and so the docstring for ivy.as_strided also + applies to this method with minimal changes. Parameters ---------- @@ -2649,10 +2608,9 @@ def as_strided( strides: Union[Sequence[int], ivy.Container], /, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.as_strided. This method simply - wraps the function, and so the docstring for ivy.as_strided also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.as_strided. This method + simply wraps the function, and so the docstring for ivy.as_strided also + applies to this method with minimal changes. Parameters ---------- @@ -2686,10 +2644,10 @@ def static_concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.concat_from_sequence. This method - simply wraps the function, and so the docstring for ivy.concat_from_sequence - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.concat_from_sequence. + This method simply wraps the function, and so the docstring for + ivy.concat_from_sequence also applies to this method with minimal + changes. Parameters ---------- @@ -2790,10 +2748,9 @@ def concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method + simply wraps the function, and so the docstring for ivy.stack also + applies to this method with minimal changes. Parameters ---------- @@ -2871,10 +2828,9 @@ def associative_scan( reverse: Union[bool, ivy.Container] = False, axis: Union[int, ivy.Container] = 0, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.associative_scan. This method - simply wraps the function, and so the docstring for ivy.associative_scan also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.associative_scan. This + method simply wraps the function, and so the docstring for + ivy.associative_scan also applies to this method with minimal changes. Parameters ---------- @@ -2905,8 +2861,7 @@ def _static_unique_consecutive( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unique_consecutive. + """ivy.Container static method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -2932,8 +2887,7 @@ def unique_consecutive( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_consecutive. + """ivy.Container instance method variant of ivy.unique_consecutive. This method simply wraps the function, and so the docstring for ivy.unique_consecutive also applies to this method with minimal @@ -2956,8 +2910,7 @@ def _static_fill_diagonal( *, wrap: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fill_diagonal. + """ivy.Container static method variant of ivy.fill_diagonal. This method simply wraps the function, and so the docstring for ivy.fill_diagonal also applies to this method with minimal @@ -2977,8 +2930,7 @@ def fill_diagonal( *, wrap: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fill_diagonal. + """ivy.Container instance method variant of ivy.fill_diagonal. This method simply wraps the function, and so the docstring for ivy.fill_diagonal also applies to this method with minimal @@ -3002,8 +2954,7 @@ def static_unfold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unfold. + """ivy.Container static method variant of ivy.unfold. This method simply wraps the function, and so the docstring for ivy.unfold also applies to this method with minimal @@ -3042,8 +2993,7 @@ def unfold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unfold. + """ivy.Container instance method variant of ivy.unfold. This method simply wraps the function, and so the docstring for ivy.unfold also applies to this method with minimal @@ -3079,8 +3029,7 @@ def static_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fold. + """ivy.Container static method variant of ivy.fold. This method simply wraps the function, and so the docstring for ivy.fold also applies to this method with minimal @@ -3121,8 +3070,7 @@ def fold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fold. + """ivy.Container instance method variant of ivy.fold. This method simply wraps the function, and so the docstring for ivy.fold also applies to this method with minimal @@ -3161,8 +3109,7 @@ def static_partial_unfold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.partial_unfold. + """ivy.Container static method variant of ivy.partial_unfold. This method simply wraps the function, and so the docstring for ivy.partial_unfold also applies to this method with minimal @@ -3213,8 +3160,7 @@ def partial_unfold( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.partial_unfold. + """ivy.Container instance method variant of ivy.partial_unfold. This method simply wraps the function, and so the docstring for ivy.partial_unfold also applies to this method with minimal @@ -3259,8 +3205,7 @@ def static_partial_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.partial_fold. + """ivy.Container static method variant of ivy.partial_fold. This method simply wraps the function, and so the docstring for ivy.partial_fold also applies to this method with minimal @@ -3311,8 +3256,7 @@ def partial_fold( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.partial_fold. + """ivy.Container instance method variant of ivy.partial_fold. This method simply wraps the function, and so the docstring for ivy.partial_fold also applies to this method with minimal @@ -3352,8 +3296,7 @@ def static_partial_tensor_to_vec( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.partial_tensor_to_vec. + """ivy.Container static method variant of ivy.partial_tensor_to_vec. This method simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec also applies to this method with minimal @@ -3401,8 +3344,7 @@ def partial_tensor_to_vec( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.partial_tensor_to_vec. + """ivy.Container instance method variant of ivy.partial_tensor_to_vec. This method simply wraps the function, and so the docstring for ivy.partial_tensor_to_vec also applies to this method with minimal @@ -3440,8 +3382,7 @@ def static_partial_vec_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.partial_vec_to_tensor. + """ivy.Container static method variant of ivy.partial_vec_to_tensor. This method simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor also applies to this method with minimal @@ -3487,8 +3428,7 @@ def partial_vec_to_tensor( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.partial_vec_to_tensor. + """ivy.Container instance method variant of ivy.partial_vec_to_tensor. This method simply wraps the function, and so the docstring for ivy.partial_vec_to_tensor also applies to this method with minimal @@ -3526,8 +3466,7 @@ def static_matricize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.matricize. + """ivy.Container static method variant of ivy.matricize. This method simply wraps the function, and so the docstring for ivy.matricize also applies to this method with minimal @@ -3573,8 +3512,7 @@ def matricize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.matricize. + """ivy.Container instance method variant of ivy.matricize. This method simply wraps the function, and so the docstring for ivy.matricize also applies to this method with minimal @@ -3609,8 +3547,7 @@ def static_soft_thresholding( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.soft_thresholding. + """ivy.Container static method variant of ivy.soft_thresholding. This method simply wraps the function, and so the docstring for ivy.soft_thresholding also applies to this method with minimal @@ -3654,8 +3591,7 @@ def soft_thresholding( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.soft_thresholding. + """ivy.Container instance method variant of ivy.soft_thresholding. This method simply wraps the function, and so the docstring for ivy.soft_thresholding also applies to this method with minimal @@ -3690,8 +3626,7 @@ def static_column_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.column_stack. + """ivy.Container static method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -3742,8 +3677,7 @@ def column_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.column_stack. + """ivy.Container instance method variant of ivy.column_stack. This method simply wraps the function, and so the docstring for ivy.column_stack also applies to this method with minimal @@ -3803,8 +3737,7 @@ def _static_put_along_axis( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.put_along_axis. + """ivy.Container static method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal @@ -3840,8 +3773,7 @@ def put_along_axis( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.put_along_axis. + """ivy.Container instance method variant of ivy.put_along_axis. This method simply wraps the function, and so the docstring for ivy.put_along_axis also applies to this method with minimal @@ -3875,8 +3807,7 @@ def _static_take( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.take. + """ivy.Container static method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -3976,8 +3907,7 @@ def take( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.take. + """ivy.Container instance method variant of ivy.take. This method simply wraps the function, and so the docstring for ivy.take also applies to this method with minimal changes. @@ -4069,10 +3999,9 @@ def _static_trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trim_zeros. This method simply wraps - the function, and so the docstring for ivy.trim_zeros also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.trim_zeros. This method + simply wraps the function, and so the docstring for ivy.trim_zeros also + applies to this method with minimal changes. Parameters ---------- @@ -4106,10 +4035,9 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ - ivy.Container instance method variant of ivy.trim_zeros. This method simply - wraps the function, and so the docstring for ivy.trim_zeros also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.trim_zeros. This method + simply wraps the function, and so the docstring for ivy.trim_zeros also + applies to this method with minimal changes. Parameters ---------- @@ -4154,10 +4082,9 @@ def concat_from_sequence( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.stack also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/norms.py b/ivy/data_classes/container/experimental/norms.py index aab171d3242df..72d8e3d7485da 100644 --- a/ivy/data_classes/container/experimental/norms.py +++ b/ivy/data_classes/container/experimental/norms.py @@ -14,10 +14,9 @@ def static_l1_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.l1_normalize. This method simply - wraps the function, and so the docstring for ivy.l1_normalize also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.l1_normalize. This method + simply wraps the function, and so the docstring for ivy.l1_normalize + also applies to this method with minimal changes. Parameters ---------- @@ -78,10 +77,9 @@ def l1_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.l1_normalize. This method simply - wraps the function, and so the docstring for ivy.l1_normalize also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.l1_normalize. This + method simply wraps the function, and so the docstring for + ivy.l1_normalize also applies to this method with minimal changes. Parameters ---------- @@ -129,10 +127,9 @@ def static_l2_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.l2_normalize. This method simply - wraps the function, and so the docstring for ivy.l2_normalize also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.l2_normalize. This method + simply wraps the function, and so the docstring for ivy.l2_normalize + also applies to this method with minimal changes. Parameters ---------- @@ -193,10 +190,9 @@ def l2_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.l2_normalize. This method simply - wraps the function, and so the docstring for ivy.l2_normalize also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.l2_normalize. This + method simply wraps the function, and so the docstring for + ivy.l2_normalize also applies to this method with minimal changes. Parameters ---------- @@ -272,10 +268,9 @@ def static_batch_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.batch_norm. This method simply wraps - the function, and so the docstring for ivy.batch_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.batch_norm. This method + simply wraps the function, and so the docstring for ivy.batch_norm also + applies to this method with minimal changes. Parameters ---------- @@ -369,10 +364,9 @@ def batch_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.batch_norm. This method simply - wraps the function, and so the docstring for ivy.batch_norm also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.batch_norm. This method + simply wraps the function, and so the docstring for ivy.batch_norm also + applies to this method with minimal changes. Parameters ---------- @@ -466,10 +460,9 @@ def static_instance_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.instance_norm. This method simply - wraps the function, and so the docstring for ivy.instance_norm also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.instance_norm. This + method simply wraps the function, and so the docstring for + ivy.instance_norm also applies to this method with minimal changes. Parameters ---------- @@ -561,10 +554,9 @@ def instance_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.instance_norm. This method simply - wraps the function, and so the docstring for ivy.instance_norm also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.instance_norm. This + method simply wraps the function, and so the docstring for + ivy.instance_norm also applies to this method with minimal changes. Parameters ---------- @@ -647,10 +639,9 @@ def static_group_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.group_norm. This method simply wraps - the function, and so the docstring for ivy.group_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.group_norm. This method + simply wraps the function, and so the docstring for ivy.group_norm also + applies to this method with minimal changes. Parameters ---------- @@ -710,10 +701,9 @@ def group_norm( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.group_norm. This method simply wraps - the function, and so the docstring for ivy.group_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.group_norm. This method + simply wraps the function, and so the docstring for ivy.group_norm also + applies to this method with minimal changes. Parameters ---------- @@ -768,10 +758,9 @@ def static_lp_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.lp_normalize. This method simply - wraps the function, and so the docstring for ivy.lp_normalize also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.lp_normalize. This method + simply wraps the function, and so the docstring for ivy.lp_normalize + also applies to this method with minimal changes. Parameters ---------- @@ -836,10 +825,9 @@ def lp_normalize( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.l2_normalize. This method simply - wraps the function, and so the docstring for ivy.l2_normalize also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.l2_normalize. This + method simply wraps the function, and so the docstring for + ivy.l2_normalize also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/random.py b/ivy/data_classes/container/experimental/random.py index 7544f92d3fafa..9a991587eba55 100644 --- a/ivy/data_classes/container/experimental/random.py +++ b/ivy/data_classes/container/experimental/random.py @@ -22,10 +22,9 @@ def static_dirichlet( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dirichlet. This method simply wraps - the function, and so the docstring for ivy.dirichlet also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.dirichlet. This method + simply wraps the function, and so the docstring for ivy.dirichlet also + applies to this method with minimal changes. Parameters ---------- @@ -89,10 +88,9 @@ def dirichlet( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dirichlet. This method simply wraps - the function, and so the docstring for ivy.shuffle also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dirichlet. This method + simply wraps the function, and so the docstring for ivy.shuffle also + applies to this method with minimal changes. Parameters ---------- @@ -158,10 +156,9 @@ def static_beta( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.beta. This method simply wraps the - function, and so the docstring for ivy.beta also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.beta. This method simply + wraps the function, and so the docstring for ivy.beta also applies to + this method with minimal changes. Parameters ---------- @@ -229,10 +226,9 @@ def beta( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.beta. This method simply wraps the - function, and so the docstring for ivy.beta also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.beta. This method + simply wraps the function, and so the docstring for ivy.beta also + applies to this method with minimal changes. Parameters ---------- @@ -299,10 +295,9 @@ def static_poisson( fill_value: Optional[Union[float, int, ivy.Container]] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.poisson. This method simply wraps the - function, and so the docstring for ivy.poisson also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.poisson. This method + simply wraps the function, and so the docstring for ivy.poisson also + applies to this method with minimal changes. Parameters ---------- @@ -369,10 +364,9 @@ def poisson( fill_value: Optional[Union[float, int, ivy.Container]] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.poisson. This method simply wraps - the function, and so the docstring for ivy.poisson also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.poisson. This method + simply wraps the function, and so the docstring for ivy.poisson also + applies to this method with minimal changes. Parameters ---------- @@ -575,10 +569,9 @@ def static_gamma( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.gamma. This method simply wraps the - function, and so the docstring for ivy.gamma also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.gamma. This method simply + wraps the function, and so the docstring for ivy.gamma also applies to + this method with minimal changes. Parameters ---------- @@ -646,10 +639,9 @@ def gamma( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ): - """ - ivy.Container method variant of ivy.gamma. This method simply wraps the - function, and so the docstring for ivy.gamma also applies to this method with - minimal changes. + """ivy.Container method variant of ivy.gamma. This method simply wraps + the function, and so the docstring for ivy.gamma also applies to this + method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/searching.py b/ivy/data_classes/container/experimental/searching.py index d261dd6637716..0886c307e45e0 100644 --- a/ivy/data_classes/container/experimental/searching.py +++ b/ivy/data_classes/container/experimental/searching.py @@ -19,10 +19,9 @@ def static_unravel_index( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unravel_index. This method simply - wraps the function, and so the docstring for ivy.unravel_index also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.unravel_index. This + method simply wraps the function, and so the docstring for + ivy.unravel_index also applies to this method with minimal changes. Parameters ---------- @@ -67,10 +66,9 @@ def unravel_index( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unravel_index. This method simply - wraps the function, and so the docstring for ivy.unravel_index also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.unravel_index. This + method simply wraps the function, and so the docstring for + ivy.unravel_index also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/sorting.py b/ivy/data_classes/container/experimental/sorting.py index a79109ea555e3..dc7c74258edb8 100644 --- a/ivy/data_classes/container/experimental/sorting.py +++ b/ivy/data_classes/container/experimental/sorting.py @@ -17,8 +17,7 @@ def static_invert_permutation( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.invert_permutation. + """ivy.Container static method variant of ivy.invert_permutation. This method simply wraps the function, and so the docstring for ivy.invert_permutation also applies to this method with minimal @@ -42,8 +41,7 @@ def invert_permutation( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.invert_permutation. + """ivy.Container instance method variant of ivy.invert_permutation. This method simply wraps the function, and so the docstring for ivy.invert_permutation also applies to this method with minimal @@ -69,10 +67,9 @@ def static_lexsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.lexsort. This method simply wraps the - function, and so the docstring for ivy.lexsort also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.lexsort. This method + simply wraps the function, and so the docstring for ivy.lexsort also + applies to this method with minimal changes. Parameters ---------- @@ -123,10 +120,9 @@ def lexsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.lexsort. This method simply wraps - the function, and so the docstring for ivy.lexsort also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.lexsort. This method + simply wraps the function, and so the docstring for ivy.lexsort also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/statistical.py b/ivy/data_classes/container/experimental/statistical.py index d7fa55b44c924..09c0e616384b1 100644 --- a/ivy/data_classes/container/experimental/statistical.py +++ b/ivy/data_classes/container/experimental/statistical.py @@ -28,10 +28,9 @@ def static_histogram( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.. This method simply wraps - the function, and so the docstring for ivy.histogram also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.. This method + simply wraps the function, and so the docstring for ivy.histogram also + applies to this method with minimal changes. Parameters ---------- @@ -135,10 +134,9 @@ def histogram( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.. This method simply - wraps the function, and so the docstring for ivy.histogram also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.. This + method simply wraps the function, and so the docstring for + ivy.histogram also applies to this method with minimal changes. Parameters ---------- @@ -235,10 +233,9 @@ def static_median( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.median. This method simply wraps the - function, and so the docstring for ivy.median also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.median. This method + simply wraps the function, and so the docstring for ivy.median also + applies to this method with minimal changes. Parameters ---------- @@ -288,10 +285,9 @@ def median( keepdims: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.median. This method simply wraps - the function, and so the docstring for ivy.median also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.median. This method + simply wraps the function, and so the docstring for ivy.median also + applies to this method with minimal changes. Parameters ---------- @@ -340,10 +336,9 @@ def static_nanmean( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nanmean. This method simply wraps the - function, and so the docstring for ivy.nanmean also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nanmean. This method + simply wraps the function, and so the docstring for ivy.nanmean also + applies to this method with minimal changes. Parameters ---------- @@ -401,10 +396,9 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nanmean. This method simply wraps - the function, and so the docstring for ivy.nanmean also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nanmean. This method + simply wraps the function, and so the docstring for ivy.nanmean also + applies to this method with minimal changes. Parameters ---------- @@ -459,10 +453,9 @@ def _static_nanmin( where: Optional[Union[ivy.Array, ivy.Container]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nanmin. This method simply wraps the - function, and so the docstring for ivy.nanmin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nanmin. This method + simply wraps the function, and so the docstring for ivy.nanmin also + applies to this method with minimal changes. Parameters ---------- @@ -521,10 +514,9 @@ def nanmin( initial: Optional[Union[int, float, complex, ivy.Container]] = None, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nanmin. This method simply wraps - the function, and so the docstring for ivy.nanmin also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nanmin. This method + simply wraps the function, and so the docstring for ivy.nanmin also + applies to this method with minimal changes. Parameters ---------- @@ -584,10 +576,9 @@ def static_nanprod( initial: Optional[Union[int, float, complex, ivy.Container]] = 1, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nanprod. This method simply wraps the - function, and so the docstring for ivy.nanprod also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nanprod. This method + simply wraps the function, and so the docstring for ivy.nanprod also + applies to this method with minimal changes. Parameters ---------- @@ -651,10 +642,9 @@ def nanprod( initial: Optional[Union[int, float, complex, ivy.Container]] = None, where: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nanprod. This method simply wraps - the function, and so the docstring for ivy.nanprod also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nanprod. This method + simply wraps the function, and so the docstring for ivy.nanprod also + applies to this method with minimal changes. Parameters ---------- @@ -717,10 +707,9 @@ def static_quantile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.quantile. This method simply wraps - the function, and so the docstring for ivy.quantile also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.quantile. This method + simply wraps the function, and so the docstring for ivy.quantile also + applies to this method with minimal changes. Parameters ---------- @@ -842,10 +831,9 @@ def quantile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.quantile. This method simply wraps - the function, and so the docstring for ivy.quantile also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.quantile. This method + simply wraps the function, and so the docstring for ivy.quantile also + applies to this method with minimal changes. Parameters ---------- @@ -966,10 +954,9 @@ def static_corrcoef( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.corrcoef. This method simply wraps - the function, and so the docstring for ivy.corrcoef also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.corrcoef. This method + simply wraps the function, and so the docstring for ivy.corrcoef also + applies to this method with minimal changes. Parameters ---------- @@ -1019,10 +1006,9 @@ def corrcoef( rowvar: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.corrcoef. This method simply wraps - the function, and so the docstring for ivy.corrcoef also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.corrcoef. This method + simply wraps the function, and so the docstring for ivy.corrcoef also + applies to this method with minimal changes. Parameters ---------- @@ -1068,10 +1054,9 @@ def static_nanmedian( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.median. This method simply wraps the - function, and so the docstring for ivy.median also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.median. This method + simply wraps the function, and so the docstring for ivy.median also + applies to this method with minimal changes. Parameters ---------- @@ -1124,10 +1109,9 @@ def nanmedian( overwrite_input: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nanmedian. This method simply wraps - the function, and so the docstring for ivy.nanmedian also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nanmedian. This method + simply wraps the function, and so the docstring for ivy.nanmedian also + applies to this method with minimal changes. Parameters ---------- @@ -1193,10 +1177,9 @@ def static_bincount( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.bincount. This method simply wraps - the function, and so the docstring for ivy.bincount also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.bincount. This method + simply wraps the function, and so the docstring for ivy.bincount also + applies to this method with minimal changes. Parameters ---------- @@ -1243,10 +1226,9 @@ def bincount( minlength: Union[int, ivy.Container] = 0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Array instance method variant of ivy.bincount. This method simply wraps the - function, and so the docstring for ivy.bincount also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.bincount. This method + simply wraps the function, and so the docstring for ivy.bincount also + applies to this method with minimal changes. Parameters ---------- @@ -1284,10 +1266,9 @@ def static_igamma( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.igamma. This method simply wraps the - function, and so the docstring for ivy.igamma also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.igamma. This method + simply wraps the function, and so the docstring for ivy.igamma also + applies to this method with minimal changes. Parameters ---------- @@ -1329,10 +1310,9 @@ def igamma( x: Union[ivy.Container, ivy.Array, ivy.NativeArray], out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.igamma. This method simply wraps - the function, and so the docstring for ivy.igamma also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.igamma. This method + simply wraps the function, and so the docstring for ivy.igamma also + applies to this method with minimal changes. Parameters ---------- @@ -1375,10 +1355,9 @@ def static_cov( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cov. This method simply wraps the - function, and so the docstring for ivy.cov also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cov. This method simply + wraps the function, and so the docstring for ivy.cov also applies to + this method with minimal changes. Parameters ---------- @@ -1492,10 +1471,9 @@ def cov( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cov. This method simply wraps the - function, and so the docstring for ivy.cov also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cov. This method simply + wraps the function, and so the docstring for ivy.cov also applies to + this method with minimal changes. Parameters ---------- @@ -1594,10 +1572,9 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cummax. This method simply wraps - the function, and so the docstring for ivy.cummax also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cummax. This method + simply wraps the function, and so the docstring for ivy.cummax also + applies to this method with minimal changes. Parameters ---------- @@ -1684,10 +1661,9 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cummin. This method simply wraps - the function, and so the docstring for ivy.cummin also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cummin. This method + simply wraps the function, and so the docstring for ivy.cummin also + applies to this method with minimal changes. Parameters ---------- @@ -1772,10 +1748,9 @@ def _static_cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cummax. This method simply wraps the - function, and so the docstring for ivy.cummax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cummax. This method + simply wraps the function, and so the docstring for ivy.cummax also + applies to this method with minimal changes. Parameters ---------- @@ -1862,10 +1837,9 @@ def _static_cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cummin. This method simply wraps the - function, and so the docstring for ivy.cummin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cummin. This method + simply wraps the function, and so the docstring for ivy.cummin also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/experimental/utility.py b/ivy/data_classes/container/experimental/utility.py index 876a9fad339e5..4218b878b282c 100644 --- a/ivy/data_classes/container/experimental/utility.py +++ b/ivy/data_classes/container/experimental/utility.py @@ -18,10 +18,10 @@ def static_optional_get_element( map_sequences: bool = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.optional_get_element. This method - simply wraps the function, and so the docstring for ivy.optional_get_element - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.optional_get_element. + This method simply wraps the function, and so the docstring for + ivy.optional_get_element also applies to this method with minimal + changes. Parameters ---------- @@ -62,10 +62,10 @@ def optional_get_element( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.optional_get_element. This method - simply wraps the function, and so the docstring for ivy.optional_get_element - also applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.optional_get_element. + This method simply wraps the function, and so the docstring for + ivy.optional_get_element also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/container/general.py b/ivy/data_classes/container/general.py index dd6d633b5f8ea..e372a016796d4 100644 --- a/ivy/data_classes/container/general.py +++ b/ivy/data_classes/container/general.py @@ -22,10 +22,9 @@ def _static_is_native_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.is_native_array. This method simply - wraps the function, and so the docstring for ivy.is_native_array also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.is_native_array. This + method simply wraps the function, and so the docstring for + ivy.is_native_array also applies to this method with minimal changes. Parameters ---------- @@ -81,10 +80,10 @@ def is_native_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.is_native_array. This method simply - wraps the function, and so the docstring for ivy.ivy.is_native_array also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.is_native_array. This + method simply wraps the function, and so the docstring for + ivy.ivy.is_native_array also applies to this method with minimal + changes. Parameters ---------- @@ -140,10 +139,9 @@ def _static_is_ivy_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.is_ivy_array. This method simply - wraps the function, and so the docstring for ivy.is_ivy_array also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.is_ivy_array. This method + simply wraps the function, and so the docstring for ivy.is_ivy_array + also applies to this method with minimal changes. Parameters ---------- @@ -197,10 +195,10 @@ def is_ivy_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.is_native_array. This method simply - wraps the function, and so the docstring for ivy.ivy.is_native_array also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.is_native_array. This + method simply wraps the function, and so the docstring for + ivy.ivy.is_native_array also applies to this method with minimal + changes. Parameters ---------- @@ -254,10 +252,9 @@ def _static_is_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.is_array. This method simply wraps - the function, and so the docstring for ivy.ivy.is_array also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.is_array. This method + simply wraps the function, and so the docstring for ivy.ivy.is_array + also applies to this method with minimal changes. Parameters ---------- @@ -316,10 +313,9 @@ def is_array( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.is_array. This method simply wraps - the function, and so the docstring for ivy.is_array also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.is_array. This method + simply wraps the function, and so the docstring for ivy.is_array also + applies to this method with minimal changes. Parameters ---------- @@ -377,10 +373,9 @@ def _static_clip_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.clip_vector_norm. This method - simply wraps the function, and so the docstring for ivy.clip_vector_norm also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.clip_vector_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_vector_norm also applies to this method with minimal changes. Parameters ---------- @@ -449,10 +444,9 @@ def clip_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.clip_vector_norm. This method - simply wraps the function, and so the docstring for ivy.clip_vector_norm also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.clip_vector_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_vector_norm also applies to this method with minimal changes. Parameters ---------- @@ -523,10 +517,9 @@ def _static_inplace_update( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inplace_update. This method simply - wraps the function, and so the docstring for ivy.inplace_update also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.inplace_update. This + method simply wraps the function, and so the docstring for + ivy.inplace_update also applies to this method with minimal changes. Parameters ---------- @@ -592,10 +585,9 @@ def inplace_update( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inplace_update. This method simply - wraps the function, and so the docstring for ivy.inplace_update also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.inplace_update. This + method simply wraps the function, and so the docstring for + ivy.inplace_update also applies to this method with minimal changes. Parameters ---------- @@ -666,10 +658,9 @@ def _static_inplace_decrement( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.inplace_decrement. This method simply - wraps the function, and so the docstring for ivy.inplace_decrement also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.inplace_decrement. This + method simply wraps the function, and so the docstring for + ivy.inplace_decrement also applies to this method with minimal changes. Parameters ---------- @@ -746,10 +737,9 @@ def inplace_decrement( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inplace_decrement. This method - simply wraps the function, and so the docstring for ivy.inplace_decrement also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.inplace_decrement. This + method simply wraps the function, and so the docstring for + ivy.inplace_decrement also applies to this method with minimal changes. Parameters ---------- @@ -808,10 +798,9 @@ def _static_inplace_increment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.inplace_increment. This method simply - wraps the function, and so the docstring for ivy.inplace_increment also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.inplace_increment. This + method simply wraps the function, and so the docstring for + ivy.inplace_increment also applies to this method with minimal changes. Parameters ---------- @@ -888,10 +877,9 @@ def inplace_increment( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inplace_increment. This method - wraps the function, and so the docstring for ivy.inplace_increment also applies - to this method with minimal changes. + """ivy.Container instance method variant of ivy.inplace_increment. This + method wraps the function, and so the docstring for + ivy.inplace_increment also applies to this method with minimal changes. Parameters ---------- @@ -949,10 +937,10 @@ def _static_assert_supports_inplace( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.assert_supports_inplace. This method - simply wraps the function, and so the docstring for ivy.assert_supports_inplace - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.assert_supports_inplace. + This method simply wraps the function, and so the docstring for + ivy.assert_supports_inplace also applies to this method with minimal + changes. Parameters ---------- @@ -993,10 +981,10 @@ def assert_supports_inplace( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.assert_supports_inplace. This - method simply wraps the function, and so the docstring for - ivy.assert_supports_inplace also applies to this method with minimal changes. + """ivy.Container instance method variant of + ivy.assert_supports_inplace. This method simply wraps the function, and + so the docstring for ivy.assert_supports_inplace also applies to this + method with minimal changes. Parameters ---------- @@ -1048,10 +1036,9 @@ def _static_all_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.all_equal. This method simply wraps - the function, and so the docstring for ivy.all_equal also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.all_equal. This method + simply wraps the function, and so the docstring for ivy.all_equal also + applies to this method with minimal changes. Parameters ---------- @@ -1126,10 +1113,9 @@ def all_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.all_equal. This method simply wraps - the function, and so the docstring for ivy.all_equal also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.all_equal. This method + simply wraps the function, and so the docstring for ivy.all_equal also + applies to this method with minimal changes. Parameters ---------- @@ -1228,10 +1214,9 @@ def _static_fourier_encode( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.fourier_encode. This method simply - wraps the function, and so the docstring for ivy.fourier_encode also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.fourier_encode. This + method simply wraps the function, and so the docstring for + ivy.fourier_encode also applies to this method with minimal changes. Parameters ---------- @@ -1320,10 +1305,9 @@ def fourier_encode( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.fourier_encode. This method simply - wraps the function, and so the docstring for ivy.fourier_encode also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.fourier_encode. This + method simply wraps the function, and so the docstring for + ivy.fourier_encode also applies to this method with minimal changes. Parameters ---------- @@ -1409,10 +1393,9 @@ def _static_gather( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.gather. This method simply wraps the - function, and so the docstring for ivy.gather also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.gather. This method + simply wraps the function, and so the docstring for ivy.gather also + applies to this method with minimal changes. Parameters ---------- @@ -1499,10 +1482,9 @@ def gather( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gather. This method simply wraps - the function, and so the docstring for ivy.gather also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.gather. This method + simply wraps the function, and so the docstring for ivy.gather also + applies to this method with minimal changes. Parameters ---------- @@ -1686,10 +1668,9 @@ def _static_scatter_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.scatter_nd. This method simply wraps - the function, and so the docstring for ivy.scatter_nd also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.scatter_nd. This method + simply wraps the function, and so the docstring for ivy.scatter_nd also + applies to this method with minimal changes. Parameters ---------- @@ -1782,10 +1763,9 @@ def scatter_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.scatter_nd. This method simply - wraps the function, and so the docstring for ivy.scatter_nd also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.scatter_nd. This method + simply wraps the function, and so the docstring for ivy.scatter_nd also + applies to this method with minimal changes. Parameters ---------- @@ -1877,10 +1857,9 @@ def _static_scatter_flat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.scatter_flat. This method simply - wraps the function, and so the docstring for ivy.scatter_flat also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.scatter_flat. This method + simply wraps the function, and so the docstring for ivy.scatter_flat + also applies to this method with minimal changes. Parameters ---------- @@ -1940,10 +1919,9 @@ def scatter_flat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.scatter_flat. This method simply - wraps the function, and so the docstring for ivy.scatter_flat also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.scatter_flat. This + method simply wraps the function, and so the docstring for + ivy.scatter_flat also applies to this method with minimal changes. Parameters ---------- @@ -2016,9 +1994,8 @@ def _static_gather_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Gather slices from all container params into a arrays with shape specified by - indices. + """Gather slices from all container params into a arrays with shape + specified by indices. Parameters ---------- @@ -2083,10 +2060,9 @@ def gather_nd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gather_nd. This method simply wraps - the function, and so the docstring for ivy.gather_nd also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.gather_nd. This method + simply wraps the function, and so the docstring for ivy.gather_nd also + applies to this method with minimal changes. Parameters ---------- @@ -2157,8 +2133,7 @@ def _static_einops_reduce( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - Perform einops reduce operation on each sub array in the container. + """Perform einops reduce operation on each sub array in the container. Parameters ---------- @@ -2229,10 +2204,9 @@ def einops_reduce( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.einops_reduce. This method simply - wraps the function, and so the docstring for ivy.einops_reduce also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.einops_reduce. This + method simply wraps the function, and so the docstring for + ivy.einops_reduce also applies to this method with minimal changes. Parameters ---------- @@ -2312,8 +2286,7 @@ def _static_einops_repeat( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - Perform einops repeat operation on each sub array in the container. + """Perform einops repeat operation on each sub array in the container. Parameters ---------- @@ -2382,10 +2355,9 @@ def einops_repeat( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.einops_repeat. This method simply - wraps the function, and so the docstring for ivy.einops_repeat also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.einops_repeat. This + method simply wraps the function, and so the docstring for + ivy.einops_repeat also applies to this method with minimal changes. Parameters ---------- @@ -2450,10 +2422,9 @@ def _static_value_is_nan( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.value_is_nan. This method simply - wraps the function, and so the docstring for ivy.value_is_nan also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.value_is_nan. This method + simply wraps the function, and so the docstring for ivy.value_is_nan + also applies to this method with minimal changes. Parameters ---------- @@ -2531,10 +2502,9 @@ def value_is_nan( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.value_is_nan. This method simply - wraps the function, and so the docstring for ivy.value_is_nan also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.value_is_nan. This + method simply wraps the function, and so the docstring for + ivy.value_is_nan also applies to this method with minimal changes. Parameters ---------- @@ -2606,10 +2576,9 @@ def _static_to_numpy( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_numpy. This method simply wraps - the function, and so the docstring for ivy.to_numpy also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.to_numpy. This method + simply wraps the function, and so the docstring for ivy.to_numpy also + applies to this method with minimal changes. Parameters ---------- @@ -2677,10 +2646,9 @@ def to_numpy( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_numpy. This method simply wraps - the function, and so the docstring for ivy.to_numpy also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_numpy. This method + simply wraps the function, and so the docstring for ivy.to_numpy also + applies to this method with minimal changes. Parameters ---------- @@ -2750,10 +2718,9 @@ def _static_to_scalar( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_scalar. This method simply wraps - the function, and so the docstring for ivy.to_scalar also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.to_scalar. This method + simply wraps the function, and so the docstring for ivy.to_scalar also + applies to this method with minimal changes. Parameters ---------- @@ -2807,10 +2774,9 @@ def to_scalar( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_scalar. This method simply wraps - the function, and so the docstring for ivy.to_scalar also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_scalar. This method + simply wraps the function, and so the docstring for ivy.to_scalar also + applies to this method with minimal changes. Parameters ---------- @@ -2867,10 +2833,9 @@ def _static_to_list( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.to_list. This method simply wraps the - function, and so the docstring for ivy.to_list also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.to_list. This method + simply wraps the function, and so the docstring for ivy.to_list also + applies to this method with minimal changes. Parameters ---------- @@ -2920,10 +2885,9 @@ def to_list( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.to_list. This method simply wraps - the function, and so the docstring for ivy.to_list also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.to_list. This method + simply wraps the function, and so the docstring for ivy.to_list also + applies to this method with minimal changes. Parameters ---------- @@ -2978,10 +2942,9 @@ def _static_stable_divide( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stable_divide. This method simply - wraps the function, and so the docstring for ivy.stable_divide also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.stable_divide. This + method simply wraps the function, and so the docstring for + ivy.stable_divide also applies to this method with minimal changes. Parameters ---------- @@ -3082,10 +3045,9 @@ def stable_divide( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stable_divide. This method simply - wraps the function, and so the docstring for ivy.stable_divide also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.stable_divide. This + method simply wraps the function, and so the docstring for + ivy.stable_divide also applies to this method with minimal changes. Parameters ---------- @@ -3168,10 +3130,9 @@ def _static_stable_pow( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stable_pow. This method simply wraps - the function, and so the docstring for ivy.stable_pow also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.stable_pow. This method + simply wraps the function, and so the docstring for ivy.stable_pow also + applies to this method with minimal changes. Parameters ---------- @@ -3257,10 +3218,9 @@ def stable_pow( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stable_pow. This method simply - wraps the function, and so the docstring for ivy.stable_pow also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.stable_pow. This method + simply wraps the function, and so the docstring for ivy.stable_pow also + applies to this method with minimal changes. Parameters ---------- @@ -3347,10 +3307,9 @@ def _static_einops_rearrange( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.einops_rearrange. This method simply - wraps the function, and so the docstring for ivy.einops_rearrange also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.einops_rearrange. This + method simply wraps the function, and so the docstring for + ivy.einops_rearrange also applies to this method with minimal changes. Parameters ---------- @@ -3435,10 +3394,9 @@ def einops_rearrange( out: Optional[ivy.Container] = None, **axes_lengths: Union[Dict[str, int], ivy.Container], ): - """ - ivy.Container instance method variant of ivy.einops_rearrange. This method - simply wraps the function, and so the docstring for ivy.einops_rearrange also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.einops_rearrange. This + method simply wraps the function, and so the docstring for + ivy.einops_rearrange also applies to this method with minimal changes. Parameters ---------- @@ -3523,10 +3481,9 @@ def _static_clip_matrix_norm( p: Union[float, ivy.Container] = 2.0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.clip_matrix_norm. This method simply - wraps the function, and so the docstring for ivy.clip_matrix_norm also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.clip_matrix_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_matrix_norm also applies to this method with minimal changes. Parameters ---------- @@ -3593,10 +3550,9 @@ def clip_matrix_norm( p: Union[float, ivy.Container] = 2.0, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.clip_matrix_norm. This method - simply wraps the function, and so the docstring for ivy.clip_matrix_norm also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.clip_matrix_norm. This + method simply wraps the function, and so the docstring for + ivy.clip_matrix_norm also applies to this method with minimal changes. Parameters ---------- @@ -3660,10 +3616,10 @@ def _static_supports_inplace_updates( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.supports_inplace_updates. This method - simply wraps the function, and so the docstring for ivy.supports_inplace_updates - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.supports_inplace_updates. + This method simply wraps the function, and so the docstring for + ivy.supports_inplace_updates also applies to this method with minimal + changes. Parameters ---------- @@ -3707,10 +3663,10 @@ def supports_inplace_updates( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.supports_inplace_updates. This - method simply wraps the static function, and so the docstring for the static - variant also applies to this method with minimal changes. + """ivy.Container instance method variant of + ivy.supports_inplace_updates. This method simply wraps the static + function, and so the docstring for the static variant also applies to + this method with minimal changes. Parameters ---------- @@ -3777,10 +3733,9 @@ def _static_get_num_dims( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.get_num_dims. This method simply - wraps the function, and so the docstring for ivy.get_num_dims also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.get_num_dims. This + method simply wraps the function, and so the docstring for + ivy.get_num_dims also applies to this method with minimal changes. Parameters ---------- @@ -3854,10 +3809,9 @@ def get_num_dims( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.get_num_dims. This method simply - wraps the function, and so the docstring for ivy.get_num_dims also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.get_num_dims. This + method simply wraps the function, and so the docstring for + ivy.get_num_dims also applies to this method with minimal changes. Parameters ---------- @@ -3931,10 +3885,9 @@ def _static_array_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.array_equal. This method simply - wraps the function, and so the docstring for ivy.array_equal also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.array_equal. This + method simply wraps the function, and so the docstring for + ivy.array_equal also applies to this method with minimal changes. Parameters ---------- @@ -3996,10 +3949,9 @@ def array_equal( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.array_equal. This method simply - wraps the function, and so the docstring for ivy.array_equal also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.array_equal. This + method simply wraps the function, and so the docstring for + ivy.array_equal also applies to this method with minimal changes. Parameters ---------- @@ -4070,10 +4022,9 @@ def static_isin( assume_unique: Union[bool, ivy.Container] = False, invert: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Container instance method variant of ivy.isin. This method simply wraps the - function, and so the docstring for ivy.isin also applies to this method with - minimal changes. + """Container instance method variant of ivy.isin. This method simply + wraps the function, and so the docstring for ivy.isin also applies to + this method with minimal changes. Parameters ---------- @@ -4120,10 +4071,9 @@ def isin( assume_unique: Union[bool, ivy.Container] = False, invert: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - Container instance method variant of ivy.isin. This method simply wraps the - function, and so the docstring for ivy.isin also applies to this method with - minimal changes. + """Container instance method variant of ivy.isin. This method simply + wraps the function, and so the docstring for ivy.isin also applies to + this method with minimal changes. Parameters ---------- @@ -4163,10 +4113,9 @@ def static_itemsize( x: ivy.Container, /, ) -> ivy.Container: - """ - Container instance method variant of ivy.itemsize. This method simply wraps the - function, and so the docstring for ivy.itemsize also applies to this method with - minimal changes. + """Container instance method variant of ivy.itemsize. This method + simply wraps the function, and so the docstring for ivy.itemsize also + applies to this method with minimal changes. Parameters ---------- @@ -4191,10 +4140,9 @@ def itemsize( self: ivy.Container, /, ) -> ivy.Container: - """ - Container instance method variant of ivy.itemsize. This method simply wraps the - function, and so the docstring for ivy.itemsize also applies to this method with - minimal changes. + """Container instance method variant of ivy.itemsize. This method + simply wraps the function, and so the docstring for ivy.itemsize also + applies to this method with minimal changes. Parameters ---------- @@ -4213,10 +4161,9 @@ def static_strides( x: ivy.Container, /, ) -> ivy.Container: - """ - Container instance method variant of ivy.strides. This method simply wraps the - function, and so the docstring for ivy.strides also applies to this method with - minimal changes. + """Container instance method variant of ivy.strides. This method simply + wraps the function, and so the docstring for ivy.strides also applies + to this method with minimal changes. Parameters ---------- @@ -4241,10 +4188,9 @@ def strides( self: ivy.Container, /, ) -> ivy.Container: - """ - Container instance method variant of ivy.strides. This method simply wraps the - function, and so the docstring for ivy.strides also applies to this method with - minimal changes. + """Container instance method variant of ivy.strides. This method simply + wraps the function, and so the docstring for ivy.strides also applies + to this method with minimal changes. Parameters ---------- @@ -4268,10 +4214,9 @@ def _static_exists( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.exists. This method simply wraps - the function, and so the docstring for ivy.exists also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.exists. This method + simply wraps the function, and so the docstring for ivy.exists also + applies to this method with minimal changes. Parameters ---------- @@ -4330,10 +4275,9 @@ def exists( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.exists. This method simply wraps - the function, and so the docstring for ivy.exists also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.exists. This method + simply wraps the function, and so the docstring for ivy.exists also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/gradients.py b/ivy/data_classes/container/gradients.py index 94a51f311c380..a1848f648913f 100644 --- a/ivy/data_classes/container/gradients.py +++ b/ivy/data_classes/container/gradients.py @@ -19,10 +19,9 @@ def _static_stop_gradient( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stop_gradient. This method simply - wraps the function, and so the docstring for ivy.stop_gradient also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.stop_gradient. This + method simply wraps the function, and so the docstring for + ivy.stop_gradient also applies to this method with minimal changes. Parameters ---------- @@ -97,10 +96,9 @@ def stop_gradient( preserve_type: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stop_gradient. This method simply - wraps the function, and so the docstring for ivy.stop_gradient also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.stop_gradient. This + method simply wraps the function, and so the docstring for + ivy.stop_gradient also applies to this method with minimal changes. Parameters ---------- @@ -175,10 +173,9 @@ def adam_step( epsilon: Union[float, ivy.Container] = 1e-7, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.adam_step. This method simply wraps - the function, and so the docstring for ivy.adam_step also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.adam_step. This method + simply wraps the function, and so the docstring for ivy.adam_step also + applies to this method with minimal changes. Parameters ---------- @@ -271,9 +268,8 @@ def optimizer_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Update weights ws of some function, given the true or effective derivatives of - some cost c with respect to ws, [dc/dw for w in ws]. + """Update weights ws of some function, given the true or effective + derivatives of some cost c with respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -351,10 +347,10 @@ def gradient_descent_update( stop_gradients: Union[bool, ivy.Container] = True, out: ivy.Container = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.gradient_descent_update. This - method simply wraps the function, and so the docstring for - ivy.gradient_descent_update also applies to this method with minimal changes. + """ivy.Container instance method variant of + ivy.gradient_descent_update. This method simply wraps the function, and + so the docstring for ivy.gradient_descent_update also applies to this + method with minimal changes. Parameters ---------- @@ -435,10 +431,9 @@ def lars_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ): - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive Rate Scaling - (LARS) method. + """Update weights ws of some function, given the derivatives of some + cost c with respect to ws, [dc/dw for w in ws], by applying Layerwise + Adaptive Rate Scaling (LARS) method. Parameters ---------- @@ -516,9 +511,8 @@ def adam_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, using ADAM update. `[reference] + """Update weights ws of some function, given the derivatives of some + cost c with respect to ws, using ADAM update. `[reference] `_ @@ -637,9 +631,9 @@ def lamb_update( stop_gradients: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws], by applying LAMB method. + """Update weights ws of some function, given the derivatives of some + cost c with respect to ws, [dc/dw for w in ws], by applying LAMB + method. Parameters ---------- diff --git a/ivy/data_classes/container/layers.py b/ivy/data_classes/container/layers.py index aad198392b2e7..6d3e681cfbf2d 100644 --- a/ivy/data_classes/container/layers.py +++ b/ivy/data_classes/container/layers.py @@ -26,10 +26,9 @@ def _static_linear( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.linear. This method simply wraps the - function, and so the docstring for ivy.linear also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.linear. This method + simply wraps the function, and so the docstring for ivy.linear also + applies to this method with minimal changes. Parameters ---------- @@ -120,10 +119,9 @@ def linear( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.linear. This method simply wraps - the function, and so the docstring for ivy.linear also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.linear. This method + simply wraps the function, and so the docstring for ivy.linear also + applies to this method with minimal changes. Parameters ---------- @@ -203,10 +201,9 @@ def _static_dropout( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dropout. This method simply wraps the - function, and so the docstring for ivy.dropout also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.dropout. This method + simply wraps the function, and so the docstring for ivy.dropout also + applies to this method with minimal changes. Parameters ---------- @@ -291,10 +288,9 @@ def dropout( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dropout. This method simply wraps - the function, and so the docstring for ivy.dropout also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dropout. This method + simply wraps the function, and so the docstring for ivy.dropout also + applies to this method with minimal changes. Parameters ---------- @@ -376,10 +372,9 @@ def _static_dropout1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dropout1d. This method simply wraps - the function, and so the docstring for ivy.dropout1d also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.dropout1d. This method + simply wraps the function, and so the docstring for ivy.dropout1d also + applies to this method with minimal changes. Parameters ---------- @@ -448,10 +443,9 @@ def dropout1d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dropout1d. This method simply wraps - the function, and so the docstring for ivy.dropout1d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dropout1d. This method + simply wraps the function, and so the docstring for ivy.dropout1d also + applies to this method with minimal changes. Parameters ---------- @@ -520,10 +514,9 @@ def _static_dropout2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dropout2d. This method simply wraps - the function, and so the docstring for ivy.dropout2d also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.dropout2d. This method + simply wraps the function, and so the docstring for ivy.dropout2d also + applies to this method with minimal changes. Parameters ---------- @@ -581,10 +574,9 @@ def dropout2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dropout2d. This method simply wraps - the function, and so the docstring for ivy.dropout2d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dropout2d. This method + simply wraps the function, and so the docstring for ivy.dropout2d also + applies to this method with minimal changes. Parameters ---------- @@ -653,10 +645,9 @@ def _static_dropout3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.dropout3d. This method simply wraps - the function, and so the docstring for ivy.dropout3d also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.dropout3d. This method + simply wraps the function, and so the docstring for ivy.dropout3d also + applies to this method with minimal changes. Parameters ---------- @@ -714,10 +705,9 @@ def dropout3d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.dropout3d. This method simply wraps - the function, and so the docstring for ivy.dropout3d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.dropout3d. This method + simply wraps the function, and so the docstring for ivy.dropout3d also + applies to this method with minimal changes. Parameters ---------- @@ -779,11 +769,10 @@ def _static_scaled_dot_product_attention( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.scaled_dot_product_attention. This - method simply wraps the function, and so the docstring for - ivy.scaled_dot_product_attention also applies to this method with minimal - changes. + """ivy.Container static method variant of + ivy.scaled_dot_product_attention. This method simply wraps the + function, and so the docstring for ivy.scaled_dot_product_attention + also applies to this method with minimal changes. Parameters ---------- @@ -902,11 +891,10 @@ def scaled_dot_product_attention( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.scaled_dot_product_attention. This - method simply wraps the function, and so the docstring for - ivy.scaled_dot_product_attention also applies to this method with minimal - changes. + """ivy.Container instance method variant of + ivy.scaled_dot_product_attention. This method simply wraps the + function, and so the docstring for ivy.scaled_dot_product_attention + also applies to this method with minimal changes. Parameters ---------- @@ -1206,10 +1194,9 @@ def _static_conv1d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv1d. This method simply wraps the - function, and so the docstring for ivy.conv1d also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.conv1d. This method + simply wraps the function, and so the docstring for ivy.conv1d also + applies to this method with minimal changes. Parameters ---------- @@ -1302,10 +1289,9 @@ def conv1d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conv1d. This method simply wraps - the function, and so the docstring for ivy.conv1d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.conv1d. This method + simply wraps the function, and so the docstring for ivy.conv1d also + applies to this method with minimal changes. Parameters ---------- @@ -1398,10 +1384,9 @@ def _static_conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv2d. This method simply wraps the - function, and so the docstring for ivy.conv2d also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.conv2d. This method + simply wraps the function, and so the docstring for ivy.conv2d also + applies to this method with minimal changes. Parameters ---------- @@ -1488,10 +1473,9 @@ def conv2d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of `ivy.conv2d`. This method simply wraps - the function, and so the docstring for `ivy.conv2d` also applies to this method - with minimal changes. + """ivy.Container instance method variant of `ivy.conv2d`. This method + simply wraps the function, and so the docstring for `ivy.conv2d` also + applies to this method with minimal changes. Parameters ---------- @@ -1578,10 +1562,9 @@ def _static_conv1d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv1d_transpose. This method simply - wraps the function, and so the docstring for ivy.conv1d_transpose also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.conv1d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv1d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -1676,10 +1659,9 @@ def conv1d_transpose( bias: Optional[ivy.Container] = None, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container]: - """ - ivy.Container instance method variant of ivy.conv1d_transpose. This method - simply wraps the function, and so the docstring for ivy.conv1d_transpose also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.conv1d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv1d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -1774,10 +1756,9 @@ def _static_conv2d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv2d_transpose. This method simply - wraps the function, and so the docstring for ivy.conv2d also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.conv2d_transpose. This + method simply wraps the function, and so the docstring for ivy.conv2d + also applies to this method with minimal changes. Parameters ---------- @@ -1878,10 +1859,9 @@ def conv2d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conv2d_transpose. This method - simply wraps the function, and so the docstring for ivy.conv2d also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.conv2d_transpose. This + method simply wraps the function, and so the docstring for ivy.conv2d + also applies to this method with minimal changes. Parameters ---------- @@ -1987,10 +1967,9 @@ def _static_depthwise_conv2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.depthwise_conv2d. This method simply - wraps the function, and so the docstring for ivy.depthwise_conv2d also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.depthwise_conv2d. This + method simply wraps the function, and so the docstring for + ivy.depthwise_conv2d also applies to this method with minimal changes. Parameters ---------- @@ -2060,10 +2039,9 @@ def depthwise_conv2d( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.depthwise_conv2d. This method - simply wraps the function, and so the docstring for ivy.depthwise_conv2d also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.depthwise_conv2d. This + method simply wraps the function, and so the docstring for + ivy.depthwise_conv2d also applies to this method with minimal changes. Parameters ---------- @@ -2132,10 +2110,9 @@ def _static_conv3d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv3d. This method simply wraps the - function, and so the docstring for ivy.conv3d also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.conv3d. This method + simply wraps the function, and so the docstring for ivy.conv3d also + applies to this method with minimal changes. Parameters ---------- @@ -2217,10 +2194,9 @@ def conv3d( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conv3d. This method simply wraps - the function, and so the docstring for ivy.conv3d also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.conv3d. This method + simply wraps the function, and so the docstring for ivy.conv3d also + applies to this method with minimal changes. Parameters ---------- @@ -2304,10 +2280,9 @@ def _static_conv3d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.conv3d_transpose. This method simply - wraps the function, and so the docstring for ivy.conv3d_transpose also applies - to this method with minimal changes. + """ivy.Container static method variant of ivy.conv3d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv3d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -2402,10 +2377,9 @@ def conv3d_transpose( bias: Optional[ivy.Container] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.conv3d_transpose. This method - simply wraps the function, and so the docstring for ivy.conv3d_transpose also - applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.conv3d_transpose. This + method simply wraps the function, and so the docstring for + ivy.conv3d_transpose also applies to this method with minimal changes. Parameters ---------- @@ -2527,10 +2501,9 @@ def lstm_update( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.lstm_update. This method simply - wraps the function, and so the docstring for ivy.lstm_update also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.lstm_update. This + method simply wraps the function, and so the docstring for + ivy.lstm_update also applies to this method with minimal changes. Parameters ---------- @@ -2633,10 +2606,9 @@ def reduce_window( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.reduce_window. This method simply - wraps the function, and so the docstring for ivy.reduce_window also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.reduce_window. This + method simply wraps the function, and so the docstring for + ivy.reduce_window also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/linear_algebra.py b/ivy/data_classes/container/linear_algebra.py index 20a30dc92b22e..464b7be1fff7e 100644 --- a/ivy/data_classes/container/linear_algebra.py +++ b/ivy/data_classes/container/linear_algebra.py @@ -30,10 +30,9 @@ def _static_matmul( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.matmul. This method simply wraps the - function, and so the docstring for ivy.matul also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.matmul. This method + simply wraps the function, and so the docstring for ivy.matul also + applies to this method with minimal changes. Parameters ---------- @@ -104,10 +103,9 @@ def matmul( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.matmul. This method simply wraps - the function, and so the docstring for ivy.matmul also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.matmul. This method + simply wraps the function, and so the docstring for ivy.matmul also + applies to this method with minimal changes. Parameters ---------- @@ -174,10 +172,9 @@ def _static_cholesky( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cholesky. This method simply wraps - the function, and so the docstring for ivy.cholesky also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.cholesky. This method + simply wraps the function, and so the docstring for ivy.cholesky also + applies to this method with minimal changes. Parameters ---------- @@ -261,10 +258,9 @@ def cholesky( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cholesky. This method simply wraps - the function, and so the docstring for ivy.cholesky also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cholesky. This method + simply wraps the function, and so the docstring for ivy.cholesky also + applies to this method with minimal changes. Parameters ---------- @@ -336,10 +332,9 @@ def _static_cross( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cross. This method simply wraps the - function, and so the docstring for ivy.cross also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cross. This method simply + wraps the function, and so the docstring for ivy.cross also applies to + this method with minimal changes. Parameters ---------- @@ -422,10 +417,9 @@ def cross( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cross. This method simply wraps the - function, and so the docstring for ivy.cross also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.cross. This method + simply wraps the function, and so the docstring for ivy.cross also + applies to this method with minimal changes. Parameters ---------- @@ -545,10 +539,9 @@ def _static_diagonal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.diagonal. This method simply wraps - the function, and so the docstring for ivy.diagonal also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.diagonal. This method + simply wraps the function, and so the docstring for ivy.diagonal also + applies to this method with minimal changes. Parameters ---------- @@ -631,10 +624,9 @@ def diagonal( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diagonal. This method simply wraps - the function, and so the docstring for ivy.diagonal also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.diagonal. This method + simply wraps the function, and so the docstring for ivy.diagonal also + applies to this method with minimal changes. Parameters ---------- @@ -737,10 +729,9 @@ def diag( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.diag. This method simply wraps the - function, and so the docstring for ivy.diag also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.diag. This method + simply wraps the function, and so the docstring for ivy.diag also + applies to this method with minimal changes. Examples -------- @@ -796,10 +787,9 @@ def eigh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eigh. This method simply wraps the - function, and so the docstring for ivy.eigh also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.eigh. This method + simply wraps the function, and so the docstring for ivy.eigh also + applies to this method with minimal changes. Parameters ---------- @@ -868,10 +858,9 @@ def _static_eigvalsh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.eigvalsh. This method simply wraps - the function, and so the docstring for ivy.eigvalsh also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.eigvalsh. This method + simply wraps the function, and so the docstring for ivy.eigvalsh also + applies to this method with minimal changes. Parameters ---------- @@ -938,10 +927,9 @@ def eigvalsh( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.eigvalsh. This method simply wraps - the function, and so the docstring for ivy.eigvalsh also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.eigvalsh. This method + simply wraps the function, and so the docstring for ivy.eigvalsh also + applies to this method with minimal changes. Parameters ---------- @@ -1006,10 +994,9 @@ def _static_inner( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.inner. This method simply wraps the - function, and so the docstring for ivy.inner also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.inner. This method simply + wraps the function, and so the docstring for ivy.inner also applies to + this method with minimal changes. Return the inner product of two vectors ``x1`` and ``x2``. @@ -1079,10 +1066,9 @@ def inner( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inner. This method simply wraps the - function, and so the docstring for ivy.inner also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.inner. This method + simply wraps the function, and so the docstring for ivy.inner also + applies to this method with minimal changes. Return the inner product of two vectors ``self`` and ``x2``. @@ -1150,10 +1136,9 @@ def _static_inv( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.inv. This method simply wraps the - function, and so the docstring for ivy.inv also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.inv. This method simply + wraps the function, and so the docstring for ivy.inv also applies to + this method with minimal changes. Parameters ---------- @@ -1219,10 +1204,9 @@ def inv( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.inv. This method simply wraps the - function, and so the docstring for ivy.inv also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.inv. This method simply + wraps the function, and so the docstring for ivy.inv also applies to + this method with minimal changes. Parameters ---------- @@ -1284,10 +1268,9 @@ def _static_pinv( rtol: Optional[Union[float, Tuple[float], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container special method variant of ivy.pinv. This method simply wraps the - function, and so the docstring for ivy.pinv also applies to this method with - minimal changes. + """ivy.Container special method variant of ivy.pinv. This method simply + wraps the function, and so the docstring for ivy.pinv also applies to + this method with minimal changes. Parameters ---------- @@ -1343,10 +1326,9 @@ def pinv( rtol: Optional[Union[float, Tuple[float], ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.pinv. This method simply wraps the - function, and so the docstring for ivy.pinv also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.pinv. This method + simply wraps the function, and so the docstring for ivy.pinv also + applies to this method with minimal changes. Parameters ---------- @@ -1409,10 +1391,9 @@ def _static_matrix_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.matrix_norm. This method simply wraps - the function, and so the docstring for ivy.matrix_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.matrix_norm. This method + simply wraps the function, and so the docstring for ivy.matrix_norm + also applies to this method with minimal changes. Parameters ---------- @@ -1497,10 +1478,9 @@ def matrix_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.matrix_norm. This method simply - wraps the function, and so the docstring for ivy.matrix_norm also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.matrix_norm. This + method simply wraps the function, and so the docstring for + ivy.matrix_norm also applies to this method with minimal changes. Parameters ---------- @@ -1630,10 +1610,9 @@ def _static_matrix_rank( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.matrix_rank. This method returns the - rank (i.e., number of non-zero singular values) of a matrix (or a stack of - matrices). + """ivy.Container static method variant of ivy.matrix_rank. This method + returns the rank (i.e., number of non-zero singular values) of a matrix + (or a stack of matrices). Parameters ---------- @@ -1725,10 +1704,9 @@ def matrix_rank( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.matrix_rank. This method returns - the rank (i.e., number of non-zero singular values) of a matrix (or a stack of - matrices). + """ivy.Container instance method variant of ivy.matrix_rank. This + method returns the rank (i.e., number of non-zero singular values) of a + matrix (or a stack of matrices). Parameters ---------- @@ -1815,8 +1793,7 @@ def _static_matrix_transpose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Transpose a matrix (or a stack of matrices) ``x``. + """Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1872,8 +1849,7 @@ def matrix_transpose( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Transpose a matrix (or a stack of matrices) ``x``. + """Transpose a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1928,10 +1904,9 @@ def _static_outer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.outer. This method simply wraps the - function, and so the docstring for ivy.outer also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.outer. This method simply + wraps the function, and so the docstring for ivy.outer also applies to + this method with minimal changes. Computes the outer product of two arrays, x1 and x2, by computing the tensor product along the last dimension of both arrays. @@ -2003,8 +1978,7 @@ def outer( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - Return the outer product of two arrays or containers. + """Return the outer product of two arrays or containers. The instance method implementation of the static method static_outer of the ivy.Container class. It calculates the outer product of two input arrays or @@ -2076,10 +2050,9 @@ def _static_qr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container static method variant of ivy.qr. This method simply wraps the - function, and so the docstring for ivy.qr also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.qr. This method simply + wraps the function, and so the docstring for ivy.qr also applies to + this method with minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -2172,10 +2145,9 @@ def qr( map_sequences: Union[bool, ivy.Container] = False, out: Optional[Tuple[ivy.Container, ivy.Container]] = None, ) -> Tuple[ivy.Container, ivy.Container]: - """ - ivy.Container instance method variant of ivy.qr. This method simply wraps the - function, and so the docstring for ivy.qr also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.qr. This method simply + wraps the function, and so the docstring for ivy.qr also applies to + this method with minimal changes. Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an @@ -2266,10 +2238,9 @@ def _static_slogdet( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.slogdet. This method simply wraps the - function, and so the docstring for ivy.slogdet also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.slogdet. This method + simply wraps the function, and so the docstring for ivy.slogdet also + applies to this method with minimal changes. Parameters ---------- @@ -2338,10 +2309,9 @@ def slogdet( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.slogdet. This method simply wraps - the function, and so the docstring for ivy.slogdet also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.slogdet. This method + simply wraps the function, and so the docstring for ivy.slogdet also + applies to this method with minimal changes. Parameters ---------- @@ -2458,10 +2428,9 @@ def _static_svd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> Union[ivy.Container, Tuple[ivy.Container, ...]]: - """ - ivy.Container static method variant of ivy.svd. This method simply wraps the - function, and so the docstring for ivy.svd also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.svd. This method simply + wraps the function, and so the docstring for ivy.svd also applies to + this method with minimal changes. Parameters ---------- @@ -2531,10 +2500,9 @@ def svd( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.svd. This method simply wraps the - function, and so the docstring for ivy.svd also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.svd. This method simply + wraps the function, and so the docstring for ivy.svd also applies to + this method with minimal changes. Parameters ---------- @@ -2749,9 +2717,9 @@ def _static_trace( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.trace. This method Returns the sum - along the specified diagonals of a matrix (or a stack of matrices). + """ivy.Container static method variant of ivy.trace. This method + Returns the sum along the specified diagonals of a matrix (or a stack + of matrices). Parameters ---------- @@ -2842,9 +2810,9 @@ def trace( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.trace. This method Returns the sum - along the specified diagonals of a matrix (or a stack of matrices). + """ivy.Container instance method variant of ivy.trace. This method + Returns the sum along the specified diagonals of a matrix (or a stack + of matrices). Parameters ---------- @@ -2983,10 +2951,9 @@ def _static_vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.vector_norm. This method simply wraps - the function, and so the docstring for ivy.vector_norm also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.vector_norm. This method + simply wraps the function, and so the docstring for ivy.vector_norm + also applies to this method with minimal changes. Parameters ---------- @@ -3098,10 +3065,9 @@ def vector_norm( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - r""" - ivy.Container instance method variant of ivy.vector_norm. This method simply - wraps the function, and so the docstring for ivy.vector_norm also applies to - this method with minimal changes. + r"""ivy.Container instance method variant of ivy.vector_norm. This + method simply wraps the function, and so the docstring for + ivy.vector_norm also applies to this method with minimal changes. Parameters ---------- @@ -3249,10 +3215,9 @@ def _static_vander( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.vander. This method simply wraps the - function, and so the docstring for ivy.vander also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.vander. This method + simply wraps the function, and so the docstring for ivy.vander also + applies to this method with minimal changes. Parameters ---------- @@ -3317,9 +3282,8 @@ def vander( increasing: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.vander. This method Returns the - Vandermonde matrix of the input array. + """ivy.Container instance method variant of ivy.vander. This method + Returns the Vandermonde matrix of the input array. Parameters ---------- @@ -3384,10 +3348,10 @@ def static_general_inner_product( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.general_inner_product. This method - simply wraps the function, and so the docstring for ivy.general_inner_product - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.general_inner_product. + This method simply wraps the function, and so the docstring for + ivy.general_inner_product also applies to this method with minimal + changes. Parameters ---------- @@ -3456,8 +3420,7 @@ def general_inner_product( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.general_inner_product. + """ivy.Container instance method variant of ivy.general_inner_product. This method simply wraps the function, and so the docstring for ivy.general_inner_product also applies to this method with diff --git a/ivy/data_classes/container/losses.py b/ivy/data_classes/container/losses.py index 4f3b65b47a39f..60dff4e8e4d2a 100644 --- a/ivy/data_classes/container/losses.py +++ b/ivy/data_classes/container/losses.py @@ -22,10 +22,9 @@ def _static_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cross_entropy. This method simply - wraps the function, and so the docstring for ivy.cross_entropy also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.cross_entropy. This + method simply wraps the function, and so the docstring for + ivy.cross_entropy also applies to this method with minimal changes. Parameters ---------- @@ -113,10 +112,9 @@ def cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cross_entropy. This method simply - wraps the function, and so the docstring for ivy.cross_entropy also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.cross_entropy. This + method simply wraps the function, and so the docstring for + ivy.cross_entropy also applies to this method with minimal changes. Parameters ---------- @@ -193,10 +191,10 @@ def _static_binary_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.binary_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.binary_cross_entropy - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.binary_cross_entropy. + This method simply wraps the function, and so the docstring for + ivy.binary_cross_entropy also applies to this method with minimal + changes. Parameters ---------- @@ -295,10 +293,10 @@ def binary_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.binary_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.binary_cross_entropy - also applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.binary_cross_entropy. + This method simply wraps the function, and so the docstring for + ivy.binary_cross_entropy also applies to this method with minimal + changes. Parameters ---------- @@ -384,10 +382,10 @@ def _static_sparse_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sparse_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.sparse_cross_entropy - also applies to this method with minimal changes. + """ivy.Container static method variant of ivy.sparse_cross_entropy. + This method simply wraps the function, and so the docstring for + ivy.sparse_cross_entropy also applies to this method with minimal + changes. Parameters ---------- @@ -474,10 +472,10 @@ def sparse_cross_entropy( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sparse_cross_entropy. This method - simply wraps the function, and so the docstring for ivy.sparse_cross_entropy - also applies to this method with minimal changes. + """ivy.Container instance method variant of ivy.sparse_cross_entropy. + This method simply wraps the function, and so the docstring for + ivy.sparse_cross_entropy also applies to this method with minimal + changes. Parameters ---------- diff --git a/ivy/data_classes/container/manipulation.py b/ivy/data_classes/container/manipulation.py index 6a2f768bac8d2..2b22319bacb04 100644 --- a/ivy/data_classes/container/manipulation.py +++ b/ivy/data_classes/container/manipulation.py @@ -32,8 +32,7 @@ def _static_concat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.concat. + """ivy.Container static method variant of ivy.concat. This method simply wraps the function, and so the docstring for ivy.concat also applies to this method with minimal changes. @@ -64,8 +63,7 @@ def concat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.concat. + """ivy.Container instance method variant of ivy.concat. This method simply wraps the function, and so the docstring for ivy.concat also applies to this method with minimal changes. @@ -95,10 +93,9 @@ def _static_expand_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.expand_dims. This method simply wraps - the function, and so the docstring for ivy.expand_dims also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.expand_dims. This method + simply wraps the function, and so the docstring for ivy.expand_dims + also applies to this method with minimal changes. Parameters ---------- @@ -194,10 +191,9 @@ def expand_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.expand_dims. This method simply - wraps the function, and so the docstring for ivy.expand_dims also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.expand_dims. This + method simply wraps the function, and so the docstring for + ivy.expand_dims also applies to this method with minimal changes. Parameters ---------- @@ -266,10 +262,9 @@ def _static_split( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container static method variant of ivy.split. This method simply wraps the - function, and so the docstring for ivy.split also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.split. This method simply + wraps the function, and so the docstring for ivy.split also applies to + this method with minimal changes. Parameters ---------- @@ -349,10 +344,9 @@ def split( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> List[ivy.Container]: - """ - ivy.Container instance method variant of ivy.split. This method simply wraps the - function, and so the docstring for ivy.split also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.split. This method + simply wraps the function, and so the docstring for ivy.split also + applies to this method with minimal changes. Parameters ---------- @@ -429,10 +423,9 @@ def _static_permute_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.permute_dims. This method simply - wraps the function, and so the docstring for ivy.permute_dims also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.permute_dims. This method + simply wraps the function, and so the docstring for ivy.permute_dims + also applies to this method with minimal changes. Parameters ---------- @@ -491,10 +484,9 @@ def permute_dims( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.permute_dims. This method simply - wraps the function, and so the docstring for ivy.permute_dims also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.permute_dims. This + method simply wraps the function, and so the docstring for + ivy.permute_dims also applies to this method with minimal changes. Parameters ---------- @@ -553,10 +545,9 @@ def _static_flip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.flip. This method simply wraps the - function, and so the docstring for ivy.flip also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.flip. This method simply + wraps the function, and so the docstring for ivy.flip also applies to + this method with minimal changes. Parameters ---------- @@ -640,10 +631,9 @@ def flip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.flip. This method simply wraps the - function, and so the docstring for ivy.flip also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.flip. This method + simply wraps the function, and so the docstring for ivy.flip also + applies to this method with minimal changes. Parameters ---------- @@ -729,10 +719,9 @@ def _static_reshape( order: Union[str, ivy.Container] = "C", allowzero: Union[bool, ivy.Container] = True, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.reshape. This method simply wraps the - function, and so the docstring for ivy.reshape also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.reshape. This method + simply wraps the function, and so the docstring for ivy.reshape also + applies to this method with minimal changes. Parameters ---------- @@ -847,10 +836,9 @@ def reshape( allowzero: Union[bool, ivy.Container] = True, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.reshape. This method simply wraps - the function, and so the docstring for ivy.reshape also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.reshape. This method + simply wraps the function, and so the docstring for ivy.reshape also + applies to this method with minimal changes. Parameters ---------- @@ -956,10 +944,9 @@ def _static_roll( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.roll. This method simply wraps the - function, and so the docstring for ivy.roll also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.roll. This method simply + wraps the function, and so the docstring for ivy.roll also applies to + this method with minimal changes. Parameters ---------- @@ -1048,10 +1035,9 @@ def roll( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.roll. This method simply wraps the - function, and so the docstring for ivy.roll also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.roll. This method + simply wraps the function, and so the docstring for ivy.roll also + applies to this method with minimal changes. Parameters ---------- @@ -1125,10 +1111,9 @@ def _static_squeeze( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.squeeze. This method simply wraps the - function, and so the docstring for ivy.squeeze also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.squeeze. This method + simply wraps the function, and so the docstring for ivy.squeeze also + applies to this method with minimal changes. Parameters ---------- @@ -1207,10 +1192,9 @@ def squeeze( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.squeeze. This method simply wraps - the function, and so the docstring for ivy.squeeze also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.squeeze. This method + simply wraps the function, and so the docstring for ivy.squeeze also + applies to this method with minimal changes. Parameters ---------- @@ -1293,10 +1277,9 @@ def _static_stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.stack. This method simply + wraps the function, and so the docstring for ivy.stack also applies to + this method with minimal changes. Parameters ---------- @@ -1390,10 +1373,9 @@ def stack( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.stack. This method simply wraps the - function, and so the docstring for ivy.stack also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.stack. This method + simply wraps the function, and so the docstring for ivy.stack also + applies to this method with minimal changes. Parameters ---------- @@ -1465,10 +1447,9 @@ def _static_repeat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.repeat. This method simply wraps the - function, and so the docstring for ivy.repeat also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.repeat. This method + simply wraps the function, and so the docstring for ivy.repeat also + applies to this method with minimal changes. Examples -------- @@ -1504,10 +1485,9 @@ def repeat( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.repeat. This method simply wraps - the function, and so the docstring for ivy.repeat also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.repeat. This method + simply wraps the function, and so the docstring for ivy.repeat also + applies to this method with minimal changes. Parameters ---------- @@ -1561,10 +1541,9 @@ def _static_tile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.tile. This method simply wraps the - function, and so the docstring for ivy.tile also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.tile. This method simply + wraps the function, and so the docstring for ivy.tile also applies to + this method with minimal changes. Parameters ---------- @@ -1617,10 +1596,9 @@ def tile( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.tile. This method simply wraps the - function, and so the docstring for ivy.tile also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.tile. This method + simply wraps the function, and so the docstring for ivy.tile also + applies to this method with minimal changes. Parameters ---------- @@ -1670,10 +1648,9 @@ def _static_constant_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.constant_pad. This method simply - wraps the function, and so the docstring for ivy.constant_pad also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.constant_pad. This method + simply wraps the function, and so the docstring for ivy.constant_pad + also applies to this method with minimal changes. Parameters ---------- @@ -1729,10 +1706,9 @@ def constant_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.constant_pad. This method simply - wraps the function, and so the docstring for ivy.constant_pad also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.constant_pad. This + method simply wraps the function, and so the docstring for + ivy.constant_pad also applies to this method with minimal changes. Parameters ---------- @@ -1787,10 +1763,9 @@ def _static_zero_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.zero_pad. This method simply wraps - the function, and so the docstring for ivy.zero_pad also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.zero_pad. This method + simply wraps the function, and so the docstring for ivy.zero_pad also + applies to this method with minimal changes. Parameters ---------- @@ -1854,10 +1829,9 @@ def zero_pad( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.zero_pad. This method simply wraps - the function, and so the docstring for ivy.zero_pad also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.zero_pad. This method + simply wraps the function, and so the docstring for ivy.zero_pad also + applies to this method with minimal changes. Parameters ---------- @@ -1923,10 +1897,9 @@ def _static_swapaxes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.swapaxes. This method simply wraps - the function, and so the docstring for ivy.swapaxes also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.swapaxes. This method + simply wraps the function, and so the docstring for ivy.swapaxes also + applies to this method with minimal changes. Parameters ---------- @@ -1992,10 +1965,9 @@ def swapaxes( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.swapaxes. This method simply wraps - the function, and so the docstring for ivy.swapaxes also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.swapaxes. This method + simply wraps the function, and so the docstring for ivy.swapaxes also + applies to this method with minimal changes. Parameters ---------- @@ -2062,10 +2034,9 @@ def _static_unstack( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unstack. This method simply wraps the - function, and so the docstring for ivy.unstack also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.unstack. This method + simply wraps the function, and so the docstring for ivy.unstack also + applies to this method with minimal changes. Parameters ---------- @@ -2160,10 +2131,9 @@ def unstack( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unstack. This method simply wraps - the function, and so the docstring for ivy.unstack also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.unstack. This method + simply wraps the function, and so the docstring for ivy.unstack also + applies to this method with minimal changes. Parameters ---------- @@ -2244,10 +2214,9 @@ def _static_clip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.clip. This method simply wraps the - function, and so the docstring for ivy.clip also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.clip. This method simply + wraps the function, and so the docstring for ivy.clip also applies to + this method with minimal changes. Parameters ---------- @@ -2332,10 +2301,9 @@ def clip( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.clip. This method simply wraps the - function, and so the docstring for ivy.clip also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.clip. This method + simply wraps the function, and so the docstring for ivy.clip also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/norms.py b/ivy/data_classes/container/norms.py index 948ff38dfbb94..39369ceba4e38 100644 --- a/ivy/data_classes/container/norms.py +++ b/ivy/data_classes/container/norms.py @@ -21,10 +21,9 @@ def layer_norm( new_std: Union[float, ivy.Container] = 1.0, out: Optional[Union[ivy.Array, ivy.Container]] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.layer_norm. This method simply - wraps the function, and so the docstring for ivy.layer_norm also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.layer_norm. This method + simply wraps the function, and so the docstring for ivy.layer_norm also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/random.py b/ivy/data_classes/container/random.py index bb7aa8c69dcc6..2932594f3fc43 100644 --- a/ivy/data_classes/container/random.py +++ b/ivy/data_classes/container/random.py @@ -23,10 +23,9 @@ def _static_random_uniform( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.random_uniform. This method simply - wraps the function, and so the docstring for ivy.random_uniform also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.random_uniform. This + method simply wraps the function, and so the docstring for + ivy.random_uniform also applies to this method with minimal changes. Parameters ---------- @@ -127,10 +126,9 @@ def random_uniform( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.random_uniform. This method simply - wraps the function, and so the docstring for ivy.random_uniform also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.random_uniform. This + method simply wraps the function, and so the docstring for + ivy.random_uniform also applies to this method with minimal changes. Parameters ---------- @@ -314,10 +312,9 @@ def _static_random_normal( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.random_normal. This method simply - wraps the function, and so the docstring for ivy.random_normal also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.random_normal. This + method simply wraps the function, and so the docstring for + ivy.random_normal also applies to this method with minimal changes. Parameters ---------- @@ -416,10 +413,9 @@ def random_normal( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.random_normal. This method simply - wraps the function, and so the docstring for ivy.random_normal also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.random_normal. This + method simply wraps the function, and so the docstring for + ivy.random_normal also applies to this method with minimal changes. Parameters ---------- @@ -604,10 +600,9 @@ def _static_multinomial( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.multinomial. This method simply wraps - the function, and so the docstring for ivy.multinomial also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.multinomial. This method + simply wraps the function, and so the docstring for ivy.multinomial + also applies to this method with minimal changes. Parameters ---------- @@ -679,10 +674,9 @@ def multinomial( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.multinomial. This method simply - wraps the function, and so the docstring for ivy.multinomial also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.multinomial. This + method simply wraps the function, and so the docstring for + ivy.multinomial also applies to this method with minimal changes. Parameters ---------- @@ -753,10 +747,9 @@ def _static_randint( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.randint. This method simply wraps the - function, and so the docstring for ivy.randint also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.randint. This method + simply wraps the function, and so the docstring for ivy.randint also + applies to this method with minimal changes. Parameters ---------- @@ -854,10 +847,9 @@ def randint( seed: Optional[Union[int, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.randint. This method simply wraps - the function, and so the docstring for ivy.randint also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.randint. This method + simply wraps the function, and so the docstring for ivy.randint also + applies to this method with minimal changes. Parameters ---------- @@ -1038,10 +1030,9 @@ def _static_shuffle( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.shuffle. This method simply wraps the - function, and so the docstring for ivy.shuffle also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.shuffle. This method + simply wraps the function, and so the docstring for ivy.shuffle also + applies to this method with minimal changes. Parameters ---------- @@ -1105,10 +1096,9 @@ def shuffle( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.shuffle. This method simply wraps - the function, and so the docstring for ivy.shuffle also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.shuffle. This method + simply wraps the function, and so the docstring for ivy.shuffle also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/searching.py b/ivy/data_classes/container/searching.py index c007d1f67cc8e..d8ceb13e8910c 100644 --- a/ivy/data_classes/container/searching.py +++ b/ivy/data_classes/container/searching.py @@ -20,10 +20,9 @@ def _static_argmax( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.argmax. This method simply wraps the - function, and so the docstring for ivy.argmax also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.argmax. This method + simply wraps the function, and so the docstring for ivy.argmax also + applies to this method with minimal changes. Parameters ---------- @@ -81,10 +80,9 @@ def argmax( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.argmax. This method simply wraps - the function, and so the docstring for ivy.argmax also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.argmax. This method + simply wraps the function, and so the docstring for ivy.argmax also + applies to this method with minimal changes. Parameters ---------- @@ -143,10 +141,9 @@ def _static_argmin( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.argmin. This method simply wraps the - function, and so the docstring for ivy.argmin also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.argmin. This method + simply wraps the function, and so the docstring for ivy.argmin also + applies to this method with minimal changes. Parameters ---------- @@ -205,10 +202,9 @@ def argmin( select_last_index: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.argmin. This method simply wraps - the function, and so the docstring for ivy.argmin also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.argmin. This method + simply wraps the function, and so the docstring for ivy.argmin also + applies to this method with minimal changes. Parameters ---------- @@ -275,10 +271,9 @@ def _static_nonzero( size: Optional[Union[int, ivy.Container]] = None, fill_value: Union[Number, ivy.Container] = 0, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.nonzero. This method simply wraps the - function, and so the docstring for ivy.nonzero also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.nonzero. This method + simply wraps the function, and so the docstring for ivy.nonzero also + applies to this method with minimal changes. Parameters ---------- @@ -315,10 +310,9 @@ def nonzero( size: Optional[Union[int, ivy.Container]] = None, fill_value: Union[Number, ivy.Container] = 0, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.nonzero. This method simply wraps - the function, and so the docstring for ivy.nonzero also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.nonzero. This method + simply wraps the function, and so the docstring for ivy.nonzero also + applies to this method with minimal changes. Parameters ---------- @@ -356,10 +350,9 @@ def _static_where( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.where. This method simply wraps the - function, and so the docstring for ivy.where also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.where. This method simply + wraps the function, and so the docstring for ivy.where also applies to + this method with minimal changes. Parameters ---------- @@ -402,10 +395,9 @@ def where( *, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.where. This method simply wraps the - function, and so the docstring for ivy.where also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.where. This method + simply wraps the function, and so the docstring for ivy.where also + applies to this method with minimal changes. Parameters ---------- @@ -452,10 +444,9 @@ def _static_argwhere( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.argwhere. This method simply wraps - the function, and so the docstring for ivy.argwhere also applies to this method - with minimal changes. + """ivy.Container static method variant of ivy.argwhere. This method + simply wraps the function, and so the docstring for ivy.argwhere also + applies to this method with minimal changes. Parameters ---------- @@ -518,10 +509,9 @@ def argwhere( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container instance method variant of ivy.argwhere. This method simply wraps - the function, and so the docstring for ivy.argwhere also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.argwhere. This method + simply wraps the function, and so the docstring for ivy.argwhere also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/set.py b/ivy/data_classes/container/set.py index e45c0e748ff86..930560637b588 100644 --- a/ivy/data_classes/container/set.py +++ b/ivy/data_classes/container/set.py @@ -19,10 +19,9 @@ def _static_unique_all( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unique_all. This method simply wraps - the function, and so the docstring for ivy.unique_all also applies to this - method with minimal changes. + """ivy.Container static method variant of ivy.unique_all. This method + simply wraps the function, and so the docstring for ivy.unique_all also + applies to this method with minimal changes. Parameters ---------- @@ -97,10 +96,9 @@ def unique_all( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_all. This method simply - wraps the function, and so the docstring for ivy.unique_all also applies to this - method with minimal changes. + """ivy.Container instance method variant of ivy.unique_all. This method + simply wraps the function, and so the docstring for ivy.unique_all also + applies to this method with minimal changes. Parameters ---------- @@ -172,10 +170,9 @@ def _static_unique_counts( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unique_counts. This method simply - wraps the function, and so the docstring for ivy.unique_counts also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.unique_counts. This + method simply wraps the function, and so the docstring for + ivy.unique_counts also applies to this method with minimal changes. Parameters ---------- @@ -236,10 +233,9 @@ def unique_counts( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_counts. This method simply - wraps the function, and so the docstring for ivy.unique_counts also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.unique_counts. This + method simply wraps the function, and so the docstring for + ivy.unique_counts also applies to this method with minimal changes. Parameters ---------- @@ -326,9 +322,8 @@ def unique_values( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_values. This method simply - wraps the function and applies it on the container. + """ivy.Container instance method variant of ivy.unique_values. This + method simply wraps the function and applies it on the container. Parameters ---------- @@ -404,10 +399,9 @@ def _static_unique_inverse( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.unique_inverse. This method simply - wraps the function, and so the docstring for ivy.unique_inverse also applies to - this method with minimal changes. + """ivy.Container static method variant of ivy.unique_inverse. This + method simply wraps the function, and so the docstring for + ivy.unique_inverse also applies to this method with minimal changes. Parameters ---------- @@ -469,10 +463,9 @@ def unique_inverse( prune_unapplied: Union[bool, ivy.Container] = False, map_sequences: Union[bool, ivy.Container] = False, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.unique_inverse. This method simply - wraps the function, and so the docstring for ivy.unique_inverse also applies to - this method with minimal changes. + """ivy.Container instance method variant of ivy.unique_inverse. This + method simply wraps the function, and so the docstring for + ivy.unique_inverse also applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/sorting.py b/ivy/data_classes/container/sorting.py index 8b1938b5ad7c8..a6409a5f176c8 100644 --- a/ivy/data_classes/container/sorting.py +++ b/ivy/data_classes/container/sorting.py @@ -24,10 +24,9 @@ def _static_argsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.argsort. This method simply wraps the - function, and so the docstring for ivy.argsort also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.argsort. This method + simply wraps the function, and so the docstring for ivy.argsort also + applies to this method with minimal changes. Parameters ---------- @@ -138,10 +137,9 @@ def argsort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.argsort. This method simply wraps - the function, and so the docstring for ivy.argsort also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.argsort. This method + simply wraps the function, and so the docstring for ivy.argsort also + applies to this method with minimal changes. Parameters ---------- @@ -222,10 +220,9 @@ def _static_sort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.sort. This method simply wraps the - function, and so the docstring for ivy.sort also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.sort. This method simply + wraps the function, and so the docstring for ivy.sort also applies to + this method with minimal changes. Examples -------- @@ -275,10 +272,9 @@ def sort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.sort. This method simply wraps the - function, and so the docstring for ivy.sort also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.sort. This method + simply wraps the function, and so the docstring for ivy.sort also + applies to this method with minimal changes. Examples -------- @@ -341,10 +337,9 @@ def static_msort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.msort. This method simply wraps the - function, and so the docstring for ivy.msort also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.msort. This method simply + wraps the function, and so the docstring for ivy.msort also applies to + this method with minimal changes. Parameters ---------- @@ -396,10 +391,9 @@ def msort( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.msort. This method simply wraps the - function, and so the docstring for ivy.msort also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.msort. This method + simply wraps the function, and so the docstring for ivy.msort also + applies to this method with minimal changes. Parameters ---------- @@ -455,8 +449,7 @@ def _static_searchsorted( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.searchsorted. + """ivy.Container static method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal @@ -492,8 +485,7 @@ def searchsorted( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.searchsorted. + """ivy.Container instance method variant of ivy.searchsorted. This method simply wraps the function, and so the docstring for ivy.searchsorted also applies to this method with minimal diff --git a/ivy/data_classes/container/statistical.py b/ivy/data_classes/container/statistical.py index f9b36cc105e6a..26db9e83fab4b 100644 --- a/ivy/data_classes/container/statistical.py +++ b/ivy/data_classes/container/statistical.py @@ -24,10 +24,9 @@ def _static_min( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.min. This method simply wraps the - function, and so the docstring for ivy.min also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.min. This method simply + wraps the function, and so the docstring for ivy.min also applies to + this method with minimal changes. Parameters ---------- @@ -111,10 +110,9 @@ def min( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.min. This method simply wraps the - function, and so the docstring for ivy.min also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.min. This method simply + wraps the function, and so the docstring for ivy.min also applies to + this method with minimal changes. Parameters ---------- @@ -197,10 +195,9 @@ def max( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.max. This method simply wraps the - function, and so the docstring for ivy.max also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.max. This method simply + wraps the function, and so the docstring for ivy.max also applies to + this method with minimal changes. Parameters ---------- @@ -277,10 +274,9 @@ def mean( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.mean. This method simply wraps the - function, and so the docstring for ivy.mean also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.mean. This method + simply wraps the function, and so the docstring for ivy.mean also + applies to this method with minimal changes. Parameters ---------- @@ -412,10 +408,9 @@ def var( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.var. This method simply wraps the - function, and so the docstring for ivy.var also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.var. This method simply + wraps the function, and so the docstring for ivy.var also applies to + this method with minimal changes. Parameters ---------- @@ -530,10 +525,9 @@ def _static_var( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.var. This method simply wraps the - function, and so the docstring for ivy.var also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.var. This method simply + wraps the function, and so the docstring for ivy.var also applies to + this method with minimal changes. Parameters ---------- @@ -602,10 +596,9 @@ def _static_prod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ): - """ - ivy.Container static method variant of ivy.prod. This method simply wraps the - function, and so the docstring for ivy.prod also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.prod. This method simply + wraps the function, and so the docstring for ivy.prod also applies to + this method with minimal changes. Parameters ---------- @@ -741,10 +734,9 @@ def prod( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.prod. This method simply wraps the - function, and so the docstring for ivy.prod also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.prod. This method + simply wraps the function, and so the docstring for ivy.prod also + applies to this method with minimal changes. Parameters ---------- @@ -933,10 +925,9 @@ def std( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.std. This method simply wraps the - function, and so the docstring for ivy.std also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.std. This method simply + wraps the function, and so the docstring for ivy.std also applies to + this method with minimal changes. Parameters ---------- @@ -1083,10 +1074,9 @@ def _static_cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cumsum. This method simply wraps the - function, and so the docstring for ivy.cumsum also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cumsum. This method + simply wraps the function, and so the docstring for ivy.cumsum also + applies to this method with minimal changes. Parameters ---------- @@ -1225,10 +1215,9 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cumsum. This method simply wraps - the function, and so the docstring for ivy.cumsum also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cumsum. This method + simply wraps the function, and so the docstring for ivy.cumsum also + applies to this method with minimal changes. Parameters ---------- @@ -1382,10 +1371,9 @@ def _static_cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.cumprod. This method simply wraps the - function, and so the docstring for ivy.cumprod also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.cumprod. This method + simply wraps the function, and so the docstring for ivy.cumprod also + applies to this method with minimal changes. Parameters ---------- @@ -1474,10 +1462,9 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]] = None, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.cumprod. This method simply wraps - the function, and so the docstring for ivy.cumprod also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.cumprod. This method + simply wraps the function, and so the docstring for ivy.cumprod also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/utility.py b/ivy/data_classes/container/utility.py index d6298db810436..4be1c16810d91 100644 --- a/ivy/data_classes/container/utility.py +++ b/ivy/data_classes/container/utility.py @@ -23,10 +23,9 @@ def _static_all( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.all. This method simply wraps the - function, and so the docstring for ivy.all also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.all. This method simply + wraps the function, and so the docstring for ivy.all also applies to + this method with minimal changes. Parameters ---------- @@ -108,10 +107,9 @@ def all( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.all. This method simply wraps the - function, and so the docstring for ivy.all also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.all. This method simply + wraps the function, and so the docstring for ivy.all also applies to + this method with minimal changes. Parameters ---------- @@ -193,10 +191,9 @@ def _static_any( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container static method variant of ivy.any. This method simply wraps the - function, and so the docstring for ivy.any also applies to this method with - minimal changes. + """ivy.Container static method variant of ivy.any. This method simply + wraps the function, and so the docstring for ivy.any also applies to + this method with minimal changes. Parameters ---------- @@ -278,10 +275,9 @@ def any( map_sequences: Union[bool, ivy.Container] = False, out: Optional[ivy.Container] = None, ) -> ivy.Container: - """ - ivy.Container instance method variant of ivy.any. This method simply wraps the - function, and so the docstring for ivy.any also applies to this method with - minimal changes. + """ivy.Container instance method variant of ivy.any. This method simply + wraps the function, and so the docstring for ivy.any also applies to + this method with minimal changes. Parameters ---------- diff --git a/ivy/data_classes/container/wrapping.py b/ivy/data_classes/container/wrapping.py index c4c500cb8e04b..8bbb2b30b5809 100644 --- a/ivy/data_classes/container/wrapping.py +++ b/ivy/data_classes/container/wrapping.py @@ -9,8 +9,7 @@ def _wrap_function(function_name: str, static: bool) -> Callable: - """ - Wrap the function called `function_name`. + """Wrap the function called `function_name`. Parameters ---------- @@ -83,9 +82,8 @@ def add_ivy_container_instance_methods( static: Union[bool, ivy.Container] = False, to_ignore: Union[Iterable, ivy.Container] = (), ): - """ - Loop over all ivy modules such as activations, general, etc. and add the module - functions to ivy container as instance methods using _wrap_function. + """Loop over all ivy modules such as activations, general, etc. and add the + module functions to ivy container as instance methods using _wrap_function. Parameters ---------- diff --git a/ivy/data_classes/factorized_tensor/cp_tensor.py b/ivy/data_classes/factorized_tensor/cp_tensor.py index aff80256786af..e81c18f929f6e 100644 --- a/ivy/data_classes/factorized_tensor/cp_tensor.py +++ b/ivy/data_classes/factorized_tensor/cp_tensor.py @@ -74,8 +74,8 @@ def cp_copy(self): )) def mode_dot(self, matrix_or_vector, mode, keep_dim=False, copy=True): - """ - N-mode product of a CP tensor and a matrix or vector at the specified mode. + """N-mode product of a CP tensor and a matrix or vector at the + specified mode. Parameters ---------- @@ -105,8 +105,7 @@ def mode_dot(self, matrix_or_vector, mode, keep_dim=False, copy=True): ) def norm(self): - """ - Return the l2 norm of a CP tensor. + """Return the l2 norm of a CP tensor. Parameters ---------- @@ -128,8 +127,7 @@ def norm(self): return ivy.CPTensor.cp_norm(self) def normalize(self, inplace=True): - """ - Normalize the factors to unit length. + """Normalize the factors to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are normalized to unit Euclidean length @@ -177,8 +175,7 @@ def n_param(self): # ---------------# @staticmethod def validate_cp_tensor(cp_tensor): - """ - Validate a cp_tensor in the form (weights, factors) + """Validate a cp_tensor in the form (weights, factors) Return the rank and shape of the validated tensor @@ -237,9 +234,8 @@ def validate_cp_tensor(cp_tensor): @staticmethod def cp_n_param(tensor_shape, rank, weights=False): - """ - Return number of parameters of a CP decomposition for a given `rank` and full - `tensor_shape`. + """Return number of parameters of a CP decomposition for a given `rank` + and full `tensor_shape`. Parameters ---------- @@ -262,8 +258,7 @@ def cp_n_param(tensor_shape, rank, weights=False): @staticmethod def validate_cp_rank(tensor_shape, rank="same", rounding="round"): - """ - Return the rank of a CP Decomposition. + """Return the rank of a CP Decomposition. Parameters ---------- @@ -306,8 +301,7 @@ def validate_cp_rank(tensor_shape, rank="same", rounding="round"): @staticmethod def cp_normalize(cp_tensor): - """ - Return cp_tensor with factors normalised to unit length. + """Return cp_tensor with factors normalised to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are @@ -355,10 +349,10 @@ def cp_normalize(cp_tensor): @staticmethod def cp_flip_sign(cp_tensor, mode=0, func=None): - """ - Return cp_tensor with factors flipped to have positive signs. The sign of a - given column is determined by `func`, which is the mean by default. Any negative - signs are assigned to the mode indicated by `mode`. + """Return cp_tensor with factors flipped to have positive signs. The + sign of a given column is determined by `func`, which is the mean by + default. Any negative signs are assigned to the mode indicated by + `mode`. Parameters ---------- @@ -410,8 +404,7 @@ def cp_flip_sign(cp_tensor, mode=0, func=None): @staticmethod def cp_lstsq_grad(cp_tensor, tensor, return_loss=False, mask=None): - r""" - Compute (for a third-order tensor) + r"""Compute (for a third-order tensor) .. math:: @@ -472,8 +465,7 @@ def cp_lstsq_grad(cp_tensor, tensor, return_loss=False, mask=None): @staticmethod def cp_to_tensor(cp_tensor, mask=None): - """ - Turn the Khatri-product of matrices into a full tensor. + """Turn the Khatri-product of matrices into a full tensor. ``factor_matrices = [|U_1, ... U_n|]`` becomes a tensor shape ``(U[1].shape[0], U[2].shape[0], ... U[-1].shape[0])`` @@ -530,8 +522,7 @@ def cp_to_tensor(cp_tensor, mask=None): @staticmethod def cp_to_unfolded(cp_tensor, mode): - """ - Turn the khatri-product of matrices into an unfolded tensor. + """Turn the khatri-product of matrices into an unfolded tensor. turns ``factors = [|U_1, ... U_n|]`` into a mode-`mode` unfolding of the tensor @@ -571,8 +562,7 @@ def cp_to_unfolded(cp_tensor, mode): @staticmethod def cp_to_vec(cp_tensor): - """ - Turn the khatri-product of matrices into a vector. + """Turn the khatri-product of matrices into a vector. (the tensor ``factors = [|U_1, ... U_n|]`` is converted into a raveled mode-0 unfolding) @@ -597,8 +587,8 @@ def cp_to_vec(cp_tensor): @staticmethod def cp_mode_dot(cp_tensor, matrix_or_vector, mode, keep_dim=False, copy=False): - """ - N-mode product of a CP tensor and a matrix or vector at the specified mode. + """N-mode product of a CP tensor and a matrix or vector at the + specified mode. Parameters ---------- @@ -669,8 +659,7 @@ def cp_mode_dot(cp_tensor, matrix_or_vector, mode, keep_dim=False, copy=False): @staticmethod def cp_norm(cp_tensor): - """ - Return the l2 norm of a CP tensor. + """Return the l2 norm of a CP tensor. Parameters ---------- @@ -762,8 +751,7 @@ def cp_norm(cp_tensor): @staticmethod def unfolding_dot_khatri_rao(x, cp_tensor, mode): - """ - Mode-n unfolding times khatri-rao product of factors. + """Mode-n unfolding times khatri-rao product of factors. Parameters ---------- diff --git a/ivy/data_classes/factorized_tensor/parafac2_tensor.py b/ivy/data_classes/factorized_tensor/parafac2_tensor.py index 76dd4be2288ec..78d07a91ff6ce 100644 --- a/ivy/data_classes/factorized_tensor/parafac2_tensor.py +++ b/ivy/data_classes/factorized_tensor/parafac2_tensor.py @@ -90,8 +90,7 @@ def n_param(self): @classmethod def from_CPTensor(cls, cp_tensor, parafac2_tensor_ok=False): - """ - Create a Parafac2Tensor from a CPTensor. + """Create a Parafac2Tensor from a CPTensor. Parameters ---------- @@ -124,9 +123,8 @@ def from_CPTensor(cls, cp_tensor, parafac2_tensor_ok=False): # ---------------# @staticmethod def validate_parafac2_tensor(parafac2_tensor): - """ - Validate a parafac2_tensor in the form (weights, factors) Return the rank and - shape of the validated tensor. + """Validate a parafac2_tensor in the form (weights, factors) Return the + rank and shape of the validated tensor. Parameters ---------- @@ -210,8 +208,7 @@ def validate_parafac2_tensor(parafac2_tensor): @staticmethod def parafac2_normalise(parafac2_tensor): - """ - Return parafac2_tensor with factors normalised to unit length. + """Return parafac2_tensor with factors normalised to unit length. Turns ``factors = [|U_1, ... U_n|]`` into ``[weights; |V_1, ... V_n|]``, where the columns of each `V_k` are normalized to unit Euclidean length @@ -267,8 +264,7 @@ def parafac2_normalise(parafac2_tensor): @staticmethod def apply_parafac2_projections(parafac2_tensor): - """ - Apply the projection matrices to the evolving factor. + """Apply the projection matrices to the evolving factor. Parameters ---------- @@ -297,8 +293,8 @@ def apply_parafac2_projections(parafac2_tensor): @staticmethod def parafac2_to_slice(parafac2_tensor, slice_idx, validate=True): - """ - Generate a single slice along the first mode from the PARAFAC2 tensor. + """Generate a single slice along the first mode from the PARAFAC2 + tensor. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -362,8 +358,7 @@ def parafac2_to_slice(parafac2_tensor, slice_idx, validate=True): @staticmethod def parafac2_to_slices(parafac2_tensor, validate=True): - """ - Generate all slices along the first mode from a PARAFAC2 tensor. + """Generate all slices along the first mode from a PARAFAC2 tensor. Generates a list of all slices from a PARAFAC2 tensor. A list is returned since the tensor might have varying size along the second mode. To return @@ -432,8 +427,7 @@ def parafac2_to_slices(parafac2_tensor, validate=True): @staticmethod def parafac2_to_tensor(parafac2_tensor): - """ - Construct a full tensor from a PARAFAC2 decomposition. + """Construct a full tensor from a PARAFAC2 decomposition. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -494,9 +488,8 @@ def parafac2_to_tensor(parafac2_tensor): @staticmethod def parafac2_to_unfolded(parafac2_tensor, mode): - """ - Construct an unfolded tensor from a PARAFAC2 decomposition. Uneven slices are - padded by zeros. + """Construct an unfolded tensor from a PARAFAC2 decomposition. Uneven + slices are padded by zeros. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by @@ -547,9 +540,8 @@ def parafac2_to_unfolded(parafac2_tensor, mode): @staticmethod def parafac2_to_vec(parafac2_tensor): - """ - Construct a vectorized tensor from a PARAFAC2 decomposition. Uneven slices are - padded by zeros. + """Construct a vectorized tensor from a PARAFAC2 decomposition. Uneven + slices are padded by zeros. The decomposition is on the form :math:`(A [B_i] C)` such that the i-th frontal slice, :math:`X_i`, of :math:`X` is given by diff --git a/ivy/data_classes/factorized_tensor/tt_tensor.py b/ivy/data_classes/factorized_tensor/tt_tensor.py index 14fb3f81a88a2..c226155527441 100644 --- a/ivy/data_classes/factorized_tensor/tt_tensor.py +++ b/ivy/data_classes/factorized_tensor/tt_tensor.py @@ -106,8 +106,7 @@ def validate_tt_tensor(tt_tensor): @staticmethod def tt_to_tensor(factors): - """ - Return the full tensor whose TT decomposition is given by 'factors'. + """Return the full tensor whose TT decomposition is given by 'factors'. Re-assembles 'factors', which represent a tensor in TT/Matrix-Product-State format into the corresponding full tensor @@ -138,8 +137,8 @@ def tt_to_tensor(factors): @staticmethod def tt_to_unfolded(factors, mode): - """ - Return the unfolding matrix of a tensor given in TT (or Tensor- Train) format. + """Return the unfolding matrix of a tensor given in TT (or Tensor- + Train) format. Reassembles a full tensor from 'factors' and returns its unfolding matrix with mode given by 'mode' @@ -160,9 +159,8 @@ def tt_to_unfolded(factors, mode): @staticmethod def tt_to_vec(factors): - """ - Return the tensor defined by its TT format ('factors') into its vectorized - format. + """Return the tensor defined by its TT format ('factors') into its + vectorized format. Parameters ---------- @@ -178,9 +176,8 @@ def tt_to_vec(factors): @staticmethod def _tt_n_param(tensor_shape, rank): - """ - Return the number of parameters of a MPS decomposition for a given `rank` and - full `tensor_shape`. + """Return the number of parameters of a MPS decomposition for a given + `rank` and full `tensor_shape`. Parameters ---------- @@ -208,8 +205,7 @@ def validate_tt_rank( rounding="round", allow_overparametrization=True, ): - """ - Return the rank of a TT Decomposition. + """Return the rank of a TT Decomposition. Parameters ---------- @@ -333,9 +329,8 @@ def validate_tt_rank( @staticmethod def pad_tt_rank(factor_list, n_padding=1, pad_boundaries=False): - """ - Pad the factors of a Tensor-Train so as to increase its rank without changing - its reconstruction. + """Pad the factors of a Tensor-Train so as to increase its rank without + changing its reconstruction. The tensor-train (ring) will be padded with 0s to increase its rank only but not the underlying tensor it represents. diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index 6ba49d03d86ea..7338bec329843 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -227,8 +227,7 @@ def _build_view(original, view, fn, args, kwargs, index=None): def _check_in_nested_sequence(sequence, value=None, _type=None): - """ - Check `sequence` for either a `value` or a value of type `_type`. + """Check `sequence` for either a `value` or a value of type `_type`. Helper to recursively check if a N-level nested `sequence` contains either a `value` or contains a value of type `_type` and return a @@ -268,8 +267,7 @@ def _get_preferred_device(args, kwargs): def handle_array_function(fn): - """ - Wrap a function `fn` to be passed to array_function method. + """Wrap a function `fn` to be passed to array_function method. Wrap a function to extract the relevant argument types to be passed to array_function method. @@ -380,10 +378,9 @@ def _handle_array_like_without_promotion(*args, **kwargs): def inputs_to_native_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_native_arrays(*args, **kwargs): - """ - Convert all `ivy.Array` instances in both the positional and keyword arguments - into `ivy.NativeArray` instances, and then calls the function with the updated - arguments. + """Convert all `ivy.Array` instances in both the positional and keyword + arguments into `ivy.NativeArray` instances, and then calls the function + with the updated arguments. Parameters ---------- @@ -420,10 +417,9 @@ def _inputs_to_native_arrays(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays(*args, **kwargs): - """ - Convert all `ivy.NativeArray` instances in both the positional and keyword - arguments into `ivy.Array` instances, and then calls the function with the - updated arguments. + """Convert all `ivy.NativeArray` instances in both the positional and + keyword arguments into `ivy.Array` instances, and then calls the + function with the updated arguments. Parameters ---------- @@ -487,8 +483,7 @@ def _outputs_to_ivy_shapes(*args, **kwargs): def to_native_shapes_and_back(fn: Callable) -> Callable: - """ - Make `fn` receive `ivy.NativeShape` and return `ivy.Shape`. + """Make `fn` receive `ivy.NativeShape` and return `ivy.Shape`. Wrap `fn` so that input shapes are all converted to `ivy.NativeShape` instances and return shapes are all converted to @@ -500,9 +495,8 @@ def to_native_shapes_and_back(fn: Callable) -> Callable: def outputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_ivy_arrays(*args, **kwargs): - """ - Call the function, and then converts all `ivy.NativeArray` instances in the - function return into `ivy.Array` instances. + """Call the function, and then converts all `ivy.NativeArray` instances + in the function return into `ivy.Array` instances. Parameters ---------- @@ -530,9 +524,8 @@ def _outputs_to_ivy_arrays(*args, **kwargs): def output_to_native_arrays(fn: Callable) -> Callable: - """ - Call the function, and then converts all `ivy.Array` instances in the function - return into `ivy.NativeArray` instances. + """Call the function, and then converts all `ivy.Array` instances in the + function return into `ivy.NativeArray` instances. Parameters ---------- @@ -557,8 +550,7 @@ def _output_to_native_arrays(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Make `fn` receive `ivy.Array` and return `ivy.NativeArray`. + """Make `fn` receive `ivy.Array` and return `ivy.NativeArray`. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ivy.NativeArray` @@ -568,8 +560,7 @@ def to_ivy_arrays_and_back(fn: Callable) -> Callable: def to_native_arrays_and_back(fn: Callable) -> Callable: - """ - Make `fn` receive `ivy.NativeArray` and return `ivy.Array`. + """Make `fn` receive `ivy.NativeArray` and return `ivy.Array`. Wrap `fn` so that input arrays are all converted to `ivy.NativeArray` instances and return arrays are all converted to @@ -579,8 +570,7 @@ def to_native_arrays_and_back(fn: Callable) -> Callable: def frontend_outputs_to_ivy_arrays(fn: Callable) -> Callable: - """ - Wrap `fn` and convert all frontend arrays in its return to ivy arrays. + """Wrap `fn` and convert all frontend arrays in its return to ivy arrays. Used in cases when a frontend function receives a callable (frontend function) argument. To be able to use that callable in a composition @@ -600,8 +590,7 @@ def _outputs_to_ivy_arrays(*args, **kwargs): def handle_view(fn: Callable) -> Callable: - """ - Wrap `fn` and performs view handling if copy is False. + """Wrap `fn` and performs view handling if copy is False. Used for functional backends (Jax and TensorFlow). Checks if the first arg is a view or original array by checking if the ._base @@ -632,8 +621,7 @@ def _handle_view(*args, **kwargs): def handle_view_indexing(fn: Callable) -> Callable: - """ - Wrap `fn` and performs view handling specifically for indexing. + """Wrap `fn` and performs view handling specifically for indexing. As with NumPy it returns a copy if advanced indexing is performed. Used for functional backends (Jax and TensorFlow). Checks if the @@ -676,8 +664,8 @@ def _convert_numpy_arrays_to_backend_specific(*args): def handle_numpy_arrays_in_specific_backend(fn: Callable) -> Callable: - """ - Wrap `fn` and converts all `numpy.ndarray` inputs to `torch.Tensor` instances. + """Wrap `fn` and converts all `numpy.ndarray` inputs to `torch.Tensor` + instances. Used for functional backends (PyTorch). Converts all `numpy.ndarray` inputs to `torch.Tensor` instances. @@ -700,9 +688,8 @@ def _handle_numpy_array_in_torch(*args, **kwargs): def infer_dtype(fn: Callable) -> Callable: @functools.wraps(fn) def _infer_dtype(*args, dtype=None, **kwargs): - """ - Determine the correct `dtype`, and then calls the function with the `dtype` - passed explicitly. + """Determine the correct `dtype`, and then calls the function with the + `dtype` passed explicitly. Parameters ---------- @@ -738,8 +725,7 @@ def _infer_dtype(*args, dtype=None, **kwargs): def handle_device(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_device(*args, **kwargs): - """ - Move all array inputs of the function to `ivy.default_device()`. + """Move all array inputs of the function to `ivy.default_device()`. Parameters ---------- @@ -793,9 +779,8 @@ def handle_out_argument(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_out_argument(*args, out=None, **kwargs): - """ - Call `fn` with the `out` argument handled correctly for performing an inplace - update. + """Call `fn` with the `out` argument handled correctly for performing + an inplace update. Parameters ---------- @@ -887,10 +872,9 @@ def handle_nestable(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_nestable(*args, **kwargs): - """ - Call `fn` with the *nestable* property of the function correctly handled. This - means mapping the function to the container leaves if any containers are passed - in the input. + """Call `fn` with the *nestable* property of the function correctly + handled. This means mapping the function to the container leaves if any + containers are passed in the input. Parameters ---------- @@ -931,10 +915,9 @@ def cont_fn(*args, **kwargs): def handle_ragged(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_ragged(*args, **kwargs): - """ - Call `fn` with the *ragged* property of the function correctly handled. This - means mapping the function to the RaggedArray arrays if any RaggedArrays are - passed in the input. + """Call `fn` with the *ragged* property of the function correctly + handled. This means mapping the function to the RaggedArray arrays if + any RaggedArrays are passed in the input. Parameters ---------- @@ -992,8 +975,7 @@ def _handle_partial_mixed_function(*args, **kwargs): def temp_asarray_wrapper(fn: Callable) -> Callable: @functools.wraps(fn) def _temp_asarray_wrapper(*args, **kwargs): - """ - Convert `Tensor` into `ivy.Array` instances. + """Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -1026,9 +1008,8 @@ def _to_ivy_array(x): def download_cython_wrapper_wrapper(fn: Callable) -> Callable: @functools.wraps(fn) def _download_cython_wrapper_wrapper(*args, **kwargs): - """ - Wrap the function to download compiled cython wrapper for the function and re- - wraps it with the downloaded wrapper. + """Wrap the function to download compiled cython wrapper for the + function and re- wraps it with the downloaded wrapper. Download the compiled cython wrapper by calling ivy.wrappers.get_wrapper(func_name: str) and then wrap the @@ -1050,12 +1031,11 @@ def _download_cython_wrapper_wrapper(*args, **kwargs): def _wrap_function( key: str, to_wrap: Callable, original: Callable, compositional: bool = False ) -> Callable: - """ - Apply wrapping to backend implementation `to_wrap` if the original implementation - `original` is also wrapped, and if `to_wrap` is not already wrapped. Attributes - `handle_nestable` etc are set during wrapping, hence indicate to us whether a - certain function has been wrapped or not. Also handles wrapping of the `linalg` - namespace. + """Apply wrapping to backend implementation `to_wrap` if the original + implementation `original` is also wrapped, and if `to_wrap` is not already + wrapped. Attributes `handle_nestable` etc are set during wrapping, hence + indicate to us whether a certain function has been wrapped or not. Also + handles wrapping of the `linalg` namespace. Parameters ---------- @@ -1262,8 +1242,8 @@ def _dtype_from_version(dic, version): def _versioned_attribute_factory(attribute_function, base): class VersionedAttributes(base): - """ - Class which add versioned attributes to a class, inheriting from `base`. + """Class which add versioned attributes to a class, inheriting from + `base`. Create a class which inherits `base` this way if isinstance is called on an instance of the class, it will return True if @@ -1292,8 +1272,7 @@ def __bool__(self): def _dtype_device_wrapper_creator(attrib, t): - """ - Create a wrapper for a dtype or device attribute. + """Create a wrapper for a dtype or device attribute. The wrapper returns the correct dtype or device for the current version of the backend. @@ -1393,8 +1372,8 @@ def _nest_has_nans(x): def handle_nans(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_nans(*args, **kwargs): - """ - Check for the existence of nans in all arrays in the `args` and `kwargs`. + """Check for the existence of nans in all arrays in the `args` and + `kwargs`. The presence of nans is then handled depending on the enabled `nan_policy`. @@ -1448,9 +1427,8 @@ def _handle_complex_input( complex_mode: Literal["split", "magnitude", "jax"] = "jax", **kwargs, ): - """ - Check whether the first positional argument is an array of complex type, and if - so handle it according to the provided `complex_mode`. + """Check whether the first positional argument is an array of complex + type, and if so handle it according to the provided `complex_mode`. The options are: `"jax"` (default): emulate the behaviour of the JAX framework. If the function @@ -1577,10 +1555,9 @@ def _handle_complex_input( def handle_backend_invalid(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_backend_invalid(*args, **kwargs): - """ - Check if any of the arguments (or nested arguments) passed to the function are - instances of ivy.Array or ivy.NativeArray. If so, it returns the function. If - not, it raises an InvalidBackendException. + """Check if any of the arguments (or nested arguments) passed to the + function are instances of ivy.Array or ivy.NativeArray. If so, it + returns the function. If not, it raises an InvalidBackendException. Parameters ---------- diff --git a/ivy/functional/backends/jax/activations.py b/ivy/functional/backends/jax/activations.py index 5f163f85fe385..cdb9340436cf6 100644 --- a/ivy/functional/backends/jax/activations.py +++ b/ivy/functional/backends/jax/activations.py @@ -1,4 +1,5 @@ -"""Collection of Jax activation functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax activation functions, wrapped to fit Ivy syntax and +signature.""" # global diff --git a/ivy/functional/backends/jax/device.py b/ivy/functional/backends/jax/device.py index e12164e617440..f21d9aa0cb66a 100644 --- a/ivy/functional/backends/jax/device.py +++ b/ivy/functional/backends/jax/device.py @@ -1,4 +1,5 @@ -"""Collection of Jax device functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax device functions, wrapped to fit Ivy syntax and +signature.""" # global import os diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index 7382466218be1..a21e94b23fc12 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -1,4 +1,5 @@ -"""Collection of Jax general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax general functions, wrapped to fit Ivy syntax and +signature.""" # global import jax diff --git a/ivy/functional/backends/jax/gradients.py b/ivy/functional/backends/jax/gradients.py index 13ee80730c2b4..5e96bdd28c101 100644 --- a/ivy/functional/backends/jax/gradients.py +++ b/ivy/functional/backends/jax/gradients.py @@ -1,4 +1,5 @@ -"""Collection of Jax gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax gradient functions, wrapped to fit Ivy syntax and +signature.""" # global import jax diff --git a/ivy/functional/backends/jax/layers.py b/ivy/functional/backends/jax/layers.py index 37bd852c7c3a6..78a72fb2fb85b 100644 --- a/ivy/functional/backends/jax/layers.py +++ b/ivy/functional/backends/jax/layers.py @@ -1,4 +1,5 @@ -"""Collection of Jax network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax network layers, wrapped to fit Ivy syntax and +signature.""" # global import jax.lax as jlax diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index bc09814ff8b58..c2e98759fe2c4 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -1,4 +1,5 @@ -"""Collection of Jax random functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Jax random functions, wrapped to fit Ivy syntax and +signature.""" # global import jax diff --git a/ivy/functional/backends/mxnet/activations.py b/ivy/functional/backends/mxnet/activations.py index 96bd23c3ca96f..b72a333da33f1 100644 --- a/ivy/functional/backends/mxnet/activations.py +++ b/ivy/functional/backends/mxnet/activations.py @@ -1,5 +1,4 @@ -""" -MXNet activation functions. +"""MXNet activation functions. Collection of MXNet activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/mxnet/device.py b/ivy/functional/backends/mxnet/device.py index bb9874bcca80d..1064e52b7aa21 100644 --- a/ivy/functional/backends/mxnet/device.py +++ b/ivy/functional/backends/mxnet/device.py @@ -1,5 +1,4 @@ -""" -MXNet device functions. +"""MXNet device functions. Collection of MXNet general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/mxnet/gradients.py b/ivy/functional/backends/mxnet/gradients.py index 97577e8634e6f..203640b7df2ef 100644 --- a/ivy/functional/backends/mxnet/gradients.py +++ b/ivy/functional/backends/mxnet/gradients.py @@ -1,4 +1,5 @@ -"""Collection of MXNet gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of MXNet gradient functions, wrapped to fit Ivy syntax and +signature.""" # global from typing import Sequence, Union diff --git a/ivy/functional/backends/mxnet/layers.py b/ivy/functional/backends/mxnet/layers.py index 5bb1ed3d5a26f..2450a2555131b 100644 --- a/ivy/functional/backends/mxnet/layers.py +++ b/ivy/functional/backends/mxnet/layers.py @@ -1,4 +1,5 @@ -"""Collection of MXNet network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of MXNet network layers, wrapped to fit Ivy syntax and +signature.""" # global import mxnet as mx diff --git a/ivy/functional/backends/mxnet/random.py b/ivy/functional/backends/mxnet/random.py index 875fc1ce304cb..033a6b26cce5d 100644 --- a/ivy/functional/backends/mxnet/random.py +++ b/ivy/functional/backends/mxnet/random.py @@ -1,5 +1,4 @@ -""" -MXNet random functions. +"""MXNet random functions. Collection of MXNet random functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/numpy/activations.py b/ivy/functional/backends/numpy/activations.py index cb9f698df3d39..714056b4b34c0 100644 --- a/ivy/functional/backends/numpy/activations.py +++ b/ivy/functional/backends/numpy/activations.py @@ -1,4 +1,5 @@ -"""Collection of Numpy activation functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy activation functions, wrapped to fit Ivy syntax and +signature.""" # global from typing import Optional, Union, Literal diff --git a/ivy/functional/backends/numpy/device.py b/ivy/functional/backends/numpy/device.py index d636feb8d8f25..b173e50154f92 100644 --- a/ivy/functional/backends/numpy/device.py +++ b/ivy/functional/backends/numpy/device.py @@ -1,4 +1,5 @@ -"""Collection of Numpy general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy general functions, wrapped to fit Ivy syntax and +signature.""" # global import os diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index fa72a2bd0164b..7c73a37ba78ca 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -1,4 +1,5 @@ -"""Collection of Numpy general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy general functions, wrapped to fit Ivy syntax and +signature.""" # global from typing import Optional, Union, Sequence, Callable, Tuple diff --git a/ivy/functional/backends/numpy/gradients.py b/ivy/functional/backends/numpy/gradients.py index 1f930d0ebe687..d6ba1e9b55bd7 100644 --- a/ivy/functional/backends/numpy/gradients.py +++ b/ivy/functional/backends/numpy/gradients.py @@ -1,4 +1,5 @@ -"""Collection of NumPy gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of NumPy gradient functions, wrapped to fit Ivy syntax and +signature.""" # global import logging diff --git a/ivy/functional/backends/numpy/helpers.py b/ivy/functional/backends/numpy/helpers.py index b5ae02d3a09f0..965bb5067baca 100644 --- a/ivy/functional/backends/numpy/helpers.py +++ b/ivy/functional/backends/numpy/helpers.py @@ -4,8 +4,7 @@ def _scalar_output_to_0d_array(function: Callable) -> Callable: - """ - Convert scalar outputs to 0d arrays. + """Convert scalar outputs to 0d arrays. Sometimes NumPy functions return scalars e.g. `np.add` does when the inputs are both 0 dimensional. diff --git a/ivy/functional/backends/numpy/layers.py b/ivy/functional/backends/numpy/layers.py index d6d4ebc27b20a..5fe2e909e5e76 100644 --- a/ivy/functional/backends/numpy/layers.py +++ b/ivy/functional/backends/numpy/layers.py @@ -1,4 +1,5 @@ -"""Collection of Numpy network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy network layers, wrapped to fit Ivy syntax and +signature.""" # global import numpy as np diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index eb0859f706ffb..4d3daa4a00c6e 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -1,4 +1,5 @@ -"""Collection of Numpy random functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Numpy random functions, wrapped to fit Ivy syntax and +signature.""" # global import numpy as np diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index 8182b0ef2263a..59c421f43ae6b 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/ivy/functional/backends/paddle/activations.py @@ -1,5 +1,4 @@ -""" -Paddle activation functions. +"""Paddle activation functions. Collection of Paddle activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/paddle/device.py b/ivy/functional/backends/paddle/device.py index 0270ccd9d1d5b..b1120da1d5657 100644 --- a/ivy/functional/backends/paddle/device.py +++ b/ivy/functional/backends/paddle/device.py @@ -1,4 +1,5 @@ -"""Collection of Paddle general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle general functions, wrapped to fit Ivy syntax and +signature.""" # global import os diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 0cba9b3ce312b..1d9802da6c154 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -748,8 +748,7 @@ def _EvaluatePolynomial(x, coefficients): def _is_scalar(x): - """ - Determines if the given tensor is a scalar. + """Determines if the given tensor is a scalar. Args ---- diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index f21d14595f180..8bdb2a2a86cbc 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -1,4 +1,5 @@ -"""Collection of Paddle general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle general functions, wrapped to fit Ivy syntax and +signature.""" # global from numbers import Number diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index 349b8218996ad..c39ef078758b1 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -1,4 +1,5 @@ -"""Collection of Paddle gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle gradient functions, wrapped to fit Ivy syntax and +signature.""" # global diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index 4798e13e3f64f..ad78d3d041b50 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -1,4 +1,5 @@ -"""Collection of Paddle network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle network layers, wrapped to fit Ivy syntax and +signature.""" from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/paddle/random.py b/ivy/functional/backends/paddle/random.py index 1c156fd300172..aa16a3d9d1666 100644 --- a/ivy/functional/backends/paddle/random.py +++ b/ivy/functional/backends/paddle/random.py @@ -1,4 +1,5 @@ -"""Collection of Paddle random functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of Paddle random functions, wrapped to fit Ivy syntax and +signature.""" # global import paddle diff --git a/ivy/functional/backends/tensorflow/activations.py b/ivy/functional/backends/tensorflow/activations.py index 2a9797f11897d..5b757031a48c5 100644 --- a/ivy/functional/backends/tensorflow/activations.py +++ b/ivy/functional/backends/tensorflow/activations.py @@ -1,5 +1,4 @@ -""" -TensorFlow activation functions. +"""TensorFlow activation functions. Collection of TensorFlow activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/device.py b/ivy/functional/backends/tensorflow/device.py index bec64860d54a4..dd7c4cea4f6c9 100644 --- a/ivy/functional/backends/tensorflow/device.py +++ b/ivy/functional/backends/tensorflow/device.py @@ -1,5 +1,4 @@ -""" -Tensorflow device functions. +"""Tensorflow device functions. Collection of TensorFlow general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 7a018f41c9197..70db8f5b6d040 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -1,5 +1,4 @@ -""" -Tensorflow general functions. +"""Tensorflow general functions. Collection of TensorFlow general functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/gradients.py b/ivy/functional/backends/tensorflow/gradients.py index d548e21bc7738..da688a2dd71f5 100644 --- a/ivy/functional/backends/tensorflow/gradients.py +++ b/ivy/functional/backends/tensorflow/gradients.py @@ -1,5 +1,4 @@ -""" -Tensorflow gradient functions. +"""Tensorflow gradient functions. Collection of TensorFlow gradient functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 3b1489bf8e787..d1e6c2043cd5b 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -1,4 +1,5 @@ -"""Collection of TensorFlow network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of TensorFlow network layers, wrapped to fit Ivy syntax and +signature.""" # global from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/tensorflow/random.py b/ivy/functional/backends/tensorflow/random.py index 22a91745a912d..dcb320508614d 100644 --- a/ivy/functional/backends/tensorflow/random.py +++ b/ivy/functional/backends/tensorflow/random.py @@ -1,5 +1,4 @@ -""" -TensorFlow random functions. +"""TensorFlow random functions. Collection of TensorFlow random functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py index 50b592d5d9587..edfe28faa07db 100644 --- a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/statistical.py @@ -118,9 +118,8 @@ def nanmedian( def _nanmedian_helper(input, axis=None, keepdims=False): - """ - The approach to Handle Nans in single dimensional plus multi-dimensional inputs are - composed on two-parts. + """The approach to Handle Nans in single dimensional plus multi-dimensional + inputs are composed on two-parts. PART 1: In this part, you have axis=None, it means we have to work on flattened data, we don't need to work on different axis.there are two cases here diff --git a/ivy/functional/backends/torch/activations.py b/ivy/functional/backends/torch/activations.py index b2dd68bd04177..e341d123ec230 100644 --- a/ivy/functional/backends/torch/activations.py +++ b/ivy/functional/backends/torch/activations.py @@ -1,5 +1,4 @@ -""" -PyTorch activation functions. +"""PyTorch activation functions. Collection of PyTorch activation functions, wrapped to fit Ivy syntax and signature. diff --git a/ivy/functional/backends/torch/device.py b/ivy/functional/backends/torch/device.py index 59d35e007d109..4fdfb8ce1c035 100644 --- a/ivy/functional/backends/torch/device.py +++ b/ivy/functional/backends/torch/device.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and +signature.""" import inspect diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 304f84f356143..2fb22fc355458 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch general functions, wrapped to fit Ivy syntax and +signature.""" # global from functools import reduce as _reduce diff --git a/ivy/functional/backends/torch/gradients.py b/ivy/functional/backends/torch/gradients.py index 3434409fa0509..207794f8c4eab 100644 --- a/ivy/functional/backends/torch/gradients.py +++ b/ivy/functional/backends/torch/gradients.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch gradient functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch gradient functions, wrapped to fit Ivy syntax and +signature.""" # global import torch diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index 754c8c63d23b3..2a7640b33db3f 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch network layers, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch network layers, wrapped to fit Ivy syntax and +signature.""" from typing import Optional, Tuple, Union, Sequence diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index 8dd695838b8c6..efc61ba4c52a1 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -1,4 +1,5 @@ -"""Collection of PyTorch random functions, wrapped to fit Ivy syntax and signature.""" +"""Collection of PyTorch random functions, wrapped to fit Ivy syntax and +signature.""" # global import torch diff --git a/ivy/functional/frontends/jax/numpy/__init__.py b/ivy/functional/frontends/jax/numpy/__init__.py index 6972b2d115109..4b8a28a0a6ed9 100644 --- a/ivy/functional/frontends/jax/numpy/__init__.py +++ b/ivy/functional/frontends/jax/numpy/__init__.py @@ -390,8 +390,8 @@ def promote_types_jax( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -424,9 +424,8 @@ def promote_types_of_jax_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index 3f770c6dfcde0..864119a245bc0 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -345,8 +345,8 @@ def interpolate( def kl_div(logits, labels, reduction="mean"): - """ - Computes the Kullback-Leibler (KL) Divergence between the logits and the labels. + """Computes the Kullback-Leibler (KL) Divergence between the logits and the + labels. Parameters ---------- diff --git a/ivy/functional/frontends/mxnet/func_wrapper.py b/ivy/functional/frontends/mxnet/func_wrapper.py index 434e5755a7f11..6b8880d6f149e 100644 --- a/ivy/functional/frontends/mxnet/func_wrapper.py +++ b/ivy/functional/frontends/mxnet/func_wrapper.py @@ -61,8 +61,7 @@ def _handle_mxnet_out(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_mxnet(*args, **kwargs): - """ - Convert `ndarray.NDArray` into `ivy.Array` instances. + """Convert `ndarray.NDArray` into `ivy.Array` instances. Convert all `ndarray.NDArray` instances in both the positional and keyword arguments into `ivy.Array` instances, and then calls @@ -84,8 +83,7 @@ def _inputs_to_ivy_arrays_mxnet(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_mxnet(*args, **kwargs): - """ - Convert `ivy.Array` into `ndarray.NDArray` instances. + """Convert `ivy.Array` into `ndarray.NDArray` instances. Call the function, and then converts all `ivy.Array` instances in the function return into `ndarray.NDArray` instances. @@ -101,8 +99,7 @@ def _outputs_to_frontend_arrays_mxnet(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray.NDArray` diff --git a/ivy/functional/frontends/mxnet/numpy/__init__.py b/ivy/functional/frontends/mxnet/numpy/__init__.py index a3b0c6fab40a1..1f8fb0f1393f8 100644 --- a/ivy/functional/frontends/mxnet/numpy/__init__.py +++ b/ivy/functional/frontends/mxnet/numpy/__init__.py @@ -104,8 +104,8 @@ def promote_types_mxnet( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -132,9 +132,8 @@ def promote_types_of_mxnet_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/numpy/__init__.py b/ivy/functional/frontends/numpy/__init__.py index 8d2eac7018fd3..9cdf0c1278021 100644 --- a/ivy/functional/frontends/numpy/__init__.py +++ b/ivy/functional/frontends/numpy/__init__.py @@ -435,9 +435,8 @@ def promote_types_of_numpy_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given ivy array inputs to a common dtype based on numpy - type promotion rules. + """Promote the dtype of the given ivy array inputs to a common dtype based + on numpy type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/numpy/func_wrapper.py b/ivy/functional/frontends/numpy/func_wrapper.py index d1d4df7a8fa1b..91df6184aa626 100644 --- a/ivy/functional/frontends/numpy/func_wrapper.py +++ b/ivy/functional/frontends/numpy/func_wrapper.py @@ -227,9 +227,9 @@ def _to_ivy_array(x): def from_zero_dim_arrays_to_scalar(fn: Callable) -> Callable: @functools.wraps(fn) def _from_zero_dim_arrays_to_scalar(*args, **kwargs): - """ - Call the function, and then convert all 0 dimensional array instances in the - function to float numbers if out argument is not provided. + """Call the function, and then convert all 0 dimensional array + instances in the function to float numbers if out argument is not + provided. Parameters ---------- @@ -282,8 +282,7 @@ def _from_zero_dim_arrays_to_scalar(*args, **kwargs): def handle_numpy_casting(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_numpy_casting(*args, casting="same_kind", dtype=None, **kwargs): - """ - Check numpy casting type. + """Check numpy casting type. Parameters ---------- @@ -344,8 +343,8 @@ def _handle_numpy_casting(*args, casting="same_kind", dtype=None, **kwargs): def handle_numpy_casting_special(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_numpy_casting_special(*args, casting="same_kind", dtype=None, **kwargs): - """ - Check numpy casting type for special cases where output must be type bool. + """Check numpy casting type for special cases where output must be type + bool. Parameters ---------- @@ -433,10 +432,9 @@ def _handle_numpy_out(*args, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_np(*args, **kwargs): - """ - Convert all `ndarray` instances in both the positional and keyword arguments - into `ivy.Array` instances, and then call the function with the updated - arguments. + """Convert all `ndarray` instances in both the positional and keyword + arguments into `ivy.Array` instances, and then call the function with + the updated arguments. Parameters ---------- @@ -463,9 +461,8 @@ def _inputs_to_ivy_arrays_np(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays(*args, order="K", **kwargs): - """ - Call the function, and then convert all `ivy.Array` instances returned by the - function into `ndarray` instances. + """Call the function, and then convert all `ivy.Array` instances + returned by the function into `ndarray` instances. Returns ------- @@ -527,8 +524,7 @@ def _outputs_to_frontend_arrays(*args, order="K", **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray` instances. diff --git a/ivy/functional/frontends/numpy/statistics/order_statistics.py b/ivy/functional/frontends/numpy/statistics/order_statistics.py index 1484182c4f62a..63209ffe912fa 100644 --- a/ivy/functional/frontends/numpy/statistics/order_statistics.py +++ b/ivy/functional/frontends/numpy/statistics/order_statistics.py @@ -11,8 +11,7 @@ def _cpercentile(N, percent, key=lambda x: x): - """ - Find the percentile of a list of values. + """Find the percentile of a list of values. @parameter N - is a list of values. Note N MUST BE already sorted. @parameter percent - a float value from 0.0 to 1.0. diff --git a/ivy/functional/frontends/onnx/__init__.py b/ivy/functional/frontends/onnx/__init__.py index 0c0b59d24c907..46a5fb5daad61 100644 --- a/ivy/functional/frontends/onnx/__init__.py +++ b/ivy/functional/frontends/onnx/__init__.py @@ -191,8 +191,8 @@ def promote_types_onnx( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -219,9 +219,8 @@ def promote_types_of_onnx_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/onnx/func_wrapper.py b/ivy/functional/frontends/onnx/func_wrapper.py index fb60b19615381..2bd6adaa3cb1e 100644 --- a/ivy/functional/frontends/onnx/func_wrapper.py +++ b/ivy/functional/frontends/onnx/func_wrapper.py @@ -49,8 +49,7 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_onnx(*args, **kwargs): - """ - Convert `Tensor` into `ivy.Array` instances. + """Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then calls the @@ -71,8 +70,7 @@ def _inputs_to_ivy_arrays_onnx(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_onnx(*args, **kwargs): - """ - Convert `ivy.Array` into `Tensor` instances. + """Convert `ivy.Array` into `Tensor` instances. Call the function, and then converts all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -89,8 +87,7 @@ def _outputs_to_frontend_arrays_onnx(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `ndarray.NDArray` diff --git a/ivy/functional/frontends/paddle/__init__.py b/ivy/functional/frontends/paddle/__init__.py index be293ee475839..58ae61580f139 100644 --- a/ivy/functional/frontends/paddle/__init__.py +++ b/ivy/functional/frontends/paddle/__init__.py @@ -156,8 +156,8 @@ def promote_types_paddle( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -184,9 +184,8 @@ def promote_types_of_paddle_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 5ea418f5153e6..bc72bd9aa7df1 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -97,8 +97,8 @@ def fftshift(x, axes=None, name=None): ) @to_ivy_arrays_and_back def hfft(x, n=None, axes=-1, norm="backward", name=None): - """Compute the FFT of a signal that has Hermitian symmetry, resulting in a real - spectrum.""" + """Compute the FFT of a signal that has Hermitian symmetry, resulting in a + real spectrum.""" # Determine the input shape and axis length input_shape = x.shape input_len = input_shape[axes] diff --git a/ivy/functional/frontends/paddle/func_wrapper.py b/ivy/functional/frontends/paddle/func_wrapper.py index c8c9e13acb0e0..4bc7db1821eb0 100644 --- a/ivy/functional/frontends/paddle/func_wrapper.py +++ b/ivy/functional/frontends/paddle/func_wrapper.py @@ -41,8 +41,7 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def new_fn(*args, **kwargs): - """ - Convert `Tensor` into `ivy.Array` instances. + """Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -64,8 +63,7 @@ def new_fn(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def new_fn(*args, **kwargs): - """ - Convert `ivy.Array` into `Tensor` instances. + """Convert `ivy.Array` into `Tensor` instances. Call the function, and then convert all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -89,8 +87,7 @@ def new_fn(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `Tensor` instances. diff --git a/ivy/functional/frontends/tensorflow/__init__.py b/ivy/functional/frontends/tensorflow/__init__.py index 8f41d31818161..fb8077c3672b7 100644 --- a/ivy/functional/frontends/tensorflow/__init__.py +++ b/ivy/functional/frontends/tensorflow/__init__.py @@ -53,10 +53,9 @@ @handle_exceptions def check_tensorflow_casting(x1, x2): - """ - Check whether the two arguments provided in the function have the same dtype, unless - one of them is an array_like or scalar, where it gets casted to the other input's - dtype. + """Check whether the two arguments provided in the function have the same + dtype, unless one of them is an array_like or scalar, where it gets casted + to the other input's dtype. Parameters ---------- diff --git a/ivy/functional/frontends/tensorflow/func_wrapper.py b/ivy/functional/frontends/tensorflow/func_wrapper.py index c72ff5565a19d..a25c8418885e2 100644 --- a/ivy/functional/frontends/tensorflow/func_wrapper.py +++ b/ivy/functional/frontends/tensorflow/func_wrapper.py @@ -37,8 +37,7 @@ def _to_ivy_array(x): # update kwargs dictionary keys helper def _update_kwarg_keys(kwargs: Dict, to_update: Dict) -> Dict: - """ - Update the key-word only arguments dictionary. + """Update the key-word only arguments dictionary. Parameters ---------- @@ -100,10 +99,9 @@ def _handle_tf_dtype(*args, dtype=None, **kwargs): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_tf(*args, **kwargs): - """ - Convert all `TensorFlow.Tensor` instances in both the positional and keyword - arguments into `ivy.Array` instances, and then call the function with the - updated arguments. + """Convert all `TensorFlow.Tensor` instances in both the positional and + keyword arguments into `ivy.Array` instances, and then call the + function with the updated arguments. Parameters ---------- @@ -142,10 +140,10 @@ def _inputs_to_ivy_arrays_tf(*args, **kwargs): def map_raw_ops_alias( alias: callable, kwargs_to_update: Optional[Dict] = None ) -> callable: - """ - Map the raw_ops function with its respective frontend alias function, as the - implementations of raw_ops is way similar to that of frontend functions, except that - only arguments are passed as key-word only in raw_ops functions. + """Map the raw_ops function with its respective frontend alias function, as + the implementations of raw_ops is way similar to that of frontend + functions, except that only arguments are passed as key-word only in + raw_ops functions. Parameters ---------- @@ -199,9 +197,8 @@ def _wraped_fn(**kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _outputs_to_frontend_arrays_tf(*args, **kwargs): - """ - Call the function, and then convert all `tensorflow.Tensor` instances in the - function return into `ivy.Array` instances. + """Call the function, and then convert all `tensorflow.Tensor` + instances in the function return into `ivy.Array` instances. Parameters ---------- diff --git a/ivy/functional/frontends/tensorflow/variable.py b/ivy/functional/frontends/tensorflow/variable.py index d1c757e19fb9a..bf6feeedde71d 100644 --- a/ivy/functional/frontends/tensorflow/variable.py +++ b/ivy/functional/frontends/tensorflow/variable.py @@ -277,12 +277,14 @@ def indices(self): @property def dense_shape(self): - """A 1-D `Tensor` containing the shape of the corresponding dense tensor.""" + """A 1-D `Tensor` containing the shape of the corresponding dense + tensor.""" return self._dense_shape @property def device(self): - """The name of the device on which `values` will be produced, or `None`.""" + """The name of the device on which `values` will be produced, or + `None`.""" return self.values.device @property diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index e871198f0a823..d502cb7e90d50 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -191,8 +191,8 @@ def promote_types_torch( type2: Union[ivy.Dtype, ivy.NativeDtype], /, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -221,9 +221,8 @@ def promote_types_of_torch_inputs( x2: Union[ivy.Array, Number, Iterable[Number]], /, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an diff --git a/ivy/functional/frontends/torch/func_wrapper.py b/ivy/functional/frontends/torch/func_wrapper.py index c79cdd9782ceb..c7df1998d4faa 100644 --- a/ivy/functional/frontends/torch/func_wrapper.py +++ b/ivy/functional/frontends/torch/func_wrapper.py @@ -131,8 +131,7 @@ def _to_ivy_array(x): def inputs_to_ivy_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def _inputs_to_ivy_arrays_torch(*args, **kwargs): - """ - Convert `Tensor` into `ivy.Array` instances. + """Convert `Tensor` into `ivy.Array` instances. Convert all `Tensor` instances in both the positional and keyword arguments into `ivy.Array` instances, and then call the function with the updated @@ -169,8 +168,7 @@ def wrapper(*args, **kwargs): def outputs_to_frontend_arrays(fn: Callable) -> Callable: @functools.wraps(fn) def outputs_to_frontend_arrays_torch(*args, **kwargs): - """ - Convert `ivy.Array` into `Tensor` instances. + """Convert `ivy.Array` into `Tensor` instances. Call the function, and then convert all `ivy.Array` instances returned by the function into `Tensor` instances. @@ -267,8 +265,7 @@ def outputs_to_native_arrays_torch(*args, **kwargs): def to_ivy_arrays_and_back(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives and returns `ivy.Array` instances. + """Wrap `fn` so it receives and returns `ivy.Array` instances. Wrap `fn` so that input arrays are all converted to `ivy.Array` instances and return arrays are all converted to `Tensor` instances. @@ -277,8 +274,7 @@ def to_ivy_arrays_and_back(fn: Callable) -> Callable: def to_ivy_shape(fn: Callable) -> Callable: - """ - Wrap `fn` so it receives `ivy.Shape` instances. + """Wrap `fn` so it receives `ivy.Shape` instances. Wrap `fn` so that any `torch_frontend.Size` arguments are converted to `ivy.Shape` instances. diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 341bebad429ad..86dd7263f24b1 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -277,8 +277,7 @@ def atan2(self, other): return torch_frontend.atan2(self, other) def view(self, *args, size=None): - """ - Reshape Tensor. + """Reshape Tensor. possible arguments are either: - size diff --git a/ivy/functional/frontends/xgboost/core.py b/ivy/functional/frontends/xgboost/core.py index 8e8dbf9b557f4..c5404abf5d839 100644 --- a/ivy/functional/frontends/xgboost/core.py +++ b/ivy/functional/frontends/xgboost/core.py @@ -123,9 +123,8 @@ def __init__(self, params=None, cache=None, model_file=None, compile=False): self._comp_binary_prediction(self.gbm.obj, cache[1]) def update(self, dtrain, dlabel, iteration, fobj=None): - """ - Update for one iteration, with objective function calculated internally. This - function should not be called directly by users. + """Update for one iteration, with objective function calculated + internally. This function should not be called directly by users. Parameters ---------- @@ -156,11 +155,10 @@ def predict( iteration_range=(0, 0), strict_shape=False, ): - """ - Predict with data. The full model will be used unless `iteration_range` is - specified, meaning user have to either slice the model or use the - ``best_iteration`` attribute to get prediction from best model returned from - early stopping. + """Predict with data. The full model will be used unless + `iteration_range` is specified, meaning user have to either slice the + model or use the ``best_iteration`` attribute to get prediction from + best model returned from early stopping. Parameters ---------- diff --git a/ivy/functional/frontends/xgboost/linear/updater_coordinate.py b/ivy/functional/frontends/xgboost/linear/updater_coordinate.py index 284fc2f5a64a0..7b7c08a64e716 100644 --- a/ivy/functional/frontends/xgboost/linear/updater_coordinate.py +++ b/ivy/functional/frontends/xgboost/linear/updater_coordinate.py @@ -8,15 +8,15 @@ def coordinate_updater(gpair, data, lr, weight, n_feat, n_iter, reg_alpha, reg_lambda): - """ - Implements one step of coordinate descent. The original optimizer implements - parallel calculations. The below code is an approximation of the original one, but - rather than computing the update direction for a single parameter at a time using a - for loop and cumulative gradients, it does the update in parallel by means of - matrix-vector multiplications. Given that xgboost's updater is non-deterministic, - the approximated and original implementations converge to pretty the same optima, - resulting in metrics' values(accuracy, f1-score) differing at a level of 0.001(for - separate runs metrics may end up being the same). + """Implements one step of coordinate descent. The original optimizer + implements parallel calculations. The below code is an approximation of the + original one, but rather than computing the update direction for a single + parameter at a time using a for loop and cumulative gradients, it does the + update in parallel by means of matrix-vector multiplications. Given that + xgboost's updater is non-deterministic, the approximated and original + implementations converge to pretty the same optima, resulting in metrics' + values(accuracy, f1-score) differing at a level of 0.001(for separate runs + metrics may end up being the same). Parameters ---------- diff --git a/ivy/functional/frontends/xgboost/sklearn.py b/ivy/functional/frontends/xgboost/sklearn.py index e2edeecb81802..3b80f8d6fa1fe 100644 --- a/ivy/functional/frontends/xgboost/sklearn.py +++ b/ivy/functional/frontends/xgboost/sklearn.py @@ -98,9 +98,8 @@ def __sklearn_is_fitted__(self): return hasattr(self, "_Booster") def get_booster(self): - """ - Get the underlying xgboost Booster of this model. This will raise an exception - when fit was not called. + """Get the underlying xgboost Booster of this model. This will raise an + exception when fit was not called. Returns ------- @@ -176,8 +175,7 @@ def fit( feature_weights=None, callbacks=None, ): - """ - Fit gradient boosting model. + """Fit gradient boosting model. Note that calling ``fit()`` multiple times will cause the model object to be re-fit from scratch. To resume training from a previous checkpoint, explicitly diff --git a/ivy/functional/frontends/xgboost/training.py b/ivy/functional/frontends/xgboost/training.py index cc727add4c5a6..cc67edb9f478d 100644 --- a/ivy/functional/frontends/xgboost/training.py +++ b/ivy/functional/frontends/xgboost/training.py @@ -18,8 +18,7 @@ def train( callbacks=None, custom_metric=None, ): - """ - Train a booster with given parameters. + """Train a booster with given parameters. Parameters ---------- diff --git a/ivy/functional/ivy/activations.py b/ivy/functional/ivy/activations.py index 2468219b98cde..8d3803b6c0777 100644 --- a/ivy/functional/ivy/activations.py +++ b/ivy/functional/ivy/activations.py @@ -48,8 +48,7 @@ def gelu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the Gaussian error linear unit (GELU) activation function. + """Apply the Gaussian error linear unit (GELU) activation function. Parameters ---------- @@ -138,8 +137,7 @@ def leaky_relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the leaky rectified linear unit function element-wise. + """Apply the leaky rectified linear unit function element-wise. If the input is complex, then by default each element is scaled by `alpha` if either its real part is strictly negative or if its real part is zero and its @@ -218,8 +216,7 @@ def log_softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the log_softmax function element-wise. + """Apply the log_softmax function element-wise. Parameters ---------- @@ -314,8 +311,7 @@ def relu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the rectified linear unit function element-wise. + """Apply the rectified linear unit function element-wise. If the input is complex, then by default each element is set to zero if either its real part is strictly negative or if its real part is zero and its @@ -386,8 +382,7 @@ def sigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the sigmoid function element-wise. + """Apply the sigmoid function element-wise. Parameters ---------- @@ -473,8 +468,7 @@ def softmax( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the softmax function element-wise. + """Apply the softmax function element-wise. Parameters ---------- @@ -571,8 +565,7 @@ def softplus( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the softplus function element-wise. + """Apply the softplus function element-wise. If the input is complex, then by default we apply the softplus operation `log(1+ exp(x))` to each element @@ -640,8 +633,7 @@ def softsign( /, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the softsign function element-wise. + """Apply the softsign function element-wise. Parameters ---------- @@ -683,8 +675,7 @@ def mish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the mish activation function element-wise. + """Apply the mish activation function element-wise. Parameters ---------- @@ -759,8 +750,7 @@ def hardswish( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the hardswish activation function element-wise. + """Apply the hardswish activation function element-wise. Parameters ---------- diff --git a/ivy/functional/ivy/control_flow_ops.py b/ivy/functional/ivy/control_flow_ops.py index 57a496e2c9b5c..7537d6c202408 100644 --- a/ivy/functional/ivy/control_flow_ops.py +++ b/ivy/functional/ivy/control_flow_ops.py @@ -17,10 +17,9 @@ def if_else( orelse_fn: Callable, vars: Dict[str, Union[ivy.Array, ivy.NativeArray]], ) -> Any: - """ - Take a condition function and two functions as input. If the condition is True, the - first function is executed and its result is returned. Otherwise, the second - function is executed and its result is returned. + """Take a condition function and two functions as input. If the condition + is True, the first function is executed and its result is returned. + Otherwise, the second function is executed and its result is returned. Parameters ---------- @@ -75,9 +74,9 @@ def while_loop( body_fn: Callable, vars: Dict[str, Union[ivy.Array, ivy.NativeArray]], ) -> Any: - """ - Take a test function, a body function and a set of variables as input. The body - function is executed repeatedly while the test function returns True. + """Take a test function, a body function and a set of variables as input. + The body function is executed repeatedly while the test function returns + True. Parameters ---------- @@ -127,9 +126,8 @@ def for_loop( body_fn: Callable, vars: Iterable[Union[ivy.Array, ivy.NativeArray]], ): - """ - Loops over an iterable, passing the current iteration along with a tuple of - variables into the provided body function. + """Loops over an iterable, passing the current iteration along with a tuple + of variables into the provided body function. Parameters ---------- diff --git a/ivy/functional/ivy/creation.py b/ivy/functional/ivy/creation.py index 44c9f370b04ed..c032bc3b69134 100644 --- a/ivy/functional/ivy/creation.py +++ b/ivy/functional/ivy/creation.py @@ -44,10 +44,9 @@ def _asarray_handle_nestable(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_handle_nestable_wrapper(*args, **kwargs): - """ - Call `fn` with the *nestable* property of the function correctly handled. This - means mapping the function to the container leaves if any containers are passed - in the input. + """Call `fn` with the *nestable* property of the function correctly + handled. This means mapping the function to the container leaves if any + containers are passed in the input. Parameters ---------- @@ -136,9 +135,9 @@ def _remove_np_bfloat16(obj): def _asarray_to_native_arrays_and_back(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_to_native_arrays_and_back_wrapper(*args, dtype=None, **kwargs): - """ - Wrap `fn` so that input arrays are all converted to `ivy.NativeArray` instances - and return arrays are all converted to `ivy.Array` instances. + """Wrap `fn` so that input arrays are all converted to + `ivy.NativeArray` instances and return arrays are all converted to + `ivy.Array` instances. This wrapper is specifically for the backend implementations of asarray. @@ -160,10 +159,9 @@ def _asarray_to_native_arrays_and_back_wrapper(*args, dtype=None, **kwargs): def _asarray_infer_dtype(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_infer_dtype_wrapper(*args, dtype=None, **kwargs): - """ - Determine the correct `dtype`, and then calls the function with the `dtype` - passed explicitly. This wrapper is specifically for the backend implementations - of asarray. + """Determine the correct `dtype`, and then calls the function with the + `dtype` passed explicitly. This wrapper is specifically for the backend + implementations of asarray. Parameters ---------- @@ -218,10 +216,9 @@ def _infer_dtype(obj): def _asarray_infer_device(fn: Callable) -> Callable: @functools.wraps(fn) def _asarray_infer_device_wrapper(*args, device=None, **kwargs): - """ - Determine the correct `device`, and then calls the function with the `device` - passed explicitly. This wrapper is specifically for the backend implementations - of asarray. + """Determine the correct `device`, and then calls the function with the + `device` passed explicitly. This wrapper is specifically for the + backend implementations of asarray. Parameters ---------- @@ -299,9 +296,8 @@ def arange( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return evenly spaced values within a given interval, with the spacing being - specified. + """Return evenly spaced values within a given interval, with the spacing + being specified. Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function @@ -411,8 +407,7 @@ def asarray( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Convert the input to an array. + """Convert the input to an array. Parameters ---------- @@ -497,8 +492,7 @@ def zeros( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array having a specified ``shape`` and filled with zeros. + """Return a new array having a specified ``shape`` and filled with zeros. Parameters ---------- @@ -562,8 +556,7 @@ def ones( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array having a specified ``shape`` and filled with ones. + """Return a new array having a specified ``shape`` and filled with ones. .. note:: @@ -661,9 +654,8 @@ def full_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array filled with ``fill_value`` and having the same ``shape`` as an - input array ``x`` . + """Return a new array filled with ``fill_value`` and having the same + ``shape`` as an input array ``x`` . Parameters ---------- @@ -769,9 +761,8 @@ def ones_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array filled with ones and having the same shape as an input array - ``x``. + """Return a new array filled with ones and having the same shape as an + input array ``x``. .. note:: @@ -889,9 +880,8 @@ def zeros_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array filled with zeros and having the same ``shape`` as an input array - ``x``. + """Return a new array filled with zeros and having the same ``shape`` as an + input array ``x``. Parameters ---------- @@ -1002,8 +992,8 @@ def tril( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the lower triangular part of a matrix (or a stack of matrices) ``x``. + """Return the lower triangular part of a matrix (or a stack of matrices) + ``x``. .. note:: @@ -1058,8 +1048,8 @@ def triu( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the upper triangular part of a matrix (or a stack of matrices) ``x``. + """Return the upper triangular part of a matrix (or a stack of matrices) + ``x``. .. note:: @@ -1116,8 +1106,7 @@ def empty( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array of given shape and type, filled with zeros. + """Return a new array of given shape and type, filled with zeros. Parameters ---------- @@ -1167,8 +1156,7 @@ def empty_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an uninitialized array with the same shape as an input array x. + """Return an uninitialized array with the same shape as an input array x. Parameters ---------- @@ -1222,8 +1210,8 @@ def eye( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a two-dimensional array with ones on the k diagonal and zeros elsewhere. + """Return a two-dimensional array with ones on the k diagonal and zeros + elsewhere. Parameters ---------- @@ -1365,8 +1353,8 @@ def linspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a certain number of evenly-spaced values in an interval along a given axis. + """Generate a certain number of evenly-spaced values in an interval along a + given axis. See :math:`arange` that allows to specify the step size of evenly spaced values in an interval. @@ -1468,8 +1456,7 @@ def meshgrid( indexing: str = "xy", out: Optional[ivy.Array] = None, ) -> List[ivy.Array]: - """ - Return coordinate matrices from coordinate vectors. + """Return coordinate matrices from coordinate vectors. Parameters ---------- @@ -1593,8 +1580,8 @@ def full( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array having a specified ``shape`` and filled with ``fill_value``. + """Return a new array having a specified ``shape`` and filled with + ``fill_value``. Parameters ---------- @@ -1696,8 +1683,7 @@ def full( def to_dlpack( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ): - """ - Return PyCapsule Object. + """Return PyCapsule Object. Parameters ---------- @@ -1736,9 +1722,8 @@ def to_dlpack( def from_dlpack( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Return a new array containing the data from another (array) object with a - ``__dlpack__`` method or PyCapsule Object. + """Return a new array containing the data from another (array) object with + a ``__dlpack__`` method or PyCapsule Object. Parameters ---------- @@ -1794,8 +1779,7 @@ def copy_array( to_ivy_array: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Copy an array. + """Copy an array. Parameters ---------- @@ -1900,8 +1884,7 @@ def native_array( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> ivy.NativeArray: - """ - Convert the input to a native array. + """Convert the input to a native array. Parameters ---------- @@ -1965,9 +1948,9 @@ def one_hot( device: Union[ivy.Device, ivy.NativeDevice] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a one-hot array. The locations represented by indices in the parameter - indices take value on_value, while all other locations take value off_value. + """Return a one-hot array. The locations represented by indices in the + parameter indices take value on_value, while all other locations take value + off_value. Parameters ---------- @@ -2081,9 +2064,8 @@ def logspace( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a certain number of evenly-spaced values in log space, in an interval along - a given axis. + """Generate a certain number of evenly-spaced values in log space, in an + interval along a given axis. Parameters ---------- @@ -2186,8 +2168,7 @@ def frombuffer( count: Optional[int] = -1, offset: Optional[int] = 0, ) -> ivy.Array: - r""" - Interpret a buffer as a 1-dimensional array. + r"""Interpret a buffer as a 1-dimensional array. .. note:: Note that either of the following must be true: @@ -2252,16 +2233,16 @@ def triu_indices( *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Tuple[ivy.Array]: - """ - Return the indices of the upper triangular part of a row by col matrix in a 2-by-N - shape (tuple of two N dimensional arrays), where the first row contains row - coordinates of all indices and the second row contains column coordinates. Indices - are ordered based on rows and then columns. The upper triangular part of the matrix - is defined as the elements on and above the diagonal. The argument k controls which - diagonal to consider. If k = 0, all elements on and above the main diagonal are - retained. A positive value excludes just as many diagonals above the main diagonal, - and similarly a negative value includes just as many diagonals below the main - diagonal. The main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, + """Return the indices of the upper triangular part of a row by col matrix + in a 2-by-N shape (tuple of two N dimensional arrays), where the first row + contains row coordinates of all indices and the second row contains column + coordinates. Indices are ordered based on rows and then columns. The upper + triangular part of the matrix is defined as the elements on and above the + diagonal. The argument k controls which diagonal to consider. If k = 0, + all elements on and above the main diagonal are retained. A positive value + excludes just as many diagonals above the main diagonal, and similarly a + negative value includes just as many diagonals below the main diagonal. The + main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, n_cols}−1]. Notes diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index e6a9f835c49b3..5e418ff22ec49 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -290,8 +290,8 @@ def astype( copy: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Copy an array to a specified data type irrespective of :ref:`type- promotion` rules. + """Copy an array to a specified data type irrespective of :ref:`type- + promotion` rules. .. note:: Casting floating-point ``NaN`` and ``infinity`` values to integral data types @@ -390,8 +390,7 @@ def astype( @handle_array_function @handle_device def broadcast_arrays(*arrays: Union[ivy.Array, ivy.NativeArray]) -> List[ivy.Array]: - """ - Broadcasts one or more arrays against one another. + """Broadcasts one or more arrays against one another. Parameters ---------- @@ -478,8 +477,7 @@ def broadcast_to( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Broadcasts an array to a specified shape. + """Broadcasts an array to a specified shape. Parameters ---------- @@ -547,9 +545,8 @@ def can_cast( to: ivy.Dtype, /, ) -> bool: - """ - Determine if one data type can be cast to another data type according to :ref:`type- - promotion` rules. + """Determine if one data type can be cast to another data type according to + :ref:`type- promotion` rules. Parameters ---------- @@ -622,8 +619,7 @@ def finfo( type: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray], /, ) -> Finfo: - """ - Machine limits for floating-point data types. + """Machine limits for floating-point data types. Parameters ---------- @@ -710,8 +706,7 @@ def iinfo( type: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray], /, ) -> Iinfo: - """ - Machine limits for integer data types. + """Machine limits for integer data types. Parameters ---------- @@ -787,9 +782,8 @@ def iinfo( def result_type( *arrays_and_dtypes: Union[ivy.Array, ivy.NativeArray, ivy.Dtype] ) -> ivy.Dtype: - """ - Return the dtype that results from applying the type promotion rules (see - :ref:`type-promotion`) to the arguments. + """Return the dtype that results from applying the type promotion rules + (see :ref:`type-promotion`) to the arguments. .. note:: If provided mixed dtypes (e.g., integer and floating-point), the returned dtype @@ -942,8 +936,7 @@ def __exit__(self, exc_type, exc_val, exc_tb): @handle_exceptions def dtype_bits(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str], /) -> int: - """ - Get the number of bits used for representing the input data type. + """Get the number of bits used for representing the input data type. Parameters ---------- @@ -978,8 +971,7 @@ def dtype_bits(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str], /) -> int: @handle_exceptions def is_hashable_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: - """ - Check if the given data type is hashable or not. + """Check if the given data type is hashable or not. Parameters ---------- @@ -1004,8 +996,7 @@ def is_hashable_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: @handle_exceptions def as_ivy_dtype(dtype_in: Union[ivy.Dtype, str], /) -> ivy.Dtype: - """ - Convert native data type to string representation. + """Convert native data type to string representation. Parameters ---------- @@ -1022,8 +1013,7 @@ def as_ivy_dtype(dtype_in: Union[ivy.Dtype, str], /) -> ivy.Dtype: @handle_exceptions def as_native_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> ivy.NativeDtype: - """ - Convert data type string representation to native data type. + """Convert data type string representation to native data type. Parameters ---------- @@ -1059,8 +1049,7 @@ def _check_complex128(input) -> bool: @handle_exceptions def closest_valid_dtype(type: Union[ivy.Dtype, str, None], /) -> Union[ivy.Dtype, str]: - """ - Determine the closest valid datatype to the datatype passed as input. + """Determine the closest valid datatype to the datatype passed as input. Parameters ---------- @@ -1197,8 +1186,7 @@ def default_float_dtype( def infer_default_dtype( dtype: Union[ivy.Dtype, ivy.NativeDtype, str], as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """ - Summary. + """Summary. Parameters ---------- @@ -1654,8 +1642,7 @@ def default_complex_dtype( def dtype( x: Union[ivy.Array, ivy.NativeArray], *, as_native: bool = False ) -> Union[ivy.Dtype, ivy.NativeDtype]: - """ - Get the data type for input array x. + """Get the data type for input array x. Parameters ---------- @@ -1699,10 +1686,10 @@ def dtype( @handle_exceptions @handle_nestable def function_supported_dtypes(fn: Callable, recurse: bool = True) -> Union[Tuple, dict]: - """ - Return the supported data types of the current backend's function. The function - returns a dict containing the supported dtypes for the compositional and primary - implementations in case of partial mixed functions. + """Return the supported data types of the current backend's function. The + function returns a dict containing the supported dtypes for the + compositional and primary implementations in case of partial mixed + functions. Parameters ---------- @@ -1750,10 +1737,10 @@ def function_supported_dtypes(fn: Callable, recurse: bool = True) -> Union[Tuple def function_unsupported_dtypes( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """ - Return the unsupported data types of the current backend's function. The function - returns a dict containing the unsupported dtypes for the compositional and primary - implementations in case of partial mixed functions. + """Return the unsupported data types of the current backend's function. The + function returns a dict containing the unsupported dtypes for the + compositional and primary implementations in case of partial mixed + functions. Parameters ---------- @@ -1799,8 +1786,8 @@ def function_unsupported_dtypes( @handle_exceptions def invalid_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str, None], /) -> bool: - """ - Determine whether the provided data type is not support by the current framework. + """Determine whether the provided data type is not support by the current + framework. Parameters ---------- @@ -1838,8 +1825,7 @@ def is_bool_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is a bool data type. + """Determine whether the input data type is a bool data type. Parameters ---------- @@ -1878,8 +1864,7 @@ def is_int_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is an int data type. + """Determine whether the input data type is an int data type. Parameters ---------- @@ -1954,8 +1939,7 @@ def nested_fun(x): @handle_exceptions def check_float(x: Any) -> bool: - """ - Check if the input is a float or a float-like object. + """Check if the input is a float or a float-like object. Parameters ---------- @@ -1977,8 +1961,7 @@ def is_float_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is a float dtype. + """Determine whether the input data type is a float dtype. Parameters ---------- @@ -2026,8 +2009,7 @@ def is_uint_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is a uint dtype. + """Determine whether the input data type is a uint dtype. Parameters ---------- @@ -2074,8 +2056,7 @@ def is_complex_dtype( dtype_in: Union[ivy.Dtype, str, ivy.Array, ivy.NativeArray, Number], /, ) -> bool: - """ - Determine whether the input data type is a complex dtype. + """Determine whether the input data type is a complex dtype. Parameters ---------- @@ -2123,8 +2104,8 @@ def promote_types( *, array_api_promotion: bool = False, ) -> ivy.Dtype: - """ - Promote the datatypes type1 and type2, returning the data type they promote to. + """Promote the datatypes type1 and type2, returning the data type they + promote to. Parameters ---------- @@ -2158,8 +2139,7 @@ def _promote(query): @handle_exceptions def set_default_dtype(dtype: Union[ivy.Dtype, ivy.NativeDtype, str], /): - """ - Set the datatype `dtype` as default data type. + """Set the datatype `dtype` as default data type. Parameters ---------- @@ -2194,8 +2174,7 @@ def set_default_dtype(dtype: Union[ivy.Dtype, ivy.NativeDtype, str], /): @handle_exceptions def set_default_float_dtype(float_dtype: Union[ivy.Dtype, str], /): - """ - Set the 'float_dtype' as the default data type. + """Set the 'float_dtype' as the default data type. Parameters ---------- @@ -2222,8 +2201,7 @@ def set_default_float_dtype(float_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_int_dtype(int_dtype: Union[ivy.Dtype, str], /): - """ - Set the 'int_dtype' as the default data type. + """Set the 'int_dtype' as the default data type. Parameters ---------- @@ -2250,8 +2228,7 @@ def set_default_int_dtype(int_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_uint_dtype(uint_dtype: Union[ivy.Dtype, str], /): - """ - Set the uint dtype to be default. + """Set the uint dtype to be default. Parameters ---------- @@ -2276,8 +2253,7 @@ def set_default_uint_dtype(uint_dtype: Union[ivy.Dtype, str], /): @handle_exceptions def set_default_complex_dtype(complex_dtype: Union[ivy.Dtype, str], /): - """ - Set the 'complex_dtype' as the default data type. + """Set the 'complex_dtype' as the default data type. Parameters ---------- @@ -2308,9 +2284,8 @@ def type_promote_arrays( x2: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple: - """ - Type promote the input arrays, returning new arrays with the shared correct data - type. + """Type promote the input arrays, returning new arrays with the shared + correct data type. Parameters ---------- @@ -2330,8 +2305,7 @@ def type_promote_arrays( @handle_exceptions def unset_default_dtype(): - """ - Reset the current default dtype to the previous state. + """Reset the current default dtype to the previous state. Examples -------- @@ -2355,8 +2329,7 @@ def unset_default_dtype(): @handle_exceptions def unset_default_float_dtype(): - """ - Reset the current default float dtype to the previous state. + """Reset the current default float dtype to the previous state. Examples -------- @@ -2376,8 +2349,7 @@ def unset_default_float_dtype(): @handle_exceptions def unset_default_int_dtype(): - """ - Reset the current default int dtype to the previous state. + """Reset the current default int dtype to the previous state. Examples -------- @@ -2396,8 +2368,7 @@ def unset_default_int_dtype(): @handle_exceptions def unset_default_uint_dtype(): - """ - Reset the current default uint dtype to the previous state. + """Reset the current default uint dtype to the previous state. Examples -------- @@ -2416,8 +2387,7 @@ def unset_default_uint_dtype(): @handle_exceptions def unset_default_complex_dtype(): - """ - Reset the current default complex dtype to the previous state. + """Reset the current default complex dtype to the previous state. Examples -------- @@ -2437,8 +2407,8 @@ def unset_default_complex_dtype(): @handle_exceptions def valid_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype, str, None], /) -> bool: - """ - Determine whether the provided data type is supported by the current framework. + """Determine whether the provided data type is supported by the current + framework. Parameters ---------- @@ -2477,9 +2447,8 @@ def promote_types_of_inputs( *, array_api_promotion: bool = False, ) -> Tuple[ivy.NativeArray, ivy.NativeArray]: - """ - Promote the dtype of the given native array inputs to a common dtype based on type - promotion rules. + """Promote the dtype of the given native array inputs to a common dtype + based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an @@ -2527,8 +2496,7 @@ def _get_target_dtype(scalar, arr): @handle_exceptions def is_native_dtype(dtype_in: Union[ivy.Dtype, ivy.NativeDtype], /) -> bool: - """ - Determine whether the input dtype is a Native dtype. + """Determine whether the input dtype is a Native dtype. Parameters ---------- diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index d02cbf35ee381..9187040ad1ffc 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -59,8 +59,7 @@ def __init__( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> None: - """ - Initialize the DefaultDevice class. + """Initialize the DefaultDevice class. Parameters ---------- @@ -76,8 +75,7 @@ def __init__( self._dev = device def __enter__(self): - """ - Enter the runtime context related to the specified device. + """Enter the runtime context related to the specified device. Returns ------- @@ -103,8 +101,7 @@ def __exit__( exc_val: Optional[Type[BaseException]], exc_tb: Optional[types.TracebackType], ) -> Union[ivy.Device, str]: - """ - Exit the runtime context related to the specified device. + """Exit the runtime context related to the specified device. Parameters ---------- @@ -178,8 +175,7 @@ def get_all_ivy_arrays_on_dev( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> ivy.Container: - """ - Get all ivy arrays which are currently alive on the specified device. + """Get all ivy arrays which are currently alive on the specified device. Parameters ---------- @@ -214,8 +210,8 @@ def get_all_ivy_arrays_on_dev( @handle_exceptions def num_ivy_arrays_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> int: - """ - Return the number of arrays which are currently alive on the specified device. + """Return the number of arrays which are currently alive on the specified + device. Parameters ---------- @@ -256,9 +252,8 @@ def print_all_ivy_arrays_on_dev( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, attr_only: bool = True, ) -> None: - """ - Print the shape and dtype for all ivy arrays which are currently alive on the - specified device. + """Print the shape and dtype for all ivy arrays which are currently alive + on the specified device. Parameters ---------- @@ -295,9 +290,8 @@ def print_all_ivy_arrays_on_dev( @handle_exceptions def set_soft_device_mode(mode: bool) -> None: - """ - Set the mode of whether to move input arrays to `ivy.default_device()` before - performing an operation. + """Set the mode of whether to move input arrays to `ivy.default_device()` + before performing an operation. Parameter --------- @@ -321,9 +315,8 @@ def set_soft_device_mode(mode: bool) -> None: @handle_exceptions def unset_soft_device_mode() -> None: - """ - Reset the mode of moving input arrays to `ivy.default_device()` before performing an - operation. + """Reset the mode of moving input arrays to `ivy.default_device()` before + performing an operation. Examples -------- @@ -351,8 +344,7 @@ def unset_soft_device_mode() -> None: def dev( x: Union[ivy.Array, ivy.NativeArray], /, *, as_native: bool = False ) -> Union[ivy.Device, ivy.NativeDevice]: - """ - Get the native device handle for input array x. + """Get the native device handle for input array x. Parameters ---------- @@ -390,8 +382,7 @@ def dev( @handle_exceptions def as_ivy_dev(device: Union[ivy.Device, str], /) -> ivy.Device: - """ - Convert device to string representation. + """Convert device to string representation. Parameters ---------- @@ -414,8 +405,7 @@ def as_ivy_dev(device: Union[ivy.Device, str], /) -> ivy.Device: @handle_exceptions def as_native_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> ivy.NativeDevice: - """ - Convert device string representation to native device type. + """Convert device string representation to native device type. Parameters ---------- @@ -459,8 +449,7 @@ def as_native_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> ivy.NativeD @handle_exceptions def clear_cached_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: - """ - Clear memory cache on target device. + """Clear memory cache on target device. Parameters ---------- @@ -479,9 +468,8 @@ def clear_cached_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> N @handle_exceptions def total_mem_on_dev(device: Union[ivy.Device, ivy.NativeDevice], /) -> float: - """ - Get the total amount of memory (in GB) for a given device string. In case of CPU, - the total RAM is returned. + """Get the total amount of memory (in GB) for a given device string. In + case of CPU, the total RAM is returned. Parameters ---------- @@ -523,9 +511,8 @@ def used_mem_on_dev( *, process_specific: bool = False, ) -> float: - """ - Get the used memory (in GB) for a given device string. In case of CPU, the used RAM - is returned. + """Get the used memory (in GB) for a given device string. In case of CPU, + the used RAM is returned. Parameters ---------- @@ -583,9 +570,8 @@ def percent_used_mem_on_dev( *, process_specific: bool = False, ) -> float: - """ - Get the percentage used memory for a given device string. In case of CPU, the used - RAM is returned. + """Get the percentage used memory for a given device string. In case of + CPU, the used RAM is returned. Parameters ---------- @@ -645,8 +631,7 @@ def dev_util( device: Union[ivy.Device, ivy.NativeDevice], /, ) -> float: - """ - Get the current utilization (%) for a given device. + """Get the current utilization (%) for a given device. Parameters ---------- @@ -688,8 +673,7 @@ def dev_util( @handle_exceptions def gpu_is_available() -> bool: - """ - Determine whether a GPU is available to use, with the backend framework. + """Determine whether a GPU is available to use, with the backend framework. Returns ------- @@ -706,8 +690,7 @@ def gpu_is_available() -> bool: @handle_exceptions def num_cpu_cores(*, logical: bool = True) -> int: - """ - Determine the number of cores available in the cpu. + """Determine the number of cores available in the cpu. Parameters ---------- @@ -732,8 +715,7 @@ def num_cpu_cores(*, logical: bool = True) -> int: @handle_exceptions def num_gpus() -> int: - """ - Determine the number of available GPUs, with the backend framework. + """Determine the number of available GPUs, with the backend framework. Returns ------- @@ -750,8 +732,7 @@ def num_gpus() -> int: @handle_exceptions def tpu_is_available() -> bool: - """ - Determine whether a TPU is available to use, with the backend framework. + """Determine whether a TPU is available to use, with the backend framework. Returns ------- @@ -779,12 +760,11 @@ def default_device( item: Optional[Union[list, tuple, dict, ivy.Array, ivy.NativeArray]] = None, as_native: Optional[bool] = None, ) -> Union[ivy.Device, ivy.NativeDevice]: - """ - Return the input device or the default device. If the as_native flag is set, the - device will be converted to a native device. If the item is provided, the item's - device is returned. If the device is not provided, the last default device is - returned. If a default device has not been set, the first gpu is returned if - available, otherwise the cpu is returned. + """Return the input device or the default device. If the as_native flag is + set, the device will be converted to a native device. If the item is + provided, the item's device is returned. If the device is not provided, the + last default device is returned. If a default device has not been set, the + first gpu is returned if available, otherwise the cpu is returned. Parameters ---------- @@ -846,8 +826,7 @@ def default_device( @handle_exceptions def set_default_device(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: - """ - Set the default device to given device instance. + """Set the default device to given device instance. Parameters ---------- @@ -878,8 +857,7 @@ def set_default_device(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: @handle_exceptions def unset_default_device() -> None: - """ - Reset the default device to "cpu". + """Reset the default device to "cpu". Examples -------- @@ -912,8 +890,8 @@ def to_device( stream: Optional[Union[int, Any]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Move the input array x to the desired device, specified by device string. + """Move the input array x to the desired device, specified by device + string. Parameters ---------- @@ -953,9 +931,8 @@ def split_factor( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, /, ) -> float: - """ - Get a device's global split factor, which can be used to scale the device's batch - splitting chunk sizes across the codebase. + """Get a device's global split factor, which can be used to scale the + device's batch splitting chunk sizes across the codebase. If the global split factor is set for a given device, returns the split factor value for the device from the split factors dictionary @@ -991,9 +968,8 @@ def split_factor( def set_split_factor( factor: float, /, *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None ) -> None: - """ - Set the global split factor for a given device, which can be used to scale batch - splitting chunk sizes for the device across the codebase. + """Set the global split factor for a given device, which can be used to + scale batch splitting chunk sizes for the device across the codebase. Parameters ---------- @@ -1050,10 +1026,9 @@ def split_func_call( stop_gradients: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Call a function by splitting its inputs along a given axis, and calling the function - in chunks, rather than feeding the entire input array at once. This can be useful to - reduce memory usage of the device the arrays are on. + """Call a function by splitting its inputs along a given axis, and calling + the function in chunks, rather than feeding the entire input array at once. + This can be useful to reduce memory usage of the device the arrays are on. Parameters ---------- @@ -1226,10 +1201,10 @@ def _get_devices(fn: Callable, complement: bool = True) -> Tuple: def function_supported_devices( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """ - Return the supported devices of the current backend's function. The function returns - a dict containing the supported devices for the compositional and primary - implementations in case of partial mixed functions. + """Return the supported devices of the current backend's function. The + function returns a dict containing the supported devices for the + compositional and primary implementations in case of partial mixed + functions. Parameters ---------- @@ -1278,10 +1253,10 @@ def function_supported_devices( def function_unsupported_devices( fn: Callable, recurse: bool = True ) -> Union[Tuple, dict]: - """ - Return the unsupported devices of the current backend's function. The function - returns a dict containing the unsupported devices for the compositional and primary - implementations in case of partial mixed functions. + """Return the unsupported devices of the current backend's function. The + function returns a dict containing the unsupported devices for the + compositional and primary implementations in case of partial mixed + functions. Parameters ---------- @@ -1327,8 +1302,7 @@ def function_unsupported_devices( class Profiler(abc.ABC): - """ - The profiler class is used to profile the execution of some code. + """The profiler class is used to profile the execution of some code. Parameters ---------- @@ -1341,8 +1315,7 @@ def __init__(self, save_dir: str): @abc.abstractmethod def start(self): - """ - Start the profiler. + """Start the profiler. This should be called before the code to be profiled. """ @@ -1350,8 +1323,7 @@ def start(self): @abc.abstractmethod def stop(self): - """ - Stop the profiler. + """Stop the profiler. This should be called after the code to be profiled. """ diff --git a/ivy/functional/ivy/elementwise.py b/ivy/functional/ivy/elementwise.py index f5468af97cfa7..7997380dec22b 100644 --- a/ivy/functional/ivy/elementwise.py +++ b/ivy/functional/ivy/elementwise.py @@ -36,10 +36,9 @@ def abs( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: # noqa - """ - Calculate the absolute value for each element ``x_i`` of the input array ``x`` - (i.e., the element-wise result has the same magnitude as the respective element in - ``x`` but has positive sign). + """Calculate the absolute value for each element ``x_i`` of the input array + ``x`` (i.e., the element-wise result has the same magnitude as the + respective element in ``x`` but has positive sign). .. note:: For signed integer data types, the absolute value of the minimum representable @@ -140,10 +139,10 @@ def acos( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the principal value of the - inverse cosine, having domain [-1, +1] and codomain [+0, +π], for each element x_i - of the input array x. Each element-wise result is expressed in radians. + """Calculate an implementation-dependent approximation of the principal + value of the inverse cosine, having domain [-1, +1] and codomain [+0, +π], + for each element x_i of the input array x. Each element-wise result is + expressed in radians. **Special cases** @@ -250,10 +249,9 @@ def acosh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the inverse hyperbolic - cosine, having domain ``[+1, +infinity]`` and codomain ``[+0, +infinity]``, for each - element ``x_i`` of the input array ``x``. + """Calculate an implementation-dependent approximation to the inverse + hyperbolic cosine, having domain ``[+1, +infinity]`` and codomain ``[+0, + +infinity]``, for each element ``x_i`` of the input array ``x``. **Special cases** @@ -361,9 +359,8 @@ def add( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the sum for each element ``x1_i`` of the input array ``x1`` with the - respective element ``x2_i`` of the input array ``x2``. + """Calculate the sum for each element ``x1_i`` of the input array ``x1`` + with the respective element ``x2_i`` of the input array ``x2``. **Special cases** @@ -511,11 +508,10 @@ def asin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the principal value of the - inverse sine, having domain ``[-1, +1]`` and codomain ``[-π/2, +π/2]`` for each - element ``x_i`` of the input array ``x``. Each element- wise result is expressed in - radians. + """Calculate an implementation-dependent approximation of the principal + value of the inverse sine, having domain ``[-1, +1]`` and codomain ``[-π/2, + +π/2]`` for each element ``x_i`` of the input array ``x``. Each element- + wise result is expressed in radians. **Special cases** @@ -600,10 +596,10 @@ def asinh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the inverse hyperbolic sine, - having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, - for each element ``x_i`` in the input array ``x``. + """Calculate an implementation-dependent approximation to the inverse + hyperbolic sine, having domain ``[-infinity, +infinity]`` and codomain + ``[-infinity, +infinity]``, for each element ``x_i`` in the input array + ``x``. **Special cases** @@ -709,11 +705,10 @@ def atan( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the principal value of the - inverse tangent, having domain ``[-infinity, +infinity]`` and codomain ``[-π/2, - +π/2]``, for each element ``x_i`` of the input array ``x``. Each element-wise result - is expressed in radians. + """Calculate an implementation-dependent approximation of the principal + value of the inverse tangent, having domain ``[-infinity, +infinity]`` and + codomain ``[-π/2, +π/2]``, for each element ``x_i`` of the input array + ``x``. Each element-wise result is expressed in radians. **Special cases** @@ -794,17 +789,17 @@ def atan2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the inverse tangent of the - quotient ``x1/x2``, having domain ``[-infinity, +infinity] x. [-infinity, - +infinity]`` (where the ``x`` notation denotes the set of ordered pairs of elements - ``(x1_i, x2_i)``) and codomain ``[-π, +π]``, for each pair of elements ``(x1_i, - x2_i)`` of the input arrays ``x1`` and ``x2``, respectively. Each element-wise - result is expressed in radians. The mathematical signs of ``x1_i and x2_i`` - determine the quadrant of each element-wise result. The quadrant (i.e., branch) is - chosen such that each element-wise result is the signed angle in radians between the - ray ending at the origin and passing through the point ``(1,0)`` and the ray ending - at the origin and passing through the point ``(x2_i, x1_i)``. + """Calculate an implementation-dependent approximation of the inverse + tangent of the quotient ``x1/x2``, having domain ``[-infinity, +infinity] + x. [-infinity, +infinity]`` (where the ``x`` notation denotes the set of + ordered pairs of elements ``(x1_i, x2_i)``) and codomain ``[-π, +π]``, for + each pair of elements ``(x1_i, x2_i)`` of the input arrays ``x1`` and + ``x2``, respectively. Each element-wise result is expressed in radians. The + mathematical signs of ``x1_i and x2_i`` determine the quadrant of each + element-wise result. The quadrant (i.e., branch) is chosen such that each + element-wise result is the signed angle in radians between the ray ending + at the origin and passing through the point ``(1,0)`` and the ray ending at + the origin and passing through the point ``(x2_i, x1_i)``. **Special cases** @@ -970,8 +965,8 @@ def atanh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array with the inverse hyperbolic tangent of the elements of ``x``. + """Return a new array with the inverse hyperbolic tangent of the elements + of ``x``. Parameters ---------- @@ -1073,10 +1068,9 @@ def bitwise_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the bitwise AND of the underlying binary representation of each element - ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """Compute the bitwise AND of the underlying binary representation of each + element ``x1_i`` of the input array ``x1`` with the respective element + ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -1167,8 +1161,8 @@ def bitwise_invert( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Inverts (flips) each bit for each element ``x_i`` of the input array ``x``. + """Inverts (flips) each bit for each element ``x_i`` of the input array + ``x``. Parameters ---------- @@ -1245,10 +1239,9 @@ def bitwise_left_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Shifts the bits of each element ``x1_i`` of the input array ``x1`` to the left by - appending ``x2_i`` (i.e., the respective element in the input array ``x2``) zeros to - the right of ``x1_i``. + """Shifts the bits of each element ``x1_i`` of the input array ``x1`` to + the left by appending ``x2_i`` (i.e., the respective element in the input + array ``x2``) zeros to the right of ``x1_i``. Parameters ---------- @@ -1296,10 +1289,9 @@ def bitwise_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the bitwise OR of the underlying binary representation of each element - ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """Compute the bitwise OR of the underlying binary representation of each + element ``x1_i`` of the input array ``x1`` with the respective element + ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -1385,9 +1377,9 @@ def bitwise_right_shift( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Shifts the bits of each element ``x1_i`` of the input array ``x1`` to the right - according to the respective element ``x2_i`` of the input array ``x2``. + """Shifts the bits of each element ``x1_i`` of the input array ``x1`` to + the right according to the respective element ``x2_i`` of the input array + ``x2``. .. note:: This operation must be an arithmetic shift (i.e., sign-propagating) and thus @@ -1501,10 +1493,9 @@ def bitwise_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the bitwise XOR of the underlying binary representation of each element - ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """Compute the bitwise XOR of the underlying binary representation of each + element ``x1_i`` of the input array ``x1`` with the respective element + ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -1606,9 +1597,9 @@ def ceil( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round each element ``x_i`` of the input array ``x`` to the smallest (i.e., closest - to ``-infinity``) integer-valued number that is not less than ``x_i``. + """Round each element ``x_i`` of the input array ``x`` to the smallest + (i.e., closest to ``-infinity``) integer-valued number that is not less + than ``x_i``. **Special cases** @@ -1697,10 +1688,10 @@ def cos( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the cosine, having domain - ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each element ``x_i`` of - the input array ``x``. Each element ``x_i`` is assumed to be expressed in radians. + """Calculate an implementation-dependent approximation to the cosine, + having domain ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for + each element ``x_i`` of the input array ``x``. Each element ``x_i`` is + assumed to be expressed in radians. **Special cases** @@ -1784,10 +1775,9 @@ def cosh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the hyperbolic cosine, having - domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, for each - element ``x_i`` in the input array ``x``. + """Calculate an implementation-dependent approximation to the hyperbolic + cosine, having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, + +infinity]``, for each element ``x_i`` in the input array ``x``. **Special cases** @@ -1904,9 +1894,8 @@ def divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate the division for each element x1_i of the input array x1 with the - respective element x2_i of the input array x2. + r"""Calculate the division for each element x1_i of the input array x1 with + the respective element x2_i of the input array x2. **Special Cases** @@ -2096,9 +2085,8 @@ def equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of x1_i == x2_i for each element x1_i of the input array x1 - with the respective element x2_i of the input array x2. + """Compute the truth value of x1_i == x2_i for each element x1_i of the + input array x1 with the respective element x2_i of the input array x2. Parameters ---------- @@ -2213,11 +2201,11 @@ def exp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the exponential function, - having domain ``[-infinity, +infinity]`` and codomain ``[+0, +infinity]``, for each - element ``x_i`` of the input array ``x`` (``e`` raised to the power of ``x_i``, - where ``e`` is the base of the natural logarithm). + """Calculate an implementation-dependent approximation to the exponential + function, having domain ``[-infinity, +infinity]`` and codomain ``[+0, + +infinity]``, for each element ``x_i`` of the input array ``x`` (``e`` + raised to the power of ``x_i``, where ``e`` is the base of the natural + logarithm). .. note:: For complex floating-point operands, ``exp(conj(x))`` must @@ -2352,9 +2340,8 @@ def imag( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the imaginary part of a complex number for each element ``x_i`` of the input - array ``val``. + """Return the imaginary part of a complex number for each element ``x_i`` + of the input array ``val``. Parameters ---------- @@ -2406,8 +2393,7 @@ def angle( deg: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate Element-wise the angle for an array of complex numbers(x+yj). + """Calculate Element-wise the angle for an array of complex numbers(x+yj). Parameters ---------- @@ -2450,8 +2436,7 @@ def gcd( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the greatest common divisor of |x1| and |x2|. + """Return the greatest common divisor of |x1| and |x2|. Parameters ---------- @@ -2492,8 +2477,7 @@ def exp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate 2**p for all p in the input array. + """Calculate 2**p for all p in the input array. Parameters ---------- @@ -2533,10 +2517,9 @@ def expm1( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to ``exp(x)-1``, having domain - ``[-infinity, +infinity]`` and codomain ``[-1, +infinity]``, for each element - ``x_i`` of the input array ``x``. + """Calculate an implementation-dependent approximation to ``exp(x)-1``, + having domain ``[-infinity, +infinity]`` and codomain ``[-1, +infinity]``, + for each element ``x_i`` of the input array ``x``. .. note:: The purpose of this function is to calculate ``exp(x)-1.0`` more accurately when @@ -2660,9 +2643,9 @@ def floor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round each element ``x_i`` of the input array ``x`` to the greatest (i.e., closest - to ``+infinity``) integer-valued number that is not greater than ``x_i``. + """Round each element ``x_i`` of the input array ``x`` to the greatest + (i.e., closest to ``+infinity``) integer-valued number that is not greater + than ``x_i``. **Special cases** @@ -2751,10 +2734,10 @@ def floor_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Round the result of dividing each element x1_i of the input array x1 by the - respective element x2_i of the input array x2 to the greatest (i.e., closest to - +infinity) integer-value number that is not greater than the division result. + r"""Round the result of dividing each element x1_i of the input array x1 by + the respective element x2_i of the input array x2 to the greatest (i.e., + closest to +infinity) integer-value number that is not greater than the + division result. .. note:: For input arrays which promote to an integer data type, @@ -2949,10 +2932,9 @@ def fmin( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the element-wise minimums of two arrays. Differs from ivy.minimum in the - case where one of the elements is NaN. ivy.minimum returns the NaN element while - ivy.fmin returns the non-NaN element. + """Compute the element-wise minimums of two arrays. Differs from + ivy.minimum in the case where one of the elements is NaN. ivy.minimum + returns the NaN element while ivy.fmin returns the non-NaN element. Parameters ---------- @@ -2997,9 +2979,8 @@ def greater( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of x1_i < x2_i for each element x1_i of the input array x1 - with the respective element x2_i of the input array x2. + """Compute the truth value of x1_i < x2_i for each element x1_i of the + input array x1 with the respective element x2_i of the input array x2. Parameters ---------- @@ -3098,9 +3079,8 @@ def greater_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of x1_i >= x2_i for each element x1_i of the input array x1 - with the respective element x2_i of the input array x2. + """Compute the truth value of x1_i >= x2_i for each element x1_i of the + input array x1 with the respective element x2_i of the input array x2. Parameters ---------- @@ -3185,9 +3165,8 @@ def less_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of x1_i <= x2_i for each element x1_i of the input array x1 - with the respective element x2_i of the input array x2. + """Compute the truth value of x1_i <= x2_i for each element x1_i of the + input array x1 with the respective element x2_i of the input array x2. Parameters ---------- @@ -3272,9 +3251,8 @@ def multiply( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate the product for each element x1_i of the input array x1 with the - respective element x2_i of the input array x2. + r"""Calculate the product for each element x1_i of the input array x1 with + the respective element x2_i of the input array x2. .. note:: Floating-point multiplication is not always associative due to finite precision. @@ -3458,9 +3436,8 @@ def isfinite( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element ``x_i`` of the input array ``x`` to determine if finite (i.e., not - ``NaN`` and not equal to positive or negative infinity). + """Test each element ``x_i`` of the input array ``x`` to determine if + finite (i.e., not ``NaN`` and not equal to positive or negative infinity). Parameters ---------- @@ -3558,9 +3535,8 @@ def isinf( detect_negative: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element x_i of the input array x to determine if equal to positive or - negative infinity. + """Test each element x_i of the input array x to determine if equal to + positive or negative infinity. Parameters ---------- @@ -3681,9 +3657,8 @@ def isnan( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element ``x_i`` of the input array ``x`` to determine whether the element - is ``NaN``. + """Test each element ``x_i`` of the input array ``x`` to determine whether + the element is ``NaN``. Parameters ---------- @@ -3791,9 +3766,9 @@ def less( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of ``x1_i < x2_i`` for each element ``x1_i`` of the input - array ``x1`` with the respective element ``x2_i`` of the input array ``x2``. + """Compute the truth value of ``x1_i < x2_i`` for each element ``x1_i`` of + the input array ``x1`` with the respective element ``x2_i`` of the input + array ``x2``. Parameters ---------- @@ -3881,10 +3856,10 @@ def log( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the natural (base ``e``) - logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, - for each element ``x_i`` of the input array ``x``. + """Calculate an implementation-dependent approximation to the natural (base + ``e``) logarithm, having domain ``[0, +infinity]`` and codomain + ``[-infinity, +infinity]``, for each element ``x_i`` of the input array + ``x``. **Special cases** @@ -3982,10 +3957,9 @@ def log10( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate an implementation-dependent approximation to the base ``10`` logarithm, - having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, for each - element ``x_i`` of the input array ``x``. + r"""Calculate an implementation-dependent approximation to the base ``10`` + logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, + +infinity]``, for each element ``x_i`` of the input array ``x``. **Special cases** @@ -4077,9 +4051,8 @@ def log1p( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to log(1+x), where log refers to - the natural (base e) logarithm. + """Calculate an implementation-dependent approximation to log(1+x), where + log refers to the natural (base e) logarithm. .. note:: The purpose of this function is to calculate ``log(1+x)`` more accurately @@ -4196,10 +4169,9 @@ def log2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate an implementation-dependent approximation to the base ``2`` logarithm, - having domain ``[0, +infinity]`` and codomain ``[-infinity, +infinity]``, for each - element ``x_i`` of the input array ``x``. + r"""Calculate an implementation-dependent approximation to the base ``2`` + logarithm, having domain ``[0, +infinity]`` and codomain ``[-infinity, + +infinity]``, for each element ``x_i`` of the input array ``x``. **Special cases** @@ -4294,10 +4266,9 @@ def logaddexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the logarithm of the sum of exponentiations ``log(exp(x1) + exp(x2))`` for - each element ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` - of the input array ``x2``. + """Calculate the logarithm of the sum of exponentiations ``log(exp(x1) + + exp(x2))`` for each element ``x1_i`` of the input array ``x1`` with the + respective element ``x2_i`` of the input array ``x2``. **Special cases** @@ -4395,8 +4366,7 @@ def logaddexp2( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate log2(2**x1 + 2**x2). + """Calculate log2(2**x1 + 2**x2). Parameters ---------- @@ -4439,9 +4409,8 @@ def logical_and( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logical AND for each element x1_i of the input array x1 with the - respective element x2_i of the input array x2. + """Compute the logical AND for each element x1_i of the input array x1 with + the respective element x2_i of the input array x2. Parameters ---------- @@ -4540,8 +4509,8 @@ def logical_not( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logical NOT for each element ``x_i`` of the input array ``x``. + """Compute the logical NOT for each element ``x_i`` of the input array + ``x``. .. note:: While this specification recommends that this function only accept input arrays @@ -4638,9 +4607,8 @@ def logical_or( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logical OR for each element ``x1_i`` of the input array ``x1`` with the - respective element ``x2_i`` of the input array ``x2``. + """Compute the logical OR for each element ``x1_i`` of the input array + ``x1`` with the respective element ``x2_i`` of the input array ``x2``. .. note:: While this specification recommends that this function only accept input arrays @@ -4730,10 +4698,9 @@ def logical_xor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the bitwise XOR of the underlying binary representation of each element - ``x1_i`` of the input array ``x1`` with the respective element ``x2_i`` of the input - array ``x2``. + """Compute the bitwise XOR of the underlying binary representation of each + element ``x1_i`` of the input array ``x1`` with the respective element + ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -4832,9 +4799,9 @@ def nan_to_num( neginf: Optional[Union[float, int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Replace NaN with zero and infinity with large finite numbers (default behaviour) or - with the numbers defined by the user using the nan, posinf and/or neginf keywords. + """Replace NaN with zero and infinity with large finite numbers (default + behaviour) or with the numbers defined by the user using the nan, posinf + and/or neginf keywords. Parameters ---------- @@ -4891,8 +4858,7 @@ def negative( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array with the negative value of each element in ``x``. + """Return a new array with the negative value of each element in ``x``. .. note:: For signed integer data types, the numerical negative of @@ -4978,9 +4944,9 @@ def not_equal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the truth value of ``x1_i != x2_i`` for each element ``x1_i`` of the input - array ``x1`` with the respective element ``x2_i`` of the input array ``x2``. + """Compute the truth value of ``x1_i != x2_i`` for each element ``x1_i`` of + the input array ``x1`` with the respective element ``x2_i`` of the input + array ``x2``. **Special Cases** @@ -5161,8 +5127,7 @@ def positive( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array with the positive value of each element in ``x``. + """Return a new array with the positive value of each element in ``x``. Parameters ---------- @@ -5238,11 +5203,10 @@ def pow( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of exponentiation by raising - each element ``x1_i`` (the base) of the input array ``x1`` to the power of ``x2_i`` - (the exponent), where ``x2_i`` is the corresponding element of the input array - ``x2``. + """Calculate an implementation-dependent approximation of exponentiation by + raising each element ``x1_i`` (the base) of the input array ``x1`` to the + power of ``x2_i`` (the exponent), where ``x2_i`` is the corresponding + element of the input array ``x2``. **Special cases** @@ -5384,11 +5348,10 @@ def real( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element ``x_i`` of the input array ``x`` to take only real part from it. - Returns a float array, where it only contains . If element has complex type with - zero complex part, the return value will be that element, else it only returns real - part. + """Test each element ``x_i`` of the input array ``x`` to take only real + part from it. Returns a float array, where it only contains . If element + has complex type with zero complex part, the return value will be that + element, else it only returns real part. Parameters ---------- @@ -5457,9 +5420,8 @@ def remainder( modulus: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the remainder of division for each element ``x1_i`` of the input array ``x1`` - and the respective element ``x2_i`` of the input array ``x2``. + """Return the remainder of division for each element ``x1_i`` of the input + array ``x1`` and the respective element ``x2_i`` of the input array ``x2``. .. note:: This function is equivalent to the Python modulus operator ``x1_i % x2_i``. For @@ -5587,9 +5549,8 @@ def round( decimals: Optional[int] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round each element ``x_i`` of the input array ``x`` to the nearest integer-valued - number. + """Round each element ``x_i`` of the input array ``x`` to the nearest + integer-valued number. .. note:: For complex floating-point operands, real and imaginary components @@ -5709,9 +5670,8 @@ def sign( np_variant: Optional[bool] = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Return an indication of the sign of a number for each element ``x_i`` of the input - array ``x``. + r"""Return an indication of the sign of a number for each element ``x_i`` of + the input array ``x``. The sign function (also known as the **signum function**) of a number :math:`x_{i}` is defined as @@ -5818,10 +5778,10 @@ def sin( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate an implementation-dependent approximation to the sine, having domain - ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each element ``x_i`` of - the input array ``x``. Each element ``x_i`` is assumed to be expressed in radians. + r"""Calculate an implementation-dependent approximation to the sine, having + domain ``(-infinity, +infinity)`` and codomain ``[-1, +1]``, for each + element ``x_i`` of the input array ``x``. Each element ``x_i`` is assumed + to be expressed in radians. .. note:: The sine is an entire function on the complex plane and has no branch cuts. @@ -5913,10 +5873,9 @@ def sinh( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate an implementation-dependent approximation to the hyperbolic sine, having - domain ``[-infinity, +infinity]`` and codomain ``[-infinity, +infinity]``, for each - element ``x_i`` of the input array ``x``. + r"""Calculate an implementation-dependent approximation to the hyperbolic + sine, having domain ``[-infinity, +infinity]`` and codomain ``[-infinity, + +infinity]``, for each element ``x_i`` of the input array ``x``. .. math:: \operatorname{sinh}(x) = \frac{e^x - e^{-x}}{2} @@ -6037,11 +5996,10 @@ def sqrt( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Calculate the square root, having domain ``[0, +infinity]`` and codomain ``[0, - +infinity]``, for each element ``x_i`` of the input array ``x``. After rounding, - each result must be indistinguishable from the infinitely precise result (as - required by IEEE 754). + r"""Calculate the square root, having domain ``[0, +infinity]`` and codomain + ``[0, +infinity]``, for each element ``x_i`` of the input array ``x``. + After rounding, each result must be indistinguishable from the infinitely + precise result (as required by IEEE 754). .. note:: After rounding, each result must be indistinguishable @@ -6169,8 +6127,7 @@ def square( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Each element ``x_i`` of the input array ``x``. + """Each element ``x_i`` of the input array ``x``. Parameters ---------- @@ -6244,9 +6201,8 @@ def subtract( alpha: Optional[Union[int, float]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the difference for each element ``x1_i`` of the input array ``x1`` with - the respective element ``x2_i`` of the input array ``x2``. + """Calculate the difference for each element ``x1_i`` of the input array + ``x1`` with the respective element ``x2_i`` of the input array ``x2``. Parameters ---------- @@ -6414,10 +6370,9 @@ def tanh( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation to the hyperbolic tangent, - having domain ``[-infinity, +infinity]`` and codomain ``[-1, +1]``, for each element - ``x_i`` of the input array ``x``. + """Calculate an implementation-dependent approximation to the hyperbolic + tangent, having domain ``[-infinity, +infinity]`` and codomain ``[-1, + +1]``, for each element ``x_i`` of the input array ``x``. **Special cases** @@ -6557,8 +6512,7 @@ def trapz( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Integrate along the given axis using the composite trapezoidal rule. + """Integrate along the given axis using the composite trapezoidal rule. If x is provided, the integration happens in sequence along its elements - they are not sorted.. @@ -6615,9 +6569,8 @@ def trunc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round each element x_i of the input array x to the integer-valued number that is - closest to but no greater than x_i. + """Round each element x_i of the input array x to the integer-valued number + that is closest to but no greater than x_i. **Special cases** @@ -6708,8 +6661,7 @@ def erf( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Gauss error function of ``x`` element-wise. + """Compute the Gauss error function of ``x`` element-wise. Parameters ---------- @@ -6772,8 +6724,7 @@ def maximum( use_where: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the max of x1 and x2 (i.e. x1 > x2 ? x1 : x2) element-wise. + """Return the max of x1 and x2 (i.e. x1 > x2 ? x1 : x2) element-wise. Parameters ---------- @@ -6864,8 +6815,7 @@ def minimum( use_where: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the min of x1 and x2 (i.e. x1 < x2 ? x1 : x2) element-wise. + """Return the min of x1 and x2 (i.e. x1 < x2 ? x1 : x2) element-wise. Parameters ---------- @@ -6955,8 +6905,7 @@ def reciprocal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a new array with the reciprocal of each element in ``x``. + """Return a new array with the reciprocal of each element in ``x``. Parameters ---------- @@ -6994,8 +6943,7 @@ def deg2rad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Convert the input from degrees to radians. + """Convert the input from degrees to radians. Parameters ---------- @@ -7073,8 +7021,7 @@ def rad2deg( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Convert the input from radians to degrees. + """Convert the input from radians to degrees. Parameters ---------- @@ -7151,9 +7098,8 @@ def trunc_divide( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Perform element-wise integer division of the inputs rounding the results towards - zero. + """Perform element-wise integer division of the inputs rounding the results + towards zero. Parameters ---------- @@ -7212,11 +7158,10 @@ def isreal( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test each element ``x_i`` of the input array ``x`` to determine whether the element - is real number. Returns a bool array, where True if input element is real. If - element has complex type with zero complex part, the return value for that element - is True. + """Test each element ``x_i`` of the input array ``x`` to determine whether + the element is real number. Returns a bool array, where True if input + element is real. If element has complex type with zero complex part, the + return value for that element is True. Parameters ---------- @@ -7278,8 +7223,7 @@ def fmod( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the element-wise remainder of divisions of two arrays. + """Compute the element-wise remainder of divisions of two arrays. Parameters ---------- @@ -7322,8 +7266,7 @@ def lcm( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the element-wise least common multiple (LCM) of x1 and x2. + """Compute the element-wise least common multiple (LCM) of x1 and x2. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/activations.py b/ivy/functional/ivy/experimental/activations.py index 1b1fda6b32a08..f9788a93ffadf 100644 --- a/ivy/functional/ivy/experimental/activations.py +++ b/ivy/functional/ivy/experimental/activations.py @@ -53,8 +53,7 @@ def logit( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logit of x. + """Compute the logit of x. logit(x) = log(x / (1 - x)). @@ -107,8 +106,7 @@ def prelu( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Prelu takes input data (Array) and slope array as input, + """Prelu takes input data (Array) and slope array as input, and produces one output data (array) where the function f(x) = slope * x for x < 0, f(x) = x for x >= 0., is applied @@ -165,8 +163,7 @@ def thresholded_relu( threshold: Union[int, float] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the rectified linear unit function with custom threshold. + """Apply the rectified linear unit function with custom threshold. Parameters ---------- @@ -250,8 +247,7 @@ def relu6( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the rectified linear unit 6 function element-wise. + """Apply the rectified linear unit 6 function element-wise. Parameters ---------- @@ -306,8 +302,7 @@ def logsigmoid( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply element-wise Log-sigmoid of x. + """Apply element-wise Log-sigmoid of x. logsigmoid(x) = log(1 / (1 + exp(-x)). @@ -361,8 +356,7 @@ def logsigmoid( def selu( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Apply the scaled exponential linear unit function element-wise. + """Apply the scaled exponential linear unit function element-wise. Parameters ---------- @@ -420,8 +414,7 @@ def selu( def silu( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Apply the silu function element-wise. + """Apply the silu function element-wise. Parameters ---------- @@ -473,8 +466,7 @@ def elu( alpha: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the elu unit function element-wise. + """Apply the elu unit function element-wise. Parameters ---------- @@ -536,8 +528,7 @@ def hardtanh( min_val: float = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the hardtanh unit function element-wise. + """Apply the hardtanh unit function element-wise. Parameters ---------- @@ -596,8 +587,7 @@ def hardtanh( def tanhshrink( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Apply the tanhshrink function element-wise. + """Apply the tanhshrink function element-wise. Parameters ---------- @@ -650,8 +640,7 @@ def softshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the softshrink function element-wise. + """Apply the softshrink function element-wise. Parameters ---------- @@ -738,8 +727,7 @@ def threshold( value: float, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the threshold function element-wise. + """Apply the threshold function element-wise. Parameters ---------- @@ -798,9 +786,8 @@ def celu( complex_mode: Literal["split", "magnitude", "jax"] = "jax", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the Continuously Differentiable Exponential Linear Unit (CELU) activation - function to each element of the input. + """Apply the Continuously Differentiable Exponential Linear Unit (CELU) + activation function to each element of the input. Parameters ---------- @@ -861,8 +848,7 @@ def scaled_tanh( beta: float = 0.67, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the scaled hyperbolic tangent (tanh) activation. + """Compute the scaled hyperbolic tangent (tanh) activation. The scaled tanh activation function is defined as: out = alpha * tanh(beta * x) @@ -940,8 +926,7 @@ def hardshrink( lambd: float = 0.5, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply the hardshrink function element-wise. + """Apply the hardshrink function element-wise. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/creation.py b/ivy/functional/ivy/experimental/creation.py index ff9ed655f1592..f1871a3098b28 100644 --- a/ivy/functional/ivy/experimental/creation.py +++ b/ivy/functional/ivy/experimental/creation.py @@ -33,9 +33,8 @@ def vorbis_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an array that contains a vorbis power complementary window of size - window_length. + """Return an array that contains a vorbis power complementary window of + size window_length. Parameters ---------- @@ -76,9 +75,8 @@ def hann_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a Hann window. The Hanning window is a taper formed by using a weighted - cosine. + """Generate a Hann window. The Hanning window is a taper formed by using a + weighted cosine. Parameters ---------- @@ -125,8 +123,8 @@ def kaiser_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Kaiser window with window length window_length and shape beta. + """Compute the Kaiser window with window length window_length and shape + beta. Parameters ---------- @@ -172,9 +170,8 @@ def kaiser_bessel_derived_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Kaiser bessel derived window with window length window_length and shape - beta. + """Compute the Kaiser bessel derived window with window length + window_length and shape beta. Parameters ---------- @@ -226,8 +223,7 @@ def hamming_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Hamming window with window length window_length. + """Compute the Hamming window with window length window_length. Parameters ---------- @@ -292,16 +288,16 @@ def tril_indices( *, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ) -> Tuple[ivy.Array, ...]: - """ - Return the indices of the lower triangular part of a row by col matrix in a 2-by-N - shape (tuple of two N dimensional arrays), where the first row contains row - coordinates of all indices and the second row contains column coordinates. Indices - are ordered based on rows and then columns. The lower triangular part of the matrix - is defined as the elements on and below the diagonal. The argument k controls which - diagonal to consider. If k = 0, all elements on and below the main diagonal are - retained. A positive value excludes just as many diagonals below the main diagonal, - and similarly a negative value includes just as many diagonals above the main - diagonal. The main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, + """Return the indices of the lower triangular part of a row by col matrix + in a 2-by-N shape (tuple of two N dimensional arrays), where the first row + contains row coordinates of all indices and the second row contains column + coordinates. Indices are ordered based on rows and then columns. The lower + triangular part of the matrix is defined as the elements on and below the + diagonal. The argument k controls which diagonal to consider. If k = 0, + all elements on and below the main diagonal are retained. A positive value + excludes just as many diagonals below the main diagonal, and similarly a + negative value includes just as many diagonals above the main diagonal. The + main diagonal are the set of indices {(i,i)} for i∈[0,min{n_rows, n_cols}−1]. Notes @@ -390,10 +386,9 @@ def eye_like( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a 2D array filled with ones on the k diagonal and zeros elsewhere. having the - same ``shape`` as the first and last dim of input array ``x``. input array ``x`` - should to be 2D. + """Return a 2D array filled with ones on the k diagonal and zeros + elsewhere. having the same ``shape`` as the first and last dim of input + array ``x``. input array ``x`` should to be 2D. Parameters ---------- @@ -483,8 +478,7 @@ def _iter_product(*args, repeat=1): def ndenumerate( input: Iterable, ) -> Generator: - """ - Multidimensional index iterator. + """Multidimensional index iterator. Parameters ---------- @@ -523,8 +517,7 @@ def _ndenumerate(input): def ndindex( shape: Tuple, ) -> Generator: - """ - Multidimensional index iterator. + """Multidimensional index iterator. Parameters ---------- @@ -557,8 +550,7 @@ def indices( dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, sparse: bool = False, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """ - Return an array representing the indices of a grid. + """Return an array representing the indices of a grid. Parameters ---------- @@ -618,9 +610,8 @@ def unsorted_segment_min( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Compute the minimum along segments of an array. Segments are defined by an integer - array of segment IDs. + """Compute the minimum along segments of an array. Segments are defined by + an integer array of segment IDs. Note ---- @@ -658,9 +649,8 @@ def unsorted_segment_sum( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Compute the sum of elements along segments of an array. Segments are defined by an - integer array of segment IDs. + """Compute the sum of elements along segments of an array. Segments are + defined by an integer array of segment IDs. Parameters ---------- @@ -698,10 +688,10 @@ def blackman_window( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a Blackman window. The Blackman window is a taper formed by using the first - three terms of a summation of cosines. It was designed to have close to the minimal - leakage possible. It is close to optimal, only slightly worse than a Kaiser window. + """Generate a Blackman window. The Blackman window is a taper formed by + using the first three terms of a summation of cosines. It was designed to + have close to the minimal leakage possible. It is close to optimal, only + slightly worse than a Kaiser window. Parameters ---------- @@ -747,8 +737,7 @@ def random_tucker( seed: Optional[int] = None, non_negative: Optional[bool] = False, ) -> Union[ivy.TuckerTensor, ivy.Array]: - """ - Generate a random Tucker tensor. + """Generate a random Tucker tensor. Parameters ---------- @@ -817,8 +806,7 @@ def random_cp( seed: Optional[int] = None, normalise_factors: Optional[bool] = True, ) -> Union[ivy.CPTensor, ivy.Array]: - """ - Generate a random CP tensor. + """Generate a random CP tensor. Parameters ---------- @@ -872,8 +860,7 @@ def random_tr( full: Optional[bool] = False, seed: Optional[int] = None, ) -> Union[ivy.TRTensor, ivy.Array]: - """ - Generate a random TR tensor. + """Generate a random TR tensor. Parameters ---------- @@ -931,8 +918,7 @@ def random_parafac2( seed: Optional[int] = None, normalise_factors: Optional[bool] = True, ) -> Union[ivy.Parafac2Tensor, ivy.Array]: - """ - Generate a random PARAFAC2 tensor. + """Generate a random PARAFAC2 tensor. Parameters ---------- @@ -988,8 +974,7 @@ def random_tt( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, seed: Optional[int] = None, ) -> Union[ivy.TTTensor, ivy.Array]: - """ - Generate a random TT/MPS tensor. + """Generate a random TT/MPS tensor. Parameters ---------- @@ -1098,10 +1083,10 @@ def mel_weight_matrix( lower_edge_hertz: float = 0.0, upper_edge_hertz: float = 3000.0, ): - """ - Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a - linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins frequency - information based on the [lower_edge_hertz, upper_edge_hertz] + """Generate a MelWeightMatrix that can be used to re-weight a Tensor + containing a linearly sampled frequency spectra (from DFT or STFT) into + num_mel_bins frequency information based on the [lower_edge_hertz, + upper_edge_hertz] range on the mel scale. This function defines the mel scale in terms of a frequency in hertz according to the following formula: mel(f) = 2595 * log10(1 + f/700) @@ -1149,9 +1134,8 @@ def unsorted_segment_mean( segment_ids: Union[ivy.Array, ivy.NativeArray], num_segments: Union[int, ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Compute the mean of elements along segments of an array. Segments are defined by an - integer array of segment IDs. + """Compute the mean of elements along segments of an array. Segments are + defined by an integer array of segment IDs. Parameters ---------- @@ -1184,8 +1168,7 @@ def polyval( coeffs: Union[ivy.Array, ivy.NativeArray], x: Union[ivy.Array, ivy.NativeArray], ): - """ - Evaluate and return a polynomial at specific given values. + """Evaluate and return a polynomial at specific given values. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/elementwise.py b/ivy/functional/ivy/experimental/elementwise.py index 09a208c346a5b..83025fd5dd56f 100644 --- a/ivy/functional/ivy/experimental/elementwise.py +++ b/ivy/functional/ivy/experimental/elementwise.py @@ -32,8 +32,7 @@ def amax( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the maximum value of the input array ``x``. + """Calculate the maximum value of the input array ``x``. .. note:: ``amax`` is an alias of ``max`` and both function @@ -149,8 +148,7 @@ def amin( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the minimum value of the input array ``x``. + """Calculate the minimum value of the input array ``x``. .. note:: ``amin`` is an alias of ``min`` and both function @@ -265,8 +263,8 @@ def lgamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the natural logarithm of the absolute value of the gamma function on x. + """Compute the natural logarithm of the absolute value of the gamma + function on x. Parameters ---------- @@ -316,11 +314,11 @@ def sinc( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate an implementation-dependent approximation of the principal value of the - normalized sinc function, having domain ``(-infinity, +infinity)`` and codomain - ``[-0.217234, 1]``, for each element ``x_i`` of the input array ``x``. Each element - ``x_i`` is assumed to be expressed in radians. + """Calculate an implementation-dependent approximation of the principal + value of the normalized sinc function, having domain ``(-infinity, + +infinity)`` and codomain ``[-0.217234, 1]``, for each element ``x_i`` of + the input array ``x``. Each element ``x_i`` is assumed to be expressed in + radians. **Special cases** @@ -393,10 +391,9 @@ def fmax( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the element-wise maximums of two arrays. Differs from ivy.maximum in the - case where one of the elements is NaN. ivy.maximum returns the NaN element while - ivy.fmax returns the non-NaN element. + """Compute the element-wise maximums of two arrays. Differs from + ivy.maximum in the case where one of the elements is NaN. ivy.maximum + returns the NaN element while ivy.fmax returns the non-NaN element. Parameters ---------- @@ -439,11 +436,10 @@ def float_power( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Raise each base in x1 to the positionally-corresponding power in x2. x1 and x2 must - be broadcastable to the same shape. This differs from the power function in that - integers, float16, and float32 are promoted to floats with a minimum precision of - float64 so that the result is always inexact. + """Raise each base in x1 to the positionally-corresponding power in x2. x1 + and x2 must be broadcastable to the same shape. This differs from the power + function in that integers, float16, and float32 are promoted to floats with + a minimum precision of float64 so that the result is always inexact. Parameters ---------- @@ -488,9 +484,8 @@ def copysign( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Change the signs of x1 to match x2 x1 and x2 must be broadcastable to a common - shape. + """Change the signs of x1 to match x2 x1 and x2 must be broadcastable to a + common shape. Parameters ---------- @@ -538,8 +533,7 @@ def count_nonzero( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Count the number of non-zero values in the array a. + """Count the number of non-zero values in the array a. Parameters ---------- @@ -598,9 +592,8 @@ def nansum( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as - zero. + """Return the sum of array elements over a given axis treating Not a + Numbers (NaNs) as zero. Parameters ---------- @@ -657,8 +650,8 @@ def isclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a boolean array where two arrays are element-wise equal within a tolerance. + """Return a boolean array where two arrays are element-wise equal within a + tolerance. The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(b)) and the absolute difference @@ -718,8 +711,7 @@ def signbit( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return element-wise True where signbit is set (less than zero). + """Return element-wise True where signbit is set (less than zero). Parameters ---------- @@ -755,8 +747,7 @@ def hypot( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Return the hypotenuse given the two sides of a right angle triangle. + """Return the hypotenuse given the two sides of a right angle triangle. Parameters ---------- @@ -796,8 +787,7 @@ def diff( append: Optional[Union[ivy.Array, ivy.NativeArray, int, list, tuple]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the n-th discrete difference along the given axis. + """Return the n-th discrete difference along the given axis. Parameters ---------- @@ -852,9 +842,8 @@ def allclose( equal_nan: bool = False, out: Optional[ivy.Array] = None, ) -> bool: - """ - Return a True if the two arrays are element-wise equal within given tolerance; - otherwise False. + """Return a True if the two arrays are element-wise equal within given + tolerance; otherwise False. The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(x2)) and the absolute difference @@ -923,9 +912,8 @@ def fix( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Round an array of floats element-wise to nearest integer towards zero. The rounded - values are returned as floats. + """Round an array of floats element-wise to nearest integer towards zero. + The rounded values are returned as floats. Parameters ---------- @@ -963,8 +951,7 @@ def nextafter( *, out: Optional[ivy.Array] = None, ) -> bool: - """ - Return the next floating-point value after x1 towards x2, element-wise. + """Return the next floating-point value after x1 towards x2, element-wise. Parameters ---------- @@ -1005,9 +992,8 @@ def zeta( *, out: Optional[ivy.Array] = None, ) -> bool: - """ - Compute the Hurwitz zeta function elementwisely with each pair of floats in two - arrays. + """Compute the Hurwitz zeta function elementwisely with each pair of floats + in two arrays. Parameters ---------- @@ -1049,8 +1035,7 @@ def gradient( edge_order: int = 1, axis: Optional[Union[int, list, tuple]] = None, ) -> Union[ivy.Array, List[ivy.Array]]: - """ - Calculate gradient of x with respect to (w.r.t.) spacing. + """Calculate gradient of x with respect to (w.r.t.) spacing. Parameters ---------- @@ -1128,8 +1113,7 @@ def xlogy( *, out: Optional[ivy.Array] = None, ) -> bool: - """ - Compute x*log(y) element-wise so that the result is 0 if x = 0. + """Compute x*log(y) element-wise so that the result is 0 if x = 0. Parameters ---------- @@ -1173,9 +1157,8 @@ def binarizer( threshold: float = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Map the values of the input tensor to either 0 or 1, element-wise, based on the - outcome of a comparison against a threshold value. + """Map the values of the input tensor to either 0 or 1, element-wise, based + on the outcome of a comparison against a threshold value. Parameters ---------- @@ -1215,8 +1198,8 @@ def conj( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the complex conjugate for each element ``x_i`` of the input array ``x``. + """Return the complex conjugate for each element ``x_i`` of the input array + ``x``. For complex number of the form @@ -1299,8 +1282,7 @@ def ldexp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return x1 * (2**x2), element-wise. + """Return x1 * (2**x2), element-wise. Parameters ---------- @@ -1342,8 +1324,8 @@ def lerp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a linear interpolation of two arrays start (given by input) and end. + """Return a linear interpolation of two arrays start (given by input) and + end. based on a scalar or array weight. input + weight * (end - input), element-wise. @@ -1469,8 +1451,7 @@ def frexp( *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Decompose the elements of x into mantissa and twos exponent. + """Decompose the elements of x into mantissa and twos exponent. Parameters ---------- @@ -1506,8 +1487,7 @@ def modf( *, out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Decompose the elements of x into fractional and integral parts. + """Decompose the elements of x into fractional and integral parts. Parameters ---------- @@ -1541,8 +1521,7 @@ def digamma( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the logarithmic derivative of the gamma function at x. + """Compute the logarithmic derivative of the gamma function at x. Note ---- @@ -1582,9 +1561,8 @@ def sparsify_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Zeros out all elements in the tensor except `card` elements with maximum absolute - values. + """Zeros out all elements in the tensor except `card` elements with maximum + absolute values. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/general.py b/ivy/functional/ivy/experimental/general.py index cef0bc2091951..144f10256c7be 100644 --- a/ivy/functional/ivy/experimental/general.py +++ b/ivy/functional/ivy/experimental/general.py @@ -39,8 +39,8 @@ def reduce( axes: Union[int, Sequence[int]] = 0, keepdims: bool = False, ) -> ivy.Array: - """ - Reduces the input array's dimensions by applying a function along one or more axes. + """Reduces the input array's dimensions by applying a function along one or + more axes. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/gradients.py b/ivy/functional/ivy/experimental/gradients.py index 8c5466de75168..126a219d890f5 100644 --- a/ivy/functional/ivy/experimental/gradients.py +++ b/ivy/functional/ivy/experimental/gradients.py @@ -3,8 +3,7 @@ def bind_custom_gradient_function(func, custom_grad_func): - """ - Bind a custom gradient function to a function. + """Bind a custom gradient function to a function. Parameters ---------- @@ -23,8 +22,7 @@ def bind_custom_gradient_function(func, custom_grad_func): def vjp(func, *primals): - """ - Compute a (reverse-mode) vector-Jacobian product of `func`. + """Compute a (reverse-mode) vector-Jacobian product of `func`. Parameters ---------- @@ -43,8 +41,7 @@ def vjp(func, *primals): def jvp(func, primals, tangents): - """ - Compute a (forward-mode) Jacobian-vector product of `func`. + """Compute a (forward-mode) Jacobian-vector product of `func`. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index cbda5a5f07232..5f629ef41f639 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -43,8 +43,7 @@ def max_pool1d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D max pool given 3-D input x. + """Compute a 1-D max pool given 3-D input x. Parameters ---------- @@ -131,8 +130,7 @@ def max_pool2d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D max pool given 4-D input x. + """Compute a 2-D max pool given 4-D input x. Parameters ---------- @@ -219,8 +217,7 @@ def max_pool3d( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D max pool given 5-D input x. + """Compute a 3-D max pool given 5-D input x. Parameters ---------- @@ -306,8 +303,7 @@ def avg_pool1d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D avg pool given 3-D input x. + """Compute a 1-D avg pool given 3-D input x. Parameters ---------- @@ -389,8 +385,7 @@ def avg_pool2d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D average pool given 4-D input x. + """Compute a 2-D average pool given 4-D input x. Parameters ---------- @@ -477,8 +472,7 @@ def avg_pool3d( divisor_override: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D avg pool given 5-D input x. + """Compute a 3-D avg pool given 5-D input x. Parameters ---------- @@ -565,8 +559,7 @@ def pool( ceil_mode: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Perform an N-D pooling operation. + """Perform an N-D pooling operation. Parameters ---------- @@ -641,8 +634,7 @@ def dct( norm: Optional[Literal["ortho"]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the 1D Discrete Cosine Transformation of a given signal. + """Compute the 1D Discrete Cosine Transformation of a given signal. Parameters ---------- @@ -752,8 +744,7 @@ def idct( norm: Optional[Literal["ortho"]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Compute the 1D Inverse Discrete Cosine Transformation of a given signal. + """Compute the 1D Inverse Discrete Cosine Transformation of a given signal. Parameters ---------- @@ -876,9 +867,8 @@ def fft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the one dimensional discrete Fourier transform given input at least 1-D - input x. + r"""Compute the one dimensional discrete Fourier transform given input at + least 1-D input x. Parameters ---------- @@ -946,11 +936,10 @@ def dropout1d( data_format: str = "NWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Randomly zero out entire channels with probability prob using samples from a - Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this - case, dropout1d performs a channel-wise dropout but assumes a channel is a 1D - feature map. + """Randomly zero out entire channels with probability prob using samples + from a Bernoulli distribution and the remaining channels are scaled by + (1/1-prob). In this case, dropout1d performs a channel-wise dropout but + assumes a channel is a 1D feature map. Parameters ---------- @@ -1022,11 +1011,10 @@ def dropout2d( data_format: str = "NHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Randomly zero out entire channels with probability prob using samples from a - Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this - case, dropout2d performs a channel-wise dropout but assumes a channel is a 2D - feature map. + """Randomly zero out entire channels with probability prob using samples + from a Bernoulli distribution and the remaining channels are scaled by + (1/1-prob). In this case, dropout2d performs a channel-wise dropout but + assumes a channel is a 2D feature map. Parameters ---------- @@ -1088,11 +1076,10 @@ def dropout3d( data_format: str = "NDHWC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Randomly zero out entire channels with probability prob using samples from a - Bernoulli distribution and the remaining channels are scaled by (1/1-prob). In this - case, dropout3d performs a channel-wise dropout but assumes a channel is a 1D - feature map. + """Randomly zero out entire channels with probability prob using samples + from a Bernoulli distribution and the remaining channels are scaled by + (1/1-prob). In this case, dropout3d performs a channel-wise dropout but + assumes a channel is a 1D feature map. Parameters ---------- @@ -1139,9 +1126,8 @@ def ifft( n: Optional[Union[int, Tuple[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the one dimensional discrete Fourier transform given input at least 1-D - input x. + r"""Compute the one dimensional discrete Fourier transform given input at + least 1-D input x. Parameters ---------- @@ -1208,8 +1194,7 @@ def embedding( max_norm: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Embeds a given tensor of indices using a given tensor of weights. + """Embeds a given tensor of indices using a given tensor of weights. Parameters ---------- @@ -1262,8 +1247,7 @@ def dft( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the discrete Fourier transform of input. + """Compute the discrete Fourier transform of input. Parameters ---------- @@ -1774,9 +1758,8 @@ def interpolate( antialias: bool = False, # ToDo: add support for antialias out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Down/up samples the input to the given size. The algorithm used for interpolation is - determined by mode. + """Down/up samples the input to the given size. The algorithm used for + interpolation is determined by mode. Parameters ---------- @@ -2116,9 +2099,8 @@ def adaptive_max_pool2d( input: Union[ivy.Array, ivy.NativeArray], output_size: Union[Sequence[int], int], ): - """ - Apply a 2D adaptive maximum pooling over an input signal composed of several input - planes. + """Apply a 2D adaptive maximum pooling over an input signal composed of + several input planes. Parameters ---------- @@ -2209,9 +2191,8 @@ def adaptive_avg_pool1d( input: Union[ivy.Array, ivy.NativeArray], output_size: int, ) -> ivy.Array: - """ - Apply a 1D adaptive average pooling over an input signal composed of several input - planes. + """Apply a 1D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -2295,9 +2276,8 @@ def adaptive_avg_pool2d( *, data_format: str = "NHWC", ) -> ivy.Array: - """ - Apply a 2D adaptive average pooling over an input signal composed of several input - planes. + """Apply a 2D adaptive average pooling over an input signal composed of + several input planes. Parameters ---------- @@ -2530,8 +2510,7 @@ def sliding_window( dilation: Union[int, Tuple[int, int]] = 1, padding: Union[str, int, Tuple[int, int]] = "VALID", ) -> ivy.Array: - """ - Slide a window of specified dimension over all elements of an array. + """Slide a window of specified dimension over all elements of an array. Parameters ---------- @@ -2663,8 +2642,7 @@ def reduce_window( base_dilation: Union[int, Sequence[int]] = 1, window_dilation: Union[int, Sequence[int]] = 1, ) -> ivy.Array: - """ - Apply a reduction function to all elements in each window of an array. + """Apply a reduction function to all elements in each window of an array. Parameters ---------- @@ -2740,8 +2718,7 @@ def fft2( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the 2-dimensional discrete Fourier Transform. + r"""Compute the 2-dimensional discrete Fourier Transform. Parameters ---------- @@ -2817,8 +2794,7 @@ def ifftn( norm: str = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the N-dimensional inverse discrete Fourier Transform. + r"""Compute the N-dimensional inverse discrete Fourier Transform. Parameters ---------- @@ -2902,8 +2878,8 @@ def rfft( norm: Literal["backward", "ortho", "forward"] = "backward", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the one-dimensional discrete Fourier transform for real-valued input. + """Compute the one-dimensional discrete Fourier transform for real-valued + input. .. note:: Applying the one-dimensional inverse discrete Fourier transform for @@ -3011,8 +2987,7 @@ def rfftn( norm: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the N-dimensional discrete Fourier Transform for real input. + """Compute the N-dimensional discrete Fourier Transform for real input. Parameters ---------- @@ -3103,8 +3078,7 @@ def stft( name: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Container static method variant of ivy.stft. + """ivy.Container static method variant of ivy.stft. This method simply wraps the function, and so the docstring for ivy.stft also applies to this method with minimal changes. @@ -3197,8 +3171,8 @@ def max_unpool1d( padding: Union[int, Tuple[int]] = 0, data_format: Optional[str] = "NCW", ) -> ivy.Array: - """ - Compute a 1-D max unpooling given the 1-D pooled input x and its indices. + """Compute a 1-D max unpooling given the 1-D pooled input x and its + indices. Parameters ---------- @@ -3291,8 +3265,7 @@ def rnn( zero_output_for_mask: bool = False, return_all_outputs: bool = True, ): - """ - Iterate over the time dimension of a tensor. + """Iterate over the time dimension of a tensor. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index c84cbfd841d05..dd0685bead55b 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -41,8 +41,8 @@ def eigh_tridiagonal( ] = None, tol: Optional[float] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array]]: - """ - Compute the eigenvalues and eigenvectors of a Hermitian tridiagonal matrix. + """Compute the eigenvalues and eigenvectors of a Hermitian tridiagonal + matrix. Parameters ---------- @@ -180,8 +180,7 @@ def diagflat( num_cols: int = -1, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Return a two-dimensional array with the flattened input as a diagonal. + """Return a two-dimensional array with the flattened input as a diagonal. Parameters ---------- @@ -243,9 +242,8 @@ def kron( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Kronecker product, a composite array made of blocks of the second array - scaled by the first. + """Compute the Kronecker product, a composite array made of blocks of the + second array scaled by the first. Parameters ---------- @@ -285,8 +283,7 @@ def matrix_exp( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the matrix exponential of a square matrix. + """Compute the matrix exponential of a square matrix. Parameters ---------- @@ -390,8 +387,7 @@ def eigvals( x: Union[ivy.Array, ivy.NativeArray], /, ) -> ivy.Array: - """ - Compute eigenvalues of x. Returns a set of eigenvalues. + """Compute eigenvalues of x. Returns a set of eigenvalues. Parameters ---------- @@ -437,8 +433,7 @@ def adjoint( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the complex conjugate transpose of x. + """Compute the complex conjugate transpose of x. Parameters ---------- @@ -482,8 +477,8 @@ def solve_triangular( unit_diagonal: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the unique solution to the triangular system of linear equations AX = B. + """Return the unique solution to the triangular system of linear equations + AX = B. Parameters ---------- @@ -540,9 +535,8 @@ def multi_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the dot product of two or more matrices in a single function call, while - selecting the fastest evaluation order. + """Compute the dot product of two or more matrices in a single function + call, while selecting the fastest evaluation order. Parameters ---------- @@ -601,8 +595,7 @@ def cond( p: Optional[Union[int, float, str]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the condition number of x. + """Compute the condition number of x. Parameters ---------- @@ -649,8 +642,7 @@ def kronecker( reverse: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Kronecker product of a list of matrices. + """Kronecker product of a list of matrices. Parameters ---------- @@ -700,8 +692,7 @@ def khatri_rao( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Khatri-Rao product of a sequence of matrices. + """Khatri-Rao product of a sequence of matrices. This can be seen as a column-wise kronecker product. If one matrix only is given, that matrix is directly returned. @@ -805,8 +796,7 @@ def mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - N-mode product of a tensor and a matrix or vector at the specified mode. + """N-mode product of a tensor and a matrix or vector at the specified mode. Parameters ---------- @@ -899,8 +889,8 @@ def multi_mode_dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - N-mode product of a tensor and several matrices or vectors over several modes. + r"""N-mode product of a tensor and several matrices or vectors over several + modes. Parameters ---------- @@ -968,8 +958,7 @@ def multi_mode_dot( def _svd_checks(x, n_eigenvecs=None): - """ - Run common checks to all of the SVD methods. + """Run common checks to all of the SVD methods. Parameters ---------- @@ -1020,11 +1009,10 @@ def svd_flip( /, u_based_decision: Optional[bool] = True, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Sign correction to ensure deterministic output from SVD. Adjusts the columns of u - and the rows of v such that the loadings in the columns in u that are largest in - absolute value are always positive. This function is borrowed from scikit- - learn/utils/extmath.py. + """Sign correction to ensure deterministic output from SVD. Adjusts the + columns of u and the rows of v such that the loadings in the columns in u + that are largest in absolute value are always positive. This function is + borrowed from scikit- learn/utils/extmath.py. Parameters ---------- @@ -1091,9 +1079,8 @@ def make_svd_non_negative( *, nntype: Optional[Literal["nndsvd", "nndsvda"]] = "nndsvd", ) -> Tuple[ivy.Array, ivy.Array]: - """ - Use NNDSVD method to transform SVD results into a non-negative form. This method - leads to more efficient solving with NNMF [1]. + """Use NNDSVD method to transform SVD results into a non-negative form. + This method leads to more efficient solving with NNMF [1]. Parameters ---------- @@ -1183,8 +1170,7 @@ def truncated_svd( compute_uv: bool = True, n_eigenvecs: Optional[int] = None, ) -> Union[ivy.Array, Tuple[ivy.Array, ivy.Array, ivy.Array]]: - """ - Compute a truncated SVD on `x` using the standard SVD. + """Compute a truncated SVD on `x` using the standard SVD. Parameters ---------- @@ -1228,8 +1214,7 @@ def tensor_train( svd: Optional[Literal["truncated_svd"]] = "truncated_svd", verbose: Optional[bool] = False, ) -> ivy.TTTensor: - """ - TT decomposition via recursive SVD. + """TT decomposition via recursive SVD. Decomposes the input into a sequence of order-3 tensors (factors) Also known as Tensor-Train decomposition [1]_ @@ -1359,11 +1344,11 @@ def initialize_tucker( mask: Optional[Union[ivy.Array, ivy.NativeArray]] = None, svd_mask_repeats: Optional[int] = 5, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ - Initialize core and factors used in `tucker`. The type of initialization is set - using `init`. If `init == 'random'` then initialize factor matrices using - `random_state`. If `init == 'svd'` then initialize the `m`th factor matrix using the - `rank` left singular vectors of the `m`th unfolding of the input tensor. + """Initialize core and factors used in `tucker`. The type of initialization + is set using `init`. If `init == 'random'` then initialize factor matrices + using `random_state`. If `init == 'svd'` then initialize the `m`th factor + matrix using the `rank` left singular vectors of the `m`th unfolding of the + input tensor. Parameters ---------- @@ -1475,8 +1460,7 @@ def partial_tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ) -> Tuple[ivy.Array, Sequence[ivy.Array]]: - """ - Partial tucker decomposition via Higher Order Orthogonal Iteration (HOI) + """Partial tucker decomposition via Higher Order Orthogonal Iteration (HOI) Decomposes `tensor` into a Tucker decomposition exclusively along the provided modes. @@ -1624,8 +1608,7 @@ def tucker( verbose: Optional[bool] = False, return_errors: Optional[bool] = False, ): - """ - Tucker decomposition via Higher Order Orthogonal Iteration (HOI) + """Tucker decomposition via Higher Order Orthogonal Iteration (HOI) Decomposes `tensor` into a Tucker decomposition: ``tensor = [| core; factors[0], ...factors[-1] |]`` [1]_ @@ -1761,10 +1744,9 @@ def tt_matrix_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the full tensor whose TT-Matrix decomposition is given by 'factors' Re- - assembles 'factors', which represent a tensor in TT-Matrix format into the - corresponding full tensor. + """Return the full tensor whose TT-Matrix decomposition is given by + 'factors' Re- assembles 'factors', which represent a tensor in TT-Matrix + format into the corresponding full tensor. Parameters ---------- @@ -1832,10 +1814,9 @@ def dot( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the dot product between two arrays `a` and `b` using the current backend's - implementation. The dot product is defined as the sum of the element-wise product of - the input arrays. + """Compute the dot product between two arrays `a` and `b` using the current + backend's implementation. The dot product is defined as the sum of the + element-wise product of the input arrays. Parameters ---------- @@ -1893,8 +1874,7 @@ def general_inner_product( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generalised inner products between tensors. + """Generalised inner products between tensors. Takes the inner product between the last (respectively first) `n_modes` of `a` (respectively `b`) @@ -1983,8 +1963,7 @@ def higher_order_moment( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Higher-Order Moment. + """Compute the Higher-Order Moment. Parameters ---------- @@ -2031,8 +2010,7 @@ def batched_outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a generalized outer product of the tensors. + """Return a generalized outer product of the tensors. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/losses.py b/ivy/functional/ivy/experimental/losses.py index bbe41582b354a..394863b5ddc26 100644 --- a/ivy/functional/ivy/experimental/losses.py +++ b/ivy/functional/ivy/experimental/losses.py @@ -28,13 +28,13 @@ def log_poisson_loss( reduction: str = "none", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the log-likelihood loss between the prediction and the target under the - assumption that the target has a Poisson distribution. Caveat: By default, this is - not the exact loss, but the loss minus a constant term [log(z!)]. That has no effect - for optimization, but does not play well with relative loss comparisons. To compute - an approximation of the log factorial term, specify ``compute_full_loss=True`` to - enable Stirling's Approximation. + """Compute the log-likelihood loss between the prediction and the target + under the assumption that the target has a Poisson distribution. Caveat: By + default, this is not the exact loss, but the loss minus a constant term + [log(z!)]. That has no effect for optimization, but does not play well with + relative loss comparisons. To compute an approximation of the log factorial + term, specify ``compute_full_loss=True`` to enable Stirling's + Approximation. Parameters ---------- @@ -169,8 +169,8 @@ def huber_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Huber loss (smooth L1 loss) between true and predicted values. + """Compute the Huber loss (smooth L1 loss) between true and predicted + values. Parameters ---------- @@ -234,8 +234,7 @@ def smooth_l1_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the smooth L1 loss between two input tensors. + """Compute the smooth L1 loss between two input tensors. Parameters ---------- @@ -363,8 +362,8 @@ def soft_margin_loss( reduction: Optional[str] = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the soft-margin hinge loss between predicted scores and true binary labels. + """Compute the soft-margin hinge loss between predicted scores and true + binary labels. Parameters ---------- @@ -424,8 +423,7 @@ def kl_div( log_target=False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Kullback-Leibler divergence loss between two input tensors + """Compute the Kullback-Leibler divergence loss between two input tensors (conventionally, probability distributions). Parameters @@ -511,8 +509,7 @@ def poisson_nll_loss( eps: float = 1e-8, reduction: str = "mean", ) -> ivy.Array: - r""" - Compute the Poisson Negative Log Likelihood Loss. + r"""Compute the Poisson Negative Log Likelihood Loss. This function calculates the negative log likelihood loss between the `input` and `target`under the assumption that @@ -587,9 +584,9 @@ def hinge_embedding_loss( margin: float = 1.0, reduction: str = "mean", ) -> ivy.Array: - r""" - Measures loss from input `x` and label `y` with values 1 or -1. It evaluates if two - inputs are similar or not, often used for embedding or semi-supervised learning. + r"""Measures loss from input `x` and label `y` with values 1 or -1. It + evaluates if two inputs are similar or not, often used for embedding or + semi-supervised learning. Loss for the `n`-th sample: .. math:: diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index 3f3fd22d9c0cf..8fe94fbf57f2b 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -103,10 +103,10 @@ def flatten( order: Optional[str] = "C", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Flattens input by reshaping it into a one-dimensional tensor. If start_dim or - end_dim are passed, only dimensions starting with start_dim and ending with end_dim - are flattened. The order of elements in input is unchanged. + """Flattens input by reshaping it into a one-dimensional tensor. If + start_dim or end_dim are passed, only dimensions starting with start_dim + and ending with end_dim are flattened. The order of elements in input is + unchanged. Parameters ---------- @@ -260,8 +260,7 @@ def moveaxis( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Move axes of an array to new positions.. + """Move axes of an array to new positions.. Parameters ---------- @@ -310,8 +309,7 @@ def heaviside( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Heaviside step function for each element in x1. + """Compute the Heaviside step function for each element in x1. Parameters ---------- @@ -359,9 +357,9 @@ def flipud( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Flip array in the up/down direction. Flip the entries in each column in the up/down - direction. Rows are preserved, but appear in a different order than before. + """Flip array in the up/down direction. Flip the entries in each column in + the up/down direction. Rows are preserved, but appear in a different order + than before. Parameters ---------- @@ -403,8 +401,7 @@ def vstack( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Stack arrays in sequence vertically (row wise). + """Stack arrays in sequence vertically (row wise). Parameters ---------- @@ -448,8 +445,7 @@ def hstack( *, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Stack arrays in sequence horizotally (column wise). + """Stack arrays in sequence horizotally (column wise). Parameters ---------- @@ -495,9 +491,8 @@ def rot90( axes: Tuple[int, int] = (0, 1), out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Rotate an array by 90 degrees in the plane specified by axes. Rotation direction is - from the first towards the second axis. + """Rotate an array by 90 degrees in the plane specified by axes. Rotation + direction is from the first towards the second axis. Parameters ---------- @@ -583,8 +578,8 @@ def top_k( sorted: bool = True, out: Optional[tuple] = None, ) -> Tuple[ivy.Array, ivy.NativeArray]: - """ - Return the `k` largest elements of the given input array along a given axis. + """Return the `k` largest elements of the given input array along a given + axis. Parameters ---------- @@ -662,10 +657,9 @@ def fliplr( copy: Optional[bool] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Flip array in the left/right direction. Flip the entries in each column in the - left/right direction. Columns are preserved, but appear in a different order than - before. + """Flip array in the left/right direction. Flip the entries in each column + in the left/right direction. Columns are preserved, but appear in a + different order than before. Parameters ---------- @@ -708,8 +702,7 @@ def i0( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the Bessel i0 function of x element-wise. + """Compute the Bessel i0 function of x element-wise. Parameters ---------- @@ -1053,8 +1046,7 @@ def pad( reflect_type: Literal["even", "odd"] = "even", **kwargs: Optional[Any], ) -> ivy.Array: - """ - Pad an array. + """Pad an array. Parameters ---------- @@ -1293,8 +1285,7 @@ def vsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Split an array vertically into multiple sub-arrays. + """Split an array vertically into multiple sub-arrays. Parameters ---------- @@ -1344,8 +1335,7 @@ def dsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Split an array into multiple sub-arrays along the 3rd axis. + """Split an array into multiple sub-arrays along the 3rd axis. Parameters ---------- @@ -1395,9 +1385,9 @@ def atleast_1d( *arys: Union[ivy.Array, ivy.NativeArray, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Convert inputs to arrays with at least one dimension. Scalar inputs are converted to - 1-dimensional arrays, whilst higher-dimensional inputs are preserved. + """Convert inputs to arrays with at least one dimension. Scalar inputs are + converted to 1-dimensional arrays, whilst higher-dimensional inputs are + preserved. Parameters ---------- @@ -1440,8 +1430,7 @@ def dstack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Stack arrays in sequence depth wise (along third axis). + """Stack arrays in sequence depth wise (along third axis). Parameters ---------- @@ -1481,9 +1470,9 @@ def atleast_2d( *arys: Union[ivy.Array, ivy.NativeArray], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Convert inputs to arrays with at least two dimension. Scalar inputs are converted to - 2-dimensional arrays, whilst higher-dimensional inputs are preserved. + """Convert inputs to arrays with at least two dimension. Scalar inputs are + converted to 2-dimensional arrays, whilst higher-dimensional inputs are + preserved. Parameters ---------- @@ -1527,9 +1516,9 @@ def atleast_3d( *arys: Union[ivy.Array, ivy.NativeArray, bool, Number], copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Convert inputs to arrays with at least three dimension. Scalar inputs are converted - to 3-dimensional arrays, whilst higher-dimensional inputs are preserved. + """Convert inputs to arrays with at least three dimension. Scalar inputs + are converted to 3-dimensional arrays, whilst higher-dimensional inputs are + preserved. Parameters ---------- @@ -1588,8 +1577,7 @@ def take_along_axis( mode: str = "fill", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Take values from the input array by matching 1d index and data slices. + """Take values from the input array by matching 1d index and data slices. Parameters ---------- @@ -1639,8 +1627,7 @@ def hsplit( *, copy: Optional[bool] = None, ) -> List[ivy.Array]: - """ - Split an array into multiple sub-arrays horizontally. + """Split an array into multiple sub-arrays horizontally. Parameters ---------- @@ -1686,8 +1673,7 @@ def hsplit( @handle_exceptions @inputs_to_native_shapes def broadcast_shapes(*shapes: Union[List[int], List[Tuple]]) -> Tuple[int]: - """ - Broadcasts shapes. + """Broadcasts shapes. Parameters ---------- @@ -1728,8 +1714,8 @@ def expand( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Broadcast the input Array following the given shape and the broadcast rule. + """Broadcast the input Array following the given shape and the broadcast + rule. Parameters ---------- @@ -1770,9 +1756,8 @@ def put_along_axis( mode: Literal["sum", "min", "max", "mul", "mean", "replace"] = "replace", out: Optional[ivy.Array] = None, ) -> None: - """ - Put values into the input array by matching 1d index and data slices along a - specified axis. + """Put values into the input array by matching 1d index and data slices + along a specified axis. Parameters ---------- @@ -1865,8 +1850,7 @@ def as_strided( strides: Sequence[int], /, ) -> ivy.Array: - """ - Create a copy of the input array with the given shape and strides. + """Create a copy of the input array with the given shape and strides. Parameters ---------- @@ -1947,8 +1931,7 @@ def concat_from_sequence( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Concatenate a sequence of arrays along a new or an existing axis. + """Concatenate a sequence of arrays along a new or an existing axis. Parameters ---------- @@ -2054,8 +2037,7 @@ def associative_scan( reverse: bool = False, axis: int = 0, ) -> ivy.Array: - """ - Perform an associative scan over the given array. + """Perform an associative scan over the given array. Parameters ---------- @@ -2140,9 +2122,8 @@ def unique_consecutive( Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray], ]: - """ - Eliminates all but the first element from every consecutive group of equivalent - elements in ``x``. + """Eliminates all but the first element from every consecutive group of + equivalent elements in ``x``. Parameters ---------- @@ -2188,8 +2169,7 @@ def fill_diagonal( *, wrap: bool = False, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Fill the main diagonal of the given array of any dimensionality.. + """Fill the main diagonal of the given array of any dimensionality.. Parameters ---------- @@ -2255,8 +2235,7 @@ def unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the mode-`mode` unfolding of `tensor` with modes starting at `0`. + """Return the mode-`mode` unfolding of `tensor` with modes starting at `0`. Parameters ---------- @@ -2289,9 +2268,9 @@ def fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Refolds the mode-`mode` unfolding into a tensor of shape `shape` In other words, - refolds the n-mode unfolded tensor into the original tensor of the specified shape. + """Refolds the mode-`mode` unfolding into a tensor of shape `shape` In + other words, refolds the n-mode unfolded tensor into the original tensor of + the specified shape. Parameters ---------- @@ -2331,11 +2310,11 @@ def partial_unfold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Partial unfolding of a tensor while ignoring the specified number of dimensions at - the beginning and the end. For instance, if the first dimension of the tensor is the - number of samples, to unfold each sample, set skip_begin=1. This would, for each i - in ``range(tensor.shape[0])``, unfold ``tensor[i, ...]``. + """Partial unfolding of a tensor while ignoring the specified number of + dimensions at the beginning and the end. For instance, if the first + dimension of the tensor is the number of samples, to unfold each sample, + set skip_begin=1. This would, for each i in ``range(tensor.shape[0])``, + unfold ``tensor[i, ...]``. Parameters ---------- @@ -2388,8 +2367,7 @@ def partial_fold( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Re-folds a partially unfolded tensor. + """Re-folds a partially unfolded tensor. Parameters ---------- @@ -2431,9 +2409,8 @@ def partial_tensor_to_vec( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Partial vectorization of a tensor while ignoring the specified dimension at the - beginning and the end. + """Partial vectorization of a tensor while ignoring the specified dimension + at the beginning and the end. Parameters ---------- @@ -2476,8 +2453,7 @@ def partial_vec_to_tensor( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Refolds a partially vectorised tensor into a full one. + """Refolds a partially vectorised tensor into a full one. Parameters ---------- @@ -2512,8 +2488,7 @@ def matricize( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Matricizes the given tensor. + """Matricizes the given tensor. Parameters ---------- @@ -2570,8 +2545,7 @@ def soft_thresholding( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Soft-thresholding operator. + """Soft-thresholding operator. sign(tensor) * max[abs(tensor) - threshold, 0] @@ -2631,8 +2605,7 @@ def choose( out: None = None, mode: Union[str, None] = None, ) -> ivy.Array: - """ - Take values from the input array by matching 1d index and data slices. + """Take values from the input array by matching 1d index and data slices. Parameters ---------- @@ -2678,8 +2651,7 @@ def column_stack( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Create a new array by horizontally stacking the arrays in arrays. + """Create a new array by horizontally stacking the arrays in arrays. Equivalent to `ivy.hstack(arrays)`, except each zero or one dimensional array `x` in arrays is first reshaped into a `(x.size(), 1)` column @@ -2751,8 +2723,7 @@ def take( fill_value: Optional[Number] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return elements of an array along an axis. + """Return elements of an array along an axis. .. note:: Conceptually, take(x, indices, axis=3) is equivalent to x[:,:,:,indices,...]; @@ -2859,10 +2830,9 @@ def trim_zeros( *, trim: Optional[str] = "fb", ) -> ivy.Array: - """ - ivy.Container instance method variant of ivy.trim_zeros. This method simply wraps - the function, and so the docstring for ivy.trim_zeros also applies to this method - with minimal changes. + """ivy.Container instance method variant of ivy.trim_zeros. This method + simply wraps the function, and so the docstring for ivy.trim_zeros also + applies to this method with minimal changes. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/norms.py b/ivy/functional/ivy/experimental/norms.py index 236e0deb967d7..5418c3fb50df8 100644 --- a/ivy/functional/ivy/experimental/norms.py +++ b/ivy/functional/ivy/experimental/norms.py @@ -120,11 +120,11 @@ def local_response_norm( data_format: Optional[Literal["NHWC", "NCHW"]] = "NHWC", out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None, ) -> ivy.Array: - """ - Apply local response normalization across the channels of a 4D input array. The 4-D - array is treated as a 3-D array of 1-D vectors (along the channel dimension), and - each vector is normalized independently. Within a given vector, each component is - divided by the squared sum of the neighbouring components. + """Apply local response normalization across the channels of a 4D input + array. The 4-D array is treated as a 3-D array of 1-D vectors (along the + channel dimension), and each vector is normalized independently. Within a + given vector, each component is divided by the squared sum of the + neighbouring components. Parameters ---------- @@ -453,8 +453,8 @@ def group_norm( data_format: Optional[str] = "NSC", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply group normalization to the input array and returns the normalized input. + """Apply group normalization to the input array and returns the normalized + input. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/random.py b/ivy/functional/ivy/experimental/random.py index 5a653147a385a..e2fc3828473dc 100644 --- a/ivy/functional/ivy/experimental/random.py +++ b/ivy/functional/ivy/experimental/random.py @@ -29,11 +29,10 @@ def dirichlet( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draw size samples of dimension k from a Dirichlet distribution. A Dirichlet- - distributed random variable can be seen as a multivariate generalization of a Beta - distribution. The Dirichlet distribution is a conjugate prior of a multinomial - distribution in Bayesian inference. + """Draw size samples of dimension k from a Dirichlet distribution. A + Dirichlet- distributed random variable can be seen as a multivariate + generalization of a Beta distribution. The Dirichlet distribution is a + conjugate prior of a multinomial distribution in Bayesian inference. Parameters ---------- @@ -99,8 +98,8 @@ def beta( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an array filled with random values sampled from a beta distribution. + """Return an array filled with random values sampled from a beta + distribution. Parameters ---------- @@ -154,8 +153,8 @@ def gamma( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an array filled with random values sampled from a gamma distribution. + """Return an array filled with random values sampled from a gamma + distribution. Parameters ---------- @@ -205,8 +204,7 @@ def poisson( fill_value: Optional[Union[int, float]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from a poisson distribution. + """Draws samples from a poisson distribution. Parameters ---------- @@ -276,9 +274,8 @@ def bernoulli( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from Bernoulli distribution parameterized by probs or logits (but not - both) + """Draws samples from Bernoulli distribution parameterized by probs or + logits (but not both) Parameters ---------- diff --git a/ivy/functional/ivy/experimental/searching.py b/ivy/functional/ivy/experimental/searching.py index 25c8928a55f9e..69c7045f95e42 100644 --- a/ivy/functional/ivy/experimental/searching.py +++ b/ivy/functional/ivy/experimental/searching.py @@ -23,8 +23,8 @@ def unravel_index( *, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array]: - """ - Convert a flat index or array of flat indices into a tuple of coordinate arrays. + """Convert a flat index or array of flat indices into a tuple of coordinate + arrays. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/sorting.py b/ivy/functional/ivy/experimental/sorting.py index 0d2d18ddf3c88..0d170828570eb 100644 --- a/ivy/functional/ivy/experimental/sorting.py +++ b/ivy/functional/ivy/experimental/sorting.py @@ -22,8 +22,7 @@ def invert_permutation( x: Union[ivy.Array, ivy.NativeArray, list, tuple], /, ) -> ivy.Array: - """ - Compute the inverse of an index permutation. + """Compute the inverse of an index permutation. Parameters ---------- @@ -62,11 +61,11 @@ def lexsort( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Perform an indirect stable sort with an array of keys in ascending order, with the - last key used as primary sort order, second-to-last for secondary, and so on. Each - row of the key must have the same length, which will also be the length of the - returned array of integer indices, which describes the sort order. + """Perform an indirect stable sort with an array of keys in ascending + order, with the last key used as primary sort order, second-to-last for + secondary, and so on. Each row of the key must have the same length, which + will also be the length of the returned array of integer indices, which + describes the sort order. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/statistical.py b/ivy/functional/ivy/experimental/statistical.py index ce8ecd50e4693..bf69d12cd5cf2 100644 --- a/ivy/functional/ivy/experimental/statistical.py +++ b/ivy/functional/ivy/experimental/statistical.py @@ -38,8 +38,7 @@ def histogram( density: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the histogram of the array ``a``. + """Compute the histogram of the array ``a``. .. note:: Given bins = [c0, ..., cK], defining intervals I0 = [c0, c1), I1 = [c1, c2), @@ -165,8 +164,7 @@ def median( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the median along the specified axis. + """Compute the median along the specified axis. Parameters ---------- @@ -213,8 +211,7 @@ def nanmean( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the mean of all non-NaN elements along the specified dimensions. + """Compute the mean of all non-NaN elements along the specified dimensions. Parameters ---------- @@ -269,8 +266,7 @@ def nanmin( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return minimum of an array or minimum along an axis, ignoring any NaNs. + """Return minimum of an array or minimum along an axis, ignoring any NaNs. Parameters ---------- @@ -333,9 +329,8 @@ def nanprod( initial: Optional[Union[int, float, complex]] = None, where: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the product of array elements over a given axis treating Not a Numbers - (NaNs) as ones. + """Compute the product of array elements over a given axis treating Not a + Numbers (NaNs) as ones. Parameters ---------- @@ -399,8 +394,7 @@ def quantile( interpolation: str = "linear", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the q-th quantile of the data along the specified axis. + """Compute the q-th quantile of the data along the specified axis. Parameters ---------- @@ -502,10 +496,9 @@ def nanmedian( overwrite_input: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - ivy.Array instance method variant of ivy.nanmedian. This method simply wraps the - function, and so the docstring for ivy.nanmedian also applies to this method with - minimal changes. + """ivy.Array instance method variant of ivy.nanmedian. This method simply + wraps the function, and so the docstring for ivy.nanmedian also applies to + this method with minimal changes. Parameters ---------- @@ -574,8 +567,7 @@ def bincount( minlength: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Count the number of occurrences of each value in an integer array. + """Count the number of occurrences of each value in an integer array. Parameters ---------- @@ -617,8 +609,7 @@ def igamma( x: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> ivy.Array: - """ - Compute the regularized lower gamma function of ``a`` and ``x``. + """Compute the regularized lower gamma function of ``a`` and ``x``. Parameters ---------- @@ -662,8 +653,7 @@ def cov( aweights: Optional[ivy.Array] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ) -> ivy.Array: - """ - Compute the covariance of matrix x1, or variables x1 and x2. + """Compute the covariance of matrix x1, or variables x1 and x2. Parameters ---------- @@ -806,9 +796,9 @@ def cummax( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a tuple containing the cumulative maximum of elements of input along the - given axis and index location of each maximum value found along the given axis. + """Return a tuple containing the cumulative maximum of elements of input + along the given axis and index location of each maximum value found along + the given axis. Parameters ---------- @@ -907,8 +897,7 @@ def cummin( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the cumulative minimum of the elements along a given axis. + """Return the cumulative minimum of the elements along a given axis. Parameters ---------- diff --git a/ivy/functional/ivy/experimental/utility.py b/ivy/functional/ivy/experimental/utility.py index e33383151b01c..f16428089885c 100644 --- a/ivy/functional/ivy/experimental/utility.py +++ b/ivy/functional/ivy/experimental/utility.py @@ -16,11 +16,10 @@ def optional_get_element( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - If the input is a tensor or sequence type, it returns the input. If the input is an - optional type, it outputs the element in the input. It is an error if the input is - an empty optional-type (i.e. does not have an element) and the behavior is undefined - in this case. + """If the input is a tensor or sequence type, it returns the input. If the + input is an optional type, it outputs the element in the input. It is an + error if the input is an empty optional-type (i.e. does not have an + element) and the behavior is undefined in this case. Parameters ---------- diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index 22beed2e3cc2d..ab09c25b25d43 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -94,9 +94,9 @@ def __exit__(self, exc_type, exc_val, exc_tb): @handle_exceptions def set_precise_mode(mode: bool) -> None: - """ - Set the mode of whether to use a promotion table that avoids any precision loss or a - compute efficient table that avoids most wider-than- necessary promotions. + """Set the mode of whether to use a promotion table that avoids any + precision loss or a compute efficient table that avoids most wider-than- + necessary promotions. Parameter --------- @@ -122,9 +122,9 @@ def set_precise_mode(mode: bool) -> None: @handle_exceptions def unset_precise_mode() -> None: - """ - Reset the mode of whether to use a promotion table that avoids any precision loss or - a compute efficient table that avoids most wider-than- necessary promotions. + """Reset the mode of whether to use a promotion table that avoids any + precision loss or a compute efficient table that avoids most wider-than- + necessary promotions. Examples -------- @@ -187,8 +187,7 @@ def get_referrers_recursive( seen_set: Optional[set] = None, local_set: Optional[set] = None, ) -> ivy.Container: - """ - Recursively retrieve referrers for an object. + """Recursively retrieve referrers for an object. This function recursively fetches referrers for the specified `item` up to a given `max_depth`. @@ -285,8 +284,7 @@ def get_referrers_recursive_inner(): def is_native_array( x: Union[ivy.Array, ivy.NativeArray], /, *, exclusive: bool = False ) -> bool: - """ - Determine whether the input x is an :class:`ivy.NativeArray` instance. + """Determine whether the input x is an :class:`ivy.NativeArray` instance. Parameters ---------- @@ -322,8 +320,7 @@ def is_native_array( def is_ivy_array( x: Union[ivy.Array, ivy.NativeArray], /, *, exclusive: Optional[bool] = False ) -> bool: - """ - Determine whether the input x is a valid Ivy Array. + """Determine whether the input x is a valid Ivy Array. Parameters ---------- @@ -354,8 +351,7 @@ def is_ivy_array( @handle_exceptions @handle_backend_invalid def is_array(x: Any, /, *, exclusive: bool = False) -> bool: - """ - Determine whether the input x is either an Ivy Array or a Native Array. + """Determine whether the input x is either an Ivy Array or a Native Array. Parameters ---------- @@ -391,8 +387,7 @@ def is_array(x: Any, /, *, exclusive: bool = False) -> bool: @handle_exceptions def is_ivy_container(x: Any, /) -> bool: - """ - Determine whether the input x is an Ivy Container. + """Determine whether the input x is an Ivy Container. Parameters ---------- @@ -422,9 +417,8 @@ def is_ivy_container(x: Any, /) -> bool: @handle_exceptions def set_array_mode(mode: bool) -> None: - """ - Set the mode of whether to convert inputs to ivy.NativeArray, then convert outputs - back to ivy.Array. + """Set the mode of whether to convert inputs to ivy.NativeArray, then + convert outputs back to ivy.Array. It Stops the conversion of ivy.NativeArray to ivy.Array in the case when it is set to False. @@ -452,9 +446,8 @@ def set_array_mode(mode: bool) -> None: @handle_exceptions def unset_array_mode() -> None: - """ - Reset the mode of converting inputs to ivy.NativeArray, then converting outputs back - to ivy.Array to the previous state. + """Reset the mode of converting inputs to ivy.NativeArray, then converting + outputs back to ivy.Array to the previous state. Examples -------- @@ -478,8 +471,7 @@ def unset_array_mode() -> None: @handle_exceptions def set_nestable_mode(mode: bool) -> None: - """ - Set the mode of whether to check if function inputs are ivy.Container. + """Set the mode of whether to check if function inputs are ivy.Container. Parameter --------- @@ -504,9 +496,8 @@ def set_nestable_mode(mode: bool) -> None: @handle_exceptions def unset_nestable_mode() -> None: - """ - Reset the mode of whether to check if function inputs are ivy.Container to the - previous state. + """Reset the mode of whether to check if function inputs are ivy.Container + to the previous state. Examples -------- @@ -532,9 +523,9 @@ def unset_nestable_mode() -> None: @handle_exceptions def set_exception_trace_mode(mode: Literal["ivy", "full", "frontend"]) -> None: - """ - Set the mode of whether to show frontend-truncated exception stack traces, ivy- - truncated exception stack traces or full exception stack traces. + """Set the mode of whether to show frontend-truncated exception stack + traces, ivy- truncated exception stack traces or full exception stack + traces. Parameter --------- @@ -562,8 +553,7 @@ def set_exception_trace_mode(mode: Literal["ivy", "full", "frontend"]) -> None: @handle_exceptions def unset_exception_trace_mode() -> None: - """ - Reset the trace mode to the previously set mode. + """Reset the trace mode to the previously set mode. Examples -------- @@ -591,8 +581,8 @@ def unset_exception_trace_mode() -> None: @handle_exceptions def set_show_func_wrapper_trace_mode(mode: bool) -> None: - """ - Set the mode of whether to show the full stack trace with function wrapping traces. + """Set the mode of whether to show the full stack trace with function + wrapping traces. Parameter --------- @@ -617,9 +607,8 @@ def set_show_func_wrapper_trace_mode(mode: bool) -> None: @handle_exceptions def unset_show_func_wrapper_trace_mode() -> None: - """ - Reset the mode of whether to show the full stack trace with function wrapping - traces. + """Reset the mode of whether to show the full stack trace with function + wrapping traces. Examples -------- @@ -654,8 +643,7 @@ def array_equal( x1: Union[ivy.Array, ivy.NativeArray], /, ) -> bool: - """ - Determine whether two input arrays are equal across all elements. + """Determine whether two input arrays are equal across all elements. Parameters ---------- @@ -699,8 +687,7 @@ def array_equal( def all_equal( *xs: Iterable[Any], equality_matrix: bool = False ) -> Union[bool, ivy.Array, ivy.NativeArray]: - """ - Determine whether the inputs are all equal. + """Determine whether the inputs are all equal. Parameters ---------- @@ -793,8 +780,7 @@ def all_equal( def to_numpy( x: Union[ivy.Array, ivy.NativeArray], /, *, copy: bool = True ) -> np.ndarray: - """ - Convert an array into a numpy array. + """Convert an array into a numpy array. Parameters ---------- @@ -864,8 +850,7 @@ def isscalar(x: Any, /) -> bool: @handle_array_function @handle_device def to_scalar(x: Union[ivy.Array, ivy.NativeArray], /) -> Number: - """ - Convert an array with a single element into a scalar. + """Convert an array with a single element into a scalar. Parameters ---------- @@ -921,8 +906,7 @@ def to_scalar(x: Union[ivy.Array, ivy.NativeArray], /) -> Number: @handle_array_function @handle_device def to_list(x: Union[ivy.Array, ivy.NativeArray], /) -> List: - """ - Create a (possibly nested) list from input array. + """Create a (possibly nested) list from input array. Parameters ---------- @@ -999,8 +983,7 @@ def clip_vector_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Clips (limits) the vector p-norm of an array. + """Clips (limits) the vector p-norm of an array. Parameters ---------- @@ -1099,8 +1082,7 @@ def clip_matrix_norm( p: float = 2.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Clips (limits) the matrix norm of an array. + """Clips (limits) the matrix norm of an array. Parameters ---------- @@ -1183,8 +1165,7 @@ def fourier_encode( concat: bool = True, flatten: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Tuple]: - """ - Pad an array with fourier encodings. + """Pad an array with fourier encodings. Parameters ---------- @@ -1284,8 +1265,7 @@ def value_is_nan( *, include_infs: bool = True, ) -> bool: - """ - Determine whether the single valued array or scalar is of nan type. + """Determine whether the single valued array or scalar is of nan type. Parameters ---------- @@ -1343,9 +1323,8 @@ def value_is_nan( def has_nans( x: Union[ivy.Array, ivy.NativeArray], /, *, include_infs: bool = True ) -> bool: - """ - Determine whether the array contains any nans, as well as infs or -infs if - specified. + """Determine whether the array contains any nans, as well as infs or -infs + if specified. Parameters ---------- @@ -1404,8 +1383,7 @@ def has_nans( @handle_exceptions def exists(x: Any, /) -> bool: - """ - Check as to whether the input is None or not. + """Check as to whether the input is None or not. Parameters ---------- @@ -1486,8 +1464,7 @@ def default( rev: bool = False, with_callable: bool = False, ) -> Any: - """ - Return x provided it exists (is not None), else returns default value. + """Return x provided it exists (is not None), else returns default value. Parameters ---------- @@ -1578,8 +1555,7 @@ def default( @handle_exceptions def to_ivy_shape(shape: Union[ivy.Shape, ivy.NativeShape]) -> ivy.Shape: - """ - Return the input shape in ivy.Shape form. + """Return the input shape in ivy.Shape form. Parameters ---------- @@ -1600,8 +1576,7 @@ def to_ivy_shape(shape: Union[ivy.Shape, ivy.NativeShape]) -> ivy.Shape: def to_native_shape( shape: Union[ivy.Array, ivy.Shape, ivy.NativeShape, tuple, int, list] ) -> ivy.NativeShape: - """ - Return the input shape in its native backend framework form. + """Return the input shape in its native backend framework form. Parameters ---------- @@ -1643,9 +1618,8 @@ def to_native_shape( @handle_exceptions @handle_nestable def try_else_none(fn: Callable, *args: Any, **kwargs: Any) -> Union[Callable, None]: - """ - Try and return the function, otherwise return None if an exception was raised during - function execution. + """Try and return the function, otherwise return None if an exception was + raised during function execution. Parameters ---------- @@ -1688,8 +1662,7 @@ def try_else_none(fn: Callable, *args: Any, **kwargs: Any) -> Union[Callable, No @handle_exceptions def arg_names(receiver): - """ - Get the expected keyword arguments for a function or class constructor. + """Get the expected keyword arguments for a function or class constructor. Parameters ---------- @@ -1719,8 +1692,7 @@ def arg_names(receiver): def match_kwargs( kwargs: Dict, *receivers: Iterable[Callable], allow_duplicates: bool = False ) -> Union[List[Dict], Dict]: - """ - Match keyword arguments to either class or function receivers. + """Match keyword arguments to either class or function receivers. Parameters ---------- @@ -1766,8 +1738,7 @@ def match_kwargs( @handle_exceptions def cache_fn(func: Callable) -> Callable: - """ - Cache function outputs. + """Cache function outputs. A decorator to wrap a function, such that computed outputs are cached to avoid recalculating them later. @@ -1820,8 +1791,7 @@ def cached_fn(*args, **kwargs): @handle_exceptions def current_backend_str() -> Union[str, None]: - """ - Return framework string. + """Return framework string. Returns ------- @@ -1847,8 +1817,7 @@ def einops_rearrange( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - Perform einops rearrange operation on input array x. + """Perform einops rearrange operation on input array x. Parameters ---------- @@ -1983,8 +1952,7 @@ def einops_reduce( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - Perform einops reduce operation on input array x. + """Perform einops reduce operation on input array x. Parameters ---------- @@ -2060,8 +2028,7 @@ def einops_repeat( out: Optional[ivy.Array] = None, **axes_lengths: Dict[str, int], ) -> ivy.Array: - """ - Perform einops repeat operation on input array x. + """Perform einops repeat operation on input array x. Parameters ---------- @@ -2121,8 +2088,8 @@ def einops_repeat( @handle_exceptions @handle_array_function def set_min_denominator(val: float) -> None: - """ - Set the global minimum denominator used by ivy for numerically stable division. + """Set the global minimum denominator used by ivy for numerically stable + division. Parameters ---------- @@ -2148,9 +2115,8 @@ def set_min_denominator(val: float) -> None: @handle_exceptions def unset_min_denominator() -> None: - """ - Reset the global minimum denominator used by ivy for numerically stable division to - the previous value. + """Reset the global minimum denominator used by ivy for numerically stable + division to the previous value. Examples -------- @@ -2176,8 +2142,8 @@ def unset_min_denominator() -> None: @handle_exceptions @handle_array_function def set_min_base(val: float) -> None: - """ - Set the global minimum base used by ivy for numerically stable power raising. + """Set the global minimum base used by ivy for numerically stable power + raising. Parameters ---------- @@ -2213,9 +2179,8 @@ def set_min_base(val: float) -> None: @handle_exceptions def unset_min_base() -> None: - """ - Reset the global minimum base used by ivy for numerically stable power raising to - the previous value. + """Reset the global minimum base used by ivy for numerically stable power + raising to the previous value. Examples -------- @@ -2247,9 +2212,8 @@ def stable_divide( *, min_denominator: Union[Number, ivy.Array, ivy.NativeArray] = None, ) -> Union[Number, ivy.Array]: - """ - Divide the numerator by the denominator, with min denominator added to the - denominator for numerical stability. + """Divide the numerator by the denominator, with min denominator added to + the denominator for numerical stability. Parameters ---------- @@ -2347,9 +2311,8 @@ def stable_pow( *, min_base: Optional[float] = None, ) -> Any: - """ - Raise the base by the power, with ivy.min_base added to the base when exponent > 1 - for numerical stability. + """Raise the base by the power, with ivy.min_base added to the base when + exponent > 1 for numerical stability. Parameters ---------- @@ -2437,8 +2400,7 @@ def stable_pow( @handle_exceptions def get_all_arrays_in_memory() -> List[Union[ivy.Array, ivy.NativeArray]]: - """ - Get all arrays which are currently alive. + """Get all arrays which are currently alive. Returns ------- @@ -2473,8 +2435,7 @@ def get_all_arrays_in_memory() -> List[Union[ivy.Array, ivy.NativeArray]]: @handle_exceptions def num_arrays_in_memory() -> int: - """ - Return the number of arrays which are currently alive. + """Return the number of arrays which are currently alive. Returns ------- @@ -2497,8 +2458,7 @@ def num_arrays_in_memory() -> int: @handle_exceptions def print_all_arrays_in_memory(): - """ - Print all native Ivy arrays in memory to the console. + """Print all native Ivy arrays in memory to the console. Gets all the native Ivy arrays which are currently alive(in the garbage collector) from get_all_arrays_in_memory() function and @@ -2514,8 +2474,7 @@ def print_all_arrays_in_memory(): @handle_exceptions @handle_array_function def set_queue_timeout(timeout: float): - """ - Set a timeout value (in seconds) for the global queue. + """Set a timeout value (in seconds) for the global queue. Set the global queue timeout value (in seconds) Default value without this function being called is 15 seconds. @@ -2546,8 +2505,7 @@ def set_queue_timeout(timeout: float): @handle_exceptions def unset_queue_timeout() -> None: - """ - Reset the global queue timeout value (in seconds) to the previous state. + """Reset the global queue timeout value (in seconds) to the previous state. Examples -------- @@ -2572,8 +2530,7 @@ def unset_queue_timeout() -> None: @handle_exceptions def set_tmp_dir(tmp_dr: str) -> None: - """ - Set the directory for saving temporary files. + """Set the directory for saving temporary files. Parameters ---------- @@ -2599,8 +2556,7 @@ def set_tmp_dir(tmp_dr: str) -> None: @handle_exceptions def unset_tmp_dir() -> None: - """ - Reset the directory for saving temporary files to the previous value. + """Reset the directory for saving temporary files to the previous value. Examples -------- @@ -2622,8 +2578,7 @@ def unset_tmp_dir() -> None: @handle_exceptions def container_types(): - """ - Summary. + """Summary. Returns ------- @@ -2640,8 +2595,8 @@ def container_types(): @handle_exceptions def inplace_arrays_supported() -> bool: - """ - Determine whether inplace arrays are supported for the current backend framework. + """Determine whether inplace arrays are supported for the current backend + framework. Returns ------- @@ -2653,8 +2608,8 @@ def inplace_arrays_supported() -> bool: @handle_exceptions def inplace_variables_supported() -> bool: - """ - Determine whether inplace variables are supported for the current backend framework. + """Determine whether inplace variables are supported for the current + backend framework. Returns ------- @@ -2669,8 +2624,7 @@ def inplace_variables_supported() -> bool: @inputs_to_native_arrays @handle_array_function def supports_inplace_updates(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """ - Return if in-place operations are supported for x's data type. + """Return if in-place operations are supported for x's data type. Determine whether in-place operations are supported for x's data type, by the current backend framework setting. @@ -2736,8 +2690,7 @@ def supports_inplace_updates(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: @inputs_to_native_arrays @handle_array_function def assert_supports_inplace(x: Union[ivy.Array, ivy.NativeArray], /) -> bool: - """ - Assert that inplace operations are supported for x. + """Assert that inplace operations are supported for x. Parameters ---------- @@ -2809,8 +2762,7 @@ def get_item( *, copy: Optional[bool] = None, ) -> ivy.Array: - """ - Gather slices from x according to query array, identical to x[query]. + """Gather slices from x according to query array, identical to x[query]. Parameters ---------- @@ -2879,8 +2831,8 @@ def set_item( *, copy: Optional[bool] = False, ) -> ivy.Array: - """ - Replace slices of x (defined by query) with val, identical to x[query] = val. + """Replace slices of x (defined by query) with val, identical to x[query] = + val. Parameters ---------- @@ -3007,8 +2959,7 @@ def inplace_update( ensure_in_backend: bool = False, keep_input_dtype: bool = False, ) -> ivy.Array: - """ - Perform in-place update for the input array. + """Perform in-place update for the input array. This will always be performed on ivy.Array instances pass in the input, and will also be performed on the native array classes in the backend when the backend @@ -3104,8 +3055,7 @@ def inplace_update( @handle_exceptions def set_inplace_mode(mode: str = "lenient") -> None: - """ - Set the memory management behavior for in-place updates in Ivy. + """Set the memory management behavior for in-place updates in Ivy. By default, Ivy creates new arrays in the backend for in-place updates. However, this behavior can be controlled by the user @@ -3152,9 +3102,8 @@ def set_inplace_mode(mode: str = "lenient") -> None: @handle_exceptions def unset_inplace_mode() -> None: - """ - Reset the memory management behavior for in-place updates in Ivy to the previous - state. + """Reset the memory management behavior for in-place updates in Ivy to the + previous state. Examples -------- @@ -3183,8 +3132,7 @@ def inplace_decrement( x: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Perform in-place decrement for the input array. + """Perform in-place decrement for the input array. Parameters ---------- @@ -3255,8 +3203,7 @@ def inplace_increment( x: Union[ivy.Array, ivy.NativeArray], val: Union[ivy.Array, ivy.NativeArray], ) -> ivy.Array: - """ - Perform in-place increment for the input array. + """Perform in-place increment for the input array. Parameters ---------- @@ -3320,8 +3267,7 @@ def scatter_flat( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Scatter flat updates into a new flat array according to flat indices. + """Scatter flat updates into a new flat array according to flat indices. Parameters ---------- @@ -3410,8 +3356,7 @@ def scatter_nd( reduction: str = "sum", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Scatter updates into a new array according to indices. + """Scatter updates into a new array according to indices. Parameters ---------- @@ -3517,8 +3462,7 @@ def gather( batch_dims: int = 0, out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Gather slices from params at axis according to indices. + """Gather slices from params at axis according to indices. Parameters ---------- @@ -3628,8 +3572,7 @@ def gather_nd( batch_dims: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Gather slices from params into a array with shape specified by indices. + """Gather slices from params into a array with shape specified by indices. Parameters ---------- @@ -3696,8 +3639,7 @@ def gather_nd( @handle_nestable @handle_array_function def multiprocessing(context: Optional[str] = None): - """ - Return backend-specific multiprocessing module. + """Return backend-specific multiprocessing module. Parameters ---------- @@ -3756,8 +3698,7 @@ def shape( *, as_array: bool = False, ) -> Union[ivy.Shape, ivy.NativeShape]: - """ - Return the shape of the array ``x``. + """Return the shape of the array ``x``. Parameters ---------- @@ -3791,8 +3732,7 @@ def shape( @handle_exceptions def set_shape_array_mode(mode: bool) -> None: - """ - Set the mode of returning shape as ivy.Array to the given mode instance. + """Set the mode of returning shape as ivy.Array to the given mode instance. Parameter --------- @@ -3817,8 +3757,7 @@ def set_shape_array_mode(mode: bool) -> None: @handle_exceptions def unset_shape_array_mode() -> None: - """ - Reset the mode of returning shape as ivy.Array to the previous state. + """Reset the mode of returning shape as ivy.Array to the previous state. Examples -------- @@ -3846,8 +3785,7 @@ def unset_shape_array_mode() -> None: def get_num_dims( x: Union[ivy.Array, ivy.NativeArray], /, *, as_array: bool = False ) -> int: - """ - Return the number of dimensions of the array x. + """Return the number of dimensions of the array x. Parameters ---------- @@ -3895,9 +3833,8 @@ def get_num_dims( @handle_exceptions def arg_info(fn: Callable, *, name: Optional[str] = None, idx: Optional[int] = None): - """ - Return the index and `inspect.Parameter` representation of the specified argument. - In the form of a dict with keys "idx" and "param". + """Return the index and `inspect.Parameter` representation of the specified + argument. In the form of a dict with keys "idx" and "param". Parameters ---------- @@ -4109,11 +4046,10 @@ def _get_devices_and_dtypes(fn, recurse=True, complement=True): @handle_exceptions @handle_nestable def function_supported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> Dict: - """ - Return the supported combination of devices and dtypes of the current backend's - function. The function returns a dict containing the supported combination of - devices and dtypes of the primary and compositional implementations in case of - partial mixed functions. + """Return the supported combination of devices and dtypes of the current + backend's function. The function returns a dict containing the supported + combination of devices and dtypes of the primary and compositional + implementations in case of partial mixed functions. Parameters ---------- @@ -4158,11 +4094,10 @@ def function_supported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> @handle_exceptions @handle_nestable def function_unsupported_devices_and_dtypes(fn: Callable, recurse: bool = True) -> Dict: - """ - Return the unsupported combination of devices and dtypes of the current backend's - function. The function returns a dict containing the unsupported combination of - devices and dtypes of the primary and compositional implementations in case of - partial mixed functions. + """Return the unsupported combination of devices and dtypes of the current + backend's function. The function returns a dict containing the unsupported + combination of devices and dtypes of the primary and compositional + implementations in case of partial mixed functions. Parameters ---------- @@ -4208,8 +4143,7 @@ def vmap( in_axes: Union[int, Sequence[int], Sequence[None]] = 0, out_axes: int = 0, ) -> Callable: - """ - Vectorizing map. Creates a function which maps func over argument axes. + """Vectorizing map. Creates a function which maps func over argument axes. Parameters ---------- @@ -4274,8 +4208,7 @@ def isin( assume_unique: bool = False, invert: bool = False, ) -> ivy.Array: - """ - Test if each element of elements is in test_elements. + """Test if each element of elements is in test_elements. Parameters ---------- @@ -4322,8 +4255,7 @@ def itemsize( x: Union[ivy.Array, ivy.NativeArray], /, ) -> int: - """ - Return the size of the input array's elements. + """Return the size of the input array's elements. Parameters ---------- @@ -4355,8 +4287,7 @@ def strides( x: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple[int]: - """ - Return the input array's strides across each dimension. + """Return the input array's strides across each dimension. Parameters ---------- @@ -4387,8 +4318,7 @@ def strides( def is_ivy_nested_array(x: Any, /) -> bool: - """ - Determine whether the input x is an Ivy Nested Array. + """Determine whether the input x is an Ivy Nested Array. Parameters ---------- diff --git a/ivy/functional/ivy/gradients.py b/ivy/functional/ivy/gradients.py index 6740e800462a4..8e1a162112909 100644 --- a/ivy/functional/ivy/gradients.py +++ b/ivy/functional/ivy/gradients.py @@ -27,7 +27,8 @@ def _get_duplicate_index_chains(xs): - """Generate a list of duplicate index chains for a given nested structure.""" + """Generate a list of duplicate index chains for a given nested + structure.""" duplicate_index_chains = () if isinstance(xs, ivy.Container): duplicate_index_chains = xs.cont_duplicate_array_keychains() @@ -37,7 +38,8 @@ def _get_duplicate_index_chains(xs): def _arrays_to_float_variables(xs, xs_grad_idxs=None): - """Convert all required arrays to float variables for gradient calculation.""" + """Convert all required arrays to float variables for gradient + calculation.""" def inner_fn(x): if ivy.is_array(x, exclusive=True): @@ -103,8 +105,7 @@ def map_fn(x): def _get_required_float_variables(xs, xs_grad_idxs): - """ - Convert all required arrays to float variables for gradient calculation. + """Convert all required arrays to float variables for gradient calculation. Also, returns a list of duplicate index chains for the nested structure. @@ -127,7 +128,8 @@ def _get_required_float_variables(xs, xs_grad_idxs): def _get_native_variables_and_indices(x, reshape=True, idxs=None, create_var=False): - """Extract all relevant results from the output nested structure of a function.""" + """Extract all relevant results from the output nested structure of a + function.""" def map_fn(x_): if ivy.is_array(x_): @@ -167,7 +169,8 @@ def map_fn(x_): def _set_duplicates(xs, duplicate_index_chains): - """Set the duplicates in the nested structure to have the same reference.""" + """Set the duplicates in the nested structure to have the same + reference.""" originals = list( map( lambda key_chains: [key_chains[0]] * (len(key_chains) - 1), @@ -233,8 +236,7 @@ def _stop_grad_and_index(func_ret, retain_grads, grads): def _process_func_ret_and_grads(func_ret, grads, retain_grads): - """ - Stop gradients propagation. + """Stop gradients propagation. Set the gradients of non-finite values to zero, and stopping gradient propagation of the function results. @@ -272,8 +274,7 @@ def _non_finite_to_zero(xs): def _flatten_containers(inputs): - """ - Flatten containers into a single tuple of arrays. + """Flatten containers into a single tuple of arrays. Returns a flattened tuple of arrays and the indices of the arrays in the original containers. @@ -338,8 +339,7 @@ def _is_variable(x, exclusive=False, to_ignore=None) -> bool: def _variable_data( x: Union[ivy.Array, ivy.NativeArray] ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Get the contents of the input. + """Get the contents of the input. Parameters ---------- @@ -373,8 +373,7 @@ def stop_gradient( preserve_type: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Stop gradient computation. + """Stop gradient computation. Parameters ---------- @@ -450,9 +449,9 @@ def execute_with_gradients( xs_grad_idxs: Sequence[Sequence[Union[str, int]]] = ((0,),), ret_grad_idxs: Sequence[Sequence[Union[str, int]]] = ((0,),), ) -> Tuple[ivy.Array, ivy.Array]: - """ - Call function func with input of xs variables, and return the function result - func_ret and the gradients of each output variable w.r.t each input variable, + """Call function func with input of xs variables, and return the function + result func_ret and the gradients of each output variable w.r.t each input + variable, Parameters ---------- @@ -528,8 +527,7 @@ def execute_with_gradients( @handle_exceptions def value_and_grad(func: Callable) -> Callable: - """ - Create a function that evaluates both func and the gradient of func. + """Create a function that evaluates both func and the gradient of func. Parameters ---------- @@ -562,8 +560,7 @@ def value_and_grad(func: Callable) -> Callable: @handle_exceptions def jac(func: Callable) -> Callable: - """ - Call function func, and return func's Jacobian partial derivatives. + """Call function func, and return func's Jacobian partial derivatives. Parameters ---------- @@ -596,8 +593,7 @@ def jac(func: Callable) -> Callable: @handle_exceptions def grad(func: Callable, argnums: Union[int, Sequence[int]] = 0) -> Callable: - """ - Call function func, and return func's gradients. + """Call function func, and return func's gradients. Parameters ---------- @@ -647,9 +643,8 @@ def adam_step( epsilon: float = 1e-7, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - Compute adam step delta, given the derivatives of some cost c with respect to - weights ws, using ADAM update. `[reference] + """Compute adam step delta, given the derivatives of some cost c with + respect to weights ws, using ADAM update. `[reference] `_ @@ -798,9 +793,8 @@ def optimizer_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Update weights ws of some function, given the true or effective derivatives of some - cost c with respect to ws, [dc/dw for w in ws]. + """Update weights ws of some function, given the true or effective + derivatives of some cost c with respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -921,9 +915,8 @@ def gradient_descent_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws]. + """Update weights ws of some function, given the derivatives of some cost c + with respect to ws, [dc/dw for w in ws]. Parameters ---------- @@ -1015,10 +1008,9 @@ def lars_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive Rate Scaling - (LARS) method. + """Update weights ws of some function, given the derivatives of some cost c + with respect to ws, [dc/dw for w in ws], by applying Layerwise Adaptive + Rate Scaling (LARS) method. Parameters ---------- @@ -1120,9 +1112,8 @@ def adam_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, using ADAM update. `[reference] + """Update weights ws of some function, given the derivatives of some cost c + with respect to ws, using ADAM update. `[reference] `_ @@ -1287,9 +1278,8 @@ def lamb_update( stop_gradients: bool = True, out: Optional[ivy.Array] = None, ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]: - """ - Update weights ws of some function, given the derivatives of some cost c with - respect to ws, [dc/dw for w in ws], by applying LAMB method. + """Update weights ws of some function, given the derivatives of some cost c + with respect to ws, [dc/dw for w in ws], by applying LAMB method. Parameters ---------- diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index cafe906734776..741aba99eaf5d 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -44,10 +44,9 @@ def _in_projection( w, b=None, ): - """ - Projects query, key and value efficiently, depending on whether we are doing self- - attention (query is key is value) or cross-attention (key is value) or an attention - where query, key and value are all different. + """Projects query, key and value efficiently, depending on whether we are + doing self- attention (query is key is value) or cross-attention (key is + value) or an attention where query, key and value are all different. it is only used in multi_head_attention layer. @@ -264,8 +263,7 @@ def dropout( noise_shape: Optional[Sequence[int]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Randomly setting a fraction of input tensor to zeroes with probability. + """Randomly setting a fraction of input tensor to zeroes with probability. `prob` at each update during training time to prevent possible overfitting. The inputs not set to 0 are scaled up `1 / (1 - prob)` by default, so that @@ -449,8 +447,7 @@ def scaled_dot_product_attention( training: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply scaled dot product attention to inputs x using optional mask. + """Apply scaled dot product attention to inputs x using optional mask. Parameters ---------- @@ -751,20 +748,20 @@ def multi_head_attention( training: bool = False, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, ivy.NativeArray]: - """ - Apply multi-head attention to inputs x. This is an implementation of multi-headed - attention as described in the paper "Attention is all you Need" (Vaswani et al., - 2017). If `query`, `key`, `value` are the same, then this is self-attention. Each - timestep in `query` attends to the corresponding sequence in `key`, and returns a - fixed-width vector. This layer first projects `query`, `key` and `value`. These are - (effectively) a list of tensors of length `num_attention_heads`, where the - corresponding shapes are `(batch_size, , key_dim)`, `(batch_size, + """Apply multi-head attention to inputs x. This is an implementation of + multi-headed attention as described in the paper "Attention is all you + Need" (Vaswani et al., 2017). If `query`, `key`, `value` are the same, then + this is self-attention. Each timestep in `query` attends to the + corresponding sequence in `key`, and returns a fixed-width vector. This + layer first projects `query`, `key` and `value`. These are (effectively) a + list of tensors of length `num_attention_heads`, where the corresponding + shapes are `(batch_size, , key_dim)`, `(batch_size, , key_dim)`, `(batch_size, , - value_dim)`. Then, the query and key tensors are dot-producted and scaled. These are - softmaxed to obtain attention probabilities. The value tensors are then interpolated - by these probabilities, then concatenated back to a single tensor. Finally, the - result tensor with the last dimension as value_dim can take a linear projection and - return. + value_dim)`. Then, the query and key tensors are dot-producted and scaled. + These are softmaxed to obtain attention probabilities. The value tensors + are then interpolated by these probabilities, then concatenated back to a + single tensor. Finally, the result tensor with the last dimension as + value_dim can take a linear projection and return. Parameters ---------- @@ -1023,8 +1020,7 @@ def conv1d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D convolution given 3-D input x and filters arrays. + """Compute a 1-D convolution given 3-D input x and filters arrays. Parameters ---------- @@ -1134,8 +1130,8 @@ def conv1d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D transpose convolution given 3-D input x and filters arrays. + """Compute a 1-D transpose convolution given 3-D input x and filters + arrays. Parameters ---------- @@ -1284,8 +1280,7 @@ def conv2d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D convolution given 4-D input x and filters arrays. + """Compute a 2-D convolution given 4-D input x and filters arrays. Parameters ---------- @@ -1425,8 +1420,8 @@ def conv2d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D transpose convolution given 4-D input x and filters arrays. + """Compute a 2-D transpose convolution given 4-D input x and filters + arrays. Parameters ---------- @@ -1562,8 +1557,8 @@ def depthwise_conv2d( dilations: Union[int, Tuple[int, int]] = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 2-D depthwise convolution given 4-D input ``x`` and filters arrays. + """Compute a 2-D depthwise convolution given 4-D input ``x`` and filters + arrays. Parameters ---------- @@ -1704,8 +1699,7 @@ def conv3d( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D convolution given 5-D input x and filters arrays. + """Compute a 3-D convolution given 5-D input x and filters arrays. Parameters ---------- @@ -1826,8 +1820,8 @@ def conv3d_transpose( bias: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 3-D transpose convolution given 5-D input x and filters arrays. + """Compute a 3-D transpose convolution given 5-D input x and filters + arrays. Parameters ---------- @@ -1970,9 +1964,8 @@ def conv_general_dilated( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D, 2-D, and 3-D convolution given 3-D, 4-D and 5-D input x respectively - and filters arrays. + """Compute a 1-D, 2-D, and 3-D convolution given 3-D, 4-D and 5-D input x + respectively and filters arrays. Parameters ---------- @@ -2055,9 +2048,8 @@ def conv_general_transpose( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D, 2-D, and 3-D transpose convolution given 3-D, 4-D and 5-D input x - respectively and filters arrays. + """Compute a 1-D, 2-D, and 3-D transpose convolution given 3-D, 4-D and 5-D + input x respectively and filters arrays. Parameters ---------- @@ -2197,9 +2189,8 @@ def conv( bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute a 1-D, 2-D, and 3-D transpose or dilated convolution given 3-D, 4-D and 5-D - input x respectively and filters arrays. + """Compute a 1-D, 2-D, and 3-D transpose or dilated convolution given 3-D, + 4-D and 5-D input x respectively and filters arrays. Parameters ---------- @@ -2297,8 +2288,8 @@ def lstm_update( recurrent_bias: Optional[Union[ivy.Array, ivy.NativeArray]] = None, time_major: bool = False, ) -> Tuple[ivy.Array, Tuple[ivy.Array, ivy.Array]]: - """ - Perform long-short term memory update by unrolling time dimension of input array. + """Perform long-short term memory update by unrolling time dimension of + input array. Parameters ---------- @@ -2539,8 +2530,7 @@ def _get_x_data_format(dims: int = 2, data_format: str = "channel_first"): def _get_num_padded_values(i, p, n, k, s): - """ - Get number of padded values in a specific window. + """Get number of padded values in a specific window. Parameters ---------- diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index bd3c643f7e763..8831c28b7b64a 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -39,8 +39,7 @@ def cholesky( upper: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the cholesky decomposition of the x matrix. + """Compute the cholesky decomposition of the x matrix. Parameters ---------- @@ -183,8 +182,7 @@ def cross( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return cross product of 3-element vectors. + """Return cross product of 3-element vectors. If x1 and x2 are multi- dimensional arrays (i.e., both have a rank greater than 1), then the cross- product of each pair of corresponding 3-element vectors is @@ -283,8 +281,8 @@ def cross( def det( x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Return the determinant of a square matrix (or a stack of square matrices)``x``. + """Return the determinant of a square matrix (or a stack of square + matrices)``x``. Parameters ---------- @@ -363,8 +361,8 @@ def diagonal( axis2: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the specified diagonals of a matrix (or a stack of matrices) ``x``. + """Return the specified diagonals of a matrix (or a stack of matrices) + ``x``. Parameters ---------- @@ -540,10 +538,9 @@ def eig( *, out: Optional[ivy.Array] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray]]: - """ - Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack of symmetric - matrices) ``x``, where ``Q`` is an orthogonal matrix (or a stack of matrices) and - ``L`` is a vector (or a stack of vectors). + """Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack + of symmetric matrices) ``x``, where ``Q`` is an orthogonal matrix (or a + stack of matrices) and ``L`` is a vector (or a stack of vectors). .. note:: The function ``eig`` currently behaves like ``eigh``, as @@ -594,10 +591,9 @@ def eigh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray]]: - r""" - Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack of symmetric - matrices) ``x``, where ``Q`` is an orthogonal matrix (or a stack of matrices) and - ``L`` is a vector (or a stack of vectors). + r"""Return an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack + of symmetric matrices) ``x``, where ``Q`` is an orthogonal matrix (or a + stack of matrices) and ``L`` is a vector (or a stack of vectors). .. note:: The function ``eig`` will be added in a future version of the specification, as @@ -707,8 +703,8 @@ def eigvalsh( UPLO: str = "L", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the eigenvalues of a symmetric matrix (or a stack of symmetric matrices) x. + """Return the eigenvalues of a symmetric matrix (or a stack of symmetric + matrices) x. .. note:: The function ``eig`` will be added in a future version of the specification, as @@ -815,8 +811,7 @@ def inner( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the inner product of two vectors ``x1`` and ``x2``. + """Return the inner product of two vectors ``x1`` and ``x2``. Parameters ---------- @@ -894,9 +889,8 @@ def inv( adjoint: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the multiplicative inverse of a square matrix (or a stack of square matrices) - ``x``. + """Return the multiplicative inverse of a square matrix (or a stack of + square matrices) ``x``. Parameters ---------- @@ -992,8 +986,7 @@ def matmul( adjoint_b: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the matrix product. + """Compute the matrix product. Parameters ---------- @@ -1153,8 +1146,7 @@ def matrix_norm( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the matrix p-norm. + """Compute the matrix p-norm. Parameters ---------- @@ -1309,8 +1301,8 @@ def matrix_norm( def matrix_power( x: Union[ivy.Array, ivy.NativeArray], n: int, /, *, out: Optional[ivy.Array] = None ) -> ivy.Array: - """ - Raise a square matrix (or a stack of square matrices) x to an integer power n. + """Raise a square matrix (or a stack of square matrices) x to an integer + power n. Parameters ---------- @@ -1416,9 +1408,8 @@ def matrix_rank( hermitian: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the rank (i.e., number of non-zero singular values) of a matrix (or a stack - of matrices). + """Return the rank (i.e., number of non-zero singular values) of a matrix + (or a stack of matrices). Parameters ---------- @@ -1530,8 +1521,7 @@ def matrix_transpose( conjugate: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Transposes a matrix (or a stack of matrices) ``x``. + """Transposes a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -1620,8 +1610,7 @@ def outer( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the outer product of two vectors ``x1`` and ``x2``. + """Return the outer product of two vectors ``x1`` and ``x2``. Parameters ---------- @@ -1711,9 +1700,8 @@ def pinv( rtol: Optional[Union[float, Tuple[float]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the (Moore-Penrose) pseudo-inverse of a matrix (or a stack of matrices) - ``x``. + """Return the (Moore-Penrose) pseudo-inverse of a matrix (or a stack of + matrices) ``x``. Parameters ---------- @@ -1787,10 +1775,9 @@ def qr( mode: str = "reduced", out: Optional[Tuple[ivy.Array, ivy.Array]] = None, ) -> Tuple[ivy.Array, ivy.Array]: - """ - Return the qr decomposition x = QR of a full column rank matrix (or a stack of - matrices), where Q is an orthonormal matrix (or a stack of matrices) and R is an - upper-triangular matrix (or a stack of matrices). + """Return the qr decomposition x = QR of a full column rank matrix (or a + stack of matrices), where Q is an orthonormal matrix (or a stack of + matrices) and R is an upper-triangular matrix (or a stack of matrices). Parameters ---------- @@ -2008,9 +1995,8 @@ def solve( adjoint: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the solution x to the system of linear equations represented by the well- - determined (i.e., full rank) linear matrix equation Ax = B. + """Return the solution x to the system of linear equations represented by + the well- determined (i.e., full rank) linear matrix equation Ax = B. Parameters ---------- @@ -2138,11 +2124,11 @@ def svd( compute_uv: bool = True, full_matrices: bool = True, ) -> Union[ivy.Array, Tuple[ivy.Array, ...]]: - """ - Return a singular value decomposition A = USVh of a matrix (or a stack of matrices) - ``x``, where ``U`` is a matrix (or a stack of matrices) with orthonormal columns, - ``S`` is a vector of non-negative numbers (or stack of vectors), and ``Vh`` is a - matrix (or a stack of matrices) with orthonormal rows. + """Return a singular value decomposition A = USVh of a matrix (or a stack + of matrices) ``x``, where ``U`` is a matrix (or a stack of matrices) with + orthonormal columns, ``S`` is a vector of non-negative numbers (or stack of + vectors), and ``Vh`` is a matrix (or a stack of matrices) with orthonormal + rows. Parameters ---------- @@ -2270,8 +2256,7 @@ def svdvals( driver: Optional[str] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the singular values of a matrix (or a stack of matrices) ``x``. + """Return the singular values of a matrix (or a stack of matrices) ``x``. Parameters ---------- @@ -2413,8 +2398,7 @@ def tensordot( axes: Union[int, Tuple[List[int], List[int]]] = 2, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a tensor contraction of x1 and x2 over specific axes. + """Return a tensor contraction of x1 and x2 over specific axes. .. note:: If either ``x1`` or ``x2`` has a complex floating-point data type, neither @@ -2514,9 +2498,8 @@ def trace( axis2: int = 1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the sum along the specified diagonals of a matrix (or a stack of matrices) - ``x``. + """Return the sum along the specified diagonals of a matrix (or a stack of + matrices) ``x``. **Special cases** @@ -2699,8 +2682,7 @@ def vecdot( axis: int = -1, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the (vector) dot product of two arrays. + """Compute the (vector) dot product of two arrays. Parameters ---------- @@ -2798,8 +2780,7 @@ def vector_norm( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - r""" - Compute the vector norm of a vector (or batch of vectors) ``x``. + r"""Compute the vector norm of a vector (or batch of vectors) ``x``. Parameters ---------- @@ -2944,9 +2925,8 @@ def diag( k: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the specified diagonals of the input array, or an array with the input - array's elements as diagonals. + """Return the specified diagonals of the input array, or an array with the + input array's elements as diagonals. Parameters ---------- @@ -3029,11 +3009,11 @@ def vander( increasing: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Generate a Vandermonde matrix. The columns of the output matrix are elementwise - powers of the input vector x^{(N-1)}, x^{(N-2)}, ..., x^0x. If increasing is True, - the order of the columns is reversed x^0, x^1, ..., x^{(N-1)}. Such a matrix with a - geometric progression in each row is named for Alexandre-Theophile Vandermonde. + """Generate a Vandermonde matrix. The columns of the output matrix are + elementwise powers of the input vector x^{(N-1)}, x^{(N-2)}, ..., x^0x. If + increasing is True, the order of the columns is reversed x^0, x^1, ..., + x^{(N-1)}. Such a matrix with a geometric progression in each row is named + for Alexandre-Theophile Vandermonde. Parameters ---------- diff --git a/ivy/functional/ivy/losses.py b/ivy/functional/ivy/losses.py index bd9cd0c77c5be..8310df572f06c 100644 --- a/ivy/functional/ivy/losses.py +++ b/ivy/functional/ivy/losses.py @@ -44,8 +44,7 @@ def cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute cross-entropy between predicted and true discrete distributions. + """Compute cross-entropy between predicted and true discrete distributions. Parameters ---------- @@ -102,8 +101,7 @@ def binary_cross_entropy( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute the binary cross entropy loss. + """Compute the binary cross entropy loss. Parameters ---------- @@ -281,8 +279,7 @@ def sparse_cross_entropy( reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Compute sparse cross entropy between logits and labels. + """Compute sparse cross entropy between logits and labels. Parameters ---------- diff --git a/ivy/functional/ivy/manipulation.py b/ivy/functional/ivy/manipulation.py index 318c663b739b7..a039a9159e3a0 100644 --- a/ivy/functional/ivy/manipulation.py +++ b/ivy/functional/ivy/manipulation.py @@ -54,8 +54,7 @@ def concat( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Join a sequence of arrays along an existing axis. + """Join a sequence of arrays along an existing axis. Parameters ---------- @@ -114,9 +113,8 @@ def expand_dims( axis: Union[int, Sequence[int]] = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Expand the shape of an array by inserting a new axis (dimension) of size one at the - position specified by axis. + """Expand the shape of an array by inserting a new axis (dimension) of size + one at the position specified by axis. Parameters ---------- @@ -252,9 +250,8 @@ def flip( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Reverses the order of elements in an array along the given axis. The shape of the - array must be preserved. + """Reverses the order of elements in an array along the given axis. The + shape of the array must be preserved. Parameters ---------- @@ -347,8 +344,7 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Permutes the axes (dimensions) of an array x. + """Permutes the axes (dimensions) of an array x. Parameters ---------- @@ -450,8 +446,7 @@ def reshape( allowzero: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Give a new shape to an array without changing its data. + """Give a new shape to an array without changing its data. Parameters ---------- @@ -574,10 +569,10 @@ def roll( axis: Optional[Union[int, Sequence[int]]] = None, out: Optional[ivy.Array] = None, ) -> Union[ivy.Array, ivy.Container]: - """ - Roll array elements along a specified axis. Array elements that roll beyond the last - position are re-introduced at the first position. Array elements that roll beyond - the first position are re-introduced at the last position. + """Roll array elements along a specified axis. Array elements that roll + beyond the last position are re-introduced at the first position. Array + elements that roll beyond the first position are re-introduced at the last + position. Parameters ---------- @@ -688,8 +683,7 @@ def squeeze( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Remove singleton dimensions (axes) from x. + """Remove singleton dimensions (axes) from x. Parameters ---------- @@ -781,8 +775,7 @@ def stack( axis: int = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Join a sequence of arrays along a new axis. + """Join a sequence of arrays along a new axis. Parameters ---------- @@ -869,8 +862,7 @@ def clip( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Clips (limits) the values in an array. + """Clips (limits) the values in an array. Given an interval, values outside the interval are clipped to the interval edges (element-wise). For example, if an interval of [0, 1] is specified, values smaller @@ -997,8 +989,7 @@ def constant_pad( value: Number = 0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Pad an array with a constant value. + """Pad an array with a constant value. Parameters ---------- @@ -1094,8 +1085,7 @@ def repeat( axis: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Repeat values along a given dimension. + """Repeat values along a given dimension. Parameters ---------- @@ -1170,8 +1160,7 @@ def split( axis: int = 0, with_remainder: bool = False, ) -> List[ivy.Array]: - """ - Split an array into multiple sub-arrays. + """Split an array into multiple sub-arrays. Parameters ---------- @@ -1256,8 +1245,7 @@ def swapaxes( copy: Optional[bool] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Interchange two axes of an array. + """Interchange two axes of an array. Parameters ---------- @@ -1364,8 +1352,7 @@ def tile( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Construct an array by repeating x the number of times given by reps. + """Construct an array by repeating x the number of times given by reps. Parameters ---------- @@ -1447,8 +1434,7 @@ def unstack( axis: int = 0, keepdims: bool = False, ) -> List[ivy.Array]: - """ - Unpacks the given dimension of a rank-R array into rank-(R-1) arrays. + """Unpacks the given dimension of a rank-R array into rank-(R-1) arrays. Parameters ---------- @@ -1542,8 +1528,7 @@ def zero_pad( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Pad an array with zeros. + """Pad an array with zeros. Parameters ---------- diff --git a/ivy/functional/ivy/meta.py b/ivy/functional/ivy/meta.py index 7ba70923ae8e6..5b3151c9accc6 100644 --- a/ivy/functional/ivy/meta.py +++ b/ivy/functional/ivy/meta.py @@ -26,8 +26,7 @@ def _compute_cost_and_update_grads( batched, num_tasks, ): - """ - Compute cost and update gradients. + """Compute cost and update gradients. This function computes the cost and updates gradients for optimization. @@ -474,8 +473,7 @@ def fomaml_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """ - Perform step of first order MAML. + """Perform step of first order MAML. Parameters ---------- @@ -590,8 +588,7 @@ def reptile_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """ - Perform a step of Reptile. + """Perform a step of Reptile. Parameters ---------- @@ -740,8 +737,7 @@ def maml_step( num_tasks: Optional[int] = None, stop_gradients: bool = True, ) -> Tuple[ivy.Array, ivy.Container, Any]: - """ - Perform step of vanilla second order MAML. + """Perform step of vanilla second order MAML. Parameters ---------- diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index a44b3e20dcb80..e0e97a718cda6 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -20,8 +20,8 @@ def index_nest( index: Union[List[int], Tuple[int], Iterable[int]], /, ) -> Any: - """ - Index a nested object, using a tuple of indices or keys in the case of dicts. + """Index a nested object, using a tuple of indices or keys in the case of + dicts. Parameters ---------- @@ -92,8 +92,7 @@ def index_nest( @handle_exceptions def prune_nest_at_index(nest: Iterable, index: Tuple, /) -> None: - """ - Prune a nested object at a specified index. + """Prune a nested object at a specified index. Parameters ---------- @@ -117,8 +116,7 @@ def set_nest_at_index( shallow: bool = True, _result: Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """ - Set the value of a nested item at a specified index. + """Set the value of a nested item at a specified index. Parameters ---------- @@ -217,8 +215,8 @@ def set_nest_at_index( @handle_exceptions def insert_into_nest_at_index(nest: Iterable, index: Tuple, value) -> None: - """ - Recursively inserts a value into a nested data structure at a specified index. + """Recursively inserts a value into a nested data structure at a specified + index. This function traverses a nested data structure and inserts the provided `value` at the specified `index`. @@ -277,8 +275,7 @@ def map_nest_at_index( shallow: bool = True, _result: Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List] = None, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """ - Map a function to the value of a nested item at a specified index. + """Map a function to the value of a nested item at a specified index. Parameters ---------- @@ -382,9 +379,8 @@ def multi_index_nest( indices: Iterable[Iterable[int]], /, ) -> Iterable[Any]: - """ - Repeatedly index a nested object, using a tuple of tuples of indices or keys in the - case of dicts. + """Repeatedly index a nested object, using a tuple of tuples of indices or + keys in the case of dicts. Parameters ---------- @@ -449,8 +445,7 @@ def multi_index_nest( @handle_exceptions def prune_nest_at_indices(nest: Iterable, indices: Tuple, /) -> None: - """ - Prune a nested object at specified indices. + """Prune a nested object at specified indices. Parameters ---------- @@ -476,8 +471,8 @@ def set_nest_at_indices( /, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """ - Set the value of a nested item at specified indices with specified values. + """Set the value of a nested item at specified indices with specified + values. Parameters ---------- @@ -554,8 +549,8 @@ def set_nest_at_indices( @handle_exceptions def insert_into_nest_at_indices(nest: Iterable, indices: Tuple, values, /) -> None: - """ - Insert a value into the nested item at specified indices with specified values. + """Insert a value into the nested item at specified indices with specified + values. Parameters ---------- @@ -583,8 +578,7 @@ def map_nest_at_indices( /, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, ivy.Container, Dict, List, Tuple]: - """ - Map a function to the values of a nested item at the specified indices. + """Map a function to the values of a nested item at the specified indices. Parameters ---------- @@ -668,9 +662,8 @@ def nested_argwhere( _base: bool = True, stop_after_n_found: Optional[int] = None, ) -> Union[Iterable, bool]: - """ - Check the leaf nodes of nested x via function fn, and returns all nest indices where - the method evaluates as True. + """Check the leaf nodes of nested x via function fn, and returns all nest + indices where the method evaluates as True. Parameters ---------- @@ -820,8 +813,7 @@ def all_nested_indices( _index: Optional[Union[int, Sequence[int]]] = None, _base: bool = True, ) -> List: - """ - Return indices of all the elements in nest. + """Return indices of all the elements in nest. Parameters ---------- @@ -916,8 +908,7 @@ def map( unique: Optional[Dict[str, Iterable[Any]]] = None, mean: bool = False, ) -> List: - """ - Apply a function on each item of an iterable x. + """Apply a function on each item of an iterable x. Parameters ---------- @@ -1027,10 +1018,9 @@ def nested_map( _dict_check_fn: Optional[Callable] = None, shallow: bool = True, ) -> Union[ivy.Array, ivy.NativeArray, Iterable, Dict]: - """ - Apply a function on x in a nested manner, whereby all dicts, lists and tuples are - traversed to their lowest leaves before applying the method and returning x. If x is - not nested, the method is applied to x directly. + """Apply a function on x in a nested manner, whereby all dicts, lists and + tuples are traversed to their lowest leaves before applying the method and + returning x. If x is not nested, the method is applied to x directly. Parameters ---------- @@ -1242,9 +1232,8 @@ def nested_any( check_nests: bool = False, _base: bool = True, ) -> bool: - """ - Check the leaf nodes of nest x via function fn, and returns True if any evaluate to - True, else False. + """Check the leaf nodes of nest x via function fn, and returns True if any + evaluate to True, else False. Parameters ---------- @@ -1288,9 +1277,8 @@ def copy_nest( include_derived: bool = False, to_mutable: bool = False, ) -> Union[ivy.Array, ivy.NativeArray, Iterable]: - """ - Copy a nest deeply, but without copying leaves of the nest, only the nest lists, - tuples and dicts are copied. + """Copy a nest deeply, but without copying leaves of the nest, only the + nest lists, tuples and dicts are copied. Parameters ---------- @@ -1391,9 +1379,8 @@ def nested_multi_map( config=None, to_ivy=True, ): - """ - Apply function to all array values from a collection of identically structured ivy - arrays. + """Apply function to all array values from a collection of identically + structured ivy arrays. Parameters ---------- @@ -1541,10 +1528,9 @@ def _found_in_index_chains(this_index_chain, index_chains): @handle_exceptions def duplicate_array_index_chains(nest: Union[ivy.Array, ivy.NativeArray, Iterable]): - """ - Group all unique index chains in a nest. This function is useful for finding all - unique index chains in a nest, and then duplicating the values at those index chains - for functional frameworks. + """Group all unique index chains in a nest. This function is useful for + finding all unique index chains in a nest, and then duplicating the values + at those index chains for functional frameworks. Parameters ---------- @@ -1572,8 +1558,7 @@ def duplicate_array_index_chains(nest: Union[ivy.Array, ivy.NativeArray, Iterabl def prune_empty(nest): - """ - Prune empty nests from a nest. + """Prune empty nests from a nest. Parameters ---------- diff --git a/ivy/functional/ivy/norms.py b/ivy/functional/ivy/norms.py index 0af316281855b..8812b94cc8a00 100644 --- a/ivy/functional/ivy/norms.py +++ b/ivy/functional/ivy/norms.py @@ -32,8 +32,7 @@ def layer_norm( new_std: float = 1.0, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Apply Layer Normalization over a mini-batch of inputs. + """Apply Layer Normalization over a mini-batch of inputs. Parameters ---------- diff --git a/ivy/functional/ivy/random.py b/ivy/functional/ivy/random.py index 23949e11ba77a..ca9510b0a0179 100644 --- a/ivy/functional/ivy/random.py +++ b/ivy/functional/ivy/random.py @@ -106,11 +106,10 @@ def random_uniform( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from a uniform distribution. Samples are uniformly distributed over - the half-open interval ``[low, high)`` (includes ``low``, but excludes ``high``). In - other words, any value within the given interval is equally likely to be drawn by - uniform. + """Draws samples from a uniform distribution. Samples are uniformly + distributed over the half-open interval ``[low, high)`` (includes ``low``, + but excludes ``high``). In other words, any value within the given interval + is equally likely to be drawn by uniform. Parameters ---------- @@ -222,8 +221,7 @@ def random_normal( device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from a normal distribution. + """Draws samples from a normal distribution. Parameters ---------- @@ -334,10 +332,10 @@ def multinomial( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Draws samples from a multinomial distribution. Specifically, returns a tensor where - each row contains num_samples indices sampled from the multinomial probability - distribution located in the corresponding row of tensor input. + """Draws samples from a multinomial distribution. Specifically, returns a + tensor where each row contains num_samples indices sampled from the + multinomial probability distribution located in the corresponding row of + tensor input. Parameters ---------- @@ -444,9 +442,8 @@ def randint( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return an array filled with random integers generated uniformly between low - (inclusive) and high (exclusive). + """Return an array filled with random integers generated uniformly between + low (inclusive) and high (exclusive). Parameters ---------- @@ -508,8 +505,7 @@ def randint( @handle_exceptions @handle_nestable def seed(*, seed_value: int = 0) -> None: - """ - Set the seed for random number generation. + """Set the seed for random number generation. Parameters ---------- @@ -539,8 +535,7 @@ def shuffle( seed: Optional[int] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Shuffles the given array along a given axis. + """Shuffles the given array along a given axis. Parameters ---------- diff --git a/ivy/functional/ivy/searching.py b/ivy/functional/ivy/searching.py index ae440f221d0d8..0faf2e0efd258 100644 --- a/ivy/functional/ivy/searching.py +++ b/ivy/functional/ivy/searching.py @@ -39,10 +39,9 @@ def argmax( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices of the maximum values along a specified axis. When the maximum - value occurs multiple times, only the indices corresponding to the first occurrence - are returned. + """Return the indices of the maximum values along a specified axis. When + the maximum value occurs multiple times, only the indices corresponding to + the first occurrence are returned. Parameters ---------- @@ -156,10 +155,9 @@ def argmin( select_last_index: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices of the minimum values along a specified axis. When the minimum - value occurs multiple times, only the indices corresponding to the first occurrence - are returned. + """Return the indices of the minimum values along a specified axis. When + the minimum value occurs multiple times, only the indices corresponding to + the first occurrence are returned. Parameters ---------- @@ -264,8 +262,7 @@ def nonzero( size: Optional[int] = None, fill_value: Number = 0, ) -> Union[Tuple[ivy.Array], ivy.Array]: - """ - Return the indices of the array elements which are non-zero. + """Return the indices of the array elements which are non-zero. .. note:: If ``x`` has a complex floating-point data type, non-zero elements @@ -401,8 +398,7 @@ def where( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return elements chosen from x or y depending on condition. + """Return elements chosen from x or y depending on condition. Parameters ---------- @@ -485,8 +481,7 @@ def argwhere( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices of all non-zero elements of the input array. + """Return the indices of all non-zero elements of the input array. Parameters ---------- diff --git a/ivy/functional/ivy/set.py b/ivy/functional/ivy/set.py index 0c0d916b24cc4..10ae870d1b89a 100644 --- a/ivy/functional/ivy/set.py +++ b/ivy/functional/ivy/set.py @@ -38,10 +38,10 @@ def unique_all( Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray], ]: - """ - Return the unique elements of an input array ``x``, the first occurring indices for - each unique element in ``x``, the indices from the set of unique elements that - reconstruct ``x``, and the corresponding counts for each unique element in ``x``. + """Return the unique elements of an input array ``x``, the first occurring + indices for each unique element in ``x``, the indices from the set of + unique elements that reconstruct ``x``, and the corresponding counts for + each unique element in ``x``. .. admonition:: Data-dependent output shape :class: important @@ -161,9 +161,8 @@ def unique_inverse( *, axis: Optional[int] = None, ) -> Tuple[Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray]]: - """ - Return the unique elements of an input array ``x``, and the indices from the set of - unique elements that reconstruct ``x``. + """Return the unique elements of an input array ``x``, and the indices from + the set of unique elements that reconstruct ``x``. .. admonition:: Data-dependent output shape :class: important @@ -276,8 +275,7 @@ def unique_values( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the unique elements of an input array ``x``. + """Return the unique elements of an input array ``x``. .. admonition:: Data-dependent output shape :class: important @@ -367,9 +365,8 @@ def unique_counts( x: Union[ivy.Array, ivy.NativeArray], /, ) -> Tuple[Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray]]: - """ - Return the unique elements of an input array ``x`` and the corresponding counts for - each unique element in ``x``. + """Return the unique elements of an input array ``x`` and the corresponding + counts for each unique element in ``x``. .. admonition:: Data-dependent output shape :class: important diff --git a/ivy/functional/ivy/sorting.py b/ivy/functional/ivy/sorting.py index fe073103f1541..7e3e7daaac313 100644 --- a/ivy/functional/ivy/sorting.py +++ b/ivy/functional/ivy/sorting.py @@ -36,8 +36,7 @@ def argsort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices that sort an array ``x`` along a specified axis. + """Return the indices that sort an array ``x`` along a specified axis. Parameters ---------- @@ -157,8 +156,7 @@ def sort( stable: bool = True, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a sorted copy of an array. + """Return a sorted copy of an array. Parameters ---------- @@ -259,8 +257,7 @@ def msort( *, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return a copy of an array sorted along the first axis. + """Return a copy of an array sorted along the first axis. Parameters ---------- @@ -308,8 +305,7 @@ def searchsorted( ret_dtype: Union[ivy.Dtype, ivy.NativeDtype] = ivy.int64, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the indices of the inserted elements in a sorted array. + """Return the indices of the inserted elements in a sorted array. Parameters ---------- diff --git a/ivy/functional/ivy/statistical.py b/ivy/functional/ivy/statistical.py index 2b8321c71682d..e6d80c8809c49 100644 --- a/ivy/functional/ivy/statistical.py +++ b/ivy/functional/ivy/statistical.py @@ -52,8 +52,7 @@ def min( where: Optional[ivy.Array] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the minimum value of the input array ``x``. + """Calculate the minimum value of the input array ``x``. .. note:: When the number of elements over which to compute the minimum value is zero, the @@ -168,8 +167,7 @@ def max( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the maximum value of the input array ``x``. + """Calculate the maximum value of the input array ``x``. .. note:: When the number of elements over which to compute the maximum value is zero, the @@ -279,8 +277,7 @@ def mean( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the arithmetic mean of the input array ``x``. + """Calculate the arithmetic mean of the input array ``x``. **Special Cases** @@ -392,8 +389,7 @@ def prod( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the product of input array x elements. + """Calculate the product of input array x elements. **Special Cases** @@ -528,8 +524,7 @@ def std( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the standard deviation of the input array ``x``. + """Calculate the standard deviation of the input array ``x``. **Special Cases** @@ -667,8 +662,7 @@ def sum( keepdims: Optional[bool] = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the sum of the input array x. + """Calculate the sum of the input array x. **Special Cases** @@ -808,8 +802,7 @@ def var( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Calculate the variance of the input array x. + """Calculate the variance of the input array x. **Special Cases** @@ -925,8 +918,7 @@ def cumsum( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the cumulative sum of the elements along a given axis. + """Return the cumulative sum of the elements along a given axis. Parameters ---------- @@ -1071,8 +1063,7 @@ def cumprod( dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Return the cumulative product of the elements along a given axis. + """Return the cumulative product of the elements along a given axis. Parameters ---------- @@ -1204,9 +1195,8 @@ def einsum( *operands: Union[ivy.Array, ivy.NativeArray], out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Sum the product of the elements of the input operands along dimensions specified - using a notation based on the Einstein summation convention. + """Sum the product of the elements of the input operands along dimensions + specified using a notation based on the Einstein summation convention. Parameters ---------- diff --git a/ivy/functional/ivy/utility.py b/ivy/functional/ivy/utility.py index 09bd432b60291..d323e0f91cda5 100644 --- a/ivy/functional/ivy/utility.py +++ b/ivy/functional/ivy/utility.py @@ -33,8 +33,8 @@ def all( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test whether all input array elements evaluate to ``True`` along a specified axis. + """Test whether all input array elements evaluate to ``True`` along a + specified axis. .. note:: Positive infinity, negative infinity, and NaN must evaluate to ``True``. @@ -147,8 +147,8 @@ def any( keepdims: bool = False, out: Optional[ivy.Array] = None, ) -> ivy.Array: - """ - Test whether any input array element evaluates to ``True`` along a specified axis. + """Test whether any input array element evaluates to ``True`` along a + specified axis. .. note:: Positive infinity, negative infinity, and NaN must evaluate to ``True``. diff --git a/ivy/stateful/activations.py b/ivy/stateful/activations.py index ae3991c099122..65d158af4b6cc 100644 --- a/ivy/stateful/activations.py +++ b/ivy/stateful/activations.py @@ -13,8 +13,7 @@ def __init__( approximate: bool = False, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the GELU activation function. + """Apply the GELU activation function. Parameters ---------- @@ -29,8 +28,7 @@ def __init__( Module.__init__(self) def _forward(self, x): - """ - Perform forward pass of the GELU activation. + """Perform forward pass of the GELU activation. Parameters ---------- @@ -58,8 +56,7 @@ def __init__(self): Module.__init__(self) def _forward(self, inputs): - """ - Perform forward pass of the GEGLU activation. + """Perform forward pass of the GEGLU activation. Parameters ---------- @@ -80,8 +77,7 @@ def __init__( self, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the RELU activation function. + """Apply the RELU activation function. Parameters ---------- @@ -117,8 +113,7 @@ def __init__( alpha: float = 0.2, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the LEAKY RELU activation function. + """Apply the LEAKY RELU activation function. Parameters ---------- @@ -161,8 +156,7 @@ def __init__( axis: Optional[int] = -1, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the LOG SOFTMAX activation function. + """Apply the LOG SOFTMAX activation function. Parameters ---------- @@ -201,8 +195,7 @@ def __init__( axis: int = -1, complex_mode: Literal["split", "magnitude", "jax"] = "jax", ): - """ - Apply the SOFTMAX activation function. + """Apply the SOFTMAX activation function. Parameters ---------- @@ -314,8 +307,7 @@ def _forward(self, x): class Sigmoid(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the SIGMOID activation function. + """Apply the SIGMOID activation function. Parameter ---------- @@ -347,8 +339,7 @@ def _extra_repr(self) -> str: class Tanh(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the TANH activation function. + """Apply the TANH activation function. Parameters ---------- @@ -380,8 +371,7 @@ def _extra_repr(self) -> str: class ReLU6(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the TANH activation function. + """Apply the TANH activation function. Parameters ---------- @@ -413,8 +403,7 @@ def _extra_repr(self) -> str: class Hardswish(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the HARDSWISH activation function. + """Apply the HARDSWISH activation function. Parameters ---------- @@ -450,8 +439,7 @@ def __init__( eps=None, complex_mode="jax", ): - """ - Apply the LOGIT activation function. + """Apply the LOGIT activation function. Parameters ---------- @@ -564,8 +552,7 @@ def _extra_repr(self) -> str: class LogSigmoid(Module): def __init__(self, complex_mode: Literal["split", "magnitude", "jax"] = "jax"): - """ - Apply the LogSigmoid activation function. + """Apply the LogSigmoid activation function. Parameter ---------- diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index 1f91646840b5f..834096133f581 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -21,9 +21,8 @@ def to_ivy_module( devices=None, inplace_update=False, ): - """ - Convert an instance of a trainable module from a native framework into a trainable - ivy.Module instance. + """Convert an instance of a trainable module from a native framework into a + trainable ivy.Module instance. Parameters ---------- @@ -76,8 +75,7 @@ def from_haiku_module( device=None, devices=None, ): - """ - Convert a Haiku module instance to an Ivy module instance. + """Convert a Haiku module instance to an Ivy module instance. Parameters ---------- @@ -170,8 +168,7 @@ def from_flax_module( device=None, devices=None, ): - """ - Convert a Flax module instance to an Ivy module instance. + """Convert a Flax module instance to an Ivy module instance. Parameters ---------- @@ -260,8 +257,7 @@ def from_keras_module( device=None, devices=None, ): - """ - Convert a Keras module instance to an Ivy module instance. + """Convert a Keras module instance to an Ivy module instance. Parameters ---------- @@ -323,8 +319,7 @@ def from_paddle_module( device=None, devices=None, ): - """ - Convert a Paddle layer instance to an Ivy module instance. + """Convert a Paddle layer instance to an Ivy module instance. Parameters ---------- @@ -380,8 +375,7 @@ def from_torch_module( devices=None, inplace_update=False, ): - """ - Convert a Torch module instance to an Ivy module instance. + """Convert a Torch module instance to an Ivy module instance. Parameters ---------- @@ -440,8 +434,8 @@ def from_torch_module( ) def to_keras_module(self): - """ - Convert a `ivy.Module` module instance to a `tf.keras.Model` instance. + """Convert a `ivy.Module` module instance to a `tf.keras.Model` + instance. Returns ------- diff --git a/ivy/stateful/helpers.py b/ivy/stateful/helpers.py index 675b30a70c496..c62ea0bea79f1 100644 --- a/ivy/stateful/helpers.py +++ b/ivy/stateful/helpers.py @@ -19,8 +19,8 @@ def _find_variables( without_initialisation=False, _visited=None, ): - """ - Find all internal variables in obj. Return empty Container if obj is None. + """Find all internal variables in obj. Return empty Container if obj is + None. Parameters ---------- @@ -100,10 +100,10 @@ def _build_and_return_v(self, *args, **kwargs): @staticmethod def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): - """ - Extract the variables from the variables container v using the key - orig_key_chain and reinstantiate the duplicate variables that were removed by - _remove_duplicate_variables in their correct locations using keychain_mappings. + """Extract the variables from the variables container v using the key + orig_key_chain and reinstantiate the duplicate variables that were + removed by _remove_duplicate_variables in their correct locations using + keychain_mappings. Parameters ---------- @@ -137,8 +137,7 @@ def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): @staticmethod def _remove_duplicate_variables(vs, created, /): - """ - Remove duplicate variables in `vs` referring to `created`. + """Remove duplicate variables in `vs` referring to `created`. Parameters ---------- @@ -182,10 +181,9 @@ def found_dup_callback(x, kc): def _wrap_call_methods( self, keychain_mappings, /, *, key="", obj=None, _visited=None ): - """ - Wrap the call methods of the Module object by looping over all the items within - the module, wrapping the __call__ methods of all submodules using - _fn_with_var_arg. + """Wrap the call methods of the Module object by looping over all the + items within the module, wrapping the __call__ methods of all + submodules using _fn_with_var_arg. Parameters ---------- @@ -242,8 +240,8 @@ def _wrap_call_methods( return def _call(self, *args, v=None, buffers=None, **kwargs): - """ - Compute forward pass of the layer, treating layer instance as callable function. + """Compute forward pass of the layer, treating layer instance as + callable function. Parameters ---------- @@ -337,8 +335,7 @@ def _fn_with_var_arg_wrapper( return fn(*a, **kw, v=v) def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): - """ - Extract variables from `v_fn` and use it as inputs for `fn`. + """Extract variables from `v_fn` and use it as inputs for `fn`. Use `v_fn` to extract the variables and use the extracted variables as inputs to the call function fn of the module. @@ -354,9 +351,9 @@ def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): return _fn_with_var_arg_wrapper def _convert_tensors_to_numpy(self): - """ - Recursively traverses the module_dict attribute of a Module object and converts - every container containing tensors to numpy using the to_numpy() method. + """Recursively traverses the module_dict attribute of a Module object + and converts every container containing tensors to numpy using the + to_numpy() method. Returns ------- @@ -369,9 +366,9 @@ def _convert_tensors_to_numpy(self): self.v = self.v.to_numpy() def _convert_numpy_to_tensors(self): - """ - Recursively traverses the module_dict attribute of a Module object and converts - every container containing tensors to numpy using the to_numpy() method. + """Recursively traverses the module_dict attribute of a Module object + and converts every container containing tensors to numpy using the + to_numpy() method. Returns ------- diff --git a/ivy/stateful/initializers.py b/ivy/stateful/initializers.py index 1481fce608f80..5f2f0a7907add 100644 --- a/ivy/stateful/initializers.py +++ b/ivy/stateful/initializers.py @@ -12,8 +12,7 @@ class Initializer(abc.ABC): - """ - An initializer for internal variables for a layer. + """An initializer for internal variables for a layer. A neuron is a function of the form `a = g(z)`, where `g` is the activation functions and `z = w_1x_1 + w_2x_2 + ... + w_nx_n` where the @@ -31,8 +30,7 @@ def create_variables( fan_in: Optional[float] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ) -> ivy.Array: - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -59,8 +57,8 @@ def create_variables( class Constant(Initializer): def __init__(self, constant: float): - """ - Constant initializer, will fill in all values with the value of `constant`. + """Constant initializer, will fill in all values with the value of + `constant`. Parameters ---------- @@ -100,9 +98,9 @@ def __init__(self): class Uniform(Initializer): def __init__(self, numerator, fan_mode, power, gain): - """ - Initialize based on a uniform distribution, will fill in all values with values - drawn from a uniform (all values have an equal probability) distribution. + """Initialize based on a uniform distribution, will fill in all values + with values drawn from a uniform (all values have an equal probability) + distribution. with range `[-wlim, wlim]` (endpoints included) with `wlim` being calculated as `gain * (numerator / fan)**power`. This distribution helps with issues when @@ -141,8 +139,7 @@ def __init__(self, numerator, fan_mode, power, gain): def create_variables( self, var_shape, device, fan_out=None, fan_in=None, dtype=None ): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -215,8 +212,8 @@ def create_variables( class GlorotUniform(Uniform): def __init__(self): - """ - Initialize Glorot uniform, also known as the Xavier uniform initializer. + """Initialize Glorot uniform, also known as the Xavier uniform + initializer. It draws values from a uniform distribution `[-limit, limit]` where `limit = sqrt(6 / (fan_in + fan_out))` where `fan_in` and `fan_out` are the @@ -227,8 +224,7 @@ def __init__(self): class FirstLayerSiren(Uniform): def __init__(self): - """ - Initialize Siren uniform for the first layer. + """Initialize Siren uniform for the first layer. It draws values from a uniform distribution `[-limit, limit]` where `limit=fan_in` where `fan_in` is the number of input @@ -239,8 +235,7 @@ def __init__(self): class Siren(Uniform): def __init__(self, w0=30): - """ - Initialize Siren uniform initializer for the first layer. + """Initialize Siren uniform initializer for the first layer. It draws values from a uniform distribution `[-limit, limit]` where `limit=sqrt(6 / fan_in) / w0` where `fan_in` is the number @@ -255,8 +250,7 @@ def __init__(self, w0=30): class KaimingNormal(Initializer): def __init__(self, mean=0, fan_mode="fan_in"): - """ - Initialize Kaiming normal, also known as He Initialization. + """Initialize Kaiming normal, also known as He Initialization. It is an method for initializing layers that takes into account the non-linearity of activation functions. It uses a normal distribution centered @@ -292,8 +286,7 @@ def create_variables( negative_slope=0.0, dtype=None, ): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -369,8 +362,7 @@ def create_variables( class RandomNormal(Initializer): def __init__(self, mean=0.0, stddev=0.05, seed=None): - """ - Initialize with Random Normal Distribution. + """Initialize with Random Normal Distribution. It draws values from a Random Normal Distribution with given mean and standard deviation. @@ -394,8 +386,7 @@ def create_variables( device=None, dtype=None, ): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- diff --git a/ivy/stateful/layers.py b/ivy/stateful/layers.py index 0fb5d4adcca41..e2cad240cccf8 100644 --- a/ivy/stateful/layers.py +++ b/ivy/stateful/layers.py @@ -28,11 +28,11 @@ def __init__( v=None, dtype=None, ): - """ - Linear layer, also referred to as dense or fully connected. The layer receives - tensors with input_channels last dimension and returns a new tensor with - output_channels last dimension, following matrix multiplication with the weight - matrix and addition with the bias vector. + """Linear layer, also referred to as dense or fully connected. The + layer receives tensors with input_channels last dimension and returns a + new tensor with output_channels last dimension, following matrix + multiplication with the weight matrix and addition with the bias + vector. Parameters ---------- @@ -66,8 +66,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -103,8 +102,7 @@ def _create_variables(self, device=None, dtype=None): return v def _forward(self, x): - """ - Perform forward pass of the Linear layer. + """Perform forward pass of the Linear layer. Parameters ---------- @@ -138,9 +136,9 @@ def __init__( dtype=None, training: bool = True, ): - """ - Dropout layer. The layer randomly zeroes some of the elements of the input - tensor with probability p using samples from a Bernoull distribution. + """Dropout layer. The layer randomly zeroes some of the elements of the + input tensor with probability p using samples from a Bernoull + distribution. Parameters ---------- @@ -159,8 +157,7 @@ def __init__( Module.__init__(self, device=None, v=None, dtype=dtype, training=training) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -174,8 +171,7 @@ def _create_variables(self, device, dtype=None): return {} def _forward(self, inputs, dtype=None): - """ - Perform forward pass of the Linear layer. + """Perform forward pass of the Linear layer. Parameters ---------- @@ -226,8 +222,7 @@ def __init__( dtype=None, training=True, ): - """ - Multi Head Attention layer. + """Multi Head Attention layer. Parameters ---------- @@ -392,8 +387,7 @@ def _forward( return_attention_weights=False, average_attention_weights=True, ): - """ - Perform forward pass of the MultiHeadAttention layer. + """Perform forward pass of the MultiHeadAttention layer. Parameters ---------- @@ -485,8 +479,7 @@ def __init__( v=None, dtype=None, ): - """ - 1D convolutional layer. + """1D convolutional layer. Parameters ---------- @@ -538,8 +531,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -575,8 +567,7 @@ def _create_variables(self, device=None, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv1D layer. + """Perform forward pass of the Conv1D layer. Parameters ---------- @@ -631,8 +622,7 @@ def __init__( v=None, dtype=None, ): - """ - 1D transpose convolutional layer. + """1D transpose convolutional layer. Parameters ---------- @@ -687,8 +677,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -724,8 +713,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv1DTranspose layer. + """Perform forward pass of the Conv1DTranspose layer. Parameters ---------- @@ -782,8 +770,7 @@ def __init__( v=None, dtype=None, ): - """ - 2D convolutional layer. + """2D convolutional layer. Parameters ---------- @@ -837,8 +824,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -874,8 +860,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv2D layer. + """Perform forward pass of the Conv2D layer. Parameters ---------- @@ -930,8 +915,7 @@ def __init__( v=None, dtype=None, ): - """ - 2D convolutional transpose layer. + """2D convolutional transpose layer. Parameters ---------- @@ -988,8 +972,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1025,8 +1008,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv2DTranspose layer. + """Perform forward pass of the Conv2DTranspose layer. Parameters ---------- @@ -1082,8 +1064,7 @@ def __init__( v=None, dtype=None, ): - """ - Depthwise 2D convolutional layer. + """Depthwise 2D convolutional layer. Parameters ---------- @@ -1134,8 +1115,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1171,8 +1151,7 @@ def _create_variables(self, device, dtype): return v def _forward(self, inputs): - """ - Perform forward pass of the DepthwiseConv2D layer. + """Perform forward pass of the DepthwiseConv2D layer. Parameters ---------- @@ -1226,8 +1205,7 @@ def __init__( v=None, dtype=None, ): - """ - 3D convolutional layer. + """3D convolutional layer. Parameters ---------- @@ -1281,8 +1259,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1318,8 +1295,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv3D layer. + """Perform forward pass of the Conv3D layer. Parameters ---------- @@ -1375,8 +1351,7 @@ def __init__( v=None, dtype=None, ): - """ - 3D convolutional transpose layer. + """3D convolutional transpose layer. Parameters ---------- @@ -1434,8 +1409,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1471,8 +1445,7 @@ def _create_variables(self, device, dtype=None): return v def _forward(self, inputs): - """ - Perform forward pass of the Conv3DTranspose layer. + """Perform forward pass of the Conv3DTranspose layer. Parameters ---------- @@ -1530,8 +1503,7 @@ def __init__( v=None, dtype=None, ): - """ - LSTM layer, which is a set of stacked lstm cells. + """LSTM layer, which is a set of stacked lstm cells. Parameters ---------- @@ -1571,8 +1543,8 @@ def __init__( # Public # def get_initial_state(self, batch_shape, dtype=None): - """ - Get the initial state of the hidden and cell states, if not provided explicitly. + """Get the initial state of the hidden and cell states, if not provided + explicitly. Parameters ---------- @@ -1597,8 +1569,7 @@ def get_initial_state(self, batch_shape, dtype=None): # Overridden def _create_variables(self, device=None, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -1656,8 +1627,7 @@ def _create_variables(self, device=None, dtype=None): @handle_nestable def _forward(self, inputs, initial_state=None): - """ - Perform forward pass of the LSTM layer. + """Perform forward pass of the LSTM layer. Parameters ---------- @@ -1726,8 +1696,7 @@ def __init__( v=None, dtype=None, ): - """ - Class for applying Max Pooling over a mini-batch of inputs. + """Class for applying Max Pooling over a mini-batch of inputs. Parameters ---------- @@ -1747,8 +1716,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -1787,8 +1755,7 @@ def __init__( v=None, dtype=None, ): - """ - Class for applying Average Pooling over a mini-batch of inputs. + """Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -1808,8 +1775,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -1848,8 +1814,7 @@ def __init__( v=None, dtype=None, ): - """ - Class for applying Max Pooling over a mini-batch of inputs. + """Class for applying Max Pooling over a mini-batch of inputs. Parameters ---------- @@ -1869,8 +1834,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -1908,8 +1872,7 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying 3D Max Pooling over 5D inputs. + """Class for applying 3D Max Pooling over 5D inputs. Parameters ---------- @@ -1927,8 +1890,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -1967,8 +1929,7 @@ def __init__( ceil_mode=False, divisor_override=None, ): - """ - Class for applying Average Pooling over a mini-batch of inputs. + """Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -1998,8 +1959,7 @@ def __init__( Module.__init__(self) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2045,8 +2005,8 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying a 2D adaptive average pooling over mini-batch of inputs. + """Class for applying a 2D adaptive average pooling over mini-batch of + inputs. Parameters ---------- @@ -2062,8 +2022,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2092,8 +2051,8 @@ def __init__( dtype=None, ): # TODO: add data_format param - """ - Class for applying a 1D adaptive average pooling over mini-batch of inputs. + """Class for applying a 1D adaptive average pooling over mini-batch of + inputs. Parameters ---------- @@ -2107,8 +2066,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2142,8 +2100,7 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying FFT to input. + """Class for applying FFT to input. Parameters ---------- @@ -2163,8 +2120,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2203,8 +2159,7 @@ def __init__( *, data_format="NWC", ): - """ - Class for applying Average Pooling over a mini-batch of inputs. + """Class for applying Average Pooling over a mini-batch of inputs. Parameters ---------- @@ -2224,8 +2179,7 @@ def __init__( Module.__init__(self) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2262,8 +2216,8 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying the Discrete Cosine Transform over mini-batch of inputs. + """Class for applying the Discrete Cosine Transform over mini-batch of + inputs. Parameters ---------- @@ -2288,8 +2242,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2337,10 +2290,9 @@ def __init__( v=None, dtype=None, ): - """ - Class for embedding indices into a dense representation. The Embedding layer is - a simple lookup table for dense vectors. It's typically used to store word - embeddings and query them using indices. + """Class for embedding indices into a dense representation. The + Embedding layer is a simple lookup table for dense vectors. It's + typically used to store word embeddings and query them using indices. Parameters ---------- @@ -2371,8 +2323,7 @@ def __init__( Module.__init__(self, device=device, v=v, dtype=dtype) def _create_variables(self, device=None, dtype=None): - """ - Create internal variables for the layer. + """Create internal variables for the layer. Parameters ---------- @@ -2402,8 +2353,7 @@ def _pad_embd(self, indices, embd): return ivy.where(mask, mask_val, embd) def _forward(self, indices): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2430,9 +2380,8 @@ def _extra_repr(self): class Identity(Module): def __init__(self): - """ - Identity layer. The layer is argument insensitive and returns the input argument - as output when called. + """Identity layer. The layer is argument insensitive and returns the + input argument as output when called. It's typically used as a placeholder when no operation is to be performed. It doesn't have any learnable parameter. @@ -2440,8 +2389,7 @@ def __init__(self): Module.__init__(self) def _forward(self, x): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- @@ -2470,8 +2418,7 @@ def __init__( device=None, dtype=None, ): - """ - Class for applying IFFT to input. + """Class for applying IFFT to input. Parameters ---------- @@ -2497,8 +2444,7 @@ def __init__( Module.__init__(self, device=device, dtype=dtype) def _forward(self, inputs): - """ - Forward pass of the layer. + """Forward pass of the layer. Parameters ---------- diff --git a/ivy/stateful/losses.py b/ivy/stateful/losses.py index 1970659dd3be1..77a47b94a0d1e 100644 --- a/ivy/stateful/losses.py +++ b/ivy/stateful/losses.py @@ -21,8 +21,7 @@ def __init__( def _forward( self, true, pred, *, compute_full_loss=None, axis=None, reduction=None ): - """ - Perform forward pass of the Log Poisson Loss. + """Perform forward pass of the Log Poisson Loss. true input array containing true labels. @@ -74,8 +73,7 @@ def __init__( Module.__init__(self) def _forward(self, true, pred, *, axis=None, epsilon=None, reduction=None): - """ - Perform forward pass of the Cross Entropy Loss. + """Perform forward pass of the Cross Entropy Loss. true input array containing true labels. diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 11e3a9838fda8..12a16f95f39dc 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -53,9 +53,8 @@ def __init__( device=None, **kwargs, ): - """ - Initialize Ivy layer, which is a stateful object consisting of trainable - variables. + """Initialize Ivy layer, which is a stateful object consisting of + trainable variables. Parameters ---------- @@ -160,8 +159,7 @@ def build( dynamic_backend=None, **kwargs, ): - """ - Build the internal layers and variables for this module. + """Build the internal layers and variables for this module. Parameters ---------- @@ -304,9 +302,8 @@ def trace_graph( kwargs: Optional[Dict] = None, **trace_kwargs, ): - """ - Trace the `ivy.Module`'s `_unified_ivy_graph` or `_call` method to the target - backend. + """Trace the `ivy.Module`'s `_unified_ivy_graph` or `_call` method to + the target backend. Parameters ---------- @@ -339,8 +336,7 @@ def trace_graph( self._lazy_traced = False def register_buffer(self, name, value): - """ - Register a buffer. + """Register a buffer. Parameters ---------- @@ -355,8 +351,7 @@ def register_buffer(self, name, value): super().__setattr__(name, value) def register_parameter(self, name, value): - """ - Register a parameter. + """Register a parameter. Parameters ---------- @@ -418,8 +413,7 @@ def show_graph( ) def save_weights(self, weights_path, /): - """ - Save the weights on the Module. + """Save the weights on the Module. Parameters ---------- @@ -434,8 +428,7 @@ def save_weights(self, weights_path, /): self.v.cont_to_disk_as_hdf5(weights_path) def save(self, filename): - """ - Save the module object to disk using pickle. + """Save the module object to disk using pickle. Parameters ---------- @@ -451,8 +444,7 @@ def save(self, filename): @staticmethod def load(filename): - """ - Load a module object from disk using pickle. + """Load a module object from disk using pickle. Parameters ---------- @@ -480,8 +472,7 @@ def __call__( buffers=None, **kwargs, ): - """ - Forward an input through current module. + """Forward an input through current module. Parameters ---------- @@ -578,9 +569,8 @@ def __repr__(self): # -----------------------------------# def _create_variables(self, *, device=None, dtype=None): - """ - Create internal trainable variables, and return as arbitrary nested dict. - Overridable. + """Create internal trainable variables, and return as arbitrary nested + dict. Overridable. Parameters ---------- @@ -597,8 +587,8 @@ def _create_variables(self, *, device=None, dtype=None): return {} def _build(self, *args, **kwargs) -> bool: - """ - Build the internal layers and variables for this module. Overridable. + """Build the internal layers and variables for this module. + Overridable. Returns ------- @@ -610,8 +600,8 @@ def _build(self, *args, **kwargs) -> bool: return True def _forward(self, *args, **kwargs): - """ - Forward pass of the layer, called after handling the optional input variables. + """Forward pass of the layer, called after handling the optional input + variables. Raises ------ @@ -620,8 +610,7 @@ def _forward(self, *args, **kwargs): raise ivy.utils.exceptions.IvyNotImplementedException def _extra_repr(self) -> str: - """ - Set the extra representation of the module. + """Set the extra representation of the module. To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line @@ -662,7 +651,8 @@ def buffers(self): @property def state_dict(self): - """Return the state_dict which is a collection of the variables and buffers.""" + """Return the state_dict which is a collection of the variables and + buffers.""" return {**self.v, **self.buffers} @property diff --git a/ivy/stateful/norms.py b/ivy/stateful/norms.py index 9e68fe433651e..5c8e3c44a53b5 100644 --- a/ivy/stateful/norms.py +++ b/ivy/stateful/norms.py @@ -19,8 +19,7 @@ def __init__( v=None, dtype=None, ): - """ - Class for applying Layer Normalization over a mini-batch of inputs. + """Class for applying Layer Normalization over a mini-batch of inputs. Parameters ---------- @@ -68,8 +67,7 @@ def _create_variables(self, device=None, dtype=None): return {} def _forward(self, inputs): - """ - Perform forward pass of the LayerNorm layer. + """Perform forward pass of the LayerNorm layer. Parameters ---------- @@ -113,8 +111,7 @@ def __init__( dtype=None, training=True, ): - """ - Class for applying Layer Normalization over a mini-batch of inputs. + """Class for applying Layer Normalization over a mini-batch of inputs. Parameters ---------- @@ -184,8 +181,7 @@ def _create_variables(self, device=None, dtype=None): return {} def _forward(self, inputs): - """ - Perform forward pass of the BatchNorm layer. + """Perform forward pass of the BatchNorm layer. Parameters ---------- diff --git a/ivy/stateful/optimizers.py b/ivy/stateful/optimizers.py index 9670c4e5aef7a..dafc66d90fbc3 100644 --- a/ivy/stateful/optimizers.py +++ b/ivy/stateful/optimizers.py @@ -24,8 +24,8 @@ def __init__( fallback_to_non_traced: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """ - Construct a general Optimizer. This is an abstract class, and must be derived. + """Construct a general Optimizer. This is an abstract class, and must + be derived. Parameters ---------- @@ -70,9 +70,9 @@ def __init__( @abc.abstractmethod def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v from update step, using nested grads - container. Override this abstract method with child class custom implementation. + """Update nested variables container v from update step, using nested + grads container. Override this abstract method with child class custom + implementation. Parameters ---------- @@ -93,8 +93,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): def _step_fn( self, v: ivy.Container, grads: ivy.Container, ignore_missing: bool = False ): - """ - Call the custom child step function implementation. + """Call the custom child step function implementation. Parameters ---------- @@ -118,8 +117,7 @@ def _step_fn( @abc.abstractmethod def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- @@ -133,8 +131,8 @@ def set_state(self, state: ivy.Container): def step( self, v: ivy.Container, grads: ivy.Container, ignore_missing: bool = False ): - """ - Update nested variables container v from overridden private self._step. + """Update nested variables container v from overridden private + self._step. Parameters ---------- @@ -169,8 +167,7 @@ def __init__( stop_gradients: bool = True, trace_on_next_step: bool = False, ): - """ - Construct a Stochastic-Gradient-Descent (SGD) optimizer. + """Construct a Stochastic-Gradient-Descent (SGD) optimizer. Parameters ---------- @@ -194,9 +191,8 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by gradient descent step, using nested - gradients container. + """Update nested variables container v by gradient descent step, using + nested gradients container. Parameters ---------- @@ -218,8 +214,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): ) def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- @@ -242,8 +237,7 @@ def __init__( stop_gradients: bool = True, trace_on_next_step: bool = False, ): - """ - Construct a Layer-wise Adaptive Rate Scaling (LARS) optimizer. + """Construct a Layer-wise Adaptive Rate Scaling (LARS) optimizer. Parameters ---------- @@ -270,9 +264,8 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by gradient descent step, using nested - gradients container. + """Update nested variables container v by gradient descent step, using + nested gradients container. Parameters ---------- @@ -295,8 +288,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): ) def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- @@ -322,8 +314,7 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """ - Construct an ADAM optimizer. + """Construct an ADAM optimizer. Parameters ---------- @@ -365,9 +356,8 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by Adam update step, using nested grads - container. + """Update nested variables container v by Adam update step, using + nested grads container. Parameters ---------- @@ -401,8 +391,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): return new_v def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- @@ -430,8 +419,7 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """ - Construct an ADAMW optimizer. + """Construct an ADAMW optimizer. Parameters ---------- @@ -473,9 +461,8 @@ def __init__( ) def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by AdamW update step, using nested grads - container. + """Update nested variables container v by AdamW update step, using + nested grads container. Parameters ---------- @@ -510,8 +497,7 @@ def __init__( trace_on_next_step: bool = False, device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None, ): - """ - Construct an LAMB optimizer. + """Construct an LAMB optimizer. Parameters ---------- @@ -558,9 +544,8 @@ def __init__( # Custom Step def _step(self, v: ivy.Container, grads: ivy.Container): - """ - Update nested variables container v by LAMB update step, using nested grads - container. + """Update nested variables container v by LAMB update step, using + nested grads container. Parameters ---------- @@ -596,8 +581,7 @@ def _step(self, v: ivy.Container, grads: ivy.Container): return new_v def set_state(self, state: ivy.Container): - """ - Set state of the optimizer. + """Set state of the optimizer. Parameters ---------- diff --git a/ivy/stateful/sequential.py b/ivy/stateful/sequential.py index 3656b1f3b24af..08bf1a1f56465 100644 --- a/ivy/stateful/sequential.py +++ b/ivy/stateful/sequential.py @@ -16,9 +16,8 @@ def __init__( v: Optional[Union[ivy.Array, ivy.NativeArray]] = None, dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, ): - """ - Initialize a sequential container. Modules will be added to it in the order they - are passed in the constructor. + """Initialize a sequential container. Modules will be added to it in + the order they are passed in the constructor. Parameters ---------- @@ -49,8 +48,7 @@ def __iter__(self): return iter(self._submodules) def _forward(self, inputs): - """ - Perform forward pass of the Sequential container. + """Perform forward pass of the Sequential container. Parameters ---------- diff --git a/ivy/utils/_importlib.py b/ivy/utils/_importlib.py index 1eaecd962124e..01247a3bd719f 100644 --- a/ivy/utils/_importlib.py +++ b/ivy/utils/_importlib.py @@ -74,8 +74,7 @@ def _from_import(name: str, package=None, mod_globals=None, from_list=(), level= def _absolute_import(name: str, asname=None, mod_globals=None): - """ - Handle absolute import statement :param name: + """Handle absolute import statement :param name: :return: """ diff --git a/ivy/utils/backend/ast_helpers.py b/ivy/utils/backend/ast_helpers.py index 795dc94e67931..8e5b2b54c6634 100644 --- a/ivy/utils/backend/ast_helpers.py +++ b/ivy/utils/backend/ast_helpers.py @@ -156,8 +156,7 @@ def _create_attrs_from_node(node, attrs=()): def _create_node(stmnt: str): - """ - Create an AST node from a given statement. + """Create an AST node from a given statement. Parameters ---------- diff --git a/ivy/utils/backend/handler.py b/ivy/utils/backend/handler.py index 576b9a3b6cf34..04974f0557488 100644 --- a/ivy/utils/backend/handler.py +++ b/ivy/utils/backend/handler.py @@ -75,8 +75,7 @@ def _get_backend_for_arg(arg_module_name): def _determine_backend_from_args(args): - """ - Return the appropriate Ivy backend, given some arguments. + """Return the appropriate Ivy backend, given some arguments. Parameters ---------- @@ -121,9 +120,8 @@ def _determine_backend_from_args(args): def set_backend_to_specific_version(backend): - """ - Update the backend dict to make the original function name point to the version - specific one. + """Update the backend dict to make the original function name point to the + version specific one. Parameters ---------- @@ -146,8 +144,8 @@ def set_backend_to_specific_version(backend): def current_backend(*args, **kwargs): - """ - Return the current backend. Priorities: global_backend > argument's backend. + """Return the current backend. Priorities: global_backend > argument's + backend. Parameters ---------- @@ -328,8 +326,7 @@ def _map_fn(x): @prevent_access_locally def set_backend(backend: str, dynamic: bool = False): - """ - Set `backend` to be the global backend. + """Set `backend` to be the global backend. Will also convert all Array and Container objects to the new backend if `dynamic` = True @@ -393,8 +390,7 @@ def set_backend(backend: str, dynamic: bool = False): def set_numpy_backend(): - """ - Set NumPy to be the global backend. + """Set NumPy to be the global backend. equivalent to `ivy.set_backend("numpy")`. """ # noqa @@ -402,8 +398,7 @@ def set_numpy_backend(): def set_jax_backend(): - """ - Set JAX to be the global backend. + """Set JAX to be the global backend. equivalent to `ivy.set_backend("jax")`. """ # noqa @@ -411,8 +406,7 @@ def set_jax_backend(): def set_tensorflow_backend(): - """ - Set TensorFlow to be the global backend. + """Set TensorFlow to be the global backend. equivalent to `ivy.set_backend("tensorflow")`. """ @@ -420,8 +414,7 @@ def set_tensorflow_backend(): def set_torch_backend(): - """ - Set torch to be the global backend. + """Set torch to be the global backend. equivalent to `ivy.set_backend("torch")`. """ # noqa @@ -429,8 +422,7 @@ def set_torch_backend(): def set_paddle_backend(): - """ - Set paddle to be the global backend. + """Set paddle to be the global backend. equivalent to `ivy.set_backend("paddle")`. """ # noqa @@ -438,8 +430,7 @@ def set_paddle_backend(): def set_mxnet_backend(): - """ - Set MXNet to be the global backend. + """Set MXNet to be the global backend. equivalent to `ivy.set_backend("mx")`. """ # noqa @@ -448,10 +439,9 @@ def set_mxnet_backend(): @prevent_access_locally def previous_backend(): - """ - Unset the current global backend, and adjusts the ivy dict such that either a - previously set global backend is then used as the backend, otherwise we return to - Ivy's implementations. + """Unset the current global backend, and adjusts the ivy dict such that + either a previously set global backend is then used as the backend, + otherwise we return to Ivy's implementations. Returns ------- diff --git a/ivy/utils/einsum_parser.py b/ivy/utils/einsum_parser.py index b7b20b89fc22c..697e47d39494b 100644 --- a/ivy/utils/einsum_parser.py +++ b/ivy/utils/einsum_parser.py @@ -12,8 +12,7 @@ def is_valid_einsum_char(x: str) -> bool: - """ - Check if the character ``x`` is valid for numpy einsum. **Examples:** + """Check if the character ``x`` is valid for numpy einsum. **Examples:** ```python is_valid_einsum_char("a") @@ -27,8 +26,7 @@ def is_valid_einsum_char(x: str) -> bool: def has_valid_einsum_chars_only(einsum_str: str) -> bool: # [x] - """ - Check if ``einsum_str`` contains only valid characters for numpy einsum. + """Check if ``einsum_str`` contains only valid characters for numpy einsum. **Examples:** ```python @@ -70,8 +68,7 @@ def get_symbol(i: int) -> str: def gen_unused_symbols(used: str, n: int) -> Iterator[str]: - """ - Generate ``n`` symbols that are not already in ``used``. + """Generate ``n`` symbols that are not already in ``used``. **Examples:** ```python @@ -90,9 +87,9 @@ def gen_unused_symbols(used: str, n: int) -> Iterator[str]: def find_output_str(subscripts: str) -> str: - """ - Find the output string for the inputs ``subscripts`` under canonical einstein - summation rules.That is, repeated indices are summed over by default. + """Find the output string for the inputs ``subscripts`` under canonical + einstein summation rules.That is, repeated indices are summed over by + default. Examples -------- @@ -114,9 +111,8 @@ def find_output_str(subscripts: str) -> str: def find_output_shape( inputs: List[str], shapes: List[TensorShapeType], output: str ) -> TensorShapeType: - """ - Find the output shape for given inputs, shapes and output string, taking into - account broadcasting. + """Find the output shape for given inputs, shapes and output string, taking + into account broadcasting. Examples -------- @@ -138,8 +134,7 @@ def find_output_shape( def possibly_convert_to_numpy(x: Any) -> Any: # possibly convert to native - """ - Convert things without a 'shape' to ndarrays, but leave everything else. + """Convert things without a 'shape' to ndarrays, but leave everything else. Examples -------- @@ -169,8 +164,8 @@ def possibly_convert_to_numpy(x: Any) -> Any: # possibly convert to native def convert_subscripts(old_sub: List[Any], symbol_map: Dict[Any, Any]) -> str: - """ - Convert user custom subscripts list to subscript string according to `symbol_map`. + """Convert user custom subscripts list to subscript string according to + `symbol_map`. Examples -------- @@ -224,9 +219,9 @@ def convert_interleaved_input( def legalise_einsum_expr(*operands: Any) -> str: - """ - Reproduction of einsum c side einsum parsing in python. **Parameters:** Intakes the - same inputs as `contract_path`, but NOT the keyword args. The only. + """Reproduction of einsum c side einsum parsing in python. **Parameters:** + Intakes the same inputs as `contract_path`, but NOT the keyword args. The + only. supported keyword argument is: - **shapes** - *(bool, optional)* Whether diff --git a/ivy/utils/einsum_path_helpers.py b/ivy/utils/einsum_path_helpers.py index c42ce79ebe5e3..465a0122e695e 100644 --- a/ivy/utils/einsum_path_helpers.py +++ b/ivy/utils/einsum_path_helpers.py @@ -11,8 +11,7 @@ def flop_count(idx_contraction, inner, num_terms, size_dictionary): - """ - Compute the number of FLOPS in the contraction. + """Compute the number of FLOPS in the contraction. Parameters ---------- @@ -47,8 +46,8 @@ def flop_count(idx_contraction, inner, num_terms, size_dictionary): def compute_size_by_dict(indices, idx_dict): - """ - Compute the product of the elements in indices based on the dictionary idx_dict. + """Compute the product of the elements in indices based on the dictionary + idx_dict. Parameters ---------- @@ -74,8 +73,7 @@ def compute_size_by_dict(indices, idx_dict): def find_contraction(positions, input_sets, output_set): - """ - Find the contraction for a given set of input and output sets. + """Find the contraction for a given set of input and output sets. Parameters ---------- @@ -131,10 +129,9 @@ def find_contraction(positions, input_sets, output_set): def optimal_path(input_sets, output_set, idx_dict, memory_limit): - """ - Compute all possible pair contractions, sieves the results based on ``memory_limit`` - and returns the lowest cost path. This algorithm scales factorial with respect to - the elements in the list ``input_sets``. + """Compute all possible pair contractions, sieves the results based on + ``memory_limit`` and returns the lowest cost path. This algorithm scales + factorial with respect to the elements in the list ``input_sets``. Parameters ---------- @@ -204,9 +201,8 @@ def optimal_path(input_sets, output_set, idx_dict, memory_limit): def parse_possible_contraction( positions, input_sets, output_set, idx_dict, memory_limit, path_cost, naive_cost ): - """ - Compute the cost (removed size + flops) and resultant indices for performing the - contraction specified by ``positions``. + """Compute the cost (removed size + flops) and resultant indices for + performing the contraction specified by ``positions``. Parameters ---------- @@ -261,9 +257,9 @@ def parse_possible_contraction( def update_other_results(results, best): - """ - Update the positions and provisional input_sets of ``results`` based on performing - the contraction result ``best``. Remove any involving the tensors contracted. + """Update the positions and provisional input_sets of ``results`` based on + performing the contraction result ``best``. Remove any involving the + tensors contracted. Parameters ---------- @@ -299,12 +295,12 @@ def update_other_results(results, best): def greedy_path(input_sets, output_set, idx_dict, memory_limit): - """ - Find the path by contracting the best pair until the input list is exhausted. The - best pair is found by minimizing the tuple ``(-prod(indices_removed), cost)``. What - this amounts to is prioritizing matrix multiplication or inner product operations, - then Hadamard like operations, and finally outer operations. Outer products are - limited by ``memory_limit``. This algorithm scales cubically with respect to the + """Find the path by contracting the best pair until the input list is + exhausted. The best pair is found by minimizing the tuple + ``(-prod(indices_removed), cost)``. What this amounts to is prioritizing + matrix multiplication or inner product operations, then Hadamard like + operations, and finally outer operations. Outer products are limited by + ``memory_limit``. This algorithm scales cubically with respect to the number of elements in the list ``input_sets``. Parameters @@ -411,8 +407,8 @@ def greedy_path(input_sets, output_set, idx_dict, memory_limit): def can_dot(inputs, result, idx_removed): - """ - Check if we can use BLAS (np.tensordot) call and its beneficial to do so. + """Check if we can use BLAS (np.tensordot) call and its beneficial to do + so. Parameters ---------- @@ -514,8 +510,7 @@ def can_dot(inputs, result, idx_removed): def parse_einsum_input(operands, subscripts=None): - """ - Reproduction of einsum c side einsum parsing in python. + """Reproduction of einsum c side einsum parsing in python. Returns ------- diff --git a/ivy/utils/exceptions.py b/ivy/utils/exceptions.py index 32d12b647b075..d8f35b27a5b0e 100644 --- a/ivy/utils/exceptions.py +++ b/ivy/utils/exceptions.py @@ -141,8 +141,7 @@ def _get_traces(curr_obj, area, local_dict, target_name): def _check_if_path_found(path, full_path): - """ - Check if the path is found in the full path. + """Check if the path is found in the full path. Parameters ---------- @@ -160,8 +159,7 @@ def _check_if_path_found(path, full_path): def _configure_stack_trace(traceback): - """ - Configure the stack trace to be displayed in the console. + """Configure the stack trace to be displayed in the console. Parameters ---------- @@ -201,8 +199,7 @@ def _configure_stack_trace(traceback): def _add_native_error(default): - """ - Append the native error to the message if it exists. + """Append the native error to the message if it exists. Parameters ---------- @@ -335,8 +332,7 @@ def __init__(self, *messages, include_backend=False): def handle_exceptions(fn: Callable) -> Callable: @functools.wraps(fn) def _handle_exceptions(*args, **kwargs): - """ - Catch all exceptions and raise them in IvyException. + """Catch all exceptions and raise them in IvyException. Parameters ---------- diff --git a/ivy/utils/inspection.py b/ivy/utils/inspection.py index 2fa60f6f9d839..77feceb756833 100644 --- a/ivy/utils/inspection.py +++ b/ivy/utils/inspection.py @@ -90,9 +90,8 @@ def _get_array_idxs(typ, idx_so_far=None): def fn_array_spec(fn): - """ - Return a specification of the function, indicating all arguments which include - arrays, and the indexes of these. + """Return a specification of the function, indicating all arguments which + include arrays, and the indexes of these. Parameters ---------- diff --git a/ivy/utils/logging.py b/ivy/utils/logging.py index 498424a976cb4..977f3add6f5ec 100644 --- a/ivy/utils/logging.py +++ b/ivy/utils/logging.py @@ -7,8 +7,7 @@ def set_logging_mode(mode): - """ - Set the current logging mode for Ivy. + """Set the current logging mode for Ivy. Possible modes are 'DEBUG', 'INFO', 'WARNING', 'ERROR'. """ @@ -22,7 +21,8 @@ def set_logging_mode(mode): def unset_logging_mode(): - """Remove the most recently set logging mode, returning to the previous one.""" + """Remove the most recently set logging mode, returning to the previous + one.""" if len(logging_mode_stack) > 1: # Remove the current mode logging_mode_stack.pop() diff --git a/ivy/utils/profiler.py b/ivy/utils/profiler.py index c168b1ce7253e..05b7d016a3a16 100644 --- a/ivy/utils/profiler.py +++ b/ivy/utils/profiler.py @@ -9,8 +9,7 @@ class Profiler(cProfile.Profile): - """ - A Profiler class that allows code profiling. + """A Profiler class that allows code profiling. Attributes ---------- diff --git a/ivy_tests/test_docstrings.py b/ivy_tests/test_docstrings.py index af4fae58af2b9..0f582920243ef 100644 --- a/ivy_tests/test_docstrings.py +++ b/ivy_tests/test_docstrings.py @@ -51,8 +51,7 @@ def trim(*, docstring): def check_docstring_examples_run( *, fn, from_container=False, from_array=False, num_sig_fig=2 ): - """ - Performs docstring tests for a given function. + """Performs docstring tests for a given function. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/assertions.py b/ivy_tests/test_ivy/helpers/assertions.py index 539d01b0d9243..b2403339f7b5f 100644 --- a/ivy_tests/test_ivy/helpers/assertions.py +++ b/ivy_tests/test_ivy/helpers/assertions.py @@ -18,9 +18,8 @@ def assert_all_close( atol=1e-08, ground_truth_backend="TensorFlow", ): - """ - Match the ret_np and ret_from_gt_np inputs element-by-element to ensure that they - are the same. + """Match the ret_np and ret_from_gt_np inputs element-by-element to ensure + that they are the same. Parameters ---------- @@ -77,9 +76,8 @@ def assert_same_type_and_shape(values, this_key_chain=None): def assert_same_type(ret_from_target, ret_from_gt, backend_to_test, gt_backend): - """ - Assert that the return types from the target and ground truth frameworks are the - same. + """Assert that the return types from the target and ground truth frameworks + are the same. checks with a string comparison because with_backend returns different objects. Doesn't check recursively. @@ -108,8 +106,8 @@ def value_test( backend: str, ground_truth_backend="TensorFlow", ): - """ - Perform a value test for matching the arrays in ret_np_flat and ret_from_np_gt_flat. + """Perform a value test for matching the arrays in ret_np_flat and + ret_from_np_gt_flat. Parameters ---------- @@ -184,9 +182,8 @@ def value_test( def check_unsupported_dtype(*, fn, input_dtypes, all_as_kwargs_np): - """ - Check whether a function does not support the input data types or the output data - type. + """Check whether a function does not support the input data types or the + output data type. Parameters ---------- @@ -229,8 +226,7 @@ def check_unsupported_dtype(*, fn, input_dtypes, all_as_kwargs_np): def check_unsupported_device(*, fn, input_device, all_as_kwargs_np): - """ - Check whether a function does not support a given device. + """Check whether a function does not support a given device. Parameters ---------- @@ -268,8 +264,7 @@ def check_unsupported_device(*, fn, input_device, all_as_kwargs_np): def check_unsupported_device_and_dtype(*, fn, device, input_dtypes, all_as_kwargs_np): - """ - Check whether a function does not support a given device or data types. + """Check whether a function does not support a given device or data types. Parameters ---------- @@ -304,8 +299,7 @@ def check_unsupported_device_and_dtype(*, fn, device, input_dtypes, all_as_kwarg def test_unsupported_function(*, fn, args, kwargs): - """ - Test a function with an unsupported datatype to raise an exception. + """Test a function with an unsupported datatype to raise an exception. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 01c4199e85ca4..ae7abf618aed0 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -76,9 +76,8 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non def _find_instance_in_args(backend: str, args, array_indices, mask): - """ - Find the first element in the arguments that is considered to be an instance of - Array or Container class. + """Find the first element in the arguments that is considered to be an + instance of Array or Container class. Parameters ---------- @@ -420,9 +419,8 @@ def test_function( return_flat_np_arrays: bool = False, **all_as_kwargs_np, ): - """ - Test a function that consumes (or returns) arrays for the current backend by - comparing the result with numpy. + """Test a function that consumes (or returns) arrays for the current + backend by comparing the result with numpy. Parameters ---------- @@ -758,9 +756,8 @@ def test_frontend_function( test_values: bool = True, **all_as_kwargs_np, ): - """ - Test a frontend function for the current backend by comparing the result with the - function in the associated framework. + """Test a frontend function for the current backend by comparing the result + with the function in the associated framework. Parameters ---------- @@ -1639,9 +1636,8 @@ def test_method( on_device: str, return_flat_np_arrays: bool = False, ): - """ - Test a class-method that consumes (or returns) arrays for the current backend by - comparing the result with numpy. + """Test a class-method that consumes (or returns) arrays for the current + backend by comparing the result with numpy. Parameters ---------- @@ -1944,9 +1940,8 @@ def test_frontend_method( tolerance_dict: Optional[dict] = None, test_values: Union[bool, str] = True, ): - """ - Test a class-method that consumes (or returns) arrays for the current backend by - comparing the result with numpy. + """Test a class-method that consumes (or returns) arrays for the current + backend by comparing the result with numpy. Parameters ---------- @@ -2282,8 +2277,7 @@ def _get_framework_atol(atols: dict, current_fw: str): def _get_nested_np_arrays(nest): - """ - Search for a NumPy arrays in a nest. + """Search for a NumPy arrays in a nest. Parameters ---------- @@ -2313,8 +2307,7 @@ def create_args_kwargs( test_flags: Union[pf.FunctionTestFlags, pf.MethodTestFlags], on_device, ): - """ - Create arguments and keyword-arguments for the function to test. + """Create arguments and keyword-arguments for the function to test. Parameters ---------- @@ -2385,8 +2378,7 @@ def wrap_frontend_function_args(argument): def kwargs_to_args_n_kwargs(*, num_positional_args, kwargs): - """ - Split the kwargs into args and kwargs. + """Split the kwargs into args and kwargs. The first num_positional_args ported to args. """ @@ -2472,8 +2464,7 @@ def flatten_frontend_to_np(*, backend: str, ret): def get_ret_and_flattened_np_array( backend_to_test: str, fn, *args, test_trace=False, precision_mode=False, **kwargs ): - """ - Run func with args and kwargs. + """Run func with args and kwargs. Return the result along with its flattened version. """ diff --git a/ivy_tests/test_ivy/helpers/globals.py b/ivy_tests/test_ivy/helpers/globals.py index e311696ce72ac..d1a4fb6e83791 100644 --- a/ivy_tests/test_ivy/helpers/globals.py +++ b/ivy_tests/test_ivy/helpers/globals.py @@ -1,6 +1,5 @@ -""" -A state holder for testing, this is only intended to hold and store testing data to be -used by the test helpers to prune unsupported data. +"""A state holder for testing, this is only intended to hold and store testing +data to be used by the test helpers to prune unsupported data. Should not be used inside any of the test functions. """ @@ -60,7 +59,8 @@ class TestData: class InterruptedTest(BaseException): - """Indicate that a test tried to write global attributes while a test is running.""" + """Indicate that a test tried to write global attributes while a test is + running.""" def __init__(self, test_interrupted): super().__init__(f"{test_interrupted} was interrupted during execution.") diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py index 0de8cfe26b10c..a0d522617220d 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py @@ -23,8 +23,7 @@ def array_bools( draw, *, size=st.shared(number_helpers.ints(min_value=1, max_value=4), key="size") ): - """ - Draws a list of booleans with a given size. + """Draws a list of booleans with a given size. Parameters ---------- @@ -74,8 +73,7 @@ def array_bools( def list_of_size(*, x, size): - """ - Return a list of the given length with elements drawn randomly from x. + """Return a list of the given length with elements drawn randomly from x. Parameters ---------- @@ -157,8 +155,7 @@ def lists( max_size=None, size_bounds=None, ): - """ - Draws a list with a random bounded size from the data-set x. + """Draws a list with a random bounded size from the data-set x. Parameters ---------- @@ -313,8 +310,8 @@ def dtype_and_values( array_api_dtypes=False, shape_key="shape", ): - """ - Draws a list of arrays with elements from the given corresponding data types. + """Draws a list of arrays with elements from the given corresponding data + types. Parameters ---------- @@ -577,9 +574,8 @@ def dtype_values_axis( force_tuple_axis=False, ret_shape=False, ): - """ - Draws a list of arrays with elements from the given data type, and a random axis of - the arrays. + """Draws a list of arrays with elements from the given data type, and a + random axis of the arrays. Parameters ---------- @@ -817,10 +813,9 @@ def array_indices_axis( indices_same_dims=False, valid_bounds=True, ): - """ - Generate two arrays x & indices, the values in the indices array are indices of the - array x. Draws an integers randomly from the minimum and maximum number of - positional arguments a given function can take. + """Generate two arrays x & indices, the values in the indices array are + indices of the array x. Draws an integers randomly from the minimum and + maximum number of positional arguments a given function can take. Parameters ---------- @@ -1046,10 +1041,9 @@ def array_indices_put_along_axis( values=None, values_dtypes=get_dtypes("valid"), ): - """ - Generate two arrays x & indices, the values in the indices array are indices of the - array x. Draws an integers randomly from the minimum and maximum number of - positional arguments a given function can take. + """Generate two arrays x & indices, the values in the indices array are + indices of the array x. Draws an integers randomly from the minimum and + maximum number of positional arguments a given function can take. Parameters ---------- @@ -1238,8 +1232,7 @@ def arrays_and_axes( return_dtype=False, force_int_axis=False, ): - """ - Generate a list of arrays and axes. + """Generate a list of arrays and axes. Parameters ---------- @@ -1408,8 +1401,8 @@ def array_values( small_abs_safety_factor=1.1, safety_factor_scale="linear", ): - """ - Draws a list (of lists) of a given shape containing values of a given data type. + """Draws a list (of lists) of a given shape containing values of a given + data type. Parameters ---------- @@ -2175,11 +2168,10 @@ def create_concatenable_arrays_dtypes( dtypes, common_shape=None, ): - """ - Draws a random number of arrays with concatenable or stackable dimensions. Arrays - have same number of dimensions, but their shape can differ along a specified - dimension (concat_dim). If concat_dim is None, arrays have the same shape. Dtypes of - arrays can differ. + """Draws a random number of arrays with concatenable or stackable + dimensions. Arrays have same number of dimensions, but their shape can + differ along a specified dimension (concat_dim). If concat_dim is None, + arrays have the same shape. Dtypes of arrays can differ. Parameters ---------- @@ -2242,10 +2234,9 @@ def create_concatenable_arrays_dtypes( # helpers for tests (core and frontend) related to solve function @st.composite def get_first_solve_batch_matrix(draw, choose_adjoint=False): - """ - Generate non-singular left hand side of equation system possibly with a single batch - dimension at the beginning. Use get_second_solve_batch_matrix to get the right hand - side. + """Generate non-singular left hand side of equation system possibly with a + single batch dimension at the beginning. Use get_second_solve_batch_matrix + to get the right hand side. Parameters ---------- @@ -2302,10 +2293,9 @@ def get_first_solve_batch_matrix(draw, choose_adjoint=False): @st.composite def get_second_solve_batch_matrix(draw, allow_simplified=True, choose_side=False): - """ - Generate right hand side of equation system. Possible with a batch dimension and - possibly with several columns of values. Use get_first_solve_batch_matrix to - generate the left hand side. + """Generate right hand side of equation system. Possible with a batch + dimension and possibly with several columns of values. Use + get_first_solve_batch_matrix to generate the left hand side. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py index 31742e5519501..08838b35ae4e7 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/dtype_helpers.py @@ -113,10 +113,10 @@ def get_dtypes( key=None, prune_function=True, ): - """ - Draws a valid dtypes for the test function. For frontend tests, it draws the data - types from the intersection between backend framework data types and frontend - framework dtypes, otherwise, draws it from backend framework data types. + """Draws a valid dtypes for the test function. For frontend tests, it draws + the data types from the intersection between backend framework data types + and frontend framework dtypes, otherwise, draws it from backend framework + data types. Parameters ---------- @@ -262,8 +262,7 @@ def array_dtypes( shared_dtype=False, array_api_dtypes=False, ): - """ - Draws a list of data types. + """Draws a list of data types. Parameters ---------- @@ -363,8 +362,7 @@ def array_dtypes( @st.composite def get_castable_dtype(draw, available_dtypes, dtype: str, x: Optional[list] = None): - """ - Draws castable dtypes for the given dtype based on the current backend. + """Draws castable dtypes for the given dtype based on the current backend. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 7662f4d2753f5..13369be1461dd 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -14,8 +14,7 @@ def matrix_is_stable(x, cond_limit=30): - """ - Check if a matrix is numerically stable or not. + """Check if a matrix is numerically stable or not. Used to avoid numerical instabilities in further computationally heavy calculations. @@ -62,8 +61,7 @@ def apply_safety_factor( large_abs_safety_factor=1.1, safety_factor_scale="linear", ): - """ - Apply safety factor scaling to numeric data type. + """Apply safety factor scaling to numeric data type. Parameters ---------- @@ -225,8 +223,8 @@ def two_broadcastable_shapes(draw): # https://github.com/data-apis/array-api-tests/array_api_tests/test_manipulation_functions.py @st.composite def reshape_shapes(draw, *, shape): - """ - Draws a random shape with the same number of elements as the given shape. + """Draws a random shape with the same number of elements as the given + shape. Parameters ---------- @@ -254,8 +252,7 @@ def reshape_shapes(draw, *, shape): # taken from https://github.com/HypothesisWorks/hypothesis/issues/1115 @st.composite def subsets(draw, *, elements): - """ - Draws a subset of elements from the given elements. + """Draws a subset of elements from the given elements. Parameters ---------- @@ -282,10 +279,9 @@ def get_shape( min_dim_size=1, max_dim_size=10, ): - """ - Draws a tuple of integers drawn randomly from [min_dim_size, max_dim_size] of size - drawn from min_num_dims to max_num_dims. Useful for randomly drawing the shape of an - array. + """Draws a tuple of integers drawn randomly from [min_dim_size, + max_dim_size] of size drawn from min_num_dims to max_num_dims. Useful for + randomly drawing the shape of an array. Parameters ---------- @@ -331,9 +327,8 @@ def get_shape( @st.composite def get_mean_std(draw, *, dtype): - """ - Draws two integers representing the mean and standard deviation for a given data - type. + """Draws two integers representing the mean and standard deviation for a + given data type. Parameters ---------- @@ -355,8 +350,8 @@ def get_mean_std(draw, *, dtype): @st.composite def get_bounds(draw, *, dtype): - """ - Draws two numbers; low and high, for a given data type such that low < high. + """Draws two numbers; low and high, for a given data type such that low < + high. Parameters ---------- @@ -402,8 +397,7 @@ def get_axis( force_tuple=False, force_int=False, ): - """ - Draws one or more axis for the given shape. + """Draws one or more axis for the given shape. Parameters ---------- @@ -517,8 +511,7 @@ def x_and_filters( depthwise=False, mixed_fn_compos=True, ): - """ - Draws a random x and filters for a convolution. + """Draws a random x and filters for a convolution. Parameters ---------- @@ -614,8 +607,8 @@ def x_and_filters( @st.composite def embedding_helper(draw, mixed_fn_compos=True): - """ - Obtain weights for embeddings, the corresponding indices, the padding indices. + """Obtain weights for embeddings, the corresponding indices, the padding + indices. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py index 55e07e3dd7442..71832e0cc3ff9 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py @@ -31,9 +31,8 @@ def floats( safety_factor_scale="linear", mixed_fn_compos=True, ): - """ - Draws an arbitrarily sized list of floats with a safety factor applied to avoid - values being generated at the edge of a dtype limit. + """Draws an arbitrarily sized list of floats with a safety factor applied + to avoid values being generated at the edge of a dtype limit. Parameters ---------- @@ -156,8 +155,7 @@ def ints( safety_factor_scale=None, mixed_fn_compos=True, ): - """ - Draws an integer with a safety factor if specified. + """Draws an integer with a safety factor if specified. Parameters ---------- @@ -221,8 +219,7 @@ def number( safety_factor_scale="linear", mixed_fn_compos=True, ): - """ - Draws integers or floats with a safety factor applied to values. + """Draws integers or floats with a safety factor applied to values. Parameters ---------- diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index 41b2e4d268b01..6c76e6e9f645a 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -60,9 +60,8 @@ def _get_runtime_flag_value(flag): @st.composite def num_positional_args_method(draw, *, method): - """ - Draws an integers randomly from the minimum and maximum number of positional - arguments a given method can take. + """Draws an integers randomly from the minimum and maximum number of + positional arguments a given method can take. Parameters ---------- @@ -92,9 +91,8 @@ def num_positional_args_method(draw, *, method): @st.composite def num_positional_args(draw, *, fn_name: Optional[str] = None): - """ - Draws an integers randomly from the minimum and maximum number of positional - arguments a given function can take. + """Draws an integers randomly from the minimum and maximum number of + positional arguments a given function can take. Parameters ---------- @@ -159,8 +157,7 @@ def num_positional_args_helper(fn_name, backend): def _import_fn(fn_tree: str): - """ - Import a function from function tree string. + """Import a function from function tree string. Parameters ---------- @@ -210,8 +207,7 @@ def _get_method_supported_devices_dtypes_helper( def _get_method_supported_devices_dtypes( method_name: str, class_module: str, class_name: str ): - """ - Get supported devices and data types for a method in Ivy API. + """Get supported devices and data types for a method in Ivy API. Parameters ---------- @@ -277,8 +273,7 @@ def _get_supported_devices_dtypes_helper( def _get_supported_devices_dtypes(fn_name: str, fn_module: str): - """ - Get supported devices and data types for a function in Ivy API. + """Get supported devices and data types for a function in Ivy API. Parameters ---------- @@ -346,8 +341,7 @@ def handle_test( test_cython_wrapper=BuiltCythonWrapperStrategy, **_given_kwargs, ): - """ - Test wrapper for Ivy functions. + """Test wrapper for Ivy functions. The wrapper sets the required test globals and creates test flags strategies. @@ -490,8 +484,7 @@ def handle_frontend_test( precision_mode=BuiltPrecisionModeStrategy, **_given_kwargs, ): - """ - Test wrapper for Ivy frontend functions. + """Test wrapper for Ivy frontend functions. The wrapper sets the required test globals and creates test flags strategies. @@ -641,8 +634,7 @@ def handle_method( method_container_flags=BuiltContainerStrategy, **_given_kwargs, ): - """ - Test wrapper for Ivy methods. + """Test wrapper for Ivy methods. The wrapper sets the required test globals and creates test flags strategies. @@ -760,8 +752,7 @@ def handle_frontend_method( generate_frontend_arrays=BuiltFrontendArrayStrategy, **_given_kwargs, ): - """ - Test wrapper for Ivy frontends methods. + """Test wrapper for Ivy frontends methods. The wrapper sets the required test globals and creates test flags strategies. diff --git a/ivy_tests/test_ivy/test_frontends/__init__.py b/ivy_tests/test_ivy/test_frontends/__init__.py index ebabc54c49ebc..e58ceb7d6761a 100644 --- a/ivy_tests/test_ivy/test_frontends/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/__init__.py @@ -1,6 +1,6 @@ class NativeClass: - """ - An empty class to represent a class that only exist in a specific framework. + """An empty class to represent a class that only exist in a specific + framework. Attributes ---------- @@ -9,8 +9,7 @@ class NativeClass: """ def __init__(self, native_class): - """ - Construct the native class object. + """Construct the native class object. Parameters ---------- diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py index f367dadb14dbc..fb081e1cd406a 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_linalg.py @@ -268,8 +268,8 @@ def test_jax_eig( ): dtype, x = dtype_and_x x = np.array(x[0], dtype=dtype[0]) - """Make symmetric positive-definite since ivy does not support complex data dtypes - currently.""" + """Make symmetric positive-definite since ivy does not support complex data + dtypes currently.""" x = np.matmul(x.T, x) + np.identity(x.shape[0]) * 1e-3 ret, frontend_ret = helpers.test_frontend_function( diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py b/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py index 57785e80fa6bb..6ede0631199e7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/__init__.py @@ -6,7 +6,8 @@ def convnumpy(argument): - """Convert NativeClass in argument to ivy frontend counterpart for numpy.""" + """Convert NativeClass in argument to ivy frontend counterpart for + numpy.""" if isinstance(argument, NativeClass): return numpy_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py index 878ed7e54c44d..d7287dc70ec57 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/helpers.py @@ -27,8 +27,8 @@ def _array_and_axes_permute_helper( max_dim_size, allow_none=False, ): - """ - Return array, its dtype and either the random permutation of its axes or None. + """Return array, its dtype and either the random permutation of its axes or + None. Parameters ---------- @@ -276,9 +276,8 @@ def dtypes_values_casting_dtype( # ufunc num_positional_args helper @st.composite def get_num_positional_args_ufunc(draw, *, fn_name=None): - """ - Draws data randomly from numbers between nin and nargs where nin and nargs are - properties of the given ufunc. + """Draws data randomly from numbers between nin and nargs where nin and + nargs are properties of the given ufunc. Parameters ---------- diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py index d4015efc19a21..498c71af9b446 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linalg/test_matrix_eigenvalues.py @@ -41,8 +41,8 @@ def test_numpy_eig( ): dtype, x = dtype_and_x x = np.array(x[0], dtype=dtype[0]) - """Make symmetric positive-definite since ivy does not support complex data dtypes - currently.""" + """Make symmetric positive-definite since ivy does not support complex data + dtypes currently.""" x = np.matmul(x.T, x) + np.identity(x.shape[0]) * 1e-3 ret, frontend_ret = helpers.test_frontend_function( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py b/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py index a2500afb3e86a..5b086cc0e5096 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/__init__.py @@ -6,7 +6,8 @@ def convpaddle(argument): - """Convert NativeClass in argument to ivy frontend counter part for paddle.""" + """Convert NativeClass in argument to ivy frontend counter part for + paddle.""" if isinstance(argument, NativeClass): return paddle_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py b/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py index 3b53dda915477..85480fbc9a089 100644 --- a/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_scipy/__init__.py @@ -5,7 +5,8 @@ def convscipy(argument): - """Convert NativeClass in argument to ivy frontend counterpart for scipy.""" + """Convert NativeClass in argument to ivy frontend counterpart for + scipy.""" if isinstance(argument, NativeClass): return scipy_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py index 58227bfafc4e0..2b7118d75a902 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/__init__.py @@ -6,7 +6,8 @@ def convtensor(argument): - """Convert NativeClass in argument to ivy frontend counterpart for tensorflow.""" + """Convert NativeClass in argument to ivy frontend counterpart for + tensorflow.""" if isinstance(argument, NativeClass): return tensorflow_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index 101f6f349a4b7..cb35f859a3cbe 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -121,8 +121,9 @@ def _get_shared_dtype(draw): @st.composite def _get_splits(draw, as_list=False): - """Generate valid splits, either by generating an integer that evenly divides the - axis or a list of splits that sum to the length of the axis being split.""" + """Generate valid splits, either by generating an integer that evenly + divides the axis or a list of splits that sum to the length of the axis + being split.""" shape = draw(st.shared(helpers.get_shape(min_num_dims=1), key="value_shape")) axis = draw( st.shared(helpers.get_axis(shape=shape, force_int=True), key="target_axis") diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py b/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py index aac6f175aa7c1..3187545f1376e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/__init__.py @@ -6,7 +6,8 @@ def convtorch(argument): - """Convert NativeClass in argument to ivy frontend counterpart for torch.""" + """Convert NativeClass in argument to ivy frontend counterpart for + torch.""" if isinstance(argument, NativeClass): return torch_classes_to_ivy_classes.get(argument._native_class) return argument diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index e0bbdb8e72e88..3c8a75dbe9702 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -541,7 +541,8 @@ def test_torch_eigvals( test_values=False, ) """In "ret" we have out eigenvalues calculated with our backend and in - "frontend_ret" are our eigenvalues calculated with the specified frontend.""" + "frontend_ret" are our eigenvalues calculated with the specified + frontend.""" """ Depending on the chosen framework there may be small differences between our diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py index e76b88adddc49..6745c947a6d5e 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_manipulation.py @@ -152,8 +152,9 @@ def _get_splits( allow_array_indices=True, is_mod_split=False, ): - """Generate valid splits, either by generating an integer that evenly divides the - axis or a list of splits that sum to the length of the axis being split.""" + """Generate valid splits, either by generating an integer that evenly + divides the axis or a list of splits that sum to the length of the axis + being split.""" shape = draw( st.shared(helpers.get_shape(min_num_dims=min_num_dims), key="value_shape") ) diff --git a/ivy_tests/test_ivy/test_misc/test_array.py b/ivy_tests/test_ivy/test_misc/test_array.py index 12553cf4da570..3098bceadf03c 100644 --- a/ivy_tests/test_ivy/test_misc/test_array.py +++ b/ivy_tests/test_ivy/test_misc/test_array.py @@ -2257,7 +2257,8 @@ def __ivy_array_function__(self, func, types, args, kwargs): return HANDLED_FUNCTIONS[func](*args, **kwargs) def implements(ivy_function): - """Register an __ivy_array_function__ implementation for MyArray objects.""" + """Register an __ivy_array_function__ implementation for MyArray + objects.""" def decorator(func): HANDLED_FUNCTIONS[ivy_function] = func diff --git a/scripts/eager_mode_benchmark/benchmark.py b/scripts/eager_mode_benchmark/benchmark.py index ba568a18de238..77b839bc3f647 100644 --- a/scripts/eager_mode_benchmark/benchmark.py +++ b/scripts/eager_mode_benchmark/benchmark.py @@ -104,9 +104,8 @@ def eager_benchmark( kwargs: Optional[Dict[str, Any]] = None, output_path="./report.csv", ): - """ - Benchmark the function or module passed in input on the required backends and - devices. + """Benchmark the function or module passed in input on the required + backends and devices. Parameters ---------- @@ -280,8 +279,7 @@ def visualize_speed_up( backends: Union[List[str], str] = "all", labels: Optional[Union[List[str], str]] = None, ): - """ - Visualize the speed up results stored in the csv. + """Visualize the speed up results stored in the csv. Parameters ---------- From bd26a28a33b89fc9416fd9482576cd9c5fa10ee4 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 6 Jan 2024 20:35:41 +0000 Subject: [PATCH 510/978] test: exclude 'nearest_jax' interpolation case in frontend test of torch quantile as it is invalid for torch.quantile, and run the test with 'nearest' interpolation. --- .../test_ivy/test_frontends/test_torch/test_reduction_ops.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py index 49ab2e9228a5e..55e9ed5fd0eda 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py @@ -846,6 +846,8 @@ def test_torch_quantile( input_dtype, x, axis, interpolation, q = dtype_and_x if type(axis) is tuple: axis = axis[0] + if interpolation == "nearest_jax": + interpolation = "nearest" helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, From 3e9247a0b0d0e79c65aeb39ebf49e3ce148d6f3e Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 7 Jan 2024 20:33:08 +0530 Subject: [PATCH 511/978] fix: Fixed passing of wrong key-word argument `dim` in `ivy.ifftn()` function call. (#27850) Co-authored-by: NripeshN --- ivy/functional/frontends/scipy/fft/fft.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/scipy/fft/fft.py b/ivy/functional/frontends/scipy/fft/fft.py index 163589eac0f3d..4b9c9a1dbbbd8 100644 --- a/ivy/functional/frontends/scipy/fft/fft.py +++ b/ivy/functional/frontends/scipy/fft/fft.py @@ -38,7 +38,7 @@ def ifft(x, n=None, axis=-1, norm=None, overwrite_x=False): def ifftn( x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, plan=None ): - return ivy.ifftn(x, s=s, dim=axes, norm=norm) + return ivy.ifftn(x, s=s, axes=axes, norm=norm) @to_ivy_arrays_and_back From aa1fcf74f76171b2343cf8341265a2d31d963b82 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 7 Jan 2024 15:47:48 +0000 Subject: [PATCH 512/978] test: fix dtype specification of uint8 for test_torch_set_rng_state get_dtypes does not accept value like "uint8" --- ivy/functional/frontends/torch/random_sampling.py | 1 + .../test_ivy/test_frontends/test_torch/test_random_sampling.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/random_sampling.py b/ivy/functional/frontends/torch/random_sampling.py index 16f7b8494105d..1606971dad777 100644 --- a/ivy/functional/frontends/torch/random_sampling.py +++ b/ivy/functional/frontends/torch/random_sampling.py @@ -255,6 +255,7 @@ def seed() -> int: return int(ivy.randint(-(2**63), 2**63 - 1)) +@with_supported_dtypes({"2.1.2 and below": ("uint8",)}, "torch",) @to_ivy_arrays_and_back def set_rng_state(new_state): return ivy.seed(seed_value=new_state) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_random_sampling.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_random_sampling.py index 2b54f57e84078..9c9cd0341e71c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_random_sampling.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_random_sampling.py @@ -538,7 +538,7 @@ def call(): @handle_frontend_test( fn_tree="torch.set_rng_state", new_state=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("uint8"), + available_dtypes=helpers.get_dtypes("valid"), min_value=0, max_value=10, min_num_dims=1, From 2ef1bb1385dbdcd0b0496ae4db1328d3448fe557 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 7 Jan 2024 16:27:24 +0000 Subject: [PATCH 513/978] fix: ensure the tests for non-implemented poisson in paddle backend skips instead of failing. --- ivy/functional/backends/paddle/experimental/random.py | 4 ++-- ivy/functional/frontends/torch/random_sampling.py | 5 ++++- ivy/functional/ivy/experimental/random.py | 2 +- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/paddle/experimental/random.py b/ivy/functional/backends/paddle/experimental/random.py index 9e1d00a6d3262..50b063a942638 100644 --- a/ivy/functional/backends/paddle/experimental/random.py +++ b/ivy/functional/backends/paddle/experimental/random.py @@ -91,8 +91,8 @@ def poisson( lam: Union[float, paddle.Tensor], *, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, - device: core.Place, - dtype: paddle.dtype, + device: core.Place = None, + dtype: paddle.dtype = None, seed: Optional[int] = None, fill_value: Optional[Union[float, int]] = 0, out: Optional[paddle.Tensor] = None, diff --git a/ivy/functional/frontends/torch/random_sampling.py b/ivy/functional/frontends/torch/random_sampling.py index 1606971dad777..f303496d23710 100644 --- a/ivy/functional/frontends/torch/random_sampling.py +++ b/ivy/functional/frontends/torch/random_sampling.py @@ -255,7 +255,10 @@ def seed() -> int: return int(ivy.randint(-(2**63), 2**63 - 1)) -@with_supported_dtypes({"2.1.2 and below": ("uint8",)}, "torch",) +@with_supported_dtypes( + {"2.1.2 and below": ("uint8",)}, + "torch", +) @to_ivy_arrays_and_back def set_rng_state(new_state): return ivy.seed(seed_value=new_state) diff --git a/ivy/functional/ivy/experimental/random.py b/ivy/functional/ivy/experimental/random.py index e2fc3828473dc..c126aba5c20cf 100644 --- a/ivy/functional/ivy/experimental/random.py +++ b/ivy/functional/ivy/experimental/random.py @@ -245,7 +245,7 @@ def poisson( ivy.array([[0., 2., 2.], [1., 2., 3.]]) """ - return ivy.current_backend().poisson( + return ivy.current_backend(lam).poisson( lam, shape=shape, device=device, From 4550323bc9555744b3934352df3b5680e52c1559 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 7 Jan 2024 22:22:13 +0530 Subject: [PATCH 514/978] fix: Fixed missing argument in `ivy.inplace_update()` function call (#27808) --- ivy/functional/backends/jax/experimental/manipulation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/experimental/manipulation.py b/ivy/functional/backends/jax/experimental/manipulation.py index 1eb7c5ac75315..0c224e74d090c 100644 --- a/ivy/functional/backends/jax/experimental/manipulation.py +++ b/ivy/functional/backends/jax/experimental/manipulation.py @@ -462,7 +462,7 @@ def take( # clip, wrap, fill ret = jnp.take(x, indices, axis=axis, mode=mode, fill_value=fill_value) if ivy.exists(out): - ivy.inplace_update(out) + ivy.inplace_update(out, ret) return ret From 7fc9a4f08dc8ea3a1023229bb50747498ea9987c Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 7 Jan 2024 22:22:58 +0530 Subject: [PATCH 515/978] fix: Fixed passing of missing `backend` argument in few function calls (#27809) --- .../test_ivy/test_frontends/test_tensorflow/test_linalg.py | 3 +++ .../test_frontends/test_tensorflow/test_raw_ops.py | 1 + .../test_ivy/test_frontends/test_tensorflow/test_tensor.py | 1 + .../test_ivy/test_frontends/test_torch/test_linalg.py | 5 +++++ .../test_ivy/test_frontends/test_torch/test_tensor.py | 7 ++++--- ivy_tests/test_ivy/test_stateful/test_layers.py | 2 +- 6 files changed, 15 insertions(+), 4 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py index 716f149551848..24e4d61344997 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py @@ -414,6 +414,7 @@ def test_tensorflow_eigvals( rtol=1e-06, atol=1e-06, ground_truth_backend=frontend, + backend=backend_fw, ) @@ -969,6 +970,7 @@ def test_tensorflow_qr( rtol=1e-2, atol=1e-2, ground_truth_backend=frontend, + backend=backend_fw, ) @@ -1120,6 +1122,7 @@ def test_tensorflow_svd( rtol=1e-2, atol=1e-2, ground_truth_backend=frontend, + backend=backend_fw, ) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index cb35f859a3cbe..027d7b72c34db 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -4279,6 +4279,7 @@ def test_tensorflow_Svd( rtol=1e-2, atol=1e-2, ground_truth_backend=frontend, + backend=backend_fw, ) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py index 66acd2020de79..d06dd9d695a86 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py @@ -1552,6 +1552,7 @@ def test_tensorflow_ivy_array( ret_np_flat=ret, ret_np_from_gt_flat=ret_gt, ground_truth_backend="tensorflow", + backend=backend_fw, ) ivy.previous_backend() diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 3c8a75dbe9702..cb1f13a438072 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -467,6 +467,7 @@ def test_torch_eig( rtol=1e-2, atol=1e-2, ground_truth_backend=frontend, + backend=backend_fw, ) @@ -511,6 +512,7 @@ def test_torch_eigh( ret_np=Q @ np.diag(L) @ Q.T, ret_from_gt_np=frontend_Q @ np.diag(frontend_L) @ frontend_Q.T, atol=1e-02, + backend=backend_fw, ) @@ -581,6 +583,7 @@ def test_torch_eigvals( rtol=1e-2, atol=1e-2, ground_truth_backend=frontend, + backend=backend_fw, ) @@ -1001,6 +1004,7 @@ def test_torch_qr( rtol=1e-2, atol=1e-2, ground_truth_backend=frontend, + backend=backend_fw, ) ivy.previous_backend() @@ -1150,6 +1154,7 @@ def test_torch_svd( rtol=1e-2, atol=1e-2, ground_truth_backend=frontend, + backend=backend_fw, ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 838b3c80026d4..7f1c4b6798882 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -10384,8 +10384,8 @@ def call(): return ret_np, ret_from_np = ret - ret_np = helpers.flatten_and_to_np(ret=ret_np) - ret_from_np = helpers.flatten_and_to_np(ret=ret_from_np) + ret_np = helpers.flatten_and_to_np(ret=ret_np, backend=backend_fw) + ret_from_np = helpers.flatten_and_to_np(ret=ret_from_np, backend=backend_fw) for u, v in zip(ret_np, ret_from_np): assert u.dtype == v.dtype assert u.shape == v.shape @@ -10510,9 +10510,10 @@ def test_torch_numpy( ) # manual testing required as function return is numpy frontend helpers.value_test( - ret_np_flat=helpers.flatten_and_to_np(ret=ret), + ret_np_flat=helpers.flatten_and_to_np(ret=ret, backend=backend_fw), ret_np_from_gt_flat=frontend_ret[0], ground_truth_backend="torch", + backend=backend_fw, ) diff --git a/ivy_tests/test_ivy/test_stateful/test_layers.py b/ivy_tests/test_ivy/test_stateful/test_layers.py index a315c74766451..f3ec09355af54 100644 --- a/ivy_tests/test_ivy/test_stateful/test_layers.py +++ b/ivy_tests/test_ivy/test_stateful/test_layers.py @@ -1053,7 +1053,7 @@ def test_dropout_layer( test_values=False, on_device=on_device, ) - ret = helpers.flatten_and_to_np(ret=ret) + ret = helpers.flatten_and_to_np(ret=ret, backend=backend_fw) for u in ret: # cardinality test assert u.shape == x[0].shape From d128f231f32febc0cbc88f016fb486afa39ee5d8 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 7 Jan 2024 17:12:10 +0000 Subject: [PATCH 516/978] fix: avoid overflows and nans in round for torch front by pushing input dtype preservation to the end tests pass except paddle. --- ivy/functional/frontends/torch/pointwise_ops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py index e2414108b8c4a..c99bcfe7736ec 100644 --- a/ivy/functional/frontends/torch/pointwise_ops.py +++ b/ivy/functional/frontends/torch/pointwise_ops.py @@ -463,10 +463,10 @@ def remainder(input, other, *, out=None): @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def round(input, *, decimals=0, out=None): - m = ivy.full(input.shape, 10.0**decimals, dtype=input.dtype) + m = ivy.full(input.shape, 10.0**decimals) upscale = ivy.multiply(input, m) rounded = ivy.round(upscale) - return ivy.divide(rounded, m, out=out) + return ivy.divide(rounded, m, out=out).astype(input.dtype) @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") From 0676f59f516e4bfda81a92384f9c58b8d52642e9 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Mon, 8 Jan 2024 03:37:30 +0530 Subject: [PATCH 517/978] Update sub-task.md --- .github/ISSUE_TEMPLATE/sub-task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/ISSUE_TEMPLATE/sub-task.md b/.github/ISSUE_TEMPLATE/sub-task.md index 34374422b3f2d..21c1855bc4283 100644 --- a/.github/ISSUE_TEMPLATE/sub-task.md +++ b/.github/ISSUE_TEMPLATE/sub-task.md @@ -2,7 +2,7 @@ name: 🍰 Sub-Task about: Reserve a sub-task from a ToDo list issue title: "" -labels: Sub Task, hacktoberfest +labels: Sub Task assignees: '' --- From 314106b6718ab48cf7789d8bc0c6fa86f21a2afa Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 8 Jan 2024 14:41:21 +0530 Subject: [PATCH 518/978] feat(ci): integrated tracer tests as a cron job to store the results in a separate field in the database (#27872) --- .github/workflows/intelligent-tests.yml | 2 +- .github/workflows/manual-tests.yml | 9 +++- .github/workflows/pre-release.yml | 4 +- .github/workflows/run-all-tests.yml | 2 +- .github/workflows/test-ivy-cron-gpu.yml | 2 +- .../workflows/test-ivy-cron-multi-version.yml | 2 +- .github/workflows/test-ivy-cron.yml | 2 +- .github/workflows/test-ivy-tracer-cron.yml | 46 +++++++++++++++++++ scripts/run_tests/run_tests.py | 22 +++++++-- 9 files changed, 77 insertions(+), 14 deletions(-) create mode 100644 .github/workflows/test-ivy-tracer-cron.yml diff --git a/.github/workflows/intelligent-tests.yml b/.github/workflows/intelligent-tests.yml index d4e2ec5de132a..6614e53eb42fd 100644 --- a/.github/workflows/intelligent-tests.yml +++ b/.github/workflows/intelligent-tests.yml @@ -89,7 +89,7 @@ jobs: run: | cd ivy set -o pipefail - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt continue-on-error: true - name: Upload test results diff --git a/.github/workflows/manual-tests.yml b/.github/workflows/manual-tests.yml index 0fa60e5338106..71c231e952c49 100644 --- a/.github/workflows/manual-tests.yml +++ b/.github/workflows/manual-tests.yml @@ -17,6 +17,11 @@ on: default: false required: false + tracer: + description: 'Tracer Testing :' + default: false + required: false + permissions: actions: read @@ -59,7 +64,7 @@ jobs: pip3 install pymongo cd ivy python3 scripts/setup_tests/setup_tests.py ${{ github.event.inputs.test }} - python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' ${{ github.event.inputs.gpu }} ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} + python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' ${{ github.event.inputs.gpu }} ${{ github.run_id }} 'false' ${{ github.event.inputs.tracer }} ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures @@ -101,7 +106,7 @@ jobs: cd ivy sudo pip3 install -e . python scripts/setup_tests/setup_tests.py "${{ github.event.inputs.test }}" - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} ${{ github.event.inputs.version}} 'false' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} ${{ github.event.inputs.version}} 'false' ${{ github.run_id }} 'false' ${{ github.event.inputs.tracer }} ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures diff --git a/.github/workflows/pre-release.yml b/.github/workflows/pre-release.yml index c7ccc919b6e61..249038c320383 100644 --- a/.github/workflows/pre-release.yml +++ b/.github/workflows/pre-release.yml @@ -35,9 +35,9 @@ jobs: - name: Run CPU Tests run: | cd ivy - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'true' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'true' 'false' ${{ steps.jobs.outputs.html_url }} - name: Run GPU Tests run: | cd ivy - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'true' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'true' 'false' ${{ steps.jobs.outputs.html_url }} diff --git a/.github/workflows/run-all-tests.yml b/.github/workflows/run-all-tests.yml index 5464f50283b52..c7bebee196cf6 100644 --- a/.github/workflows/run-all-tests.yml +++ b/.github/workflows/run-all-tests.yml @@ -64,7 +64,7 @@ jobs: cd ivy python scripts/setup_tests/filter_tests.py ${{ matrix.branch }} set -o pipefail - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt continue-on-error: true - name: Upload test results diff --git a/.github/workflows/test-ivy-cron-gpu.yml b/.github/workflows/test-ivy-cron-gpu.yml index 08ee34cd83dc1..c917cb74133b2 100644 --- a/.github/workflows/test-ivy-cron-gpu.yml +++ b/.github/workflows/test-ivy-cron-gpu.yml @@ -75,7 +75,7 @@ jobs: pip3 install pymongo cd ivy python3 scripts/setup_tests/cron_tests.py ${{ github.run_number }} true - python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} + python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} stop-vm: needs: run-gpu-tests diff --git a/.github/workflows/test-ivy-cron-multi-version.yml b/.github/workflows/test-ivy-cron-multi-version.yml index 14d9e02820c75..5f4177b3d0cf7 100644 --- a/.github/workflows/test-ivy-cron-multi-version.yml +++ b/.github/workflows/test-ivy-cron-multi-version.yml @@ -38,7 +38,7 @@ jobs: cd ivy pip3 install pymongo python scripts/setup_tests/cron_tests_multi_version.py ${{ github.run_number }} - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'true' 'false' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'true' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures diff --git a/.github/workflows/test-ivy-cron.yml b/.github/workflows/test-ivy-cron.yml index 7ee07cd6d3b99..59790144c2d41 100644 --- a/.github/workflows/test-ivy-cron.yml +++ b/.github/workflows/test-ivy-cron.yml @@ -38,7 +38,7 @@ jobs: cd ivy pip3 install pymongo python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures diff --git a/.github/workflows/test-ivy-tracer-cron.yml b/.github/workflows/test-ivy-tracer-cron.yml new file mode 100644 index 0000000000000..edbd67ddfdd45 --- /dev/null +++ b/.github/workflows/test-ivy-tracer-cron.yml @@ -0,0 +1,46 @@ +name: test-ivy-cron +on: + workflow_dispatch: + schedule: + - cron: '15 * * * *' +permissions: + actions: read +jobs: + run-nightly-tests: + runs-on: ubuntu-latest + steps: + - name: Checkout 🛎️Ivy + uses: actions/checkout@v2 + with: + path: ivy + persist-credentials: false + submodules: "recursive" + + - name: Install ivy and fetch binaries + run: | + cd ivy + sudo pip3 install -e . + mkdir .ivy + touch .ivy/key.pem + echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem + cd .. + + - name: Get Job URL + uses: Tiryoh/gha-jobid-action@v0 + id: jobs + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + job_name: ${{ github.job }} + + - name: Run Tests + id: tests + run: | + cd ivy + pip3 install pymongo + python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'true' ${{ steps.jobs.outputs.html_url }} + continue-on-error: true + + - name: Check on failures + if: steps.tests.outcome != 'success' + run: exit 1 diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index ac5704b461004..0df6d1d59f32f 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -20,9 +20,10 @@ gpu_flag = sys.argv[5] workflow_id = sys.argv[6] priority_flag = sys.argv[7] + tracer_flag = sys.argv[8] - if len(sys.argv) > 8 and sys.argv[8] != "null": - run_id = sys.argv[8] + if len(sys.argv) > 9 and sys.argv[9] != "null": + run_id = sys.argv[9] else: run_id = f"https://github.com/unifyai/ivy/actions/runs/{workflow_id}" @@ -30,6 +31,13 @@ if gpu_flag == "true": device = "gpu" + tracer_str = "" + if tracer_flag == "true": + tracer_flag = "tracer_" + tracer_str = " --with-trace-testing" + else: + tracer_flag = "" + cluster = MongoClient( f"mongodb+srv://deep-ivy:{mongo_key}@cluster0.qdvf8q3.mongodb.net/?retryWrites=true&w=majority" # noqa ) @@ -111,7 +119,7 @@ ) command = ( "docker exec test-container python3 -m pytest --tb=short" - f" {test_path}{device_str} --backend {backend}" + f" {test_path}{device_str} --backend {backend}{tracer_str}" ) os.system(command) @@ -207,8 +215,12 @@ "_id": function_name, "test_path": test_path, "submodule": submodule, - f"{prefix_str}{backend}.{version}.status.{device}": not failed, - f"{prefix_str}{backend}.{version}.workflow.{device}": run_id, + f"{prefix_str}{backend}.{version}.{tracer_flag}status.{device}": ( + not failed + ), + f"{prefix_str}{backend}.{version}.{tracer_flag}workflow.{device}": ( + run_id + ), } # add transpilation metrics if report generated From 0f9c7f146d49107809cd32eb5e23201cd559c03b Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 8 Jan 2024 15:17:29 +0000 Subject: [PATCH 519/978] fix: specify integer as unsupported for exp in tf backend --- ivy/functional/backends/tensorflow/elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index ac832299752ae..ce1c86669cf73 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -245,6 +245,7 @@ def equal( return tf.math.equal(x1, x2) +@with_unsupported_dtypes({"2.15.0 and below": ("integer",)}, backend_version) def exp( x: Union[tf.Tensor, tf.Variable], /, From cc176bbfc96803a4b764cb704452eb9d9cea1f5c Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 8 Jan 2024 15:28:00 +0000 Subject: [PATCH 520/978] fix: specify integer as unsupported for log and cos in tf backend --- ivy/functional/backends/tensorflow/elementwise.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index ce1c86669cf73..a3fbb32c47a64 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -199,6 +199,7 @@ def ceil( return tf.math.ceil(x) +@with_unsupported_dtypes({"2.15.0 and below": ("integer",)}, backend_version) def cos( x: Union[tf.Tensor, tf.Variable], /, @@ -432,7 +433,9 @@ def less_equal( return tf.math.less_equal(x1, x2) -@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes( + {"2.15.0 and below": ("float16", "bfloat16", "integer")}, backend_version +) def log( x: Union[tf.Tensor, tf.Variable], /, From 069a279e14dd33ec7b923fca2aec7d7d5e4101ca Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 8 Jan 2024 16:23:29 +0000 Subject: [PATCH 521/978] feat: enable crosscasting for exp, log and cos in torch frontend need to check if the wrapper has any unwanted side effects as it is accessing the global cross_data_types --- ivy/functional/frontends/torch/func_wrapper.py | 13 +++++++++++++ ivy/functional/frontends/torch/pointwise_ops.py | 8 +++++++- 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/func_wrapper.py b/ivy/functional/frontends/torch/func_wrapper.py index c7df1998d4faa..96f8379494b88 100644 --- a/ivy/functional/frontends/torch/func_wrapper.py +++ b/ivy/functional/frontends/torch/func_wrapper.py @@ -304,3 +304,16 @@ def to_ivy_shape_torch(*args, **kwargs): to_ivy_shape_torch.to_ivy_shape_torch = True return to_ivy_shape_torch + + +def with_crosscast(fn: Callable) -> Callable: + # todo: check for any unwanted side effects + @functools.wraps(fn) + def with_crosscast_(*args, **kwargs): + ivy.crosscast_data_types(True) + ret = fn(*args, **kwargs) + ivy.crosscast_data_types(False) + return ret + + with_crosscast.with_crosscast_ = True + return with_crosscast_ diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py index c99bcfe7736ec..33dbd474f00b9 100644 --- a/ivy/functional/frontends/torch/pointwise_ops.py +++ b/ivy/functional/frontends/torch/pointwise_ops.py @@ -5,7 +5,10 @@ with_supported_dtypes, ) import ivy.functional.frontends.torch as torch_frontend -from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back +from ivy.functional.frontends.torch.func_wrapper import ( + to_ivy_arrays_and_back, + with_crosscast, +) @to_ivy_arrays_and_back @@ -154,6 +157,7 @@ def copysign(input, other, *, out=None): @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back +@with_crosscast def cos(input, *, out=None): return ivy.cos(input, out=out) @@ -195,6 +199,7 @@ def erfc(input, *, out=None): @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back +@with_crosscast def exp(input, *, out=None): return ivy.exp(input, out=out) @@ -302,6 +307,7 @@ def lgamma(input, *, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_crosscast def log(input, *, out=None): return ivy.log(input, out=out) From 3318cd16ec60a05a467393c64afbdd65d46ce2de Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Tue, 9 Jan 2024 00:15:03 +0530 Subject: [PATCH 522/978] Fix ivy.floor (#27855) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/elementwise.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 735034e9ac3de..b7a670f7e5302 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -179,7 +179,7 @@ def ceil(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {"2.5.1 and below": ("float16", "float32", "float64", "complex")}, + {"2.5.1 and below": ("float32", "float64", "complex")}, backend_version, ) def floor(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: From 939eb3f1ea023d35cbed05f667e165254158ba12 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 9 Jan 2024 11:33:34 +0530 Subject: [PATCH 523/978] refactor(ci): renamed the test-ivy-tracer-cron workflow to avoid naming conflict with test-ivy-cron --- .github/workflows/test-ivy-tracer-cron.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test-ivy-tracer-cron.yml b/.github/workflows/test-ivy-tracer-cron.yml index edbd67ddfdd45..6faaca7d2d1ad 100644 --- a/.github/workflows/test-ivy-tracer-cron.yml +++ b/.github/workflows/test-ivy-tracer-cron.yml @@ -1,4 +1,4 @@ -name: test-ivy-cron +name: test-ivy-tracer-cron on: workflow_dispatch: schedule: From 61c5e083cd33860401a489b434ea46ab7b260e54 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 9 Jan 2024 13:04:17 +0530 Subject: [PATCH 524/978] fix: reduced the limit of tests in a tracer cron job to 20, prevented the script from recording transpilation metrics in a tracer cron job and added that cmdline argument (#27883) --- .github/workflows/test-ivy-cron-gpu.yml | 2 +- .github/workflows/test-ivy-cron.yml | 2 +- .github/workflows/test-ivy-tracer-cron.yml | 2 +- scripts/run_tests/run_tests.py | 2 +- scripts/setup_tests/cron_tests.py | 4 +++- 5 files changed, 7 insertions(+), 5 deletions(-) diff --git a/.github/workflows/test-ivy-cron-gpu.yml b/.github/workflows/test-ivy-cron-gpu.yml index c917cb74133b2..d382aafc3aa16 100644 --- a/.github/workflows/test-ivy-cron-gpu.yml +++ b/.github/workflows/test-ivy-cron-gpu.yml @@ -74,7 +74,7 @@ jobs: run: | pip3 install pymongo cd ivy - python3 scripts/setup_tests/cron_tests.py ${{ github.run_number }} true + python3 scripts/setup_tests/cron_tests.py ${{ github.run_number }} true false python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} stop-vm: diff --git a/.github/workflows/test-ivy-cron.yml b/.github/workflows/test-ivy-cron.yml index 59790144c2d41..047076cc012b4 100644 --- a/.github/workflows/test-ivy-cron.yml +++ b/.github/workflows/test-ivy-cron.yml @@ -37,7 +37,7 @@ jobs: run: | cd ivy pip3 install pymongo - python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false + python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false false python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true diff --git a/.github/workflows/test-ivy-tracer-cron.yml b/.github/workflows/test-ivy-tracer-cron.yml index 6faaca7d2d1ad..0696b5c4aedf4 100644 --- a/.github/workflows/test-ivy-tracer-cron.yml +++ b/.github/workflows/test-ivy-tracer-cron.yml @@ -37,7 +37,7 @@ jobs: run: | cd ivy pip3 install pymongo - python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false + python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false true python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'true' ${{ steps.jobs.outputs.html_url }} continue-on-error: true diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 0df6d1d59f32f..d020123b979fc 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -224,7 +224,7 @@ } # add transpilation metrics if report generated - if not failed and report_content: + if not failed and report_content and not tracer_flag: if is_frontend_test: test_info = { **test_info, diff --git a/scripts/setup_tests/cron_tests.py b/scripts/setup_tests/cron_tests.py index 810401efffb48..e589a78461fc0 100644 --- a/scripts/setup_tests/cron_tests.py +++ b/scripts/setup_tests/cron_tests.py @@ -2,7 +2,7 @@ from get_all_tests import get_all_tests -run_iter, gpu = int(sys.argv[1]), sys.argv[2] +run_iter, gpu, tracer = int(sys.argv[1]), sys.argv[2], sys.argv[3] if gpu == "true": from setup_priority_tests import main @@ -13,6 +13,8 @@ else: test_names = get_all_tests() tests_per_run = 150 + if tracer == "true": + tests_per_run = 20 num_tests = len(test_names) start = run_iter * tests_per_run end = (run_iter + 1) * tests_per_run From b9cb39bbe81d38f60d73b4102cfe7ca1e4168c61 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 9 Jan 2024 16:37:38 +0530 Subject: [PATCH 525/978] fix: Fixed passing of un-necessary argument `dtype` (#27880) --- ivy/functional/frontends/paddle/tensor/tensor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 95ac52b70ee27..0e9cba69b82b8 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -560,9 +560,9 @@ def isfinite(self, name=None): return paddle_frontend.isfinite(self) @with_supported_dtypes({"2.4.2 and below": ("float16", "bfloat16")}, "paddle") - def all(self, axis=None, keepdim=False, dtype=None, name=None): + def all(self, axis=None, keepdim=False, name=None): return paddle_frontend.Tensor( - ivy.all(self.ivy_array, axis=axis, keepdims=keepdim, dtype=dtype) + ivy.all(self.ivy_array, axis=axis, keepdims=keepdim) ) @with_supported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") From a5ceff5a035340b1f9d1328022c4e835008869c3 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 9 Jan 2024 16:44:03 +0530 Subject: [PATCH 526/978] fix: Fixed passing of wrong key-word argument `dim` in `ivy.ifftn()` function call. (#27885) --- ivy/functional/frontends/paddle/fft.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index bc72bd9aa7df1..52139bd5427af 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -280,7 +280,7 @@ def irfft2(x, s=None, axes=(-2, -1), norm="backward"): # Calculate the normalization factor 'n' based on the shape 's' n = ivy.prod(ivy.array(s)) - result = ivy.ifftn(x, dim=axes[0], norm=norm) + result = ivy.ifftn(x, axes=axes[0], norm=norm) # Normalize the result based on the 'norm' parameter if norm == "backward": From b024de17148728f658c30db8116547ed8d4daa58 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Tue, 9 Jan 2024 18:20:30 +0530 Subject: [PATCH 527/978] fix: fixed relu6 supported dtypes (#27874) Fixes failing test case in relu6 experimental function. --- .../test_experimental/test_nn/test_activations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py index 5a79ef33ad3cf..c716f32820e02 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py @@ -214,7 +214,7 @@ def test_prelu(*, dtype_and_x, slope, test_flags, backend_fw, fn_name, on_device @handle_test( fn_tree="functional.ivy.experimental.relu6", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), + available_dtypes=helpers.get_dtypes("float_and_complex"), large_abs_safety_factor=2, small_abs_safety_factor=2, safety_factor_scale="log", From 11d30f954a0aff1f3619af266d5739b43c547f62 Mon Sep 17 00:00:00 2001 From: Soumyadeep Biswas Date: Tue, 9 Jan 2024 19:04:56 +0530 Subject: [PATCH 528/978] index_add (#26394) Adds paddle frontend function index_add. --- .../frontends/paddle/manipulation.py | 31 +++++++ .../test_paddle/test_manipulation.py | 88 +++++++++++++++++++ 2 files changed, 119 insertions(+) diff --git a/ivy/functional/frontends/paddle/manipulation.py b/ivy/functional/frontends/paddle/manipulation.py index 69e9f6c22dbb3..e8f59e91960a5 100644 --- a/ivy/functional/frontends/paddle/manipulation.py +++ b/ivy/functional/frontends/paddle/manipulation.py @@ -86,6 +86,37 @@ def gather_nd(x, index, name=None): return ivy.gather_nd(x, index) +@with_supported_dtypes( + {"2.5.1 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + "paddle", +) +@to_ivy_arrays_and_back +def index_add(x, index, axis, value, *, name=None): + x = ivy.swapaxes(x, axis, 0) + value = ivy.swapaxes(value, axis, 0) + _to_adds = [] + index = sorted(zip(ivy.to_list(index), range(len(index))), key=(lambda i: i[0])) + while index: + _curr_idx = index[0][0] + while len(_to_adds) < _curr_idx: + _to_adds.append(ivy.zeros_like(value[0])) + _to_add_cum = ivy.get_item(value, index[0][1]) + while (len(index)) > 1 and (index[0][0] == index[1][0]): + _to_add_cum = _to_add_cum + ivy.get_item(value, index.pop(1)[1]) + index.pop(0) + _to_adds.append(_to_add_cum) + while len(_to_adds) < x.shape[0]: + _to_adds.append(ivy.zeros_like(value[0])) + _to_adds = ivy.stack(_to_adds) + if len(x.shape) < 2: + # Added this line due to the paddle backend treating scalars as 1-d arrays + _to_adds = ivy.flatten(_to_adds) + + ret = ivy.add(x, _to_adds) + ret = ivy.swapaxes(ret, axis, 0) + return ret + + @to_ivy_arrays_and_back def put_along_axis(arr, indices, values, axis, reduce="assign"): result = ivy.put_along_axis(arr, indices, values, axis) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_manipulation.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_manipulation.py index 413f799ef4d9d..c3515fd426518 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_manipulation.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_manipulation.py @@ -48,6 +48,62 @@ def _arrays_axis_n_dtypes(draw): return xs, input_dtypes, axis +@st.composite +def _arrays_dim_idx_n_dtypes(draw): + num_dims = draw(st.shared(helpers.ints(min_value=1, max_value=4), key="num_dims")) + num_arrays = 2 + common_shape = draw( + helpers.lists( + x=helpers.ints(min_value=2, max_value=3), + min_size=num_dims - 1, + max_size=num_dims - 1, + ) + ) + _dim = draw(helpers.ints(min_value=0, max_value=num_dims - 1)) + unique_dims = draw( + helpers.lists( + x=helpers.ints(min_value=2, max_value=3), + min_size=num_arrays, + max_size=num_arrays, + ) + ) + + min_dim = min(unique_dims) + max_dim = max(unique_dims) + _idx = draw( + helpers.array_values( + shape=min_dim, + dtype="int64", + min_value=0, + max_value=max_dim, + exclude_min=False, + ) + ) + + xs = [] + # available_input_types = draw(helpers.get_dtypes("integer")) + available_input_types = ["int32", "int64", "float16", "float32", "float64"] + input_dtypes = draw( + helpers.array_dtypes( + available_dtypes=available_input_types, + num_arrays=num_arrays, + shared_dtype=True, + ) + ) + for ud, dt in zip(unique_dims, input_dtypes): + x = draw( + helpers.array_values( + shape=common_shape[:_dim] + [ud] + common_shape[_dim:], + dtype=dt, + large_abs_safety_factor=2.5, + small_abs_safety_factor=2.5, + safety_factor_scale="log", + ) + ) + xs.append(x) + return xs, input_dtypes, _dim, _idx + + # concat @st.composite def _arrays_idx_n_dtypes(draw): @@ -471,6 +527,38 @@ def test_paddle_gather_nd( ) +@handle_frontend_test( + fn_tree="paddle.index_add", + xs_dtypes_dim_idx=_arrays_dim_idx_n_dtypes(), +) +def test_paddle_index_add( + *, + xs_dtypes_dim_idx, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + xs, input_dtypes, axis, indices = xs_dtypes_dim_idx + if xs[0].shape[axis] < xs[1].shape[axis]: + source, input = xs + else: + input, source = xs + helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + frontend=frontend, + on_device=on_device, + x=input, + index=indices, + axis=axis, + value=source, + ) + + # repeat_interleave @handle_frontend_test( fn_tree="paddle.repeat_interleave", From aa1561c2024dd14b497b07e9ad5a3bdef3fabd7a Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 9 Jan 2024 19:52:25 +0530 Subject: [PATCH 529/978] feat: Added `isort` rule/check to `ruff` (#27825) --- pyproject.toml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index deb45218b37d4..0e29ca0ffbb38 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -33,7 +33,9 @@ select = [ # pycodestyle "E", "W", # pydocstyle - "D" + "D", + # isort (Missing required import) + "I002" ] From 45b563c34a703d1be83161a35c0a71b496aa9e7c Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Tue, 9 Jan 2024 15:56:14 +0000 Subject: [PATCH 530/978] fix: torch frontend Tensor.__bool__ now returning bools, Tensor.type_as returning new tensor instead of operating inplace and fixed signature for unique_consecutive (#27887) --- ivy/functional/frontends/torch/reduction_ops.py | 2 +- ivy/functional/frontends/torch/tensor.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index c512e35d6e917..1e76c5bb2d589 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -361,7 +361,7 @@ def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=No "torch", ) @to_ivy_arrays_and_back -def unique_consecutive(input, return_inverse, return_counts, dim): +def unique_consecutive(input, return_inverse=False, return_counts=False, dim=None): output, inverse_indices, counts = ivy.unique_consecutive(input, axis=dim) ret = (output,) if return_inverse: diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 86dd7263f24b1..81f692f12f774 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -949,7 +949,7 @@ def type(self, dtype=None, non_blocking=False, **kwargs): @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") def type_as(self, other): if self.dtype != other.dtype: - self.ivy_array = ivy.astype(self.ivy_array, other.dtype) + return torch_frontend.tensor(ivy.astype(self.ivy_array, other.dtype)) return self def byte(self, memory_format=None): @@ -1185,7 +1185,7 @@ def bernoulli(self, *, generator=None, out=None): def __bool__(self): if len(self.shape) == sum(self.shape): - return torch_frontend.tensor(self.ivy_array.to_scalar().__bool__()) + return self.ivy_array.to_scalar().__bool__() raise ValueError( "The truth value of an array with more than one element is ambiguous. " "Use a.any() or a.all()" From ceb327786ac80c8a5330481bf3bae370bc9d1696 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 10 Jan 2024 14:58:35 +0530 Subject: [PATCH 531/978] fix:fixed silu activation at tensorflow and torch backend (#27889) Co-authored-by: NripeshN --- ivy/functional/backends/tensorflow/experimental/activations.py | 2 +- ivy/functional/backends/torch/experimental/activations.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/activations.py b/ivy/functional/backends/tensorflow/experimental/activations.py index 11c67e78af3b5..8b56ba0b303a1 100644 --- a/ivy/functional/backends/tensorflow/experimental/activations.py +++ b/ivy/functional/backends/tensorflow/experimental/activations.py @@ -59,7 +59,7 @@ def selu(x: Tensor, /, *, out: Optional[Tensor] = None) -> Tensor: return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def silu( x: Tensor, /, diff --git a/ivy/functional/backends/torch/experimental/activations.py b/ivy/functional/backends/torch/experimental/activations.py index 230e429e4bc98..99e4974b1e60f 100644 --- a/ivy/functional/backends/torch/experimental/activations.py +++ b/ivy/functional/backends/torch/experimental/activations.py @@ -57,7 +57,7 @@ def selu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def silu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.nn.functional.silu(x) From 1b872183bc8a79b01a5e889e15825c5ccf790acb Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 10 Jan 2024 09:45:20 +0000 Subject: [PATCH 532/978] feat: handle case for float values with int dtype specified in tf backend (#27890) --- ivy/functional/backends/tensorflow/creation.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py index 8f84e8e3cda1a..4a96058aa5dff 100644 --- a/ivy/functional/backends/tensorflow/creation.py +++ b/ivy/functional/backends/tensorflow/creation.py @@ -93,6 +93,10 @@ def asarray( with tf.device(device): if tf.is_tensor(obj): ret = tf.cast(obj, dtype) if obj.dtype != dtype else obj + elif dtype.is_integer and np.issubdtype( + (obj_np := np.array(obj)).dtype, np.floating + ): + ret = tf.convert_to_tensor(obj_np, dtype) else: ret = tf.convert_to_tensor(obj, dtype) return tf.identity(ret) if (copy or ret.device != device) else ret From 31a6cfc0970f2b1c1e75d81b61f46be52c949a33 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 10 Jan 2024 18:09:20 +0530 Subject: [PATCH 533/978] fix: updated torch.unique frontend to return a tuple just like the torch.unique function instead of a named tuple (#27893) --- ivy/functional/frontends/torch/reduction_ops.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 1e76c5bb2d589..53772d8417fee 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -335,8 +335,6 @@ def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=No if return_counts: fields.append("counts") - Results = namedtuple("Results", fields) - values = [results.values] if return_inverse: inverse_indices = results.inverse_indices @@ -348,7 +346,9 @@ def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=No if return_counts: values.append(results.counts) - return Results(*values) + if len(values) == 1: + return values[0] + return tuple(values) @with_unsupported_dtypes( From 19e9f6e87a35420025fabf940b09818d26ca1b34 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 10 Jan 2024 18:56:16 +0530 Subject: [PATCH 534/978] fix: Fixed using of deprecated `logging.warn()` method (#27882) --- ivy/wrappers/utils.py | 4 ++-- ivy_tests/test_ivy/helpers/function_testing.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/wrappers/utils.py b/ivy/wrappers/utils.py index 0d64041a96c9a..b264e70275903 100644 --- a/ivy/wrappers/utils.py +++ b/ivy/wrappers/utils.py @@ -14,7 +14,7 @@ def download_cython_wrapper(func_name: str): """Get the wrapper for the given function name.""" if func_name + ".so" not in wrappers["ivy"]["functional"]: - logging.warn(f"Wrapper for {func_name} not found.") + logging.warning(f"Wrapper for {func_name} not found.") return False try: response = request.urlopen( @@ -29,7 +29,7 @@ def download_cython_wrapper(func_name: str): print("Downloaded wrapper for " + func_name) return True except request.HTTPError: - logging.warn(f"Unable to download wrapper for {func_name}.") + logging.warning(f"Unable to download wrapper for {func_name}.") return False diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index ae7abf618aed0..05c595d8dc2aa 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -66,7 +66,7 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non except Exception: import logging - logging.warn("API key is invalid, test_trace is skipped.") + logging.warning("API key is invalid, test_trace is skipped.") return fn From 74dd5c4bf041d166ccd5ffc5f2ffe4a27589d83c Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 10 Jan 2024 16:36:18 +0000 Subject: [PATCH 535/978] fix: remove the with_crosscast wrapper in torch frontend --- ivy/functional/frontends/torch/func_wrapper.py | 13 ------------- ivy/functional/frontends/torch/pointwise_ops.py | 4 ---- 2 files changed, 17 deletions(-) diff --git a/ivy/functional/frontends/torch/func_wrapper.py b/ivy/functional/frontends/torch/func_wrapper.py index 96f8379494b88..c7df1998d4faa 100644 --- a/ivy/functional/frontends/torch/func_wrapper.py +++ b/ivy/functional/frontends/torch/func_wrapper.py @@ -304,16 +304,3 @@ def to_ivy_shape_torch(*args, **kwargs): to_ivy_shape_torch.to_ivy_shape_torch = True return to_ivy_shape_torch - - -def with_crosscast(fn: Callable) -> Callable: - # todo: check for any unwanted side effects - @functools.wraps(fn) - def with_crosscast_(*args, **kwargs): - ivy.crosscast_data_types(True) - ret = fn(*args, **kwargs) - ivy.crosscast_data_types(False) - return ret - - with_crosscast.with_crosscast_ = True - return with_crosscast_ diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py index 33dbd474f00b9..60169dc556b10 100644 --- a/ivy/functional/frontends/torch/pointwise_ops.py +++ b/ivy/functional/frontends/torch/pointwise_ops.py @@ -7,7 +7,6 @@ import ivy.functional.frontends.torch as torch_frontend from ivy.functional.frontends.torch.func_wrapper import ( to_ivy_arrays_and_back, - with_crosscast, ) @@ -157,7 +156,6 @@ def copysign(input, other, *, out=None): @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back -@with_crosscast def cos(input, *, out=None): return ivy.cos(input, out=out) @@ -199,7 +197,6 @@ def erfc(input, *, out=None): @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back -@with_crosscast def exp(input, *, out=None): return ivy.exp(input, out=out) @@ -307,7 +304,6 @@ def lgamma(input, *, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") -@with_crosscast def log(input, *, out=None): return ivy.log(input, out=out) From 24ba98e7dd6b4064fe1250d8c2c79ab698c705ae Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 10 Jan 2024 16:37:47 +0000 Subject: [PATCH 536/978] fix: avoid index error in expand function for tensorflow backend --- .../backends/tensorflow/experimental/manipulation.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/experimental/manipulation.py b/ivy/functional/backends/tensorflow/experimental/manipulation.py index 43e286e1eb0a8..2e7f511bc9928 100644 --- a/ivy/functional/backends/tensorflow/experimental/manipulation.py +++ b/ivy/functional/backends/tensorflow/experimental/manipulation.py @@ -349,7 +349,9 @@ def expand( shape = list(shape) for i, dim in enumerate(shape): if dim < 0: - shape[i] = x.shape[i] + shape[i] = x.shape.num_elements() / tf.reduce_prod( + [s for s in shape if s > 0] + ) return tf.broadcast_to(x, shape) From 70efc60267a6be257a418e49d227fa5c185857fe Mon Sep 17 00:00:00 2001 From: Ivan Dobrosovestnov <36077882+ivankot88@users.noreply.github.com> Date: Wed, 10 Jan 2024 18:51:35 +0100 Subject: [PATCH 537/978] feat: add bessel_i1 to tensorflow frontend (#26468) Co-authored-by: Ivan Co-authored-by: ivy-branch --- ivy/functional/frontends/tensorflow/math.py | 167 ++++++++++++++++++ .../test_tensorflow/test_math.py | 35 ++++ 2 files changed, 202 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index d0d974b5b6f36..6e711e6390008 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -13,6 +13,138 @@ ) +# --- Helpers --- # +# --------------- # + + +def _chbevl(x, coef, N): + """Evaluates the series. + + N-1 + - ' + y = > coef[i] T (x/2) + - i + i=0 + + of Chebyshev polynomials Ti at argument x/2. + + Coefficients are stored in reverse order, i.e. the zero + order term is last in the array. Note N is the number of + coefficients, not the order. + + If coefficients are for the interval a to b, x must + have been transformed to x -> 2(2x - b - a)/(b-a) before + entering the routine. This maps x from (a, b) to (-1, 1), + over which the Chebyshev polynomials are defined. + + If the coefficients are for the inverted interval, in + which (a, b) is mapped to (1/b, 1/a), the transformation + required is x -> 2(2ab/x - b - a)/(b-a). If b is infinity, + this becomes x -> 4a/x - 1. + """ + b0 = coef[0:1] + b1 = ivy.zeros_like(x) + i = N - 1 + p = 1 + + while i > 0: + b2 = b1 + b1 = b0 + with ivy.PreciseMode(True): + b0 = x * b1 - b2 + coef[p : p + 1] + p += 1 + i -= 1 + + return 0.5 * (b0 - b2) + + +def _get_chebyshev_coefficients_for_exp_i1(): + """Chebyshev coefficients for exp(-x) I1(x) / x in the interval [0,8]. + + lim(x->0){ exp(-x) I1(x) / x } = 1/2. + + Returns list of 29 float elements + ------- + """ + return ivy.array( + [ + 2.77791411276104639959e-18, + -2.11142121435816608115e-17, + 1.55363195773620046921e-16, + -1.10559694773538630805e-15, + 7.60068429473540693410e-15, + -5.04218550472791168711e-14, + 3.22379336594557470981e-13, + -1.98397439776494371520e-12, + 1.17361862988909016308e-11, + -6.66348972350202774223e-11, + 3.62559028155211703701e-10, + -1.88724975172282928790e-9, + 9.38153738649577178388e-9, + -4.44505912879632808065e-8, + 2.00329475355213526229e-7, + -8.56872026469545474066e-7, + 3.47025130813767847674e-6, + -1.32731636560394358279e-5, + 4.78156510755005422638e-5, + -1.61760815825896745588e-4, + 5.12285956168575772895e-4, + -1.51357245063125314899e-3, + 4.15642294431288815669e-3, + -1.05640848946261981558e-2, + 2.47264490306265168283e-2, + -5.29459812080949914269e-2, + 1.02643658689847095384e-1, + -1.76416518357834055153e-1, + 2.52587186443633654823e-1, + ] + ) + + +def _get_chebyshev_coefficients_for_exp_sqrt_i1(): + """Chebyshev coefficients for exp(-x) sqrt(x) I1(x) in the inverted + interval [8,infinity]. + + lim(x->inf){ exp(-x) sqrt(x) I1(x) } = 1/sqrt(2pi). + + Returns a list of 25 elements containing float + ------- + """ + return ivy.array( + [ + 7.51729631084210481353e-18, + 4.41434832307170791151e-18, + -4.65030536848935832153e-17, + -3.20952592199342395980e-17, + 2.96262899764595013876e-16, + 3.30820231092092828324e-16, + -1.88035477551078244854e-15, + -3.81440307243700780478e-15, + 1.04202769841288027642e-14, + 4.27244001671195135429e-14, + -2.10154184277266431302e-14, + -4.08355111109219731823e-13, + -7.19855177624590851209e-13, + 2.03562854414708950722e-12, + 1.41258074366137813316e-11, + 3.25260358301548823856e-11, + -1.89749581235054123450e-11, + -5.58974346219658380687e-10, + -3.83538038596423702205e-9, + -2.63146884688951950684e-8, + -2.51223623787020892529e-7, + -3.88256480887769039346e-6, + -1.10588938762623716291e-4, + -9.76109749136146840777e-3, + 7.78576235018280120474e-1, + ] + ) + + +# --- Main --- # +# ------------ # + + @with_unsupported_dtypes( { "1.2.0": ("float16", "complex64", "complex128"), @@ -104,6 +236,41 @@ def atanh(x, name="atanh"): return ivy.atanh(x) +@with_supported_dtypes( + {"2.15.0 and below": ("float16", "float32", "float64")}, "tensorflow" +) +@to_ivy_arrays_and_back +def bessel_i1(x, name=None): + z = ivy.abs(x) + result = ivy.zeros_like(z) + + mask1 = z <= 8.0 + + if ivy.any(mask1) > 0: + y = (z[mask1] / ivy.array([2.0])) - ivy.array([2.0]) + result[mask1] = ( + _chbevl(y, _get_chebyshev_coefficients_for_exp_i1(), 29) + * z[mask1] + * ivy.exp(z[mask1]) + ) + + mask2 = ~mask1 + if ivy.any(mask2) > 0: + result[mask2] = ( + ivy.exp(z[mask2]) + * _chbevl( + ivy.array([32.0]) / z[mask2] - ivy.array([2.0]), + _get_chebyshev_coefficients_for_exp_sqrt_i1(), + 25, + ) + / ivy.sqrt(z[mask2]) + ) + + result[x < 0.0] = -result[x < 0.0] + + return result + + @with_supported_dtypes( {"2.15.0 and below": ("int32",)}, "tensorflow", diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py index 1ad9f4d2e1987..9e9cc7aebe1af 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py @@ -449,6 +449,41 @@ def test_tensorflow_atanh( ) +# bessel_i1 +@handle_frontend_test( + fn_tree="tensorflow.math.bessel_i1", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=1, + min_value=-10, + max_value=10, + min_num_dims=1, + max_num_dims=4, + shared_dtype=True, + ), + test_with_out=st.just(False), +) +def test_tensorflow_bessel_i1( + *, + dtype_and_x, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x=x[0], + ) + + # bincount @handle_frontend_test( fn_tree="tensorflow.math.bincount", From 06508027180ea29977b4cafd316d536247cb5664 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Wed, 10 Jan 2024 22:31:26 +0000 Subject: [PATCH 538/978] fix: ivy rnn and while_loop changes to fix lstm transpilations (#27878) --- ivy/functional/backends/torch/control_flow_ops.py | 5 +++-- ivy/functional/ivy/control_flow_ops.py | 8 -------- ivy/functional/ivy/experimental/layers.py | 14 +++++++++----- 3 files changed, 12 insertions(+), 15 deletions(-) diff --git a/ivy/functional/backends/torch/control_flow_ops.py b/ivy/functional/backends/torch/control_flow_ops.py index 7d97ef344120c..d114e59c2146d 100644 --- a/ivy/functional/backends/torch/control_flow_ops.py +++ b/ivy/functional/backends/torch/control_flow_ops.py @@ -17,10 +17,11 @@ def cond(*_): def while_loop(test_fn, body_fn, vars): - result = vars if isinstance(vars, dict): result = list(vars.values()) - while test_fn(*result): + else: + result = list(vars) + while test_fn(*result) is True: result = body_fn(*result) if not isinstance(result, tuple): result = (result,) diff --git a/ivy/functional/ivy/control_flow_ops.py b/ivy/functional/ivy/control_flow_ops.py index 7537d6c202408..9973de660b546 100644 --- a/ivy/functional/ivy/control_flow_ops.py +++ b/ivy/functional/ivy/control_flow_ops.py @@ -3,12 +3,8 @@ from ivy.utils.backend import current_backend from ivy.func_wrapper import ( handle_array_like_without_promotion, - handle_backend_invalid, - handle_device, - outputs_to_ivy_arrays, to_native_arrays_and_back, ) -from ivy.utils.exceptions import handle_exceptions def if_else( @@ -65,10 +61,6 @@ def _if_else(cond, body_fn, orelse_fn, **vars): return _if_else(cond, body_fn, orelse_fn, **vars) -@handle_exceptions -@handle_backend_invalid -@outputs_to_ivy_arrays -@handle_device def while_loop( test_fn: Callable, body_fn: Callable, diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 5f629ef41f639..05aaddc089b6a 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -3328,7 +3328,7 @@ def rnn( if not ivy.is_bool_dtype(mask): mask = ivy.astype(mask, ivy.bool) if len(mask.shape) == 2: - mask = ivy.expand_dims(mask) + mask = ivy.expand_dims(mask, axis=-1) if not time_major: mask = ivy.permute_dims(mask, (1, 0, *range(2, len(mask.shape)))) @@ -3423,7 +3423,13 @@ def _expand_mask(mask_t, input_t, fixed_dim=1): input_time_zero, tuple(initial_states) + tuple(constants) ) - output_size = int(time_steps_t) if return_all_outputs else 1 + if return_all_outputs: + if ivy.is_array(time_steps_t): + output_size = time_steps_t.to_scalar() + else: + output_size = time_steps_t + else: + output_size = 1 output_loop = ivy.empty( (output_size, *output_time_zero.shape), dtype=output_time_zero.dtype ) @@ -3437,10 +3443,8 @@ def _expand_mask(mask_t, input_t, fixed_dim=1): if go_backwards: mask = ivy.flip(mask, axis=0) - mask_list = ivy.unstack(mask) - def masking_fn(time): - return mask_list[time] + return mask[time] def compute_masked_output(mask_t, output, mask): tiled_mask_t = tuple( From 7bf0b7e537ac14615a6223a9076a8f7337deb636 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 11 Jan 2024 15:01:53 +0530 Subject: [PATCH 539/978] feat: Updated `ruff` and `black` pre-commit hook versions (#27894) Co-authored-by: NripeshN --- .pre-commit-config.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 2e7f83aff2726..ebd63add93c6f 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,13 +7,13 @@ repos: - id: check-toml - id: end-of-file-fixer - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.1.8 + rev: v0.1.11 hooks: # Run the linter. - id: ruff args: [ --fix ] - repo: https://github.com/psf/black-pre-commit-mirror - rev: 23.12.0 + rev: 23.12.1 hooks: - id: black language_version: python3 From d8f2b377b41f2f08ece89fd906e79aa1c5f7355d Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 11 Jan 2024 15:04:22 +0530 Subject: [PATCH 540/978] fix: fixed ivy elu activation function (#27876) Co-authored-by: NripeshN --- ivy/functional/backends/jax/experimental/activations.py | 1 + ivy/functional/backends/tensorflow/experimental/activations.py | 3 +-- ivy/functional/backends/torch/experimental/activations.py | 2 +- .../test_experimental/test_nn/test_activations.py | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/activations.py b/ivy/functional/backends/jax/experimental/activations.py index f2e298cf4400c..af914da4a4f88 100644 --- a/ivy/functional/backends/jax/experimental/activations.py +++ b/ivy/functional/backends/jax/experimental/activations.py @@ -73,6 +73,7 @@ def silu(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return ret +@with_unsupported_dtypes({"0.4.14 and below": ("float16", "bfloat16")}, backend_version) def elu( x: JaxArray, /, *, alpha: float = 1.0, out: Optional[JaxArray] = None ) -> JaxArray: diff --git a/ivy/functional/backends/tensorflow/experimental/activations.py b/ivy/functional/backends/tensorflow/experimental/activations.py index 8b56ba0b303a1..2c5140fa83975 100644 --- a/ivy/functional/backends/tensorflow/experimental/activations.py +++ b/ivy/functional/backends/tensorflow/experimental/activations.py @@ -74,8 +74,7 @@ def silu( @with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def elu(x: Tensor, /, *, alpha: float = 1.0, out: Optional[Tensor] = None) -> Tensor: - alpha = tf.cast(alpha, x.dtype) - ret = tf.cast(tf.where(x > 0, x, tf.multiply(alpha, tf.math.expm1(x))), x.dtype) + ret = tf.keras.activations.elu(x, alpha) if ivy.exists(out): return ivy.inplace_update(out, ret).astype(x.dtype) return ivy.astype(ret, x.dtype) diff --git a/ivy/functional/backends/torch/experimental/activations.py b/ivy/functional/backends/torch/experimental/activations.py index 99e4974b1e60f..f947baa9d40b0 100644 --- a/ivy/functional/backends/torch/experimental/activations.py +++ b/ivy/functional/backends/torch/experimental/activations.py @@ -62,7 +62,7 @@ def silu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten return torch.nn.functional.silu(x) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) def elu( x: torch.Tensor, /, *, alpha: float = 1.0, out: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py index c716f32820e02..75fbc12a2fdc2 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py @@ -40,7 +40,7 @@ def test_celu( @handle_test( fn_tree="functional.ivy.experimental.elu", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), + available_dtypes=helpers.get_dtypes("float_and_complex"), large_abs_safety_factor=8, small_abs_safety_factor=8, safety_factor_scale="log", From 21df3f0850b1f9d44d20b5609e6893886d2c5460 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 11 Jan 2024 18:58:40 +0530 Subject: [PATCH 541/978] fix: Fixed passing of un-necessary `device` argument in `ivy.blackman_window()` (#27897) --- ivy/data_classes/array/experimental/creation.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/ivy/data_classes/array/experimental/creation.py b/ivy/data_classes/array/experimental/creation.py index 62ab0e9f1744d..c83e24c78e6ac 100644 --- a/ivy/data_classes/array/experimental/creation.py +++ b/ivy/data_classes/array/experimental/creation.py @@ -167,9 +167,7 @@ def blackman_window( ivy.array([-1.38777878e-17, 1.30000000e-01, 6.30000000e-01, 1.00000000e+00, 6.30000000e-01, 1.30000000e-01, -1.38777878e-17]) """ - return ivy.blackman_window( - self._data, periodic=periodic, dtype=dtype, device=device, out=out - ) + return ivy.blackman_window(self._data, periodic=periodic, dtype=dtype, out=out) def trilu( self: ivy.Array, From 70e5a5918fc41ae326ba416b53087b618c9587b5 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 11 Jan 2024 19:00:14 +0530 Subject: [PATCH 542/978] refactor: Removed un-necessary global declaration for `avg` variable (#27899) --- .../frontends/numpy/statistics/averages_and_variances.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ivy/functional/frontends/numpy/statistics/averages_and_variances.py b/ivy/functional/frontends/numpy/statistics/averages_and_variances.py index 3cfd82ed68ced..bd911614f0fc7 100644 --- a/ivy/functional/frontends/numpy/statistics/averages_and_variances.py +++ b/ivy/functional/frontends/numpy/statistics/averages_and_variances.py @@ -13,7 +13,6 @@ @from_zero_dim_arrays_to_scalar def average(a, /, *, axis=None, weights=None, returned=False, keepdims=False): axis = tuple(axis) if isinstance(axis, list) else axis - global avg avg = 0 if keepdims is None: From dad9a2400e802d0bd04362e18fa3c84db10942ec Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Thu, 11 Jan 2024 15:06:07 +0000 Subject: [PATCH 543/978] fix: tf backend getitem condition handling the case of no arrays in the query. and tf backend add working with bool inputs (#27900) --- ivy/functional/backends/tensorflow/elementwise.py | 2 ++ ivy/functional/backends/tensorflow/general.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index a3fbb32c47a64..a30b34bba8a60 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -50,6 +50,8 @@ def add( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: x1, x2 = ivy.promote_types_of_inputs(x1, x2) + if x1.dtype.is_bool and x2.dtype.is_bool: + return tf.math.logical_or(x1, x2) if alpha not in (1, None): with ivy.ArrayMode(False): x2 = multiply(x2, alpha) diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 70db8f5b6d040..0d8a8c3f98ab4 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -65,7 +65,7 @@ def get_item( get_item.partial_mixed_handler = lambda x, query, **kwargs: ( all(_check_query(i) for i in query) - and len({i.shape for i in query if ivy.is_array(i)}) == 1 + and len({i.shape for i in query if ivy.is_array(i)}) <= 1 if isinstance(query, tuple) else _check_query(query) ) From eb2a8c0855eae242886922d7228e3341e96bc4aa Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Thu, 11 Jan 2024 15:15:54 +0000 Subject: [PATCH 544/978] fix(torch frontend): `unique` fixed to return tuple, not named tuple. added `Tensor.mH`. `empty` working with scalar tensor inputs. `equal` changed to use array ops. (#27901) --- .../frontends/torch/comparison_ops.py | 2 +- .../frontends/torch/creation_ops.py | 2 ++ .../frontends/torch/reduction_ops.py | 20 ++++--------------- ivy/functional/frontends/torch/tensor.py | 4 ++++ 4 files changed, 11 insertions(+), 17 deletions(-) diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index 7ed083f88b1fe..c5e244189f127 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -74,7 +74,7 @@ def eq(input, other, *, out=None): @to_ivy_arrays_and_back def equal(input, other): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) - return ivy.all_equal(input, other) + return ivy.all(ivy.equal(input, other)) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/torch/creation_ops.py b/ivy/functional/frontends/torch/creation_ops.py index 4f4d9134a9738..f7d2e689c93df 100644 --- a/ivy/functional/frontends/torch/creation_ops.py +++ b/ivy/functional/frontends/torch/creation_ops.py @@ -108,6 +108,8 @@ def empty( raise TypeError("empty() got multiple values for argument 'shape'") if size is None: size = args[0] if isinstance(args[0], (tuple, list, ivy.Shape)) else args + if isinstance(size, (tuple, list)): + size = tuple(s.to_scalar() if ivy.is_array(s) else s for s in size) return ivy.empty(shape=size, dtype=dtype, device=device, out=out) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 53772d8417fee..52e184fa6a289 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -328,27 +328,15 @@ def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=No if dim is not None: sorted = True results = ivy.unique_all(input, axis=dim, by_value=sorted) - - fields = ["output"] - if return_inverse: - fields.append("inverse_indices") - if return_counts: - fields.append("counts") - - values = [results.values] + ret = (results.values,) if return_counts or return_inverse else results.values if return_inverse: inverse_indices = results.inverse_indices - if dim is None: inverse_indices = inverse_indices.reshape(input.shape) - - values.append(inverse_indices) + ret += (results.inverse_indices,) if return_counts: - values.append(results.counts) - - if len(values) == 1: - return values[0] - return tuple(values) + ret += (results.counts,) + return ret @with_unsupported_dtypes( diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 81f692f12f774..53f47aea2adef 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -85,6 +85,10 @@ def T(self): return self return torch_frontend.permute(self, list(range(self.ndim))[::-1]) + @property + def mH(self): + return torch_frontend.adjoint(self) + @property def data(self): return torch_frontend.tensor( From 9134ee3efed30bdce5219c8103b782222669e31f Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Thu, 11 Jan 2024 18:53:21 +0000 Subject: [PATCH 545/978] fix jax backend set item with scalar values (#27886) --- ivy/functional/backends/jax/general.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index a21e94b23fc12..7b697d61444f4 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -91,7 +91,8 @@ def set_item( ) -> JaxArray: if ivy.is_array(query) and ivy.is_bool_dtype(query): query, expected_shape = _mask_to_index(query, x) - val = _broadcast_to(val, expected_shape)._data + if ivy.is_array(val): + val = _broadcast_to(val, expected_shape)._data ret = x.at[query].set(val) if copy: return ret From 66e0c4905908633fa1b2966d6da05a183c9f40d5 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 11 Jan 2024 22:42:27 +0000 Subject: [PATCH 546/978] fix: handle case of indexing with tensors in tf backend --- ivy/functional/backends/tensorflow/general.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index 0d8a8c3f98ab4..c1ff4c4d73068 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -60,6 +60,8 @@ def get_item( *, copy: Optional[bool] = None, ) -> Union[tf.Tensor, tf.Variable]: + if isinstance(query, (tf.Tensor, tf.Variable)): + return tf.gather(x, query) return x.__getitem__(query) From f0c758e3d77c345bae2b5e2795e6e534db7cec8a Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 12 Jan 2024 09:41:24 +0000 Subject: [PATCH 547/978] test: fix the unpacking issue in test_max test passing --- .../test_ivy/test_functional/test_core/test_statistical.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py index 54fbf5f232ec9..650060617b8aa 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py @@ -231,7 +231,7 @@ def test_einsum( keep_dims=st.booleans(), ) def test_max(*, dtype_and_x, keep_dims, test_flags, backend_fw, fn_name, on_device): - input_dtype, x, axis = dtype_and_x + input_dtype, x, axis, *_ = dtype_and_x helpers.test_function( input_dtypes=input_dtype, test_flags=test_flags, From a3c1766e3538582a716901ac120e76fa27adffa4 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 12 Jan 2024 15:48:30 +0530 Subject: [PATCH 548/978] fix: Fixed passing of arguments to `ivy.polyval()` function call (#27905) --- ivy/data_classes/array/experimental/creation.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/ivy/data_classes/array/experimental/creation.py b/ivy/data_classes/array/experimental/creation.py index c83e24c78e6ac..589f7d9168ace 100644 --- a/ivy/data_classes/array/experimental/creation.py +++ b/ivy/data_classes/array/experimental/creation.py @@ -342,6 +342,4 @@ def polyval( return ivy.polyval( coeffs, x, - dtype=dtype, - device=device, ) From 6adb16ea6b8c1eb975a5af6483f31d9d6c443cd6 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 12 Jan 2024 18:16:19 +0400 Subject: [PATCH 549/978] Volunteer program and github badges (#27891) --- docs/overview/contributing.rst | 12 ++- docs/overview/contributing/github_rewards.rst | 97 +++++++++++++++++++ .../contributing/volunteer_workflow.rst | 22 +++++ 3 files changed, 129 insertions(+), 2 deletions(-) create mode 100644 docs/overview/contributing/github_rewards.rst create mode 100644 docs/overview/contributing/volunteer_workflow.rst diff --git a/docs/overview/contributing.rst b/docs/overview/contributing.rst index 6e988bba87b52..1eb64226860f7 100644 --- a/docs/overview/contributing.rst +++ b/docs/overview/contributing.rst @@ -30,10 +30,16 @@ The contributor guide is split into the sections below, it's best to go from sta | (e) `Open Tasks `_ | See where you can help us out! 🙋 | -| (f) `Helpful Resources `_ +| (f) `Volunteer Workflow `_ +| How to climb up the ranks in our Volunteer program 🧗 +| +| (g) `GitHub Rewards `_ +| Check out our GitHub badges and achievements! 🏅 +| +| (h) `Helpful Resources `_ | Resources you would find useful when learning Ivy 📖 | -| (g) `Error Handling `_ +| (i) `Error Handling `_ | Common errors you will be facing contributing to Ivy ❌ .. toctree:: @@ -46,6 +52,8 @@ The contributor guide is split into the sections below, it's best to go from sta contributing/building_the_docs.rst Deep Dive contributing/open_tasks.rst + contributing/volunteer_workflow.rst + contributing/github_rewards.rst contributing/helpful_resources.rst contributing/error_handling.rst diff --git a/docs/overview/contributing/github_rewards.rst b/docs/overview/contributing/github_rewards.rst new file mode 100644 index 0000000000000..7ecf591257ffe --- /dev/null +++ b/docs/overview/contributing/github_rewards.rst @@ -0,0 +1,97 @@ +GitHub Rewards +============== + +Our GitHub Rewards program offers a range of badges, each designed to formally recognize the specific achievements of our contributors in various key areas of project development. + +Badges +~~~~~~~ + +**Debugging Dynamos** - These badges are awarded to contributors who demonstrate exceptional skill in identifying and reporting issues. It recognizes the crucial role of pinpointing problems which is fundamental in maintaining the integrity and performance of our codebase. + +**Pull Request Pioneer** - These awards are granted to those who actively contribute to the development of our projects by initiating pull requests. This badge acknowledges the importance of collaborative development and the initiative taken in proposing valuable code changes and improvements. + +**Merging Master** - These badges are formal recognitions for contributors whose pull requests consistently meet our high standards of quality and are successfully merged into the main codebase. + +**Merging Wizard** - These exclusive badges are awarded to contributors who successfully get *priority* pull requests merged. This recognition is for handling complex, high-priority tasks that have a substantial impact on the project's progress and success. + +**Ivy Inspectors** - These badges are given in acknowledgment of the essential role played by those who review our pull requests. It honours the commitment to quality and diligence in ensuring that each code merge aligns with our high standards. + +Each badge comes in four distinct tiers – Initial, Bronze, Silver, and Gold, mirroring your growing expertise and commitment in these areas. + +Badge Tiers +~~~~~~~~~~~~ + +.. list-table:: + :widths: 50 25 30 30 30 + :header-rows: 1 + + * - GitHub Badge + - Initial (1 Task) + - Bronze (5 Tasks) + - Silver (15 Tasks) + - Gold (30 Tasks) + * - Debugging Dynamos + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-00.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-02.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-03.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-04.png + :width: 110 + :alt: Alternative text + * - Pull Request Pioneer + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-00.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-02.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-03.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-04.png + :width: 110 + :alt: Alternative text + * - Merging Master + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-00.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-02.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-03.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-04.png + :width: 110 + :alt: Alternative text + * - Merging Wizard + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-00.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-02.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-03.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-04.png + :width: 110 + :alt: Alternative text + * - Ivy Inspectors + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-00.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-02.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-03.png + :width: 110 + :alt: Alternative text + - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-04.png + :width: 110 + :alt: Alternative text diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst new file mode 100644 index 0000000000000..b8d48f0e6b246 --- /dev/null +++ b/docs/overview/contributing/volunteer_workflow.rst @@ -0,0 +1,22 @@ +Volunteer Workflow +================== + +We've created a promotion workflow to help you advance through the different tiers of contribution, from Contributor to Core Contributor, Rising Contributor, and finally, Top Contributor. + +Our promotion structure is based on our GitHub badge system. Check out `Github Rewards `_ for more information about them! + +Contributor +----------- +Start as a Contributor by earning any of the Initial Badges. It's straightforward—complete one of the simple tasks listed and you're in! This first step on your journey opens the door to becoming an integral part of our community. + +Core Contributor +---------------- +Elevate to Core Contributor status by earning a Bronze Badge. As a Core Contributor, you're recognized not just for your skills but also for your growing commitment to our mission. You'll have the opportunity to engage more deeply with our projects and play an important role in shaping the future of our initiatives. This tier is a testament to your dedication and a stepping stone to even greater achievements within our community. + +Rising Contributor +------------------ +Ascend to the Rising Contributor level by acquiring a Silver Badge. This tier will allow you to be more deeply involved with our core group. You'll join our GitHub team, enabling you to directly commit changes, and modify issues. As a Rising Contributor, you're encouraged to tackle complex tasks, pushing your skills to new heights. + +Top Contributor +--------------- +Achieve a Gold Badge to reach the peak of our program as a Top Contributor. This tier is for those who demonstrate exceptional dedication and expertise. You'll gain the privilege of engaging with bounty-holding internal tasks and join our Bounty Program, where completing top-priority issues can earn you cash rewards. Upon reaching this level, we will be delighted to acknowledge your contributions to Ivy with a special token of appreciation. From cb2e589dd2900d08c150030e77454a7852419b18 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 12 Jan 2024 20:46:13 +0530 Subject: [PATCH 550/978] fix: Fixed passing of `ceil_mode` key-word argument in `ivy.avg_pool2d()` function call (#27852) --- .../frontends/mindspore/ops/function/nn_func.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index 864119a245bc0..c476401281148 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -111,12 +111,12 @@ def adaptive_avg_pool2d(input, output_size): @to_ivy_arrays_and_back def avg_pool2d( input, - kernel_size, - stride=None, + kernel_size=1, + stride=1, padding=0, - pad_mode=False, + ceil_mode=False, count_include_pad=True, - divisor_override=None, + divisor_override=0, ): # Figure out input dims N input_rank = input.ndim @@ -149,7 +149,7 @@ def avg_pool2d( stride, padding_str, data_format=data_format, - pad_mode=pad_mode, + ceil_mode=ceil_mode, count_include_pad=count_include_pad, divisor_override=divisor_override, ) From 939d7b09b90f1418b470234206907bdb48c30ca1 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 12 Jan 2024 19:44:40 +0400 Subject: [PATCH 551/978] feat: add more details to the volunteer pipeline (#27910) --- docs/overview/contributing/volunteer_workflow.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst index b8d48f0e6b246..9be2f34ac229d 100644 --- a/docs/overview/contributing/volunteer_workflow.rst +++ b/docs/overview/contributing/volunteer_workflow.rst @@ -20,3 +20,7 @@ Ascend to the Rising Contributor level by acquiring a Silver Badge. This tier wi Top Contributor --------------- Achieve a Gold Badge to reach the peak of our program as a Top Contributor. This tier is for those who demonstrate exceptional dedication and expertise. You'll gain the privilege of engaging with bounty-holding internal tasks and join our Bounty Program, where completing top-priority issues can earn you cash rewards. Upon reaching this level, we will be delighted to acknowledge your contributions to Ivy with a special token of appreciation. + +Join Our Team +~~~~~~ +Embark on a rewarding journey with Unify by signing up as a volunteer. We invite you to complete our `Google Form `_, where you can share your details and get started. This is your first step towards making an impact in the world of AI technology. Join us, and let's innovate together! From 084b0c39e073b735d75b7a35885f2b0b89c4a82b Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 12 Jan 2024 21:33:19 +0530 Subject: [PATCH 552/978] fix: Fixed the link to `github_rewards` in docs (#27912) Co-authored-by: NripeshN --- docs/overview/contributing/volunteer_workflow.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst index 9be2f34ac229d..b2218daa9eaf4 100644 --- a/docs/overview/contributing/volunteer_workflow.rst +++ b/docs/overview/contributing/volunteer_workflow.rst @@ -3,7 +3,7 @@ Volunteer Workflow We've created a promotion workflow to help you advance through the different tiers of contribution, from Contributor to Core Contributor, Rising Contributor, and finally, Top Contributor. -Our promotion structure is based on our GitHub badge system. Check out `Github Rewards `_ for more information about them! +Our promotion structure is based on our GitHub badge system. Check out `Github Rewards `_ for more information about them! Contributor ----------- From a0aa0c82c0d37265867a7a7672f19b432e09a9d1 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 12 Jan 2024 20:04:59 +0400 Subject: [PATCH 553/978] Update heading volunteer_workflow.rst --- docs/overview/contributing/volunteer_workflow.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst index b2218daa9eaf4..423b4df172c3a 100644 --- a/docs/overview/contributing/volunteer_workflow.rst +++ b/docs/overview/contributing/volunteer_workflow.rst @@ -22,5 +22,5 @@ Top Contributor Achieve a Gold Badge to reach the peak of our program as a Top Contributor. This tier is for those who demonstrate exceptional dedication and expertise. You'll gain the privilege of engaging with bounty-holding internal tasks and join our Bounty Program, where completing top-priority issues can earn you cash rewards. Upon reaching this level, we will be delighted to acknowledge your contributions to Ivy with a special token of appreciation. Join Our Team -~~~~~~ +------------- Embark on a rewarding journey with Unify by signing up as a volunteer. We invite you to complete our `Google Form `_, where you can share your details and get started. This is your first step towards making an impact in the world of AI technology. Join us, and let's innovate together! From c3533828d507dab4b71db2a2ea27269d64293600 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 12 Jan 2024 20:18:15 +0400 Subject: [PATCH 554/978] feat: Update volunteer_workflow.rs --- docs/overview/contributing/volunteer_workflow.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst index 423b4df172c3a..dc3d73833adba 100644 --- a/docs/overview/contributing/volunteer_workflow.rst +++ b/docs/overview/contributing/volunteer_workflow.rst @@ -23,4 +23,4 @@ Achieve a Gold Badge to reach the peak of our program as a Top Contributor. This Join Our Team ------------- -Embark on a rewarding journey with Unify by signing up as a volunteer. We invite you to complete our `Google Form `_, where you can share your details and get started. This is your first step towards making an impact in the world of AI technology. Join us, and let's innovate together! +Embark on a rewarding journey with Unify by signing up as a volunteer. We invite you to complete our `Google Form `_, where you can share your details and get started. Join us, and let's innovate together! From c735f9399eb8ed969ec6ea1e5767cb7a9749d2e2 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 12 Jan 2024 17:13:17 +0000 Subject: [PATCH 555/978] test: add atol in test_numpy_correlate to avoid minor value mismatches --- .../test_numpy/test_statistics/test_correlating.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_statistics/test_correlating.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_statistics/test_correlating.py index ee73f44e8a3d6..055ec7ace5b72 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_statistics/test_correlating.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_statistics/test_correlating.py @@ -83,7 +83,8 @@ def test_numpy_correlate( test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, - rtol=1e-2, + rtol=1e-3, + atol=1e-3, a=xs[0], v=xs[1], mode=mode, From a9fb01d76849c96167971a8959b45be218319c1e Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 12 Jan 2024 17:15:02 +0000 Subject: [PATCH 556/978] fix: fix test_lgamma by adding the missing container method not to be confused with igamma --- .../container/experimental/statistical.py | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/ivy/data_classes/container/experimental/statistical.py b/ivy/data_classes/container/experimental/statistical.py index 09c0e616384b1..8c88175c9a543 100644 --- a/ivy/data_classes/container/experimental/statistical.py +++ b/ivy/data_classes/container/experimental/statistical.py @@ -1338,6 +1338,35 @@ def igamma( """ return self.static_igamma(self, x=x, out=out) + @staticmethod + def static_lgamma( + a: Union[ivy.Container, ivy.Array, ivy.NativeArray], + /, + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + out: Optional[ivy.Container] = None, + ) -> ivy.Container: + return ContainerBase.cont_multi_map_in_function( + "lgamma", + a, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + out=out, + ) + + def lgamma( + self: ivy.Container, + /, + *, + out: Optional[ivy.Container] = None, + ) -> ivy.Container: + return self.static_lgamma(self, out=out) + @staticmethod def static_cov( x1: Union[ivy.Array, ivy.NativeArray, ivy.Container], From 31a2a4d4ae96973399f71f73d8f00a2f08fdfc0a Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 12 Jan 2024 21:26:12 +0400 Subject: [PATCH 557/978] feat: Update volunteer_workflow.rst --- docs/overview/contributing/volunteer_workflow.rst | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst index dc3d73833adba..bdebee8739b60 100644 --- a/docs/overview/contributing/volunteer_workflow.rst +++ b/docs/overview/contributing/volunteer_workflow.rst @@ -1,6 +1,8 @@ Volunteer Workflow ================== +Embark on a rewarding journey with Unify by signing up`_ as a volunteer. Let's innovate together! + We've created a promotion workflow to help you advance through the different tiers of contribution, from Contributor to Core Contributor, Rising Contributor, and finally, Top Contributor. Our promotion structure is based on our GitHub badge system. Check out `Github Rewards `_ for more information about them! @@ -20,7 +22,3 @@ Ascend to the Rising Contributor level by acquiring a Silver Badge. This tier wi Top Contributor --------------- Achieve a Gold Badge to reach the peak of our program as a Top Contributor. This tier is for those who demonstrate exceptional dedication and expertise. You'll gain the privilege of engaging with bounty-holding internal tasks and join our Bounty Program, where completing top-priority issues can earn you cash rewards. Upon reaching this level, we will be delighted to acknowledge your contributions to Ivy with a special token of appreciation. - -Join Our Team -------------- -Embark on a rewarding journey with Unify by signing up as a volunteer. We invite you to complete our `Google Form `_, where you can share your details and get started. Join us, and let's innovate together! From 824867535d81eb03cf76cf473dd5c663189bfb36 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 12 Jan 2024 21:26:24 +0400 Subject: [PATCH 558/978] Update volunteer_workflow.rst --- docs/overview/contributing/volunteer_workflow.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst index bdebee8739b60..a29f10f855d8d 100644 --- a/docs/overview/contributing/volunteer_workflow.rst +++ b/docs/overview/contributing/volunteer_workflow.rst @@ -1,7 +1,7 @@ Volunteer Workflow ================== -Embark on a rewarding journey with Unify by signing up`_ as a volunteer. Let's innovate together! +Embark on a rewarding journey with Unify by signing up `_ as a volunteer. Let's innovate together! We've created a promotion workflow to help you advance through the different tiers of contribution, from Contributor to Core Contributor, Rising Contributor, and finally, Top Contributor. From d5c73ecf63f56dd31a279f12659486f59ac0a113 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 12 Jan 2024 21:28:59 +0400 Subject: [PATCH 559/978] feat: Update link volunteer_workflow.rst --- docs/overview/contributing/volunteer_workflow.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst index a29f10f855d8d..5c2092d4292fc 100644 --- a/docs/overview/contributing/volunteer_workflow.rst +++ b/docs/overview/contributing/volunteer_workflow.rst @@ -1,7 +1,7 @@ Volunteer Workflow ================== -Embark on a rewarding journey with Unify by signing up `_ as a volunteer. Let's innovate together! +Embark on a rewarding journey with Unify by `signing up `_ as a volunteer. Let's innovate together! We've created a promotion workflow to help you advance through the different tiers of contribution, from Contributor to Core Contributor, Rising Contributor, and finally, Top Contributor. From 0dc7bfc60c6eb13d630f946886cfaa1f0bad8dc8 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 12 Jan 2024 18:55:53 +0000 Subject: [PATCH 560/978] fix: update the implementation of modf in tf backend the currently used tf.math.modf doesn't exist. --- .../backends/tensorflow/experimental/elementwise.py | 5 ++++- ivy/functional/backends/torch/experimental/elementwise.py | 5 +++-- .../test_experimental/test_core/test_elementwise.py | 2 +- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/elementwise.py b/ivy/functional/backends/tensorflow/experimental/elementwise.py index 62467bf853aac..ffb9614300c90 100644 --- a/ivy/functional/backends/tensorflow/experimental/elementwise.py +++ b/ivy/functional/backends/tensorflow/experimental/elementwise.py @@ -538,13 +538,16 @@ def frexp( return m, e +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def modf( x: Union[tf.Tensor, tf.Variable], /, *, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - return tf.math.modf(x) + integer_part = tf.math.floor(x) + fractional_part = x - integer_part + return fractional_part, integer_part def digamma( diff --git a/ivy/functional/backends/torch/experimental/elementwise.py b/ivy/functional/backends/torch/experimental/elementwise.py index faa58bff5650f..7b0194571abfd 100644 --- a/ivy/functional/backends/torch/experimental/elementwise.py +++ b/ivy/functional/backends/torch/experimental/elementwise.py @@ -416,8 +416,9 @@ def modf( *, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: - modf_x = torch.modf(x) - return torch.resolve_modf(input=modf_x) + fractional_part = torch.frac(x) + integer_part = torch.floor(x) + return fractional_part, integer_part @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py index 24517040cf225..12e3bd938b063 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py @@ -796,7 +796,7 @@ def test_lgamma( @handle_test( fn_tree="functional.ivy.experimental.modf", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), num_arrays=1, min_value=0, exclude_min=True, From 70d902fd7092af59f026612abd6fe432b1b2dddc Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 12 Jan 2024 19:03:17 +0000 Subject: [PATCH 561/978] fix: update the return signature of modf in tf and torch backends to reflect it being tuple of tensors --- ivy/functional/backends/tensorflow/experimental/elementwise.py | 2 +- ivy/functional/backends/torch/experimental/elementwise.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/tensorflow/experimental/elementwise.py b/ivy/functional/backends/tensorflow/experimental/elementwise.py index ffb9614300c90..8f5b53c24a1dd 100644 --- a/ivy/functional/backends/tensorflow/experimental/elementwise.py +++ b/ivy/functional/backends/tensorflow/experimental/elementwise.py @@ -544,7 +544,7 @@ def modf( /, *, out: Optional[Union[tf.Tensor, tf.Variable]] = None, -) -> Union[tf.Tensor, tf.Variable]: +) -> Tuple[Union[tf.Tensor, tf.Variable], Union[tf.Tensor, tf.Variable]]: integer_part = tf.math.floor(x) fractional_part = x - integer_part return fractional_part, integer_part diff --git a/ivy/functional/backends/torch/experimental/elementwise.py b/ivy/functional/backends/torch/experimental/elementwise.py index 7b0194571abfd..309139a7bbf62 100644 --- a/ivy/functional/backends/torch/experimental/elementwise.py +++ b/ivy/functional/backends/torch/experimental/elementwise.py @@ -415,7 +415,7 @@ def modf( /, *, out: Optional[torch.Tensor] = None, -) -> torch.Tensor: +) -> Tuple[torch.Tensor, torch.Tensor]: fractional_part = torch.frac(x) integer_part = torch.floor(x) return fractional_part, integer_part From cd625c96ed4dd4b84bc45e5888f9b5b5dc37cb54 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 12 Jan 2024 19:14:39 +0000 Subject: [PATCH 562/978] fix: update modf implementation in paddle backend removing the call paddle.modf which doesn't exist. --- .../backends/paddle/experimental/elementwise.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 1d9802da6c154..6c7500612de5c 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -669,11 +669,22 @@ def conj(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. return paddle.conj(x) +@with_supported_dtypes( + { + "2.5.0 and below": ( + "float32", + "float64", + ) + }, + backend_version, +) def modf( x: paddle.Tensor, /, *, out: Optional[Tuple[paddle.Tensor, paddle.Tensor]] = None ) -> Tuple[paddle.Tensor, paddle.Tensor]: with ivy.ArrayMode(False): - return paddle.modf(x, out=out) + integer_part = paddle.floor(x) + fractional_part = x - integer_part + return fractional_part, integer_part @with_supported_dtypes( From c1b132c5ed9c1a2447cf3a19d6bfcd65d62aa4a6 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 12 Jan 2024 19:44:58 +0000 Subject: [PATCH 563/978] fix: fix core test_deg2rad by avoiding attribute error requiring enabling numpy behaviour etc. this was due to the usage of experimental numpy api from tf. --- ivy/functional/backends/tensorflow/elementwise.py | 6 +++--- .../test_ivy/test_functional/test_core/test_elementwise.py | 5 ++++- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index a30b34bba8a60..f6535b236d591 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -2,7 +2,6 @@ from typing import Union, Optional import tensorflow as tf - # local import ivy from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes @@ -859,14 +858,15 @@ def reciprocal( return tf.math.reciprocal(x) -@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def deg2rad( x: Union[tf.Tensor, tf.Variable], /, *, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - return tf.experimental.numpy.deg2rad(x) + radians = x * ivy.pi / 180.0 + return radians def rad2deg( diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index df93ccd30e631..d3cd221a77f33 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -635,7 +635,10 @@ def test_cosh(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.deg2rad", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric") + available_dtypes=helpers.get_dtypes("valid"), + safety_factor_scale="log", + large_abs_safety_factor=2, + small_abs_safety_factor=2, ), ) def test_deg2rad(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): From 948fa956f2ef552f8a3cd9ecf6252128196166ec Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Fri, 12 Jan 2024 20:06:00 +0000 Subject: [PATCH 564/978] fix: specify complex as unsupported for most backends as the use of isposinf and isneginf doesn't take complex inputs --- ivy/functional/backends/jax/elementwise.py | 1 + ivy/functional/backends/numpy/elementwise.py | 1 + ivy/functional/backends/paddle/elementwise.py | 4 ++++ ivy/functional/backends/torch/elementwise.py | 1 + 4 files changed, 7 insertions(+) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index 62ac7a5fa5c6d..42a5fd51077c5 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -248,6 +248,7 @@ def isfinite(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.isfinite(x) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def isinf( x: JaxArray, /, diff --git a/ivy/functional/backends/numpy/elementwise.py b/ivy/functional/backends/numpy/elementwise.py index 3000ed0954685..5275c963ffebf 100644 --- a/ivy/functional/backends/numpy/elementwise.py +++ b/ivy/functional/backends/numpy/elementwise.py @@ -378,6 +378,7 @@ def isfinite(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarra isfinite.support_native_out = True +@with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) @_scalar_output_to_0d_array def isinf( x: np.ndarray, diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index b7a670f7e5302..b68fc1aa87b51 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -98,6 +98,10 @@ def isfinite( return paddle.isfinite(x) +@with_unsupported_dtypes( + {"2.5.2 and below": ("complex", "uint8")}, + backend_version, +) def isinf( x: paddle.Tensor, /, diff --git a/ivy/functional/backends/torch/elementwise.py b/ivy/functional/backends/torch/elementwise.py index a10cac96704db..7aec8d25c8a0c 100644 --- a/ivy/functional/backends/torch/elementwise.py +++ b/ivy/functional/backends/torch/elementwise.py @@ -95,6 +95,7 @@ def isfinite(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch return torch.isfinite(x) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def isinf( x: torch.Tensor, From c993756f1d68508651a12a876e122affdbb19bc7 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sat, 13 Jan 2024 21:20:19 +0530 Subject: [PATCH 565/978] fix: Fixed using of deprecated `inspect.getargspec()` function (#27907) Co-authored-by: NripeshN --- ivy/functional/frontends/torch/utilities.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/utilities.py b/ivy/functional/frontends/torch/utilities.py index 48fa393c14410..728c788a61569 100644 --- a/ivy/functional/frontends/torch/utilities.py +++ b/ivy/functional/frontends/torch/utilities.py @@ -27,7 +27,7 @@ def bincount(x, weights=None, minlength=0): def if_else(cond_fn, body_fn, orelse_fn, vars): - cond_keys = inspect.getargspec(cond_fn).args + cond_keys = inspect.getfullargspec(cond_fn).args cond_vars = dict(zip(cond_keys, vars)) return ivy.if_else(cond_fn, body_fn, orelse_fn, cond_vars) From 51d1f48c93df7f8c797b58fb9cf99be2eeb6b4f4 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Sat, 13 Jan 2024 21:36:08 +0000 Subject: [PATCH 566/978] fix torch.lstm frontend tests (#27916) --- ivy/functional/backends/tensorflow/layers.py | 9 +++++++-- .../frontends/torch/nn/functional/layer_functions.py | 2 +- .../test_nn/test_functional/test_layer_functions.py | 2 +- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index d1e6c2043cd5b..300afb74ae168 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -716,8 +716,13 @@ def step(cell_inputs, cell_states): h_tm1 = cell_states[0] # previous memory state c_tm1 = cell_states[1] # previous carry state - z = tf.keras.backend.dot(cell_inputs, kernel) + bias - z += tf.keras.backend.dot(h_tm1, recurrent_kernel) + recurrent_bias + z = tf.keras.backend.dot(cell_inputs, kernel) + if bias is not None: + z += bias + + z += tf.keras.backend.dot(h_tm1, recurrent_kernel) + if recurrent_bias is not None: + z += recurrent_bias z0, z1, z2, z3 = tf.split(z, 4, axis=-1) diff --git a/ivy/functional/frontends/torch/nn/functional/layer_functions.py b/ivy/functional/frontends/torch/nn/functional/layer_functions.py index 7ed6d8d90354e..75f41ea474f12 100644 --- a/ivy/functional/frontends/torch/nn/functional/layer_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/layer_functions.py @@ -96,7 +96,7 @@ def _generic_lstm( (weight_ih, weight_hh), (bias_i, bias_h), bidirectional, - batch_first=batch_first, + batch_first=False, batch_sizes=batch_sizes, ) h_outs.append(h_out) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py index 1395d00bb080b..e44d5deec0b69 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py @@ -178,7 +178,7 @@ def test_torch_lstm( ): dtypes, kwargs = dtypes_kwargs # Todo: Debug the function to have this case passing as well - assume("batch_sizes" not in kwargs or not kwargs["bidirectional"]) + assume("batch_sizes" not in kwargs) helpers.test_frontend_function( input_dtypes=dtypes, backend_to_test=backend_fw, From ad74d1c962e0d1a4df4aaf88b5dd9998c2801bdc Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 14 Jan 2024 15:02:08 +0000 Subject: [PATCH 567/978] Update volunteer-leaderboard.rst --- .../overview/contributing/volunteer_ranks.rst | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 docs/overview/contributing/volunteer_ranks.rst diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst new file mode 100644 index 0000000000000..0258594dd866a --- /dev/null +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -0,0 +1,20 @@ +Volunteer Ranks +============== + +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. + +Rising Contributors +------------------- +.. list-table:: + :widths: 50 50 50 + :header-rows: 1 + + * - Full Name + - Github ID + - Badges + * - samunder singh + - `samthakur587 `_ + - Debugging Dynamo Silver, Merging Master Bronze, Debugging Dynamo Bronze, Pull Request Pioneer Bronze, Pull Request Pioneer, Debugging Dynamo, Merging Master + * - V\. Sai Suraj + - `Sai-Suraj-27 `_ + - Merging Master Silver, Debugging Dynamo Silver, Pull Request Pioneer Silver, Merging Master Bronze, Debugging Dynamo Bronze, Pull Request Pioneer Bronze, Pull Request Pioneer, Debugging Dynamo, Merging Master From bfb38c57bef3e0f22323cf2fba88d0ef1fb57d7c Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 14 Jan 2024 15:03:23 +0000 Subject: [PATCH 568/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/contributing/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 0258594dd866a..9b70ab8c23ae9 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Ranks ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- From 7f1f86c2e832bb13c3e54690c82fca42941cf2f4 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 14 Jan 2024 15:59:39 +0000 Subject: [PATCH 569/978] Update volunteer-leaderboard.rst --- docs/overview/contributing/volunteer_ranks.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 9b70ab8c23ae9..f598eb1c0aa2b 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Ranks ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- @@ -14,7 +14,7 @@ Rising Contributors - Badges * - samunder singh - `samthakur587 `_ - - Debugging Dynamo Silver, Merging Master Bronze, Debugging Dynamo Bronze, Pull Request Pioneer Bronze, Pull Request Pioneer, Debugging Dynamo, Merging Master + - Debugging Dynamo Silver, Merging Master Bronze, Pull Request Pioneer Bronze * - V\. Sai Suraj - `Sai-Suraj-27 `_ - - Merging Master Silver, Debugging Dynamo Silver, Pull Request Pioneer Silver, Merging Master Bronze, Debugging Dynamo Bronze, Pull Request Pioneer Bronze, Pull Request Pioneer, Debugging Dynamo, Merging Master + - Merging Master Silver, Debugging Dynamo Silver, Pull Request Pioneer Silver From d3a4e61e599d3f2f47691c326a1731233c31bd89 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 14 Jan 2024 16:01:42 +0000 Subject: [PATCH 570/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/contributing/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index f598eb1c0aa2b..5ba0bd7a7eb84 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Ranks ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- From 08b6971f707c6e7a21893c1909a6f9e688791d12 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 14 Jan 2024 16:08:10 +0000 Subject: [PATCH 571/978] Update volunteer-leaderboard.rst --- docs/overview/contributing/volunteer_ranks.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 5ba0bd7a7eb84..6ea8c3c428d37 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ -Volunteer Ranks +Volunteer Leaderboard ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- From edded3a0f9c3ebd9fc1292827b1508c548fc6784 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 14 Jan 2024 16:09:39 +0000 Subject: [PATCH 572/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/contributing/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 6ea8c3c428d37..19ae1b21f66f5 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Leaderboard ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- From 69c1fdbdfeca04ca29e0941a6e68a3320e286ff2 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 14 Jan 2024 16:14:29 +0000 Subject: [PATCH 573/978] Update volunteer-leaderboard.rst --- docs/overview/contributing/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 19ae1b21f66f5..00cb66f1314ac 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Leaderboard ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- @@ -12,9 +12,9 @@ Rising Contributors * - Full Name - Github ID - Badges - * - samunder singh - - `samthakur587 `_ - - Debugging Dynamo Silver, Merging Master Bronze, Pull Request Pioneer Bronze * - V\. Sai Suraj - `Sai-Suraj-27 `_ - Merging Master Silver, Debugging Dynamo Silver, Pull Request Pioneer Silver + * - samunder singh + - `samthakur587 `_ + - Debugging Dynamo Silver, Merging Master Bronze, Pull Request Pioneer Bronze From 0a08f68b544cee8dfe66eb06026c4e4b62984f21 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 14 Jan 2024 16:15:49 +0000 Subject: [PATCH 574/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/contributing/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 00cb66f1314ac..ac035b0a2588f 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Leaderboard ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- From fdd896e23845c2ca4ebac6aa7c1acbac55072b83 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 14 Jan 2024 16:17:03 +0000 Subject: [PATCH 575/978] Update volunteer-leaderboard.rst --- docs/overview/contributing/volunteer_ranks.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index ac035b0a2588f..ef7b223ccb91f 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Leaderboard ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- @@ -9,7 +9,7 @@ Rising Contributors :widths: 50 50 50 :header-rows: 1 - * - Full Name + * - Name - Github ID - Badges * - V\. Sai Suraj From 1b81b0882ce2b5ff738332362273587c24e670c4 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 14 Jan 2024 16:18:28 +0000 Subject: [PATCH 576/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/contributing/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index ef7b223ccb91f..523dfa11b3563 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Leaderboard ============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- From 932867dfb20b281074413e2d1fdff5e279ee5ec4 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sun, 14 Jan 2024 20:31:32 +0400 Subject: [PATCH 577/978] Update contributing.rst --- docs/overview/contributing.rst | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/overview/contributing.rst b/docs/overview/contributing.rst index 1eb64226860f7..963ec63968a7d 100644 --- a/docs/overview/contributing.rst +++ b/docs/overview/contributing.rst @@ -36,10 +36,13 @@ The contributor guide is split into the sections below, it's best to go from sta | (g) `GitHub Rewards `_ | Check out our GitHub badges and achievements! 🏅 | -| (h) `Helpful Resources `_ +| (h) `Volunteer Leaderboard `_ +| See where you stand on our leaderboard 🏆 +| +| (i) `Helpful Resources `_ | Resources you would find useful when learning Ivy 📖 | -| (i) `Error Handling `_ +| (j) `Error Handling `_ | Common errors you will be facing contributing to Ivy ❌ .. toctree:: @@ -54,6 +57,7 @@ The contributor guide is split into the sections below, it's best to go from sta contributing/open_tasks.rst contributing/volunteer_workflow.rst contributing/github_rewards.rst + contributing/volunteer_ranks.rst contributing/helpful_resources.rst contributing/error_handling.rst From 9a181d9d01573630d15066be2938c5c8c7491b4c Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 14 Jan 2024 22:11:55 +0000 Subject: [PATCH 578/978] test: update test_torch_exp array dtypes to all valid types --- .../test_ivy/test_frontends/test_torch/test_pointwise_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py index e59d370752821..b8dc1f212a862 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py @@ -1211,7 +1211,7 @@ def test_torch_erfc( @handle_frontend_test( fn_tree="torch.exp", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), + available_dtypes=helpers.get_dtypes("valid"), ), ) def test_torch_exp( From 3f0e5f566c2ab953c8c045279b8430d4f8062c41 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 14 Jan 2024 22:15:47 +0000 Subject: [PATCH 579/978] test: update the safety scale in test_asin to avoid nans in jax backend tests --- ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index d3cd221a77f33..5c74ed9aad14c 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -293,6 +293,7 @@ def test_angle( fn_tree="functional.ivy.asin", dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("float_and_complex"), + safety_factor_scale="log", large_abs_safety_factor=4, small_abs_safety_factor=4, ), From f3dd7eb5b126afbb2d646277a086c19950c22ba2 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 14 Jan 2024 22:24:31 +0000 Subject: [PATCH 580/978] test: increase safety for test_atan to avoid some value mismatches for jax backend --- .../test_ivy/test_functional/test_core/test_elementwise.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 5c74ed9aad14c..dc912ebc156ff 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -340,8 +340,8 @@ def test_asinh(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): fn_tree="functional.ivy.atan", dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("float_and_complex"), - large_abs_safety_factor=2, - small_abs_safety_factor=2, + large_abs_safety_factor=4, + small_abs_safety_factor=4, safety_factor_scale="log", ), ) From fec52dc754aba0f3b8570bb685560af1c607139c Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 14 Jan 2024 22:27:28 +0000 Subject: [PATCH 581/978] fix: reset broadcasting issues in jax backend setitem (#27909) --- ivy/functional/backends/jax/general.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index 7b697d61444f4..2b1cd31da7661 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -58,8 +58,7 @@ def _mask_to_index(query, x): raise ivy.exceptions.IvyException("too many indices") elif not len(query.shape): query = jnp.tile(query, x.shape[0]) - expected_shape = x[query].shape - return jnp.where(query), expected_shape + return jnp.where(query) def get_item( @@ -75,7 +74,7 @@ def get_item( return jnp.array([], dtype=x.dtype) else: return jnp.expand_dims(x, 0) - query, _ = _mask_to_index(query, x) + query = _mask_to_index(query, x) elif isinstance(query, list): query = (query,) return x.__getitem__(query) @@ -90,9 +89,10 @@ def set_item( copy: Optional[bool] = False, ) -> JaxArray: if ivy.is_array(query) and ivy.is_bool_dtype(query): - query, expected_shape = _mask_to_index(query, x) - if ivy.is_array(val): - val = _broadcast_to(val, expected_shape)._data + query = _mask_to_index(query, x) + expected_shape = x[query].shape + if ivy.is_array(val): + val = _broadcast_to(val, expected_shape)._data ret = x.at[query].set(val) if copy: return ret From a945a7d6a7f9fe46d950719fb89a1b081929c3d6 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 14 Jan 2024 22:31:45 +0000 Subject: [PATCH 582/978] test: fix test_asinh for paddle backend taking float16 out of the supported types and also for jax backend value mismatches by making the safety scale to be log. --- ivy/functional/backends/paddle/elementwise.py | 1 - ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index b68fc1aa87b51..cfaeaa6563c0a 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -210,7 +210,6 @@ def asin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( { "2.5.2 and below": ( - "float16", "float32", "float64", ) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index dc912ebc156ff..ae33eed1e985e 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -319,6 +319,7 @@ def test_asin(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): available_dtypes=helpers.get_dtypes("float_and_complex"), large_abs_safety_factor=4, small_abs_safety_factor=4, + safety_factor_scale="log", ), ) def test_asinh(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): From 954cc36f41e1a40d4bd4a83d6fe6095df6c84fc4 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 14 Jan 2024 22:37:25 +0000 Subject: [PATCH 583/978] test: ensure test_acos is run for all valid types with relevant specifications in tf backend and update the safety factor scale to be log --- ivy/functional/backends/tensorflow/elementwise.py | 1 + .../test_ivy/test_functional/test_core/test_elementwise.py | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index f6535b236d591..11c0dbcad8278 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -22,6 +22,7 @@ def abs( return tf.abs(x) +@with_unsupported_dtypes({"2.15.0 and below": ("unsigned", "bool")}, backend_version) def acos( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index ae33eed1e985e..98e077287ebff 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -177,9 +177,10 @@ def test_abs(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.acos", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float_and_complex"), + available_dtypes=helpers.get_dtypes("valid"), large_abs_safety_factor=4, small_abs_safety_factor=4, + safety_factor_scale="log", ), ) def test_acos(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): From 13dc7b0704901b3d76ee7852a73ae714dc11313a Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 14 Jan 2024 23:09:24 +0000 Subject: [PATCH 584/978] fix: specify uint8 as unsupported for logical_not in paddle backend --- ivy/functional/backends/paddle/elementwise.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index cfaeaa6563c0a..c031905aa1b7f 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -377,7 +377,7 @@ def cos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T return paddle.cos(x) -@with_unsupported_dtypes({"2.5.1 and below": ("uint", "float16")}, backend_version) +@with_unsupported_dtypes({"2.5.1 and below": ("uint8", "float16")}, backend_version) def logical_not( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: From 2a75afb654ddcd802214dd0ca1e7a9c8a05b2792 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 14 Jan 2024 23:38:15 +0000 Subject: [PATCH 585/978] fix: make paddle backend logical_xor match functionality with that of tf and get the test_logical_xor passing --- ivy/functional/backends/paddle/elementwise.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index c031905aa1b7f..1f44c14736956 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -529,7 +529,8 @@ def logical_xor( ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) if paddle.is_complex(x1): - return _apply_for_real_and_imag(paddle.logical_xor, x1, x2) + x1 = paddle.cast(x1, paddle.bool) + x2 = paddle.cast(x2, paddle.bool) return paddle.logical_xor(x1, x2) From 9b2801dfd334911347ece8909e5075ae82481fa1 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 15 Jan 2024 12:27:21 +0530 Subject: [PATCH 586/978] fix(docs): updated the contributor guide (#27920) --- docs/overview/contributing.rst | 28 ++++++------ ...ub_rewards.rst => contributor_rewards.rst} | 9 ++-- docs/overview/contributing/open_tasks.rst | 21 +++++++-- .../contributing/volunteer_program.rst | 43 +++++++++++++++++++ .../overview/contributing/volunteer_ranks.rst | 4 +- .../contributing/volunteer_workflow.rst | 24 ----------- 6 files changed, 81 insertions(+), 48 deletions(-) rename docs/overview/contributing/{github_rewards.rst => contributor_rewards.rst} (92%) create mode 100644 docs/overview/contributing/volunteer_program.rst delete mode 100644 docs/overview/contributing/volunteer_workflow.rst diff --git a/docs/overview/contributing.rst b/docs/overview/contributing.rst index 963ec63968a7d..236a682b7f6b2 100644 --- a/docs/overview/contributing.rst +++ b/docs/overview/contributing.rst @@ -21,24 +21,24 @@ The contributor guide is split into the sections below, it's best to go from sta | (b) `The Basics `_ | Managing your fork 🇾, creating issues ⭕, and creating pull-requests ⬆️ | -| (c) `Building the Docs `_ -| How to build the documentation locally 🏗️ -| -| (d) `Deep Dive `_ -| Take a deep dive into the codebase 🤿 -| -| (e) `Open Tasks `_ +| (c) `Open Tasks `_ | See where you can help us out! 🙋 | -| (f) `Volunteer Workflow `_ -| How to climb up the ranks in our Volunteer program 🧗 +| (d) `Contributor Rewards `_ +| Check out our contributor badges and achievements! 🏅 | -| (g) `GitHub Rewards `_ -| Check out our GitHub badges and achievements! 🏅 +| (e) `Volunteer Program `_ +| How to climb up the ranks in our Volunteer program 🧗 | -| (h) `Volunteer Leaderboard `_ +| (f) `Volunteer Leaderboard `_ | See where you stand on our leaderboard 🏆 | +| (g) `Building the Docs `_ +| How to build the documentation locally 🏗️ +| +| (h) `Deep Dive `_ +| Take a deep dive into the codebase 🤿 +| | (i) `Helpful Resources `_ | Resources you would find useful when learning Ivy 📖 | @@ -55,8 +55,8 @@ The contributor guide is split into the sections below, it's best to go from sta contributing/building_the_docs.rst Deep Dive contributing/open_tasks.rst - contributing/volunteer_workflow.rst - contributing/github_rewards.rst + contributing/volunteer_program.rst + contributing/contributor_rewards.rst contributing/volunteer_ranks.rst contributing/helpful_resources.rst contributing/error_handling.rst diff --git a/docs/overview/contributing/github_rewards.rst b/docs/overview/contributing/contributor_rewards.rst similarity index 92% rename from docs/overview/contributing/github_rewards.rst rename to docs/overview/contributing/contributor_rewards.rst index 7ecf591257ffe..bbf3d6d505051 100644 --- a/docs/overview/contributing/github_rewards.rst +++ b/docs/overview/contributing/contributor_rewards.rst @@ -1,12 +1,13 @@ -GitHub Rewards -============== +Contributor Rewards +=================== -Our GitHub Rewards program offers a range of badges, each designed to formally recognize the specific achievements of our contributors in various key areas of project development. +We award a range of badges, each designed to formally recognize the specific achievements of our contributors in various key areas of ivy's development. Badges ~~~~~~~ -**Debugging Dynamos** - These badges are awarded to contributors who demonstrate exceptional skill in identifying and reporting issues. It recognizes the crucial role of pinpointing problems which is fundamental in maintaining the integrity and performance of our codebase. +**Debugging Dynamos** - These badges are awarded to contributors who demonstrate exceptional skill in identifying and reporting issues. +It recognizes the crucial role of pinpointing problems which is fundamental in maintaining the integrity and performance of our codebase. **Pull Request Pioneer** - These awards are granted to those who actively contribute to the development of our projects by initiating pull requests. This badge acknowledges the importance of collaborative development and the initiative taken in proposing valuable code changes and improvements. diff --git a/docs/overview/contributing/open_tasks.rst b/docs/overview/contributing/open_tasks.rst index 38556ecf8594f..a93ed13d89803 100644 --- a/docs/overview/contributing/open_tasks.rst +++ b/docs/overview/contributing/open_tasks.rst @@ -32,22 +32,35 @@ Please always use the latest commit on GitHub when working on any of these tasks Fixing Failing Tests -------------------- -In the Ivy repository, we've identified a range of functions and tests that currently fall short of our quality standards. The root of these issues is not always clear-cut. In some instances, the problem may lie within the functions themselves, while in others, it could be the tests, which were crafted by various contributors, that are at fault. This situation presents a unique opportunity for community involvement. We are actively inviting contributions from our community to help tackle these challenges. +We've identified a range of functions and tests that fail the tests. +The root of these issues is not always straightforward. +In some instances, the problem may lie within the function implementations, while in others, it could be the way the tests were added previously. +Certain failing tests are more urgent to fix than others, as mentioned in the sub-section below. +We encourage contributions from the community to help tackle these challenges. How to Contribute ~~~~~~~~~~~~~~~~~ **Identifying Issues** -To get started, visit our issues page: `Failing Tests `_. Here, you will find a list of open issues labeled as "Failing Test" and "ToDo". These issues are categorised under various frameworks supported by our repository. We encourage you to select a framework you're comfortable with or interested in contributing to. +To get started, visit our issues page: `Failing Tests `_. +Here, you will find a list of open issues labeled as "Failing Test" and "ToDo". +These issues are categorised under various frameworks supported by our repository. +We encourage you to select a framework you're comfortable with or interested in contributing to. **Selecting a Test** -Within each framework, tests are classified as either "Priority Open" or "Other Open." While we prioritize fixing the "Priority Open" tests, contributions towards any test, including those labeled "Other Open," are highly valuable. Each test issue is linked directly to the specific failing workflow. This linkage provides you with immediate access to the details of what exactly is failing and the context around it. +Within each framework, tests are classified as either "Priority Open" or "Other Open." +While we prioritize fixing the "Priority Open" tests, contributions towards any test, including those labeled "Other Open," are highly valuable. +Each test issue is linked directly to the specific failing workflow. +This linkage provides you with immediate access to the details of what exactly is failing and the context around it. **Making Your Contribution** -After selecting a test to work on, please fork the repository and create a new branch for your fix. Ensure that your solution addresses the issue effectively and doesn't introduce new errors. Once you're confident in your fix, submit a pull request to the main repository. Our team will review your contribution, provide feedback if necessary, and then merge your changes once they meet our standards. +After selecting a test to work on, please make the necessary changes and create a PR referring to `the basics `_. +Ensure that your solution addresses the issue effectively and doesn't introduce new errors. +Once you're confident in your fix, submit a pull request to the main repository. +Our team will review your contribution, provide feedback if necessary, and then merge your changes once we're good to go. Frontend APIs ------------- diff --git a/docs/overview/contributing/volunteer_program.rst b/docs/overview/contributing/volunteer_program.rst new file mode 100644 index 0000000000000..65be69053c3d5 --- /dev/null +++ b/docs/overview/contributing/volunteer_program.rst @@ -0,0 +1,43 @@ +Volunteer Program +================= + +The goal of the volunteer program is to facilitate contributors in the community that would like to work more closely +with our team. +Embark on a rewarding journey with Unify by `signing up `_ as a volunteer. +Let's innovate together! + +We've created a promotion workflow to help you advance through the different tiers of contribution, +from Contributor to Core Contributor, Rising Contributor, and finally, Top Contributor. + +Our promotion structure is based on our badge system. +Check out `Contributor Rewards `_ for more information about them! + +Contributor +----------- +Start as a Contributor by earning any of the Initial Badges. +It's straightforward — complete one of the open tasks listed and you're in! +This first step opens the door for you to become an integral part of our community. + +Core Contributor +---------------- +Get elevated to Core Contributor status by earning a Bronze Badge. +As a Core Contributor, you're recognized not just for your skills but also for your growing commitment to our mission. +You'll have the opportunity to engage more deeply with our projects and play an important role in shaping the future of our initiatives. +This tier is a testament to your dedication and a stepping stone to even greater achievements within our community. +As a token of appreciation, you'll be eligible for a $25 welcome gift. + +Rising Contributor +------------------ +Ascend to the Rising Contributor level by acquiring a Silver Badge. +This tier will allow you to be more deeply involved with our core group. +You'll join our GitHub team, enabling you to directly commit changes to :code:`main`, manage PRs made by others in the community, etc. +You'll also be invited to all our internal meetings to be able to follow along with everything happening in the team. +As a Rising Contributor, you're encouraged to tackle complex tasks, pushing your skills to new heights. + +Top Contributor +--------------- +Achieve a Gold Badge to reach the peak of our program as a Top Contributor. +This tier is for those who demonstrate exceptional dedication and expertise. +You'll gain the privilege of engaging with bounty-holding internal tasks and join our Bounty Program, +where completing top-priority issues can earn you cash rewards. +Upon reaching this level, we will be delighted to acknowledge your contributions with a special token of appreciation. diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 523dfa11b3563..c0ed67e5aeb62 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Volunteer Leaderboard -============== +===================== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- diff --git a/docs/overview/contributing/volunteer_workflow.rst b/docs/overview/contributing/volunteer_workflow.rst deleted file mode 100644 index 5c2092d4292fc..0000000000000 --- a/docs/overview/contributing/volunteer_workflow.rst +++ /dev/null @@ -1,24 +0,0 @@ -Volunteer Workflow -================== - -Embark on a rewarding journey with Unify by `signing up `_ as a volunteer. Let's innovate together! - -We've created a promotion workflow to help you advance through the different tiers of contribution, from Contributor to Core Contributor, Rising Contributor, and finally, Top Contributor. - -Our promotion structure is based on our GitHub badge system. Check out `Github Rewards `_ for more information about them! - -Contributor ------------ -Start as a Contributor by earning any of the Initial Badges. It's straightforward—complete one of the simple tasks listed and you're in! This first step on your journey opens the door to becoming an integral part of our community. - -Core Contributor ----------------- -Elevate to Core Contributor status by earning a Bronze Badge. As a Core Contributor, you're recognized not just for your skills but also for your growing commitment to our mission. You'll have the opportunity to engage more deeply with our projects and play an important role in shaping the future of our initiatives. This tier is a testament to your dedication and a stepping stone to even greater achievements within our community. - -Rising Contributor ------------------- -Ascend to the Rising Contributor level by acquiring a Silver Badge. This tier will allow you to be more deeply involved with our core group. You'll join our GitHub team, enabling you to directly commit changes, and modify issues. As a Rising Contributor, you're encouraged to tackle complex tasks, pushing your skills to new heights. - -Top Contributor ---------------- -Achieve a Gold Badge to reach the peak of our program as a Top Contributor. This tier is for those who demonstrate exceptional dedication and expertise. You'll gain the privilege of engaging with bounty-holding internal tasks and join our Bounty Program, where completing top-priority issues can earn you cash rewards. Upon reaching this level, we will be delighted to acknowledge your contributions to Ivy with a special token of appreciation. From 2f7bc0639065022abe37723e763b8d7c74ca4e94 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 15 Jan 2024 17:28:43 +0530 Subject: [PATCH 587/978] refactor: Added `raise from` clause to exceptions for improved tracebacks (#27918) --- ivy/__init__.py | 4 ++-- ivy/functional/backends/jax/data_type.py | 2 +- .../backends/jax/experimental/manipulation.py | 4 ++-- ivy/functional/backends/jax/manipulation.py | 6 +++--- ivy/functional/backends/jax/utility.py | 4 ++-- ivy/functional/backends/numpy/data_type.py | 2 +- ivy/functional/backends/numpy/utility.py | 2 +- .../backends/paddle/experimental/manipulation.py | 4 ++-- .../backends/paddle/experimental/norms.py | 4 ++-- ivy/functional/backends/tensorflow/data_type.py | 4 ++-- .../backends/tensorflow/manipulation.py | 4 ++-- ivy/functional/backends/tensorflow/utility.py | 4 ++-- ivy/functional/backends/torch/data_type.py | 2 +- .../backends/torch/experimental/manipulation.py | 4 ++-- ivy/functional/backends/torch/general.py | 8 ++++---- ivy/functional/frontends/jax/numpy/__init__.py | 6 ++++-- ivy/functional/frontends/mxnet/numpy/__init__.py | 6 ++++-- ivy/functional/frontends/numpy/__init__.py | 6 ++++-- .../data_type_routines/creating_data_types.py | 16 ++++++++-------- ivy/functional/frontends/onnx/__init__.py | 6 ++++-- ivy/functional/frontends/paddle/__init__.py | 6 ++++-- ivy/functional/frontends/torch/__init__.py | 6 ++++-- ivy/functional/frontends/torch/linalg.py | 4 ++-- ivy/functional/frontends/torch/tensor.py | 10 ++++++---- .../ivy/experimental/linear_algebra.py | 8 ++++---- ivy/stateful/sequential.py | 8 ++++---- 26 files changed, 77 insertions(+), 63 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 620bc5860fbd5..116c5212f8aed 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -443,8 +443,8 @@ def unknown_shape(rank=None, **kwargs): def with_rank(self, rank): try: return self.merge_with(self.unknown_shape(rank=rank)) - except ValueError: - raise ValueError(f"Shape {self} must have rank {rank}") + except ValueError as e: + raise ValueError(f"Shape {self} must have rank {rank}") from e def with_rank_at_least(self, rank): if self.rank is not None and self.rank < rank: diff --git a/ivy/functional/backends/jax/data_type.py b/ivy/functional/backends/jax/data_type.py index 5f2a13bb68113..1a84e9ad456e3 100644 --- a/ivy/functional/backends/jax/data_type.py +++ b/ivy/functional/backends/jax/data_type.py @@ -133,7 +133,7 @@ def broadcast_arrays(*arrays: JaxArray) -> List[JaxArray]: try: return jnp.broadcast_arrays(*arrays) except ValueError as e: - raise ivy.utils.exceptions.IvyBroadcastShapeError(e) + raise ivy.utils.exceptions.IvyBroadcastShapeError(e) from e def broadcast_to( diff --git a/ivy/functional/backends/jax/experimental/manipulation.py b/ivy/functional/backends/jax/experimental/manipulation.py index 0c224e74d090c..c519d7acfd16e 100644 --- a/ivy/functional/backends/jax/experimental/manipulation.py +++ b/ivy/functional/backends/jax/experimental/manipulation.py @@ -442,11 +442,11 @@ def take( if ivy.exists(axis): try: x_shape = x.shape[axis] - except Exception: + except Exception as e: raise ValueError( f"axis {axis} is out of bounds for array of dimension" f" {len(x.shape)}" - ) + ) from e else: x_shape = jnp.prod(x.shape) diff --git a/ivy/functional/backends/jax/manipulation.py b/ivy/functional/backends/jax/manipulation.py index 3d3b7c792a21c..30b6f2d9d7055 100644 --- a/ivy/functional/backends/jax/manipulation.py +++ b/ivy/functional/backends/jax/manipulation.py @@ -39,7 +39,7 @@ def concat( try: return jnp.concatenate(xs, axis) except ValueError as error: - raise ivy.utils.exceptions.IvyIndexError(error) + raise ivy.utils.exceptions.IvyIndexError(error) from error def expand_dims( @@ -54,7 +54,7 @@ def expand_dims( ret = jnp.expand_dims(x, axis) return ret except ValueError as error: - raise ivy.utils.exceptions.IvyIndexError(error) + raise ivy.utils.exceptions.IvyIndexError(error) from error def flip( @@ -143,7 +143,7 @@ def stack( try: return jnp.stack(arrays, axis=axis) except ValueError as error: - raise ivy.utils.exceptions.IvyIndexError(error) + raise ivy.utils.exceptions.IvyIndexError(error) from error # Extra # diff --git a/ivy/functional/backends/jax/utility.py b/ivy/functional/backends/jax/utility.py index 8fac7a2afbca6..6d2293ef45913 100644 --- a/ivy/functional/backends/jax/utility.py +++ b/ivy/functional/backends/jax/utility.py @@ -19,7 +19,7 @@ def all( try: return jnp.all(x, axis, keepdims=keepdims) except ValueError as error: - raise ivy.utils.exceptions.IvyIndexError(error) + raise ivy.utils.exceptions.IvyIndexError(error) from error def any( @@ -34,4 +34,4 @@ def any( try: return jnp.any(x, axis, keepdims=keepdims, out=out) except ValueError as error: - raise ivy.utils.exceptions.IvyIndexError(error) + raise ivy.utils.exceptions.IvyIndexError(error) from error diff --git a/ivy/functional/backends/numpy/data_type.py b/ivy/functional/backends/numpy/data_type.py index 0f59bfe7ac0e9..342eed678a793 100644 --- a/ivy/functional/backends/numpy/data_type.py +++ b/ivy/functional/backends/numpy/data_type.py @@ -130,7 +130,7 @@ def broadcast_arrays(*arrays: np.ndarray) -> List[np.ndarray]: try: return np.broadcast_arrays(*arrays) except ValueError as e: - raise ivy.utils.exceptions.IvyBroadcastShapeError(e) + raise ivy.utils.exceptions.IvyBroadcastShapeError(e) from e @with_unsupported_dtypes({"1.26.3 and below": ("complex",)}, backend_version) diff --git a/ivy/functional/backends/numpy/utility.py b/ivy/functional/backends/numpy/utility.py index de5597f952940..bba2ef86e03a7 100644 --- a/ivy/functional/backends/numpy/utility.py +++ b/ivy/functional/backends/numpy/utility.py @@ -17,7 +17,7 @@ def all( try: return np.asarray(np.all(x, axis=axis, keepdims=keepdims, out=out)) except np.AxisError as error: - raise ivy.utils.exceptions.IvyIndexError(error) + raise ivy.utils.exceptions.IvyIndexError(error) from error all.support_native_out = True diff --git a/ivy/functional/backends/paddle/experimental/manipulation.py b/ivy/functional/backends/paddle/experimental/manipulation.py index 61fdaae94fd93..1193133ae8366 100644 --- a/ivy/functional/backends/paddle/experimental/manipulation.py +++ b/ivy/functional/backends/paddle/experimental/manipulation.py @@ -774,7 +774,7 @@ def take( if ivy.exists(axis): try: x_shape = x.shape[axis] - except Exception: + except Exception as e: rank = len(x.shape) raise IndexError( "(OutOfRange) Attr(axis) is out of range, " @@ -784,7 +784,7 @@ def take( "(0 - input_dim.size()) == true, " "but received axis < input_dim.size() && axis >= " "(0 - input_dim.size()):0 != true:1.]" - ) + ) from e else: x_shape = paddle.prod(paddle.to_tensor(x.shape)) diff --git a/ivy/functional/backends/paddle/experimental/norms.py b/ivy/functional/backends/paddle/experimental/norms.py index c36bf0dda786f..092dda34030b6 100644 --- a/ivy/functional/backends/paddle/experimental/norms.py +++ b/ivy/functional/backends/paddle/experimental/norms.py @@ -55,11 +55,11 @@ def batch_norm( if data_format[-1] == "C" else data_formats[0:4][x.ndim - 2] ) - except IndexError: + except IndexError as e: raise IndexError( "data_format must be one of 'NC', 'NCL', 'NCHW', 'NCDHW', 'NLC', 'NHWC'," f" 'NDHWC' but receive {data_format}" - ) + ) from e with ivy.ArrayMode(False): if training: diff --git a/ivy/functional/backends/tensorflow/data_type.py b/ivy/functional/backends/tensorflow/data_type.py index 8b7209debc852..558120c4af568 100644 --- a/ivy/functional/backends/tensorflow/data_type.py +++ b/ivy/functional/backends/tensorflow/data_type.py @@ -117,7 +117,7 @@ def broadcast_arrays( try: desired_shape = tf.broadcast_dynamic_shape(arrays[0].shape, arrays[1].shape) except tf.errors.InvalidArgumentError as e: - raise ivy.utils.exceptions.IvyBroadcastShapeError(e) + raise ivy.utils.exceptions.IvyBroadcastShapeError(e) from e if len(arrays) > 2: for i in range(2, len(arrays)): try: @@ -125,7 +125,7 @@ def broadcast_arrays( desired_shape, arrays[i].shape ) except tf.errors.InvalidArgumentError as e: - raise ivy.utils.exceptions.IvyBroadcastShapeError(e) + raise ivy.utils.exceptions.IvyBroadcastShapeError(e) from e else: return [arrays[0]] result = [] diff --git a/ivy/functional/backends/tensorflow/manipulation.py b/ivy/functional/backends/tensorflow/manipulation.py index e2d6f8f13a2be..5e35641ab3c26 100644 --- a/ivy/functional/backends/tensorflow/manipulation.py +++ b/ivy/functional/backends/tensorflow/manipulation.py @@ -66,7 +66,7 @@ def expand_dims( ret = tf.reshape(x, shape=out_shape) return ret except (tf.errors.InvalidArgumentError, np.AxisError) as error: - raise ivy.utils.exceptions.IvyIndexError(error) + raise ivy.utils.exceptions.IvyIndexError(error) from error def flip( @@ -196,7 +196,7 @@ def stack( try: return tf.experimental.numpy.stack(arrays, axis) except ValueError as e: - raise ivy.utils.exceptions.IvyIndexError(e) + raise ivy.utils.exceptions.IvyIndexError(e) from e # Extra # diff --git a/ivy/functional/backends/tensorflow/utility.py b/ivy/functional/backends/tensorflow/utility.py index 997b6dca682dc..a09dedb163baa 100644 --- a/ivy/functional/backends/tensorflow/utility.py +++ b/ivy/functional/backends/tensorflow/utility.py @@ -24,7 +24,7 @@ def all( try: return tf.reduce_all(tf.cast(x, tf.bool), axis=axis, keepdims=keepdims) except tf.errors.InvalidArgumentError as e: - raise ivy.utils.exceptions.IvyIndexError(e) + raise ivy.utils.exceptions.IvyIndexError(e) from e def any( @@ -44,4 +44,4 @@ def any( try: return tf.reduce_any(tf.cast(x, tf.bool), axis=axis, keepdims=keepdims) except tf.errors.InvalidArgumentError as e: - raise ivy.utils.exceptions.IvyIndexError(e) + raise ivy.utils.exceptions.IvyIndexError(e) from e diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index b650590e6c290..db70c7e023852 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -91,7 +91,7 @@ def broadcast_arrays(*arrays: torch.Tensor) -> List[torch.Tensor]: try: return list(torch.broadcast_tensors(*arrays)) except RuntimeError as e: - raise ivy.utils.exceptions.IvyBroadcastShapeError(e) + raise ivy.utils.exceptions.IvyBroadcastShapeError(e) from e def broadcast_to( diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index 14265cebd1eea..7071e63922e41 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -550,13 +550,13 @@ def take( if ivy.exists(axis): try: x_shape = x.shape[axis] - except Exception: + except Exception as e: rank = len(x.shape) raise IndexError( "IndexError: Dimension out of range" f"(expected to be in range of[-{rank}, {rank-1}]" f", but got {axis})" - ) + ) from e else: x_shape = torch.prod(torch.tensor(x.shape)) diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 2fb22fc355458..af88439c9ee57 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -387,10 +387,10 @@ def scatter_flat( if torch_scatter is None: try: import torch_scatter as torch_scatter - except ImportError: + except ImportError as e: raise ivy.utils.exceptions.IvyException( "Unable to import torch_scatter, verify this is correctly installed." - ) + ) from e if reduction == "replace": output[indices.type(torch.int64)] = updates res = output @@ -478,10 +478,10 @@ def scatter_nd( if torch_scatter is None: try: import torch_scatter as torch_scatter - except ImportError: + except ImportError as e: raise ivy.utils.exceptions.IvyException( "Unable to import torch_scatter, verify this is correctly installed." - ) + ) from e if reduction == "replace": flat_output[flat_indices_for_flat] = flat_updates flat_scatter = flat_output diff --git a/ivy/functional/frontends/jax/numpy/__init__.py b/ivy/functional/frontends/jax/numpy/__init__.py index 4b8a28a0a6ed9..2512624217a74 100644 --- a/ivy/functional/frontends/jax/numpy/__init__.py +++ b/ivy/functional/frontends/jax/numpy/__init__.py @@ -407,8 +407,10 @@ def promote_types_jax( """ try: ret = jax_promotion_table[(ivy.as_ivy_dtype(type1), ivy.as_ivy_dtype(type2))] - except KeyError: - raise ivy.utils.exceptions.IvyException("these dtypes are not type promotable") + except KeyError as e: + raise ivy.utils.exceptions.IvyException( + "these dtypes are not type promotable" + ) from e return ret diff --git a/ivy/functional/frontends/mxnet/numpy/__init__.py b/ivy/functional/frontends/mxnet/numpy/__init__.py index 1f8fb0f1393f8..cc7390eadec51 100644 --- a/ivy/functional/frontends/mxnet/numpy/__init__.py +++ b/ivy/functional/frontends/mxnet/numpy/__init__.py @@ -121,8 +121,10 @@ def promote_types_mxnet( """ try: ret = mxnet_promotion_table[(ivy.as_ivy_dtype(type1), ivy.as_ivy_dtype(type2))] - except KeyError: - raise ivy.utils.exceptions.IvyException("these dtypes are not type promotable") + except KeyError as e: + raise ivy.utils.exceptions.IvyException( + "these dtypes are not type promotable" + ) from e return ret diff --git a/ivy/functional/frontends/numpy/__init__.py b/ivy/functional/frontends/numpy/__init__.py index 9cdf0c1278021..2abc591a2ddcf 100644 --- a/ivy/functional/frontends/numpy/__init__.py +++ b/ivy/functional/frontends/numpy/__init__.py @@ -425,8 +425,10 @@ def promote_numpy_dtypes( type1, type2 = ivy.as_ivy_dtype(type1), ivy.as_ivy_dtype(type2) try: return numpy_promotion_table[(type1, type2)] - except KeyError: - raise ivy.utils.exceptions.IvyException("these dtypes are not type promotable") + except KeyError as e: + raise ivy.utils.exceptions.IvyException( + "these dtypes are not type promotable" + ) from e @handle_exceptions diff --git a/ivy/functional/frontends/numpy/data_type_routines/creating_data_types.py b/ivy/functional/frontends/numpy/data_type_routines/creating_data_types.py index bab1425b65a5c..84bd99b6b71d6 100644 --- a/ivy/functional/frontends/numpy/data_type_routines/creating_data_types.py +++ b/ivy/functional/frontends/numpy/data_type_routines/creating_data_types.py @@ -19,11 +19,11 @@ def __repr__(self): def __ge__(self, other): try: other = dtype(other) - except TypeError: + except TypeError as e: raise ivy.utils.exceptions.IvyException( "Attempted to compare a dtype with something which" "couldn't be interpreted as a dtype" - ) + ) from e return self == np_frontend.promote_numpy_dtypes( self._ivy_dtype, other._ivy_dtype @@ -32,22 +32,22 @@ def __ge__(self, other): def __gt__(self, other): try: other = dtype(other) - except TypeError: + except TypeError as e: raise ivy.utils.exceptions.IvyException( "Attempted to compare a dtype with something which" "couldn't be interpreted as a dtype" - ) + ) from e return self >= other and self != other def __lt__(self, other): try: other = dtype(other) - except TypeError: + except TypeError as e: raise ivy.utils.exceptions.IvyException( "Attempted to compare a dtype with something which" "couldn't be interpreted as a dtype" - ) + ) from e return self != np_frontend.promote_numpy_dtypes( self._ivy_dtype, other._ivy_dtype @@ -56,11 +56,11 @@ def __lt__(self, other): def __le__(self, other): try: other = dtype(other) - except TypeError: + except TypeError as e: raise ivy.utils.exceptions.IvyException( "Attempted to compare a dtype with something which" "couldn't be interpreted as a dtype" - ) + ) from e return self < other or self == other diff --git a/ivy/functional/frontends/onnx/__init__.py b/ivy/functional/frontends/onnx/__init__.py index 46a5fb5daad61..1eafc7e63a158 100644 --- a/ivy/functional/frontends/onnx/__init__.py +++ b/ivy/functional/frontends/onnx/__init__.py @@ -208,8 +208,10 @@ def promote_types_onnx( """ try: ret = onnx_promotion_table[(ivy.as_ivy_dtype(type1), ivy.as_ivy_dtype(type2))] - except KeyError: - raise ivy.utils.exceptions.IvyException("these dtypes are not type promotable") + except KeyError as e: + raise ivy.utils.exceptions.IvyException( + "these dtypes are not type promotable" + ) from e return ret diff --git a/ivy/functional/frontends/paddle/__init__.py b/ivy/functional/frontends/paddle/__init__.py index 58ae61580f139..33518fbaf3905 100644 --- a/ivy/functional/frontends/paddle/__init__.py +++ b/ivy/functional/frontends/paddle/__init__.py @@ -173,8 +173,10 @@ def promote_types_paddle( """ try: ret = paddle_promotion_table[(ivy.as_ivy_dtype(type1), ivy.as_ivy_dtype(type2))] - except KeyError: - raise ivy.utils.exceptions.IvyException("these dtypes are not type promotable") + except KeyError as e: + raise ivy.utils.exceptions.IvyException( + "these dtypes are not type promotable" + ) from e return ret diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index d502cb7e90d50..af031aa7c9d26 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -210,8 +210,10 @@ def promote_types_torch( ret = torch_frontend.torch_promotion_table[ (ivy.as_ivy_dtype(type1), ivy.as_ivy_dtype(type2)) ] - except KeyError: - raise ivy.utils.exceptions.IvyException("these dtypes are not type promotable") + except KeyError as e: + raise ivy.utils.exceptions.IvyException( + "these dtypes are not type promotable" + ) from e return ret diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index d34c0c5c09e2b..67d662d72f97e 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -23,7 +23,7 @@ def cholesky_ex(input, *, upper=False, check_errors=False, out=None): return matrix, info except RuntimeError as e: if check_errors: - raise RuntimeError(e) + raise RuntimeError(e) from e else: matrix = input * math.nan info = ivy.ones(input.shape[:-2], dtype=ivy.int32) @@ -292,7 +292,7 @@ def solve_ex(A, B, *, left=True, check_errors=False, out=None): return result, info except RuntimeError as e: if check_errors: - raise RuntimeError(e) + raise RuntimeError(e) from e else: result = A * math.nan info = ivy.ones(A.shape[:-2], dtype=ivy.int32) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 53f47aea2adef..e462fb61c736c 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -814,11 +814,11 @@ def size(self, dim=None): return shape try: return shape[dim] - except IndexError: + except IndexError as e: raise IndexError( f"Dimension out of range (expected to be in range of [{len(shape)}," f" {len(shape) - 1}], but got {dim}" - ) + ) from e def matmul(self, other): return torch_frontend.matmul(self, other) @@ -2290,8 +2290,10 @@ def __new__(cls, iterable=()): continue try: new_iterable.append(int(item)) - except Exception: - raise TypeError(f"Expected int, but got {type(item)} at index {i}") + except Exception as e: + raise TypeError( + f"Expected int, but got {type(item)} at index {i}" + ) from e return super().__new__(cls, tuple(new_iterable)) def __init__(self, shape) -> None: diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index dd0685bead55b..46ff186bd66bd 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -1385,11 +1385,11 @@ def initialize_tucker( """ try: assert len(x.shape) >= 2 - except ValueError: + except ValueError as e: raise ValueError( "expected x to have at least 2 dimensions but it has only" f" {len(x.shape)} dimension(s)" - ) + ) from e # Initialisation if init == "svd": @@ -1667,11 +1667,11 @@ def tucker( if fixed_factors: try: (core, factors) = init - except ValueError: + except ValueError as e: raise ValueError( f"Got fixed_factor={fixed_factors} but no appropriate Tucker tensor was" ' passed for "init".' - ) + ) from e if len(fixed_factors) == len(factors): return ivy.TuckerTensor((core, factors)) diff --git a/ivy/stateful/sequential.py b/ivy/stateful/sequential.py index 08bf1a1f56465..684f698a0dee1 100644 --- a/ivy/stateful/sequential.py +++ b/ivy/stateful/sequential.py @@ -34,13 +34,13 @@ def __init__( for i, submod in enumerate(sub_modules): try: submod.v = v["submodules"][f"v{str(i)}"] - except KeyError: + except KeyError as e: if submod.v: raise ivy.utils.exceptions.IvyException( "variables v passed to Sequential class must have key " "chains in the form of " '"submodules/v{}", where {} is an idx' - ) + ) from e self._submodules = list(sub_modules) Module.__init__(self, device=device, v=v, dtype=dtype) @@ -64,13 +64,13 @@ def _forward(self, inputs): for i, submod in enumerate(self._submodules): try: x = submod(x, v=self.v.submodules[f"v{str(i)}"]) - except KeyError: + except KeyError as e: if submod.v: raise ivy.utils.exceptions.IvyException( "variables v passed to Sequential class must have key chains " "in the form of " '"submodules/v{}", where {} is an idx' - ) + ) from e x = submod(x) return x From a93a3230983359ef0bea2cfbe8eb7d55643ad784 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Mon, 15 Jan 2024 18:41:26 +0400 Subject: [PATCH 588/978] Remove award (#27923) --- .vaunt/config.yaml | 48 ++----------------- .../contributing/contributor_rewards.rst | 15 ------ 2 files changed, 4 insertions(+), 59 deletions(-) diff --git a/.vaunt/config.yaml b/.vaunt/config.yaml index 99840afc3069e..43131223f3945 100644 --- a/.vaunt/config.yaml +++ b/.vaunt/config.yaml @@ -9,17 +9,7 @@ achievements: - trigger: actor: author action: issue - condition: count(created_at >= "2023-12-26") >= 1 - - - achievement: - name: Pull Request Pioneer - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-00.png - description: Awarded for creating pull requests. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(created_at >= "2023-12-26") >= 1 + condition: count(created_at >= "2023-12-26" & labels in {'Useful Issue'}) >= 1 - achievement: name: Merging Master @@ -59,17 +49,7 @@ achievements: - trigger: actor: author action: issue - condition: count(created_at >= "2023-12-26") >= 5 - - - achievement: - name: Pull Request Pioneer Bronze - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-02.png - description: Awarded for creating 5 pull requests. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(created_at >= "2023-12-26") >= 5 + condition: count(created_at >= "2023-12-26" & labels in {'Useful Issue'}) >= 5 - achievement: name: Merging Master Bronze @@ -109,17 +89,7 @@ achievements: - trigger: actor: author action: issue - condition: count(created_at >= "2023-12-26") >= 15 - - - achievement: - name: Pull Request Pioneer Silver - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-03.png - description: Awarded for creating 15 pull requests. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(created_at >= "2023-12-26") >= 15 + condition: count(created_at >= "2023-12-26" & labels in {'Useful Issue'}) >= 15 - achievement: name: Merging Master Silver @@ -159,17 +129,7 @@ achievements: - trigger: actor: author action: issue - condition: count(created_at >= "2023-12-26") >= 30 - - - achievement: - name: Pull Request Pioneer Gold - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-04.png - description: Awarded for creating 30 pull requests. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(created_at >= "2023-12-26") >= 30 + condition: count(created_at >= "2023-12-26" & labels in {'Useful Issue'}) >= 30 - achievement: name: Merging Master Gold diff --git a/docs/overview/contributing/contributor_rewards.rst b/docs/overview/contributing/contributor_rewards.rst index bbf3d6d505051..ec5847fb25ec2 100644 --- a/docs/overview/contributing/contributor_rewards.rst +++ b/docs/overview/contributing/contributor_rewards.rst @@ -9,8 +9,6 @@ Badges **Debugging Dynamos** - These badges are awarded to contributors who demonstrate exceptional skill in identifying and reporting issues. It recognizes the crucial role of pinpointing problems which is fundamental in maintaining the integrity and performance of our codebase. -**Pull Request Pioneer** - These awards are granted to those who actively contribute to the development of our projects by initiating pull requests. This badge acknowledges the importance of collaborative development and the initiative taken in proposing valuable code changes and improvements. - **Merging Master** - These badges are formal recognitions for contributors whose pull requests consistently meet our high standards of quality and are successfully merged into the main codebase. **Merging Wizard** - These exclusive badges are awarded to contributors who successfully get *priority* pull requests merged. This recognition is for handling complex, high-priority tasks that have a substantial impact on the project's progress and success. @@ -44,19 +42,6 @@ Badge Tiers - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-04.png :width: 110 :alt: Alternative text - * - Pull Request Pioneer - - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-00.png - :width: 110 - :alt: Alternative text - - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-02.png - :width: 110 - :alt: Alternative text - - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-03.png - :width: 110 - :alt: Alternative text - - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_03-04.png - :width: 110 - :alt: Alternative text * - Merging Master - .. image:: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-00.png :width: 110 From c05cd03a1a819bd4c851155ca02fda3e9e03660f Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Mon, 15 Jan 2024 15:10:25 +0000 Subject: [PATCH 589/978] fix: expand when shape is longer than the input's shape (#27913) --- .../backends/numpy/experimental/manipulation.py | 3 +++ .../backends/tensorflow/experimental/manipulation.py | 8 +++++--- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/numpy/experimental/manipulation.py b/ivy/functional/backends/numpy/experimental/manipulation.py index 9a86855d16ec6..e2ad547b7b851 100644 --- a/ivy/functional/backends/numpy/experimental/manipulation.py +++ b/ivy/functional/backends/numpy/experimental/manipulation.py @@ -402,6 +402,9 @@ def expand( out: Optional[np.ndarray] = None, ) -> np.ndarray: shape = list(shape) + n_extra_dims = len(shape) - x.ndim + if n_extra_dims > 0: + x = np.expand_dims(x, tuple(range(n_extra_dims))) for i, dim in enumerate(shape): if dim < 0: shape[i] = x.shape[i] diff --git a/ivy/functional/backends/tensorflow/experimental/manipulation.py b/ivy/functional/backends/tensorflow/experimental/manipulation.py index 2e7f511bc9928..f2f702e230fc1 100644 --- a/ivy/functional/backends/tensorflow/experimental/manipulation.py +++ b/ivy/functional/backends/tensorflow/experimental/manipulation.py @@ -347,11 +347,13 @@ def expand( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: shape = list(shape) + n_extra_dims = len(shape) - len(x.shape) + if n_extra_dims > 0: + new_shape = (1,) * n_extra_dims + tuple(x.shape) + x = tf.reshape(x, new_shape) for i, dim in enumerate(shape): if dim < 0: - shape[i] = x.shape.num_elements() / tf.reduce_prod( - [s for s in shape if s > 0] - ) + shape[i] = x.shape[i] return tf.broadcast_to(x, shape) From e2f62fd0bd7bb1bbac593246a17f6863395368b0 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 15 Jan 2024 19:56:01 +0400 Subject: [PATCH 590/978] Update contributor program name and fix file paths --- docs/overview/contributing.rst | 6 +++--- docs/overview/contributing/volunteer_program.rst | 6 +++--- scripts/backend_generation/tree_generation.py | 5 ++++- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/docs/overview/contributing.rst b/docs/overview/contributing.rst index 236a682b7f6b2..f5998b0a03b5a 100644 --- a/docs/overview/contributing.rst +++ b/docs/overview/contributing.rst @@ -27,10 +27,10 @@ The contributor guide is split into the sections below, it's best to go from sta | (d) `Contributor Rewards `_ | Check out our contributor badges and achievements! 🏅 | -| (e) `Volunteer Program `_ -| How to climb up the ranks in our Volunteer program 🧗 +| (e) `Contributor Program `_ +| How to climb up the ranks in our Contributor program 🧗 | -| (f) `Volunteer Leaderboard `_ +| (f) `Contributor Leaderboard `_ | See where you stand on our leaderboard 🏆 | | (g) `Building the Docs `_ diff --git a/docs/overview/contributing/volunteer_program.rst b/docs/overview/contributing/volunteer_program.rst index 65be69053c3d5..23a901a45146c 100644 --- a/docs/overview/contributing/volunteer_program.rst +++ b/docs/overview/contributing/volunteer_program.rst @@ -1,9 +1,9 @@ -Volunteer Program +Contributor Program ================= -The goal of the volunteer program is to facilitate contributors in the community that would like to work more closely +The goal of the Contributor program is to facilitate contributors in the community that would like to work more closely with our team. -Embark on a rewarding journey with Unify by `signing up `_ as a volunteer. +Embark on a rewarding journey with Unify by `signing up `_ as a Contributor. Let's innovate together! We've created a promotion workflow to help you advance through the different tiers of contribution, diff --git a/scripts/backend_generation/tree_generation.py b/scripts/backend_generation/tree_generation.py index 871ef7abbc343..51834c55bb8c6 100644 --- a/scripts/backend_generation/tree_generation.py +++ b/scripts/backend_generation/tree_generation.py @@ -208,6 +208,9 @@ def _copy_tree(backend_reference_path: str, backend_generation_path: str): def _create_type_mapping(config: dict, reference_backend_init_path: str): + # print pwd for debugging + print(os.getcwd()) + print with open(reference_backend_init_path, "r") as file: file_src = file.read() @@ -238,7 +241,7 @@ def generate(config_file): global _target_backend _target_backend = _config["name"] - backends_root = "../../ivy/functional/backends/" + backends_root = "ivy/functional/backends/" backend_reference_path = backends_root + _backend_reference backend_generation_path = backends_root + _target_backend From a57f242d85b4c7ffa4fc9b933a8583051ef3f577 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 15 Jan 2024 15:59:17 +0000 Subject: [PATCH 591/978] Update volunteer-leaderboard.rst --- docs/overview/contributing/volunteer_ranks.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index c0ed67e5aeb62..0ba4129261298 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ -Volunteer Leaderboard -===================== +Contributor Leaderboard +============== -This page lists all of our amazing volunteers who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing Contributor who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- From 97536065df47a5686c5927e1cc32c75b95712bd4 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 15 Jan 2024 16:00:39 +0000 Subject: [PATCH 592/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/contributing/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 0ba4129261298..3416f245fd14f 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Contributor Leaderboard ============== -This page lists all of our amazing Contributor who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing Contributor who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- From c405d5209d1f2b8cbd4023d6179d7262e19b6ee4 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 15 Jan 2024 16:18:26 +0000 Subject: [PATCH 593/978] feat: handle 2d case for torch frontend cdist similar to native torch and ensure test is run for 2d and passing --- .../frontends/torch/miscellaneous_ops.py | 27 ++++++++++--------- .../test_torch/test_miscellaneous_ops.py | 2 +- 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index b38ee9bde458c..413a9ec0a6927 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -95,19 +95,20 @@ def cartesian_prod(*tensors): @with_unsupported_dtypes({"2.1.2 and below": "float16"}, "torch") @to_ivy_arrays_and_back def cdist(x1, x2, p=2.0, compute_mode="use_mm_for_euclid_dist_if_necessary"): - if len(x1.shape) != 3 or len(x2.shape) != 3: - raise ivy.exceptions.IvyError( - "Both ivy arrays need to have 3 dimensions (BxRxM)" - ) - - if ( - compute_mode != "use_mm_for_euclid_dist_if_necessary" - and compute_mode != "use_mm_for_euclid_dist" - and compute_mode != "donot_use_mm_for_euclid_dist" - ): - raise ivy.exceptions.IvyError( - f"{compute_mode} is not a valid value for compute_mode" - ) + if len(x1.shape) == 2 and len(x2.shape) == 2: + x1_first_dim, x2_first_dim = x1.shape[0], x2.shape[0] + if ( + compute_mode == "use_mm_for_euclid_dist_if_necessary" + and (x1_first_dim > 25 or x2_first_dim > 25) + or compute_mode == "use_mm_for_euclid_dist" + ): + return ivy.vector_norm(x1[:, None, :] - x2[None, :, :], axis=-1, ord=p) + else: + distances = ivy.zeros((x1_first_dim, x2_first_dim), dtype=x1.dtype) + for i in range(x1_first_dim): + for j in range(x2_first_dim): + distances[i, j] = ivy.vector_norm(x1[i, :] - x2[j, :], ord=p) + return distances if p == 2: B, P, M = x1.shape _, R, _ = x2.shape diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 03d370b1f20fb..83698b88a0db9 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -513,7 +513,7 @@ def test_torch_cartesian_prod( @handle_frontend_test( fn_tree="torch.cdist", dtypes_and_x=helpers.dtype_and_values( - shape=st.shared(helpers.get_shape(min_num_dims=3, max_num_dims=3), key="shape"), + shape=st.shared(helpers.get_shape(min_num_dims=2, max_num_dims=3), key="shape"), shared_dtype=True, num_arrays=2, allow_inf=False, From f057407029669edeaf1fc49b90883978e4f0c3aa Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 15 Jan 2024 19:15:22 +0000 Subject: [PATCH 594/978] Update volunteer-leaderboard.rst --- docs/overview/contributing/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 3416f245fd14f..8a448ebdf056a 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,5 +1,5 @@ Contributor Leaderboard -============== +======================= This page lists all of our amazing Contributor who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. From fd2586750e2a84f6d9c39a10e853766b9c1ccca5 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 16 Jan 2024 12:50:39 +0530 Subject: [PATCH 595/978] feat: Added more checks to `ruff` (#27919) --- .pre-commit-config.yaml | 2 +- pyproject.toml | 14 ++++++++++++-- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index ebd63add93c6f..34d42d6af8eea 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: - id: check-toml - id: end-of-file-fixer - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.1.11 + rev: v0.1.13 hooks: # Run the linter. - id: ruff diff --git a/pyproject.toml b/pyproject.toml index 0e29ca0ffbb38..30afa89dfc9ea 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,8 +34,18 @@ select = [ "E", "W", # pydocstyle "D", - # isort (Missing required import) - "I002" + "I002", # Missing required import. + "UP008", # Checks for super calls that pass redundant arguments. + "PGH002", # deprecated-log-warn. + "PLR0203", # Static method defined without decorator. + "PLR0202", # Class method defined without decorator. + "PLW0245", # super call is missing parentheses. + "PLR1722", # Use sys.exit() instead of exit() and quit(). + "TRY004", # Prefer TypeError exception for invalid type. + "PT014", # pytest-duplicate-parametrize-test-cases. + "PT006", # Checks for the type of parameter names passed to pytest.mark.parametrize. + "PT007", # Checks for the type of parameter values passed to pytest.mark.parametrize. + "PT018", # Checks for assertions that combine multiple independent conditions. ] From 7e26cf27881a70e340b3f18f6520503ad52636e1 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Tue, 16 Jan 2024 10:04:22 +0000 Subject: [PATCH 596/978] feat: add ivy.lstm to functional api (#27922) --- ivy/functional/backends/torch/layers.py | 25 ++ .../torch/nn/functional/layer_functions.py | 228 +------------- ivy/functional/ivy/layers.py | 282 ++++++++++++++++++ .../test_functional/test_layer_functions.py | 5 +- .../test_functional/test_nn/test_layers.py | 163 +++++++++- 5 files changed, 472 insertions(+), 231 deletions(-) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index 2a7640b33db3f..690d0114afd51 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -868,3 +868,28 @@ def scaled_dot_product_attention_v_2p0p0_and_above( if isinstance(mask, torch.Tensor): mask = torch.where(mask == 0, -torch.inf, 0) return torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=mask) + + +def lstm( + input: torch.Tensor, + initial_states: Tuple[torch.Tensor], + all_weights: Tuple[torch.Tensor], + has_biases: bool, + num_layers: int, + dropout: float, + train: bool, + bidirectional: bool, + batch_first: bool = False, + batch_sizes: Sequence = None, +): + return torch._VF.lstm( + input, + initial_states, + all_weights, + has_biases, + num_layers, + dropout, + train, + bidirectional, + batch_first, + ) diff --git a/ivy/functional/frontends/torch/nn/functional/layer_functions.py b/ivy/functional/frontends/torch/nn/functional/layer_functions.py index 75f41ea474f12..d3be3e8b3dae1 100644 --- a/ivy/functional/frontends/torch/nn/functional/layer_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/layer_functions.py @@ -1,8 +1,6 @@ import ivy from ivy.func_wrapper import with_supported_device_and_dtypes, with_supported_dtypes from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back -from ivy.functional.ivy.experimental.manipulation import _slice_along_axis -from ivy.utils.exceptions import IvyNotImplementedException # --- Helpers --- # @@ -17,132 +15,6 @@ def _extract_states(states, batch_sizes): return h -def _generic_lstm( - input, - initial_states, - all_weights, - has_biases, - num_layers, - dropout, - train, - bidirectional, - batch_first=False, - batch_sizes=None, -): - weights_per_layer = 4 if has_biases else 2 - - assert len(all_weights) == num_layers * weights_per_layer * (1 + bidirectional) - layer_weights = [ - all_weights[i : i + weights_per_layer] - for i in range(0, len(all_weights), weights_per_layer) - ] - - if batch_sizes is not None: - input, batch_sizes = _pad_packed_sequence(input, batch_sizes) - - if batch_first: - input = ivy.swapaxes(input, 0, 1) - - if dropout and train: - raise IvyNotImplementedException() - - unidirectional = not bidirectional - - h0, c0 = initial_states - h_outs, c_outs = [], [] - - output = input - for i in range(num_layers): - if unidirectional: - if weights_per_layer == 4: - weight_ih, weight_hh, (bias_i, bias_h) = _transform_weights( - layer_weights, i - ) - else: - weight_ih, weight_hh = _transform_weights_no_bias(layer_weights, i) - bias_i = bias_h = None - - state_indices = i, i + 1 - else: - if weights_per_layer == 4: - weight_ih_f, weight_hh_f, (bias_i_f, bias_h_f) = _transform_weights( - layer_weights, 2 * i - ) - weight_ih_b, weight_hh_b, (bias_i_b, bias_h_b) = _transform_weights( - layer_weights, 2 * i + 1 - ) - else: - weight_ih_f, weight_hh_f = _transform_weights_no_bias( - layer_weights, 2 * i - ) - weight_ih_b, weight_hh_b = _transform_weights_no_bias( - layer_weights, 2 * i + 1 - ) - bias_i_f = bias_h_f = bias_i_b = bias_h_b = None - - weight_ih = weight_ih_f, weight_ih_b - weight_hh = weight_hh_f, weight_hh_b - bias_i = bias_i_f, bias_i_b - bias_h = bias_h_f, bias_h_b - - state_indices = 2 * i, 2 * i + 2 - - output, (h_out, c_out) = _lstm_layer( - output, - ( - _retrieve_state(h0, *state_indices, num_layers), - _retrieve_state(c0, *state_indices, num_layers), - ), - (weight_ih, weight_hh), - (bias_i, bias_h), - bidirectional, - batch_first=False, - batch_sizes=batch_sizes, - ) - h_outs.append(h_out) - c_outs.append(c_out) - - if batch_first: - output = ivy.swapaxes(output, 0, 1) - - h_outs = h_out if num_layers == 1 else ivy.concat(h_outs, axis=0) - c_outs = c_out if num_layers == 1 else ivy.concat(c_outs, axis=0) - - if batch_sizes is not None: - output = _pack_padded_sequence(output, batch_sizes)[0] - - return output, h_outs, c_outs - - -def _lstm_cell( - x, - init_h, - init_c, - kernel, - recurrent_kernel, - bias, - recurrent_bias, - batch_first, - batch_sizes=None, -): - init_h = ivy.squeeze(init_h, axis=0) - init_c = ivy.squeeze(init_c, axis=0) - out, states = ivy.lstm_update( - x, - init_h, - init_c, - kernel, - recurrent_kernel, - bias=bias, - recurrent_bias=recurrent_bias, - time_major=not batch_first, - ) - h, c = states - h = ivy.expand_dims(h) if len(h.shape) == 2 else h - c = ivy.expand_dims(c) if len(c.shape) == 2 else c - return out, (h, c) - - def _lstm_full( input, hx, @@ -154,7 +26,7 @@ def _lstm_full( bidirectional, batch_first, ): - return _generic_lstm( + return ivy.lstm( input, hx, params, @@ -167,49 +39,6 @@ def _lstm_full( ) -def _lstm_layer( - x, hidden, weights, biases, bidirectional, batch_first, batch_sizes=None -): - if not bidirectional: - result, (h, c) = _lstm_cell( - x, - *hidden, - *weights, - *biases, - batch_first=batch_first, - batch_sizes=batch_sizes, - ) - else: - result_fw, (h_fw, c_fw) = _lstm_cell( - x, - hidden[0][:1], - hidden[1][:1], - weights[0][0], - weights[1][0], - biases[0][0], - biases[1][0], - batch_first=batch_first, - batch_sizes=batch_sizes, - ) - x_reversed = ivy.flip(x, axis=0) - result_bw, (h_bw, c_bw) = _lstm_cell( - x_reversed, - hidden[0][1:], - hidden[1][1:], - weights[0][1], - weights[1][1], - biases[0][1], - biases[1][1], - batch_first=batch_first, - batch_sizes=batch_sizes, - ) - result_bw = ivy.flip(result_bw, axis=0) - result = ivy.concat([result_fw, result_bw], axis=len(result_fw.shape) - 1) - c = ivy.concat([c_fw, c_bw], axis=0) - h = ivy.concat([h_fw, h_bw], axis=0) - return result, (h, c) - - def _lstm_packed( data, batch_sizes, @@ -221,7 +50,7 @@ def _lstm_packed( train, bidirectional, ): - return _generic_lstm( + return ivy.lstm( data, hx, params, @@ -234,59 +63,6 @@ def _lstm_packed( ) -def _pack_padded_sequence(input, lengths): - input = ivy.swapaxes(input, 0, 1) - data = [] - batch_sizes = [] - for i in range(int(max(lengths))): - valid_data_mask = ivy.array(lengths) > i - data.append(input[valid_data_mask, i]) - batch_sizes.append(int(sum(valid_data_mask))) - data = ivy.concat(data) - batch_sizes = ivy.array(batch_sizes, dtype=ivy.int64) - return data, batch_sizes - - -def _pad_packed_sequence(data, batch_sizes): - padded_data = ivy.full( - (len(batch_sizes), int(max(batch_sizes)), *data.shape[1:]), - 0, - dtype=data.dtype, - device=data.device, - ) - data_offset = 0 - for i, batch_size in enumerate(batch_sizes): - batch_size = int(batch_size) - padded_data[i, :batch_size] = data[data_offset : data_offset + batch_size] - data_offset += batch_size - lengths = ivy.sum( - ivy.arange(1, int(max(batch_sizes)) + 1)[:, ivy.newaxis] <= batch_sizes, - axis=1, - dtype=ivy.int64, - ) - return padded_data, lengths - - -def _retrieve_state(x, start, end, num_layers): - return x if num_layers == 1 else _slice_along_axis(x, start=start, stop=end, axis=0) - - -def _transform_weights(layer_weights, layer_index): - weights = layer_weights[layer_index] - weight_ih, weight_hh, bias_ih, bias_hh = weights - return ( - ivy.swapaxes(weight_ih, 0, 1), - ivy.swapaxes(weight_hh, 0, 1), - (bias_ih, bias_hh), - ) - - -def _transform_weights_no_bias(layer_weights, layer_index): - weights = layer_weights[layer_index] - weight_ih, weight_hh = weights - return ivy.swapaxes(weight_ih, 0, 1), ivy.swapaxes(weight_hh, 0, 1) - - # --- Main --- # # ------------ # diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 741aba99eaf5d..461adc33ed642 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -2379,6 +2379,155 @@ def lstm_update( return ret, (ht, ct) +@handle_exceptions +@handle_nestable +@handle_array_like_without_promotion +@inputs_to_ivy_arrays +@handle_array_function +def lstm( + input: ivy.Array, + initial_states: Tuple[ivy.Array], + all_weights: Tuple[ivy.Array], + has_biases: bool, + num_layers: int, + dropout: float, + train: bool, + bidirectional: bool, + batch_first: bool = False, + batch_sizes: Sequence = None, +): + """Applies a multi-layer long-short term memory to an input sequence. + + Parameters + ---------- + input + input array of shape (seq_len, batch, input_size) when `batch_first` is False + or (batch, seq_len, input_size) when `batch_first` is True + initial_states + tuple of two arrays (h_0, c_0) where h_0 is the initial hidden state of shape + (num_layers * num_directions, batch, hidden_size) and c_0 is the initial cell + state of shape (num_layers * num_directions, batch, hidden_size) + + (num_directions being 2 when `bidirectional`, otherwise 1) + all_weights + tuple of arrays representing the learnable weights of the lstm, with each + layer having either four arrays (w_ih, w_hh, b_ih, b_hh), when has_biases=True, + or two (w_ih, w_hh), when has_biases=False + + w_ih: weight of shape (4 * hidden_size, input_size) + w_hh: weight of shape (4 * hidden_size, hidden_size) + b_ih: bias of shape (4 * hidden_size,) + b_hh: bias of shape (4 * hidden_size,) + has_biases + indicates whether the `all_weights` argument includes biases + num_layers + number of layers for the lstm to use + dropout + dropout rate + train + whether to run the lstm in train mode or eval mode + bidirectional + whether the lstm is bidirectional or unidirectional + batch_first + defines the data format of the input and output arrays + batch_sizes + specifies the batch size at each timestep, when the input is a packed sequence + + Returns + ------- + output + output array of shape (seq_len, batch, num_directions * hidden_size) or + (batch, seq_len, num_directions * hidden_size), depending on `batch_first` + h_outs + final hidden state of shape (num_layers * num_directions, batch, hidden_size) + c_outs + final cell state of shape (num_layers * num_directions, batch, hidden_size) + """ + weights_per_layer = 4 if has_biases else 2 + + assert len(all_weights) == num_layers * weights_per_layer * (1 + bidirectional) + layer_weights = [ + all_weights[i : i + weights_per_layer] + for i in range(0, len(all_weights), weights_per_layer) + ] + + if batch_sizes is not None: + input, batch_sizes = _pad_packed_sequence(input, batch_sizes) + + if batch_first: + input = ivy.swapaxes(input, 0, 1) + + if dropout and train: + raise ivy.utils.exceptions.IvyNotImplementedException() + + unidirectional = not bidirectional + + h0, c0 = initial_states + h_outs, c_outs = [], [] + + output = input + for i in range(num_layers): + if unidirectional: + if weights_per_layer == 4: + weight_ih, weight_hh, (bias_i, bias_h) = _transform_weights( + layer_weights, i + ) + else: + weight_ih, weight_hh = _transform_weights_no_bias(layer_weights, i) + bias_i = bias_h = None + + state_indices = i, i + 1 + else: + if weights_per_layer == 4: + weight_ih_f, weight_hh_f, (bias_i_f, bias_h_f) = _transform_weights( + layer_weights, 2 * i + ) + weight_ih_b, weight_hh_b, (bias_i_b, bias_h_b) = _transform_weights( + layer_weights, 2 * i + 1 + ) + else: + weight_ih_f, weight_hh_f = _transform_weights_no_bias( + layer_weights, 2 * i + ) + weight_ih_b, weight_hh_b = _transform_weights_no_bias( + layer_weights, 2 * i + 1 + ) + bias_i_f = bias_h_f = bias_i_b = bias_h_b = None + + weight_ih = weight_ih_f, weight_ih_b + weight_hh = weight_hh_f, weight_hh_b + bias_i = bias_i_f, bias_i_b + bias_h = bias_h_f, bias_h_b + + state_indices = 2 * i, 2 * i + 2 + + output, (h_out, c_out) = _lstm_layer( + output, + ( + _retrieve_state(h0, *state_indices, num_layers), + _retrieve_state(c0, *state_indices, num_layers), + ), + (weight_ih, weight_hh), + (bias_i, bias_h), + bidirectional, + batch_first=False, + batch_sizes=batch_sizes, + ) + h_outs.append(h_out) + c_outs.append(c_out) + + if batch_first: + output = ivy.swapaxes(output, 0, 1) + + h_outs = h_out if num_layers == 1 else ivy.concat(h_outs, axis=0) + c_outs = c_out if num_layers == 1 else ivy.concat(c_outs, axis=0) + + if batch_sizes is not None: + output = _pack_padded_sequence(output, batch_sizes)[0] + + return output, h_outs, c_outs + + # Helpers # @@ -2623,6 +2772,139 @@ def _convert_boxes_to_roi_format(boxes): return rois +def _lstm_cell( + x, + init_h, + init_c, + kernel, + recurrent_kernel, + bias, + recurrent_bias, + batch_first, + batch_sizes=None, +): + init_h = ivy.squeeze(init_h, axis=0) + init_c = ivy.squeeze(init_c, axis=0) + out, states = lstm_update( + x, + init_h, + init_c, + kernel, + recurrent_kernel, + bias=bias, + recurrent_bias=recurrent_bias, + time_major=not batch_first, + ) + h, c = states + h = ivy.expand_dims(h) if len(h.shape) == 2 else h + c = ivy.expand_dims(c) if len(c.shape) == 2 else c + return out, (h, c) + + +def _lstm_layer( + x, hidden, weights, biases, bidirectional, batch_first, batch_sizes=None +): + if not bidirectional: + result, (h, c) = _lstm_cell( + x, + *hidden, + *weights, + *biases, + batch_first=batch_first, + batch_sizes=batch_sizes, + ) + else: + result_fw, (h_fw, c_fw) = _lstm_cell( + x, + hidden[0][:1], + hidden[1][:1], + weights[0][0], + weights[1][0], + biases[0][0], + biases[1][0], + batch_first=batch_first, + batch_sizes=batch_sizes, + ) + x_reversed = ivy.flip(x, axis=0) + result_bw, (h_bw, c_bw) = _lstm_cell( + x_reversed, + hidden[0][1:], + hidden[1][1:], + weights[0][1], + weights[1][1], + biases[0][1], + biases[1][1], + batch_first=batch_first, + batch_sizes=batch_sizes, + ) + result_bw = ivy.flip(result_bw, axis=0) + result = ivy.concat([result_fw, result_bw], axis=len(result_fw.shape) - 1) + c = ivy.concat([c_fw, c_bw], axis=0) + h = ivy.concat([h_fw, h_bw], axis=0) + return result, (h, c) + + +def _pack_padded_sequence(input, lengths): + input = ivy.swapaxes(input, 0, 1) + data = [] + batch_sizes = [] + for i in range(int(max(lengths))): + valid_data_mask = ivy.array(lengths) > i + data.append(input[valid_data_mask, i]) + batch_sizes.append(int(sum(valid_data_mask))) + data = ivy.concat(data) + batch_sizes = ivy.array(batch_sizes, dtype=ivy.int64) + return data, batch_sizes + + +def _pad_packed_sequence(data, batch_sizes): + padded_data = ivy.full( + (len(batch_sizes), int(max(batch_sizes)), *data.shape[1:]), + 0, + dtype=data.dtype, + device=data.device, + ) + data_offset = 0 + for i, batch_size in enumerate(batch_sizes): + batch_size = int(batch_size) + padded_data[i, :batch_size] = data[data_offset : data_offset + batch_size] + data_offset += batch_size + lengths = ivy.sum( + ivy.arange(1, int(max(batch_sizes)) + 1)[:, ivy.newaxis] <= batch_sizes, + axis=1, + dtype=ivy.int64, + ) + return padded_data, lengths + + +def _retrieve_state(x, start, end, num_layers): + return x if num_layers == 1 else _slice_along_axis(x, start=start, stop=end, axis=0) + + +def _transform_weights(layer_weights, layer_index): + weights = layer_weights[layer_index] + weight_ih, weight_hh, bias_ih, bias_hh = weights + return ( + ivy.swapaxes(weight_ih, 0, 1), + ivy.swapaxes(weight_hh, 0, 1), + (bias_ih, bias_hh), + ) + + +def _transform_weights_no_bias(layer_weights, layer_index): + weights = layer_weights[layer_index] + weight_ih, weight_hh = weights + return ivy.swapaxes(weight_ih, 0, 1), ivy.swapaxes(weight_hh, 0, 1) + + +def _slice_along_axis(x, start=0, stop=None, stride=1, axis=0): + if axis >= 0: + slices = [slice(None)] * axis + [slice(start, stop, stride)] + else: + slices = [Ellipsis, slice(start, stop, stride)] + [slice(None)] * (-1 - axis) + return x[tuple(slices)] + + @handle_exceptions @handle_nestable @handle_array_like_without_promotion diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py index e44d5deec0b69..453026fad8ea9 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_layer_functions.py @@ -4,10 +4,7 @@ # local import ivy -from ivy.functional.ivy.layers import _get_embed_dim -from ivy.functional.frontends.torch.nn.functional.layer_functions import ( - _pack_padded_sequence, -) +from ivy.functional.ivy.layers import _get_embed_dim, _pack_padded_sequence from ivy_tests.test_ivy import helpers from ivy_tests.test_ivy.helpers import handle_frontend_test from ivy_tests.test_ivy.test_functional.test_nn.test_layers import _mha_helper diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index 73fe88ff2e848..f1bf4f99e9d84 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -9,7 +9,7 @@ # local import ivy_tests.test_ivy.helpers as helpers from ivy_tests.test_ivy.helpers import handle_test -from ivy.functional.ivy.layers import _deconv_length +from ivy.functional.ivy.layers import _deconv_length, _pack_padded_sequence # --- Helpers --- # @@ -83,6 +83,144 @@ def _general_transpose_helper(draw): return dims, x_f_d_df +@st.composite +def _lstm_helper(draw): + dtype = draw(helpers.get_dtypes("float", full=False)) + + has_biases = draw(st.booleans()) + bidirectional = draw(st.booleans()) + dropout = draw(st.floats(min_value=0, max_value=0.99)) + train = draw(st.booleans()) and not dropout + packed = draw(st.booleans()) + + batch_first = draw(st.booleans()) and not packed + num_batches = draw(st.integers(min_value=1, max_value=5)) + num_layers = draw(st.integers(min_value=1, max_value=3)) + num_directions = 2 if bidirectional else 1 + seq_size = draw(st.integers(min_value=1, max_value=5)) + in_size = draw(st.integers(min_value=1, max_value=3)) + hidden_size = draw(st.integers(min_value=1, max_value=3)) + + input = draw( + helpers.array_values( + dtype=dtype[0], + shape=( + (num_batches, seq_size, in_size) + if batch_first + else (seq_size, num_batches, in_size) + ), + min_value=0, + max_value=1, + ) + ) + + init_h = draw( + helpers.array_values( + dtype=dtype[0], + shape=(num_directions * num_layers, num_batches, hidden_size), + min_value=0, + max_value=1, + ) + ) + init_c = draw( + helpers.array_values( + dtype=dtype[0], + shape=(num_directions * num_layers, num_batches, hidden_size), + min_value=0, + max_value=1, + ) + ) + + all_weights = [] + for k in range(num_layers): + for _ in range(num_directions): + weight_ih = draw( + helpers.array_values( + dtype=dtype[0], + shape=( + (4 * hidden_size, in_size) + if k == 0 + else (4 * hidden_size, num_directions * hidden_size) + ), + min_value=0, + max_value=1, + ) + ) + weight_hh = draw( + helpers.array_values( + dtype=dtype[0], + shape=(4 * hidden_size, hidden_size), + min_value=0, + max_value=1, + ) + ) + all_weights += [weight_ih, weight_hh] + if has_biases: + bias_ih = draw( + helpers.array_values( + dtype=dtype[0], + shape=(4 * hidden_size,), + min_value=0, + max_value=1, + ) + ) + bias_hh = draw( + helpers.array_values( + dtype=dtype[0], + shape=(4 * hidden_size,), + min_value=0, + max_value=1, + ) + ) + all_weights += [bias_ih, bias_hh] + + if packed: + batch_sizes = [seq_size] + batch_sizes += draw( + st.lists( + st.integers(min_value=1, max_value=seq_size), + min_size=num_batches - 1, + max_size=num_batches - 1, + ) + ) + batch_sizes = np.array(draw(st.permutations(batch_sizes))) + input, batch_sizes = ( + ivy.to_numpy(p) for p in _pack_padded_sequence(input, batch_sizes) + ) + else: + batch_sizes = None + + initial_states = init_h, init_c + all_weights = tuple(all_weights) + if batch_sizes is not None: + dtypes = dtype + ["int64"] + kwargs = { + "input": input, + "batch_sizes": batch_sizes, + "initial_states": initial_states, + "all_weights": all_weights, + "has_biases": has_biases, + "num_layers": num_layers, + "dropout": dropout, + "train": train, + "bidirectional": bidirectional, + } + else: + dtypes = dtype + kwargs = { + "input": input, + "initial_states": initial_states, + "all_weights": all_weights, + "has_biases": has_biases, + "num_layers": num_layers, + "dropout": dropout, + "train": train, + "bidirectional": bidirectional, + "batch_first": batch_first, + } + return dtypes, kwargs + + @st.composite def _mha_helper(draw, same_pre_embed_dim=False, batch_second=False): _qkv_same_dim = draw(st.booleans()) @@ -1391,7 +1529,30 @@ def test_linear(*, dtype_x_weight_bias, test_flags, backend_fw, fn_name, on_devi ) +# TODO: fix this test # lstm +# @handle_test( +# fn_tree="functional.ivy.lstm", +# dtypes_kwargs=_lstm_helper(), +# ground_truth_backend="torch", +# test_with_out=st.just(False), +# ) +# def test_lstm(*, dtypes_kwargs, test_flags, backend_fw, fn_name, on_device): +# dtypes, kwargs = dtypes_kwargs +# assume("batch_sizes" not in kwargs) +# helpers.test_function( +# input_dtypes=dtypes, +# test_flags=test_flags, +# backend_to_test=backend_fw, +# fn_name=fn_name, +# on_device=on_device, +# rtol_=1e-01, +# atol_=1e-01, +# **kwargs, +# ) + + +# lstm_update @handle_test( fn_tree="functional.ivy.lstm_update", dtype_lstm=_x_and_lstm( From 4391439f7a297069ef8a44f90f4989339d534fdc Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 16 Jan 2024 10:07:56 +0000 Subject: [PATCH 597/978] test: remove instance method imag as it is overwritten by the property and disable test for instance method in test_imag --- ivy/data_classes/array/elementwise.py | 34 ------------------- .../test_core/test_elementwise.py | 1 + 2 files changed, 1 insertion(+), 34 deletions(-) diff --git a/ivy/data_classes/array/elementwise.py b/ivy/data_classes/array/elementwise.py index b8de2d75e91ad..35a79eb00ee3d 100644 --- a/ivy/data_classes/array/elementwise.py +++ b/ivy/data_classes/array/elementwise.py @@ -2731,40 +2731,6 @@ def nan_to_num( self._data, copy=copy, nan=nan, posinf=posinf, neginf=neginf, out=out ) - def imag( - self: ivy.Array, - /, - *, - out: Optional[ivy.Array] = None, - ) -> ivy.Array: - """ivy.Array instance method variant of ivy.imag. This method simply - wraps the function, and so the docstring for ivy.imag also applies to - this method with minimal changes. - - Parameters - ---------- - self - Array-like input. - out - optional output array, for writing the result to. - - Returns - ------- - ret - Returns an array with the imaginary part of complex numbers. - - Examples - -------- - >>> b = ivy.array(np.array([1+2j, 3+4j, 5+6j])) - >>> b - ivy.array([1.+2.j, 3.+4.j, 5.+6.j]) - >>> ivy.imag(b) - ivy.array([2., 4., 6.]) - >>> b.imag() - ivy.array([2., 4., 6.]) - """ - return ivy.imag(self._data, out=out) - def angle( self: ivy.Array, /, diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 98e077287ebff..cea111ff23d2e 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1000,6 +1000,7 @@ def test_greater_equal(*, dtype_and_x, test_flags, backend_fw, fn_name, on_devic allow_nan=False, ), test_gradients=st.just(False), + test_instance_method=st.just(False), ) def test_imag( *, From 2b50a133327b7a0f8de04329bf3c24839272f5c9 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 16 Jan 2024 16:03:28 +0530 Subject: [PATCH 598/978] fix: Fixed raising `TypeError` for invalid type (#27928) --- ivy/functional/backends/paddle/layers.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index ad78d3d041b50..878c7689a3b24 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -30,10 +30,11 @@ def _convert_to_list(value, n, name="padding", _type=int): else: try: value_list = list(value) - except TypeError: - raise ValueError( - f"The input {name}'s type must be list or tuple. Received: {value}" - ) + except TypeError as e: + raise TypeError( + f"The input {value}'s type must be list or tuple. Received:" + f" {type(value)}" + ) from e else: return value_list From 2038f90bf558fd47f2d39f72ccb770f9edd177ec Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 16 Jan 2024 16:03:49 +0530 Subject: [PATCH 599/978] fix: Added missing `assert` to 3 comparison checks (#27926) --- .../test_jax/test_numpy/test_mathematical_functions.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py index 7ff6a267a5b4b..402c3a7f6a3be 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py @@ -1103,9 +1103,9 @@ def test_jax_einsum_path( **kw, optimize=optimize, ) - len(ret[0]) == len(ret_gt[0]) - all(x == y for x, y in zip(ret[0], ret_gt[0])) - ret[1] == str(ret_gt[1]) + assert len(ret[0]) == len(ret_gt[0]) + assert all(x == y for x, y in zip(ret[0], ret_gt[0])) + assert ret[1] == str(ret_gt[1]) # exp From 868f13b6dd623999860bb1cddb6d2755c719b621 Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Tue, 16 Jan 2024 15:33:56 +0000 Subject: [PATCH 600/978] fix: tf get item with non 0 dim tensor queries (#27921) --- ivy/functional/backends/tensorflow/general.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index c1ff4c4d73068..e0b238c455703 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -49,7 +49,7 @@ def current_backend_str() -> str: def _check_query(query): return not isinstance(query, list) and ( - not (ivy.is_array(query) and ivy.is_bool_dtype(query) and bool(query.ndim > 0)) + not (ivy.is_array(query) and bool(query.ndim > 0)) ) @@ -60,8 +60,6 @@ def get_item( *, copy: Optional[bool] = None, ) -> Union[tf.Tensor, tf.Variable]: - if isinstance(query, (tf.Tensor, tf.Variable)): - return tf.gather(x, query) return x.__getitem__(query) From be7411dd8be510eba2f9e3316619a873eeaa58da Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Tue, 16 Jan 2024 16:16:32 +0000 Subject: [PATCH 601/978] fix: torch frontend expand working with scalar tensors in `size`. torch frontend rand/randn working with ivy shape inputs. tf reciprocal working with int inputs. (#27929) --- ivy/functional/backends/tensorflow/elementwise.py | 2 ++ ivy/functional/frontends/torch/random_sampling.py | 4 ++-- ivy/functional/frontends/torch/tensor.py | 5 ++++- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index 11c0dbcad8278..0f5b887e61618 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -856,6 +856,8 @@ def reciprocal( *, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: + if x.dtype.is_integer: + x = tf.cast(x, tf.float32) return tf.math.reciprocal(x) diff --git a/ivy/functional/frontends/torch/random_sampling.py b/ivy/functional/frontends/torch/random_sampling.py index f303496d23710..77f1c96f49230 100644 --- a/ivy/functional/frontends/torch/random_sampling.py +++ b/ivy/functional/frontends/torch/random_sampling.py @@ -95,7 +95,7 @@ def rand( if ( isinstance(size, (list, tuple)) and len(size) == 1 - and isinstance(size[0], (list, tuple)) + and isinstance(size[0], (list, tuple, ivy.Shape)) ): size = size[0] seed = generator.initial_seed() if generator is not None else None @@ -195,7 +195,7 @@ def randn( if ( isinstance(size, (list, tuple)) and len(size) == 1 - and isinstance(size[0], (list, tuple)) + and isinstance(size[0], (list, tuple, ivy.Shape)) ): size = size[0] seed = generator.initial_seed() if generator is not None else None diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index e462fb61c736c..2cd2fd7a02d76 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -664,7 +664,10 @@ def expand(self, *args, size=None): size = args[0] else: size = args - + if isinstance(size, (tuple, list)): + size = tuple( + s.item() if isinstance(s, torch_frontend.Tensor) else s for s in size + ) return torch_frontend.tensor(ivy.expand(self.ivy_array, tuple(size))) def expand_as(self, other): From afcb99a5ba5eb51e443df8b024d77262f580524f Mon Sep 17 00:00:00 2001 From: NripeshN Date: Tue, 16 Jan 2024 19:44:36 +0000 Subject: [PATCH 602/978] Update volunteer-leaderboard.rst --- docs/overview/contributing/volunteer_ranks.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 8a448ebdf056a..6d20db9f9530d 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -1,7 +1,7 @@ Contributor Leaderboard ======================= -This page lists all of our amazing Contributor who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing Contributors who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Rising Contributors ------------------- @@ -14,7 +14,7 @@ Rising Contributors - Badges * - V\. Sai Suraj - `Sai-Suraj-27 `_ - - Merging Master Silver, Debugging Dynamo Silver, Pull Request Pioneer Silver + - Merging Master Silver, Debugging Dynamo Silver * - samunder singh - `samthakur587 `_ - - Debugging Dynamo Silver, Merging Master Bronze, Pull Request Pioneer Bronze + - Debugging Dynamo Silver, Merging Master Bronze From dce86de9c3a50ecadf8da1d9fbc8efb190435304 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Tue, 16 Jan 2024 22:54:56 +0000 Subject: [PATCH 603/978] fix: minor corrections to ivy.lstm (#27933) --- ivy/functional/backends/torch/layers.py | 2 +- ivy/functional/ivy/layers.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index 690d0114afd51..e23e8cee591a2 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -882,7 +882,7 @@ def lstm( batch_first: bool = False, batch_sizes: Sequence = None, ): - return torch._VF.lstm( + return torch.lstm( input, initial_states, all_weights, diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 461adc33ed642..53ca95676a3d0 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -2785,7 +2785,7 @@ def _lstm_cell( ): init_h = ivy.squeeze(init_h, axis=0) init_c = ivy.squeeze(init_c, axis=0) - out, states = lstm_update( + out, states = ivy.lstm_update( x, init_h, init_c, From 036dfcbcf1a916dcff6a9326218e3c62795d0ffa Mon Sep 17 00:00:00 2001 From: Nightcrab Date: Wed, 17 Jan 2024 03:41:04 +0000 Subject: [PATCH 604/978] ignore when copy constructor doesn't work --- ivy/functional/ivy/nest.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index e0e97a718cda6..10c15293d3e67 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -369,7 +369,10 @@ def map_nest_at_index( try: _result = nest_type(_result) except TypeError: - _result = nest_type(*_result) + try: + _result = nest_type(*_result) + except TypeError: + pass return _result From 288ea0db2cc452cad8c34439ade984541352b397 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 17 Jan 2024 11:20:59 +0530 Subject: [PATCH 605/978] fix: Issue with unsupported dtypes (#27934) 1. fixed an issue with _nested_get that was failing the unsupported dtypes function when testing with a frontend tensor method that uses the .to call as we can't infer the type of the instance where .to is being called in arbitrary code. 2. also updated the log1p frontend method and the relu frontend method implementations for the same. --- ivy/functional/frontends/torch/tensor.py | 9 +++++---- ivy/functional/ivy/data_type.py | 15 +++++++-------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 2cd2fd7a02d76..198982e47a8ef 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -5,7 +5,6 @@ # local import ivy import ivy.functional.frontends.torch as torch_frontend -import ivy.functional.frontends.torch.nn.functional as torch_frontend_nn from ivy.functional.frontends.numpy.creation_routines.from_existing_data import ( array as np_frontend_array, ) @@ -390,7 +389,7 @@ def log2(self): @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") def relu(self): - return torch_frontend_nn.relu(self) + return torch_frontend.nn.functional.relu(self) @numpy_to_torch_style_args @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @@ -1714,12 +1713,14 @@ def stride(self, dim=None): ) def log1p(self): promoted_type = ivy.promote_types(self.dtype, "float32") - return torch_frontend.log1p(self).to(promoted_type) + res = torch_frontend.log1p(self) + return res.to(promoted_type) @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") def log1p_(self): promoted_type = ivy.promote_types(self.dtype, "float32") - self.ivy_array = torch_frontend.log1p(self).to(promoted_type).ivy_array + res = torch_frontend.log1p(self) + self.ivy_array = res.to(promoted_type).ivy_array return self def baddbmm(self, batch1, batch2, *, beta=1, alpha=1): diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index 5e418ff22ec49..4bd8dcb4f8584 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -188,16 +188,15 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): } for key in fl: if "frontend" in key: - fn_tree = key.split(".") - root, tree, fn_name = fn_tree[0], fn_tree[1:-1], fn_tree[-1] - root_module = importlib.import_module( - ".".join([frontends[root], *tree]) - ) - frontend_fn = getattr(root_module, fn_name) - frontend_fl = _get_function_list(frontend_fn) + frontend_fn = fl[key] + for frontend in frontends: + if frontend in key: + key = key.replace(frontend, frontends[frontend]) + frontend_module = ".".join(key.split(".")[:-1]) + frontend_fl = {key: frontend_fn} res += list( _get_functions_from_string( - frontend_fl, __import__(frontend_fn.__module__) + frontend_fl, importlib.import_module(frontend_module) ) ) to_visit.extend(set(res)) From 02acd51d00e04052a159522385f4164cde9fd3b0 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 17 Jan 2024 13:55:33 +0530 Subject: [PATCH 606/978] refactor: update setup_priority_tests.py to make the process more robust --- scripts/setup_tests/setup_priority_tests.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/scripts/setup_tests/setup_priority_tests.py b/scripts/setup_tests/setup_priority_tests.py index 6f1f85ea30e9e..52377d947daf7 100644 --- a/scripts/setup_tests/setup_priority_tests.py +++ b/scripts/setup_tests/setup_priority_tests.py @@ -10,16 +10,14 @@ def main(): ci_dashboard_db = cluster["ci_dashboard"] ivy_tests_collection = ci_dashboard_db["ivy_tests"] frontend_tests_collection = ci_dashboard_db["frontend_tests"] - demos_collection = ci_dashboard_db["demos"] # iterate over demos and collect ivy and frontend functions used - demos = demos_collection.find() - ivy_functions, frontend_functions = [], [] - for demo in demos: - ivy_functions += demo.get("ivy_functions", []) - frontend_functions += demo.get("frontend_functions", []) - ivy_functions = list(set(ivy_functions)) - frontend_functions = list(set(frontend_functions)) + ivy_test_docs = ivy_tests_collection.find() + frontend_test_docs = frontend_tests_collection.find() + ivy_functions = [ivy_test_doc["_id"] for ivy_test_doc in ivy_test_docs if ivy_test_doc.get("demos", None)] + frontend_functions = [frontend_test_doc["_id"] for frontend_test_doc in frontend_test_docs if frontend_test_doc.get("demos", None)] + ivy_functions = sorted(list(set(ivy_functions))) + frontend_functions = sorted(list(set(frontend_functions))) # find corresponding test paths for those functions ivy_test_paths = [] From a7f1ff026ebd012388466376e3fa78a2790d48c4 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 17 Jan 2024 08:26:50 +0000 Subject: [PATCH 607/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scripts/setup_tests/setup_priority_tests.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/scripts/setup_tests/setup_priority_tests.py b/scripts/setup_tests/setup_priority_tests.py index 52377d947daf7..7e124af88a828 100644 --- a/scripts/setup_tests/setup_priority_tests.py +++ b/scripts/setup_tests/setup_priority_tests.py @@ -14,8 +14,16 @@ def main(): # iterate over demos and collect ivy and frontend functions used ivy_test_docs = ivy_tests_collection.find() frontend_test_docs = frontend_tests_collection.find() - ivy_functions = [ivy_test_doc["_id"] for ivy_test_doc in ivy_test_docs if ivy_test_doc.get("demos", None)] - frontend_functions = [frontend_test_doc["_id"] for frontend_test_doc in frontend_test_docs if frontend_test_doc.get("demos", None)] + ivy_functions = [ + ivy_test_doc["_id"] + for ivy_test_doc in ivy_test_docs + if ivy_test_doc.get("demos", None) + ] + frontend_functions = [ + frontend_test_doc["_id"] + for frontend_test_doc in frontend_test_docs + if frontend_test_doc.get("demos", None) + ] ivy_functions = sorted(list(set(ivy_functions))) frontend_functions = sorted(list(set(frontend_functions))) From 88cffff668bba45487653ea644874688df3d2ee0 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 17 Jan 2024 14:39:31 +0530 Subject: [PATCH 608/978] fix: Fixed the issue with dtype mismatches as the precision_mode argument wasn't being passed everywhere --- ivy_tests/test_ivy/helpers/function_testing.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 05c595d8dc2aa..df81f34ec8611 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -242,6 +242,7 @@ def target_fn(instance, *args, **kwargs): target_fn, *copy_args, test_trace=test_flags.test_trace, + precision_mode=test_flags.precision_mode, **copy_kwargs, ) @@ -265,14 +266,14 @@ def target_fn(instance, *args, **kwargs): ret_from_target, ret_np_flat_from_target, ) = get_ret_and_flattened_np_array( - fw, instance.__getattribute__(fn_name), *args, **kwargs, out=out + fw, instance.__getattribute__(fn_name), *args, **kwargs, out=out, precision_mode=test_flags.precision_mode ) else: ( ret_from_target, ret_np_flat_from_target, ) = get_ret_and_flattened_np_array( - fw, ivy_backend.__dict__[fn_name], *args, **kwargs, out=out + fw, ivy_backend.__dict__[fn_name], *args, **kwargs, out=out, precision_mode=test_flags.precision_mode ) test_ret = ( ret_from_target[getattr(ivy_backend.__dict__[fn_name], "out_index")] From 132f1fba1b8080cd72fada466c1451ce651177fe Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 17 Jan 2024 09:10:52 +0000 Subject: [PATCH 609/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy_tests/test_ivy/helpers/function_testing.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index df81f34ec8611..94beb091b989c 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -266,14 +266,24 @@ def target_fn(instance, *args, **kwargs): ret_from_target, ret_np_flat_from_target, ) = get_ret_and_flattened_np_array( - fw, instance.__getattribute__(fn_name), *args, **kwargs, out=out, precision_mode=test_flags.precision_mode + fw, + instance.__getattribute__(fn_name), + *args, + **kwargs, + out=out, + precision_mode=test_flags.precision_mode, ) else: ( ret_from_target, ret_np_flat_from_target, ) = get_ret_and_flattened_np_array( - fw, ivy_backend.__dict__[fn_name], *args, **kwargs, out=out, precision_mode=test_flags.precision_mode + fw, + ivy_backend.__dict__[fn_name], + *args, + **kwargs, + out=out, + precision_mode=test_flags.precision_mode, ) test_ret = ( ret_from_target[getattr(ivy_backend.__dict__[fn_name], "out_index")] From e374ef49ea59fbe7516cf20901613558daa8e035 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 17 Jan 2024 13:00:45 +0000 Subject: [PATCH 610/978] fix: handle shape mismatch for the inverse in torch frontend's `unique` function and the complex dtype --- ivy/functional/frontends/torch/reduction_ops.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 52e184fa6a289..e1a2e9715585e 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -323,6 +323,7 @@ def sum(input, dim=None, keepdim=False, *, dtype=None, out=None): return ivy.sum(input, axis=dim, dtype=dtype, keepdims=keepdim, out=out) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None): if dim is not None: @@ -333,7 +334,7 @@ def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=No inverse_indices = results.inverse_indices if dim is None: inverse_indices = inverse_indices.reshape(input.shape) - ret += (results.inverse_indices,) + ret += (inverse_indices,) if return_counts: ret += (results.counts,) return ret From 1036e25daa4573838fa5b561f04f81598fcd8044 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 17 Jan 2024 15:52:07 +0000 Subject: [PATCH 611/978] fix: handle shape inconsistencies in torch frontend nonzero and simplify tests passing. --- .../torch/indexing_slicing_joining_mutating_ops.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py index 792c5796e8b03..6715f68b64bf2 100644 --- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py +++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py @@ -342,13 +342,9 @@ def narrow(input, dim, start, length): @to_ivy_arrays_and_back def nonzero(input, *, out=None, as_tuple=False): - ret = ivy.nonzero(input) - if as_tuple is False: - ret = ivy.matrix_transpose(ivy.stack(ret)) - - if ivy.exists(out): - return ivy.inplace_update(out, ret) - return ret + if as_tuple: + return ivy.nonzero(input, as_tuple=as_tuple) + return ivy.argwhere(input != 0, out=out) @to_ivy_arrays_and_back From 9aa8fe5b341fa48dd8ef102fccee5cbaa4ffefb7 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 17 Jan 2024 17:09:30 +0000 Subject: [PATCH 612/978] tests: improve logging for large array value mismatches in value tests making mismatching values easier to be spotted --- ivy_tests/test_ivy/helpers/assertions.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy_tests/test_ivy/helpers/assertions.py b/ivy_tests/test_ivy/helpers/assertions.py index b2403339f7b5f..a4f7a942a4080 100644 --- a/ivy_tests/test_ivy/helpers/assertions.py +++ b/ivy_tests/test_ivy/helpers/assertions.py @@ -58,6 +58,8 @@ def assert_all_close( f" the results from backend {backend} " f"and ground truth framework {ground_truth_backend} " f"do not match\n {ret_np}!={ret_from_gt_np} \n\n" + "The mismatching elements are at `False` indices:\n\n" + f"{ret_np == ret_from_gt_np} \n\n" ) From 9e45fbba7ce5980711d691afe120c3f29ae6a46b Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 18 Jan 2024 00:20:38 +0530 Subject: [PATCH 613/978] fix: unsupported dtype at jax asinh (#27943) Co-authored-by: NripeshN --- ivy/functional/backends/jax/elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index 42a5fd51077c5..056996b8cc710 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -55,6 +55,7 @@ def asin(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arcsin(x) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def asinh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arcsinh(x) From ce096db007ffaad4e7a5f94baa8554aaed1e0449 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 18 Jan 2024 01:58:23 +0530 Subject: [PATCH 614/978] fix: fixed the ivy.mean (#27903) --- .../test_ivy/test_functional/test_core/test_statistical.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py index 650060617b8aa..47d8ef1d894dd 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py @@ -251,7 +251,7 @@ def test_max(*, dtype_and_x, keep_dims, test_flags, backend_fw, fn_name, on_devi keep_dims=st.booleans(), ) def test_mean(*, dtype_and_x, keep_dims, test_flags, backend_fw, fn_name, on_device): - input_dtype, x, axis = dtype_and_x + input_dtype, x, axis, dtype3, where = dtype_and_x helpers.test_function( input_dtypes=input_dtype, test_flags=test_flags, From cbb8383ee8a9b7b06662239a0ce49fcf61ee0b77 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 17 Jan 2024 22:02:08 +0000 Subject: [PATCH 615/978] fix: correct usage of unique_all, update set related function issue, move container method example over to the relevant method, close #27895 --- ivy/data_classes/container/set.py | 12 ++++++++++++ .../frontends/sklearn/model_selection/_split.py | 2 +- ivy/functional/ivy/set.py | 14 -------------- 3 files changed, 13 insertions(+), 15 deletions(-) diff --git a/ivy/data_classes/container/set.py b/ivy/data_classes/container/set.py index 930560637b588..e388499e07c52 100644 --- a/ivy/data_classes/container/set.py +++ b/ivy/data_classes/container/set.py @@ -511,6 +511,18 @@ def unique_inverse( a: ivy.array([1, 3, 0, 2, 4, 1]), b: ivy.array([5, 4, 2, 3, 4, 1, 0]) }] + + >>> x = ivy.Container(a=ivy.array([1., 4., 3. , 5. , 3. , 7.]), + ... b=ivy.array([3, 2, 6, 3, 7, 4, 9])) + >>> y = ivy.ivy.unique_inverse(x) + >>> print(y) + [{ + a: ivy.array([1., 3., 4., 5., 7.]), + b: ivy.array([2, 3, 4, 6, 7, 9]) + }, { + a: ivy.array([0, 2, 1, 3, 1, 4]), + b: ivy.array([1, 0, 3, 1, 4, 2, 5]) + }] """ return self._static_unique_inverse( self, diff --git a/ivy/functional/frontends/sklearn/model_selection/_split.py b/ivy/functional/frontends/sklearn/model_selection/_split.py index ec6dc3d067f1e..1f14400186012 100644 --- a/ivy/functional/frontends/sklearn/model_selection/_split.py +++ b/ivy/functional/frontends/sklearn/model_selection/_split.py @@ -77,7 +77,7 @@ def _iter_test_indices(self, X=None, y=None, groups=None): ivy.seed(seed_value=self.random_state) y = ivy.array(y) y = column_or_1d(y) - _, y_idx, y_inv, _ = ivy.unique_all(y, return_index=True, return_inverse=True) + _, y_idx, y_inv, _ = ivy.unique_all(y) class_perm = ivy.unique_inverse(y_idx) y_encoded = class_perm[y_inv] diff --git a/ivy/functional/ivy/set.py b/ivy/functional/ivy/set.py index 10ae870d1b89a..5f9e92f400918 100644 --- a/ivy/functional/ivy/set.py +++ b/ivy/functional/ivy/set.py @@ -243,20 +243,6 @@ def unique_inverse( >>> print(y) Results(values=ivy.array([0.2, 0.3, 0.5, 0.8, 1.2, 2.4]), inverse_indices=ivy.array([2, 1, 3, 0, 4, 5, 1])) - - With :class:`ivy.Container` input: - - >>> x = ivy.Container(a=ivy.array([1., 4., 3. , 5. , 3. , 7.]), - ... b=ivy.array([3, 2, 6, 3, 7, 4, 9])) - >>> y = ivy.ivy.unique_inverse(x) - >>> print(y) - [{ - a: ivy.array([1., 3., 4., 5., 7.]), - b: ivy.array([2, 3, 4, 6, 7, 9]) - }, { - a: ivy.array([0, 2, 1, 3, 1, 4]), - b: ivy.array([1, 0, 3, 1, 4, 2, 5]) - }] """ return ivy.current_backend(x).unique_inverse(x, axis=axis) From d5a926bfac57aa37e0790d4d9eaf7307c6eacbb9 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 18 Jan 2024 04:38:00 +0530 Subject: [PATCH 616/978] fix: added complex as unsupported dtype in asin (#27946) --- ivy/functional/backends/jax/elementwise.py | 1 + ivy/functional/backends/torch/elementwise.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index 056996b8cc710..dffa6b358102a 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -51,6 +51,7 @@ def add( return jnp.add(x1, x2) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def asin(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arcsin(x) diff --git a/ivy/functional/backends/torch/elementwise.py b/ivy/functional/backends/torch/elementwise.py index 7aec8d25c8a0c..13e8f3a83460c 100644 --- a/ivy/functional/backends/torch/elementwise.py +++ b/ivy/functional/backends/torch/elementwise.py @@ -204,7 +204,7 @@ def fmin( fmin.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def asin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) From 5bc4f51a1f20948351ac2151969646c3ae352a79 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 18 Jan 2024 08:11:23 +0530 Subject: [PATCH 617/978] fix: updated _nested_get to deal with the case where multiple function calls are chained together --- ivy/functional/ivy/data_type.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index 4bd8dcb4f8584..947a052343a69 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -192,6 +192,8 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): for frontend in frontends: if frontend in key: key = key.replace(frontend, frontends[frontend]) + if "(" in key: + key = key.split('(')[0] frontend_module = ".".join(key.split(".")[:-1]) frontend_fl = {key: frontend_fn} res += list( From be82a7a7ddaa74eff3c915505edf05db47e11f6d Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 18 Jan 2024 02:42:43 +0000 Subject: [PATCH 618/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/ivy/data_type.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index 947a052343a69..83e8dbae61baa 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -193,7 +193,7 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): if frontend in key: key = key.replace(frontend, frontends[frontend]) if "(" in key: - key = key.split('(')[0] + key = key.split("(")[0] frontend_module = ".".join(key.split(".")[:-1]) frontend_fl = {key: frontend_fn} res += list( From 6e5fa5cb67ab2a707f8fd4b0360fa1a0ccb63a7c Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Thu, 18 Jan 2024 01:52:05 -0800 Subject: [PATCH 619/978] FIX: fix error in elementwise.add by removing unsupported data int16 (#27938) --- ivy/functional/backends/paddle/elementwise.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 1f44c14736956..8b94405b21be1 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -28,7 +28,7 @@ def _elementwise_helper(x1, x2): @with_unsupported_dtypes( - {"2.5.2 and below": ("int8", "uint8", "float16", "bool", "bfloat16")}, + {"2.5.2 and below": ("int8", "int16", "uint8", "float16", "bool", "bfloat16")}, backend_version, ) def add( From 8d2f4d431b957add3fc9f79d6dcb6d20ecacbbe5 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 18 Jan 2024 15:32:05 +0530 Subject: [PATCH 620/978] fix: fixed the uint not supported by min (#27931) --- ivy/functional/backends/numpy/statistical.py | 1 + ivy/functional/backends/tensorflow/statistical.py | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/numpy/statistical.py b/ivy/functional/backends/numpy/statistical.py index bca5a48a850d1..cba78d4124988 100644 --- a/ivy/functional/backends/numpy/statistical.py +++ b/ivy/functional/backends/numpy/statistical.py @@ -14,6 +14,7 @@ # -------------------# +@_scalar_output_to_0d_array def min( x: np.ndarray, /, diff --git a/ivy/functional/backends/tensorflow/statistical.py b/ivy/functional/backends/tensorflow/statistical.py index 7f8a539eb2500..f79a665fb2e99 100644 --- a/ivy/functional/backends/tensorflow/statistical.py +++ b/ivy/functional/backends/tensorflow/statistical.py @@ -12,7 +12,9 @@ # -------------------# -@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) +@with_unsupported_dtypes( + {"2.15.0 and below": ("complex", "bool", "uint64")}, backend_version +) def min( x: Union[tf.Tensor, tf.Variable], /, From 7e424744deacf38417922ede9432b8f7110237bc Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 18 Jan 2024 16:23:56 +0530 Subject: [PATCH 621/978] feat: Updated `paddle` version mapping form `2.5.2` to `2.6.0` (#27941) --- docs/overview/deep_dive/data_types.rst | 2 +- ivy/functional/backends/paddle/__init__.py | 12 +- ivy/functional/backends/paddle/activations.py | 18 +- ivy/functional/backends/paddle/creation.py | 12 +- ivy/functional/backends/paddle/data_type.py | 2 +- ivy/functional/backends/paddle/elementwise.py | 124 ++++---- .../paddle/experimental/activations.py | 28 +- .../backends/paddle/experimental/creation.py | 4 +- .../paddle/experimental/elementwise.py | 28 +- .../backends/paddle/experimental/layers.py | 22 +- .../paddle/experimental/linear_algebra.py | 10 +- .../backends/paddle/experimental/losses.py | 14 +- .../paddle/experimental/manipulation.py | 28 +- .../backends/paddle/experimental/norms.py | 4 +- .../backends/paddle/experimental/random.py | 2 +- .../paddle/experimental/sparse_array.py | 2 +- .../paddle/experimental/statistical.py | 22 +- ivy/functional/backends/paddle/general.py | 4 +- ivy/functional/backends/paddle/gradients.py | 2 +- ivy/functional/backends/paddle/layers.py | 8 +- .../backends/paddle/linear_algebra.py | 32 +- .../backends/paddle/manipulation.py | 22 +- ivy/functional/backends/paddle/random.py | 8 +- ivy/functional/backends/paddle/searching.py | 8 +- ivy/functional/backends/paddle/set.py | 8 +- ivy/functional/backends/paddle/sorting.py | 8 +- ivy/functional/backends/paddle/statistical.py | 16 +- ivy/functional/frontends/__init__.py | 2 +- ivy/functional/frontends/jax/array.py | 4 +- ivy/functional/frontends/jax/numpy/fft.py | 2 +- .../jax/numpy/mathematical_functions.py | 2 +- .../frontends/numpy/logic/array_contents.py | 2 +- ivy/functional/frontends/paddle/creation.py | 34 +- ivy/functional/frontends/paddle/fft.py | 28 +- ivy/functional/frontends/paddle/linalg.py | 30 +- ivy/functional/frontends/paddle/logic.py | 36 +-- .../frontends/paddle/manipulation.py | 34 +- ivy/functional/frontends/paddle/math.py | 164 +++++----- .../paddle/nn/functional/activation.py | 44 +-- .../frontends/paddle/nn/functional/common.py | 16 +- .../frontends/paddle/nn/functional/conv.py | 12 +- .../frontends/paddle/nn/functional/loss.py | 32 +- .../frontends/paddle/nn/functional/norm.py | 4 +- .../frontends/paddle/nn/functional/pooling.py | 14 +- .../frontends/paddle/nn/functional/vision.py | 4 +- ivy/functional/frontends/paddle/random.py | 14 +- ivy/functional/frontends/paddle/search.py | 18 +- ivy/functional/frontends/paddle/stat.py | 10 +- .../frontends/paddle/tensor/manipulation.py | 2 +- .../frontends/paddle/tensor/math.py | 22 +- .../frontends/paddle/tensor/random.py | 4 +- .../frontends/paddle/tensor/tensor.py | 296 +++++++++--------- .../frontends/paddle/vision/transforms.py | 14 +- .../frontends/tensorflow/general_functions.py | 2 +- ivy/functional/frontends/tensorflow/math.py | 2 +- .../torch/nn/functional/dropout_functions.py | 2 +- ivy/functional/frontends/torch/tensor.py | 2 +- 57 files changed, 651 insertions(+), 651 deletions(-) diff --git a/docs/overview/deep_dive/data_types.rst b/docs/overview/deep_dive/data_types.rst index 0dff16390e4bf..bbf15ebd1839e 100644 --- a/docs/overview/deep_dive/data_types.rst +++ b/docs/overview/deep_dive/data_types.rst @@ -423,7 +423,7 @@ set of dtypes is not supported by a certain device. .. code-block:: python - @with_unsupported_device_and_dtypes({"2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version) + @with_unsupported_device_and_dtypes({"2.6.0 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version) def gcd( x1: Union[paddle.Tensor, int, list, tuple], x2: Union[paddle.Tensor, float, list, tuple], diff --git a/ivy/functional/backends/paddle/__init__.py b/ivy/functional/backends/paddle/__init__.py index 86deeb0c9b9d6..7b11652539c8b 100644 --- a/ivy/functional/backends/paddle/__init__.py +++ b/ivy/functional/backends/paddle/__init__.py @@ -175,7 +175,7 @@ def rep_method(*args, **kwargs): ), } valid_int_dtypes = { - "2.5.2 and below": ( + "2.6.0 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -187,8 +187,8 @@ def rep_method(*args, **kwargs): "2.4.2 and below": (ivy.float16, ivy.float32, ivy.float64), "2.5.0 and above": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64), } -valid_uint_dtypes = {"2.5.2 and below": (ivy.uint8,)} -valid_complex_dtypes = {"2.5.2 and below": (ivy.complex64, ivy.complex128)} +valid_uint_dtypes = {"2.6.0 and below": (ivy.uint8,)} +valid_complex_dtypes = {"2.6.0 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -228,10 +228,10 @@ def rep_method(*args, **kwargs): ), } -invalid_int_dtypes = {"2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_int_dtypes = {"2.6.0 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} invalid_float_dtypes = {"2.4.2 and below": (ivy.bfloat16,), "2.5.0 and above": ()} -invalid_uint_dtypes = {"2.5.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_complex_dtypes = {"2.5.2 and below": ()} +invalid_uint_dtypes = {"2.6.0 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_complex_dtypes = {"2.6.0 and below": ()} # leave these untouched invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index 59c421f43ae6b..a08580b4383d0 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/ivy/functional/backends/paddle/activations.py @@ -22,7 +22,7 @@ @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version, ) def relu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -32,7 +32,7 @@ def relu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def leaky_relu( @@ -52,7 +52,7 @@ def leaky_relu( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def gelu( @@ -76,7 +76,7 @@ def gelu( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def sigmoid( @@ -88,7 +88,7 @@ def sigmoid( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.6.0 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def softmax( x: paddle.Tensor, @@ -138,7 +138,7 @@ def softplus( # Softsign @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {"2.6.0 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def softsign( x: paddle.Tensor, @@ -152,7 +152,7 @@ def softsign( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {"2.6.0 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def log_softmax( x: paddle.Tensor, @@ -171,7 +171,7 @@ def log_softmax( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def mish( @@ -187,7 +187,7 @@ def mish( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version ) def hardswish( x: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index e91fcc479ba5d..347f953338cbb 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -142,7 +142,7 @@ def empty_like( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "uint8", "int8", @@ -356,7 +356,7 @@ def _slice_at_axis(sl, axis): @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("uint16", "bfloat16", "float16")}}, backend_version + {"2.6.0 and below": {"cpu": ("uint16", "bfloat16", "float16")}}, backend_version ) def linspace( start: Union[paddle.Tensor, float], @@ -414,7 +414,7 @@ def linspace( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -484,7 +484,7 @@ def ones_like( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -503,7 +503,7 @@ def tril( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -616,7 +616,7 @@ def one_hot( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def frombuffer( diff --git a/ivy/functional/backends/paddle/data_type.py b/ivy/functional/backends/paddle/data_type.py index 6112117f2e6d5..e0277bb2e8fa7 100644 --- a/ivy/functional/backends/paddle/data_type.py +++ b/ivy/functional/backends/paddle/data_type.py @@ -143,7 +143,7 @@ def broadcast_arrays(*arrays: paddle.Tensor) -> List[paddle.Tensor]: @with_unsupported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "uint8", "int8", "int16", diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 8b94405b21be1..97f7a68516a5d 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -28,7 +28,7 @@ def _elementwise_helper(x1, x2): @with_unsupported_dtypes( - {"2.5.2 and below": ("int8", "int16", "uint8", "float16", "bool", "bfloat16")}, + {"2.6.0 and below": ("int8", "int16", "uint8", "float16", "bool", "bfloat16")}, backend_version, ) def add( @@ -59,7 +59,7 @@ def bitwise_xor( @with_supported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "float16", "float32", "float64", @@ -79,7 +79,7 @@ def bitwise_invert( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -99,7 +99,7 @@ def isfinite( @with_unsupported_dtypes( - {"2.5.2 and below": ("complex", "uint8")}, + {"2.6.0 and below": ("complex", "uint8")}, backend_version, ) def isinf( @@ -141,7 +141,7 @@ def equal( @with_unsupported_dtypes( - {"2.5.1 and below": ("int8", "int16", "bfloat16", "unsigned", "float16")}, + {"2.6.0 and below": ("int8", "int16", "bfloat16", "unsigned", "float16")}, backend_version, ) def less_equal( @@ -173,7 +173,7 @@ def bitwise_and( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version, ) def ceil(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -183,7 +183,7 @@ def ceil(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version, ) def floor(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -194,7 +194,7 @@ def floor(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float32", "float64", @@ -209,7 +209,7 @@ def asin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float32", "float64", ) @@ -221,7 +221,7 @@ def asinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16", "float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float16", "float32", "float64", "complex")}}, backend_version, ) def sign( @@ -235,7 +235,7 @@ def sign( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, backend_version + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version ) def sqrt(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: """Calculate the square root with type handling.""" @@ -250,7 +250,7 @@ def sqrt(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float32", "float64", @@ -264,7 +264,7 @@ def cosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, backend_version + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version ) def log10(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -276,7 +276,7 @@ def log10(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version, ) def log2(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -289,7 +289,7 @@ def log2(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version, ) def log1p(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -300,7 +300,7 @@ def log1p(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_supported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "float", "int32", "int64", @@ -317,7 +317,7 @@ def isnan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_unsupported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "int8", "uint8", ) @@ -342,7 +342,7 @@ def less( @with_unsupported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "int8", "int16", "uint8", @@ -364,7 +364,7 @@ def multiply( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float32", "float64", @@ -377,7 +377,7 @@ def cos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T return paddle.cos(x) -@with_unsupported_dtypes({"2.5.1 and below": ("uint8", "float16")}, backend_version) +@with_unsupported_dtypes({"2.6.0 and below": ("uint8", "float16")}, backend_version) def logical_not( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: @@ -389,7 +389,7 @@ def logical_not( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64", "complex")}, backend_version, ) def divide( @@ -410,7 +410,7 @@ def divide( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version, ) def fmin( @@ -434,7 +434,7 @@ def _apply_for_real_and_imag(fn, x1, x2): @with_supported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "bool", "float32", "float64", @@ -464,7 +464,7 @@ def greater( @with_supported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "bool", "float32", "float64", @@ -494,7 +494,7 @@ def greater_equal( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float32", "float64", @@ -518,7 +518,7 @@ def acos(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("bool", "float32", "int32", "float64", "int64", "complex") } }, @@ -536,7 +536,7 @@ def logical_xor( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("bool", "float32", "int32", "float64", "int64", "complex") } }, @@ -552,7 +552,7 @@ def logical_and( @with_supported_dtypes( - {"2.5.1 and below": ("bool", "float32", "int32", "float64", "int64", "complex")}, + {"2.6.0 and below": ("bool", "float32", "int32", "float64", "int64", "complex")}, backend_version, ) def logical_or( @@ -566,7 +566,7 @@ def logical_or( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float32", "float64", @@ -589,7 +589,7 @@ def acosh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def sin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -603,7 +603,7 @@ def sin(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, backend_version, ) def negative( @@ -623,7 +623,7 @@ def not_equal( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def tanh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -642,7 +642,7 @@ def tanh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "uint8", "int8", "int32", @@ -667,7 +667,7 @@ def floor_divide( @with_supported_dtypes( - {"2.5.1 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, + {"2.6.0 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, backend_version, ) def bitwise_or( @@ -682,7 +682,7 @@ def bitwise_or( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "complex")}, backend_version + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version ) def sinh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -706,7 +706,7 @@ def positive( @with_supported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "int32", "int64", "float32", @@ -723,7 +723,7 @@ def square( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "int32", "int64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "int32", "int64", "complex")}}, backend_version, ) def pow( @@ -764,7 +764,7 @@ def _round_half_to_even(x): # This function aims to mimic the behavior of np.round similar to how tf.experimental.numpy.round does # noqa: E501 # Reference for tf.experimental.numpy.round:https://github.com/tensorflow/tensorflow/blob/v2.13.0/tensorflow/python/ops/numpy_ops/np_array_ops.py#L724 # noqa: E501 @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float16", "complex")}}, backend_version + {"2.6.0 and below": {"cpu": ("bfloat16", "float16", "complex")}}, backend_version ) def round( x: paddle.Tensor, /, *, decimals: int = 0, out: Optional[paddle.Tensor] = None @@ -790,7 +790,7 @@ def round( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, backend_version + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version ) def trunc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -798,7 +798,7 @@ def trunc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle return paddle.trunc(x) -@with_supported_dtypes({"2.5.2 and below": ("float64", "float32")}, backend_version) +@with_supported_dtypes({"2.6.0 and below": ("float64", "float32")}, backend_version) def trapz( y: paddle.Tensor, /, @@ -846,7 +846,7 @@ def trapz( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "int32", "int64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "int32", "int64", "complex")}}, backend_version, ) def abs( @@ -861,7 +861,7 @@ def abs( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version ) def logaddexp( x1: paddle.Tensor, x2: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None @@ -874,7 +874,7 @@ def logaddexp( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version ) def logaddexp2( x1: Union[paddle.Tensor, float, list, tuple], @@ -889,7 +889,7 @@ def logaddexp2( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -910,7 +910,7 @@ def real(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def tan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -921,7 +921,7 @@ def tan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def atan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -933,7 +933,7 @@ def atan(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int32", "int64", @@ -952,7 +952,7 @@ def atan2( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "complex")}, backend_version, ) def log(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -962,7 +962,7 @@ def log(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T @with_supported_dtypes( - {"2.5.1 and below": ("int32", "int64", "float32", "float64", "complex")}, + {"2.6.0 and below": ("int32", "int64", "float32", "float64", "complex")}, backend_version, ) def exp(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -985,7 +985,7 @@ def exp2( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def subtract( x1: Union[float, paddle.Tensor], @@ -1003,7 +1003,7 @@ def subtract( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "int32", "int64")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "int32", "int64")}}, backend_version, ) def remainder( @@ -1029,7 +1029,7 @@ def remainder( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64", "complex")}}, backend_version, ) def atanh(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -1068,13 +1068,13 @@ def bitwise_left_shift( # ------# -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, backend_version) def erf(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: return paddle.erf(x) @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64", "complex")}, backend_version, ) def minimum( @@ -1098,7 +1098,7 @@ def minimum( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64", "complex")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64", "complex")}, backend_version, ) def maximum( @@ -1121,7 +1121,7 @@ def maximum( @with_supported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "float32", "float64", ) @@ -1135,7 +1135,7 @@ def reciprocal( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def deg2rad( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None @@ -1144,7 +1144,7 @@ def deg2rad( @with_supported_dtypes( - {"2.5.1 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def rad2deg( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None @@ -1183,7 +1183,7 @@ def fmod( return paddle_backend.where(paddle_backend.less(x1, 0), -res, res) -@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, backend_version) +@with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, backend_version) def lcm( x1: paddle.Tensor, x2: paddle.Tensor, @@ -1196,7 +1196,7 @@ def lcm( @with_supported_dtypes( { - "2.5.1 and below": ( + "2.6.0 and below": ( "float32", "float64", "complex", @@ -1218,7 +1218,7 @@ def angle( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int32", "int64")}}, backend_version + {"2.6.0 and below": {"cpu": ("int32", "int64")}}, backend_version ) def gcd( x1: Union[paddle.Tensor, int, list, tuple], @@ -1231,7 +1231,7 @@ def gcd( return paddle.gcd(x1, x2) -@with_supported_dtypes({"2.5.2 and below": ("complex",)}, backend_version) +@with_supported_dtypes({"2.6.0 and below": ("complex",)}, backend_version) def imag( val: paddle.Tensor, /, diff --git a/ivy/functional/backends/paddle/experimental/activations.py b/ivy/functional/backends/paddle/experimental/activations.py index 8d13b487369da..13e004e82652e 100644 --- a/ivy/functional/backends/paddle/experimental/activations.py +++ b/ivy/functional/backends/paddle/experimental/activations.py @@ -14,7 +14,7 @@ @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version + {"2.6.0 and below": {"cpu": ("float16", "bfloat16")}}, backend_version ) def logit( x: paddle.Tensor, @@ -44,7 +44,7 @@ def logit( ).cast(x.dtype) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, backend_version) def thresholded_relu( x: paddle.Tensor, /, @@ -56,7 +56,7 @@ def thresholded_relu( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.6.0 and below": ("complex", "float32", "float64")}, backend_version ) def relu6( x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None @@ -67,7 +67,7 @@ def relu6( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.6.0 and below": ("complex", "float32", "float64")}, backend_version ) def logsigmoid( input: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None @@ -82,7 +82,7 @@ def logsigmoid( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.6.0 and below": ("complex", "float32", "float64")}, backend_version ) def selu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -101,7 +101,7 @@ def selu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.6.0 and below": ("complex", "float32", "float64")}, backend_version ) def silu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: if paddle.is_complex(x): @@ -110,7 +110,7 @@ def silu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle. @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.6.0 and below": ("complex", "float32", "float64")}, backend_version ) def elu( x: paddle.Tensor, /, *, alpha: float = 1.0, out: Optional[paddle.Tensor] = None @@ -128,7 +128,7 @@ def elu( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.6.0 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def hardtanh( x: paddle.Tensor, @@ -154,7 +154,7 @@ def hardtanh( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.6.0 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def tanhshrink( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None @@ -167,7 +167,7 @@ def tanhshrink( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.6.0 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def threshold( x: paddle.Tensor, @@ -188,7 +188,7 @@ def threshold( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.6.0 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def softshrink( x: paddle.Tensor, /, *, lambd: float = 0.5, out: Optional[paddle.Tensor] = None @@ -204,7 +204,7 @@ def softshrink( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version + {"2.6.0 and below": {"cpu": ("bfloat16", "float16")}}, backend_version ) def celu( x: paddle.Tensor, @@ -219,7 +219,7 @@ def celu( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64"), "gpu": ("uint16", "float16", "float32", "float64"), } @@ -238,7 +238,7 @@ def scaled_tanh( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, + {"2.6.0 and below": {"cpu": ("float16", "bfloat16")}}, backend_version, ) def hardshrink( diff --git a/ivy/functional/backends/paddle/experimental/creation.py b/ivy/functional/backends/paddle/experimental/creation.py index 6dedf411c06a7..dda4e9820a368 100644 --- a/ivy/functional/backends/paddle/experimental/creation.py +++ b/ivy/functional/backends/paddle/experimental/creation.py @@ -183,7 +183,7 @@ def unsorted_segment_sum( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -257,7 +257,7 @@ def unsorted_segment_mean( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float16", "int8", "int16", "uint8", "complex", "bool") } }, diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 6c7500612de5c..aa2f22f778830 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -20,7 +20,7 @@ @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float32", "float64", "int32", @@ -42,7 +42,7 @@ def amax( @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float32", "float64", "int32", @@ -63,7 +63,7 @@ def amin( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, backend_version, ) def lgamma( @@ -73,7 +73,7 @@ def lgamma( @with_supported_dtypes( - {"2.5.2 and below": ("float64", "float32", "int32", "int64")}, + {"2.6.0 and below": ("float64", "float32", "int32", "int64")}, backend_version, ) def fmax( @@ -89,7 +89,7 @@ def fmax( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version ) def sinc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: y = ivy.pi * paddle.where(x == 0, paddle.to_tensor(1.0e-20, dtype=x.dtype), x) @@ -153,7 +153,7 @@ def copysign( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("uint8", "int8", "int16", "float16")}}, + {"2.6.0 and below": {"cpu": ("uint8", "int8", "int16", "float16")}}, backend_version, ) def nansum( @@ -172,7 +172,7 @@ def nansum( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version ) def isclose( a: paddle.Tensor, @@ -188,7 +188,7 @@ def isclose( @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "int16", "int8", "uint8")}, backend_version + {"2.6.0 and below": ("float16", "int16", "int8", "uint8")}, backend_version ) def diff( x: Union[paddle.Tensor, list, tuple], @@ -237,7 +237,7 @@ def hypot( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -277,7 +277,7 @@ def fix( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version ) def nextafter( x1: paddle.Tensor, @@ -318,7 +318,7 @@ def nextafter( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -396,7 +396,7 @@ def _np_ndim(x): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, backend_version, ) def gradient( @@ -654,7 +654,7 @@ def count_nonzero( @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "complex64", "complex128", "float32", @@ -775,7 +775,7 @@ def _is_scalar(x): # TODO: Repalce once native function becomes available. # Compute an approximation of the error function complement (1 - erf(x)). @with_supported_dtypes( - {"2.5.2 and below": ("float64", "float32")}, + {"2.6.0 and below": ("float64", "float32")}, backend_version, ) def erfc(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: diff --git a/ivy/functional/backends/paddle/experimental/layers.py b/ivy/functional/backends/paddle/experimental/layers.py index 4adb2e37d3a9b..a1942a5b4d120 100644 --- a/ivy/functional/backends/paddle/experimental/layers.py +++ b/ivy/functional/backends/paddle/experimental/layers.py @@ -30,7 +30,7 @@ def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_ @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -97,7 +97,7 @@ def max_pool1d( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -168,7 +168,7 @@ def max_pool2d( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -301,7 +301,7 @@ def dct( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "bool", "float16")}, backend_version + {"2.6.0 and below": ("bfloat16", "bool", "float16")}, backend_version ) def fft( x: paddle.Tensor, @@ -345,7 +345,7 @@ def fft( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -367,7 +367,7 @@ def dropout1d( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -389,7 +389,7 @@ def dropout2d( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("bfloat16", "float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -422,7 +422,7 @@ def ifft( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("int8", "float32", "float64"), "gpu": ("int8", "bfloat16", "float16", "float32", "float64"), }, @@ -514,7 +514,7 @@ def rfft( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "float16", "complex64", "complex128", "bool")}, + {"2.6.0 and below": ("bfloat16", "float16", "complex64", "complex128", "bool")}, backend_version, ) def rfftn( @@ -531,7 +531,7 @@ def rfftn( @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "complex64", "complex128", ) @@ -553,7 +553,7 @@ def fft2( # stft @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "complex64", "complex128", ) diff --git a/ivy/functional/backends/paddle/experimental/linear_algebra.py b/ivy/functional/backends/paddle/experimental/linear_algebra.py index aa76b96d31996..eacf1acf4278b 100644 --- a/ivy/functional/backends/paddle/experimental/linear_algebra.py +++ b/ivy/functional/backends/paddle/experimental/linear_algebra.py @@ -13,7 +13,7 @@ @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8", "int16", "uint8", "float16", "bfloat16")}}, + {"2.6.0 and below": {"cpu": ("int8", "int16", "uint8", "float16", "bfloat16")}}, backend_version, ) def diagflat( @@ -47,7 +47,7 @@ def diagflat( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8", "uint8", "int16")}}, backend_version + {"2.6.0 and below": {"cpu": ("int8", "uint8", "int16")}}, backend_version ) def kron( a: paddle.Tensor, @@ -91,7 +91,7 @@ def adjoint( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8", "uint8", "int16", "float16")}}, + {"2.6.0 and below": {"cpu": ("int8", "uint8", "int16", "float16")}}, backend_version, ) def solve_triangular( @@ -133,7 +133,7 @@ def lu_factor( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float32", "float64", @@ -168,7 +168,7 @@ def dot( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float32", "float64", diff --git a/ivy/functional/backends/paddle/experimental/losses.py b/ivy/functional/backends/paddle/experimental/losses.py index ec01230538bae..ebb90d24898aa 100644 --- a/ivy/functional/backends/paddle/experimental/losses.py +++ b/ivy/functional/backends/paddle/experimental/losses.py @@ -14,7 +14,7 @@ @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float16", "int8", @@ -42,7 +42,7 @@ def l1_loss( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -72,7 +72,7 @@ def smooth_l1_loss( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float16", "int8", @@ -100,7 +100,7 @@ def huber_loss( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float16", "int8", @@ -127,7 +127,7 @@ def soft_margin_loss( @with_supported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float32", "float64")}}, + {"2.6.0 and below": {"cpu": ("float32", "float64")}}, backend_version, ) def kl_div( @@ -195,7 +195,7 @@ def _validate_poisson_nll_params( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64"), "gpu": ("bfloat16", "float16", "float32", "float64"), } @@ -243,7 +243,7 @@ def poisson_nll_loss( @with_supported_device_and_dtypes( { - "2.5.1 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64"), "gpu": ("float16", "float32", "float64"), } diff --git a/ivy/functional/backends/paddle/experimental/manipulation.py b/ivy/functional/backends/paddle/experimental/manipulation.py index 1193133ae8366..5ddb1adb64d8c 100644 --- a/ivy/functional/backends/paddle/experimental/manipulation.py +++ b/ivy/functional/backends/paddle/experimental/manipulation.py @@ -95,7 +95,7 @@ @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int16", "int8", "uint8", @@ -121,7 +121,7 @@ def moveaxis( @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, backend_version, ) def pad( @@ -187,7 +187,7 @@ def pad( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -212,7 +212,7 @@ def heaviside( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.6.0 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def flipud( @@ -237,7 +237,7 @@ def vstack( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int16", "bfloat16")}}, + {"2.6.0 and below": {"cpu": ("int16", "bfloat16")}}, backend_version, ) def hstack( @@ -254,7 +254,7 @@ def hstack( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.6.0 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def rot90( @@ -270,7 +270,7 @@ def rot90( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def top_k( @@ -297,7 +297,7 @@ def top_k( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.6.0 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def fliplr( @@ -465,7 +465,7 @@ def atleast_2d( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version, ) def atleast_3d( @@ -490,7 +490,7 @@ def atleast_3d( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "bool", "float16", "int16", "int8", "uint8")}, + {"2.6.0 and below": ("bfloat16", "bool", "float16", "int16", "int8", "uint8")}, backend_version, ) def take_along_axis( @@ -612,7 +612,7 @@ def concat_from_sequence( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version + {"2.6.0 and below": {"cpu": ("int8", "int16", "uint8")}}, backend_version ) def unique_consecutive( x: paddle.Tensor, @@ -675,7 +675,7 @@ def unique_consecutive( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8", "int16", "uint8", "float16")}}, + {"2.6.0 and below": {"cpu": ("int8", "int16", "uint8", "float16")}}, backend_version, ) def fill_diagonal( @@ -741,7 +741,7 @@ def _take_with_axis( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("int64", "float64", "int32", "uint8", "float32", "bool") } }, @@ -878,7 +878,7 @@ def trim_zeros(a: paddle.Tensor, /, *, trim: Optional[str] = "bf") -> paddle.Ten @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def put_along_axis( arr: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/experimental/norms.py b/ivy/functional/backends/paddle/experimental/norms.py index 092dda34030b6..bfef54ffae551 100644 --- a/ivy/functional/backends/paddle/experimental/norms.py +++ b/ivy/functional/backends/paddle/experimental/norms.py @@ -12,7 +12,7 @@ # use numpy implementation with ivy functions @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -105,7 +105,7 @@ def batch_norm( ) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, backend_version) def l1_normalize( x: paddle.Tensor, /, *, axis: Optional[int] = None, out: paddle.Tensor = None ) -> paddle.Tensor: diff --git a/ivy/functional/backends/paddle/experimental/random.py b/ivy/functional/backends/paddle/experimental/random.py index 50b063a942638..462084349e2ae 100644 --- a/ivy/functional/backends/paddle/experimental/random.py +++ b/ivy/functional/backends/paddle/experimental/random.py @@ -16,7 +16,7 @@ @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", diff --git a/ivy/functional/backends/paddle/experimental/sparse_array.py b/ivy/functional/backends/paddle/experimental/sparse_array.py index 9a1f7870a323d..453ee5568e96a 100644 --- a/ivy/functional/backends/paddle/experimental/sparse_array.py +++ b/ivy/functional/backends/paddle/experimental/sparse_array.py @@ -19,7 +19,7 @@ def is_native_sparse_array(x: paddle.Tensor) -> bool: @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8",)}}, backend_version + {"2.6.0 and below": {"cpu": ("int8",)}}, backend_version ) def native_sparse_array( data=None, diff --git a/ivy/functional/backends/paddle/experimental/statistical.py b/ivy/functional/backends/paddle/experimental/statistical.py index 7572b28f0e8d0..84425deeee725 100644 --- a/ivy/functional/backends/paddle/experimental/statistical.py +++ b/ivy/functional/backends/paddle/experimental/statistical.py @@ -14,7 +14,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def median( @@ -32,7 +32,7 @@ def median( ) else: ret = paddle.median(input, axis=axis, keepdim=True) - # keepdims is set to True because in versions up to 2.5.2 + # keepdims is set to True because in versions up to 2.6.0 # there was a problem when the axis was defined, and it was the # only axis in the tensor, so it needs to be handled manually if not keepdims: @@ -48,7 +48,7 @@ def median( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64", "int64")}, backend_version + {"2.6.0 and below": ("complex", "float32", "float64", "int64")}, backend_version ) def nanmean( a: paddle.Tensor, @@ -101,7 +101,7 @@ def _validate_quantile(q): @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -140,7 +140,7 @@ def nanmin( return result -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, backend_version) def nanprod( a: paddle.Tensor, /, @@ -308,7 +308,7 @@ def _compute_quantile_wrapper( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -382,7 +382,7 @@ def histogram( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def nanmedian( input: paddle.Tensor, @@ -401,7 +401,7 @@ def nanmedian( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -433,7 +433,7 @@ def unravel_index( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -556,7 +556,7 @@ def cov( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "bool", "float32", "float64")}, + {"2.6.0 and below": ("complex", "bool", "float32", "float64")}, backend_version, ) def cummax( @@ -681,7 +681,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("uint8", "int8", "int16")}}, + {"2.6.0 and below": {"cpu": ("uint8", "int8", "int16")}}, backend_version, ) def cummin( diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 8bdb2a2a86cbc..2d1804e87c315 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -85,7 +85,7 @@ def _squeeze_helper(query, x_ndim): @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("int8", "int16", "float16", "complex64", "complex128") } }, @@ -228,7 +228,7 @@ def _gather(params1): @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, + {"2.6.0 and below": {"cpu": ("bfloat16", "float16")}}, backend_version, ) def gather_nd( diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index c39ef078758b1..0a0a9ab9b7c80 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -103,7 +103,7 @@ def grad_(x): @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version ) def execute_with_gradients( func, xs, /, *, retain_grads=False, xs_grad_idxs=((0,),), ret_grad_idxs=((0,),) diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index 878c7689a3b24..03892066f5b8d 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -159,7 +159,7 @@ def conv1d( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, + {"2.6.0 and below": {"cpu": ("float16", "bfloat16")}}, backend_version, ) def conv1d_transpose( @@ -220,7 +220,7 @@ def conv2d( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, + {"2.6.0 and below": {"cpu": ("float16", "bfloat16")}}, backend_version, ) def conv2d_transpose( @@ -281,7 +281,7 @@ def depthwise_conv2d( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version, ) def conv3d( @@ -341,7 +341,7 @@ def conv3d_transpose( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("float16",)}}, + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version, ) def conv_general_dilated( diff --git a/ivy/functional/backends/paddle/linear_algebra.py b/ivy/functional/backends/paddle/linear_algebra.py index 16592ed2f4e1d..21694a6879290 100644 --- a/ivy/functional/backends/paddle/linear_algebra.py +++ b/ivy/functional/backends/paddle/linear_algebra.py @@ -24,7 +24,7 @@ @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -91,7 +91,7 @@ def _cross(x1, x2, axisa, axisb, axisc, axis): @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def det(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: @@ -183,7 +183,7 @@ def inner( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def inv( @@ -252,7 +252,7 @@ def matmul( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_norm( @@ -334,7 +334,7 @@ def eig( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_power( @@ -344,7 +344,7 @@ def matrix_power( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def matrix_rank( @@ -441,7 +441,7 @@ def tensorsolve( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def qr( @@ -457,7 +457,7 @@ def qr( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def slogdet( @@ -476,7 +476,7 @@ def slogdet( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def solve( @@ -503,7 +503,7 @@ def solve( return ret -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, backend_version) def svd( x: paddle.Tensor, /, *, full_matrices: bool = True, compute_uv: bool = True ) -> Union[paddle.Tensor, Tuple[paddle.Tensor, ...]]: @@ -517,7 +517,7 @@ def svd( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("complex64", "complex128")}}, backend_version, ) def svdvals( @@ -532,7 +532,7 @@ def svdvals( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64")}, backend_version + {"2.6.0 and below": ("complex", "float32", "float64")}, backend_version ) def tensordot( x1: paddle.Tensor, @@ -548,7 +548,7 @@ def tensordot( @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "int8", "int16", @@ -624,7 +624,7 @@ def vector_norm( @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, backend_version, ) def diag( @@ -638,7 +638,7 @@ def diag( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("uint8", "int8", "int16", "complex64", "complex128")}}, + {"2.6.0 and below": {"cpu": ("uint8", "int8", "int16", "complex64", "complex128")}}, backend_version, ) def vander( @@ -660,7 +660,7 @@ def vander( @with_unsupported_dtypes( - {"2.5.2 and below": ("unsigned", "int8", "int16", "float16")}, + {"2.6.0 and below": ("unsigned", "int8", "int16", "float16")}, backend_version, ) def vector_to_skew_symmetric_matrix( diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index 8bc317e29c6f5..0e205ce439d39 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -74,7 +74,7 @@ def expand_dims( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.6.0 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def flip( @@ -91,7 +91,7 @@ def flip( @with_unsupported_dtypes( - {"2.5.2 and below": ("uint8", "int8", "int16", "bfloat16")}, backend_version + {"2.6.0 and below": ("uint8", "int8", "int16", "bfloat16")}, backend_version ) def permute_dims( x: paddle.Tensor, @@ -159,7 +159,7 @@ def reshape( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def roll( @@ -174,7 +174,7 @@ def roll( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "float16", "int16")}, backend_version + {"2.6.0 and below": ("bfloat16", "float16", "int16")}, backend_version ) def squeeze( x: paddle.Tensor, @@ -201,7 +201,7 @@ def squeeze( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int16", "uint8", "int8", "float16")}}, + {"2.6.0 and below": {"cpu": ("int16", "uint8", "int8", "float16")}}, backend_version, ) def stack( @@ -249,7 +249,7 @@ def stack( # ------# -@with_unsupported_dtypes({"2.5.2 and below": ("int16",)}, backend_version) +@with_unsupported_dtypes({"2.6.0 and below": ("int16",)}, backend_version) def split( x: paddle.Tensor, /, @@ -299,7 +299,7 @@ def split( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def repeat( @@ -335,7 +335,7 @@ def repeat( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, + {"2.6.0 and below": ("bfloat16", "float16", "int16", "int8", "uint8")}, backend_version, ) def tile( @@ -378,7 +378,7 @@ def tile( @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bfloat16", "float16", "int8", @@ -419,7 +419,7 @@ def zero_pad( @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int32", "int64", @@ -478,7 +478,7 @@ def clip( @with_unsupported_dtypes( - {"2.5.2 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version + {"2.6.0 and below": ("int16", "int8", "uint8", "bfloat16")}, backend_version ) def unstack( x: paddle.Tensor, diff --git a/ivy/functional/backends/paddle/random.py b/ivy/functional/backends/paddle/random.py index aa16a3d9d1666..15c10f366a1a7 100644 --- a/ivy/functional/backends/paddle/random.py +++ b/ivy/functional/backends/paddle/random.py @@ -26,7 +26,7 @@ @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8",)}}, + {"2.6.0 and below": {"cpu": ("int8",)}}, backend_version, ) def random_uniform( @@ -57,7 +57,7 @@ def random_uniform( @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "int16", "int8")}, backend_version + {"2.6.0 and below": ("float16", "int16", "int8")}, backend_version ) def random_normal( *, @@ -78,7 +78,7 @@ def random_normal( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "float32", "float64", @@ -109,7 +109,7 @@ def multinomial( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8",)}}, + {"2.6.0 and below": {"cpu": ("int8",)}}, backend_version, ) def randint( diff --git a/ivy/functional/backends/paddle/searching.py b/ivy/functional/backends/paddle/searching.py index d5c6a6ffbb9da..f64c9c97288ba 100644 --- a/ivy/functional/backends/paddle/searching.py +++ b/ivy/functional/backends/paddle/searching.py @@ -16,7 +16,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {"2.6.0 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, backend_version, ) def argmax( @@ -48,7 +48,7 @@ def argmax( @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "bool", "complex", "float16", "int8")}, + {"2.6.0 and below": ("bfloat16", "bool", "complex", "float16", "int8")}, backend_version, ) def argmin( @@ -80,7 +80,7 @@ def argmin( @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "int8", "uint8")}, backend_version + {"2.6.0 and below": ("float16", "int8", "uint8")}, backend_version ) def nonzero( x: paddle.Tensor, @@ -161,7 +161,7 @@ def where( @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "int8", "uint8")}, backend_version + {"2.6.0 and below": ("float16", "int8", "uint8")}, backend_version ) def argwhere( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None diff --git a/ivy/functional/backends/paddle/set.py b/ivy/functional/backends/paddle/set.py index 177953d137981..789218824f1d6 100644 --- a/ivy/functional/backends/paddle/set.py +++ b/ivy/functional/backends/paddle/set.py @@ -10,7 +10,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_all( x: paddle.Tensor, @@ -86,7 +86,7 @@ def unique_all( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_counts(x: paddle.Tensor, /) -> Tuple[paddle.Tensor, paddle.Tensor]: unique, counts = paddle.unique(x, return_counts=True) @@ -109,7 +109,7 @@ def unique_counts(x: paddle.Tensor, /) -> Tuple[paddle.Tensor, paddle.Tensor]: @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_inverse( x: paddle.Tensor, @@ -144,7 +144,7 @@ def unique_inverse( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def unique_values( x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None diff --git a/ivy/functional/backends/paddle/sorting.py b/ivy/functional/backends/paddle/sorting.py index 26d78dbe0cc06..f67aa6bece1b4 100644 --- a/ivy/functional/backends/paddle/sorting.py +++ b/ivy/functional/backends/paddle/sorting.py @@ -9,7 +9,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def argsort( x: paddle.Tensor, @@ -24,7 +24,7 @@ def argsort( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def sort( x: paddle.Tensor, @@ -39,7 +39,7 @@ def sort( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def searchsorted( x: paddle.Tensor, @@ -74,7 +74,7 @@ def searchsorted( @with_unsupported_device_and_dtypes( - {"2.5.2 and below": {"cpu": ("int8", "uint8", "int16", "float16", "complex")}}, + {"2.6.0 and below": {"cpu": ("int8", "uint8", "int16", "float16", "complex")}}, backend_version, ) def msort( diff --git a/ivy/functional/backends/paddle/statistical.py b/ivy/functional/backends/paddle/statistical.py index 3875bdbc2c946..9bdf6199a7f3f 100644 --- a/ivy/functional/backends/paddle/statistical.py +++ b/ivy/functional/backends/paddle/statistical.py @@ -22,7 +22,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def min( @@ -68,7 +68,7 @@ def min( @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def max( @@ -106,7 +106,7 @@ def max( @with_supported_dtypes( - {"2.5.2 and below": ("bool", "complex", "float32", "float64")}, backend_version + {"2.6.0 and below": ("bool", "complex", "float32", "float64")}, backend_version ) def mean( x: paddle.Tensor, @@ -136,7 +136,7 @@ def mean( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def prod( x: paddle.Tensor, @@ -185,7 +185,7 @@ def std( @with_unsupported_dtypes( - {"2.5.2 and below": ("int8", "int16", "uint8")}, + {"2.6.0 and below": ("int8", "int16", "uint8")}, backend_version, ) def sum( @@ -226,7 +226,7 @@ def var( # Extra # # ----- # @with_supported_dtypes( - {"2.5.2 and below": ("complex", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("complex", "float32", "float64", "int32", "int64")}, backend_version, ) def cumprod( @@ -276,7 +276,7 @@ def cumprod( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, backend_version + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version ) def cumsum( x: paddle.Tensor, @@ -325,7 +325,7 @@ def cumsum( @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64", "complex64", "complex128"), "gpu": ( "bfloat16", diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 83fa1be55a9e1..013a7e3fc26f8 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -7,7 +7,7 @@ "numpy": "1.25.2", "jax": "0.4.23", "scipy": "1.10.1", - "paddle": "2.5.2", + "paddle": "2.6.0", "sklearn": "1.3.0", "xgboost": "1.7.6", "torchvision": "0.15.2.", diff --git a/ivy/functional/frontends/jax/array.py b/ivy/functional/frontends/jax/array.py index 7e5aa872f4c04..2e049123c166a 100644 --- a/ivy/functional/frontends/jax/array.py +++ b/ivy/functional/frontends/jax/array.py @@ -74,7 +74,7 @@ def astype(self, dtype): f"Dtype {self.dtype} is not castable to {dtype}" ) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def argmax( self, /, @@ -90,7 +90,7 @@ def argmax( keepdims=keepdims, ) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def argmin( self, /, diff --git a/ivy/functional/frontends/jax/numpy/fft.py b/ivy/functional/frontends/jax/numpy/fft.py index e8c18e016caf8..d1500f394e5e1 100644 --- a/ivy/functional/frontends/jax/numpy/fft.py +++ b/ivy/functional/frontends/jax/numpy/fft.py @@ -19,7 +19,7 @@ def fft2(a, s=None, axes=(-2, -1), norm=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def fftfreq(n, d=1.0, *, dtype=None): if not isinstance( n, (int, type(ivy.int8), type(ivy.int16), type(ivy.int32), type(ivy.int64)) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 3c7b864f20500..939e47d79999f 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -90,7 +90,7 @@ def ceil(x, /): return ivy.ceil(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def clip(a, a_min=None, a_max=None, out=None): return ivy.array(ivy.clip(a, a_min, a_max), dtype=a.dtype) diff --git a/ivy/functional/frontends/numpy/logic/array_contents.py b/ivy/functional/frontends/numpy/logic/array_contents.py index 2d0c40ef64ce7..7388b57862b8d 100644 --- a/ivy/functional/frontends/numpy/logic/array_contents.py +++ b/ivy/functional/frontends/numpy/logic/array_contents.py @@ -25,7 +25,7 @@ def isclose(a, b, /, *, rtol=1e-05, atol=1e-08, equal_nan=False): @with_supported_dtypes( - {"2.5.2 and below": ("int64", "float64", "float32", "int32", "bfloat16")}, "paddle" + {"2.6.0 and below": ("int64", "float64", "float32", "int32", "bfloat16")}, "paddle" ) @to_ivy_arrays_and_back def isin(element, test_elements, assume_unique=False, invert=False): diff --git a/ivy/functional/frontends/paddle/creation.py b/ivy/functional/frontends/paddle/creation.py index 24d90399e4f8a..4cc1b8f9b0820 100644 --- a/ivy/functional/frontends/paddle/creation.py +++ b/ivy/functional/frontends/paddle/creation.py @@ -7,14 +7,14 @@ ) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def arange(start, end=None, step=1, dtype=None, name=None): return ivy.arange(start, end, step=step, dtype=dtype) @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64", "bool")}, + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64", "bool")}, "paddle", ) @to_ivy_arrays_and_back @@ -30,7 +30,7 @@ def assign(x, output=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("bfloat16", "uint16", "uint32", "uint64")}, "paddle" + {"2.6.0 and below": ("bfloat16", "uint16", "uint32", "uint64")}, "paddle" ) @to_ivy_arrays_and_back def clone(x): @@ -38,7 +38,7 @@ def clone(x): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -54,7 +54,7 @@ def complex(real, imag, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diag(x, offset=0, padding_value=0, name=None): @@ -69,7 +69,7 @@ def diag(x, offset=0, padding_value=0, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diagflat(x, offset=0, name=None): @@ -105,7 +105,7 @@ def full_like(x, fill_value, /, *, dtype=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def linspace(start, stop, num, dtype=None, name=None): @@ -113,7 +113,7 @@ def linspace(start, stop, num, dtype=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def logspace(start, stop, num, base=10.0, dtype=None, name=None): @@ -121,14 +121,14 @@ def logspace(start, stop, num, base=10.0, dtype=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def meshgrid(*args, **kwargs): return ivy.meshgrid(*args, indexing="ij") -@with_unsupported_dtypes({"2.5.2 and below": "int8"}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": "int8"}, "paddle") @to_ivy_arrays_and_back def ones(shape, /, *, dtype=None, name=None): dtype = "float32" if dtype is None else dtype @@ -136,7 +136,7 @@ def ones(shape, /, *, dtype=None, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" + {"2.6.0 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" ) @to_ivy_arrays_and_back def ones_like(x, /, *, dtype=None, name=None): @@ -152,7 +152,7 @@ def to_tensor(data, /, *, dtype=None, place=None, stop_gradient=True): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "uint8", "int8", "int16", @@ -169,7 +169,7 @@ def tril(x, diagonal=0, name=None): return ivy.tril(x, k=diagonal) -@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def tril_indices(row, col, offset=0, dtype="int64"): arr = ivy.tril_indices(row, col, offset) @@ -179,7 +179,7 @@ def tril_indices(row, col, offset=0, dtype="int64"): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "uint8", "int8", "int16", @@ -196,7 +196,7 @@ def triu(x, diagonal=0, name=None): return ivy.triu(x, k=diagonal) -@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def triu_indices(row, col=None, offset=0, dtype="int64"): arr = ivy.triu_indices(row, col, offset) @@ -206,7 +206,7 @@ def triu_indices(row, col=None, offset=0, dtype="int64"): return arr -@with_unsupported_dtypes({"2.5.2 and below": "int8"}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": "int8"}, "paddle") @to_ivy_arrays_and_back def zeros(shape, /, *, dtype=None, name=None): dtype = "float32" if dtype is None else dtype @@ -214,7 +214,7 @@ def zeros(shape, /, *, dtype=None, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" + {"2.6.0 and below": ("uint8", "int8", "complex64", "complex128")}, "paddle" ) @to_ivy_arrays_and_back def zeros_like(x, /, *, dtype=None, name=None): diff --git a/ivy/functional/frontends/paddle/fft.py b/ivy/functional/frontends/paddle/fft.py index 52139bd5427af..4068bc665bcaf 100644 --- a/ivy/functional/frontends/paddle/fft.py +++ b/ivy/functional/frontends/paddle/fft.py @@ -7,7 +7,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128")}, + {"2.6.0 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -18,7 +18,7 @@ def fft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float32", @@ -37,7 +37,7 @@ def fft2(x, s=None, axes=(-2, -1), norm="backward", name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float32", @@ -63,7 +63,7 @@ def fftfreq(n, d=1.0, dtype=None, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float32", @@ -92,7 +92,7 @@ def fftshift(x, axes=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128")}, + {"2.6.0 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -114,7 +114,7 @@ def hfft(x, n=None, axes=-1, norm="backward", name=None): @with_supported_dtypes( - {"2.5.2 and below": "complex64"}, + {"2.6.0 and below": "complex64"}, "paddle", ) @to_ivy_arrays_and_back @@ -135,7 +135,7 @@ def hfft2(x, s=None, axis=(-2, -1), norm="backward"): @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128")}, + {"2.6.0 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -145,7 +145,7 @@ def ifft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128")}, + {"2.6.0 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -156,7 +156,7 @@ def ifftn(x, s=None, axes=None, norm="backward", name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float32", @@ -184,7 +184,7 @@ def ifftshift(x, axes=None, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float32", @@ -238,7 +238,7 @@ def ihfftn(x, s=None, axes=None, norm="backward", name=None): @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128")}, + {"2.6.0 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -257,7 +257,7 @@ def irfft(x, n=None, axis=-1.0, norm="backward", name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float16", @@ -293,7 +293,7 @@ def irfft2(x, s=None, axes=(-2, -1), norm="backward"): @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128")}, + {"2.6.0 and below": ("complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -344,7 +344,7 @@ def irfftn(x, s=None, axes=None, norm="backward", name=None): return result_t -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rfft(x, n=None, axis=-1, norm="backward", name=None): return ivy.dft(x, axis=axis, inverse=False, onesided=True, dft_length=n, norm=norm) diff --git a/ivy/functional/frontends/paddle/linalg.py b/ivy/functional/frontends/paddle/linalg.py index 23d7e51f918de..559050e2dd0a9 100644 --- a/ivy/functional/frontends/paddle/linalg.py +++ b/ivy/functional/frontends/paddle/linalg.py @@ -14,7 +14,7 @@ def bincount(x, weights=None, minlength=0, name=None): # bmm -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def bmm(x, y, transpose_x=False, transpose_y=False, name=None): if len(ivy.shape(x)) != 3 or len(ivy.shape(y)) != 3: @@ -24,14 +24,14 @@ def bmm(x, y, transpose_x=False, transpose_y=False, name=None): # cholesky -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cholesky(x, /, *, upper=False, name=None): return ivy.cholesky(x, upper=upper) # cholesky_solve -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cholesky_solve(x, y, /, *, upper=False, name=None): if upper: @@ -41,7 +41,7 @@ def cholesky_solve(x, y, /, *, upper=False, name=None): # cond -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def cond(x, p=None, name=None): ret = ivy.cond(x, p=p, out=name) @@ -51,7 +51,7 @@ def cond(x, p=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def cross(x, y, /, *, axis=9, name=None): @@ -62,7 +62,7 @@ def cross(x, y, /, *, axis=9, name=None): # diagonal @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float64", @@ -87,7 +87,7 @@ def dist(x, y, p=2): # dot -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def dot(x, y, name=None): x, y = promote_types_of_paddle_inputs(x, y) @@ -151,7 +151,7 @@ def lu_unpack(lu_data, lu_pivots, unpack_datas=True, unpack_pivots=True, *, out= # matmul -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def matmul(x, y, transpose_x=False, transpose_y=False, name=None): x, y = promote_types_of_paddle_inputs(x, y) @@ -159,21 +159,21 @@ def matmul(x, y, transpose_x=False, transpose_y=False, name=None): # matrix_power -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def matrix_power(x, n, name=None): return ivy.matrix_power(x, n) # mv -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def mv(x, vec, name=None): return ivy.dot(x, vec) # norm -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def norm(x, p="fro", axis=None, keepdim=False, name=None): if axis is None and p is not None: @@ -226,7 +226,7 @@ def norm(x, p="fro", axis=None, keepdim=False, name=None): # pinv -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def pinv(x, rcond=1e-15, hermitian=False, name=None): # TODO: Add hermitian functionality @@ -234,21 +234,21 @@ def pinv(x, rcond=1e-15, hermitian=False, name=None): # qr -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def qr(x, mode="reduced", name=None): return ivy.qr(x, mode=mode) # solve -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def solve(x, y, name=None): return ivy.solve(x, y) # transpose -@with_unsupported_dtypes({"2.5.2 and below": ("uint8", "int8", "int16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("uint8", "int8", "int16")}, "paddle") @to_ivy_arrays_and_back def transpose(x, perm, name=None): return ivy.permute_dims(x, axes=perm) diff --git a/ivy/functional/frontends/paddle/logic.py b/ivy/functional/frontends/paddle/logic.py index 220d26ded9aaf..45bb6cd12fc10 100644 --- a/ivy/functional/frontends/paddle/logic.py +++ b/ivy/functional/frontends/paddle/logic.py @@ -13,7 +13,7 @@ @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float32", "float64", "bool", @@ -35,7 +35,7 @@ def allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -54,7 +54,7 @@ def bitwise_and(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -73,7 +73,7 @@ def bitwise_not(x, out=None, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -92,7 +92,7 @@ def bitwise_or(x, y, name=None, out=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -110,7 +110,7 @@ def bitwise_xor(x, y, /, *, name=None, out=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + {"2.6.0 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -120,7 +120,7 @@ def equal(x, y, /, *, name=None): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "uint8", "int8", "int16", @@ -137,7 +137,7 @@ def equal_all(x, y, /, *, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {"2.6.0 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -146,7 +146,7 @@ def greater_equal(x, y, /, *, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {"2.6.0 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -155,7 +155,7 @@ def greater_than(x, y, /, *, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + {"2.6.0 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -170,7 +170,7 @@ def is_tensor(x): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float32", "float64", ) @@ -183,7 +183,7 @@ def isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, + {"2.6.0 and below": ("bool", "uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -192,7 +192,7 @@ def less_equal(x, y, /, *, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -202,7 +202,7 @@ def less_than(x, y, /, *, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -222,7 +222,7 @@ def logical_and(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -242,7 +242,7 @@ def logical_not(x, /, *, name=None, out=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -262,7 +262,7 @@ def logical_or(x, y, /, *, name=None, out=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -281,7 +281,7 @@ def logical_xor(x, y, /, *, name=None, out=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, + {"2.6.0 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/manipulation.py b/ivy/functional/frontends/paddle/manipulation.py index e8f59e91960a5..2cb0974b00a7f 100644 --- a/ivy/functional/frontends/paddle/manipulation.py +++ b/ivy/functional/frontends/paddle/manipulation.py @@ -10,14 +10,14 @@ ) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def abs(x, name=None): return ivy.abs(x) @with_supported_dtypes( - {"2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -27,7 +27,7 @@ def broadcast_to(x, shape, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "float16", "float32", @@ -44,14 +44,14 @@ def cast(x, dtype): return ivy.astype(x, dtype) -@with_unsupported_dtypes({"2.5.2 and below": ("int8", "int16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("int8", "int16")}, "paddle") @to_ivy_arrays_and_back def concat(x, axis, name=None): return ivy.concat(x, axis=axis) @with_supported_dtypes( - {"2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -60,7 +60,7 @@ def expand(x, shape, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("int8", "uint8", "int16", "float16")}, + {"2.6.0 and below": ("int8", "uint8", "int16", "float16")}, "paddle", ) @to_ivy_arrays_and_back @@ -69,7 +69,7 @@ def flip(x, axis, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("bool", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("bool", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -78,7 +78,7 @@ def gather(params, indices, axis=-1, batch_dims=0, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, + {"2.6.0 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, "paddle", ) @to_ivy_arrays_and_back @@ -87,7 +87,7 @@ def gather_nd(x, index, name=None): @with_supported_dtypes( - {"2.5.1 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + {"2.6.0 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -124,7 +124,7 @@ def put_along_axis(arr, indices, values, axis, reduce="assign"): @with_supported_dtypes( - {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, + {"2.6.0 and below": ("int32", "int64", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -157,7 +157,7 @@ def roll(x, shifts, axis=None, name=None): @with_supported_device_and_dtypes( { - "2.5.2 and above": { + "2.6.0 and above": { "cpu": ( "bool", "int32", @@ -176,7 +176,7 @@ def rot90(x, k=1, axes=(0, 1), name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("int16", "complex64", "complex128")}, + {"2.6.0 and below": ("int16", "complex64", "complex128")}, "paddle", ) @to_ivy_arrays_and_back @@ -185,7 +185,7 @@ def split(x, num_or_sections, axis=0, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "bfloat16", "int8", "int16")}, + {"2.6.0 and below": ("float16", "bfloat16", "int8", "int16")}, "paddle", ) @to_ivy_arrays_and_back @@ -203,7 +203,7 @@ def take_along_axis(arr, indices, axis): @with_unsupported_dtypes( - {"2.5.2 and below": ("int8", "uint8", "int16", "float16")}, + {"2.6.0 and below": ("int8", "uint8", "int16", "float16")}, "paddle", ) @to_ivy_arrays_and_back @@ -217,7 +217,7 @@ def tolist(x): @with_supported_dtypes( - {"2.5.2 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + {"2.6.0 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -229,7 +229,7 @@ def unbind(input, axis=0): @with_supported_dtypes( - {"2.5.2 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + {"2.6.0 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -239,7 +239,7 @@ def unique_consecutive(x, axis=0): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float32", "float64", "int32", diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index f81f5b5f89584..252d8f1be9c93 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -8,26 +8,26 @@ from ivy.functional.frontends.paddle.func_wrapper import to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def abs(x, name=None): return ivy.abs(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def acos(x, name=None): return ivy.acos(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def acosh(x, name=None): return ivy.acosh(x) @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" ) @to_ivy_arrays_and_back def add(x, y, name=None): @@ -35,7 +35,7 @@ def add(x, y, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle" ) @to_ivy_arrays_and_back def add_(x, y, name=None): @@ -43,7 +43,7 @@ def add_(x, y, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def addmm(input, x, y, beta=1.0, alpha=1.0, name=None): @@ -58,7 +58,7 @@ def all(x, axis, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def amax(x, axis=None, keepdims=False): @@ -76,7 +76,7 @@ def amax(x, axis=None, keepdims=False): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def amin(x, axis=None, keepdim=False, name=None): @@ -84,7 +84,7 @@ def amin(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128", "float32", "float64")}, + {"2.6.0 and below": ("complex64", "complex128", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -98,19 +98,19 @@ def any(x, axis=None, keepdim=False, name=None): return ivy.any(x, axis=axis, keepdims=keepdim) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def asin(x, name=None): return ivy.asin(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def asinh(x, name=None): return ivy.asinh(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def atan(x, name=None): return ivy.atan(x) @@ -122,19 +122,19 @@ def atan2(x, y, name=None): return ivy.atan2(x, y) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def atanh(x, name=None): return ivy.atanh(x) -@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def broadcast_shape(x_shape, y_shape): return ivy.broadcast_shapes(x_shape, y_shape) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def ceil(x, name=None): return ivy.ceil(x) @@ -146,20 +146,20 @@ def conj(x, name=None): return ivy.conj(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def cos(x, name=None): return ivy.cos(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def cosh(x, name=None): return ivy.cosh(x) @with_supported_dtypes( - {"2.5.2 and below": ("int32", "int64", "float16", "float32", "float64", "bool")}, + {"2.6.0 and below": ("int32", "int64", "float16", "float32", "float64", "bool")}, "paddle", ) @to_ivy_arrays_and_back @@ -169,7 +169,7 @@ def count_nonzero(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float32", @@ -186,14 +186,14 @@ def cumprod(x, dim=None, dtype=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def cumsum(x, axis=None, dtype=None, name=None): return ivy.cumsum(x, axis=axis, dtype=dtype) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def deg2rad(x, name=None): return ivy.deg2rad(x) @@ -201,7 +201,7 @@ def deg2rad(x, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float64", @@ -219,53 +219,53 @@ def diagonal(x, offset=0, axis1=0, axis2=1, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def diff(x, n=1, axis=-1, prepend=None, append=None, name=None): return ivy.diff(x, n=n, axis=axis, prepend=prepend, append=append) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def digamma(x, name=None): digamma_fun = ivy.digamma return ivy.array(digamma_fun(x), dtype=x.dtype) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def divide(x, y, name=None): return ivy.divide(x, y) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def erf(x, name=None): return ivy.erf(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def exp(x, name=None): return ivy.exp(x) -@with_supported_dtypes({"2.5.2 and below": ("float16", "float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float16", "float32", "float64")}, "paddle") @to_ivy_arrays_and_back def expm1(x, name=None): return ivy.expm1(x) @with_supported_dtypes( - {"2.5.2 and below": ("bfloat16", "float32", "float64")}, "paddle" + {"2.6.0 and below": ("bfloat16", "float32", "float64")}, "paddle" ) @to_ivy_arrays_and_back def floor(x, name=None): return ivy.floor(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def floor_divide(x, y, name=None): return ivy.floor_divide(x, y) @@ -273,7 +273,7 @@ def floor_divide(x, y, name=None): @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64", "int32", "int64"), "gpu": ("float16", "float32", "float64", "int32", "int64"), } @@ -285,20 +285,20 @@ def floor_mod(x, y, name=None): return ivy.remainder(x, y) -@with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": "bfloat16"}, "paddle") @to_ivy_arrays_and_back def fmax(x, y, name=None): return ivy.fmax(x, y) -@with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": "bfloat16"}, "paddle") @to_ivy_arrays_and_back def fmin(x, y, name=None): return ivy.fmin(x, y) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def frac(x, name=None): @@ -306,21 +306,21 @@ def frac(x, name=None): return ivy.subtract(x, y) -@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def gcd(x, y, name=None): return ivy.gcd(x, y) @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def heaviside(x, y, name=None): return ivy.heaviside(x, y) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def inner(x, y, name=None): result = ivy.inner(x, y) @@ -331,14 +331,14 @@ def inner(x, y, name=None): return result -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def inverse(x, name=None): return ivy.inv(x) @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isfinite(x, name=None): @@ -346,7 +346,7 @@ def isfinite(x, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isinf(x, name=None): @@ -354,7 +354,7 @@ def isinf(x, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def isnan(x, name=None): @@ -362,62 +362,62 @@ def isnan(x, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def kron(x, y, name=None): return ivy.kron(x, y) -@with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, "paddle") @to_ivy_arrays_and_back def lcm(x, y, name=None): return ivy.lcm(x, y) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lerp(x, y, weight, name=None): return ivy.lerp(x, y, weight) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lgamma(x, name=None): return ivy.lgamma(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def log(x, name=None): return ivy.log(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log10(x, name=None): return ivy.log10(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log1p(x, name=None): return ivy.log1p(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log2(x, name=None): return ivy.log2(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def logit(x, eps=None, name=None): return ivy.logit(x, eps=eps) -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def logsumexp(x, axis=None, y=None): x = ivy.asarray(x) @@ -441,7 +441,7 @@ def logsumexp(x, axis=None, y=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def max(x, axis=None, keepdim=False, name=None): @@ -449,14 +449,14 @@ def max(x, axis=None, keepdim=False, name=None): # maximum -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def maximum(x, y, name=None): return ivy.maximum(x, y) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def min(x, axis=None, keepdim=False, name=None): @@ -464,7 +464,7 @@ def min(x, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def minimum(x, y, name=None): @@ -472,27 +472,27 @@ def minimum(x, y, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def mm(input, mat2, name=None): return ivy.matmul(input, mat2) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def multiply(x, y, name=None): return ivy.multiply(x, y) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def nanmean(x, axis=None, keepdims=False): return ivy.nanmean(x, axis=axis, keepdims=keepdims) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def nansum(x, axis=None, dtype=None, name=None): @@ -500,7 +500,7 @@ def nansum(x, axis=None, dtype=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int8", "int16", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -508,39 +508,39 @@ def neg(x, name=None): return ivy.negative(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def outer(x, y, name=None): return ivy.outer(x, y) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def pow(x, y, name=None): return ivy.pow(x, y) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def prod(x, axis=None, keepdim=False, dtype=None, name=None): return ivy.prod(x, axis=axis, keepdims=keepdim, dtype=dtype) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def rad2deg(x, name=None): return ivy.rad2deg(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def reciprocal(x, name=None): return ivy.reciprocal(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def remainder(x, y, name=None): return ivy.remainder(x, y) @@ -548,7 +548,7 @@ def remainder(x, y, name=None): @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("float32", "float64"), "gpu": ("float16", "float32", "float64"), } @@ -560,7 +560,7 @@ def remainder_(x, y, name=None): return ivy.inplace_update(x, remainder(x, y)) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def round(x, name=None): sign = ivy.sign(x) @@ -568,49 +568,49 @@ def round(x, name=None): return x -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rsqrt(x, name=None): return 1 / ivy.sqrt(x) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sgn(x, name=None): return ivy.sign(x, np_variant=True) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sign(x, name=None): return ivy.sign(x, np_variant=False) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def sin(x, name=None): return ivy.sin(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sinh(x, name=None): return ivy.sinh(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sqrt(x, name=None): return ivy.sqrt(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def square(x, name=None): return ivy.square(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def stanh(x, scale_a=0.67, scale_b=1.7159, name=None): # TODO this function will be simplified as soon as the ivy.stanh(x,a,b) is added @@ -622,7 +622,7 @@ def stanh(x, scale_a=0.67, scale_b=1.7159, name=None): return ret -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def subtract(x, y, name=None): return ivy.subtract(x, y) @@ -630,7 +630,7 @@ def subtract(x, y, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float64", "int64", ) @@ -648,7 +648,7 @@ def sum(x, axis=None, dtype=None, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int6")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int6")}, "paddle" ) @to_ivy_arrays_and_back def take( @@ -670,20 +670,20 @@ def take( return ivy.gather(x, index, axis=0) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def tan(x, name=None): return ivy.tan(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanh(x, name=None): return ivy.tanh(x) @with_supported_dtypes( - {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {"2.6.0 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) @to_ivy_arrays_and_back def trace(x, offset=0, axis1=0, axis2=1, name=None): diff --git a/ivy/functional/frontends/paddle/nn/functional/activation.py b/ivy/functional/frontends/paddle/nn/functional/activation.py index f8621b7f3f998..da520c585e761 100644 --- a/ivy/functional/frontends/paddle/nn/functional/activation.py +++ b/ivy/functional/frontends/paddle/nn/functional/activation.py @@ -8,7 +8,7 @@ tanh = paddle_tanh -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def celu( x, @@ -20,7 +20,7 @@ def celu( return ivy.celu(x, alpha=alpha) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def elu( x, @@ -32,13 +32,13 @@ def elu( return ivy.elu(x, alpha=alpha) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def gelu(x, approximate=False, name=None): return ivy.gelu(x, approximate=approximate) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def glu(x, axis=-1, name=None): size = x.shape[axis] @@ -63,21 +63,21 @@ def gumbel_softmax(x, temperature=1.0, hard=False, axis=-1, name=None): return y_soft -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardshrink(x, threshold=0.5, name=None): mask = ivy.logical_or(ivy.greater(x, threshold), ivy.less(x, -threshold)) return ivy.where(mask, x, 0.0) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardsigmoid(x, slope=0.1666667, offset=0.5, name=None): ret = ivy.minimum(ivy.maximum(ivy.add(ivy.multiply(x, slope), offset), 0), 1) return ret -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardswish(x, name=None): relu6_val = ivy.relu6(ivy.add(x, 3)) @@ -85,7 +85,7 @@ def hardswish(x, name=None): return ret -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def hardtanh( x, @@ -106,13 +106,13 @@ def leaky_relu(x, negative_slope=0.01, name=None): return ivy.leaky_relu(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log_sigmoid(x, name=None): return -ivy.softplus(-x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def log_softmax(x, axis=-1, dtype=None, name=None): x = ivy.astype(x, dtype) if dtype else x @@ -121,31 +121,31 @@ def log_softmax(x, axis=-1, dtype=None, name=None): return ret -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def mish(x, name=None): return ivy.mish(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def prelu(x, weight, data_format="NCHW", name=None): return ivy.add(ivy.maximum(0, x), ivy.multiply(weight, ivy.minimum(0, x))) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu(x, name=None): return ivy.relu(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu6(x, name=None): return ivy.relu6(x) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def relu_(x, name=None): ret = ivy.relu(x) @@ -153,7 +153,7 @@ def relu_(x, name=None): return x -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def rrelu( x, @@ -189,7 +189,7 @@ def rrelu( return out.astype(x.dtype) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def selu( x, @@ -222,13 +222,13 @@ def softmax_(x, axis=-1, dtype=None, name=None): return x -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softplus(x, beta=1, threshold=20, name=None): return ivy.softplus(x, beta=beta, threshold=threshold) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softshrink( x, @@ -243,7 +243,7 @@ def softshrink( return ivy.astype(add, x.dtype) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def softsign( x, @@ -254,7 +254,7 @@ def softsign( return ivy.divide(x, ivy.add(1, ivy.abs(x))) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def swish(x, name=None): return ivy.multiply(x, ivy.sigmoid(x)) @@ -273,7 +273,7 @@ def tanh_(x, name=None): # return ret.astype(x.dtype) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanhshrink( x, diff --git a/ivy/functional/frontends/paddle/nn/functional/common.py b/ivy/functional/frontends/paddle/nn/functional/common.py index 4f513b23cf5a9..882ce9a543f64 100644 --- a/ivy/functional/frontends/paddle/nn/functional/common.py +++ b/ivy/functional/frontends/paddle/nn/functional/common.py @@ -5,7 +5,7 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def cosine_similarity(x1, x2, *, axis=1, eps=1e-08): if len(x1.shape) == len(x2.shape) and len(x2.shape) >= 2: numerator = ivy.sum(x1 * x2, axis=axis) @@ -26,7 +26,7 @@ def cosine_similarity(x1, x2, *, axis=1, eps=1e-08): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def dropout(x, p=0.5, axis=None, training=True, mode="upscale_in_train", name=None): if axis is not None and axis > 1: raise ValueError("Axis value can only be 0 or 1 or None.") @@ -53,13 +53,13 @@ def dropout(x, p=0.5, axis=None, training=True, mode="upscale_in_train", name=No @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def dropout2d(x, *, p=0.5, training=True, data_format="NCHW", name=None): return ivy.dropout2d(x, p, training=training, data_format=data_format) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def dropout3d(x, p=0.5, training=True, data_format="NCDHW", name=None): return ivy.dropout3d(x, p, training=training, data_format=data_format) @@ -74,7 +74,7 @@ def get_mask(shape, device, prob, seed=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def interpolate( x, size=None, @@ -91,14 +91,14 @@ def interpolate( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def linear(x, weight, bias=None, name=None): weight = ivy.swapaxes(weight, -1, -2) return ivy.linear(x, weight, bias=bias) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): # Input checking if isinstance(kernel_sizes, int): @@ -178,7 +178,7 @@ def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def zeropad2d(x, padding, data_format="NCHW", name=None): if ivy.is_array(padding): padding = padding.to_list() diff --git a/ivy/functional/frontends/paddle/nn/functional/conv.py b/ivy/functional/frontends/paddle/nn/functional/conv.py index 296ba22e4237c..43e7699eba218 100644 --- a/ivy/functional/frontends/paddle/nn/functional/conv.py +++ b/ivy/functional/frontends/paddle/nn/functional/conv.py @@ -79,7 +79,7 @@ def _conv_transpose( # ------------ # -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv1d( x, @@ -95,7 +95,7 @@ def conv1d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv1d_transpose( x, @@ -115,7 +115,7 @@ def conv1d_transpose( ) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv2d( x, @@ -131,7 +131,7 @@ def conv2d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv2d_transpose( x, @@ -151,7 +151,7 @@ def conv2d_transpose( ) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv3d( x, @@ -167,7 +167,7 @@ def conv3d( return _conv(x, weight, bias, stride, padding, dilation, groups, data_format) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def conv3d_transpose( x, diff --git a/ivy/functional/frontends/paddle/nn/functional/loss.py b/ivy/functional/frontends/paddle/nn/functional/loss.py index 5951a446501b8..41cf9f9ab8d1e 100644 --- a/ivy/functional/frontends/paddle/nn/functional/loss.py +++ b/ivy/functional/frontends/paddle/nn/functional/loss.py @@ -47,7 +47,7 @@ def _pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): # ------------ # -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def binary_cross_entropy(input, label, weight=None, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -59,7 +59,7 @@ def binary_cross_entropy(input, label, weight=None, reduction="mean", name=None) @with_supported_dtypes( - {"2.5.2 and below": ("float32",)}, + {"2.6.0 and below": ("float32",)}, "paddle", ) @inputs_to_ivy_arrays @@ -83,7 +83,7 @@ def binary_cross_entropy_with_logits( @handle_exceptions @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def cosine_embedding_loss( input1, input2, label, margin=0.0, reduction="mean", name=None ): @@ -124,7 +124,7 @@ def cosine_embedding_loss( return out -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def dice_loss(input, label, epsilon=0.00001, name=None): ivy.assertions.check_true( @@ -163,7 +163,7 @@ def dice_loss(input, label, epsilon=0.00001, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32",)}, + {"2.6.0 and below": ("float32",)}, "paddle", ) @to_ivy_arrays_and_back @@ -187,7 +187,7 @@ def hinge_embedding_loss(input, label, margin=1.0, reduction="mean"): return loss -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def kl_div( input, @@ -234,7 +234,7 @@ def l1_loss( @with_supported_dtypes( - {"2.5.2 and below": ("float32",)}, + {"2.6.0 and below": ("float32",)}, "paddle", ) @to_ivy_arrays_and_back @@ -245,7 +245,7 @@ def log_loss(input, label, epsilon=0.0001, name=None): return out -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def margin_ranking_loss(input, other, label, margin=0.0, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -265,7 +265,7 @@ def margin_ranking_loss(input, other, label, margin=0.0, reduction="mean", name= return out -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @inputs_to_ivy_arrays def mse_loss(input, label, reduction="mean", name=None): reduction = _get_reduction_func(reduction) @@ -275,7 +275,7 @@ def mse_loss(input, label, reduction="mean", name=None): return paddle.to_tensor(ret) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def multi_label_soft_margin_loss( input, label, weight=None, reduction="mean", name=None @@ -293,7 +293,7 @@ def multi_label_soft_margin_loss( return ret -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def nll_loss( input, @@ -326,7 +326,7 @@ def nll_loss( return output -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sigmoid_focal_loss( logit, @@ -372,7 +372,7 @@ def sigmoid_focal_loss( return loss -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def smooth_l1_loss( input, @@ -399,7 +399,7 @@ def smooth_l1_loss( @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @inputs_to_ivy_arrays @@ -459,13 +459,13 @@ def softmax_with_cross_entropy( return paddle.to_tensor(loss) -@with_supported_dtypes({"2.5.2 and below": ("float32",)}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32",)}, "paddle") @to_ivy_arrays_and_back def square_error_cost(input, label): return ivy.square(ivy.subtract(input, label)) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def triplet_margin_loss( input, diff --git a/ivy/functional/frontends/paddle/nn/functional/norm.py b/ivy/functional/frontends/paddle/nn/functional/norm.py index 392abafeca45b..0090bb9ac5a9f 100644 --- a/ivy/functional/frontends/paddle/nn/functional/norm.py +++ b/ivy/functional/frontends/paddle/nn/functional/norm.py @@ -5,13 +5,13 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def layer_norm(x, normalized_shape, weight=None, bias=None, epsilon=1e-05, name=None): return ivy.layer_norm(x, normalized_shape, scale=weight, offset=bias, eps=epsilon) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def normalize(x, p=2, axis=1, epsilon=1e-12, name=None): if axis < 0: axis = ivy.get_num_dims(x) + axis diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py index 261176db7211c..219b73f8a47b7 100644 --- a/ivy/functional/frontends/paddle/nn/functional/pooling.py +++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py @@ -7,13 +7,13 @@ @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def adaptive_avg_pool1d(x, output_size, name=None): return ivy.adaptive_avg_pool1d(x, output_size) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def adaptive_avg_pool2d(x, output_size, data_format="NCHW", name=None): return ivy.adaptive_avg_pool2d(x, output_size, data_format=data_format) @@ -25,13 +25,13 @@ def adaptive_avg_pool3d(x, output_size, data_format="NCHW", name=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def adaptive_max_pool2d(x, output_size, return_mask=None, name=None): return ivy.adaptive_max_pool2d(x, output_size) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def avg_pool1d( x, kernel_size, stride=None, padding=0, exclusive=True, ceil_mode=False, name=None ): @@ -61,7 +61,7 @@ def avg_pool1d( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def avg_pool2d( x, kernel_size, @@ -99,7 +99,7 @@ def avg_pool2d( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def max_pool2d( x, kernel_size, @@ -133,7 +133,7 @@ def max_pool2d( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def max_unpool1d( x, indices, diff --git a/ivy/functional/frontends/paddle/nn/functional/vision.py b/ivy/functional/frontends/paddle/nn/functional/vision.py index 73fcae0c89e1b..bc7b222e83ea8 100644 --- a/ivy/functional/frontends/paddle/nn/functional/vision.py +++ b/ivy/functional/frontends/paddle/nn/functional/vision.py @@ -9,7 +9,7 @@ @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def affine_grid(theta, out_shape, align_corners=True): if len(out_shape) == 4: N, C, H, W = out_shape @@ -75,7 +75,7 @@ def affine_grid(theta, out_shape, align_corners=True): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def channel_shuffle(x, groups, data_format="NCHW", name=None): if len(ivy.shape(x)) != 4: raise ValueError( diff --git a/ivy/functional/frontends/paddle/random.py b/ivy/functional/frontends/paddle/random.py index 2a436935b9933..dafb52ffd7ece 100644 --- a/ivy/functional/frontends/paddle/random.py +++ b/ivy/functional/frontends/paddle/random.py @@ -8,7 +8,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -18,7 +18,7 @@ def multinomial(x, num_samples=1, replacement=False, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -27,7 +27,7 @@ def normal(mean=0.0, std=1.0, shape=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -37,7 +37,7 @@ def poisson(x, name=None): @with_supported_device_and_dtypes( { - "2.5.2 and above": { + "2.6.0 and above": { "cpu": ( "bfloat16", "float32", @@ -75,7 +75,7 @@ def randint(low=0, high=None, shape=[1], dtype=None, name=None): @with_unsupported_dtypes( - {"2.5.2 and below": ("int16", "float16", "bfloat16", "uint8")}, + {"2.6.0 and below": ("int16", "float16", "bfloat16", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -99,7 +99,7 @@ def randn(shape, dtype=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -108,7 +108,7 @@ def standard_normal(shape, dtype=None, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/search.py b/ivy/functional/frontends/paddle/search.py index c26923d08ae2e..29608b493561c 100644 --- a/ivy/functional/frontends/paddle/search.py +++ b/ivy/functional/frontends/paddle/search.py @@ -7,7 +7,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {"2.6.0 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -16,7 +16,7 @@ def argmax(x, /, *, axis=None, keepdim=False, dtype="int64", name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, + {"2.6.0 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")}, "paddle", ) @to_ivy_arrays_and_back @@ -34,7 +34,7 @@ def argsort(x, /, *, axis=-1, descending=False, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, + {"2.6.0 and below": ("int32", "int64", "float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -44,7 +44,7 @@ def index_sample(x, index): # kthvalue @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def kthvalue(x, k, axis=None, keepdim=False, name=None): @@ -65,7 +65,7 @@ def kthvalue(x, k, axis=None, keepdim=False, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -86,7 +86,7 @@ def nonzero(input, /, *, as_tuple=False): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -102,7 +102,7 @@ def searchsorted(sorted_sequence, values, out_int32=False, right=False, name=Non @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -111,7 +111,7 @@ def sort(x, /, *, axis=-1, descending=False, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -121,7 +121,7 @@ def topk(x, k, axis=None, largest=True, sorted=True, name=None): # where @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/stat.py b/ivy/functional/frontends/paddle/stat.py index 1ee6edd5ce54d..1c2310e48b5ea 100644 --- a/ivy/functional/frontends/paddle/stat.py +++ b/ivy/functional/frontends/paddle/stat.py @@ -6,7 +6,7 @@ ) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def mean(input, axis=None, keepdim=False, out=None): ret = ivy.mean(input, axis=axis, keepdims=keepdim, out=out) @@ -14,7 +14,7 @@ def mean(input, axis=None, keepdim=False, out=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -37,7 +37,7 @@ def nanmedian(x, axis=None, keepdim=True, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, "paddle", ) @to_ivy_arrays_and_back @@ -51,7 +51,7 @@ def numel(x, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "uint16")}, + {"2.6.0 and below": ("float32", "float64", "uint16")}, "paddle", ) @to_ivy_arrays_and_back @@ -64,7 +64,7 @@ def std(x, axis=None, unbiased=True, keepdim=False, name=None): return ivy.std(x, axis=axis, correction=int(unbiased), keepdims=keepdim) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def var(x, axis=None, unbiased=True, keepdim=False, name=None): if unbiased: diff --git a/ivy/functional/frontends/paddle/tensor/manipulation.py b/ivy/functional/frontends/paddle/tensor/manipulation.py index 5300c5ba213d9..db6320542ee2d 100644 --- a/ivy/functional/frontends/paddle/tensor/manipulation.py +++ b/ivy/functional/frontends/paddle/tensor/manipulation.py @@ -12,7 +12,7 @@ @with_unsupported_dtypes( - {"2.5.2 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, + {"2.6.0 and below": ("int8", "uint8", "int16", "uint16", "float16", "bfloat16")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/tensor/math.py b/ivy/functional/frontends/paddle/tensor/math.py index ceb36b11d7310..6332b1636a37d 100644 --- a/ivy/functional/frontends/paddle/tensor/math.py +++ b/ivy/functional/frontends/paddle/tensor/math.py @@ -9,14 +9,14 @@ # Please add non-inplace counterparts to `/frontends/paddle/math.py`. -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def ceil_(x, name=None): return ivy.ceil(x, out=x) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def clip_(x, min=None, max=None, name=None): @@ -38,54 +38,54 @@ def clip_(x, min=None, max=None, name=None): return res -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def exp_(x, name=None): return ivy.inplace_update(x, exp(x)) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def floor_(x, name=None): return ivy.inplace_update(x, floor(x)) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def lerp_(x, y, weight, name=None): return ivy.inplace_update(x, lerp(x, y, weight)) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def reciprocal_(x, name=None): return ivy.inplace_update(x, reciprocal(x)) -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def round_(x, name=None): return ivy.inplace_update(x, round(x)) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def rsqrt_(x, name=None): return ivy.inplace_update(x, reciprocal(sqrt(x))) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def sqrt_(x, name=None): return ivy.inplace_update(x, sqrt(x)) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def subtract_(x, y, name=None): return ivy.inplace_update(x, subtract(x, y)) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def tanh_(x, name=None): return ivy.inplace_update(x, tanh(x)) diff --git a/ivy/functional/frontends/paddle/tensor/random.py b/ivy/functional/frontends/paddle/tensor/random.py index dd6be26c2f4f2..31e370942c6ad 100644 --- a/ivy/functional/frontends/paddle/tensor/random.py +++ b/ivy/functional/frontends/paddle/tensor/random.py @@ -12,7 +12,7 @@ @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back @@ -21,7 +21,7 @@ def exponential_(x, lam=1.0, name=None): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64")}, + {"2.6.0 and below": ("float32", "float64")}, "paddle", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 0e9cba69b82b8..059b777c6c4b7 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -62,28 +62,28 @@ def ivy_array(self, array): # -------------------# @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __add__(self, y, /, name=None): return paddle_frontend.add(self, y) @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __radd__(self, x, /, name=None): return paddle_frontend.add(self, x) @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __sub__(self, y, /, name=None): return paddle_frontend.subtract(self, y) @with_unsupported_dtypes( - {"2.5.2 and below": ("uint8", "int8", "int16", "float16", "bfloat16")}, + {"2.6.0 and below": ("uint8", "int8", "int16", "float16", "bfloat16")}, "paddle", ) def __mul__(self, y, /, name=None): @@ -91,7 +91,7 @@ def __mul__(self, y, /, name=None): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -107,7 +107,7 @@ def __gt__(self, y, /, name=None): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -123,7 +123,7 @@ def __lt__(self, y, /, name=None): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -139,7 +139,7 @@ def __ge__(self, y, /, name=None): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -155,7 +155,7 @@ def __le__(self, y, /, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -170,7 +170,7 @@ def __or__(self, y, /, name=None): return paddle_frontend.logic.bitwise_or(self, y) @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __rsub__(self, x, /, name=None): @@ -186,11 +186,11 @@ def __setitem__(self, item, value): "ivy.functional.frontends.paddle.Tensor object doesn't support assignment" ) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def __floordiv__(self, y, /, name=None): return paddle_frontend.floor_divide(self, y) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def __ne__(self, y, /, name=None): return paddle_frontend.not_equal(self, y) @@ -201,14 +201,14 @@ def __iter__(self): yield self[i] @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __rmul__(self, y, /, name=None): return paddle_frontend.multiply(self, y) @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __float__(self): @@ -227,21 +227,21 @@ def __neg__(self): return paddle_frontend.neg(self) @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __rdiv__(self, y, /, name=None): return paddle_frontend.divide(y, self) @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __rtruediv__(self, y, /, name=None): return paddle_frontend.divide(y, self) @with_unsupported_dtypes( - {"2.5.2 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, + {"2.6.0 and below": ("bool", "unsigned", "int8", "float16", "bfloat16")}, "paddle", ) def __int__(self): @@ -249,7 +249,7 @@ def __int__(self): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "unsigned", "int8", @@ -307,47 +307,47 @@ def reshape_(self, *args, shape=None): def dim(self): return self.ivy_array.ndim - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def abs(self): return paddle_frontend.abs(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def acosh(self, name=None): return paddle_frontend.acosh(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def add_n(self, inputs, name=None): inputs = ivy.array(inputs) return ivy.sum(inputs, dtype=inputs.dtype, axis=0) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def ceil(self): return paddle_frontend.ceil(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def ceil_(self): self.ivy_array = self.ceil().ivy_array return self - @with_unsupported_dtypes({"2.5.2 and below": ("complex", "int8")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("complex", "int8")}, "paddle") def numel(self): return paddle_frontend.numel(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16",)}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16",)}, "paddle") def asinh(self, name=None): return paddle_frontend.asinh(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def asin(self, name=None): return paddle_frontend.asin(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def cosh(self, name=None): return paddle_frontend.cosh(self) @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "int32", "int64", "float64", @@ -362,101 +362,101 @@ def cosh(self, name=None): def diagonal(self, offset, axis1=0, axis2=1, name=None): return paddle_frontend.diagonal(self, offset=offset, axis1=axis1, axis2=axis2) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def log(self, name=None): return paddle_frontend.log(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def sin(self, name=None): return paddle_frontend.sin(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def sinh(self, name=None): return paddle_frontend.sinh(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def lerp(self, y, weight, name=None): return paddle_frontend.lerp(self, y, weight) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def lerp_(self, y, weight, name=None): self.ivy_array = paddle_frontend.lerp(self, y, weight).ivy_array return self - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def argmax(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.argmax(self, axis=axis, keepdim=keepdim, dtype=dtype) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "uint16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "uint16")}, "paddle") def unsqueeze(self, axis=None, name=None): return paddle_frontend.Tensor(ivy.expand_dims(self._ivy_array, axis=axis)) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def sqrt(self, name=None): return paddle_frontend.sqrt(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def sqrt_(self, name=None): self.ivy_array = self.sqrt().ivy_array return self - @with_unsupported_dtypes({"2.5.2 and below": ("bfloat16", "uint16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("bfloat16", "uint16")}, "paddle") def zero_(self): self.ivy_array = paddle_frontend.zeros_like(self).ivy_array return self - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def cos(self, name=None): return paddle_frontend.cos(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def exp(self, name=None): return paddle_frontend.exp(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def exp_(self, name=None): self.ivy_array = self.exp().ivy_array return self - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def erf(self, name=None): return paddle_frontend.erf(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def subtract(self, y, name=None): return paddle_frontend.subtract(self, y) @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" + {"2.6.0 and below": ("float16", "uint8", "int8", "bool")}, "paddle" ) def subtract_(self, y, name=None): self.ivy_array = self.subtract(y).ivy_array return self - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def log10(self, name=None): return paddle_frontend.Tensor(ivy.log10(self._ivy_array)) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def argsort(self, axis=-1, descending=False, name=None): return paddle_frontend.argsort(self, axis=axis, descending=descending) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def floor(self, name=None): return paddle_frontend.floor(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def floor_(self): self.ivy_array = self.floor().ivy_array return self - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def round_(self, name=None): self.ivy_array = paddle_frontend.round(self).ivy_array return self @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def clip(self, min=None, max=None, name=None): ivy.utils.assertions.check_all_or_any_fn( @@ -476,56 +476,56 @@ def clip(self, min=None, max=None, name=None): return paddle_frontend.Tensor(ret) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def clip_(self, min=None, max=None, name=None): self._ivy_array = self.clip(min, max).ivy_array return self - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def tanh(self, name=None): return paddle_frontend.tanh(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def add(self, y, name=None): return paddle_frontend.Tensor(ivy.add(self._ivy_array, _to_ivy_array(y))) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def add_(self, y, name=None): self.ivy_array = paddle_frontend.add(self, y).ivy_array return self - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def addmm(self, x, y, beta=1.0, alpha=1.0, name=None): return paddle_frontend.addmm(self, x, y, beta, alpha) @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isinf(self, name=None): return paddle_frontend.isinf(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "uint16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "uint16")}, "paddle") def unsqueeze_(self, axis=None, name=None): self.ivy_array = self.unsqueeze(axis=axis).ivy_array return self - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def square(self, name=None): return paddle_frontend.square(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def remainder_(self, y, name=None): self.ivy_array = paddle_frontend.remainder(self, y).ivy_array return self - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def cholesky(self, upper=False, name=None): return paddle_frontend.cholesky(self, upper=upper) @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "uint16", "int16")}, "paddle" + {"2.6.0 and below": ("float16", "uint16", "int16")}, "paddle" ) def squeeze(self, axis=None, name=None): if isinstance(axis, int) and self.ndim > 0: @@ -536,24 +536,24 @@ def squeeze(self, axis=None, name=None): return paddle_frontend.squeeze(self, axis=axis) @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "uint16", "int16")}, "paddle" + {"2.6.0 and below": ("float16", "uint16", "int16")}, "paddle" ) def squeeze_(self, axis=None, name=None): self.ivy_array = paddle_frontend.squeeze(self, axis=axis).ivy_array return self - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def multiply(self, y, name=None): return paddle_frontend.multiply(self, y) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def matmul(self, y, transpose_x=False, transpose_y=False, name=None): return paddle_frontend.matmul( self, y, transpose_x=transpose_x, transpose_y=transpose_y ) @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isfinite(self, name=None): @@ -565,17 +565,17 @@ def all(self, axis=None, keepdim=False, name=None): ivy.all(self.ivy_array, axis=axis, keepdims=keepdim) ) - @with_supported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def allclose(self, other, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): return paddle_frontend.allclose( self, other, rtol=rtol, atol=atol, equal_nan=equal_nan ) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def sort(self, axis=-1, descending=False, name=None): return paddle_frontend.sort(self, axis=axis, descending=descending) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def log1p(self, name=None): return paddle_frontend.log1p(self) @@ -597,7 +597,7 @@ def bitwise_and(self, y, out=None, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -613,22 +613,22 @@ def logical_or(self, y, out=None, name=None): return paddle_frontend.logical_or(self, y, out=out) @with_supported_dtypes( - {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, + {"2.6.0 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, "paddle", ) def bitwise_xor(self, y, out=None, name=None): return paddle_frontend.bitwise_xor(self, y) - @with_supported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def any(self, axis=None, keepdim=False, name=None): return paddle_frontend.any(self, axis=axis, keepdim=keepdim) - @with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": "bfloat16"}, "paddle") def astype(self, dtype): return paddle_frontend.Tensor(ivy.astype(self._ivy_array, dtype)) @with_supported_dtypes( - {"2.5.2 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, + {"2.6.0 and below": ("bool", "uint8", "int8", "int16", "int32", "int64")}, "paddle", ) def bitwise_not(self, out=None, name=None): @@ -636,7 +636,7 @@ def bitwise_not(self, out=None, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -651,7 +651,7 @@ def bitwise_or(self, y, out=None, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -667,7 +667,7 @@ def logical_xor(self, y, out=None, name=None): return paddle_frontend.logical_xor(self, y, out=out) @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def isnan(self, name=None): @@ -675,7 +675,7 @@ def isnan(self, name=None): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -689,22 +689,22 @@ def isnan(self, name=None): def greater_than(self, y, name=None): return paddle_frontend.greater_than(self, y) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def rsqrt(self, name=None): return paddle_frontend.rsqrt(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def rsqrt_(self, name=None): self.ivy_array = self.rsqrt().ivy_array return self - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def reciprocal(self, name=None): return paddle_frontend.reciprocal(self) @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -719,12 +719,12 @@ def reciprocal(self, name=None): def logical_and(self, y, out=None, name=None): return paddle_frontend.logical_and(self, y, out=out) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def divide(self, y, name=None): return paddle_frontend.divide(self, y) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "complex64", "complex128")}, + {"2.6.0 and below": ("float32", "float64", "complex64", "complex128")}, "paddle", ) def eigvals(self, name=None): @@ -732,7 +732,7 @@ def eigvals(self, name=None): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "uint8", "int8", @@ -746,18 +746,18 @@ def eigvals(self, name=None): def less_than(self, y, name=None): return paddle_frontend.less_than(self, y) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def cumprod(self, dim=None, dtype=None, name=None): return paddle_frontend.cumprod(self, dim=dim, dtype=dtype) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def cumsum(self, axis=None, dtype=None, name=None): return paddle_frontend.Tensor( ivy.cumsum(self._ivy_array, axis=axis, dtype=dtype) ) @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128", "float32", "float64")}, + {"2.6.0 and below": ("complex64", "complex128", "float32", "float64")}, "paddle", ) def angle(self, name=None): @@ -765,7 +765,7 @@ def angle(self, name=None): @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "uint8", "int8", "int16", @@ -778,13 +778,13 @@ def angle(self, name=None): def equal(self, y, name=None): return paddle_frontend.equal(self, y) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def rad2deg(self, name=None): return paddle_frontend.rad2deg(self) @with_unsupported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "uint8", "int8", "int16", @@ -798,46 +798,46 @@ def rad2deg(self, name=None): def equal_all(self, y, name=None): return paddle_frontend.equal_all(self, y) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def maximum(self, other, name=None): return paddle_frontend.maximum(self, other) - @with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": "bfloat16"}, "paddle") def fmax(self, y, name=None): return paddle_frontend.fmax(self, y) - @with_unsupported_dtypes({"2.5.2 and below": "bfloat16"}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": "bfloat16"}, "paddle") def fmin(self, y, name=None): return paddle_frontend.fmin(self, y) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def minimum(self, y, name=None): return paddle_frontend.minimum(self, y) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def max(self, axis=None, keepdim=False, name=None): return paddle_frontend.max(self, axis=axis, keepdim=keepdim) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def deg2rad(self, name=None): return paddle_frontend.deg2rad(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def digamma(self, name=None): return paddle_frontend.digamma(self) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64", "bool")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64", "bool")}, "paddle" ) def rot90(self, k=1, axes=(0, 1), name=None): return paddle_frontend.rot90(self, k=k, axes=axes) @with_supported_dtypes( - {"2.5.2 and below": ("complex64", "complex128")}, + {"2.6.0 and below": ("complex64", "complex128")}, "paddle", ) def imag(self, name=None): @@ -848,7 +848,7 @@ def is_tensor(self): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float32", "float64", ) @@ -860,22 +860,22 @@ def isclose(self, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None): self, y, rtol=rtol, atol=atol, equal_nan=equal_nan ) - @with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, "paddle") def floor_divide(self, y, name=None): return paddle_frontend.floor_divide(self, y) - @with_supported_dtypes({"2.5.2 and below": ("int32", "int64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, "paddle") def mod(self, y, name=None): return paddle_frontend.Tensor(ivy.fmod(self._ivy_array, _to_ivy_array(y))) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def floor_mod(self, y, name=None): return paddle_frontend.remainder(self, y) # cond - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def cond(self, p=None, name=None): return paddle_frontend.cond(self, p=p, name=name) @@ -883,7 +883,7 @@ def cond(self, p=None, name=None): def conj(self, name=None): return paddle_frontend.conj(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def log2(self, name=None): return paddle_frontend.log2(self) @@ -895,7 +895,7 @@ def neg(self, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int8", "int16", @@ -910,15 +910,15 @@ def neg(self, name=None): def logical_not(self, out=None, name=None): return paddle_frontend.logical_not(self) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def sign(self, name=None): return paddle_frontend.sign(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def var(self, axis=None, unbiased=True, keepdim=False, name=None): return paddle_frontend.var(self, axis=axis, unbiased=unbiased, keepdim=keepdim) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def sgn(self, name=None): return paddle_frontend.sgn(self) @@ -926,45 +926,45 @@ def tolist(self): return paddle_frontend.Tensor(ivy.to_list(self._ivy_array)) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) def min(self, axis=None, keepdim=False, name=None): return paddle_frontend.min(self, axis=axis, keepdim=keepdim) @with_supported_dtypes( - {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {"2.6.0 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def pow(self, y, name=None): return paddle_frontend.pow(self, y) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def prod(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.Tensor( ivy.prod(self._ivy_array, axis=axis, keepdims=keepdim, dtype=dtype) ) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def atan(self, name=None): return paddle_frontend.atan(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def atanh(self, name=None): return paddle_frontend.atanh(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def std(self, axis=None, unbiased=True, keepdim=False, name=None): return paddle_frontend.std(self, axis=axis, unbiased=unbiased, keepdim=keepdim) @with_supported_dtypes( - {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {"2.6.0 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def trunc(self, name=None): return paddle_frontend.trunc(self) - @with_supported_dtypes({"2.5.2 and below": ("complex64", "complex128")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("complex64", "complex128")}, "paddle") def as_real(self, name=None): if not ivy.is_complex_dtype(self._ivy_array): raise ivy.exceptions.IvyError( @@ -974,12 +974,12 @@ def as_real(self, name=None): im_part = ivy.imag(self._ivy_array) return paddle_frontend.Tensor(ivy.stack((re_part, im_part), axis=-1)) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def stanh(self, scale_a=0.67, scale_b=1.7159, name=None): return paddle_frontend.stanh(self, scale_a=scale_a, scale_b=scale_b) @with_supported_dtypes( - {"2.5.2 and below": ("int32", "int64", "float32", "float64")}, "paddle" + {"2.6.0 and below": ("int32", "int64", "float32", "float64")}, "paddle" ) def trace(self, offset=0, axis1=0, axis2=1, name=None): return paddle_frontend.Tensor( @@ -988,7 +988,7 @@ def trace(self, offset=0, axis1=0, axis2=1, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bfloat16", "float32", "float64", @@ -1010,7 +1010,7 @@ def flatten(self, start_axis=0, stop_axis=-1, name=None): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "float32", "float64", "int16", @@ -1025,52 +1025,52 @@ def argmin(self, axis=None, keepdim=False, dtype=None, name=None): return paddle_frontend.argmin(self, axis=axis, keepdim=keepdim, dtype=dtype) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle", ) def topk(self, k, axis=None, largest=True, sorted=True, name=None): return paddle_frontend.topk(self, k, axis=axis, largest=largest, sorted=sorted) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def remainder(self, y, name=None): return paddle_frontend.remainder(self, y) def is_floating_point(self): return paddle_frontend.is_floating_point(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def tanh_(self, name=None): y = self.tanh(self) return ivy.inplace_update(self, y) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def reciprocal_(self, name=None): y = self.reciprocal(self) return ivy.inplace_update(self, y) @with_unsupported_dtypes( - {"2.5.2 and below": ("complex", "uint8", "uint16")}, "paddle" + {"2.6.0 and below": ("complex", "uint8", "uint16")}, "paddle" ) def numpy(self): return self.ivy_array.to_numpy() - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def nonzero(self): return paddle_frontend.nonzero(self) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def inner(self, y, name=None): return paddle_frontend.inner(self, y, name) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def acos(self, name=None): return paddle_frontend.Tensor(ivy.acos(self._ivy_array)) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def mean(self, axis=None, keepdim=False, name=None): return paddle_frontend.mean(self, axis=axis, keepdim=keepdim) - @with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") def as_complex(self, name=None): if self.ivy_array.shape[-1] != 2: raise ivy.exceptions.IvyError( @@ -1085,29 +1085,29 @@ def as_complex(self, name=None): return value @with_supported_dtypes( - {"2.5.2 and below": ("int32", "int64", "float32", "float64", "bool")}, "paddle" + {"2.6.0 and below": ("int32", "int64", "float32", "float64", "bool")}, "paddle" ) def not_equal(self, y, name=None): return paddle_frontend.not_equal(self._ivy_array, y) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def less_equal(self, y, name=None): return paddle_frontend.less_equal(self._ivy_array, y) - @with_supported_dtypes({"2.5.2 and below": ("complex64", "complex128")}, "paddle") + @with_supported_dtypes({"2.6.0 and below": ("complex64", "complex128")}, "paddle") def real(self, name=None): return paddle_frontend.real(self._ivy_array) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def t(self, name=None): axes = list(range(len(self.ivy_array.shape)))[::-1] return ivy.permute_dims(self.ivy_array, axes=axes) @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "float16", "float32", @@ -1122,12 +1122,12 @@ def t(self, name=None): def cast(self, dtype): return paddle_frontend.cast(self, dtype) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def bmm(self, y, transpose_x=False, transpose_y=False, name=None): return paddle_frontend.bmm(self, y, transpose_x, transpose_y) @with_supported_dtypes( - {"2.5.2 and below": ("float16", "float32", "float64", "int32", "int64")}, + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle", ) def fill_(self, value): @@ -1136,7 +1136,7 @@ def fill_(self, value): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int32", "int64", @@ -1152,7 +1152,7 @@ def unbind(self, axis=0): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "int32", "int64", @@ -1171,19 +1171,19 @@ def cpu(self): return self @with_unsupported_dtypes( - {"2.5.2 and below": ("int16", "complex64", "complex128")}, + {"2.6.0 and below": ("int16", "complex64", "complex128")}, "paddle", ) def split(self, num_or_sections, axis=0, name=None): return paddle_frontend.split(self._ivy_array, num_or_sections, axis, name) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def frac(self, name=None): return paddle_frontend.frac(self._ivy_array) - @with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def gather(self, y, name=None): return paddle_frontend.gather(self, y) @@ -1191,27 +1191,27 @@ def is_complex(self): return paddle_frontend.is_complex(self) @with_unsupported_dtypes( - {"2.5.2 and below": ("float16", "uint8", "int8", "bool")}, "paddle" + {"2.6.0 and below": ("float16", "uint8", "int8", "bool")}, "paddle" ) def gather_(self, y, name=None): res = self.gather(self, y) return ivy.inplace_update(self, res) @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def heaviside(self, y, name=None): return paddle_frontend.heaviside(self, y) @with_supported_dtypes( - {"2.5.2 and below": ("bool", "int32", "int64", "float32", "float64")}, "paddle" + {"2.6.0 and below": ("bool", "int32", "int64", "float32", "float64")}, "paddle" ) def expand(self, shape, name=None): return paddle_frontend.expand(self._ivy_array, shape) @with_supported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ( "bool", "int32", @@ -1230,7 +1230,7 @@ def tile(self, repeat_times): @with_supported_dtypes( { - "2.5.2 and below": ( + "2.6.0 and below": ( "bool", "float16", "float32", diff --git a/ivy/functional/frontends/paddle/vision/transforms.py b/ivy/functional/frontends/paddle/vision/transforms.py index dac89b602ea19..c2ff2af63c3ce 100644 --- a/ivy/functional/frontends/paddle/vision/transforms.py +++ b/ivy/functional/frontends/paddle/vision/transforms.py @@ -104,7 +104,7 @@ def _rgb_to_hsv(img): # ------------ # -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def adjust_brightness(img, brightness_factor): assert brightness_factor >= 0, "brightness_factor should be non-negative." @@ -117,7 +117,7 @@ def adjust_brightness(img, brightness_factor): return _blend_images(img, extreme_target, brightness_factor) -@with_supported_dtypes({"2.5.2 and below": ("float32", "float64", "uint8")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64", "uint8")}, "paddle") @to_ivy_arrays_and_back def adjust_hue(img, hue_factor): assert -0.5 <= hue_factor <= 0.5, "hue_factor should be in range [-0.5, 0.5]" @@ -145,7 +145,7 @@ def adjust_hue(img, hue_factor): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def hflip(img): @@ -154,7 +154,7 @@ def hflip(img): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) def normalize(img, mean, std, data_format="CHW", to_rgb=False): if ivy.is_array(img): @@ -171,7 +171,7 @@ def normalize(img, mean, std, data_format="CHW", to_rgb=False): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def pad(img, padding, fill=0, padding_mode="constant"): @@ -201,7 +201,7 @@ def pad(img, padding, fill=0, padding_mode="constant"): @with_supported_dtypes( - {"2.5.2 and below": ("float32", "float64", "int32", "int64")}, "paddle" + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" ) @to_ivy_arrays_and_back def to_tensor(pic, data_format="CHW"): @@ -211,7 +211,7 @@ def to_tensor(pic, data_format="CHW"): @with_unsupported_device_and_dtypes( { - "2.5.2 and below": { + "2.6.0 and below": { "cpu": ("int8", "uint8", "int16", "float16", "bfloat16", "bool") } }, diff --git a/ivy/functional/frontends/tensorflow/general_functions.py b/ivy/functional/frontends/tensorflow/general_functions.py index 322becf12c4b4..cc98ef66453e8 100644 --- a/ivy/functional/frontends/tensorflow/general_functions.py +++ b/ivy/functional/frontends/tensorflow/general_functions.py @@ -212,7 +212,7 @@ def foldl( return result -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") @to_ivy_arrays_and_back def foldr( fn, diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index 6e711e6390008..111b76bcda4f6 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -621,7 +621,7 @@ def minimum(x, y, name=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.5.2 and below": ("bfloat16",)}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("bfloat16",)}, "paddle") def mod(x, y, name=None): x, y = check_tensorflow_casting(x, y) return ivy.remainder(x, y) diff --git a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py index e384bc25e023e..f7782aa74b377 100644 --- a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py @@ -8,7 +8,7 @@ # ToDo: this function will be simplified once ivy.alpha_dropout is implemented @to_ivy_arrays_and_back @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") -@with_unsupported_dtypes({"2.5.2 and below": ("float16", "bfloat16")}, "paddle") +@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def alpha_dropout(input, p=0.5, training=False, inplace=False): if p == 0.0 or not training or input.shape == () or input.shape == (0,): return input diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 198982e47a8ef..860957d9f6232 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -150,7 +150,7 @@ def reshape(self, *args, shape=None): raise ValueError("reshape() got no values for argument 'shape'") @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") - @with_unsupported_dtypes({"2.5.1 and below": ("float16",)}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16",)}, "paddle") def reshape_as(self, other): return torch_frontend.reshape(self, other.shape) From e117ca55999cbee5e0efdc3e0fa74e0eeb5cfb12 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 18 Jan 2024 17:10:52 +0530 Subject: [PATCH 622/978] fix: changed the `_w_shape` for transpose convolution stateful layers according to the changes in e40024d --- ivy/stateful/layers.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/stateful/layers.py b/ivy/stateful/layers.py index e2cad240cccf8..6dd606c1c6529 100644 --- a/ivy/stateful/layers.py +++ b/ivy/stateful/layers.py @@ -664,7 +664,7 @@ def __init__( self._filter_size = filter_size self._strides = strides self._padding = padding - self._w_shape = (filter_size, input_channels, output_channels) + self._w_shape = (filter_size, output_channels, input_channels) self._b_shape = ( (1, 1, output_channels) if data_format == "NWC" else (1, output_channels, 1) ) @@ -957,7 +957,7 @@ def __init__( self._filter_shape = filter_shape self._strides = strides self._padding = padding - self._w_shape = filter_shape + [input_channels, output_channels] + self._w_shape = filter_shape + [output_channels, input_channels] self._b_shape = ( (1, 1, 1, output_channels) if data_format == "NHWC" @@ -1393,7 +1393,7 @@ def __init__( self._filter_shape = filter_shape self._strides = strides self._padding = padding - self._w_shape = filter_shape + [input_channels, output_channels] + self._w_shape = filter_shape + [output_channels, input_channels] self._b_shape = ( (1, 1, 1, 1, output_channels) if data_format == "NDHWC" From 73dfaa1450795e67283eb6e738b0dc6240e75fd1 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 18 Jan 2024 12:44:43 +0000 Subject: [PATCH 623/978] fix: fix test_torch__getitem fixing the empty dim case in tf backend (#27953) --- ivy/functional/backends/tensorflow/general.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index e0b238c455703..c093b475cac89 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -60,6 +60,9 @@ def get_item( *, copy: Optional[bool] = None, ) -> Union[tf.Tensor, tf.Variable]: + if ivy.is_array(query) and ivy.is_bool_dtype(query): + if not len(query.shape): + return tf.expand_dims(x, 0) return x.__getitem__(query) From 831e04ee3a486d01fa04413ae88287a67e79bf1d Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 18 Jan 2024 13:25:27 +0000 Subject: [PATCH 624/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index d73e8c32a2ecd..1f673b63cd755 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit d73e8c32a2ecd739a4ecc777fb69ceb01b9622c5 +Subproject commit 1f673b63cd7559a6b492f88916e900e6a2aba28e From 1506548d4a42670e2d278ce19ea5608fa3623da9 Mon Sep 17 00:00:00 2001 From: Soumyadeep Biswas Date: Thu, 18 Jan 2024 19:19:00 +0530 Subject: [PATCH 625/978] index_add_ (#26761) --- .../frontends/paddle/tensor/manipulation.py | 36 ++++++- .../test_tensor/test_manipulation.py | 93 +++++++++++++++++++ 2 files changed, 127 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/paddle/tensor/manipulation.py b/ivy/functional/frontends/paddle/tensor/manipulation.py index db6320542ee2d..c83bdaaf96101 100644 --- a/ivy/functional/frontends/paddle/tensor/manipulation.py +++ b/ivy/functional/frontends/paddle/tensor/manipulation.py @@ -6,6 +6,39 @@ ) from ivy.func_wrapper import with_unsupported_dtypes + +@with_supported_dtypes( + {"2.5.1 and below": ("bool", "int32", "int64", "float16", "float32", "float64")}, + "paddle", +) +@to_ivy_arrays_and_back +def index_add_(x, index, axis, value, *, name=None): + x = ivy.swapaxes(x, axis, 0) + value = ivy.swapaxes(value, axis, 0) + _to_adds = [] + index = sorted(zip(ivy.to_list(index), range(len(index))), key=(lambda i: i[0])) + while index: + _curr_idx = index[0][0] + while len(_to_adds) < _curr_idx: + _to_adds.append(ivy.zeros_like(value[0])) + _to_add_cum = ivy.get_item(value, index[0][1]) + while (len(index)) > 1 and (index[0][0] == index[1][0]): + _to_add_cum = _to_add_cum + ivy.get_item(value, index.pop(1)[1]) + index.pop(0) + _to_adds.append(_to_add_cum) + while len(_to_adds) < x.shape[0]: + _to_adds.append(ivy.zeros_like(value[0])) + _to_adds = ivy.stack(_to_adds) + if len(x.shape) < 2: + # Added this line due to the paddle backend treating scalars as 1-d arrays + _to_adds = ivy.flatten(_to_adds) + + ret = ivy.add(x, _to_adds) + ret = ivy.swapaxes(ret, axis, 0) + x = ret + return x + + # NOTE: # Only inplace functions are to be added in this file. # Please add non-inplace counterparts to `/frontends/paddle/manipulation.py`. @@ -17,6 +50,5 @@ ) @to_ivy_arrays_and_back def reshape_(x, shape): - ret = ivy.reshape(x, shape) - ivy.inplace_update(x, ret) + ivy.reshape(x, shape) return x diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_manipulation.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_manipulation.py index c1265c500864e..d2f8f5bde0fea 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_manipulation.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_manipulation.py @@ -13,6 +13,63 @@ # --------------- # +@st.composite +def _arrays_dim_idx_n_dtypes(draw): + num_dims = draw(st.shared(helpers.ints(min_value=1, max_value=4), key="num_dims")) + num_arrays = 2 + common_shape = draw( + helpers.lists( + x=helpers.ints(min_value=2, max_value=3), + min_size=num_dims - 1, + max_size=num_dims - 1, + ) + ) + _dim = draw(helpers.ints(min_value=0, max_value=num_dims - 1)) + unique_dims = draw( + helpers.lists( + x=helpers.ints(min_value=2, max_value=3), + min_size=num_arrays, + max_size=num_arrays, + ) + ) + + min_dim = min(unique_dims) + max_dim = max(unique_dims) + _idx = draw( + helpers.array_values( + shape=min_dim, + dtype="int64", + min_value=0, + max_value=max_dim, + exclude_min=False, + ) + ) + + xs = [] + # available_input_types = draw(helpers.get_dtypes("integer")) + # available_input_types = ["int32", "int64", "float16", "float32", "float64"] + available_input_types = ["int32", "int64"] + input_dtypes = draw( + helpers.array_dtypes( + available_dtypes=available_input_types, + num_arrays=num_arrays, + shared_dtype=True, + ) + ) + for ud, dt in zip(unique_dims, input_dtypes): + x = draw( + helpers.array_values( + shape=common_shape[:_dim] + [ud] + common_shape[_dim:], + dtype=dt, + large_abs_safety_factor=2.5, + small_abs_safety_factor=2.5, + safety_factor_scale="log", + ) + ) + xs.append(x) + return xs, input_dtypes, _dim, _idx + + @st.composite def dtypes_x_reshape_(draw): shape = draw(helpers.get_shape(min_num_dims=1)) @@ -25,6 +82,42 @@ def dtypes_x_reshape_(draw): return dtypes, x, shape +# --- Main --- # +# ------------ # + + +@handle_frontend_test( + fn_tree="paddle.tensor.manipulation.index_add_", + xs_dtypes_dim_idx=_arrays_dim_idx_n_dtypes(), +) +def test_paddle_index_add_( + *, + xs_dtypes_dim_idx, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + xs, input_dtypes, axis, indices = xs_dtypes_dim_idx + if xs[0].shape[axis] < xs[1].shape[axis]: + source, input = xs + else: + input, source = xs + helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + frontend=frontend, + on_device=on_device, + x=input, + index=indices, + axis=axis, + value=source, + ) + + # reshape_ @handle_frontend_test( fn_tree="paddle.tensor.manipulation.reshape_", From f09e9031981fb238462f790d3def30c50b363acf Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 18 Jan 2024 19:39:28 +0530 Subject: [PATCH 626/978] fix: Updated `WSL` section of `Setting Up` by adding a code-snippet to install optional dependencies (#27951) Co-authored-by: Kareem Morsy --- docs/overview/contributing/setting_up.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/overview/contributing/setting_up.rst b/docs/overview/contributing/setting_up.rst index 876ab5e8c54d0..4b8151034e2ec 100644 --- a/docs/overview/contributing/setting_up.rst +++ b/docs/overview/contributing/setting_up.rst @@ -650,7 +650,7 @@ the steps explained below will help you in setting up a less resource-intensive pip install git+https://github.com/unifyai/ivy.git -#. If you want to set up a local repository, you can do so by following :ref:`this guide ` +#. Or else, if you want to set up a local repository, you can do so by following :ref:`this guide ` as explained above and install the required development dependencies by running: .. code-block:: none @@ -660,6 +660,7 @@ the steps explained below will help you in setting up a less resource-intensive .. code-block:: none pip install -r requirements/requirements.txt + pip install -r requirements/optional.txt #. Once done, you can now open VSCode right from your terminal and get started with your development by just running: From 2f8548d3c6ead70f0af65a484156ed2454c2bf0d Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Thu, 18 Jan 2024 14:26:53 +0000 Subject: [PATCH 627/978] fix(tensorflow-backend): Fix asarray in tensorflow backend for cases when dtype is not provided and the passed in object is also not a tf.Tensor --- ivy/functional/backends/tensorflow/creation.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py index 4a96058aa5dff..bdcbddf911f89 100644 --- a/ivy/functional/backends/tensorflow/creation.py +++ b/ivy/functional/backends/tensorflow/creation.py @@ -93,9 +93,12 @@ def asarray( with tf.device(device): if tf.is_tensor(obj): ret = tf.cast(obj, dtype) if obj.dtype != dtype else obj - elif dtype.is_integer and np.issubdtype( - (obj_np := np.array(obj)).dtype, np.floating + elif ( + dtype is not None + and dtype.is_integer + and np.issubdtype(np.array(obj).dtype, np.floating) ): + obj_np = np.array(obj) ret = tf.convert_to_tensor(obj_np, dtype) else: ret = tf.convert_to_tensor(obj, dtype) From 3927ed065506ebc6d4d2a16708c32589cca8b79b Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 19 Jan 2024 09:24:37 +0530 Subject: [PATCH 628/978] fix: added native shape support to torch frontend methods (#27962) --- ivy/functional/frontends/torch/creation_ops.py | 18 +++++++++++++++--- ivy/functional/frontends/torch/tensor.py | 16 ++++++++++------ 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/ivy/functional/frontends/torch/creation_ops.py b/ivy/functional/frontends/torch/creation_ops.py index f7d2e689c93df..6e583d2dd8a20 100644 --- a/ivy/functional/frontends/torch/creation_ops.py +++ b/ivy/functional/frontends/torch/creation_ops.py @@ -107,7 +107,11 @@ def empty( if args and size: raise TypeError("empty() got multiple values for argument 'shape'") if size is None: - size = args[0] if isinstance(args[0], (tuple, list, ivy.Shape)) else args + size = ( + args[0] + if isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)) + else args + ) if isinstance(size, (tuple, list)): size = tuple(s.to_scalar() if ivy.is_array(s) else s for s in size) return ivy.empty(shape=size, dtype=dtype, device=device, out=out) @@ -252,7 +256,11 @@ def ones(*args, size=None, out=None, dtype=None, device=None, requires_grad=Fals if args and size: raise TypeError("ones() got multiple values for argument 'shape'") if size is None: - size = args[0] if isinstance(args[0], (tuple, list, ivy.Shape)) else args + size = ( + args[0] + if isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)) + else args + ) return ivy.ones(shape=size, dtype=dtype, device=device, out=out) @@ -344,7 +352,11 @@ def zeros(*args, size=None, out=None, dtype=None, device=None, requires_grad=Fal if args and size: raise TypeError("zeros() got multiple values for argument 'shape'") if size is None: - size = args[0] if isinstance(args[0], (tuple, list, ivy.Shape)) else args + size = ( + args[0] + if isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)) + else args + ) return ivy.zeros(shape=size, dtype=dtype, device=device, out=out) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 860957d9f6232..beb046b843199 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -141,7 +141,7 @@ def reshape(self, *args, shape=None): if shape is not None: return torch_frontend.reshape(self, shape) if args: - if isinstance(args[0], (tuple, list, ivy.Shape)): + if isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)): shape = args[0] return torch_frontend.reshape(self, shape) else: @@ -301,7 +301,7 @@ def view(self, *args, size=None): shape_tup = size elif args and not ivy.exists(size): if ( - isinstance(args[0], (tuple, list, ivy.Shape)) + isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)) or type(args[0]).__name__ == "Size" ) and len(args) == 1: shape_tup = args[0] @@ -468,7 +468,11 @@ def new_ones( if device is None: device = self.device if size is None: - size = args[0] if isinstance(args[0], (tuple, list, ivy.Shape)) else args + size = ( + args[0] + if isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)) + else args + ) return torch_frontend.ones( size, dtype=dtype, device=device, requires_grad=requires_grad ) @@ -659,7 +663,7 @@ def expand(self, *args, size=None): if args and size: raise TypeError("expand() got multiple values for argument 'size'") if args: - if isinstance(args[0], (tuple, list, ivy.Shape)): + if isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)): size = args[0] else: size = args @@ -862,7 +866,7 @@ def permute(self, *args, dims=None): if dims is not None: return torch_frontend.permute(self, dims) if args: - if isinstance(args[0], (tuple, list, ivy.Shape)): + if isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)): dims = args[0] return torch_frontend.permute(self, dims) else: @@ -1087,7 +1091,7 @@ def repeat(self, *args, repeats=None): "repeat() got multiple values for argument 'repeats'" ) if args: - if isinstance(args[0], (tuple, list, ivy.Shape)): + if isinstance(args[0], (tuple, list, ivy.Shape, ivy.NativeShape)): repeats = args[0] else: repeats = args From a51dc270e01ed437221a22cae92ecef78a9e9048 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 19 Jan 2024 08:13:06 +0000 Subject: [PATCH 629/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 1f673b63cd755..4c53b0d9ba360 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 1f673b63cd7559a6b492f88916e900e6a2aba28e +Subproject commit 4c53b0d9ba36081e2bfd90ea3b2e0eb48e744b23 From fcab0a4570d68b70a7e6cc5b3f73c68681b267e4 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 19 Jan 2024 08:24:29 +0000 Subject: [PATCH 630/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 4c53b0d9ba360..6e65c6ab10bfe 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 4c53b0d9ba36081e2bfd90ea3b2e0eb48e744b23 +Subproject commit 6e65c6ab10bfe076f71be28734c3bc96f0aeb662 From b6f4a0520a7f81c409ce02fe9b5e13bf0dcc7c7b Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 19 Jan 2024 11:27:20 +0300 Subject: [PATCH 631/978] fix: removed the deletion of the image after everyworkflow by a pull before every workflow to save time on the gpu cron job --- scripts/run_tests/run_tests.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index d020123b979fc..18a1e1e9bef13 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -111,6 +111,7 @@ image = "unifyai/ivy:latest-gpu" device_str = " --device=gpu:0" device_access_str = " --gpus all" + os.system("docker pull unifyai/ivy:latest-gpu") os.system( f"docker run{device_access_str} --name test-container -v " @@ -250,10 +251,6 @@ # delete the container os.system("docker rm -f test-container") - # delete pulled image before terminating - if device == "gpu": - os.system("docker rmi unifyai/ivy:latest-gpu") - # if any tests fail, the workflow fails if failed: sys.exit(1) From a11a0fa05471c9813ad724947a099cbe91d42c50 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 19 Jan 2024 08:39:05 +0000 Subject: [PATCH 632/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 6e65c6ab10bfe..bbab2ffe7b4ba 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 6e65c6ab10bfe076f71be28734c3bc96f0aeb662 +Subproject commit bbab2ffe7b4bae885082cb718c493e52685b0166 From 1356ffd7d59efe8a850c035fcfd7487d080c0c3d Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 19 Jan 2024 08:48:15 +0000 Subject: [PATCH 633/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index bbab2ffe7b4ba..7555b52653adf 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit bbab2ffe7b4bae885082cb718c493e52685b0166 +Subproject commit 7555b52653adf712d6b0ec4e47660602ad880d0c From bd1bbd985169d73a56ca0a168b1c75ee48674e67 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Fri, 19 Jan 2024 08:52:07 +0000 Subject: [PATCH 634/978] chore(temp): Remove dynamic_backend arg for ivy.Container from frontend nn.Module --- ivy/functional/frontends/torch/nn/modules/module.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 16ac649480c6a..c9c9aa107b71c 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -40,8 +40,7 @@ def _create_variables(self, device=None, dtype=None): for k, v in self.__dict__.items() if isinstance(v, Parameter) ] - ), - dynamic_backend=self._dynamic_backend, + ) ) # Created variables that were added using `register_paramter`, # since those would appear in `self._v` From 860da2d2a5cd5bb96412f4e5f97d578b1d01481d Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 19 Jan 2024 14:23:07 +0530 Subject: [PATCH 635/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index e083ce379d981..bf93798e93c53 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.5.1" +__version__ = "0.0.6.0" From ef12773a6230c8631303c9c43371698a666e0bc5 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 19 Jan 2024 09:50:18 +0000 Subject: [PATCH 636/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 7555b52653adf..76f67e43a0af7 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 7555b52653adf712d6b0ec4e47660602ad880d0c +Subproject commit 76f67e43a0af796fd3964c00bd7216ba8229d642 From b5e6304ec6f5eb70d21fc4bebf956b2846adbe05 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 19 Jan 2024 09:55:41 +0000 Subject: [PATCH 637/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 76f67e43a0af7..2312393af2a12 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 76f67e43a0af796fd3964c00bd7216ba8229d642 +Subproject commit 2312393af2a12f3bdf1c5ab2f4aa3b0c871e4860 From e2a250393aea9f527466584a885c99c36cf9b1cb Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 19 Jan 2024 16:29:07 +0000 Subject: [PATCH 638/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 2312393af2a12..4f06395a2f4bc 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 2312393af2a12f3bdf1c5ab2f4aa3b0c871e4860 +Subproject commit 4f06395a2f4bc26987fa8295c6e398fa95b9b645 From 6f7ce7bb49eae735f550bbeb513013b3161acfb5 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 21 Jan 2024 07:15:00 +0400 Subject: [PATCH 639/978] feat: Add video to open_tasks Fix Failing tests --- docs/overview/contributing/open_tasks.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/docs/overview/contributing/open_tasks.rst b/docs/overview/contributing/open_tasks.rst index a93ed13d89803..6c5d2b65f4bbc 100644 --- a/docs/overview/contributing/open_tasks.rst +++ b/docs/overview/contributing/open_tasks.rst @@ -62,6 +62,14 @@ Ensure that your solution addresses the issue effectively and doesn't introduce Once you're confident in your fix, submit a pull request to the main repository. Our team will review your contribution, provide feedback if necessary, and then merge your changes once we're good to go. +**Video** + +.. raw:: html + + + Frontend APIs ------------- From f1fc4cb543615bdc1364821b122c1c2127d4b461 Mon Sep 17 00:00:00 2001 From: saeedashrraf <48128381+saeedashrraf@users.noreply.github.com> Date: Sun, 21 Jan 2024 08:02:43 +0100 Subject: [PATCH 640/978] feat: Added the profiling tools for Torch and TensorFlow (#27976) --- ivy/utils/profiler.py | 159 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 159 insertions(+) diff --git a/ivy/utils/profiler.py b/ivy/utils/profiler.py index 05b7d016a3a16..371d14f88fe99 100644 --- a/ivy/utils/profiler.py +++ b/ivy/utils/profiler.py @@ -53,3 +53,162 @@ def __exit__(self, *exc): if self.print_stats: stats.print_stats() + + +def tensorflow_profile_start( + logdir: str, + host_tracer_level: int = 2, + python_tracer_level: int = 0, + device_tracer_level: int = 1, + delay_ms: int = None, +): + """Initialize and start the profiler. + + Parameters + ---------- + logdir: str + Directory where the profile data will be saved to. + host_tracer_level: int + Adjust CPU tracing level. Values are: 1 - critical info only, 2 - info, 3 - verbose. [default value is 2] + python_tracer_level: int + Toggle tracing of Python function calls. Values are: 1 - enabled, 0 - disabled [default value is 0] + device_tracer_level: int + Adjust device (TPU/GPU) tracing level. Values are: 1 - enabled, 0 - disabled [default value is 1] + delay_ms: int + Requests for all hosts to start profiling at a timestamp that is delay_ms away from the current time. delay_ms is in milliseconds. If zero, each host will start profiling immediately upon receiving the request. Default value is None, allowing the profiler guess the best value. + Save the weights on the Module. + + Returns + ------- + None + """ + from tensorflow.profiler.experimental import ProfilerOptions, start + + options = ProfilerOptions( + host_tracer_level=host_tracer_level, + python_tracer_level=python_tracer_level, + device_tracer_level=device_tracer_level, + delay_ms=delay_ms, + ) + start(logdir, options=options) + + +def tensorflow_profile_stop(): + """Stop the profiler.""" + from tensorflow.profiler.experimental import stop + + stop() + + +def torch_profiler_init( + logdir=None, + activities=None, + schedule=None, + on_trace_ready=None, + record_shapes=False, + profile_memory=False, + with_stack=False, + with_flops=False, + with_modules=False, + experimental_config=None, +): + """Initialize and returns a Torch profiler instance. + + Parameters + ---------- + logdir : str + Directory where the profile data will be saved to. + + activities : iterable + list of activity groups (CPU, CUDA) to use in profiling, supported values: + ``torch.profiler.ProfilerActivity.CPU``, ``torch.profiler.ProfilerActivity.CUDA``. + Default value: ProfilerActivity.CPU and (when available) ProfilerActivity.CUDA. + + schedule : Callable + callable that takes step (int) as a single parameter and returns + ``ProfilerAction`` value that specifies the profiler action to perform at each step. + + on_trace_ready : Callable + callable that is called at each step when ``schedule`` + returns ``ProfilerAction.RECORD_AND_SAVE`` during the profiling. + + record_shapes : bool + save information about operator's input shapes. + + profile_memory : bool + track tensor memory allocation/deallocation. + + with_stack : bool + record source information (file and line number) for the ops. + + with_flops : bool + use formula to estimate the FLOPs (floating point operations) of specific operators + (matrix multiplication and 2D convolution). + + with_modules : bool + record module hierarchy (including function names) + corresponding to the callstack of the op. e.g. If module A's forward call's + module B's forward which contains an aten::add op, then aten::add's module hierarchy is A.B + Note that this support exist, at the moment, only for TorchScript models + and not eager mode models. + + experimental_config _ExperimentalConfig : _ExperimentalConfig + A set of experimental options + used for Kineto library features. Note, backward compatibility is not guaranteed. + + Returns + ------- + Torch profiler instance. + """ + from torch.profiler import profile, tensorboard_trace_handler + + profiler = profile( + activities=activities, + schedule=schedule, + on_trace_ready=( + tensorboard_trace_handler(logdir) + if on_trace_ready is None and logdir is not None + else on_trace_ready + ), + record_shapes=record_shapes, + profile_memory=profile_memory, + with_stack=with_stack, + with_flops=with_flops, + with_modules=with_modules, + experimental_config=experimental_config, + ) + return profiler + + +def torch_profiler_start(profiler): + """Start the profiler. + + Parameters + ---------- + profiler : torch.profiler.profile + Torch profiler instance. + + Returns + ------- + None + """ + profiler.start() + + +def torch_profiler_stop(profiler): + """Start the profiler. + + Parameters + ---------- + profiler : torch.profiler.profile + Torch profiler instance. + + Returns + ------- + None + """ + from torch.autograd.profiler import KinetoStepTracker + from torch.profiler.profiler import PROFILER_STEP_NAME + + profiler.stop() + KinetoStepTracker.erase_step_count(PROFILER_STEP_NAME) From 0f8f4870cd3289cd3ff8db50ee43c84098bcd7aa Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Sun, 21 Jan 2024 20:36:24 +0400 Subject: [PATCH 641/978] Update YouTube link --- docs/overview/contributing/open_tasks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/open_tasks.rst b/docs/overview/contributing/open_tasks.rst index 6c5d2b65f4bbc..4420295b0d893 100644 --- a/docs/overview/contributing/open_tasks.rst +++ b/docs/overview/contributing/open_tasks.rst @@ -67,7 +67,7 @@ Our team will review your contribution, provide feedback if necessary, and then .. raw:: html Frontend APIs From fc422f811e35315f74407672befa381305b95ac8 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 22 Jan 2024 07:37:37 +0530 Subject: [PATCH 642/978] fix:fixed ivy.maximum tests for all backend (#27971) --- ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index cea111ff23d2e..60489a816c710 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1431,6 +1431,7 @@ def test_logical_xor(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device) @handle_test( fn_tree="functional.ivy.maximum", dtype_and_x_and_use_where=min_max_helper(), + test_gradients=st.just(False), ) def test_maximum( *, dtype_and_x_and_use_where, test_flags, backend_fw, fn_name, on_device From 4c3083577dbec85d1179dccd9ae8916f9be87e39 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 22 Jan 2024 12:30:31 +0530 Subject: [PATCH 643/978] fix: Fixed `ivy.adjoint` test for all backends (#27984) Co-authored-by: NripeshN --- .../test_experimental/test_core/test_linalg.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py index e89b36633e92f..655b8149eb478 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py @@ -859,7 +859,6 @@ def _tucker_data(draw): fn_tree="functional.ivy.experimental.adjoint", dtype_x=helpers.dtype_and_values( available_dtypes=( - ivy.float16, ivy.float32, ivy.float64, ivy.complex64, @@ -875,7 +874,7 @@ def _tucker_data(draw): shared_dtype=True, ), ) -def test_adjoint(dtype_x, test_flags, backend_fw, fn_name): +def test_adjoint(dtype_x, test_flags, backend_fw, fn_name, on_device): dtype, x = dtype_x helpers.test_function( input_dtypes=dtype, @@ -883,6 +882,7 @@ def test_adjoint(dtype_x, test_flags, backend_fw, fn_name): backend_to_test=backend_fw, fn_name=fn_name, x=x[0], + on_device=on_device, ) From 90bedc1be8aa6600420db9b158dd6d278213ebc6 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Mon, 22 Jan 2024 13:10:27 +0500 Subject: [PATCH 644/978] feat(stateful): Add `NativeModule` to all backends with the implementation of a custom `tensorflow.keras.Model` subclass for the `tensorflow` backend to follow `ivy.Module`'s API (#27955) --- ivy/__init__.py | 4 + ivy/functional/backends/jax/__init__.py | 15 + ivy/functional/backends/jax/module.py | 0 ivy/functional/backends/mxnet/__init__.py | 5 + ivy/functional/backends/mxnet/module.py | 0 ivy/functional/backends/numpy/__init__.py | 5 + ivy/functional/backends/numpy/module.py | 0 ivy/functional/backends/paddle/__init__.py | 6 + ivy/functional/backends/paddle/module.py | 0 .../backends/tensorflow/__init__.py | 6 + ivy/functional/backends/tensorflow/module.py | 684 ++++++++++++++++++ ivy/functional/backends/torch/__init__.py | 5 + ivy/functional/backends/torch/module.py | 0 .../frontends/torch/nn/modules/module.py | 8 +- 14 files changed, 737 insertions(+), 1 deletion(-) create mode 100644 ivy/functional/backends/jax/module.py create mode 100644 ivy/functional/backends/mxnet/module.py create mode 100644 ivy/functional/backends/numpy/module.py create mode 100644 ivy/functional/backends/paddle/module.py create mode 100644 ivy/functional/backends/tensorflow/module.py create mode 100644 ivy/functional/backends/torch/module.py diff --git a/ivy/__init__.py b/ivy/__init__.py index 116c5212f8aed..1a074aec61900 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -69,6 +69,10 @@ class NativeShape: pass +class NativeModule: + pass + + class Container: pass diff --git a/ivy/functional/backends/jax/__init__.py b/ivy/functional/backends/jax/__init__.py index b0d52c4819e6d..33d48e0bfc5cc 100644 --- a/ivy/functional/backends/jax/__init__.py +++ b/ivy/functional/backends/jax/__init__.py @@ -4,6 +4,7 @@ import jaxlib import jax import jax.numpy as jnp +import importlib from typing import Union # make ivy.Container compatible with jax pytree traversal @@ -240,8 +241,22 @@ def closest_valid_dtype(type=None, /, as_native=False): from .experimental import * from . import control_flow_ops from .control_flow_ops import * +from . import module +from .module import * # sub-backends from . import sub_backends from .sub_backends import * + + +if importlib.util.find_spec("flax"): + import flax + + NativeModule = flax.linen.Module +elif importlib.util.find_spec("haiku"): + import haiku as hk + + NativeModule = hk.Module +else: + NativeModule = None diff --git a/ivy/functional/backends/jax/module.py b/ivy/functional/backends/jax/module.py new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/ivy/functional/backends/mxnet/__init__.py b/ivy/functional/backends/mxnet/__init__.py index 3e0bef791040a..9a73876faa148 100644 --- a/ivy/functional/backends/mxnet/__init__.py +++ b/ivy/functional/backends/mxnet/__init__.py @@ -201,3 +201,8 @@ def closest_valid_dtype(type=None, /, as_native=False): from .control_flow_ops import * from . import sub_backends from .sub_backends import * +from . import module +from .module import * + + +NativeModule = mx.gluon.nn.Block diff --git a/ivy/functional/backends/mxnet/module.py b/ivy/functional/backends/mxnet/module.py new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/ivy/functional/backends/numpy/__init__.py b/ivy/functional/backends/numpy/__init__.py index 5ddf86a0b9a17..d739b919131b9 100644 --- a/ivy/functional/backends/numpy/__init__.py +++ b/ivy/functional/backends/numpy/__init__.py @@ -213,9 +213,14 @@ def closest_valid_dtype(type=None, /, as_native=False): from .experimental import * from . import control_flow_ops from .control_flow_ops import * +from . import module +from .module import * # sub-backends from . import sub_backends from .sub_backends import * + + +NativeModule = None diff --git a/ivy/functional/backends/numpy/module.py b/ivy/functional/backends/numpy/module.py new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/ivy/functional/backends/paddle/__init__.py b/ivy/functional/backends/paddle/__init__.py index 7b11652539c8b..0e5f0fa31e9ee 100644 --- a/ivy/functional/backends/paddle/__init__.py +++ b/ivy/functional/backends/paddle/__init__.py @@ -297,8 +297,14 @@ def closest_valid_dtype(type=None, /, as_native=False): from .experimental import * from . import control_flow_ops from .control_flow_ops import * +from . import module +from .module import * + # sub-backends from . import sub_backends from .sub_backends import * + + +NativeModule = paddle.nn.Layer diff --git a/ivy/functional/backends/paddle/module.py b/ivy/functional/backends/paddle/module.py new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/ivy/functional/backends/tensorflow/__init__.py b/ivy/functional/backends/tensorflow/__init__.py index 786e8169f9139..6af4c4d36e712 100644 --- a/ivy/functional/backends/tensorflow/__init__.py +++ b/ivy/functional/backends/tensorflow/__init__.py @@ -265,3 +265,9 @@ def closest_valid_dtype(type=None, /, as_native=False): # sub-backends from . import sub_backends from .sub_backends import * + +from . import module +from .module import Model + + +NativeModule = Model diff --git a/ivy/functional/backends/tensorflow/module.py b/ivy/functional/backends/tensorflow/module.py new file mode 100644 index 0000000000000..07eb2fef45a03 --- /dev/null +++ b/ivy/functional/backends/tensorflow/module.py @@ -0,0 +1,684 @@ +# global +from __future__ import annotations +import re +import tensorflow as tf +from typing import Union +import functools +import logging +from tensorflow.python.util import nest + + +class ModelHelpers: + @staticmethod + def _get_first_array(*args, **kwargs): + arr = None + flattened_args = tf.nest.flatten((args, kwargs)) + arr_candidates = tf.nest.map_structure( + lambda x: x if isinstance(x, (tf.Tensor, tf.Variable)) else False, + flattened_args, + ) + for arr_candidate in arr_candidates: + if arr_candidate is not False: + arr = arr_candidate + break + return arr + + @staticmethod + def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): + if ModelHelpers._dict_has_key_chain(v, orig_key_chain): + ret_cont = ModelHelpers._dict_at_key_chain(v, orig_key_chain) + else: + ret_cont = dict() + for old_kc, new_kc in keychain_mappings.items(): + if orig_key_chain in old_kc: + # Check if `v` contains `new_kc` before replacing in `ret_cont` + if ModelHelpers._dict_has_key_chain(v, new_kc): + ret_cont = ModelHelpers._dict_set_at_key_chain( + ret_cont, + "/".join(old_kc.split("/")[1:]), + ModelHelpers._dict_at_key_chain(v, new_kc), + ) + else: + continue + return ret_cont + + @staticmethod + def _remove_duplicate_variables(vs, created, /): + created_ids = tf.nest.map_structure(lambda x: id(x), created) + vs_ids = tf.nest.map_structure(lambda x: id(x), vs) + ids = {} + duplicate_keychains = [] + keychain_mappings = {} + + def unique_callback(x, kc): + ids[x] = kc + return x + + def found_dup_callback(x, kc): + if ids[x] == kc: + return x + duplicate_keychains.append(kc) + keychain_mappings[kc] = ids[x] + return x + + created_ids = nest.map_structure_with_paths( + lambda kc, x: unique_callback(x, kc), created_ids + ) + vs_ids = nest.map_structure_with_paths( + lambda kc, x: ( + unique_callback(x, kc) if x not in ids else found_dup_callback(x, kc) + ), + vs_ids, + ) + for dup_kc in duplicate_keychains: + vs = ModelHelpers._dict_prune_key_chain(vs, dup_kc) + return vs, keychain_mappings + + @staticmethod + def _dict_set_at_key_chain(in_dict, key_chain, val, inplace=False): + keys = re.split("[/.]", key_chain) + if inplace: + cont = in_dict + else: + cont = in_dict + sub_cont = cont + for key in keys[:-1]: + if key not in sub_cont: + sub_cont[key] = dict() + sub_cont = sub_cont[key] + sub_cont[keys[-1]] = val + return cont + + @staticmethod + def _dict_at_key_chain(dict, key_chain, ignore_key_errors=False): + keys = re.split("[/.]", key_chain) + ret = dict + for key in keys: + try: + ret = ret[key] + except KeyError as e: + if ignore_key_errors: + return + raise Exception(repr(e)) + return ret + + @staticmethod + def _dict_has_key_chain(dict, key_chain): + keys = re.split("[/.]", key_chain) + ret = dict + for key in keys: + try: + ret = ret[key] + except KeyError: + return False + return True + + @staticmethod + def _dict_prune_key_chain(in_dict, key_chain): + keys_in_chain = re.split("[/.]", key_chain) + out_dict = {} + for key, value in in_dict.items(): + if isinstance(value, dict): + if key == keys_in_chain[0]: + if len(keys_in_chain) == 1: + new_val = [] + else: + new_val = ModelHelpers._dict_prune_key_chain( + value, + "/".join(keys_in_chain[1:]), + ) + if len(new_val) > 0: + out_dict[key] = new_val + else: + if len(value) > 0: + out_dict[key] = value + else: + if len(keys_in_chain) != 1 or key != keys_in_chain[0]: + out_dict[key] = value + return out_dict + + @staticmethod + def _addindent(s_, numSpaces): + s = s_.split("\n") + # don't do anything for single-line stuff + if len(s) == 1: + return s_ + first = s.pop(0) + s = [(numSpaces * " ") + line for line in s] + s = "\n".join(s) + s = first + "\n" + s + return s + + +class Model(tf.keras.Model, ModelHelpers): + _build_mode = None + _with_partial_v = None + _store_vars = True + _built = False + _keras_built = False + _v = None + _buffers = None + _module_dict = None + _args = None + _kwargs = None + _module_graph = None + _target = None + _lazy_traced = False + _training = None + _dynamic_backend = None + _device = None + _dtype = None + + def __init__( + self, + /, + *args, + v=None, + buffers=None, + build_mode="on_init", + store_vars=True, + with_partial_v=False, + dynamic_backend=None, + training=True, + dtype=None, + device=None, + **kwargs, + ): + super(Model, self).__init__( + trainable=training, + dtype=dtype, + ) + self._build_mode = build_mode + self._with_partial_v = with_partial_v + self._store_vars = store_vars + self._built = False + self._keras_built = False + self._v_from_constructor = v if isinstance(v, dict) or v is None else dict(v) + self._v = v if v is not None else dict() + self._buffers = dict(buffers or {}) + self._module_dict = dict() + self._args = args + self._kwargs = kwargs + self._module_graph = None + self._target = None + self._lazy_traced = False + self._training = training + self._dynamic_backend = dynamic_backend + self._device = device or "cpu" + self._dtype = dtype or tf.float32 + if build_mode != "on_init": + return + self.build(*args, dynamic_backend=dynamic_backend, **kwargs) + + def _find_variables( + self, + /, + *, + obj=None, + without_initialisation=False, + _visited=None, + ): + _visited = _visited or {} + vs = dict() + if id(obj) in _visited: + return vs + _visited[id(obj)] = True + if isinstance(obj, Model) and obj is not self: + + if not obj.built and without_initialisation: + return lambda: obj._build_and_return_v( + *obj._args, dynamic_backend=self._dynamic_backend, **obj._kwargs + ) + + return obj._build_and_return_v( + *obj._args, dynamic_backend=obj._dynamic_backend, **obj._kwargs + ) + elif isinstance(obj, (list, tuple)): + for i, v in enumerate(obj): + ret = self._find_variables( + obj=v, + without_initialisation=without_initialisation, + _visited=_visited, + ) + if ret: + vs[f"v{str(i)}"] = ret + return vs + elif isinstance(obj, dict): + for k, v in obj.items(): + ret = self._find_variables( + obj=v, + without_initialisation=without_initialisation, + _visited=_visited, + ) + if ret: + vs[k[1:] if k[0] == "_" else k] = ret + return vs + elif not hasattr(obj, "__dict__"): + return vs + for k, v in obj.__dict__.items(): + if ( + v is not None + and k[0:2] != "__" + and not k.startswith(( + "_module_dict", + "_self_", + )) + ): + ret = self._find_variables( + obj=v, + without_initialisation=without_initialisation, + _visited=_visited, + ) + if ret: + vs[k[1:] if k[0] == "_" else k] = ret + return vs + + def _find_buffers(self): + if hasattr(self, "_module_dict"): + for key, sub_module in self._module_dict.items(): + if len(sub_module._buffers) > 0: + self._buffers[key] = sub_module._buffers + + def _build_and_return_v(self, *args, **kwargs): + if not self._built: + self.build(*args, **kwargs) + return self.v + + def _assign_weights(self): + model_weights = [] + + # trainable weights + for kc, x in self.v.items(): + + # Only add weights for this layer + if isinstance(x, dict): + continue + + self.v[kc] = ( + self.add_weight(name=kc, shape=x.shape, dtype=x.dtype, trainable=True) + if x is not None + else x + ) + if isinstance(x, tf.Variable): + self.v[kc].assign(x.value()) + ( + model_weights.append(self.v[kc].numpy()) + if self.v[kc] is not None + else self.v[kc] + ) + + # non-trainable weights + for kc, x in self.buffers.items(): + + # Only add weights for this layer + if isinstance(x, dict): + continue + + self.buffers[kc] = ( + self.add_weight(name=kc, shape=x.shape, dtype=x.dtype, trainable=False) + if x is not None + else x + ) + if isinstance(x, tf.Variable): + self.buffers[kc].assign(x.value()) + ( + model_weights.append(self.buffers[kc].numpy()) + if self.buffers[kc] is not None + else self.buffers[kc] + ) + + if model_weights: + self.set_weights(model_weights) + + def build( + self, + *args, + from_call=False, + device=None, + dtype=None, + dynamic_backend=None, + **kwargs, + ): + self._device = device or self._device + self._dtype = dtype or self._dtype + self._dynamic_backend = dynamic_backend or self._dynamic_backend + # return False if not from_call but build_mode is on_call + if not from_call and self._build_mode == "on_call": + return self.v + + # build local Module, and any child modules flagged with "explicit" build mode + # this gets the child modules initialised at best, their weights + # remain un-generated + built = self._build(*args, **kwargs) or True + + # this creates weights for this Module only + created = self._create_variables(device=self._device, dtype=dtype) + created = ( + created.cont_to_dict() if hasattr(created, "cont_to_dict") else created + ) + + # build variables based on locally built layers, if v not passed in constructor + created_n_found = dict( + **self._find_variables( + obj=self, + without_initialisation=( + True + if self._v_from_constructor and not self._with_partial_v + else False + ), + ), + **created, + ) + if self._v_from_constructor: + # TODO: Add logic here for when `v` is passed in the constructor + raise Exception("TODO: Implement this logic") + else: + self._v = created_n_found + # remove duplicates + self._v, keychain_mappings = self._remove_duplicate_variables(self._v, created) + # build any child 'on_call' layers + if not built and from_call: + # TODO: Add logic for here + raise Exception("TODO: Implement this logic") + + # flag built and remove local variables if specified + self._built = bool(built) + v_ret = self.v + if not self._store_vars: + # ToDo: verify variables in self.v are released once this method exits + self._v = dict() + + # compute the module dict + self._compute_module_dict() + + # once all variables built, find and assign buffers + self._find_buffers() + + # also assign the keras model trainable and non-trainable weights now + self._assign_weights() + + # wrap call methods if the model is fully built + if built: + self._wrap_call_methods(keychain_mappings, obj=self) + + return v_ret if bool(v_ret) or isinstance(built, bool) else built + + def _wrap_call_methods( + self, keychain_mappings, /, *, key="", obj=None, _visited=None + ): + _visited = _visited or {} + if id(obj) in _visited or not isinstance(key, str): + return + _visited[id(obj)] = True + if isinstance(obj, Model) and obj is not self: + orig_key_chain = key[1:] if key[0] == "_" else key + + obj.__call__ = self._fn_with_var_arg( + obj.__call__, self._extract_v, keychain_mappings, orig_key_chain + ) + return + elif isinstance(obj, (list, tuple)): + for i, val in enumerate(obj): + self._wrap_call_methods( + keychain_mappings, + key=f"{key}/v{str(i)}", + obj=val, + _visited=_visited, + ) + return + elif isinstance(obj, dict): + for k, val in obj.items(): + k = f"{key}/{k}" if key != "" and isinstance(k, str) else k + self._wrap_call_methods( + keychain_mappings, key=k, obj=val, _visited=_visited + ) + return + for k, val in obj.module_dict.items(): + if k.startswith(("__", "_self_")): + continue + k = f"{key}/{k}" if key != "" else k + if val is not None: + self._wrap_call_methods( + keychain_mappings, key=k, obj=val, _visited=_visited + ) + return + + def _call(self, *args, v=None, buffers=None, **kwargs): + if not self._built or not self._keras_built: + first_arr = self._get_first_array(*args, **kwargs) + + if not self._built: + self.build( + *args, + **kwargs, + from_call=True, + dtype=first_arr.dtype if first_arr is not None else tf.float32, + ) + + if not self._keras_built: + self.inputs = tf.nest.flatten(args) + super(Model, self).build( # noqa: UP008 + first_arr.shape if first_arr is not None else tf.TensorShape(None) + ) + + # If `v` was provided, replace with the module's v + replace_v = False + if v is not None: + v_orig = self.v + self._v = v + replace_v = True + + # If `buffers` were provided, replace with the module's buffers + replace_buffers = False + if buffers is not None: + buffers_orig = self.buffers + self._buffers = buffers + replace_buffers = True + + if replace_v or replace_buffers: + # Call the forward pass + ret = super(Model, self).__call__(*args, **kwargs) # noqa: UP008 + # Replace v, buffers if needed + self._v = v_orig if replace_v else self._v + self._buffers = buffers_orig if replace_buffers else self._buffers + return ret + elif hasattr(self.__call__, "wrapped"): + return self.__call__(*args, **kwargs) + return super(Model, self).__call__(*args, **kwargs) # noqa: UP008 + + def _rebuild(self): + logging.warning( + "Building the module again as a trainable module was modified, " + 'please use the "explicit" or "on_call" build_modes instead ' + 'of "on_init" to avoid repetitive building after each addition' + ) + self._v = dict() + self._built = False + self.build(*self._args, **self._kwargs) + + def _compute_module_dict(self): + self._module_dict = dict() + for key, value in self.__dict__.items(): + if isinstance(value, Model): + if "stateful" in value.__module__ or hasattr(value, "_frontend_module"): + self._module_dict[key] = value + else: + self._module_dict[key] = value._module_dict + + def _fn_with_var_arg_wrapper( + self, *a, fn, v_fn, keychain_mappings, orig_key_chain, **kw + ): + if "v" in kw: + del kw["v"] + v = v_fn(self.v, keychain_mappings, orig_key_chain) + return fn(*a, **kw, v=v) + + def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): + _fn_with_var_arg_wrapper = functools.partial( + self._fn_with_var_arg_wrapper, + fn=fn, + v_fn=v_fn, + keychain_mappings=keychain_mappings, + orig_key_chain=orig_key_chain, + ) + _fn_with_var_arg_wrapper.wrapped = True + return _fn_with_var_arg_wrapper + + def register_buffer(self, name: str, value: Union[tf.Tensor, tf.Variable]): + if value is not None: + self._buffers.update({name: value}) + else: + self.__setattr__(name, value) + + def register_parameter(self, name: str, value: Union[tf.Tensor, tf.Variable]): + self._v.update({name: value}) + + def train(self, mode: bool = True): + self._training = mode + self.trainable = mode + + def eval(self): + return self.train(mode=False) + + def call(self, inputs, training=None, mask=None): + raise NotImplementedError( + "When subclassing the `Model` class, you should implement a `call` method." + ) + + # Methods to be Optionally Overridden # + # -----------------------------------# + + def _create_variables(self, *, device=None, dtype=None): + return {} + + def _build(self, *args, **kwargs) -> bool: + return True + + def _forward(self, *args, **kwargs): + raise NotImplementedError( + "When subclassing the `Model` class, you should " + "implement a `_forward` method." + ) + + def _extra_repr(self) -> str: + return "" + + # Properties # + # -----------# + + @property + def device(self): + return self._device + + @property + def dtype(self): + return self._dtype + + @property + def build_mode(self): + return self._build_mode + + @property + def training(self): + return self._training + + @property + def v(self): + return self._v + + @property + def buffers(self): + return self._buffers + + @property + def state_dict(self): + return {**self.v, **self.buffers} + + @property + def module_dict(self): + return self._module_dict + + # Dunder Methods # + # ---------------# + + def __call__( + self, + *args, + v=None, + buffers=None, + **kwargs, + ): + ret = self._call(*args, v=v, buffers=buffers, **kwargs) + return ret + + def __getattr__(self, name): + if name == "v": + if not super().__getattribute__("_v") and not self.built: + return self._build_and_return_v( + *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs + ) + + _dict = super().__getattribute__("__dict__") + if name in _dict: + return _dict[name] + + elif "_v" in _dict and name in _dict["_v"]: + return _dict["_v"][name] + + return super().__getattribute__(name) + + def __setattr__(self, name, value): + if name in ["v", "buffers"]: + name = "_" + name + if isinstance(value, Model): + ret = super().__setattr__(name, value) + if ( + hasattr(self, "_build_mode") + and self.build_mode == "on_init" + and self.built + ): + self._rebuild() + return ret + elif isinstance(value, tf.Variable) and not name.startswith("_"): + ret = self.register_parameter(name, value) + if ( + hasattr(self, "_build_mode") + and self.build_mode == "on_init" + and self.built + ): + self._rebuild() + return ret + return super().__setattr__(name, value) + + def __delattr__(self, name): + if hasattr(self, name): + if isinstance(getattr(self, name), Model): + super().__delattr__(name) + if self.build_mode == "on_init": + self._rebuild() + return + super().__delattr__(name) + + def __repr__(self): + extra_lines = [] + extra_repr = self._extra_repr() + if extra_repr: + extra_lines = extra_repr.split("\n") + child_lines = [] + for key in self.v.keys(): + if isinstance(getattr(self, key, None), Model): + mod_str = repr(getattr(self, key)) + mod_str = self._addindent(mod_str, 2) + child_lines.append(f"({key}): {mod_str}") + lines = extra_lines + child_lines + + main_str = f"{self.__class__.__name__}(" + if lines: + # simple one-liner info, which most builtin Modules will use + if len(extra_lines) == 1 and not child_lines: + main_str += extra_lines[0] + else: + main_str += "\n " + "\n ".join(lines) + "\n" + + main_str += ")" + return main_str diff --git a/ivy/functional/backends/torch/__init__.py b/ivy/functional/backends/torch/__init__.py index 922b6ff3506bb..e82a5063499f8 100644 --- a/ivy/functional/backends/torch/__init__.py +++ b/ivy/functional/backends/torch/__init__.py @@ -270,8 +270,13 @@ def globals_getter_func(x=None): from .control_flow_ops import * from . import norms from .norms import * +from . import module +from .module import * # sub-backends from . import sub_backends from .sub_backends import * + + +NativeModule = torch.nn.Module diff --git a/ivy/functional/backends/torch/module.py b/ivy/functional/backends/torch/module.py new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index c9c9aa107b71c..b4d13f57725a9 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -39,6 +39,9 @@ def _create_variables(self, device=None, dtype=None): (k.replace(".", "/"), v) for k, v in self.__dict__.items() if isinstance(v, Parameter) + and not k.startswith( + ("_"), + ) ] ) ) @@ -104,6 +107,9 @@ def forward(self, *input: Any) -> None: f'Module [{type(self).__name__}] is missing the required "forward" function' ) + def call(self, inputs, *args, training=None, mask=None, **kwargs): + return self.forward(inputs, *args, **kwargs) + def _forward(self, *a, **kw): ret = self._call_impl(*a, **kw) return ret @@ -231,7 +237,7 @@ def _extra_repr(self) -> str: return "" def _call_impl(self, *args, **kwargs): - return self.forward(*args, **kwargs) + return self.call(*args, **kwargs) def __getattribute__(self, name: str) -> Any: if name == "__dict__": From bd97b2cdb11f462707921309e759ade5386998a1 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 22 Jan 2024 08:11:01 +0000 Subject: [PATCH 645/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 4f06395a2f4bc..216e0fdd44137 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 4f06395a2f4bc26987fa8295c6e398fa95b9b645 +Subproject commit 216e0fdd44137fcd1a2be0d21f131d62c5509afe From b95edbc98679fd81eed32b0a9297c5f7d4941996 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 22 Jan 2024 08:57:30 +0000 Subject: [PATCH 646/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 216e0fdd44137..901be35fb3472 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 216e0fdd44137fcd1a2be0d21f131d62c5509afe +Subproject commit 901be35fb34723cd5a684a9a3344181418e03696 From bb787ce0d3148b8700415d6d529bda1dd76c1a93 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 22 Jan 2024 17:49:52 +0530 Subject: [PATCH 647/978] fix: Fixed raising of `keyError()` to properly include `path_type` in the error message (#27965) --- ivy/functional/frontends/jax/numpy/mathematical_functions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index 939e47d79999f..c68a4740223b0 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -315,7 +315,7 @@ def einsum_path(subscripts, *operands, optimize="greedy"): elif path_type == "optimal": path = optimal_path(input_sets, output_set, dimension_dict, memory_arg) else: - raise KeyError("Path name %s not found", path_type) + raise KeyError(f"Path name {path_type} not found") cost_list, scale_list, size_list, contraction_list = [], [], [], [] From fc4abc0a72f40184082126fc554519934c274877 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 22 Jan 2024 17:51:09 +0530 Subject: [PATCH 648/978] fix: fixed ivy.sum not passing the test case at paddle & torch backend (#27973) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/statistical.py | 5 ++--- ivy/functional/backends/torch/statistical.py | 4 +++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/paddle/statistical.py b/ivy/functional/backends/paddle/statistical.py index 9bdf6199a7f3f..4a0376cd2cf17 100644 --- a/ivy/functional/backends/paddle/statistical.py +++ b/ivy/functional/backends/paddle/statistical.py @@ -8,7 +8,6 @@ import ivy from ivy.func_wrapper import ( with_supported_dtypes, - with_unsupported_dtypes, with_supported_device_and_dtypes, ) import ivy.functional.backends.paddle as paddle_backend @@ -184,8 +183,8 @@ def std( return _std(x, axis, correction, keepdims).cast(x.dtype) -@with_unsupported_dtypes( - {"2.6.0 and below": ("int8", "int16", "uint8")}, +@with_supported_dtypes( + {"2.6.0 and below": ("bool", "float16", "float32", "float64", "int32", "int64")}, backend_version, ) def sum( diff --git a/ivy/functional/backends/torch/statistical.py b/ivy/functional/backends/torch/statistical.py index 7ec801d192d5d..36ee6cee1326a 100644 --- a/ivy/functional/backends/torch/statistical.py +++ b/ivy/functional/backends/torch/statistical.py @@ -181,7 +181,9 @@ def std( # Function does support uint8, but allowing support for unsigned will cause # the function to break the upcasting rule defined in the Array API Standard -@with_unsupported_dtypes({"2.1.2 and below": ("uint8",)}, backend_version) +@with_unsupported_dtypes( + {"2.1.2 and below": ("uint8", "float16", "bfloat16")}, backend_version +) def sum( x: torch.Tensor, /, From 084ac3e5c2cf81059f33d0fb7ee888436c615902 Mon Sep 17 00:00:00 2001 From: Deeptendu Santra <55111154+Dsantra92@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:10:57 +0530 Subject: [PATCH 649/978] Update compiler.py 47eda8e (#27990) Co-authored-by: ivy-branch --- binaries.json | 3 ++- ivy/compiler/compiler.py | 15 +++++++++------ 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/binaries.json b/binaries.json index 1bc4c24020693..107ae5776eb88 100644 --- a/binaries.json +++ b/binaries.json @@ -28,6 +28,7 @@ "IID.so", "III.so", "IIL.so", + "IIM.so", "IIV.so", "IIX.so", "IL.so", @@ -70,4 +71,4 @@ } ] } -} +} \ No newline at end of file diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 535e749daff4b..4c6a46ed0a7a3 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,8 +21,7 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend - operations. + """Takes `fn` and traces it into a more efficient composition of backend operations. Parameters ---------- @@ -92,8 +91,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703 - """ + 0.0001785755157470703""" + from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -128,6 +127,7 @@ def transpile( static_argnames: Optional[Union[str, Iterable[str]]] = None, compile_mode: Optional[str] = None, graph_caching: bool = False, + graph_optimizations: bool = True, modes_to_trace: str = "all", stateful: Optional[List] = None, arg_stateful_idxs: Optional[List] = None, @@ -156,8 +156,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph. - """ + Either a transpiled Graph or a non-initialized LazyGraph.""" + from ._compiler import transpile as _transpile return _transpile( @@ -170,6 +170,7 @@ def transpile( static_argnames=static_argnames, compile_mode=compile_mode, graph_caching=graph_caching, + graph_optimizations=graph_optimizations, modes_to_trace=modes_to_trace, stateful=stateful, arg_stateful_idxs=arg_stateful_idxs, @@ -185,6 +186,7 @@ def unify( *objs: Callable, source: Optional[str] = None, graph_caching: bool = False, + graph_optimizations: bool = True, args: Optional[Sequence] = None, kwargs: Optional[Mapping] = None, with_numpy: bool = True, @@ -197,6 +199,7 @@ def unify( *objs, source=source, graph_caching=graph_caching, + graph_optimizations=graph_optimizations, args=args, kwargs=kwargs, with_numpy=with_numpy, From 9fa0e2ba784ce76574ded61f286c1ef3b6617594 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Mon, 22 Jan 2024 12:42:48 +0000 Subject: [PATCH 650/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- binaries.json | 2 +- ivy/compiler/compiler.py | 11 ++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/binaries.json b/binaries.json index 107ae5776eb88..649ad6ff15915 100644 --- a/binaries.json +++ b/binaries.json @@ -71,4 +71,4 @@ } ] } -} \ No newline at end of file +} diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 4c6a46ed0a7a3..1404fd94969a2 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -21,7 +21,8 @@ def trace_graph( params_v=None, v=None ): - """Takes `fn` and traces it into a more efficient composition of backend operations. + """Takes `fn` and traces it into a more efficient composition of backend + operations. Parameters ---------- @@ -91,8 +92,8 @@ def trace_graph( >>> start = time.time() >>> graph(x) >>> print(time.time() - start) - 0.0001785755157470703""" - + 0.0001785755157470703 + """ from ._compiler import trace_graph as _trace_graph return _trace_graph( @@ -156,8 +157,8 @@ def transpile( Returns ------- - Either a transpiled Graph or a non-initialized LazyGraph.""" - + Either a transpiled Graph or a non-initialized LazyGraph. + """ from ._compiler import transpile as _transpile return _transpile( From ec786478df1a49e603240d4c14a86e61aa5d41cf Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:29:54 +0530 Subject: [PATCH 651/978] fix: added wrappers.json to the MANIFEST.in --- MANIFEST.in | 1 + 1 file changed, 1 insertion(+) diff --git a/MANIFEST.in b/MANIFEST.in index e0a363d10c6ec..8003b02e6779e 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -4,3 +4,4 @@ include ivy/compiler/*.so include ivy/compiler/*.py include binaries.json include available_configs.json +include wrappers.json From dfa4c78eb17e2c68b2df770152b8c2285f1f0f54 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:32:51 +0530 Subject: [PATCH 652/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index bf93798e93c53..2f33e58432d06 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.6.0" +__version__ = "0.0.6.1" From f03bd1ba78762228573e1bf4cc305e3508a22079 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:44:28 +0530 Subject: [PATCH 653/978] fix: fixed an issue with the wrappers.json with a patch for now --- ivy/wrappers/utils.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/wrappers/utils.py b/ivy/wrappers/utils.py index b264e70275903..7702f70f4456e 100644 --- a/ivy/wrappers/utils.py +++ b/ivy/wrappers/utils.py @@ -7,7 +7,8 @@ folder_path = os.sep.join(__file__.split(os.sep)[:-3]) wrappers_path = os.path.join(folder_path, "wrappers.json") -wrappers = json.loads(open(wrappers_path).read()) +if os.path.exists(wrappers_path): + wrappers = json.loads(open(wrappers_path).read()) wrapers_dir = os.path.join(folder_path, "ivy/wrappers") From 3d8fcae028e01dbcf8f5362d00619db4418a1968 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 22 Jan 2024 18:44:41 +0530 Subject: [PATCH 654/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index 2f33e58432d06..b8794d03c5abb 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.6.1" +__version__ = "0.0.6.2" From 5ec27ac39f867520a7c016353ea89575d0987874 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 22 Jan 2024 19:31:49 +0530 Subject: [PATCH 655/978] fix: Fixed `ivy.fix` for paddle backend (#27988) --- ivy/functional/backends/paddle/experimental/elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index aa2f22f778830..b3f4bf64fb9eb 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -266,6 +266,7 @@ def allclose( return paddle.allclose(x1, x2, rtol=rtol, atol=atol, equal_nan=equal_nan).squeeze(0) +@with_unsupported_dtypes({"2.6.0 and below": ("float16",)}, backend_version) def fix( x: paddle.Tensor, /, From f2316e744c0ce178638dbce3f3887ff5f25b2b01 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:43:10 +0530 Subject: [PATCH 656/978] fix: fixed ivy.cumsum tests at all backend (#27974) Co-authored-by: NripeshN --- ivy/functional/backends/jax/statistical.py | 1 + ivy/functional/backends/tensorflow/statistical.py | 1 + ivy/functional/backends/torch/statistical.py | 4 ++-- .../test_ivy/test_functional/test_core/test_statistical.py | 1 + 4 files changed, 5 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/jax/statistical.py b/ivy/functional/backends/jax/statistical.py index a0b31da7eca77..bff5fca9a2d1e 100644 --- a/ivy/functional/backends/jax/statistical.py +++ b/ivy/functional/backends/jax/statistical.py @@ -183,6 +183,7 @@ def cumprod( return jnp.flip(x, axis=axis) +@with_unsupported_dtypes({"0.4.23 and below": "bool"}, backend_version) def cumsum( x: JaxArray, axis: int = 0, diff --git a/ivy/functional/backends/tensorflow/statistical.py b/ivy/functional/backends/tensorflow/statistical.py index f79a665fb2e99..f111a2804e5a1 100644 --- a/ivy/functional/backends/tensorflow/statistical.py +++ b/ivy/functional/backends/tensorflow/statistical.py @@ -200,6 +200,7 @@ def cumprod( return tf.math.cumprod(x, axis, exclusive, reverse) +@with_unsupported_dtypes({"2.15.0 and below": "bool"}, backend_version) def cumsum( x: Union[tf.Tensor, tf.Variable], axis: int = 0, diff --git a/ivy/functional/backends/torch/statistical.py b/ivy/functional/backends/torch/statistical.py index 36ee6cee1326a..76030c794dfb6 100644 --- a/ivy/functional/backends/torch/statistical.py +++ b/ivy/functional/backends/torch/statistical.py @@ -292,8 +292,8 @@ def cumprod( # TODO: bfloat16 support is added in PyTorch 1.12.1 @with_unsupported_dtypes( { - "1.12.1 and below": ("uint8", "float16", "bfloat16"), - "1.12.1 and above": ("uint8", "float16"), + "1.12.1 and below": ("uint8", "bool", "float16", "bfloat16"), + "1.12.1 and above": ("uint8", "bool", "float16"), }, backend_version, ) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py index 47d8ef1d894dd..143db6235ea77 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py @@ -153,6 +153,7 @@ def test_cumprod( dtype_x_axis_castable=_get_castable_dtype(), exclusive=st.booleans(), reverse=st.booleans(), + test_gradients=st.just(False), ) def test_cumsum( *, From 38d644122e09fde2b10be2a20c068c7d34690f8d Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:44:05 +0530 Subject: [PATCH 657/978] fix: fixed ivy.minimum tests not passing at tensorflow paddle backend (#27963) Co-authored-by: NripeshN --- ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 60489a816c710..31cc0abcd9296 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1455,6 +1455,7 @@ def test_maximum( @handle_test( fn_tree="functional.ivy.minimum", dtype_and_x_and_use_where=min_max_helper(), + test_gradients=st.just(False), ) def test_minimum( *, dtype_and_x_and_use_where, test_flags, backend_fw, fn_name, on_device From 5b0e136704cfc3f13363acd65e0978054f1e1b2f Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:48:53 +0530 Subject: [PATCH 658/978] fix: fixed floor_divide tests not passing at paddle backend (#27960) Co-authored-by: NripeshN --- ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 31cc0abcd9296..752128514bc4d 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -827,6 +827,7 @@ def test_floor(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): safety_factor_scale="linear", shared_dtype=True, ), + test_gradients=st.just(False), ) def test_floor_divide(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): input_dtype, x = dtype_and_x From 548dee20988bb51724d688b7bbdf2f48be10110e Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:49:56 +0530 Subject: [PATCH 659/978] fix: fixed tests not passing at paddle backend (#27958) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/elementwise.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 97f7a68516a5d..bd5906c7431ac 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -974,6 +974,10 @@ def exp(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.T return paddle.exp(x) +@with_supported_dtypes( + {"2.6.0 and below": ("int32", "int64", "float32", "float64", "complex")}, + backend_version, +) def exp2( x: Union[paddle.Tensor, float, list, tuple], /, From b38fa862d0d9cbed0b1f0758148776955e8bc651 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:50:52 +0530 Subject: [PATCH 660/978] fix: fixed unsupported complex dtype at jax and torch backend (#27948) Co-authored-by: NripeshN --- ivy/functional/backends/jax/elementwise.py | 1 + ivy/functional/backends/torch/elementwise.py | 2 +- .../test_ivy/test_functional/test_core/test_elementwise.py | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index dffa6b358102a..c4a84e65d9048 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -28,6 +28,7 @@ def abs( return jnp.where(x != 0, jnp.absolute(x), 0) +@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) def acos(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arccos(x) diff --git a/ivy/functional/backends/torch/elementwise.py b/ivy/functional/backends/torch/elementwise.py index 13e8f3a83460c..3e2a4d69d7a21 100644 --- a/ivy/functional/backends/torch/elementwise.py +++ b/ivy/functional/backends/torch/elementwise.py @@ -403,7 +403,7 @@ def greater_equal( greater_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def acos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 752128514bc4d..a5f7eb3d8e164 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -177,7 +177,7 @@ def test_abs(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.acos", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), + available_dtypes=helpers.get_dtypes("float_and_complex"), large_abs_safety_factor=4, small_abs_safety_factor=4, safety_factor_scale="log", From 4f9c684a4311cc2e3dc71d31d3d7938bf077a5c7 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 22 Jan 2024 19:53:00 +0530 Subject: [PATCH 661/978] fix: edited the x1 multiple check at complex dtype (#27939) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/elementwise.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index bd5906c7431ac..a9cd43fd5e930 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -140,8 +140,8 @@ def equal( ) -@with_unsupported_dtypes( - {"2.6.0 and below": ("int8", "int16", "bfloat16", "unsigned", "float16")}, +@with_supported_dtypes( + {"2.6.0 and below": ("bool", "float32", "float64", "int32", "int64", "complex")}, backend_version, ) def less_equal( @@ -153,7 +153,7 @@ def less_equal( ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) if paddle.is_complex(x1): - if paddle.is_complex(x1): + if paddle.is_complex(x2): real = paddle.less_equal(x1.real(), x2.real()) imag = paddle.less_equal(x1.imag(), x2.imag()) return paddle_backend.logical_and(real, imag) From e62f5b68f8fb267ef3f618666e2f4fabb915db6b Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 22 Jan 2024 15:30:34 +0000 Subject: [PATCH 662/978] fix: update torch frontnend Tensor method cumprod's arg defaults to match with native torch --- ivy/functional/frontends/torch/tensor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index beb046b843199..314bca4cc1711 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1391,7 +1391,7 @@ def item(self): @numpy_to_torch_style_args @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") - def cumprod(self, dim, dtype): + def cumprod(self, dim, dtype=None): return torch_frontend.cumprod(self, dim, dtype=dtype) @numpy_to_torch_style_args From 12c965a47dad7cece4536bb9f1d4ce9f38683bb1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kacper=20Ko=C5=BCdo=C5=84?= <102428159+Kacper-W-Kozdon@users.noreply.github.com> Date: Mon, 22 Jan 2024 20:16:49 +0100 Subject: [PATCH 663/978] feat: added unflatten frontend and backend support (#27416) Co-authored-by: joaozenobio --- .../backends/jax/experimental/manipulation.py | 17 ++++ .../numpy/experimental/manipulation.py | 18 ++++- .../paddle/experimental/manipulation.py | 14 ++++ .../tensorflow/experimental/manipulation.py | 18 ++++- .../torch/experimental/manipulation.py | 19 ++++- .../frontends/torch/miscellaneous_ops.py | 5 ++ .../ivy/experimental/manipulation.py | 61 ++++++++++++++ .../test_torch/test_miscellaneous_ops.py | 80 +++++++++++++++++++ 8 files changed, 229 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/manipulation.py b/ivy/functional/backends/jax/experimental/manipulation.py index c519d7acfd16e..36759c9dd1dfd 100644 --- a/ivy/functional/backends/jax/experimental/manipulation.py +++ b/ivy/functional/backends/jax/experimental/manipulation.py @@ -15,6 +15,7 @@ import jax.lax as jlax from numbers import Number from collections import namedtuple +from ivy.func_wrapper import handle_out_argument # local import ivy @@ -468,3 +469,19 @@ def take( def trim_zeros(a: JaxArray, /, *, trim: Optional[str] = "bf") -> JaxArray: return jnp.trim_zeros(a, trim=trim) + + +@handle_out_argument +def unflatten( + x: JaxArray, + /, + dim: int = 0, + shape: Tuple[int] = None, + *, + out: Optional[JaxArray] = None, + order: Optional[str] = None, +) -> JaxArray: + dim = abs(len(x.shape) + dim) if dim < 0 else dim + res_shape = x.shape[:dim] + shape + x.shape[dim + 1 :] + res = jnp.reshape(x, res_shape) + return res diff --git a/ivy/functional/backends/numpy/experimental/manipulation.py b/ivy/functional/backends/numpy/experimental/manipulation.py index e2ad547b7b851..a4a7c9ed12756 100644 --- a/ivy/functional/backends/numpy/experimental/manipulation.py +++ b/ivy/functional/backends/numpy/experimental/manipulation.py @@ -18,7 +18,7 @@ # local import ivy from ivy.functional.backends.numpy.helpers import _scalar_output_to_0d_array -from ivy.func_wrapper import with_supported_dtypes +from ivy.func_wrapper import with_supported_dtypes, handle_out_argument # noinspection PyProtectedMember from . import backend_version @@ -601,3 +601,19 @@ def put_along_axis( put_along_axis.partial_mixed_handler = lambda *args, mode=None, **kwargs: mode in [ "replace", ] + + +@handle_out_argument +def unflatten( + x: np.ndarray, + /, + dim: int = 0, + shape: Tuple[int] = None, + *, + out: Optional[np.ndarray] = None, + order: Optional[str] = None, +) -> np.ndarray: + dim = abs(len(x.shape) + dim) if dim < 0 else dim + res_shape = x.shape[:dim] + shape + x.shape[dim + 1 :] + res = np.reshape(x, res_shape) + return res diff --git a/ivy/functional/backends/paddle/experimental/manipulation.py b/ivy/functional/backends/paddle/experimental/manipulation.py index 5ddb1adb64d8c..788a73d263c76 100644 --- a/ivy/functional/backends/paddle/experimental/manipulation.py +++ b/ivy/functional/backends/paddle/experimental/manipulation.py @@ -20,6 +20,7 @@ with_unsupported_device_and_dtypes, with_supported_dtypes, with_unsupported_dtypes, + handle_out_argument, ) import paddle import ivy @@ -905,3 +906,16 @@ def put_along_axis( "sum", "mul", ] + + +@handle_out_argument +def unflatten( + x: paddle.Tensor, + /, + dim: int = 0, + shape: Tuple[int] = None, + *, + out: Optional[paddle.Tensor] = None, +) -> paddle.Tensor: + res = paddle.unflatten(x, dim, shape) + return res diff --git a/ivy/functional/backends/tensorflow/experimental/manipulation.py b/ivy/functional/backends/tensorflow/experimental/manipulation.py index f2f702e230fc1..e03aebe12f749 100644 --- a/ivy/functional/backends/tensorflow/experimental/manipulation.py +++ b/ivy/functional/backends/tensorflow/experimental/manipulation.py @@ -16,7 +16,7 @@ import tensorflow as tf # local -from ivy.func_wrapper import with_unsupported_dtypes +from ivy.func_wrapper import with_unsupported_dtypes, handle_out_argument from .. import backend_version import ivy from ivy.functional.ivy.experimental.manipulation import _to_tf_padding @@ -565,3 +565,19 @@ def trim_zeros(a: tf.Tensor, /, *, trim: Optional[str] = "bf") -> tf.Tensor: last = tf.minimum(last, tf.cast(tf.shape(a)[0], tf.int64)) return a[first:last] + + +@handle_out_argument +def unflatten( + x: tf.Tensor, + /, + dim: int = 0, + shape: Tuple[int] = None, + *, + out: Optional[tf.Tensor] = None, + name: Optional[str] = None, +) -> tf.Tensor: + dim = abs(len(x.shape) + dim) if dim < 0 else dim + res_shape = x.shape[:dim] + tf.TensorShape(shape) + x.shape[dim + 1 :] + res = tf.reshape(x, res_shape, name) + return res diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index 7071e63922e41..485884c6511ed 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -17,7 +17,11 @@ # local -from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes +from ivy.func_wrapper import ( + with_unsupported_dtypes, + with_supported_dtypes, + handle_out_argument, +) from .. import backend_version import ivy from ivy.functional.ivy.experimental.manipulation import ( @@ -639,3 +643,16 @@ def trim_zeros(a: torch.Tensor, /, *, trim: Optional[str] = "bf") -> torch.Tenso else: last = last - 1 return a[first:last] + + +@handle_out_argument +def unflatten( + x: torch.Tensor, + /, + dim: int = 0, + shape: Tuple[int] = None, + *, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + res = torch.unflatten(x, dim, shape) + return res diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 413a9ec0a6927..d3af93bf17ce9 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -544,6 +544,11 @@ def triu_indices(row, col, offset=0, dtype="int64", device="cpu", layout=None): return ivy.stack(ivy.nonzero(sample_matrix)).astype(dtype) +@to_ivy_arrays_and_back +def unflatten(input, /, *, dim, sizes): + return ivy.unflatten(input, dim=dim, shape=sizes, out=None) + + @to_ivy_arrays_and_back def vander(x, N=None, increasing=False): # if N == 0: diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index 8fe94fbf57f2b..604dab42cbe64 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -2870,3 +2870,64 @@ def trim_zeros( ), "to_skip": ("inputs_to_ivy_arrays",), } + + +@handle_exceptions +@handle_backend_invalid +@handle_nestable +@handle_array_like_without_promotion +@handle_view +@handle_out_argument +@to_native_arrays_and_back +@handle_array_function +@handle_device +def unflatten( + x: Union[ivy.Array, ivy.NativeArray], + /, + *, + dim: int, + shape: Tuple[int], + out: Optional[ivy.Array] = None, +) -> ivy.Array: + """Expand a dimension of the input tensor over multiple dimensions. + + Parameters + ---------- + x + input tensor. + dim + dimension to be unflattened, specified as an index into input.shape. + shape + new shape of the unflattened dimension. One of its elements can be -1 in + which case the corresponding output dimension is inferred. Otherwise, + the product of sizes must equal input.shape[dim]. + out + optional output array, for writing the result to. It must have a shape that the + inputs broadcast to. + + Returns + ------- + ret + view of input with the specified dimension unflattened. + + + This function conforms to the `Array API Standard + `_. This docstring is an extension of the + `docstring `_ + in the standard. + + Both the description and the type hints above assumes an array input for simplicity, + but this function is *nestable*, and therefore also accepts :class:`ivy.Container` + instances in place of any of the arguments. + + Examples + -------- + >>> ivy.unflatten(torch.randn(3, 4, 1), dim=1, shape=(2, 2)).shape + torch.Size([3, 2, 2, 1]) + >>> ivy.unflatten(torch.randn(3, 4, 1), dim=1, shape=(-1, 2)).shape + torch.Size([3, 2, 2, 1]) + >>> ivy.unflatten(torch.randn(5, 12, 3), dim=-2, shape=(2, 2, 3, 1, 1)).shape + torch.Size([5, 2, 2, 3, 1, 1, 3]) + """ + return current_backend(x).unflatten(x, dim=dim, shape=shape, out=out) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 83698b88a0db9..5a77b6cfbbe6e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -1777,6 +1777,86 @@ def test_torch_triu_indices( ) +# unflatten +@handle_frontend_test( + fn_tree="torch.unflatten", + shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), + dtype_and_values=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_num_dims=1, + shape_key="shape", + ), + get_axis=helpers.get_axis( + shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), + max_size=1, + min_size=1, + force_int=True, + ), +) +def test_torch_unflatten( + *, + dtype_and_values, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, + shape, + get_axis, +): + if type(get_axis) is not tuple: + axis = get_axis + else: + axis = 0 if get_axis is None else get_axis[0] + dtype, x = dtype_and_values + + def factorization(n): + factors = [1] + + def get_factor(n): + x_fixed = 2 + cycle_size = 2 + x = 2 + factor = 1 if n % 2 else 2 + + while factor == 1: + for count in range(cycle_size): + if factor > 1: + break + x = (x * x + 1) % n + factor = math.gcd(x - x_fixed, n) + + cycle_size *= 2 + x_fixed = x + + return factor + + while n > 1: + next = get_factor(n) + factors.append(next) + n //= next + + return factors + + shape_ = ( + tuple(factorization(shape[axis])) + if tuple(factorization(shape[axis])) + else shape + ) + helpers.test_frontend_function( + input_dtypes=dtype, + frontend=frontend, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + test_values=False, + input=x[0], + dim=axis, + sizes=shape_, + ) + + # vander @handle_frontend_test( fn_tree="torch.vander", From e351e4b6d7bbbbf4d511da66d78c18e4701d3d4b Mon Sep 17 00:00:00 2001 From: Nightcrab Date: Tue, 23 Jan 2024 09:22:56 +0000 Subject: [PATCH 664/978] implement index_put_ using ivy.map --- ivy/functional/frontends/torch/tensor.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 314bca4cc1711..acd0a720c4aa9 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2252,10 +2252,17 @@ def index_put(self, indices, values, accumulate=False): return ret def index_put_(self, indices, values, accumulate=False): + def _set_add(index): + self[index] += values + + def _set(index): + self[index] = values + if accumulate: - self[indices] += values + ivy.map(fn=_set_add, unique={"index": indices}) else: - self[indices] = values + ivy.map(fn=_set, unique={"index": indices}) + return self # Method aliases From 7dcca64839b63dbd539d3058473e6f8db77e41bc Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Tue, 23 Jan 2024 03:41:50 -0800 Subject: [PATCH 665/978] FIX! Fix Ivy Failing Test: paddle - elementwise.not_equal (#28000) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/elementwise.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index a9cd43fd5e930..c7b538c640dd1 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -612,6 +612,10 @@ def negative( return paddle.neg(x) +@with_supported_dtypes( + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, + backend_version, +) def not_equal( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], From f165c505c4df2cbcd9fc602033d0ed749abe2830 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 23 Jan 2024 20:50:29 +0530 Subject: [PATCH 666/978] feat: added an example for using the profiler in utils (#28004) --- ivy/utils/profiler_example.ipynb | 143 +++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+) create mode 100644 ivy/utils/profiler_example.ipynb diff --git a/ivy/utils/profiler_example.ipynb b/ivy/utils/profiler_example.ipynb new file mode 100644 index 0000000000000..a49999df0bd8d --- /dev/null +++ b/ivy/utils/profiler_example.ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn\n", + "import tensorflow as tf\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class TFModel(tf.keras.Model):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.lin = tf.keras.layers.Dense(10, activation=tf.nn.relu)\n", + " \n", + " def call(self, inputs, training=False):\n", + " return self.lin(inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class TorchModel(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.lin = nn.Linear(10, 10)\n", + " \n", + " def forward(self, x):\n", + " return self.lin(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tf_model = tf.function(TFModel()) \n", + "inp = np.random.random((10, 10))\n", + "x = tf.convert_to_tensor(inp, dtype=tf.float32)\n", + "tf_model(x)\n", + "\n", + "tf_model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch_model = torch.compile(TorchModel())\n", + "inp2 = np.random.random((10, 10)).astype(np.float32)\n", + "x2 = torch.from_numpy(inp2)\n", + "torch_model, torch_model(x2).shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating the Profiler Logs TensorFlow" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "logs = 'logs/' + \"tensorflow\"\n", + "\n", + "from ivy.utils.profiler import tensorflow_profile_start, tensorflow_profile_stop\n", + "tensorflow_profile_start(logs, \n", + " host_tracer_level = 3,\n", + " python_tracer_level = 1,\n", + " device_tracer_level = 1)\n", + "tf_model(x)\n", + "tensorflow_profile_stop()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Launch TensorBoard and navigate to the Profile tab to view performance profile \n", + "!tensorboard --logdir='logs/'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating the Profiler Logs Torch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from ivy.utils.profiler import torch_profiler_init, torch_profiler_start, torch_profiler_stop\n", + "profiler = torch_profiler_init(activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA ],\n", + " on_trace_ready=torch.profiler.tensorboard_trace_handler('./logs/torch'),\n", + " record_shapes=True,\n", + " profile_memory=True,\n", + " with_stack=True)\n", + "torch_profiler_start(profiler)\n", + "torch_model(x2)\n", + "torch_profiler_stop(profiler)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "multienv", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 196e20cc76bb15666b40d783e5e0f0dcc4e43536 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 23 Jan 2024 20:59:17 +0530 Subject: [PATCH 667/978] fix: Fixed Frontend Failing Test: paddle - tensor.paddle.Tensor.any (#27992) --- ivy/functional/frontends/paddle/tensor/tensor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 059b777c6c4b7..f3fe3500552a7 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -619,7 +619,7 @@ def logical_or(self, y, out=None, name=None): def bitwise_xor(self, y, out=None, name=None): return paddle_frontend.bitwise_xor(self, y) - @with_supported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") + @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def any(self, axis=None, keepdim=False, name=None): return paddle_frontend.any(self, axis=axis, keepdim=keepdim) From 4a2ef0bc377ef475cf64b5b1a9d8bbcaf0e85bfa Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Wed, 24 Jan 2024 08:43:07 +0000 Subject: [PATCH 668/978] feat(torch-frontend): Add finfo to torch frontend --- ivy/functional/frontends/torch/miscellaneous_ops.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index d3af93bf17ce9..ee0143f3b70df 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -239,6 +239,11 @@ def einsum(equation, *operands): return ivy.einsum(equation, *operands) +@to_ivy_arrays_and_back +def finfo(dtype): + return ivy.finfo(dtype) + + @to_ivy_arrays_and_back def flatten(input, start_dim=0, end_dim=-1): return ivy.flatten(input, start_dim=start_dim, end_dim=end_dim) From e1724a8232f19d21f24286d058a906f0ed300666 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Wed, 24 Jan 2024 08:43:49 +0000 Subject: [PATCH 669/978] fix(torch-frontend): Handle default case for torch.Size when no input shape is provided. Also add numel to the Size class --- ivy/functional/frontends/torch/tensor.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index acd0a720c4aa9..f3f939df27eb5 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2298,6 +2298,7 @@ def _set(index): class Size(tuple): def __new__(cls, iterable=()): + iterable = ivy.Shape([]) if not iterable else iterable new_iterable = [] for i, item in enumerate(iterable): if isinstance(item, int): @@ -2311,7 +2312,8 @@ def __new__(cls, iterable=()): ) from e return super().__new__(cls, tuple(new_iterable)) - def __init__(self, shape) -> None: + def __init__(self, shape=()) -> None: + shape = ivy.Shape([]) if not shape else shape self._ivy_shape = shape if isinstance(shape, ivy.Shape) else ivy.shape(shape) def __repr__(self): @@ -2320,3 +2322,6 @@ def __repr__(self): @property def ivy_shape(self): return self._ivy_shape + + def numel(self): + return int(ivy.astype(ivy.prod(self), ivy.int64)) From 82ccaebd9743a6d7d0d47309fc0db3b43c315cbe Mon Sep 17 00:00:00 2001 From: Suyash Gupta Date: Wed, 24 Jan 2024 15:00:52 +0530 Subject: [PATCH 670/978] fix: Updated the OpenSSL download link in Using venv section of Setting Up (#27954) --- docs/overview/contributing/setting_up.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/overview/contributing/setting_up.rst b/docs/overview/contributing/setting_up.rst index 4b8151034e2ec..fa329b7358713 100644 --- a/docs/overview/contributing/setting_up.rst +++ b/docs/overview/contributing/setting_up.rst @@ -231,8 +231,8 @@ This is a builtin package and doesn't require explicit installation. .. code-block:: none - wget http://nz2.archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.1f-1ubuntu2.19_amd64.deb - sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2.19_amd64.deb + wget http://nz2.archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.1f-1ubuntu2.20_amd64.deb + sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2.20_amd64.deb PS: If the link gets expired at some point in the future, check http://nz2.archive.ubuntu.com/ubuntu/pool/main/o/openssl/?C=M;O=D for a valid one. From 3e2da70a5ce970ed89c975a719d777b0dd6925e7 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Wed, 24 Jan 2024 21:55:25 +0000 Subject: [PATCH 671/978] fix(data_type): Add missing functools.wraps to the _handle_nestable_dtype_info_wrapper decorator --- ivy/functional/ivy/data_type.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index 83e8dbae61baa..5739c59c551e8 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -3,6 +3,7 @@ import logging import inspect import math +import functools from numbers import Number from typing import Union, Tuple, List, Optional, Callable, Iterable, Any import numpy as np @@ -48,6 +49,7 @@ def _is_valid_dtypes_attributes(fn: Callable) -> bool: def _handle_nestable_dtype_info(fn): + @functools.wraps(fn) def _handle_nestable_dtype_info_wrapper(type): if isinstance(type, ivy.Container): type = type.cont_map(lambda x, kc: fn(x)) From e0d649317f084fb43a471d303eea32c2b765c297 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 25 Jan 2024 08:50:16 +0530 Subject: [PATCH 672/978] refactor: Removed `Optional typehint` when the default value of an argument is non-None value Co-authored-by: joaozenobio --- .../backends/jax/experimental/losses.py | 7 ++- ivy/functional/backends/jax/layers.py | 2 +- .../backends/numpy/experimental/losses.py | 11 ++-- ivy/functional/backends/numpy/general.py | 2 +- ivy/functional/backends/paddle/creation.py | 10 ++-- .../paddle/experimental/elementwise.py | 20 +++---- ivy/functional/backends/paddle/layers.py | 54 +++++++++---------- .../backends/paddle/linear_algebra.py | 14 ++--- .../backends/tensorflow/creation.py | 6 +-- ivy/functional/ivy/experimental/losses.py | 14 ++--- .../ivy/experimental/manipulation.py | 26 ++++----- 11 files changed, 79 insertions(+), 87 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/losses.py b/ivy/functional/backends/jax/experimental/losses.py index 91aa08c222779..8456c3e1defcf 100644 --- a/ivy/functional/backends/jax/experimental/losses.py +++ b/ivy/functional/backends/jax/experimental/losses.py @@ -1,5 +1,4 @@ import jax.numpy as jnp -from typing import Optional from ivy.functional.backends.jax import JaxArray # local @@ -30,8 +29,8 @@ def smooth_l1_loss( target: JaxArray, /, *, - beta: Optional[float] = 1.0, - reduction: Optional[str] = "mean", + beta: float = 1.0, + reduction: str = "mean", ) -> JaxArray: if beta < 1e-5: loss = jnp.abs(input - target) @@ -52,7 +51,7 @@ def soft_margin_loss( target: JaxArray, /, *, - reduction: Optional[str] = "mean", + reduction: str = "mean", ) -> JaxArray: loss = jnp.sum(jnp.log1p(jnp.exp(-input * target))) / jnp.size(input) diff --git a/ivy/functional/backends/jax/layers.py b/ivy/functional/backends/jax/layers.py index 78a72fb2fb85b..146514399b07b 100644 --- a/ivy/functional/backends/jax/layers.py +++ b/ivy/functional/backends/jax/layers.py @@ -427,7 +427,7 @@ def conv_general_transpose( filter_format: str = "channel_last", data_format: str = "channel_last", dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, - feature_group_count: Optional[int] = 1, + feature_group_count: int = 1, bias: Optional[JaxArray] = None, out: Optional[JaxArray] = None, ): diff --git a/ivy/functional/backends/numpy/experimental/losses.py b/ivy/functional/backends/numpy/experimental/losses.py index 622b3464b3311..359d69c4f30e0 100644 --- a/ivy/functional/backends/numpy/experimental/losses.py +++ b/ivy/functional/backends/numpy/experimental/losses.py @@ -1,5 +1,4 @@ import numpy as np -from typing import Optional from ivy.functional.backends.numpy.helpers import _scalar_output_to_0d_array from ivy.func_wrapper import ( with_unsupported_dtypes, @@ -15,8 +14,8 @@ def huber_loss( target: np.ndarray, /, *, - delta: Optional[float] = 1.0, - reduction: Optional[str] = "mean", + delta: float = 1.0, + reduction: str = "mean", ) -> np.ndarray: abs_diff = np.abs(input - target) quadratic_loss = 0.5 * (abs_diff**2) @@ -39,8 +38,8 @@ def smooth_l1_loss( target: np.ndarray, /, *, - beta: Optional[float] = 1.0, - reduction: Optional[str] = "mean", + beta: float = 1.0, + reduction: str = "mean", ) -> np.ndarray: if beta < 1e-5: loss = np.abs(input - target) @@ -63,7 +62,7 @@ def soft_margin_loss( target: np.ndarray, /, *, - reduction: Optional[str] = "mean", + reduction: str = "mean", ) -> np.ndarray: loss = np.sum(np.log1p(np.exp(-input * target))) / input.size diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index 7c73a37ba78ca..7db6a0c320298 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -47,7 +47,7 @@ def set_item( val: np.ndarray, /, *, - copy: Optional[bool] = False, + copy: bool = False, ) -> np.ndarray: if copy: x = np.copy(x) diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index 347f953338cbb..da61893325591 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -551,7 +551,7 @@ def zeros_like( def copy_array( x: paddle.Tensor, *, - to_ivy_array: Optional[bool] = True, + to_ivy_array: bool = True, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: if 0 in x.shape: @@ -621,9 +621,9 @@ def one_hot( ) def frombuffer( buffer: bytes, - dtype: Optional[paddle.dtype] = float, - count: Optional[int] = -1, - offset: Optional[int] = 0, + dtype: paddle.dtype = float, + count: int = -1, + offset: int = 0, ) -> paddle.Tensor: dtype_bytes = int(ivy.Dtype(dtype).dtype_bits / 8) if str(dtype) == "bool": @@ -658,7 +658,7 @@ def frombuffer( def triu_indices( n_rows: int, n_cols: Optional[int] = None, - k: Optional[int] = 0, + k: int = 0, /, *, device: core.Place = None, diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index b3f4bf64fb9eb..7fabf0b78ef52 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -162,7 +162,7 @@ def nansum( *, axis: Optional[Union[Tuple[int, ...], int]] = None, dtype: Optional[paddle.dtype] = None, - keepdims: Optional[bool] = False, + keepdims: bool = False, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: result = paddle.nansum(x, axis=axis, dtype=dtype, keepdim=keepdims) @@ -179,9 +179,9 @@ def isclose( b: paddle.Tensor, /, *, - rtol: Optional[float] = 1e-05, - atol: Optional[float] = 1e-08, - equal_nan: Optional[bool] = False, + rtol: float = 1e-05, + atol: float = 1e-08, + equal_nan: bool = False, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: return paddle.isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan) @@ -258,9 +258,9 @@ def allclose( x2: paddle.Tensor, /, *, - rtol: Optional[float] = 1e-05, - atol: Optional[float] = 1e-08, - equal_nan: Optional[bool] = False, + rtol: float = 1e-05, + atol: float = 1e-08, + equal_nan: bool = False, out: Optional[paddle.Tensor] = None, ) -> bool: return paddle.allclose(x1, x2, rtol=rtol, atol=atol, equal_nan=equal_nan).squeeze(0) @@ -404,9 +404,9 @@ def gradient( x: paddle.Tensor, /, *, - spacing: Optional[Union[int, list, tuple]] = 1, + spacing: Union[int, list, tuple] = 1, axis: Optional[Union[int, list, tuple]] = None, - edge_order: Optional[int] = 1, + edge_order: int = 1, ) -> Union[paddle.Tensor, List[paddle.Tensor]]: """Https://github.com/numpy/numpy/blob/v1.24.3/numpy/lib/ function_base.py#L969-L1312.""" @@ -645,7 +645,7 @@ def count_nonzero( /, *, axis: Optional[Union[int, list, tuple]] = None, - keepdims: Optional[bool] = False, + keepdims: bool = False, dtype: Optional[paddle.dtype] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py index 03892066f5b8d..fb20e6ae75272 100644 --- a/ivy/functional/backends/paddle/layers.py +++ b/ivy/functional/backends/paddle/layers.py @@ -149,8 +149,8 @@ def conv1d( /, *, data_format: str = "NWC", - filter_format: Optional[str] = "channel_last", - x_dilations: Optional[Union[int, Tuple[int]]] = 1, + filter_format: str = "channel_last", + x_dilations: Union[int, Tuple[int]] = 1, dilations: Union[int, Tuple[int]] = 1, bias: Optional[paddle.Tensor] = None, out: Optional[paddle.Tensor] = None, @@ -210,8 +210,8 @@ def conv2d( /, *, data_format: str = "NHWC", - filter_format: Optional[str] = "channel_last", - x_dilations: Optional[Union[int, Tuple[int, int]]] = 1, + filter_format: str = "channel_last", + x_dilations: Union[int, Tuple[int, int]] = 1, dilations: Union[int, Tuple[int, int]] = 1, bias: Optional[paddle.Tensor] = None, out: Optional[paddle.Tensor] = None, @@ -232,8 +232,8 @@ def conv2d_transpose( *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, filter_format: str = "channel_last", - data_format: Optional[str] = "NHWC", - dilations: Optional[Union[int, Tuple[int, int]]] = 1, + data_format: str = "NHWC", + dilations: Union[int, Tuple[int, int]] = 1, bias: Optional[paddle.Tensor] = None, out: Optional[paddle.Tensor] = None, ): @@ -273,8 +273,8 @@ def depthwise_conv2d( padding: Union[str, int, Sequence[Tuple[int, int]]], /, *, - data_format: Optional[str] = "NHWC", - dilations: Optional[Union[int, Tuple[int, int]]] = 1, + data_format: str = "NHWC", + dilations: Union[int, Tuple[int, int]] = 1, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: raise IvyNotImplementedException() @@ -291,10 +291,10 @@ def conv3d( padding: Union[str, int, Sequence[Tuple[int, int]]], /, *, - data_format: Optional[str] = "NDHWC", - filter_format: Optional[str] = "channel_last", - x_dilations: Optional[Union[int, Tuple[int, int, int]]] = 1, - dilations: Optional[Union[int, Tuple[int, int, int]]] = 1, + data_format: str = "NDHWC", + filter_format: str = "channel_last", + x_dilations: Union[int, Tuple[int, int, int]] = 1, + dilations: Union[int, Tuple[int, int, int]] = 1, bias: Optional[paddle.Tensor] = None, out: Optional[paddle.Tensor] = None, ): @@ -332,8 +332,8 @@ def conv3d_transpose( *, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, filter_format: str = "channel_last", - data_format: Optional[str] = "NDHWC", - dilations: Optional[Union[int, Tuple[int, int, int]]] = 1, + data_format: str = "NDHWC", + dilations: Union[int, Tuple[int, int, int]] = 1, bias: Optional[paddle.Tensor] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: @@ -351,16 +351,12 @@ def conv_general_dilated( padding: Union[str, int, Sequence[Tuple[int, int]]], /, *, - dims: Optional[int] = 2, - data_format: Optional[str] = "channel_last", - filter_format: Optional[str] = "channel_last", - feature_group_count: Optional[int] = 1, - x_dilations: Optional[ - Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] - ] = 1, - dilations: Optional[ - Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] - ] = 1, + dims: int = 2, + data_format: str = "channel_last", + filter_format: str = "channel_last", + feature_group_count: int = 1, + x_dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, + dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, bias: Optional[paddle.Tensor] = None, out: Optional[paddle.Tensor] = None, ): @@ -432,14 +428,12 @@ def conv_general_transpose( padding: Union[str, Sequence[Tuple[int, int]]], /, *, - dims: Optional[int] = 2, + dims: int = 2, output_shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, filter_format: str = "channel_last", - data_format: Optional[str] = "NDHWC", - dilations: Optional[ - Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] - ] = 1, - feature_group_count: Optional[int] = 1, + data_format: str = "NDHWC", + dilations: Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int]] = 1, + feature_group_count: int = 1, bias: Optional[paddle.Tensor] = None, out: Optional[paddle.Tensor] = None, ): diff --git a/ivy/functional/backends/paddle/linear_algebra.py b/ivy/functional/backends/paddle/linear_algebra.py index 21694a6879290..cac523656a3b0 100644 --- a/ivy/functional/backends/paddle/linear_algebra.py +++ b/ivy/functional/backends/paddle/linear_algebra.py @@ -144,7 +144,7 @@ def eigh( x: paddle.Tensor, /, *, - UPLO: Optional[str] = "L", + UPLO: str = "L", out: Optional[paddle.Tensor] = None, ) -> Tuple[paddle.Tensor]: result_tuple = NamedTuple( @@ -158,7 +158,7 @@ def eigvalsh( x: paddle.Tensor, /, *, - UPLO: Optional[str] = "L", + UPLO: str = "L", out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: return paddle.linalg.eigvalsh(x, UPLO=UPLO) @@ -259,8 +259,8 @@ def matrix_norm( x: paddle.Tensor, /, *, - ord: Optional[Union[int, float, Literal[inf, -inf, "fro", "nuc"]]] = "fro", - axis: Optional[Tuple[int, int]] = (-2, -1), + ord: Union[int, float, Literal[inf, -inf, "fro", "nuc"]] = "fro", + axis: Tuple[int, int] = (-2, -1), keepdims: bool = False, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: @@ -353,7 +353,7 @@ def matrix_rank( *, atol: Optional[Union[float, Tuple[float]]] = None, rtol: Optional[Union[float, Tuple[float]]] = None, - hermitian: Optional[bool] = False, + hermitian: bool = False, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: if (x.ndim < 2) or (0 in x.shape): @@ -592,8 +592,8 @@ def vector_norm( /, *, axis: Optional[Union[int, Sequence[int]]] = None, - keepdims: Optional[bool] = False, - ord: Optional[Union[int, float, Literal[inf, -inf]]] = 2, + keepdims: bool = False, + ord: Union[int, float, Literal[inf, -inf]] = 2, dtype: Optional[paddle.dtype] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py index bdcbddf911f89..2b7f602d8a2dd 100644 --- a/ivy/functional/backends/tensorflow/creation.py +++ b/ivy/functional/backends/tensorflow/creation.py @@ -393,9 +393,9 @@ def one_hot( @with_unsupported_dtypes({"2.15.0 and below": ("uint32", "uint64")}, backend_version) def frombuffer( buffer: bytes, - dtype: Optional[tf.DType] = float, - count: Optional[int] = -1, - offset: Optional[int] = 0, + dtype: tf.DType = float, + count: int = -1, + offset: int = 0, ) -> Union[tf.Tensor, tf.Variable]: if isinstance(buffer, bytearray): buffer = bytes(buffer) diff --git a/ivy/functional/ivy/experimental/losses.py b/ivy/functional/ivy/experimental/losses.py index 394863b5ddc26..bcf72c68008fd 100644 --- a/ivy/functional/ivy/experimental/losses.py +++ b/ivy/functional/ivy/experimental/losses.py @@ -107,7 +107,7 @@ def l1_loss( target: Union[ivy.Array, ivy.NativeArray], /, *, - reduction: Optional[str] = "mean", + reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: """ @@ -165,8 +165,8 @@ def huber_loss( pred: Union[ivy.Array, ivy.NativeArray], /, *, - delta: Optional[float] = 1.0, - reduction: Optional[str] = "mean", + delta: float = 1.0, + reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: """Compute the Huber loss (smooth L1 loss) between true and predicted @@ -230,8 +230,8 @@ def smooth_l1_loss( target: Union[ivy.Array, ivy.NativeArray], /, *, - beta: Optional[float] = 1.0, - reduction: Optional[str] = "mean", + beta: float = 1.0, + reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: """Compute the smooth L1 loss between two input tensors. @@ -359,7 +359,7 @@ def soft_margin_loss( target: Union[ivy.Array, ivy.NativeArray], /, *, - reduction: Optional[str] = "mean", + reduction: str = "mean", out: Optional[ivy.Array] = None, ) -> ivy.Array: """Compute the soft-margin hinge loss between predicted scores and true @@ -419,7 +419,7 @@ def kl_div( target: Union[ivy.Array, ivy.NativeArray], /, *, - reduction: Optional[str] = "mean", + reduction: str = "mean", log_target=False, out: Optional[ivy.Array] = None, ) -> ivy.Array: diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index 604dab42cbe64..a4bf5fd435a47 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -98,9 +98,9 @@ def flatten( /, *, copy: Optional[bool] = None, - start_dim: Optional[int] = 0, - end_dim: Optional[int] = -1, - order: Optional[str] = "C", + start_dim: int = 0, + end_dim: int = -1, + order: str = "C", out: Optional[ivy.Array] = None, ) -> ivy.Array: """Flattens input by reshaping it into a one-dimensional tensor. If @@ -2231,7 +2231,7 @@ def fill_diagonal( def unfold( x: Union[ivy.Array, ivy.NativeArray], /, - mode: Optional[int] = 0, + mode: int = 0, *, out: Optional[ivy.Array] = None, ) -> ivy.Array: @@ -2303,10 +2303,10 @@ def fold( def partial_unfold( x: Union[ivy.Array, ivy.NativeArray], /, - mode: Optional[int] = 0, - skip_begin: Optional[int] = 1, - skip_end: Optional[int] = 0, - ravel_tensors: Optional[bool] = False, + mode: int = 0, + skip_begin: int = 1, + skip_end: int = 0, + ravel_tensors: bool = False, *, out: Optional[ivy.Array] = None, ) -> ivy.Array: @@ -2363,7 +2363,7 @@ def partial_fold( /, mode: int, shape: Union[ivy.Shape, ivy.NativeShape, Sequence[int]], - skip_begin: Optional[int] = 1, + skip_begin: int = 1, *, out: Optional[ivy.Array] = None, ) -> ivy.Array: @@ -2404,8 +2404,8 @@ def partial_fold( def partial_tensor_to_vec( x: Union[ivy.Array, ivy.NativeArray], /, - skip_begin: Optional[int] = 1, - skip_end: Optional[int] = 0, + skip_begin: int = 1, + skip_end: int = 0, *, out: Optional[ivy.Array] = None, ) -> ivy.Array: @@ -2449,7 +2449,7 @@ def partial_vec_to_tensor( x: Union[ivy.Array, ivy.NativeArray], /, shape: Union[ivy.Shape, ivy.NativeShape, Sequence[int]], - skip_begin: Optional[int] = 1, + skip_begin: int = 1, *, out: Optional[ivy.Array] = None, ) -> ivy.Array: @@ -2828,7 +2828,7 @@ def trim_zeros( a: Union[ivy.Array, ivy.NativeArray], /, *, - trim: Optional[str] = "fb", + trim: str = "fb", ) -> ivy.Array: """ivy.Container instance method variant of ivy.trim_zeros. This method simply wraps the function, and so the docstring for ivy.trim_zeros also From 8ff497a8c592b75f010160b313dc431218c2b475 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 25 Jan 2024 08:52:15 +0530 Subject: [PATCH 673/978] fix: Fixed inconsistent `naming` of some tests (#28028) Co-authored-by: joaozenobio --- .../test_frontends/test_jax/test_array.py | 586 ++++++++--------- .../test_paddle/test_tensor/test_tensor.py | 592 +++++++++--------- .../test_tensorflow/test_tensor.py | 146 ++--- .../test_frontends/test_torch/test_tensor.py | 62 +- 4 files changed, 693 insertions(+), 693 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py index 8fa019823c2c0..546387bf6b111 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py @@ -208,15 +208,13 @@ def dtype_x_axis(draw): @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__add__", - dtype_x=helpers.dtype_and_values( + method_name="__abs__", + dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, - num_arrays=2, ), ) -def test_jax___add__( - dtype_x, +def test_jax___abs__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -224,7 +222,7 @@ def test_jax___add__( backend_fw, on_device, ): - input_dtype, x = dtype_x + input_dtype, x = dtype_and_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -232,7 +230,7 @@ def test_jax___add__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -244,14 +242,14 @@ def test_jax___add__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__div__", + method_name="__add__", dtype_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("numeric"), shared_dtype=True, num_arrays=2, ), ) -def test_jax___div__( +def test_jax___add__( dtype_x, frontend, frontend_method_data, @@ -261,7 +259,6 @@ def test_jax___div__( on_device, ): input_dtype, x = dtype_x - assume(not np.any(np.isclose(x[1], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -278,17 +275,18 @@ def test_jax___div__( ) -# __getitem__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__getitem__", - dtype_x_index=helpers.dtype_array_query( - available_dtypes=helpers.get_dtypes("valid"), - ).filter(lambda x: not (isinstance(x[-1], np.ndarray) and x[-1].dtype == np.bool_)), + method_name="__and__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), + num_arrays=2, + shared_dtype=True, + ), ) -def test_jax___getitem__( - dtype_x_index, +def test_jax___and__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -296,13 +294,15 @@ def test_jax___getitem__( backend_fw, on_device, ): - input_dtype, x, index = dtype_x_index + input_dtype, x = dtype_and_x helpers.test_frontend_method( - init_input_dtypes=[input_dtype[0]], + init_input_dtypes=input_dtype, backend_to_test=backend_fw, - init_all_as_kwargs_np={"object": x}, - method_input_dtypes=[*input_dtype[1:]], - method_all_as_kwargs_np={"idx": index}, + init_all_as_kwargs_np={ + "object": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -314,13 +314,15 @@ def test_jax___getitem__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__invert__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), + method_name="__div__", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + shared_dtype=True, + num_arrays=2, ), ) -def test_jax___invert__( - dtype_and_x, +def test_jax___div__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -328,7 +330,8 @@ def test_jax___invert__( backend_fw, on_device, ): - input_dtype, x = dtype_and_x + input_dtype, x = dtype_x + assume(not np.any(np.isclose(x[1], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -336,7 +339,7 @@ def test_jax___invert__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={}, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -348,11 +351,14 @@ def test_jax___invert__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__lshift__", - dtype_x_shift=_get_dtype_x_and_int_shift(dtype="signed_integer"), + method_name="__eq__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + ), ) -def test_jax___lshift__( - dtype_x_shift, +def test_jax___eq__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -360,15 +366,18 @@ def test_jax___lshift__( backend_fw, on_device, ): - input_dtype, x, shift = dtype_x_shift + input_dtype, x = dtype_and_x + assume("bfloat16" not in input_dtype) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "object": x, + "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": shift}, + method_all_as_kwargs_np={ + "other": x[1], + }, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -380,11 +389,14 @@ def test_jax___lshift__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__matmul__", - dtype_x=_get_dtype_input_and_vectors(), + method_name="__ge__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float_and_integer"), + num_arrays=2, + ), ) -def test_jax___matmul__( - dtype_x, +def test_jax___ge__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -392,7 +404,8 @@ def test_jax___matmul__( backend_fw, on_device, ): - input_dtype, x = dtype_x + input_dtype, x = dtype_and_x + assume("bfloat16" not in input_dtype) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -400,7 +413,9 @@ def test_jax___matmul__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={ + "other": x[1], + }, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -409,18 +424,17 @@ def test_jax___matmul__( ) +# __getitem__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__mod__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, - num_arrays=2, - ), + method_name="__getitem__", + dtype_x_index=helpers.dtype_array_query( + available_dtypes=helpers.get_dtypes("valid"), + ).filter(lambda x: not (isinstance(x[-1], np.ndarray) and x[-1].dtype == np.bool_)), ) -def test_jax___mod__( - dtype_x, +def test_jax___getitem__( + dtype_x_index, frontend, frontend_method_data, init_flags, @@ -428,16 +442,13 @@ def test_jax___mod__( backend_fw, on_device, ): - input_dtype, x = dtype_x - assume(not np.any(np.isclose(x[1], 0))) + input_dtype, x, index = dtype_x_index helpers.test_frontend_method( - init_input_dtypes=input_dtype, + init_input_dtypes=[input_dtype[0]], backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "object": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + init_all_as_kwargs_np={"object": x}, + method_input_dtypes=[*input_dtype[1:]], + method_all_as_kwargs_np={"idx": index}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -449,15 +460,14 @@ def test_jax___mod__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__mul__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, + method_name="__gt__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float_and_integer"), num_arrays=2, ), ) -def test_jax___mul__( - dtype_x, +def test_jax___gt__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -465,7 +475,8 @@ def test_jax___mul__( backend_fw, on_device, ): - input_dtype, x = dtype_x + input_dtype, x = dtype_and_x + assume("bfloat16" not in input_dtype) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -473,7 +484,9 @@ def test_jax___mul__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={ + "other": x[1], + }, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -485,15 +498,13 @@ def test_jax___mul__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__radd__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, - num_arrays=2, + method_name="__invert__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), ), ) -def test_jax___radd__( - dtype_x, +def test_jax___invert__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -501,7 +512,7 @@ def test_jax___radd__( backend_fw, on_device, ): - input_dtype, x = dtype_x + input_dtype, x = dtype_and_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -509,7 +520,7 @@ def test_jax___radd__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -521,15 +532,14 @@ def test_jax___radd__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rdiv__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, + method_name="__le__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float_and_integer"), num_arrays=2, ), ) -def test_jax___rdiv__( - dtype_x, +def test_jax___le__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -537,8 +547,8 @@ def test_jax___rdiv__( backend_fw, on_device, ): - input_dtype, x = dtype_x - assume(not np.any(np.isclose(x[0], 0))) + input_dtype, x = dtype_and_x + assume("bfloat16" not in input_dtype) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -546,7 +556,9 @@ def test_jax___rdiv__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={ + "other": x[1], + }, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -558,10 +570,10 @@ def test_jax___rdiv__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rlshift__", + method_name="__lshift__", dtype_x_shift=_get_dtype_x_and_int_shift(dtype="signed_integer"), ) -def test_jax___rlshift__( +def test_jax___lshift__( dtype_x_shift, frontend, frontend_method_data, @@ -575,10 +587,10 @@ def test_jax___rlshift__( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "object": shift, + "object": x, }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x}, + method_all_as_kwargs_np={"other": shift}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -590,11 +602,15 @@ def test_jax___rlshift__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rmatmul__", - dtype_x=_get_dtype_input_and_vectors(), + method_name="__lt__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float_and_integer"), + num_arrays=2, + shared_dtype=True, + ), ) -def test_jax___rmatmul__( - dtype_x, +def test_jax___lt__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -602,7 +618,7 @@ def test_jax___rmatmul__( backend_fw, on_device, ): - input_dtype, x = dtype_x + input_dtype, x = dtype_and_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -610,7 +626,9 @@ def test_jax___rmatmul__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={ + "other": x[1], + }, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -622,14 +640,10 @@ def test_jax___rmatmul__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rmod__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, - num_arrays=2, - ), + method_name="__matmul__", + dtype_x=_get_dtype_input_and_vectors(), ) -def test_jax___rmod__( +def test_jax___matmul__( dtype_x, frontend, frontend_method_data, @@ -639,7 +653,6 @@ def test_jax___rmod__( on_device, ): input_dtype, x = dtype_x - assume(not np.any(np.isclose(x[0], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -659,14 +672,14 @@ def test_jax___rmod__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rmul__", + method_name="__mod__", dtype_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("numeric"), shared_dtype=True, num_arrays=2, ), ) -def test_jax___rmul__( +def test_jax___mod__( dtype_x, frontend, frontend_method_data, @@ -676,6 +689,7 @@ def test_jax___rmul__( on_device, ): input_dtype, x = dtype_x + assume(not np.any(np.isclose(x[1], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -695,11 +709,15 @@ def test_jax___rmul__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rrshift__", - dtype_x_shift=_get_dtype_x_and_int_shift(dtype="signed_integer"), + method_name="__mul__", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + shared_dtype=True, + num_arrays=2, + ), ) -def test_jax___rrshift__( - dtype_x_shift, +def test_jax___mul__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -707,15 +725,15 @@ def test_jax___rrshift__( backend_fw, on_device, ): - input_dtype, x, shift = dtype_x_shift + input_dtype, x = dtype_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "object": shift, + "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x}, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -727,11 +745,14 @@ def test_jax___rrshift__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rshift__", - dtype_x_shift=_get_dtype_x_and_int_shift(dtype="signed_integer"), + method_name="__ne__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + ), ) -def test_jax___rshift__( - dtype_x_shift, +def test_jax___ne__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -739,15 +760,18 @@ def test_jax___rshift__( backend_fw, on_device, ): - input_dtype, x, shift = dtype_x_shift + input_dtype, x = dtype_and_x + assume("bfloat16" not in input_dtype) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "object": x, + "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": shift}, + method_all_as_kwargs_np={ + "other": x[1], + }, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -759,15 +783,13 @@ def test_jax___rshift__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rsub__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, - num_arrays=2, + method_name="__neg__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("signed_integer"), ), ) -def test_jax___rsub__( - dtype_x, +def test_jax___neg__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -775,7 +797,7 @@ def test_jax___rsub__( backend_fw, on_device, ): - input_dtype, x = dtype_x + input_dtype, x = dtype_and_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -783,7 +805,7 @@ def test_jax___rsub__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -795,15 +817,15 @@ def test_jax___rsub__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rtruediv__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, + method_name="__or__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), num_arrays=2, + shared_dtype=True, ), ) -def test_jax___rtruediv__( - dtype_x, +def test_jax___or__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -811,8 +833,7 @@ def test_jax___rtruediv__( backend_fw, on_device, ): - input_dtype, x = dtype_x - assume(not np.any(np.isclose(x[0], 0))) + input_dtype, x = dtype_and_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -832,15 +853,13 @@ def test_jax___rtruediv__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__sub__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, - num_arrays=2, + method_name="__pos__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), ), ) -def test_jax___sub__( - dtype_x, +def test_jax___pos__( + dtype_and_x, frontend, frontend_method_data, init_flags, @@ -848,38 +867,35 @@ def test_jax___sub__( backend_fw, on_device, ): - input_dtype, x = dtype_x + input_dtype, x = dtype_and_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, + on_device=on_device, init_all_as_kwargs_np={ "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, - on_device=on_device, ) @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__truediv__", - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - shared_dtype=True, + method_name="__pow__", + dtype_x_pow=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), num_arrays=2, - large_abs_safety_factor=2, - small_abs_safety_factor=2, - safety_factor_scale="log", + shared_dtype=True, ), ) -def test_jax___truediv__( - dtype_x, +def test_jax___pow__( + dtype_x_pow, frontend, frontend_method_data, init_flags, @@ -887,8 +903,7 @@ def test_jax___truediv__( backend_fw, on_device, ): - input_dtype, x = dtype_x - assume(not np.any(np.isclose(x[1], 0))) + input_dtype, x = dtype_x_pow helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -896,7 +911,9 @@ def test_jax___truediv__( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={ + "other": x[1], + }, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -908,13 +925,15 @@ def test_jax___truediv__( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__abs__", - dtype_and_x=helpers.dtype_and_values( + method_name="__radd__", + dtype_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("numeric"), + shared_dtype=True, + num_arrays=2, ), ) -def test_jax__abs_( - dtype_and_x, +def test_jax___radd__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -922,7 +941,7 @@ def test_jax__abs_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x + input_dtype, x = dtype_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -930,7 +949,7 @@ def test_jax__abs_( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={}, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -942,14 +961,14 @@ def test_jax__abs_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__and__", + method_name="__rand__", dtype_and_x=helpers.dtype_and_values( available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), num_arrays=2, shared_dtype=True, ), ) -def test_jax__and_( +def test_jax___rand__( dtype_and_x, frontend, frontend_method_data, @@ -978,14 +997,15 @@ def test_jax__and_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__eq__", - dtype_and_x=helpers.dtype_and_values( + method_name="__rdiv__", + dtype_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("numeric"), + shared_dtype=True, num_arrays=2, ), ) -def test_jax__eq_( - dtype_and_x, +def test_jax___rdiv__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -993,8 +1013,8 @@ def test_jax__eq_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x - assume("bfloat16" not in input_dtype) + input_dtype, x = dtype_x + assume(not np.any(np.isclose(x[0], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1002,9 +1022,7 @@ def test_jax__eq_( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1016,14 +1034,11 @@ def test_jax__eq_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__ge__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float_and_integer"), - num_arrays=2, - ), + method_name="__rlshift__", + dtype_x_shift=_get_dtype_x_and_int_shift(dtype="signed_integer"), ) -def test_jax__ge_( - dtype_and_x, +def test_jax___rlshift__( + dtype_x_shift, frontend, frontend_method_data, init_flags, @@ -1031,18 +1046,15 @@ def test_jax__ge_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x - assume("bfloat16" not in input_dtype) + input_dtype, x, shift = dtype_x_shift helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "object": x[0], + "object": shift, }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, + method_all_as_kwargs_np={"other": x}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1054,14 +1066,11 @@ def test_jax__ge_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__gt__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float_and_integer"), - num_arrays=2, - ), + method_name="__rmatmul__", + dtype_x=_get_dtype_input_and_vectors(), ) -def test_jax__gt_( - dtype_and_x, +def test_jax___rmatmul__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -1069,8 +1078,7 @@ def test_jax__gt_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x - assume("bfloat16" not in input_dtype) + input_dtype, x = dtype_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1078,9 +1086,7 @@ def test_jax__gt_( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1092,14 +1098,15 @@ def test_jax__gt_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__le__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float_and_integer"), + method_name="__rmod__", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + shared_dtype=True, num_arrays=2, ), ) -def test_jax__le_( - dtype_and_x, +def test_jax___rmod__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -1107,8 +1114,8 @@ def test_jax__le_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x - assume("bfloat16" not in input_dtype) + input_dtype, x = dtype_x + assume(not np.any(np.isclose(x[0], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1116,9 +1123,7 @@ def test_jax__le_( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1130,15 +1135,15 @@ def test_jax__le_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__lt__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float_and_integer"), - num_arrays=2, + method_name="__rmul__", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), shared_dtype=True, + num_arrays=2, ), ) -def test_jax__lt_( - dtype_and_x, +def test_jax___rmul__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -1146,7 +1151,7 @@ def test_jax__lt_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x + input_dtype, x = dtype_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1154,9 +1159,7 @@ def test_jax__lt_( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1168,13 +1171,14 @@ def test_jax__lt_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__ne__", + method_name="__ror__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), num_arrays=2, + shared_dtype=True, ), ) -def test_jax__ne_( +def test_jax___ror__( dtype_and_x, frontend, frontend_method_data, @@ -1184,7 +1188,6 @@ def test_jax__ne_( on_device, ): input_dtype, x = dtype_and_x - assume("bfloat16" not in input_dtype) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1192,9 +1195,7 @@ def test_jax__ne_( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1206,13 +1207,11 @@ def test_jax__ne_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__neg__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("signed_integer"), - ), + method_name="__rpow__", + dtype_x_pow=_get_dtype_x_and_int(), ) -def test_jax__neg_( - dtype_and_x, +def test_jax___rpow__( + dtype_x_pow, frontend, frontend_method_data, init_flags, @@ -1220,15 +1219,17 @@ def test_jax__neg_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x + input_dtype, x, pow = dtype_x_pow helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "object": x[0], + "object": pow[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={}, + method_all_as_kwargs_np={ + "other": x[0], + }, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1240,15 +1241,11 @@ def test_jax__neg_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__or__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), - num_arrays=2, - shared_dtype=True, - ), + method_name="__rrshift__", + dtype_x_shift=_get_dtype_x_and_int_shift(dtype="signed_integer"), ) -def test_jax__or_( - dtype_and_x, +def test_jax___rrshift__( + dtype_x_shift, frontend, frontend_method_data, init_flags, @@ -1256,15 +1253,15 @@ def test_jax__or_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x + input_dtype, x, shift = dtype_x_shift helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "object": x[0], + "object": shift, }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={"other": x[1]}, + method_all_as_kwargs_np={"other": x}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1276,13 +1273,11 @@ def test_jax__or_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__pos__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), - ), + method_name="__rshift__", + dtype_x_shift=_get_dtype_x_and_int_shift(dtype="signed_integer"), ) -def test_jax__pos_( - dtype_and_x, +def test_jax___rshift__( + dtype_x_shift, frontend, frontend_method_data, init_flags, @@ -1290,35 +1285,35 @@ def test_jax__pos_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x + input_dtype, x, shift = dtype_x_shift helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, - on_device=on_device, init_all_as_kwargs_np={ - "object": x[0], + "object": x, }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={}, + method_all_as_kwargs_np={"other": shift}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, + on_device=on_device, ) @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__pow__", - dtype_x_pow=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), - num_arrays=2, + method_name="__rsub__", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), shared_dtype=True, + num_arrays=2, ), ) -def test_jax__pow_( - dtype_x_pow, +def test_jax___rsub__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -1326,7 +1321,7 @@ def test_jax__pow_( backend_fw, on_device, ): - input_dtype, x = dtype_x_pow + input_dtype, x = dtype_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1334,9 +1329,7 @@ def test_jax__pow_( "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1348,15 +1341,15 @@ def test_jax__pow_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rand__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), - num_arrays=2, + method_name="__rtruediv__", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), shared_dtype=True, + num_arrays=2, ), ) -def test_jax__rand_( - dtype_and_x, +def test_jax___rtruediv__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -1364,7 +1357,8 @@ def test_jax__rand_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x + input_dtype, x = dtype_x + assume(not np.any(np.isclose(x[0], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1384,14 +1378,14 @@ def test_jax__rand_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__ror__", + method_name="__rxor__", dtype_and_x=helpers.dtype_and_values( available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), num_arrays=2, shared_dtype=True, ), ) -def test_jax__ror_( +def test_jax___rxor__( dtype_and_x, frontend, frontend_method_data, @@ -1420,11 +1414,15 @@ def test_jax__ror_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rpow__", - dtype_x_pow=_get_dtype_x_and_int(), + method_name="__sub__", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + shared_dtype=True, + num_arrays=2, + ), ) -def test_jax__rpow_( - dtype_x_pow, +def test_jax___sub__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -1432,17 +1430,15 @@ def test_jax__rpow_( backend_fw, on_device, ): - input_dtype, x, pow = dtype_x_pow + input_dtype, x = dtype_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "object": pow[0], + "object": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[0], - }, + method_all_as_kwargs_np={"other": x[1]}, frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, @@ -1454,15 +1450,18 @@ def test_jax__rpow_( @handle_frontend_method( class_tree=CLASS_TREE, init_tree="jax.numpy.array", - method_name="__rxor__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), - num_arrays=2, + method_name="__truediv__", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), shared_dtype=True, + num_arrays=2, + large_abs_safety_factor=2, + small_abs_safety_factor=2, + safety_factor_scale="log", ), ) -def test_jax__rxor_( - dtype_and_x, +def test_jax___truediv__( + dtype_x, frontend, frontend_method_data, init_flags, @@ -1470,7 +1469,8 @@ def test_jax__rxor_( backend_fw, on_device, ): - input_dtype, x = dtype_and_x + input_dtype, x = dtype_x + assume(not np.any(np.isclose(x[1], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1497,7 +1497,7 @@ def test_jax__rxor_( shared_dtype=True, ), ) -def test_jax__xor_( +def test_jax___xor__( dtype_and_x, frontend, frontend_method_data, diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index bb38c75a90680..60bc850a30f8a 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -418,90 +418,56 @@ def test_paddle___add__( ) -# __ge__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__ge__", + method_name="__float__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True + available_dtypes=helpers.get_dtypes("numeric"), + max_num_dims=0, ), ) -def test_paddle___ge__( +def test_paddle___float__( dtype_and_x, frontend_method_data, init_flags, method_flags, - frontend, - on_device, backend_fw, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "y": x[1], - }, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - - -# __gt__ -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="__gt__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True - ), -) -def test_paddle___gt__( - dtype_and_x, - frontend_method_data, - init_flags, - method_flags, frontend, on_device, - backend_fw, ): - input_dtype, x = dtype_and_x + input_dtypes, xs = dtype_and_x + # Numpy doesn't support complex to float conversion + assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) helpers.test_frontend_method( - init_input_dtypes=input_dtype, + init_input_dtypes=input_dtypes, backend_to_test=backend_fw, + method_input_dtypes=input_dtypes, init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "y": x[1], + "object": xs[0], }, + method_all_as_kwargs_np={}, + frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, - frontend=frontend, on_device=on_device, ) -# __le__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__le__", + method_name="__floordiv__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + available_dtypes=helpers.get_dtypes("float"), + num_arrays=2, + large_abs_safety_factor=2.5, + small_abs_safety_factor=2.5, + safety_factor_scale="log", ), ) -def test_paddle___le__( +def test_paddle___floordiv__( dtype_and_x, frontend_method_data, init_flags, @@ -511,6 +477,7 @@ def test_paddle___le__( backend_fw, ): input_dtype, x = dtype_and_x + assume(not np.any(np.isclose(x[1], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -519,26 +486,27 @@ def test_paddle___le__( }, method_input_dtypes=input_dtype, method_all_as_kwargs_np={ - "y": x[1], + "other": x[1], }, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, frontend=frontend, on_device=on_device, + atol_=1, ) -# __lt__ +# __ge__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__lt__", + method_name="__ge__", dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True ), ) -def test_paddle___lt__( +def test_paddle___ge__( dtype_and_x, frontend_method_data, init_flags, @@ -566,17 +534,18 @@ def test_paddle___lt__( ) -# __mul__ +# __getitem__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__mul__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True - ), + method_name="__getitem__", + dtype_x_index=helpers.dtype_array_query( + available_dtypes=helpers.get_dtypes("valid"), + allow_neg_step=False, + ).filter(lambda x: x[0][0] == x[0][-1] and _filter_query(x[-2])), ) -def test_paddle___mul__( - dtype_and_x, +def test_paddle___getitem__( + dtype_x_index, frontend_method_data, init_flags, method_flags, @@ -584,17 +553,13 @@ def test_paddle___mul__( on_device, backend_fw, ): - input_dtype, x = dtype_and_x + input_dtype, x, index = dtype_x_index helpers.test_frontend_method( - init_input_dtypes=input_dtype, + init_input_dtypes=[input_dtype[0]], backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "y": x[1], - }, + init_all_as_kwargs_np={"data": x}, + method_input_dtypes=[*input_dtype[1:]], + method_all_as_kwargs_np={"item": index}, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, @@ -603,16 +568,16 @@ def test_paddle___mul__( ) -# __or__ +# __gt__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__or__", + method_name="__gt__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("integer"), num_arrays=2, shared_dtype=True + available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True ), ) -def test_paddle___or__( +def test_paddle___gt__( dtype_and_x, frontend_method_data, init_flags, @@ -640,123 +605,56 @@ def test_paddle___or__( ) -# __radd__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__radd__", + method_name="__int__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + available_dtypes=helpers.get_dtypes("integer"), + max_num_dims=0, + min_value=-1e15, + max_value=1e15, ), ) -def test_paddle___radd__( +def test_paddle___int__( dtype_and_x, frontend_method_data, init_flags, method_flags, - frontend, - on_device, - backend_fw, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "x": x[1], - }, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - - -# __setitem__ -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="__setitem__", - dtypes_x_index_val=helpers.dtype_array_query_val( - available_dtypes=helpers.get_dtypes("valid"), - ).filter(lambda x: x[0][0] == x[0][-1] and _filter_query(x[-2])), -) -def test_paddle___setitem__( - dtypes_x_index_val, - frontend_method_data, - init_flags, - method_flags, - frontend, - on_device, backend_fw, -): - input_dtype, x, index, val = dtypes_x_index_val - helpers.test_frontend_method( - init_input_dtypes=[input_dtype[0]], - backend_to_test=backend_fw, - init_all_as_kwargs_np={"data": x}, - method_input_dtypes=[*input_dtype[1:]], - method_all_as_kwargs_np={"item": index, "value": val}, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - - -# __sub__ -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="__sub__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True - ), -) -def test_paddle___sub__( - dtype_and_x, - frontend_method_data, - init_flags, - method_flags, frontend, on_device, - backend_fw, ): - input_dtype, x = dtype_and_x + input_dtypes, xs = dtype_and_x + # Numpy doesn't support complex to int conversion + assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) helpers.test_frontend_method( - init_input_dtypes=input_dtype, + init_input_dtypes=input_dtypes, backend_to_test=backend_fw, + method_input_dtypes=input_dtypes, init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "y": x[1], + "object": xs[0], }, + method_all_as_kwargs_np={}, + frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, - frontend=frontend, on_device=on_device, ) +# invert @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__float__", + method_name="__invert__", dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("numeric"), max_num_dims=0, ), ) -def test_paddle__float__( +def test_paddle___invert__( dtype_and_x, frontend_method_data, init_flags, @@ -766,8 +664,6 @@ def test_paddle__float__( on_device, ): input_dtypes, xs = dtype_and_x - # Numpy doesn't support complex to float conversion - assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) helpers.test_frontend_method( init_input_dtypes=input_dtypes, backend_to_test=backend_fw, @@ -784,19 +680,16 @@ def test_paddle__float__( ) +# __le__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__floordiv__", + method_name="__le__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), - num_arrays=2, - large_abs_safety_factor=2.5, - small_abs_safety_factor=2.5, - safety_factor_scale="log", + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True ), ) -def test_paddle__floordiv__( +def test_paddle___le__( dtype_and_x, frontend_method_data, init_flags, @@ -806,7 +699,6 @@ def test_paddle__floordiv__( backend_fw, ): input_dtype, x = dtype_and_x - assume(not np.any(np.isclose(x[1], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -815,81 +707,43 @@ def test_paddle__floordiv__( }, method_input_dtypes=input_dtype, method_all_as_kwargs_np={ - "other": x[1], + "y": x[1], }, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, frontend=frontend, on_device=on_device, - atol_=1, - ) - - -# __getitem__ -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="paddle.to_tensor", - method_name="__getitem__", - dtype_x_index=helpers.dtype_array_query( - available_dtypes=helpers.get_dtypes("valid"), - allow_neg_step=False, - ).filter(lambda x: x[0][0] == x[0][-1] and _filter_query(x[-2])), -) -def test_paddle__getitem__( - dtype_x_index, - frontend_method_data, - init_flags, - method_flags, - frontend, - on_device, - backend_fw, -): - input_dtype, x, index = dtype_x_index - helpers.test_frontend_method( - init_input_dtypes=[input_dtype[0]], - backend_to_test=backend_fw, - init_all_as_kwargs_np={"data": x}, - method_input_dtypes=[*input_dtype[1:]], - method_all_as_kwargs_np={"item": index}, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, ) +# __len__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__int__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("integer"), - max_num_dims=0, - min_value=-1e15, - max_value=1e15, + method_name="__len__", + dtype_and_x=_array_and_shape( + min_num_dims=1, + max_num_dims=5, ), ) -def test_paddle__int__( +def test_paddle___len__( dtype_and_x, + frontend, frontend_method_data, init_flags, method_flags, backend_fw, - frontend, on_device, ): - input_dtypes, xs = dtype_and_x - # Numpy doesn't support complex to int conversion - assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) + input_dtype, x = dtype_and_x helpers.test_frontend_method( - init_input_dtypes=input_dtypes, + init_input_dtypes=input_dtype, backend_to_test=backend_fw, - method_input_dtypes=input_dtypes, init_all_as_kwargs_np={ - "object": xs[0], + "value": x[0], }, + method_input_dtypes=input_dtype, method_all_as_kwargs_np={}, frontend=frontend, frontend_method_data=frontend_method_data, @@ -899,17 +753,19 @@ def test_paddle__int__( ) -# invert +# long @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__invert__", + method_name="__long__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("integer"), max_num_dims=0, + min_value=-1e15, + max_value=1e15, ), ) -def test_paddle__invert__( +def test_paddle___long__( dtype_and_x, frontend_method_data, init_flags, @@ -919,6 +775,8 @@ def test_paddle__invert__( on_device, ): input_dtypes, xs = dtype_and_x + # Numpy doesn't support complex to int conversion + assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) helpers.test_frontend_method( init_input_dtypes=input_dtypes, backend_to_test=backend_fw, @@ -935,78 +793,76 @@ def test_paddle__invert__( ) -# __len__ +# __lt__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__len__", - dtype_and_x=_array_and_shape( - min_num_dims=1, - max_num_dims=5, + method_name="__lt__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True ), ) -def test_paddle__len__( +def test_paddle___lt__( dtype_and_x, - frontend, frontend_method_data, init_flags, method_flags, - backend_fw, + frontend, on_device, + backend_fw, ): input_dtype, x = dtype_and_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "value": x[0], + "data": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np={}, - frontend=frontend, + method_all_as_kwargs_np={ + "y": x[1], + }, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, + frontend=frontend, on_device=on_device, ) -# long +# __mul__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__long__", + method_name="__mul__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("integer"), - max_num_dims=0, - min_value=-1e15, - max_value=1e15, + available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True ), ) -def test_paddle__long__( +def test_paddle___mul__( dtype_and_x, frontend_method_data, init_flags, method_flags, - backend_fw, frontend, on_device, + backend_fw, ): - input_dtypes, xs = dtype_and_x - # Numpy doesn't support complex to int conversion - assume(not np.issubdtype(input_dtypes[0], np.complexfloating)) + input_dtype, x = dtype_and_x helpers.test_frontend_method( - init_input_dtypes=input_dtypes, + init_input_dtypes=input_dtype, backend_to_test=backend_fw, - method_input_dtypes=input_dtypes, init_all_as_kwargs_np={ - "object": xs[0], + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], }, - method_all_as_kwargs_np={}, - frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, + frontend=frontend, on_device=on_device, ) @@ -1024,7 +880,7 @@ def test_paddle__long__( allow_inf=False, ), ) -def test_paddle__ne__( +def test_paddle___ne__( dtype_and_x, frontend_method_data, init_flags, @@ -1064,7 +920,7 @@ def test_paddle__ne__( allow_inf=False, ), ) -def test_paddle__neg__( +def test_paddle___neg__( dtype_and_x, frontend_method_data, init_flags, @@ -1090,58 +946,54 @@ def test_paddle__neg__( ) +# __or__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="__rdiv__", + method_name="__or__", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - num_arrays=2, - shared_dtype=True, - large_abs_safety_factor=10, - small_abs_safety_factor=10, - safety_factor_scale="log", + available_dtypes=helpers.get_dtypes("integer"), num_arrays=2, shared_dtype=True ), ) -def test_paddle__rdiv__( +def test_paddle___or__( dtype_and_x, - frontend, frontend_method_data, init_flags, method_flags, + frontend, on_device, backend_fw, ): input_dtype, x = dtype_and_x - assume(not np.any(np.isclose(x[0], 0))) - assume(not np.any(np.isclose(x[1], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "value": x[0], + "data": x[0], }, method_input_dtypes=input_dtype, method_all_as_kwargs_np={ "y": x[1], }, - frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, + frontend=frontend, on_device=on_device, ) -# reshape +# __radd__ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="reshape", - dtype_x_shape=_reshape_helper(), + method_name="__radd__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + ), ) -def test_paddle__reshape( - dtype_x_shape, +def test_paddle___radd__( + dtype_and_x, frontend_method_data, init_flags, method_flags, @@ -1149,11 +1001,7 @@ def test_paddle__reshape( on_device, backend_fw, ): - input_dtype, x, shape = dtype_x_shape - assume(len(shape) != 0) - shape = { - "shape": shape, - } + input_dtype, x = dtype_and_x helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1161,7 +1009,9 @@ def test_paddle__reshape( "data": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np=shape, + method_all_as_kwargs_np={ + "x": x[1], + }, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, @@ -1170,39 +1020,45 @@ def test_paddle__reshape( ) -# reshape_ @handle_frontend_method( class_tree=CLASS_TREE, init_tree="paddle.to_tensor", - method_name="reshape_", - dtype_x_shape=_reshape_helper(), + method_name="__rdiv__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + shared_dtype=True, + large_abs_safety_factor=10, + small_abs_safety_factor=10, + safety_factor_scale="log", + ), ) -def test_paddle__reshape_( - dtype_x_shape, +def test_paddle___rdiv__( + dtype_and_x, + frontend, frontend_method_data, init_flags, method_flags, - frontend, on_device, backend_fw, ): - input_dtype, x, shape = dtype_x_shape - assume(len(shape) != 0) - shape = { - "shape": shape, - } + input_dtype, x = dtype_and_x + assume(not np.any(np.isclose(x[0], 0))) + assume(not np.any(np.isclose(x[1], 0))) helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, init_all_as_kwargs_np={ - "data": x[0], + "value": x[0], }, method_input_dtypes=input_dtype, - method_all_as_kwargs_np=shape, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend=frontend, frontend_method_data=frontend_method_data, init_flags=init_flags, method_flags=method_flags, - frontend=frontend, on_device=on_device, ) @@ -1220,7 +1076,7 @@ def test_paddle__reshape_( allow_inf=False, ), ) -def test_paddle__rmul__( +def test_paddle___rmul__( dtype_and_x, frontend_method_data, init_flags, @@ -1259,7 +1115,7 @@ def test_paddle__rmul__( shared_dtype=True, ), ) -def test_paddle__rsub__( +def test_paddle___rsub__( dtype_and_x, frontend, frontend_method_data, @@ -1300,7 +1156,7 @@ def test_paddle__rsub__( safety_factor_scale="log", ), ) -def test_paddle__rtruediv__( +def test_paddle___rtruediv__( dtype_and_x, frontend, frontend_method_data, @@ -1330,6 +1186,76 @@ def test_paddle__rtruediv__( ) +# __setitem__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__setitem__", + dtypes_x_index_val=helpers.dtype_array_query_val( + available_dtypes=helpers.get_dtypes("valid"), + ).filter(lambda x: x[0][0] == x[0][-1] and _filter_query(x[-2])), +) +def test_paddle___setitem__( + dtypes_x_index_val, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x, index, val = dtypes_x_index_val + helpers.test_frontend_method( + init_input_dtypes=[input_dtype[0]], + backend_to_test=backend_fw, + init_all_as_kwargs_np={"data": x}, + method_input_dtypes=[*input_dtype[1:]], + method_all_as_kwargs_np={"item": index, "value": val}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + +# __sub__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__sub__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True + ), +) +def test_paddle___sub__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __xor__ @handle_frontend_method( class_tree=CLASS_TREE, @@ -1341,7 +1267,7 @@ def test_paddle__rtruediv__( shared_dtype=True, ), ) -def test_paddle__xor__( +def test_paddle___xor__( dtype_and_x, frontend, frontend_method_data, @@ -4818,6 +4744,80 @@ def test_paddle_remainder_( ) +# reshape +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="reshape", + dtype_x_shape=_reshape_helper(), +) +def test_paddle_reshape( + dtype_x_shape, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x, shape = dtype_x_shape + assume(len(shape) != 0) + shape = { + "shape": shape, + } + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np=shape, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + +# reshape_ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="reshape_", + dtype_x_shape=_reshape_helper(), +) +def test_paddle_reshape_( + dtype_x_shape, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x, shape = dtype_x_shape + assume(len(shape) != 0) + shape = { + "shape": shape, + } + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np=shape, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # rot90 @handle_frontend_method( class_tree=CLASS_TREE, diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py index d06dd9d695a86..153f2089e184b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_tensor.py @@ -85,7 +85,7 @@ def _check_query(query): shared_dtype=True, ), ) -def test_tensorflow__add__( +def test_tensorflow___add__( dtype_and_x, frontend, frontend_method_data, @@ -113,45 +113,6 @@ def test_tensorflow__add__( ) -# __and__ -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="tensorflow.constant", - method_name="__and__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("integer"), - num_arrays=2, - shared_dtype=True, - ), -) -def test_tensorflow__and__( - dtype_and_x, - frontend, - frontend_method_data, - init_flags, - method_flags, - backend_fw, - on_device, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "value": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "y": x[1], - }, - frontend=frontend, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - on_device=on_device, - ) - - # __array__ @handle_frontend_method( class_tree=CLASS_TREE, @@ -160,7 +121,7 @@ def test_tensorflow__and__( dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("valid")), dtype=helpers.get_dtypes("valid", full=False), ) -def test_tensorflow__array__( +def test_tensorflow___array__( dtype_and_x, dtype, frontend, @@ -193,7 +154,7 @@ def test_tensorflow__array__( max_dim_size=1, ), ) -def test_tensorflow__bool__( +def test_tensorflow___bool__( dtype_and_x, frontend, frontend_method_data, @@ -232,7 +193,7 @@ def test_tensorflow__bool__( safety_factor_scale="log", ), ) -def test_tensorflow__div__( +def test_tensorflow___div__( dtype_and_x, frontend, frontend_method_data, @@ -271,7 +232,7 @@ def test_tensorflow__div__( num_arrays=2, ), ) -def test_tensorflow__eq__( +def test_tensorflow___eq__( dtype_and_x, frontend, frontend_method_data, @@ -312,7 +273,7 @@ def test_tensorflow__eq__( safety_factor_scale="log", ), ) -def test_tensorflow__floordiv__( +def test_tensorflow___floordiv__( dtype_and_x, frontend, frontend_method_data, @@ -351,7 +312,7 @@ def test_tensorflow__floordiv__( shared_dtype=True, ), ) -def test_tensorflow__ge__( +def test_tensorflow___ge__( dtype_and_x, frontend, frontend_method_data, @@ -394,7 +355,7 @@ def test_tensorflow__ge__( ) ), ) -def test_tensorflow__getitem__( +def test_tensorflow___getitem__( dtype_x_index, frontend, frontend_method_data, @@ -429,7 +390,7 @@ def test_tensorflow__getitem__( shared_dtype=True, ), ) -def test_tensorflow__gt__( +def test_tensorflow___gt__( dtype_and_x, frontend, frontend_method_data, @@ -466,7 +427,7 @@ def test_tensorflow__gt__( available_dtypes=helpers.get_dtypes("integer") ), ) -def test_tensorflow__invert__( +def test_tensorflow___invert__( dtype_and_x, frontend, frontend_method_data, @@ -503,7 +464,7 @@ def test_tensorflow__invert__( shared_dtype=True, ), ) -def test_tensorflow__le__( +def test_tensorflow___le__( dtype_and_x, frontend, frontend_method_data, @@ -541,7 +502,7 @@ def test_tensorflow__le__( max_num_dims=5, ), ) -def test_tensorflow__len__( +def test_tensorflow___len__( dtype_and_x, frontend, frontend_method_data, @@ -578,7 +539,7 @@ def test_tensorflow__len__( shared_dtype=True, ), ) -def test_tensorflow__lt__( +def test_tensorflow___lt__( dtype_and_x, frontend, frontend_method_data, @@ -626,7 +587,7 @@ def test_tensorflow__lt__( safety_factor_scale="log", ), ) -def test_tensorflow__matmul__( +def test_tensorflow___matmul__( dtype_and_x, frontend, frontend_method_data, @@ -665,7 +626,7 @@ def test_tensorflow__matmul__( shared_dtype=True, ), ) -def test_tensorflow__mod__( +def test_tensorflow___mod__( dtype_and_x, frontend, frontend_method_data, @@ -705,7 +666,7 @@ def test_tensorflow__mod__( shared_dtype=True, ), ) -def test_tensorflow__mul__( +def test_tensorflow___mul__( dtype_and_x, frontend, frontend_method_data, @@ -744,7 +705,7 @@ def test_tensorflow__mul__( shared_dtype=True, ), ) -def test_tensorflow__ne__( +def test_tensorflow___ne__( dtype_and_x, frontend, frontend_method_data, @@ -788,7 +749,7 @@ def test_tensorflow__ne__( ], ), ) -def test_tensorflow__neg__( +def test_tensorflow___neg__( dtype_and_x, frontend, frontend_method_data, @@ -824,7 +785,7 @@ def test_tensorflow__neg__( max_dim_size=1, ), ) -def test_tensorflow__nonzero__( +def test_tensorflow___nonzero__( dtype_and_x, frontend, frontend_method_data, @@ -861,7 +822,7 @@ def test_tensorflow__nonzero__( shared_dtype=True, ), ) -def test_tensorflow__or__( +def test_tensorflow___or__( dtype_and_x, frontend, frontend_method_data, @@ -906,7 +867,7 @@ def test_tensorflow__or__( shared_dtype=True, ), ) -def test_tensorflow__pow__( +def test_tensorflow___pow__( dtype_and_x, frontend, frontend_method_data, @@ -952,7 +913,7 @@ def test_tensorflow__pow__( shared_dtype=True, ), ) -def test_tensorflow__radd__( +def test_tensorflow___radd__( dtype_and_x, frontend, frontend_method_data, @@ -991,7 +952,7 @@ def test_tensorflow__radd__( shared_dtype=True, ), ) -def test_tensorflow__rand__( +def test_tensorflow___rand__( dtype_and_x, frontend, frontend_method_data, @@ -1033,7 +994,7 @@ def test_tensorflow__rand__( safety_factor_scale="log", ), ) -def test_tensorflow__rfloordiv__( +def test_tensorflow___rfloordiv__( dtype_and_x, frontend, frontend_method_data, @@ -1081,7 +1042,7 @@ def test_tensorflow__rfloordiv__( safety_factor_scale="log", ), ) -def test_tensorflow__rmatmul__( +def test_tensorflow___rmatmul__( dtype_and_x, frontend, frontend_method_data, @@ -1122,7 +1083,7 @@ def test_tensorflow__rmatmul__( max_value=100, ), ) -def test_tensorflow__rmul__( +def test_tensorflow___rmul__( dtype_and_x, frontend, frontend_method_data, @@ -1161,7 +1122,7 @@ def test_tensorflow__rmul__( shared_dtype=True, ), ) -def test_tensorflow__ror__( +def test_tensorflow___ror__( dtype_and_x, frontend, frontend_method_data, @@ -1196,7 +1157,7 @@ def test_tensorflow__ror__( method_name="__rpow__", dtype_and_x=_pow_helper_shared_dtype(), ) -def test_tensorflow__rpow__( +def test_tensorflow___rpow__( dtype_and_x, frontend, frontend_method_data, @@ -1235,7 +1196,7 @@ def test_tensorflow__rpow__( shared_dtype=True, ), ) -def test_tensorflow__rsub__( +def test_tensorflow___rsub__( dtype_and_x, frontend, frontend_method_data, @@ -1277,7 +1238,7 @@ def test_tensorflow__rsub__( safety_factor_scale="log", ), ) -def test_tensorflow__rtruediv__( +def test_tensorflow___rtruediv__( dtype_and_x, frontend, frontend_method_data, @@ -1316,7 +1277,7 @@ def test_tensorflow__rtruediv__( shared_dtype=True, ), ) -def test_tensorflow__rxor__( +def test_tensorflow___rxor__( dtype_and_x, frontend, frontend_method_data, @@ -1355,7 +1316,7 @@ def test_tensorflow__rxor__( shared_dtype=True, ), ) -def test_tensorflow__sub__( +def test_tensorflow___sub__( dtype_and_x, frontend, frontend_method_data, @@ -1397,7 +1358,7 @@ def test_tensorflow__sub__( safety_factor_scale="log", ), ) -def test_tensorflow__truediv__( +def test_tensorflow___truediv__( dtype_and_x, frontend, frontend_method_data, @@ -1437,7 +1398,46 @@ def test_tensorflow__truediv__( shared_dtype=True, ), ) -def test_tensorflow__xor__( +def test_tensorflow___xor__( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "value": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend=frontend, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + on_device=on_device, + ) + + +# __and__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="tensorflow.constant", + method_name="__and__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("integer"), + num_arrays=2, + shared_dtype=True, + ), +) +def test_tensorflow__and__( dtype_and_x, frontend, frontend_method_data, diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 7f1c4b6798882..a0e89163f2f76 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -513,6 +513,37 @@ def test_torch___and__( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="__array__", + dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("valid")), + dtype=helpers.get_dtypes("valid", full=False), +) +def test_torch___array__( + dtype_and_x, + dtype, + frontend, + backend_fw, +): + input_dtype, x = dtype_and_x + if x[0].dtype == "bfloat16": + return + dtype[0] = np.dtype(dtype[0]) + ret_gt = torch.tensor(x[0]).__array__(dtype[0]) + with BackendHandler.update_backend(backend_fw) as ivy_backend: + local_importer = ivy_backend.utils.dynamic_import + function_module = local_importer.import_module("ivy.functional.frontends.torch") + ret = function_module.tensor(x[0]).__array__(dtype[0]) + + helpers.value_test( + ret_np_flat=ret.ravel(), + ret_np_from_gt_flat=ret_gt.ravel(), + ground_truth_backend="torch", + backend=backend_fw, + ) + + @handle_frontend_method( class_tree=CLASS_TREE, init_tree="torch.tensor", @@ -1409,37 +1440,6 @@ def test_torch___truediv__( ) -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="torch.tensor", - method_name="__array__", - dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("valid")), - dtype=helpers.get_dtypes("valid", full=False), -) -def test_torch__array__( - dtype_and_x, - dtype, - frontend, - backend_fw, -): - input_dtype, x = dtype_and_x - if x[0].dtype == "bfloat16": - return - dtype[0] = np.dtype(dtype[0]) - ret_gt = torch.tensor(x[0]).__array__(dtype[0]) - with BackendHandler.update_backend(backend_fw) as ivy_backend: - local_importer = ivy_backend.utils.dynamic_import - function_module = local_importer.import_module("ivy.functional.frontends.torch") - ret = function_module.tensor(x[0]).__array__(dtype[0]) - - helpers.value_test( - ret_np_flat=ret.ravel(), - ret_np_from_gt_flat=ret_gt.ravel(), - ground_truth_backend="torch", - backend=backend_fw, - ) - - @given( dtype_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("valid", prune_function=False), From 2911896438d1a6b6ce7b087cd0a123798d1ec96f Mon Sep 17 00:00:00 2001 From: NripeshN Date: Thu, 25 Jan 2024 09:06:10 +0000 Subject: [PATCH 674/978] Update volunteer-leaderboard.rst --- docs/overview/contributing/volunteer_ranks.rst | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/contributing/volunteer_ranks.rst index 6d20db9f9530d..579ba7b74c501 100644 --- a/docs/overview/contributing/volunteer_ranks.rst +++ b/docs/overview/contributing/volunteer_ranks.rst @@ -3,8 +3,8 @@ Contributor Leaderboard This page lists all of our amazing Contributors who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. -Rising Contributors -------------------- +Top Contributors +---------------- .. list-table:: :widths: 50 50 50 :header-rows: 1 @@ -14,7 +14,16 @@ Rising Contributors - Badges * - V\. Sai Suraj - `Sai-Suraj-27 `_ - - Merging Master Silver, Debugging Dynamo Silver + - Merging Master Gold, Debugging Dynamo Silver +Rising Contributors +------------------- +.. list-table:: + :widths: 50 50 50 + :header-rows: 1 + + * - Name + - Github ID + - Badges * - samunder singh - `samthakur587 `_ - - Debugging Dynamo Silver, Merging Master Bronze + - Merging Master Silver, Debugging Dynamo Silver From 95af3724478967722de72e66844816b6442088d7 Mon Sep 17 00:00:00 2001 From: Vismay Suramwar <83938053+Vismay-dev@users.noreply.github.com> Date: Thu, 25 Jan 2024 03:07:36 -0600 Subject: [PATCH 675/978] fix: Fixed creation `ivy.zeros_like` failing test for all backends (#28032) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/creation.py | 4 ++++ ivy_tests/test_ivy/test_functional/test_core/test_creation.py | 1 + 2 files changed, 5 insertions(+) diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index da61893325591..f4411ff0ba279 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -530,6 +530,10 @@ def zeros( return paddle.zeros(shape=shape).cast(dtype) +@with_unsupported_device_and_dtypes( + {"2.6.0 and below": {"cpu": ("uint8", "int8", "int16", "float16", "bfloat16")}}, + backend_version, +) def zeros_like( x: paddle.Tensor, /, diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_creation.py b/ivy_tests/test_ivy/test_functional/test_core/test_creation.py index 99a105e454651..e13e0836f24eb 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_creation.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_creation.py @@ -848,6 +848,7 @@ def test_zeros(*, shape, dtype, test_flags, backend_fw, fn_name, on_device): min_dim_size=1, max_dim_size=5, ), + test_gradients=st.just(False), ) def test_zeros_like(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): dtype, x = dtype_and_x From bec4752711c314f01298abc3845f02c24a99acab Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 25 Jan 2024 12:45:21 +0000 Subject: [PATCH 676/978] fix: update tensor method `unfold` to fix certain cases where torch frontend behaves differently than the native torch. this takes dimension into account when slicing, ensuring retuned value's size is arranged correctly --- ivy/functional/frontends/torch/tensor.py | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index f3f939df27eb5..71ce3db81dfcd 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -761,9 +761,20 @@ def new_empty( def unfold(self, dimension, size, step): slices = [] - for i in range(0, self.shape[dimension] - size + 1, step): - slices.append(self.ivy_array[i : i + size]) - return torch_frontend.stack(slices) + self_shape = tuple(self.shape) + for i in range(0, self_shape[dimension] - size + 1, step): + slicing = [slice(None)] * len(self.shape) + slicing[dimension] = slice(i, i + size) + slices.append(self.ivy_array[tuple(slicing)]) + stacked = torch_frontend.stack(slices, dim=dimension) + new_shape = list(self.shape) + num_slices = (self.shape[dimension] - size) // step + 1 + new_shape[dimension] = num_slices + new_shape.insert(dimension + 1, size) + reshaped = stacked.reshape(new_shape) + dims = list(range(len(stacked.shape))) + dims[-2], dims[-1] = dims[-1], dims[-2] + return reshaped.permute(*dims) def long(self, memory_format=None): self.ivy_array = ivy.astype(self.ivy_array, ivy.int64, copy=False) From bccc59063a2f13cdcb3dafc330cae6658751f0a9 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 25 Jan 2024 20:21:00 +0530 Subject: [PATCH 677/978] fix: Fixed `ivy.remainder()` function call which contains wrong argument (#28045) --- ivy/functional/frontends/tensorflow/variable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/tensorflow/variable.py b/ivy/functional/frontends/tensorflow/variable.py index bf6feeedde71d..e97034e4559f1 100644 --- a/ivy/functional/frontends/tensorflow/variable.py +++ b/ivy/functional/frontends/tensorflow/variable.py @@ -188,7 +188,7 @@ def __mul__(self, x, name="mul"): return tf_frontend.math.multiply(x, self._ivy_array, name=name) def __mod__(self, x, name="mod"): - return ivy.remainder(x, self._ivy_array, name=name) + return tf_frontend.math.mod(x, self._ivy_array, name=name) def __ne__(self, other): return tf_frontend.raw_ops.NotEqual( From 74128a59bf1620e1d650599df6a955f347adc1da Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 26 Jan 2024 04:53:49 +0000 Subject: [PATCH 678/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 901be35fb3472..358cdc435092b 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 901be35fb34723cd5a684a9a3344181418e03696 +Subproject commit 358cdc435092bc996dfcea48759fb2124c126f07 From de9ee844b47ee5a97ee7e2933557a6ee3f0b11fd Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 26 Jan 2024 11:15:37 +0530 Subject: [PATCH 679/978] fix: Fixed the issue with the copy argument tests by using stop gradients and converting the results to numpy before comparing whether they share memory --- ivy_tests/test_ivy/helpers/function_testing.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 94beb091b989c..11694dce9920d 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -325,6 +325,8 @@ def target_fn(instance, *args, **kwargs): precision_mode=test_flags.precision_mode, **kwargs, ) + first_array = ivy_backend.stop_gradient(first_array).to_numpy() + ret_ = ivy_backend.stop_gradient(ret_).to_numpy() assert not np.may_share_memory(first_array, ret_) ret_device = None From c306cf3e37bf6973561c8febc17e9101c5638fcc Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 26 Jan 2024 12:42:40 +0400 Subject: [PATCH 680/978] Update volunteer ranks position --- docs/overview/{contributing => }/volunteer_ranks.rst | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/overview/{contributing => }/volunteer_ranks.rst (100%) diff --git a/docs/overview/contributing/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst similarity index 100% rename from docs/overview/contributing/volunteer_ranks.rst rename to docs/overview/volunteer_ranks.rst From e7aa94748a95ff05be824ae9cb7c63125dd35844 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 26 Jan 2024 12:50:44 +0400 Subject: [PATCH 681/978] Update docs --- docs/index.rst | 1 + docs/overview/contributing.rst | 12 ++++-------- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index e88f08969b560..02a4eefdf723a 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -46,6 +46,7 @@ overview/design.rst overview/contributing.rst + overview/volunteer_ranks.rst overview/deep_dive.rst overview/glossary.rst overview/faq.rst diff --git a/docs/overview/contributing.rst b/docs/overview/contributing.rst index f5998b0a03b5a..53a98e9417dc0 100644 --- a/docs/overview/contributing.rst +++ b/docs/overview/contributing.rst @@ -30,19 +30,16 @@ The contributor guide is split into the sections below, it's best to go from sta | (e) `Contributor Program `_ | How to climb up the ranks in our Contributor program 🧗 | -| (f) `Contributor Leaderboard `_ -| See where you stand on our leaderboard 🏆 -| -| (g) `Building the Docs `_ +| (f) `Building the Docs `_ | How to build the documentation locally 🏗️ | -| (h) `Deep Dive `_ +| (g) `Deep Dive `_ | Take a deep dive into the codebase 🤿 | -| (i) `Helpful Resources `_ +| (h) `Helpful Resources `_ | Resources you would find useful when learning Ivy 📖 | -| (j) `Error Handling `_ +| (i) `Error Handling `_ | Common errors you will be facing contributing to Ivy ❌ .. toctree:: @@ -57,7 +54,6 @@ The contributor guide is split into the sections below, it's best to go from sta contributing/open_tasks.rst contributing/volunteer_program.rst contributing/contributor_rewards.rst - contributing/volunteer_ranks.rst contributing/helpful_resources.rst contributing/error_handling.rst From fd5a2b32a7b76aca58e70d6dbfd0f33e39f227d9 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 26 Jan 2024 13:15:03 +0400 Subject: [PATCH 682/978] Updated volunteer ranks --- docs/overview/contributing/contributor_rewards.rst | 2 +- docs/overview/volunteer_ranks.rst | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/overview/contributing/contributor_rewards.rst b/docs/overview/contributing/contributor_rewards.rst index ec5847fb25ec2..9ca1e9494c2c7 100644 --- a/docs/overview/contributing/contributor_rewards.rst +++ b/docs/overview/contributing/contributor_rewards.rst @@ -11,7 +11,7 @@ It recognizes the crucial role of pinpointing problems which is fundamental in m **Merging Master** - These badges are formal recognitions for contributors whose pull requests consistently meet our high standards of quality and are successfully merged into the main codebase. -**Merging Wizard** - These exclusive badges are awarded to contributors who successfully get *priority* pull requests merged. This recognition is for handling complex, high-priority tasks that have a substantial impact on the project's progress and success. +**Merging Wizard** - These exclusive badges are awarded to contributors who successfully get *priority* pull requests merged. This recognition is for handling complex, high-priority tasks that have a substantial impact on the project's progress and success. Priority pull requests are those associated with `"Priority Open" issues `_ found within each framework. **Ivy Inspectors** - These badges are given in acknowledgment of the essential role played by those who review our pull requests. It honours the commitment to quality and diligence in ensuring that each code merge aligns with our high standards. diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 579ba7b74c501..99604a7221ed2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -1,7 +1,7 @@ Contributor Leaderboard ======================= -This page lists all of our amazing Contributors who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing Contributors who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Top Contributors ---------------- From dcb67ca695287f89a7535385eb0a7cd134fb07ca Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 26 Jan 2024 09:16:28 +0000 Subject: [PATCH 683/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/contributing/contributor_rewards.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/contributing/contributor_rewards.rst b/docs/overview/contributing/contributor_rewards.rst index 9ca1e9494c2c7..f2cdd3c3225ff 100644 --- a/docs/overview/contributing/contributor_rewards.rst +++ b/docs/overview/contributing/contributor_rewards.rst @@ -11,7 +11,7 @@ It recognizes the crucial role of pinpointing problems which is fundamental in m **Merging Master** - These badges are formal recognitions for contributors whose pull requests consistently meet our high standards of quality and are successfully merged into the main codebase. -**Merging Wizard** - These exclusive badges are awarded to contributors who successfully get *priority* pull requests merged. This recognition is for handling complex, high-priority tasks that have a substantial impact on the project's progress and success. Priority pull requests are those associated with `"Priority Open" issues `_ found within each framework. +**Merging Wizard** - These exclusive badges are awarded to contributors who successfully get *priority* pull requests merged. This recognition is for handling complex, high-priority tasks that have a substantial impact on the project's progress and success. Priority pull requests are those associated with `"Priority Open" issues `_ found within each framework. **Ivy Inspectors** - These badges are given in acknowledgment of the essential role played by those who review our pull requests. It honours the commitment to quality and diligence in ensuring that each code merge aligns with our high standards. From a1d80980c8ed8331e7ae037042902bddaf203a5c Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 26 Jan 2024 19:34:30 +0530 Subject: [PATCH 684/978] feat: Updated `black` formatter version and modified all the files according to it (#28040) --- .pre-commit-config.yaml | 2 +- scripts/backend_generation/generate.py | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 34d42d6af8eea..d18a3b680e7df 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -13,7 +13,7 @@ repos: - id: ruff args: [ --fix ] - repo: https://github.com/psf/black-pre-commit-mirror - rev: 23.12.1 + rev: 24.1.0 hooks: - id: black language_version: python3 diff --git a/scripts/backend_generation/generate.py b/scripts/backend_generation/generate.py index 90886b67f61b4..523ad1b6f28a7 100644 --- a/scripts/backend_generation/generate.py +++ b/scripts/backend_generation/generate.py @@ -167,8 +167,7 @@ def _should_install_backend(package_name): ) from e elif ret.lower() == "n": print( - Fore.YELLOW - + "Will continue without backend installed, " + Fore.YELLOW + "Will continue without backend installed, " "type checking won't be available.\n" ) else: From 7f643e79210dfebe29956155bc8b8ef9e74794af Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 29 Jan 2024 01:27:20 +0530 Subject: [PATCH 685/978] =?UTF-8?q?fix:=20fixed=20sigmoid=20test=20functio?= =?UTF-8?q?n=20by=20adding=20atol=20and=20rtol=20to=20support=20f=E2=80=A6?= =?UTF-8?q?=20(#28093)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fixed sigmoid support float16 dtype --- ivy_tests/test_ivy/test_functional/test_nn/test_activations.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_activations.py b/ivy_tests/test_ivy/test_functional/test_nn/test_activations.py index 83a1d3985c6ff..66d6e7c42e63e 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_activations.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_activations.py @@ -208,6 +208,8 @@ def test_sigmoid( test_flags=test_flags, fn_name=fn_name, on_device=on_device, + atol_=1e-02, + rtol_=1e-02, x=x[0], complex_mode=complex_mode, ) From b31203248802de0c6b2ceb23165438903d836871 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 29 Jan 2024 01:29:39 +0530 Subject: [PATCH 686/978] fix: fix the tests on bool dtype (#28092) fix test function of cumsum to not take bool dtype as input --- ivy_tests/test_ivy/test_functional/test_core/test_statistical.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py index 143db6235ea77..4d5066ded502d 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py @@ -166,6 +166,7 @@ def test_cumsum( on_device, ): input_dtype, x, axis, castable_dtype = dtype_x_axis_castable + assume("bool" not in input_dtype) # ToDo: set as_variable_flags as the parameter generated by test_cumsum once # this issue is marked as completed https://github.com/pytorch/pytorch/issues/75733 if "torch" in backend_fw: From ca50197392322d87182200971389c310c6d0479c Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 29 Jan 2024 18:37:37 +0530 Subject: [PATCH 687/978] fix: Fixed paddle backend for `comparison_ops.torch.equal` and `raw_ops.tensorflow.raw_ops.Equal` (#28096) --- ivy/functional/backends/paddle/elementwise.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index c7b538c640dd1..cb15c8d8c4948 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -120,6 +120,9 @@ def isinf( return paddle.zeros(shape=x.shape, dtype=bool) +@with_supported_dtypes( + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version +) def equal( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], From dcc3e0043a3d94be4e216692a5467018a907a37d Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 29 Jan 2024 18:38:50 +0530 Subject: [PATCH 688/978] fix: Fixed `attribute.paddle.real` for all the backends (#28103) --- ivy/functional/frontends/paddle/attribute.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/ivy/functional/frontends/paddle/attribute.py b/ivy/functional/frontends/paddle/attribute.py index a94192737bdcb..baa8f64258d4a 100644 --- a/ivy/functional/frontends/paddle/attribute.py +++ b/ivy/functional/frontends/paddle/attribute.py @@ -1,5 +1,6 @@ # global import ivy +from ivy.func_wrapper import with_supported_dtypes from ivy.functional.frontends.paddle.func_wrapper import ( to_ivy_arrays_and_back, ) @@ -30,6 +31,15 @@ def rank(input): return ivy.get_num_dims(input) +@with_supported_dtypes( + { + "2.6.0 and below": ( + "complex64", + "complex128", + ) + }, + "paddle", +) @to_ivy_arrays_and_back def real(x): return ivy.real(x) From 995886245e9cde9885ee02b5a4ba4668427230a2 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 29 Jan 2024 18:41:42 +0530 Subject: [PATCH 689/978] fix: Fixed `math.paddle.pow` for paddle backend (#28091) --- ivy/functional/frontends/paddle/math.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index 252d8f1be9c93..3180215d448fc 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -514,7 +514,9 @@ def outer(x, y, name=None): return ivy.outer(x, y) -@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") +@with_supported_dtypes( + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" +) @to_ivy_arrays_and_back def pow(x, y, name=None): return ivy.pow(x, y) From bc8f749b876f779dcd72626c6767b77b4efdbd43 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 29 Jan 2024 20:19:34 +0530 Subject: [PATCH 690/978] fix: Fixed `creation.paddle.eye` for all backends (#28068) --- ivy/functional/frontends/paddle/creation.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/functional/frontends/paddle/creation.py b/ivy/functional/frontends/paddle/creation.py index 4cc1b8f9b0820..2f1b4a5f136c5 100644 --- a/ivy/functional/frontends/paddle/creation.py +++ b/ivy/functional/frontends/paddle/creation.py @@ -87,6 +87,9 @@ def empty_like(x, dtype=None, name=None): return ivy.empty_like(x, dtype=dtype) +@with_supported_dtypes( + {"2.6.0 and below": ("float16", "float32", "float64", "int32", "int64")}, "paddle" +) @to_ivy_arrays_and_back def eye(num_rows, num_columns=None, dtype=None, name=None): return ivy.eye(num_rows, num_columns, dtype=dtype) From 9079c403eb69ffa9a19b26d8191b93e08b95280c Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 29 Jan 2024 21:26:02 +0530 Subject: [PATCH 691/978] fix: fixed cumprod not support bool dtype (#28059) fixed cumprod not support bool dtype --- ivy/functional/backends/jax/statistical.py | 2 +- ivy/functional/backends/numpy/statistical.py | 2 +- ivy/functional/backends/tensorflow/statistical.py | 2 +- ivy/functional/backends/torch/statistical.py | 2 +- .../test_ivy/test_functional/test_core/test_statistical.py | 1 + 5 files changed, 5 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/jax/statistical.py b/ivy/functional/backends/jax/statistical.py index bff5fca9a2d1e..d03e9411f2561 100644 --- a/ivy/functional/backends/jax/statistical.py +++ b/ivy/functional/backends/jax/statistical.py @@ -147,7 +147,7 @@ def var( # ------# -@with_unsupported_dtypes({"0.4.23 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16", "bool")}, backend_version) def cumprod( x: JaxArray, /, diff --git a/ivy/functional/backends/numpy/statistical.py b/ivy/functional/backends/numpy/statistical.py index cba78d4124988..bffc814767cc3 100644 --- a/ivy/functional/backends/numpy/statistical.py +++ b/ivy/functional/backends/numpy/statistical.py @@ -178,7 +178,7 @@ def var( # ------# -@with_unsupported_dtypes({"1.26.3 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"1.26.3 and below": ("bfloat16", "bool")}, backend_version) def cumprod( x: np.ndarray, /, diff --git a/ivy/functional/backends/tensorflow/statistical.py b/ivy/functional/backends/tensorflow/statistical.py index f111a2804e5a1..95db57526ef9b 100644 --- a/ivy/functional/backends/tensorflow/statistical.py +++ b/ivy/functional/backends/tensorflow/statistical.py @@ -178,7 +178,7 @@ def var( # ------# -@with_unsupported_dtypes({"2.15.0 and below": "bfloat16"}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16", "bool")}, backend_version) def cumprod( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/torch/statistical.py b/ivy/functional/backends/torch/statistical.py index 76030c794dfb6..eb4666237ae0c 100644 --- a/ivy/functional/backends/torch/statistical.py +++ b/ivy/functional/backends/torch/statistical.py @@ -245,7 +245,7 @@ def var( # TODO: bfloat16 support is added in PyTorch 1.12.1 @with_unsupported_dtypes( { - "2.1.2 and below": ("uint8", "float16", "bfloat16"), + "2.1.2 and below": ("uint8", "float16", "bfloat16", "bool"), }, backend_version, ) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py index 4d5066ded502d..7c6cd30e28a00 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_statistical.py @@ -108,6 +108,7 @@ def _statistical_dtype_values(draw, *, function, min_value=None, max_value=None) dtype_x_axis_castable=_get_castable_dtype(), exclusive=st.booleans(), reverse=st.booleans(), + test_gradients=st.just(False), ) def test_cumprod( *, From bd44715e9f92119cc6bc6fba5caed85c23ee42a7 Mon Sep 17 00:00:00 2001 From: Suyash Gupta Date: Tue, 30 Jan 2024 00:44:30 +0530 Subject: [PATCH 692/978] fix: Fix Ivy Failing Test: torch - manipulation.reshape (#28018) Co-authored-by: joaozenobio --- ivy/functional/backends/torch/manipulation.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/torch/manipulation.py b/ivy/functional/backends/torch/manipulation.py index 86cf88bb8e919..3e18e83eb33c9 100644 --- a/ivy/functional/backends/torch/manipulation.py +++ b/ivy/functional/backends/torch/manipulation.py @@ -1,7 +1,7 @@ # global import math from numbers import Number -from typing import Union, Optional, Tuple, List, Sequence, Iterable +from typing import Iterable, List, Optional, Sequence, Tuple, Union import torch @@ -11,6 +11,7 @@ # noinspection PyProtectedMember from ivy.functional.ivy.manipulation import _calculate_out_shape + from . import backend_version @@ -61,7 +62,7 @@ def flip( out: Optional[torch.Tensor] = None, ) -> torch.Tensor: if copy: - x = x.clone().detach() + x = x.clone() num_dims = len(x.shape) if not num_dims: return x @@ -88,6 +89,10 @@ def permute_dims( return torch.permute(x, axes) +@with_unsupported_dtypes( + {"2.1.2 and below": ("bfloat16",)}, + backend_version, +) def reshape( x: torch.Tensor, /, @@ -98,6 +103,8 @@ def reshape( allowzero: bool = True, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: + if copy: + x = x.clone() ivy.utils.assertions.check_elem_in_list(order, ["C", "F"]) if not allowzero: shape = [ From 2f03afc02992b71eb2496f25af755ea038162de3 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Mon, 29 Jan 2024 18:46:05 -0800 Subject: [PATCH 693/978] Fix! Fix Ivy Failing Test: paddle jax tensoflow- general.inplace_update (#28022) --- ivy_tests/test_ivy/test_functional/test_core/test_general.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index 951c1d05e804c..e37e69b61ba1e 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -1289,7 +1289,7 @@ def test_inplace_increment(x_val_and_dtypes, test_flags, on_device, backend_fw): shared_dtype=True, ), keep_x_dtype=st.booleans(), - inplace_mode=st.sampled_from(["lenient", "strict"]), + inplace_mode=st.just("lenient"), ) def test_inplace_update( x_val_and_dtypes, keep_x_dtype, inplace_mode, test_flags, on_device, backend_fw From 7dd4b88bb75466fe11c2a2252b733457ffa3492b Mon Sep 17 00:00:00 2001 From: Nightcrab Date: Tue, 30 Jan 2024 09:45:49 +0000 Subject: [PATCH 694/978] fix torch Size frontend when creating empty shape --- ivy/functional/frontends/torch/tensor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 71ce3db81dfcd..5b3c1d4fd8bab 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2309,7 +2309,7 @@ def _set(index): class Size(tuple): def __new__(cls, iterable=()): - iterable = ivy.Shape([]) if not iterable else iterable + iterable = ivy.Shape([]) if iterable == () else iterable new_iterable = [] for i, item in enumerate(iterable): if isinstance(item, int): @@ -2324,7 +2324,7 @@ def __new__(cls, iterable=()): return super().__new__(cls, tuple(new_iterable)) def __init__(self, shape=()) -> None: - shape = ivy.Shape([]) if not shape else shape + shape = ivy.Shape([]) if shape == () else shape self._ivy_shape = shape if isinstance(shape, ivy.Shape) else ivy.shape(shape) def __repr__(self): From 71ca34dcd6f4a0709381877897ea3ffe56378bd9 Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Tue, 30 Jan 2024 13:54:08 +0000 Subject: [PATCH 695/978] fix: implement torch frontend `eq`, and remove it as alias for `equal` as they are different methods (#28121) --- ivy/functional/frontends/torch/tensor.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 5b3c1d4fd8bab..ec96b640d5092 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -516,6 +516,9 @@ def not_equal_(self, other, *, out=None): self.ivy_array = self.not_equal(other).ivy_array return self + def eq(self, other): + return torch_frontend.eq(self, other) + def equal(self, other): return torch_frontend.equal(self, other) @@ -2282,7 +2285,6 @@ def _set(index): ndimension = dim subtract = sub sub_ = subtract_ - eq = equal arctan = atan arctan_ = atan_ arctan2 = atan2 From 181a14d01cc9e1b1587893db5fd5bb0d0e819497 Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Tue, 30 Jan 2024 17:34:47 +0300 Subject: [PATCH 696/978] (fix)(module): fixed the implementation of the _assign_weights method of the subclassed Model class which was only capturing the current module's parameters and not recursing into the submodules. This was leading to an error when building the model as the no of weights captured inmodel_weights and the no of weights in self.weights had a mismatch. --- ivy/functional/backends/tensorflow/module.py | 211 ++++++++++++++++--- 1 file changed, 179 insertions(+), 32 deletions(-) diff --git a/ivy/functional/backends/tensorflow/module.py b/ivy/functional/backends/tensorflow/module.py index 07eb2fef45a03..c27a5595baeca 100644 --- a/ivy/functional/backends/tensorflow/module.py +++ b/ivy/functional/backends/tensorflow/module.py @@ -2,10 +2,159 @@ from __future__ import annotations import re import tensorflow as tf -from typing import Union import functools import logging from tensorflow.python.util import nest +from typing import NamedTuple, Callable, Any, Tuple, List, Dict, Type, Union +from dataclasses import dataclass + +# A NodeDef holds two callables: +# - flatten_fn should take the collection and return a flat list of values. +# It can also return some context that is used in reconstructing the +# collection. +# - unflatten_fn should take a flat list of values and some context +# (returned by flatten_fn). It returns the collection by reconstructing +# it from the list and the context. +Context = Any +PyTree = Any +FlattenFunc = Callable[[PyTree], Tuple[List, Context]] +UnflattenFunc = Callable[[List, Context], PyTree] + + +class NodeDef(NamedTuple): + flatten_fn: FlattenFunc + unflatten_fn: UnflattenFunc + + +SUPPORTED_NODES: Dict[Type[Any], NodeDef] = {} + + +def _register_pytree_node( + typ: Any, flatten_fn: FlattenFunc, unflatten_fn: UnflattenFunc +) -> None: + SUPPORTED_NODES[typ] = NodeDef(flatten_fn, unflatten_fn) + + +def _dict_flatten(d: Dict[Any, Any]) -> Tuple[List[Any], Context]: + return list(d.values()), list(d.keys()) + + +def _dict_unflatten(values: List[Any], context: Context) -> Dict[Any, Any]: + return {key: value for key, value in zip(context, values)} + + +_register_pytree_node(dict, _dict_flatten, _dict_unflatten) + + +def _get_node_type(pytree: Any) -> Any: + return type(pytree) + + +# A leaf is defined as anything that is not a Node. +def _is_leaf(pytree: PyTree) -> bool: + return _get_node_type(pytree) not in SUPPORTED_NODES.keys() + + +# A TreeSpec represents the structure of a pytree. It holds: +# "type": the type of root Node of the pytree +# context: some context that is useful in unflattening the pytree +# children_specs: specs for each child of the root Node +# num_leaves: the number of leaves +@dataclass +class TreeSpec: + type: Any + context: Context + children_specs: List["TreeSpec"] + + def get_keychains(self, prefix="", sep="/"): + keychains = [] + for key, child_spec in zip(self.context, self.children_specs): + new_prefix = prefix + key + sep if prefix else key + sep + if child_spec.children_specs: # Non-leaf node + keychains.extend(child_spec.get_keychains(new_prefix, sep)) + else: # Leaf node + keychains.append(new_prefix[: -len(sep)]) + return keychains + + def __post_init__(self) -> None: + self.num_leaves: int = sum([spec.num_leaves for spec in self.children_specs]) + + def __repr__(self, indent: int = 0) -> str: + repr_prefix: str = f"TreeSpec({self.type.__name__}, {self.context}, [" + children_specs_str: str = "" + if len(self.children_specs): + indent += len(repr_prefix) + children_specs_str += self.children_specs[0].__repr__(indent) + children_specs_str += "," if len(self.children_specs) > 1 else "" + children_specs_str += ",".join([ + "\n" + " " * indent + child.__repr__(indent) + for child in self.children_specs[1:] + ]) + repr_suffix: str = f"{children_specs_str}])" + return repr_prefix + repr_suffix + + +class LeafSpec(TreeSpec): + def __init__(self) -> None: + super().__init__(None, None, []) + self.num_leaves = 1 + + def __repr__(self, indent: int = 0) -> str: + return "*" + + +def tree_flatten(pytree: PyTree) -> Tuple[List[Any], TreeSpec]: + """Flattens a pytree into a list of values and a TreeSpec that can be used + to reconstruct the pytree.""" + if _is_leaf(pytree): + return [pytree], LeafSpec() + + node_type = _get_node_type(pytree) + flatten_fn = _dict_flatten + child_pytrees, context = flatten_fn(pytree) + + # Recursively flatten the children + result: List[Any] = [] + children_specs: List["TreeSpec"] = [] + for child in child_pytrees: + flat, child_spec = tree_flatten(child) + result += flat + children_specs.append(child_spec) + + return result, TreeSpec(node_type, context, children_specs) + + +def tree_unflatten(values: List[Any], spec: TreeSpec) -> PyTree: + """Given a list of values and a TreeSpec, builds a pytree. + + This is the inverse operation of `tree_flatten`. + """ + if not isinstance(spec, TreeSpec): + raise TypeError( + f"tree_unflatten(values, spec): Expected `spec` to be instance of " + f"TreeSpec but got item of type {type(spec)}." + ) + if len(values) != spec.num_leaves: + raise TypeError( + f"tree_unflatten(values, spec): `values` has length {len(values)} " + f"but the spec refers to a pytree that holds {spec.num_leaves} " + f"items ({spec})." + ) + if isinstance(spec, LeafSpec): + return values[0] + + unflatten_fn = _dict_unflatten + + # Recursively unflatten the children + start = 0 + end = 0 + child_pytrees = [] + for child_spec in spec.children_specs: + end += child_spec.num_leaves + child_pytrees.append(tree_unflatten(values[start:end], child_spec)) + start = end + + return unflatten_fn(child_pytrees, spec.context) class ModelHelpers: @@ -224,7 +373,6 @@ def _find_variables( return vs _visited[id(obj)] = True if isinstance(obj, Model) and obj is not self: - if not obj.built and without_initialisation: return lambda: obj._build_and_return_v( *obj._args, dynamic_backend=self._dynamic_backend, **obj._kwargs @@ -285,50 +433,49 @@ def _build_and_return_v(self, *args, **kwargs): return self.v def _assign_weights(self): - model_weights = [] + model_weights = {} + existing_ids = [id(w) for w in self.weights] # trainable weights - for kc, x in self.v.items(): - - # Only add weights for this layer - if isinstance(x, dict): - continue - - self.v[kc] = ( + flattened_v, v_spec = tree_flatten(self.v) + flattened_kc = v_spec.get_keychains() + new_weights = [None] * len(flattened_v) + for i, (kc, x) in enumerate(zip(flattened_kc, flattened_v)): + new_weights[i] = ( self.add_weight(name=kc, shape=x.shape, dtype=x.dtype, trainable=True) - if x is not None + if x is not None and id(x) not in existing_ids else x ) if isinstance(x, tf.Variable): - self.v[kc].assign(x.value()) - ( - model_weights.append(self.v[kc].numpy()) - if self.v[kc] is not None - else self.v[kc] - ) + new_weights[i].assign(x.value()) + if new_weights[i] is not None: + model_weights[id(new_weights[i])] = new_weights[i].numpy() + self.v = tree_unflatten(new_weights, v_spec) # non-trainable weights - for kc, x in self.buffers.items(): - - # Only add weights for this layer - if isinstance(x, dict): - continue - - self.buffers[kc] = ( + flattened_buf, buf_spec = tree_flatten(self.buffers) + flattened_kc = buf_spec.get_keychains() + new_buf = [None] * len(flattened_buf) + for i, (kc, x) in enumerate(zip(flattened_kc, flattened_buf)): + new_buf[i] = ( self.add_weight(name=kc, shape=x.shape, dtype=x.dtype, trainable=False) - if x is not None + if x is not None and id(x) not in existing_ids else x ) if isinstance(x, tf.Variable): - self.buffers[kc].assign(x.value()) - ( - model_weights.append(self.buffers[kc].numpy()) - if self.buffers[kc] is not None - else self.buffers[kc] - ) + new_buf[i].assign(x.value()) + if new_buf[i] is not None: + model_weights[id(new_buf[i])] = new_buf[i].numpy() + self.buffers = tree_unflatten(new_buf, buf_spec) + + def _sort_weights(model_weights, weights): + sorted_weights = [] + for weight in weights: + sorted_weights.append(model_weights[id(weight)]) + return sorted_weights if model_weights: - self.set_weights(model_weights) + self.set_weights(_sort_weights(model_weights, self.weights)) def build( self, From 77ff2edf6c4d9b2dc28b7c3e775535c62a8f15b4 Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Tue, 30 Jan 2024 17:41:27 +0300 Subject: [PATCH 697/978] (fix)(module): fixed the implementation of the train() method of the subclassed Model class which was previouslyt not setting the attributes on the child modules. --- ivy/functional/backends/tensorflow/module.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/functional/backends/tensorflow/module.py b/ivy/functional/backends/tensorflow/module.py index c27a5595baeca..6e19f1568f1c6 100644 --- a/ivy/functional/backends/tensorflow/module.py +++ b/ivy/functional/backends/tensorflow/module.py @@ -682,7 +682,10 @@ def register_parameter(self, name: str, value: Union[tf.Tensor, tf.Variable]): def train(self, mode: bool = True): self._training = mode + for module in self.children(): + module.train(mode) self.trainable = mode + return self def eval(self): return self.train(mode=False) From 08a4a1059f98bf5df1abf01837820e2d4cd259a9 Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Tue, 30 Jan 2024 17:48:01 +0300 Subject: [PATCH 698/978] (fix)(frontend nn.Module): Fixed an issue with the add_module() method not updating the underlying self._module dict which was causing the nn.ModuleList to always be a list of size 1. Also added the missing apply method to the frontend nn.Module class. --- .../frontends/torch/nn/modules/module.py | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index b4d13f57725a9..a9363d8ad4e78 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -1,7 +1,7 @@ # global import ivy from collections import OrderedDict -from typing import Any, Dict, Iterator, List, Optional, Set, Tuple +from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Callable # local from ivy.functional.frontends.torch.nn.parameter import Parameter @@ -115,8 +115,27 @@ def _forward(self, *a, **kw): return ret def add_module(self, name: str, module: Optional["Module"]) -> None: + if not isinstance(module, Module) and module is not None: + raise TypeError(f"{type(module)} is not a Module subclass") + elif not isinstance(name, str): + raise TypeError(f"module name should be a string. Got {type(name)}") + elif hasattr(self, name) and name not in self._modules: + raise KeyError(f"attribute '{name}' already exists") + elif "." in name: + raise KeyError(f'module name can\'t contain ".", got: {name}') + elif name == "": + raise KeyError('module name can\'t be empty string ""') + + self._modules[name] = module + super().__setattr__(name, module) + def apply(self, fn: Callable[["Module"], None]): + for module in self.children(): + module.apply(fn) + fn(self) + return self + def register_buffer(self, name: str, value: Optional["Tensor"]) -> None: super().register_buffer(name, value) From 53f26a7c8391afbc79d459b0b187f3a968965f1d Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Tue, 30 Jan 2024 17:52:56 +0300 Subject: [PATCH 699/978] (fix)(data_class): added a small fix to the ivy.Array class which was previously throwing an error when passed a tuple/list. Added a check to convert the tuple/list to an array in such a case. --- ivy/data_classes/array/array.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 7794ebee4d7d9..77536ed75c53e 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -144,6 +144,8 @@ def _init(self, data, dynamic_backend=None): self._data = data elif isinstance(data, np.ndarray): self._data = ivy.asarray(data)._data + elif isinstance(data, (list, tuple)): + self._data = ivy.asarray(data)._data elif ivy.is_ivy_sparse_array(data): self._data = data._data elif ivy.is_native_sparse_array(data): From 6b32e5854168398136e4f5b9f4d4e601a3a4976d Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Tue, 30 Jan 2024 19:46:32 +0300 Subject: [PATCH 700/978] (fix)(backend Module): fixed the issue with using the @dataclass for the TreeSpec class causing an issue when inspecting the code as the module isnt a part of the sys.modules. Resorted to the use of a normal class and defined the __init__ method for it. --- ivy/functional/backends/tensorflow/module.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/ivy/functional/backends/tensorflow/module.py b/ivy/functional/backends/tensorflow/module.py index 6e19f1568f1c6..cf9c8a52ae78e 100644 --- a/ivy/functional/backends/tensorflow/module.py +++ b/ivy/functional/backends/tensorflow/module.py @@ -6,7 +6,6 @@ import logging from tensorflow.python.util import nest from typing import NamedTuple, Callable, Any, Tuple, List, Dict, Type, Union -from dataclasses import dataclass # A NodeDef holds two callables: # - flatten_fn should take the collection and return a flat list of values. @@ -60,11 +59,12 @@ def _is_leaf(pytree: PyTree) -> bool: # context: some context that is useful in unflattening the pytree # children_specs: specs for each child of the root Node # num_leaves: the number of leaves -@dataclass class TreeSpec: - type: Any - context: Context - children_specs: List["TreeSpec"] + def __init__(self, type, context, children_specs): + self.type: Any = type + self.context: Context = context + self.children_specs: List["TreeSpec"] = children_specs + self.num_leaves: int = sum([spec.num_leaves for spec in self.children_specs]) def get_keychains(self, prefix="", sep="/"): keychains = [] @@ -76,9 +76,6 @@ def get_keychains(self, prefix="", sep="/"): keychains.append(new_prefix[: -len(sep)]) return keychains - def __post_init__(self) -> None: - self.num_leaves: int = sum([spec.num_leaves for spec in self.children_specs]) - def __repr__(self, indent: int = 0) -> str: repr_prefix: str = f"TreeSpec({self.type.__name__}, {self.context}, [" children_specs_str: str = "" From 7b0bdad99b75ee6e0d0f6dd14ad592754cf63c6a Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Tue, 30 Jan 2024 16:54:35 +0000 Subject: [PATCH 701/978] (fix)(tf backend)(utility): fixed the backend implementation of ivy.any and ivy.all for the TF backend which was previously tf.function unfriendly as we were using tf.constant which does not work when using SymbolicTensors. --- ivy/functional/backends/tensorflow/utility.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/ivy/functional/backends/tensorflow/utility.py b/ivy/functional/backends/tensorflow/utility.py index a09dedb163baa..e267a1533c458 100644 --- a/ivy/functional/backends/tensorflow/utility.py +++ b/ivy/functional/backends/tensorflow/utility.py @@ -15,7 +15,6 @@ def all( keepdims: bool = False, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - x = tf.constant(x) if axis is None: num_dims = len(x.shape) axis = tuple(range(num_dims)) @@ -35,7 +34,6 @@ def any( keepdims: bool = False, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - x = tf.constant(x) if axis is None: num_dims = len(x.shape) axis = tuple(range(num_dims)) From b33ed80acb9204711b60f7135e75b4b792a958d8 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 30 Jan 2024 23:28:00 +0530 Subject: [PATCH 702/978] fix: Fixed `paddle_backend.divide` (#28063) --- ivy/functional/backends/paddle/elementwise.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index cb15c8d8c4948..c266ff3a716d7 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -402,12 +402,13 @@ def divide( *, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: - if paddle.is_complex(x1) or paddle.is_complex(x2): - angle_value = paddle.angle(x1) - paddle.angle(x2) - abs_value = paddle.abs(x1) / paddle.abs(x2) - return paddle.complex( - abs_value * paddle.cos(angle_value), abs_value * paddle.sin(angle_value) - ) + if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): + if paddle.is_complex(x1) or paddle.is_complex(x2): + angle_value = paddle.angle(x1) - paddle.angle(x2) + abs_value = paddle.abs(x1) / paddle.abs(x2) + return paddle.complex( + abs_value * paddle.cos(angle_value), abs_value * paddle.sin(angle_value) + ) x1, x2, ret_dtype = _elementwise_helper(x1, x2) return (x1 / x2).astype(ret_dtype) From 30f636642dadab33e7b7114736760d4b16f5725b Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 31 Jan 2024 02:28:55 +0530 Subject: [PATCH 703/978] fix: fixed fmod at paddle backend (#28124) paddle backend tests are fixed --- ivy/functional/backends/paddle/elementwise.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index c266ff3a716d7..6f7490d6e0437 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -1183,6 +1183,10 @@ def isreal( return paddle.ones_like(x, dtype="bool") +@with_supported_dtypes( + {"2.6.0 and below": ("float32", "float64", "int32", "int64", "complex")}, + backend_version, +) def fmod( x1: paddle.Tensor, x2: paddle.Tensor, From 3eaf4da43fbc89013f1cb1d1e9b2f0318190c8f4 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 31 Jan 2024 02:31:23 +0530 Subject: [PATCH 704/978] fix: fixed rad2deg for all the backend (#28131) fixed rad2deg that it's not able to convert int dtype on tf to egertensor --- ivy/functional/backends/tensorflow/elementwise.py | 1 + .../test_ivy/test_functional/test_core/test_elementwise.py | 6 +++--- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index 0f5b887e61618..5a86d3e29e637 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -872,6 +872,7 @@ def deg2rad( return radians +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) def rad2deg( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index a5f7eb3d8e164..8caad965f98c0 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1636,9 +1636,7 @@ def test_pow(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.rad2deg", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric") - ), + dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("valid")), ) def test_rad2deg(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): input_dtype, x = dtype_and_x @@ -1646,6 +1644,8 @@ def test_rad2deg(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): input_dtypes=input_dtype, test_flags=test_flags, backend_to_test=backend_fw, + rtol_=1e-2, + atol_=1e-2, fn_name=fn_name, on_device=on_device, x=x[0], From abde04deb91ba2b455e62cae7ce2fa4e47223970 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 31 Jan 2024 14:26:55 +0530 Subject: [PATCH 705/978] feat: added a workflow to be able to trigger all or priority failing tests in the CI, given that tests don't get triggered intelligently at times (#28134) --- .github/workflows/run-failing-tests.yml | 80 ++++++++++++++ scripts/setup_tests/setup_failing_tests.py | 120 +++++++++++++++++++++ 2 files changed, 200 insertions(+) create mode 100644 .github/workflows/run-failing-tests.yml create mode 100644 scripts/setup_tests/setup_failing_tests.py diff --git a/.github/workflows/run-failing-tests.yml b/.github/workflows/run-failing-tests.yml new file mode 100644 index 0000000000000..97eb12a463674 --- /dev/null +++ b/.github/workflows/run-failing-tests.yml @@ -0,0 +1,80 @@ +name: Run Failing Tests +on: + workflow_dispatch: + inputs: + priority: + description: 'Priority:' + default: true + required: false + +permissions: + actions: read +jobs: + display_test_results: + if: ${{ always() }} + runs-on: ubuntu-latest + needs: + - run_tests + + steps: + - name: Download all test results + uses: actions/download-artifact@v3 + + - name: Combined Test Results + run: | + find . -name "test_results_*.txt" -exec cat {} + > combined_test_results.txt + echo "Test results summary:" + cat combined_test_results.txt + + run_tests: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + branch: [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128 ] + steps: + - name: Checkout Ivy 🛎 + uses: actions/checkout@v3 + with: + path: ivy + persist-credentials: false + submodules: "recursive" + fetch-depth: 1 + + - name: Get Job URL + uses: Tiryoh/gha-jobid-action@v0 + id: jobs + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + job_name: ${{ github.job }} + + - name: Setup Tests + run: | + pip3 install pymongo + cd ivy + mkdir .ivy + touch .ivy/key.pem + echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem + python scripts/setup_tests/setup_failing_tests.py ${{ github.event.inputs.priority }} ${{ matrix.branch }} + + - name: Run Tests + run: | + cd ivy + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} + continue-on-error: true + + - name: Check on failures + if: steps.tests.outcome != 'success' + run: exit 1 diff --git a/scripts/setup_tests/setup_failing_tests.py b/scripts/setup_tests/setup_failing_tests.py new file mode 100644 index 0000000000000..713d089910a99 --- /dev/null +++ b/scripts/setup_tests/setup_failing_tests.py @@ -0,0 +1,120 @@ +from get_all_tests import BACKENDS +from packaging import version +from pymongo import MongoClient +import requests +import sys + + +def get_latest_package_version(package_name): + try: + url = f"https://pypi.org/pypi/{package_name}/json" + response = requests.get(url, timeout=10) + response.raise_for_status() + package_info = response.json() + versions = list(package_info["releases"].keys()) + key = lambda x: version.parse(x) + return sorted(versions, key=key, reverse=True) + except requests.exceptions.RequestException: + print(f"Error: Failed to fetch package information for {package_name}.") + return None + + +def main(): + # connect to the database + priority = sys.argv[1] == "true" + run_iter = int(sys.argv[2]) - 1 + cluster = MongoClient( + "mongodb+srv://readonly-user:hvpwV5yVeZdgyTTm@cluster0.qdvf8q3.mongodb.net" + ) + ci_dashboard_db = cluster["ci_dashboard"] + ivy_tests_collection = ci_dashboard_db["ivy_tests"] + frontend_tests_collection = ci_dashboard_db["frontend_tests"] + + # iterate over demos and collect ivy and frontend functions used + ivy_test_docs = ivy_tests_collection.find() + frontend_test_docs = frontend_tests_collection.find() + ivy_functions = [ + ivy_test_doc["_id"] + for ivy_test_doc in ivy_test_docs + if not priority or ivy_test_doc.get("demos", None) + ] + frontend_functions = [ + frontend_test_doc["_id"] + for frontend_test_doc in frontend_test_docs + if not priority or frontend_test_doc.get("demos", None) + ] + ivy_functions = sorted(list(set(ivy_functions))) + frontend_functions = sorted(list(set(frontend_functions))) + versions = { + backend: [ + version_name.replace(".", "_") + for version_name in get_latest_package_version(backend) + ] + for backend in BACKENDS + } + + # find corresponding test paths for those functions + ivy_test_paths = [] + frontend_test_paths = [] + for function in ivy_functions: + print("function", function) + result = ivy_tests_collection.find_one({"_id": function}) + if result: + for backend in BACKENDS: + if backend in result: + for version_name in versions[backend]: + if version_name in result[backend]: + if "status" in result[backend][version_name]: + status = result[backend][version_name]["status"].get( + "cpu" + ) + if not status and status is not None: + ivy_test_paths.append( + f"{result['test_path']},{backend}" + ) + break + + for function in frontend_functions: + print("frontend function", function) + frontend = function.split(".")[0] + result = frontend_tests_collection.find_one({"_id": function}) + if result and frontend in versions: + for frontend_version in versions[frontend]: + if frontend_version in result: + backend_result = result[frontend_version] + for backend in BACKENDS: + if backend in backend_result: + for version_name in versions[backend]: + if version_name in backend_result[backend]: + if ( + "status" + in backend_result[backend][version_name] + ): + status = backend_result[backend][version_name][ + "status" + ].get("cpu") + if not status and status is not None: + frontend_test_paths.append( + f"{result['test_path']},{backend}" + ) + break + + all_tests = ivy_test_paths + frontend_test_paths + all_tests = [test_path.strip() for test_path in all_tests] + tests_per_run = 50 + num_tests = len(all_tests) + start = run_iter * tests_per_run + end = (run_iter + 1) * tests_per_run + end = min(end, num_tests) + if start < end: + tests = all_tests[start:end] + else: + tests = [] + + # add those paths to the tests_to_run + with open("tests_to_run", "w") as write_file: + write_file.write("\n".join(tests)) + + +if __name__ == "__main__": + main() From 91a0b62de5881dcf5e88949262780c252b030e28 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 31 Jan 2024 14:34:10 +0530 Subject: [PATCH 706/978] fix: removed the final check from the workflow to avoid marking unused jobs as failing --- .github/workflows/run-failing-tests.yml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/.github/workflows/run-failing-tests.yml b/.github/workflows/run-failing-tests.yml index 97eb12a463674..e15935ccd581d 100644 --- a/.github/workflows/run-failing-tests.yml +++ b/.github/workflows/run-failing-tests.yml @@ -74,7 +74,3 @@ jobs: cd ivy python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true - - - name: Check on failures - if: steps.tests.outcome != 'success' - run: exit 1 From 37a010d29d30354b06f7571738cd233f00773377 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 31 Jan 2024 18:46:14 +0530 Subject: [PATCH 707/978] fix: added the tensorflow backend implementation for bernoulli and fixed the backend implementations for the other backends regarding default shape and default dtype (#28139) --- .../backends/jax/experimental/random.py | 3 ++- .../backends/numpy/experimental/random.py | 1 + .../backends/paddle/experimental/random.py | 5 ++++- .../backends/tensorflow/experimental/random.py | 11 ++++++++--- .../tf_probability/experimental/random.py | 1 + .../backends/torch/experimental/random.py | 18 ++++++++---------- .../test_experimental/test_core/test_random.py | 5 ++++- 7 files changed, 28 insertions(+), 16 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/random.py b/ivy/functional/backends/jax/experimental/random.py index 17b2d54037a99..19093eda961ea 100644 --- a/ivy/functional/backends/jax/experimental/random.py +++ b/ivy/functional/backends/jax/experimental/random.py @@ -117,6 +117,7 @@ def bernoulli( seed: Optional[int] = None, out: Optional[JaxArray] = None, ) -> JaxArray: + dtype = dtype if dtype is not None else probs.dtype if seed: rng_input = jax.random.PRNGKey(seed) else: @@ -126,4 +127,4 @@ def bernoulli( probs = jax.nn.softmax(logits, axis=-1) if hasattr(probs, "shape") and not _check_shapes_broadcastable(shape, probs.shape): shape = probs.shape - return jax.random.bernoulli(rng_input, probs, shape=shape) + return jax.random.bernoulli(rng_input, probs, shape=shape).astype(dtype) diff --git a/ivy/functional/backends/numpy/experimental/random.py b/ivy/functional/backends/numpy/experimental/random.py index 16293d4eac407..34960431a3210 100644 --- a/ivy/functional/backends/numpy/experimental/random.py +++ b/ivy/functional/backends/numpy/experimental/random.py @@ -99,6 +99,7 @@ def bernoulli( seed: Optional[int] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: + dtype = dtype if dtype is not None else probs.dtype if seed is not None: np.random.seed(seed) if logits is not None: diff --git a/ivy/functional/backends/paddle/experimental/random.py b/ivy/functional/backends/paddle/experimental/random.py index 462084349e2ae..e5095b76bc297 100644 --- a/ivy/functional/backends/paddle/experimental/random.py +++ b/ivy/functional/backends/paddle/experimental/random.py @@ -127,6 +127,7 @@ def bernoulli( seed: Optional[int] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: + dtype = dtype if dtype is not None else probs.dtype if seed is not None: paddle.seed(seed) if probs is not None: @@ -134,7 +135,9 @@ def bernoulli( elif logits is not None: probs = ivy.softmax(logits) probs = paddle.cast(probs, dtype) - probs = paddle.unsqueeze(probs, 0) if len(probs.shape) == 0 else probs + squeeze = len(probs.shape) == 0 + probs = paddle.unsqueeze(probs, 0) if squeeze else probs probs = paddle.maximum(probs, paddle.full_like(probs, 1e-6)) sample = paddle.bernoulli(probs) + sample = paddle.squeeze(sample, 0) if squeeze else sample return sample diff --git a/ivy/functional/backends/tensorflow/experimental/random.py b/ivy/functional/backends/tensorflow/experimental/random.py index c2742785656e3..2a1bff81f7029 100644 --- a/ivy/functional/backends/tensorflow/experimental/random.py +++ b/ivy/functional/backends/tensorflow/experimental/random.py @@ -90,15 +90,20 @@ def poisson( return ret +@with_unsupported_dtypes({"2.15.0 and below": ("bfloat16",)}, backend_version) def bernoulli( probs: Union[float, tf.Tensor, tf.Variable], *, logits: Union[float, tf.Tensor, tf.Variable] = None, shape: Optional[Union[ivy.NativeShape, Sequence[int]]] = None, device: Optional[str] = None, - dtype: DType, + dtype: Optional[str] = None, seed: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: - pass - # TODO: Implement purely in tensorflow + dtype = dtype if dtype is not None else probs.dtype + if logits is not None: + probs = tf.nn.softmax(logits, -1) + if not _check_shapes_broadcastable(shape, probs.shape): + shape = probs.shape + return tf.keras.backend.random_bernoulli(shape, probs, dtype, seed) diff --git a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py index ef672977bb4d2..b33cd8304df18 100644 --- a/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py +++ b/ivy/functional/backends/tensorflow/sub_backends/tf_probability/experimental/random.py @@ -63,6 +63,7 @@ def bernoulli( seed: Optional[int] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: + dtype = dtype if dtype is not None else probs.dtype if seed is not None: tf.random.set_seed(seed) if logits is not None: diff --git a/ivy/functional/backends/torch/experimental/random.py b/ivy/functional/backends/torch/experimental/random.py index a4d5b116b0782..5532f5914a42f 100644 --- a/ivy/functional/backends/torch/experimental/random.py +++ b/ivy/functional/backends/torch/experimental/random.py @@ -116,16 +116,14 @@ def bernoulli( seed: Optional[int] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: + dtype = dtype if dtype is not None else probs.dtype if seed: torch.manual_seed(seed) if logits is not None: - if not _check_shapes_broadcastable(shape, logits.shape): - shape = logits.shape - elif probs is not None: - if not _check_shapes_broadcastable(shape, probs.shape): - shape = probs.shape - return ( - torch.distributions.bernoulli.Bernoulli(probs=probs, logits=logits) - .sample(shape) - .to(device, dtype) - ) + probs = torch.nn.functional.softmax(logits, -1) + if not _check_shapes_broadcastable(shape, probs.shape): + shape = probs.shape + return torch.bernoulli(probs, out=out).to(device, dtype).broadcast_to(shape) + + +bernoulli.support_native_out = True diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_random.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_random.py index 730c1749af982..0da1bbb87a106 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_random.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_random.py @@ -16,6 +16,7 @@ ), seed=helpers.ints(min_value=0, max_value=100), test_gradients=st.just(False), + ground_truth_backend="torch", ) def test_bernoulli( *, dtype_and_probs, seed, test_flags, backend_fw, fn_name, on_device @@ -25,18 +26,20 @@ def test_bernoulli( assume( not ("torch" in str(backend_fw) and "float16" in dtype and on_device == "cpu") ) - helpers.test_function( + ret_np_flat_from_target, ret_np_from_gt_flat = helpers.test_function( input_dtypes=dtype, test_flags=test_flags, on_device=on_device, backend_to_test=backend_fw, fn_name=fn_name, test_values=False, + return_flat_np_arrays=True, probs=probs[0], logits=None, shape=None, seed=seed, ) + helpers.assert_same_type_and_shape([ret_np_flat_from_target, ret_np_from_gt_flat]) # beta From bc39f29b4e924c3cbdee8349a7a74fcc5ac7d920 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Wed, 31 Jan 2024 14:10:10 +0000 Subject: [PATCH 708/978] feat: superset ivy.lstm so it can be used equivalently to tf.keras.layers.lstm (#28140) --- ivy/functional/backends/torch/layers.py | 49 +++++++++++++- .../torch/nn/functional/layer_functions.py | 6 +- ivy/functional/ivy/layers.py | 65 +++++++++++++++++-- .../test_functional/test_nn/test_layers.py | 29 +++++++-- 4 files changed, 132 insertions(+), 17 deletions(-) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index e23e8cee591a2..ebf94504dd536 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -874,22 +874,65 @@ def lstm( input: torch.Tensor, initial_states: Tuple[torch.Tensor], all_weights: Tuple[torch.Tensor], - has_biases: bool, num_layers: int, dropout: float, train: bool, bidirectional: bool, batch_first: bool = False, batch_sizes: Sequence = None, + weights_transposed: bool = False, + has_ih_bias: bool = True, + has_hh_bias: bool = True, + return_sequences: bool = True, + return_states: bool = True, ): - return torch.lstm( + if weights_transposed: + # transpose the weights if they are in the wrong format + all_weights = [ + torch.transpose(weight, 1, 0) if weight.dim() == 2 else weight + for weight in all_weights + ] + else: + all_weights = list(all_weights) + + if (has_ih_bias and not has_hh_bias) or (has_hh_bias and not has_ih_bias): + # insert zero biases into the weights where one set of biases is not + # used, to avoid stride errors in lstm + shapes = [] + for i in range(2, len(all_weights), 3): + shapes.append(tuple(all_weights[i].shape)) + for i, shape in enumerate(shapes): + idx = (i + 1) * 4 - (1 if has_ih_bias else 2) + all_weights.insert(idx, torch.zeros(shape)) + has_ih_bias = True + has_hh_bias = True + + if initial_states[0].dim() == 2: + initial_states[0] = ivy.expand_dims(initial_states[0]) + if initial_states[1].dim() == 2: + initial_states[1] = ivy.expand_dims(initial_states[1]) + + ret = torch.lstm( input, initial_states, all_weights, - has_biases, + has_ih_bias, num_layers, dropout, train, bidirectional, batch_first, ) + + if return_states: + if return_sequences: + return ret + else: + return tuple( + [ret[0][:, -1], ret[1], ret[2]] + ) # TODO: this depends on batch_first + else: + if return_sequences: + return ret[0] + else: + return ret[0][:, -1] diff --git a/ivy/functional/frontends/torch/nn/functional/layer_functions.py b/ivy/functional/frontends/torch/nn/functional/layer_functions.py index d3be3e8b3dae1..7dfce9e67993f 100644 --- a/ivy/functional/frontends/torch/nn/functional/layer_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/layer_functions.py @@ -30,12 +30,13 @@ def _lstm_full( input, hx, params, - has_biases, num_layers, dropout, train, bidirectional, batch_first=batch_first, + has_ih_bias=has_biases, + has_hh_bias=has_biases, ) @@ -54,12 +55,13 @@ def _lstm_packed( data, hx, params, - has_biases, num_layers, dropout, train, bidirectional, batch_sizes=batch_sizes, + has_ih_bias=has_biases, + has_hh_bias=has_biases, ) diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index 53ca95676a3d0..b9662a0cf1eda 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -2388,13 +2388,17 @@ def lstm( input: ivy.Array, initial_states: Tuple[ivy.Array], all_weights: Tuple[ivy.Array], - has_biases: bool, num_layers: int, dropout: float, train: bool, bidirectional: bool, batch_first: bool = False, batch_sizes: Sequence = None, + weights_transposed: bool = False, + has_ih_bias: bool = True, + has_hh_bias: bool = True, + return_sequences: bool = True, + return_states: bool = True, ): """Applies a multi-layer long-short term memory to an input sequence. @@ -2411,15 +2415,13 @@ def lstm( (num_directions being 2 when `bidirectional`, otherwise 1) all_weights tuple of arrays representing the learnable weights of the lstm, with each - layer having either four arrays (w_ih, w_hh, b_ih, b_hh), when has_biases=True, - or two (w_ih, w_hh), when has_biases=False + layer having up to four arrays (w_ih, w_hh, b_ih, b_hh) representing the weights + and biases (if biases are being used) w_ih: weight of shape (4 * hidden_size, input_size) w_hh: weight of shape (4 * hidden_size, hidden_size) b_ih: bias of shape (4 * hidden_size,) b_hh: bias of shape (4 * hidden_size,) - has_biases - indicates whether the `all_weights` argument includes biases num_layers number of layers for the lstm to use dropout @@ -2432,6 +2434,19 @@ def lstm( defines the data format of the input and output arrays batch_sizes specifies the batch size at each timestep, when the input is a packed sequence + weights_transposed + whether the weights are transposed compared to the format + in which they are expected (input_size, 4 * hidden_size) + rather than (4 * hidden_size, input_size) + has_ih_bias + whether the `all_weights` argument includes a input-hidden bias + has_hh_bias + whether the `all_weights` argument includes a hidden-hidden bias + return_sequences + whether to return the last output in the output sequence, + or the full sequence + return_states + whether to return the final hidden and carry states in addition to the output Returns ------- @@ -2443,7 +2458,34 @@ def lstm( c_outs final cell state of shape (num_layers * num_directions, batch, hidden_size) """ - weights_per_layer = 4 if has_biases else 2 + # TODO: the test for this function needs to be fixed - + # see ivy_tests/test_ivy/test_functional/test_nn/test_layers.py::test_lstm + + if weights_transposed: + # transpose the weights if they are in the wrong format + all_weights = [ + ivy.swapaxes(weight, 1, 0) if weight.dim() == 2 else weight + for weight in all_weights + ] + else: + all_weights = list(all_weights) + + if (has_ih_bias and not has_hh_bias) or (has_hh_bias and not has_ih_bias): + # insert zero biases into the weights where one set of biases is not used + shapes = [] + for i in range(2, len(all_weights), 3): + shapes.append(tuple(all_weights[i].shape)) + for i, shape in enumerate(shapes): + idx = (i + 1) * 4 - (1 if has_ih_bias else 2) + all_weights.insert(idx, ivy.zeros(shape)) + has_ih_bias = True + has_hh_bias = True + + weights_per_layer = 2 + if has_ih_bias: + weights_per_layer += 1 + if has_hh_bias: + weights_per_layer += 1 assert len(all_weights) == num_layers * weights_per_layer * (1 + bidirectional) layer_weights = [ @@ -2525,7 +2567,16 @@ def lstm( if batch_sizes is not None: output = _pack_padded_sequence(output, batch_sizes)[0] - return output, h_outs, c_outs + if return_states: + if return_sequences: + return output, h_outs, c_outs + else: + return output[:, -1], h_outs, c_outs # TODO: this depends on batch_first + else: + if return_sequences: + return output + else: + return output[:, -1] # Helpers # diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index f1bf4f99e9d84..f18a9b632b028 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -87,7 +87,11 @@ def _general_transpose_helper(draw): def _lstm_helper(draw): dtype = draw(helpers.get_dtypes("float", full=False)) - has_biases = draw(st.booleans()) + has_ih_bias = draw(st.booleans()) + has_hh_bias = draw(st.booleans()) + weights_transposed = draw(st.booleans()) + return_sequences = draw(st.booleans()) + return_states = draw(st.booleans()) bidirectional = draw(st.booleans()) dropout = draw(st.floats(min_value=0, max_value=0.99)) train = draw(st.booleans()) and not dropout @@ -155,7 +159,7 @@ def _lstm_helper(draw): ) ) all_weights += [weight_ih, weight_hh] - if has_biases: + if has_ih_bias: bias_ih = draw( helpers.array_values( dtype=dtype[0], @@ -164,6 +168,8 @@ def _lstm_helper(draw): max_value=1, ) ) + all_weights.append(bias_ih) + if has_hh_bias: bias_hh = draw( helpers.array_values( dtype=dtype[0], @@ -172,7 +178,12 @@ def _lstm_helper(draw): max_value=1, ) ) - all_weights += [bias_ih, bias_hh] + all_weights.append(bias_hh) + + if weights_transposed: + all_weights = [ + ivy.swapaxes(w, 0, 1) if w.dims() == 2 else w for w in all_weights + ] if packed: batch_sizes = [seq_size] @@ -199,11 +210,15 @@ def _lstm_helper(draw): "batch_sizes": batch_sizes, "initial_states": initial_states, "all_weights": all_weights, - "has_biases": has_biases, "num_layers": num_layers, "dropout": dropout, "train": train, "bidirectional": bidirectional, + "weights_transposed": weights_transposed, + "has_ih_bias": has_ih_bias, + "has_hh_bias": has_hh_bias, + "return_sequences": return_sequences, + "return_states": return_states, } else: dtypes = dtype @@ -211,12 +226,16 @@ def _lstm_helper(draw): "input": input, "initial_states": initial_states, "all_weights": all_weights, - "has_biases": has_biases, "num_layers": num_layers, "dropout": dropout, "train": train, "bidirectional": bidirectional, "batch_first": batch_first, + "weights_transposed": weights_transposed, + "has_ih_bias": has_ih_bias, + "has_hh_bias": has_hh_bias, + "return_sequences": return_sequences, + "return_states": return_states, } return dtypes, kwargs From 33369c8acd25ff5e852bba3516ef8f2b2e8a8068 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 31 Jan 2024 20:31:41 +0530 Subject: [PATCH 709/978] fix: Fixed `stat.paddle.mean` for all backends (#28087) --- ivy/functional/frontends/paddle/stat.py | 4 ++-- ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py | 4 +++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/paddle/stat.py b/ivy/functional/frontends/paddle/stat.py index 1c2310e48b5ea..695e60dc5bd4e 100644 --- a/ivy/functional/frontends/paddle/stat.py +++ b/ivy/functional/frontends/paddle/stat.py @@ -1,12 +1,12 @@ # global import ivy -from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes +from ivy.func_wrapper import with_supported_dtypes from ivy.functional.frontends.paddle.func_wrapper import ( to_ivy_arrays_and_back, ) -@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") +@with_supported_dtypes({"2.6.0 and below": ("float32", "float64")}, "paddle") @to_ivy_arrays_and_back def mean(input, axis=None, keepdim=False, out=None): ret = ivy.mean(input, axis=axis, keepdims=keepdim, out=out) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py index f8ccfc5b7ac2c..9d37a3532b9de 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_stat.py @@ -26,7 +26,7 @@ def test_paddle_mean( backend_fw, test_flags, ): - input_dtype, x, axis = dtype_and_x + input_dtype, x, axis = dtype_and_x[:3] test_flags.num_positional_args = len(dtype_and_x) - 2 helpers.test_frontend_function( input_dtypes=input_dtype, @@ -35,6 +35,8 @@ def test_paddle_mean( test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, + rtol=1e-2, + atol=1e-2, input=x[0], axis=axis, keepdim=keepdim, From fbc737520322002c09a4ccfa8e957cc189f23b37 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 31 Jan 2024 21:52:35 +0530 Subject: [PATCH 710/978] fix: Fixed the lint warnings, failures and Updated black version (#28141) --- .pre-commit-config.yaml | 2 +- ivy/functional/backends/paddle/data_type.py | 2 +- ivy/functional/backends/torch/data_type.py | 2 +- ivy/functional/ivy/general.py | 2 +- ivy/functional/ivy/gradients.py | 2 +- ivy/utils/einsum_parser.py | 2 +- ivy/utils/profiler.py | 4 ++-- pyproject.toml | 3 --- 8 files changed, 8 insertions(+), 11 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d18a3b680e7df..ef72c32b06d33 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -13,7 +13,7 @@ repos: - id: ruff args: [ --fix ] - repo: https://github.com/psf/black-pre-commit-mirror - rev: 24.1.0 + rev: 24.1.1 hooks: - id: black language_version: python3 diff --git a/ivy/functional/backends/paddle/data_type.py b/ivy/functional/backends/paddle/data_type.py index e0277bb2e8fa7..48833be5155de 100644 --- a/ivy/functional/backends/paddle/data_type.py +++ b/ivy/functional/backends/paddle/data_type.py @@ -231,7 +231,7 @@ def as_ivy_dtype(dtype_in: Union[paddle.dtype, str, bool, int, float], /) -> ivy def as_native_dtype( - dtype_in: Union[paddle.dtype, str, bool, int, float] + dtype_in: Union[paddle.dtype, str, bool, int, float], ) -> paddle.dtype: if dtype_in is int: return ivy.default_int_dtype(as_native=True) diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index db70c7e023852..0fa729c4812e1 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -183,7 +183,7 @@ def as_ivy_dtype( @with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, backend_version) def as_native_dtype( - dtype_in: Union[torch.dtype, str, bool, int, float, np.dtype] + dtype_in: Union[torch.dtype, str, bool, int, float, np.dtype], ) -> torch.dtype: if dtype_in is int: return ivy.default_int_dtype(as_native=True) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index ab09c25b25d43..f19a1c4b0face 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -1574,7 +1574,7 @@ def to_ivy_shape(shape: Union[ivy.Shape, ivy.NativeShape]) -> ivy.Shape: @handle_exceptions def to_native_shape( - shape: Union[ivy.Array, ivy.Shape, ivy.NativeShape, tuple, int, list] + shape: Union[ivy.Array, ivy.Shape, ivy.NativeShape, tuple, int, list], ) -> ivy.NativeShape: """Return the input shape in its native backend framework form. diff --git a/ivy/functional/ivy/gradients.py b/ivy/functional/ivy/gradients.py index 8e1a162112909..fb93425a4c4f7 100644 --- a/ivy/functional/ivy/gradients.py +++ b/ivy/functional/ivy/gradients.py @@ -337,7 +337,7 @@ def _is_variable(x, exclusive=False, to_ignore=None) -> bool: def _variable_data( - x: Union[ivy.Array, ivy.NativeArray] + x: Union[ivy.Array, ivy.NativeArray], ) -> Union[ivy.Array, ivy.NativeArray]: """Get the contents of the input. diff --git a/ivy/utils/einsum_parser.py b/ivy/utils/einsum_parser.py index 697e47d39494b..46705dd798b60 100644 --- a/ivy/utils/einsum_parser.py +++ b/ivy/utils/einsum_parser.py @@ -178,7 +178,7 @@ def convert_subscripts(old_sub: List[Any], symbol_map: Dict[Any, Any]) -> str: def convert_interleaved_input( - operands: Union[List[Any], Tuple[Any]] + operands: Union[List[Any], Tuple[Any]], ) -> Tuple[str, List[Any]]: """Convert 'interleaved' input to standard einsum input.""" tmp_operands = list(operands) diff --git a/ivy/utils/profiler.py b/ivy/utils/profiler.py index 371d14f88fe99..7558dce70d32a 100644 --- a/ivy/utils/profiler.py +++ b/ivy/utils/profiler.py @@ -81,7 +81,7 @@ def tensorflow_profile_start( Returns ------- None - """ + """ # noqa: E501 from tensorflow.profiler.experimental import ProfilerOptions, start options = ProfilerOptions( @@ -159,7 +159,7 @@ def torch_profiler_init( Returns ------- Torch profiler instance. - """ + """ # noqa: E501 from torch.profiler import profile, tensorboard_trace_handler profiler = profile( diff --git a/pyproject.toml b/pyproject.toml index 30afa89dfc9ea..19d04d5dcdd2e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -37,9 +37,6 @@ select = [ "I002", # Missing required import. "UP008", # Checks for super calls that pass redundant arguments. "PGH002", # deprecated-log-warn. - "PLR0203", # Static method defined without decorator. - "PLR0202", # Class method defined without decorator. - "PLW0245", # super call is missing parentheses. "PLR1722", # Use sys.exit() instead of exit() and quit(). "TRY004", # Prefer TypeError exception for invalid type. "PT014", # pytest-duplicate-parametrize-test-cases. From 4b865616eb1b4fbe802f2b405452a3be1402599c Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 31 Jan 2024 21:53:37 +0530 Subject: [PATCH 711/978] fix: fixed `paddle_backend.greater` and `paddle_backend.greater_equal` (#28111) --- ivy/functional/backends/paddle/elementwise.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 6f7490d6e0437..59f773ebfe5c4 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -458,8 +458,8 @@ def greater( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if paddle.is_complex(x1): - if paddle.is_complex(x1): + if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): + if paddle.is_complex(x1) and paddle.is_complex(x2): real = paddle.greater_than(x1.real(), x2.real()) imag = paddle.greater_than(x1.imag(), x2.imag()) return paddle.logical_and(real, imag) @@ -488,8 +488,8 @@ def greater_equal( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if paddle.is_complex(x1): - if paddle.is_complex(x1): + if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): + if paddle.is_complex(x1) and paddle.is_complex(x2): real = paddle.greater_equal(x1.real(), x2.real()) imag = paddle.greater_equal(x1.imag(), x2.imag()) return paddle.logical_and(real, imag) From 6cc77f1b8e964ef96b8f76dc0ab7d68d582132f0 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 31 Jan 2024 21:54:29 +0530 Subject: [PATCH 712/978] fix: fixed `paddle_backend.less` and `paddle_backend.less_equal` (#28109) --- ivy/functional/backends/paddle/elementwise.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 59f773ebfe5c4..297b507cea31a 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -155,8 +155,8 @@ def less_equal( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if paddle.is_complex(x1): - if paddle.is_complex(x2): + if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): + if paddle.is_complex(x1) and paddle.is_complex(x2): real = paddle.less_equal(x1.real(), x2.real()) imag = paddle.less_equal(x1.imag(), x2.imag()) return paddle_backend.logical_and(real, imag) @@ -335,10 +335,11 @@ def less( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - if paddle.is_complex(x1): - real = paddle.less_than(x1.real(), x2.real()) - imag = paddle.less_than(x1.imag(), x2.imag()) - return logical_and(real, imag) + if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): + if paddle.is_complex(x1) and paddle.is_complex(x2): + real = paddle.less_than(x1.real(), x2.real()) + imag = paddle.less_than(x1.imag(), x2.imag()) + return logical_and(real, imag) return paddle.less_than(x1, x2) From a706f8fdbc167c5650d45acef5562ff18633a3ec Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 1 Feb 2024 02:29:32 +0530 Subject: [PATCH 713/978] fix: fixed the failing test case at paddle backend (#27831) fixed tests at paddle backend --- ivy/functional/backends/paddle/elementwise.py | 20 ++++++++----------- .../test_core/test_elementwise.py | 2 +- 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 297b507cea31a..21183c2915cfd 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -120,8 +120,9 @@ def isinf( return paddle.zeros(shape=x.shape, dtype=bool) -@with_supported_dtypes( - {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, backend_version +@with_unsupported_dtypes( + {"2.6.0 and below": ("bfloat16",)}, + backend_version, ) def equal( x1: Union[float, paddle.Tensor], @@ -131,16 +132,11 @@ def equal( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) - diff = paddle_backend.subtract(x1, x2) - ret = paddle_backend.logical_and( - paddle_backend.less_equal(diff, 0), paddle_backend.greater_equal(diff, 0) - ) - # ret result is sufficient for all cases except where the value is +/-INF of NaN - return paddle_backend.where( - paddle_backend.isnan(diff), - ~paddle_backend.logical_or(paddle_backend.isnan(x1), paddle_backend.isnan(x2)), - ret, - ) + if paddle.is_complex(x1): + real = paddle.equal(x1.real(), x2.real()) + imag = paddle.equal(x1.imag(), x2.imag()) + return paddle_backend.logical_and(real, imag) + return paddle.equal(x1, x2) @with_supported_dtypes( diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 8caad965f98c0..dd4d079fa9f9d 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -687,7 +687,7 @@ def test_divide(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.equal", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid", full=True), num_arrays=2 + available_dtypes=helpers.get_dtypes("valid", full=False), num_arrays=2 ), test_gradients=st.just(False), ) From 8917d8c0eb58a9f40e6412ca15b0c4ee960a0391 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 1 Feb 2024 03:07:47 +0530 Subject: [PATCH 714/978] Cov (#22811) Co-authored-by: ivy-branch --- .../frontends/paddle/tensor/tensor.py | 12 ++ .../test_paddle/test_tensor/test_tensor.py | 139 ++++++++++++++++++ 2 files changed, 151 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index f3fe3500552a7..51ba3eee9a1d7 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -986,6 +986,18 @@ def trace(self, offset=0, axis1=0, axis2=1, name=None): ivy.trace(self._ivy_array, offset=offset, axis1=axis1, axis2=axis2) ) + @with_supported_dtypes({"2.6.0 and below": ("float64", "float32")}, "paddle") + def cov(self, rowvar=True, ddof=True, fweights=None, aweights=None): + return paddle_frontend.Tensor( + ivy.cov( + self._ivy_array, + rowVar=rowvar, + ddof=int(ddof), + fweights=fweights, + aweights=aweights, + ) + ) + @with_supported_dtypes( { "2.6.0 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index 60bc850a30f8a..eff1506aae721 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -312,6 +312,94 @@ def _get_dtype_input_and_matrices_for_matmul(draw): return dtype, mat1, mat2, transpose_x, transpose_y +@st.composite +def _get_dtype_value1_value2_cov( + draw, + available_dtypes, + min_num_dims, + max_num_dims, + min_dim_size, + max_dim_size, + abs_smallest_val=None, + min_value=None, + max_value=None, + allow_inf=False, + exclude_min=False, + exclude_max=False, + large_abs_safety_factor=4, + small_abs_safety_factor=4, + safety_factor_scale="log", +): + shape = draw( + helpers.get_shape( + allow_none=False, + min_num_dims=min_num_dims, + max_num_dims=max_num_dims, + min_dim_size=min_dim_size, + max_dim_size=max_dim_size, + ) + ) + + dtype = draw(st.sampled_from(draw(available_dtypes))) + + values = [] + for i in range(1): + values.append( + draw( + helpers.array_values( + dtype=dtype, + shape=shape, + abs_smallest_val=abs_smallest_val, + min_value=min_value, + max_value=max_value, + allow_inf=allow_inf, + exclude_min=exclude_min, + exclude_max=exclude_max, + large_abs_safety_factor=large_abs_safety_factor, + small_abs_safety_factor=small_abs_safety_factor, + safety_factor_scale=safety_factor_scale, + ) + ) + ) + + value = values[0] + + # modifiers: rowVar, bias, ddof + rowVar = draw(st.booleans()) + ddof = draw(st.booleans()) + + numVals = None + if rowVar is False: + numVals = -1 if numVals == 0 else 0 + else: + numVals = 0 if len(shape) == 1 else -1 + + fweights = draw( + helpers.array_values( + dtype="int64", + shape=shape[numVals], + abs_smallest_val=1, + min_value=1, + max_value=10, + allow_inf=False, + ) + ) + + aweights = draw( + helpers.array_values( + dtype="float64", + shape=shape[numVals], + abs_smallest_val=1, + min_value=1, + max_value=10, + allow_inf=False, + small_abs_safety_factor=1, + ) + ) + + return [dtype], value, rowVar, ddof, fweights, aweights + + @st.composite def _reshape_helper(draw): # generate a shape s.t len(shape) > 0 @@ -5686,6 +5774,57 @@ def test_paddle_tensor_chunk( ) +# cov +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="cov", + dtype_x1_corr_cov=_get_dtype_value1_value2_cov( + available_dtypes=helpers.get_dtypes("float"), + min_num_dims=2, + max_num_dims=2, + min_dim_size=2, + max_dim_size=5, + min_value=1, + max_value=1e10, + abs_smallest_val=0.01, + large_abs_safety_factor=2, + safety_factor_scale="log", + ), +) +def test_paddle_tensor_cov( + dtype_x1_corr_cov, + frontend_method_data, + init_flags, + method_flags, + frontend, + backend_fw, + on_device, +): + dtype, x, rowvar, ddof, fweights, aweights = dtype_x1_corr_cov + helpers.test_frontend_method( + init_input_dtypes=["float64", "int64", "float64"], + init_all_as_kwargs_np={ + "data": x, + }, + method_input_dtypes=["int64", "float64"], + backend_to_test=backend_fw, + method_all_as_kwargs_np={ + "rowvar": rowvar, + "ddof": ddof, + "fweights": fweights, + "aweights": aweights, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + rtol_=1e-3, + atol_=1e-3, + frontend=frontend, + on_device=on_device, + ) + + # expand @handle_frontend_method( class_tree=CLASS_TREE, From fff4830a50f9651ed355a6de78bdaa04d7152516 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Thu, 1 Feb 2024 04:25:52 -0800 Subject: [PATCH 715/978] Fix: Fix Ivy Failing Test: paddle - manipulation.concat (#28003) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/manipulation.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index 0e205ce439d39..71accc56dad03 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -22,6 +22,10 @@ # -------------------# +@with_unsupported_dtypes( + {"2.6.0 and below": ("bfloat16", "float16")}, + backend_version, +) def concat( xs: Union[Tuple[paddle.Tensor, ...], List[paddle.Tensor]], /, From 171d7aa693542946c61daa1923e503db447955fa Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Thu, 1 Feb 2024 04:32:30 -0800 Subject: [PATCH 716/978] FIX! Fix Ivy Failing Test: torch - searching.argmax (#28117) Co-authored-by: NripeshN --- ivy_tests/test_ivy/test_functional/test_core/test_searching.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_searching.py b/ivy_tests/test_ivy/test_functional/test_core/test_searching.py index 425c78805d9bb..f7b5ab9a88c31 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_searching.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_searching.py @@ -64,7 +64,7 @@ def _dtype_x_limited_axis(draw, *, allow_none=False): fn_tree="functional.ivy.argmax", dtype_x_axis=_dtype_x_limited_axis(allow_none=True), keepdims=st.booleans(), - dtype=helpers.get_dtypes("valid", full=False, none=True), + dtype=helpers.get_dtypes("numeric", full=False, none=True), select_last_index=st.booleans(), ) def test_argmax( From 75935bb4255d37c1037b49823083e3b3245fce46 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Thu, 1 Feb 2024 16:38:34 +0400 Subject: [PATCH 717/978] Update achievement conditions in config.yaml --- .vaunt/config.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.vaunt/config.yaml b/.vaunt/config.yaml index 43131223f3945..675a034d96b20 100644 --- a/.vaunt/config.yaml +++ b/.vaunt/config.yaml @@ -29,7 +29,7 @@ achievements: - trigger: actor: author action: pull_request - condition: count(merged = true & labels in {'Priority PR'} & created_at >= "2023-12-26") >= 1 + condition: count(merged = true & labels in {'Priority'} & created_at >= "2023-12-26") >= 1 - achievement: name: Ivy Inspectors @@ -69,7 +69,7 @@ achievements: - trigger: actor: author action: pull_request - condition: count(merged = true & labels in {'Priority PR'} & created_at >= "2023-12-26") >= 5 + condition: count(merged = true & labels in {'Priority'} & created_at >= "2023-12-26") >= 5 - achievement: name: Ivy Inspectors Bronze @@ -109,7 +109,7 @@ achievements: - trigger: actor: author action: pull_request - condition: count(merged = true & labels in {'Priority PR'} & created_at >= "2023-12-26") >= 15 + condition: count(merged = true & labels in {'Priority'} & created_at >= "2023-12-26") >= 15 - achievement: name: Ivy Inspectors Silver @@ -149,7 +149,7 @@ achievements: - trigger: actor: author action: pull_request - condition: count(merged = true & labels in {'Priority PR'} & created_at >= "2023-12-26") >= 30 + condition: count(merged = true & labels in {'Priority'} & created_at >= "2023-12-26") >= 30 - achievement: name: Ivy Inspectors Gold From 602a436f85cd4d90279d2e761c7a9af407bbc216 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Thu, 1 Feb 2024 12:55:04 +0000 Subject: [PATCH 718/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 99604a7221ed2..579ba7b74c501 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -1,7 +1,7 @@ Contributor Leaderboard ======================= -This page lists all of our amazing Contributors who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing Contributors who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Top Contributors ---------------- From d7fc3987b21999d1dc94dce870bd9b65d8a545e5 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Thu, 1 Feb 2024 15:42:42 +0000 Subject: [PATCH 719/978] feat: change ivy.lstm to always return sequences and states (#28155) --- ivy/functional/backends/torch/layers.py | 15 +-------------- .../torch/nn/functional/layer_functions.py | 6 ++++-- ivy/functional/ivy/layers.py | 18 +----------------- .../test_functional/test_nn/test_layers.py | 6 ------ 4 files changed, 6 insertions(+), 39 deletions(-) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index ebf94504dd536..e628b11acd34c 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -883,8 +883,6 @@ def lstm( weights_transposed: bool = False, has_ih_bias: bool = True, has_hh_bias: bool = True, - return_sequences: bool = True, - return_states: bool = True, ): if weights_transposed: # transpose the weights if they are in the wrong format @@ -924,15 +922,4 @@ def lstm( batch_first, ) - if return_states: - if return_sequences: - return ret - else: - return tuple( - [ret[0][:, -1], ret[1], ret[2]] - ) # TODO: this depends on batch_first - else: - if return_sequences: - return ret[0] - else: - return ret[0][:, -1] + return ret[0][:, -1], ret[0], (ret[1], ret[2]) diff --git a/ivy/functional/frontends/torch/nn/functional/layer_functions.py b/ivy/functional/frontends/torch/nn/functional/layer_functions.py index 7dfce9e67993f..0a28dd7bf91d0 100644 --- a/ivy/functional/frontends/torch/nn/functional/layer_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/layer_functions.py @@ -26,7 +26,7 @@ def _lstm_full( bidirectional, batch_first, ): - return ivy.lstm( + ret = ivy.lstm( input, hx, params, @@ -38,6 +38,7 @@ def _lstm_full( has_ih_bias=has_biases, has_hh_bias=has_biases, ) + return ret[1], ret[2][0], ret[2][1] def _lstm_packed( @@ -51,7 +52,7 @@ def _lstm_packed( train, bidirectional, ): - return ivy.lstm( + ret = ivy.lstm( data, hx, params, @@ -63,6 +64,7 @@ def _lstm_packed( has_ih_bias=has_biases, has_hh_bias=has_biases, ) + return ret[1], ret[2][0], ret[2][1] # --- Main --- # diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index b9662a0cf1eda..ceabe86041d31 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -2397,8 +2397,6 @@ def lstm( weights_transposed: bool = False, has_ih_bias: bool = True, has_hh_bias: bool = True, - return_sequences: bool = True, - return_states: bool = True, ): """Applies a multi-layer long-short term memory to an input sequence. @@ -2442,11 +2440,6 @@ def lstm( whether the `all_weights` argument includes a input-hidden bias has_hh_bias whether the `all_weights` argument includes a hidden-hidden bias - return_sequences - whether to return the last output in the output sequence, - or the full sequence - return_states - whether to return the final hidden and carry states in addition to the output Returns ------- @@ -2567,16 +2560,7 @@ def lstm( if batch_sizes is not None: output = _pack_padded_sequence(output, batch_sizes)[0] - if return_states: - if return_sequences: - return output, h_outs, c_outs - else: - return output[:, -1], h_outs, c_outs # TODO: this depends on batch_first - else: - if return_sequences: - return output - else: - return output[:, -1] + return output[:, -1], output, (h_outs, c_outs) # Helpers # diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py index f18a9b632b028..385b19b1a4c18 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_layers.py @@ -90,8 +90,6 @@ def _lstm_helper(draw): has_ih_bias = draw(st.booleans()) has_hh_bias = draw(st.booleans()) weights_transposed = draw(st.booleans()) - return_sequences = draw(st.booleans()) - return_states = draw(st.booleans()) bidirectional = draw(st.booleans()) dropout = draw(st.floats(min_value=0, max_value=0.99)) train = draw(st.booleans()) and not dropout @@ -217,8 +215,6 @@ def _lstm_helper(draw): "weights_transposed": weights_transposed, "has_ih_bias": has_ih_bias, "has_hh_bias": has_hh_bias, - "return_sequences": return_sequences, - "return_states": return_states, } else: dtypes = dtype @@ -234,8 +230,6 @@ def _lstm_helper(draw): "weights_transposed": weights_transposed, "has_ih_bias": has_ih_bias, "has_hh_bias": has_hh_bias, - "return_sequences": return_sequences, - "return_states": return_states, } return dtypes, kwargs From 85ff35ebb78d0ee6e8e7e5e85a832e39f5aa1221 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Thu, 1 Feb 2024 18:37:27 +0000 Subject: [PATCH 720/978] fix(stateful): Fixes torch.nn.Module __setattr__ logic to remove existing attributes during attribute setting for correct retrieval of overwritten attributes. Added module building check to named_modules and named_modules and named_children similar to named_parameters --- ivy/functional/backends/tensorflow/module.py | 6 ++--- .../frontends/torch/nn/modules/module.py | 27 ++++++++++++++++++- 2 files changed, 29 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/tensorflow/module.py b/ivy/functional/backends/tensorflow/module.py index cf9c8a52ae78e..c00046ce22e27 100644 --- a/ivy/functional/backends/tensorflow/module.py +++ b/ivy/functional/backends/tensorflow/module.py @@ -760,7 +760,7 @@ def __call__( def __getattr__(self, name): if name == "v": - if not super().__getattribute__("_v") and not self.built: + if not super().__getattribute__("_v") and not getattr(self, "built", False): return self._build_and_return_v( *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs ) @@ -782,7 +782,7 @@ def __setattr__(self, name, value): if ( hasattr(self, "_build_mode") and self.build_mode == "on_init" - and self.built + and getattr(self, "built", False) ): self._rebuild() return ret @@ -791,7 +791,7 @@ def __setattr__(self, name, value): if ( hasattr(self, "_build_mode") and self.build_mode == "on_init" - and self.built + and getattr(self, "built", False) ): self._rebuild() return ret diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index a9363d8ad4e78..75363c39f0548 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -197,7 +197,7 @@ def parameters(self, recurse: bool = True) -> Iterator[Parameter]: def named_parameters( self, prefix: str = "", recurse: bool = True, remove_duplicate: bool = True ) -> Iterator[Tuple[str, Parameter]]: - if not self.built: + if not getattr(self, "built", False): self.build( *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs ) @@ -214,6 +214,10 @@ def children(self) -> Iterator["Module"]: yield module def named_children(self) -> Iterator[Tuple[str, "Module"]]: + if not getattr(self, "built", False): + self.build( + *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs + ) memo = set() for name, module in self._module_dict.items(): if module is not None and id(module) not in memo: @@ -230,6 +234,10 @@ def named_modules( prefix: str = "", remove_duplicate: bool = True, ): + if not getattr(self, "built", False): + self.build( + *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs + ) if memo is None: memo = set() if id(self) not in memo: @@ -282,6 +290,23 @@ def __getattribute__(self, name: str) -> Any: return super().__getattribute__(mapping[name]) return super().__getattribute__(name) + def __setattr__(self, name, value) -> None: + def remove_from(*dicts_or_sets): + for d in dicts_or_sets: + if name in d: + if isinstance(d, dict): + del d[name] + else: + d.discard(name) + + params = self.__dict__.get("_v") + if params is not None and name in params and isinstance(value, Parameter): + remove_from(self.__dict__, self._buffers, self._module_dict) + self.register_parameter(name, value) + super().__setattr__(name, value) + else: + super().__setattr__(name, value) + def __repr__(self): # We treat the extra repr like the sub-module, one item per line extra_lines = [] From a66367b433cf3c76118a5152f4bdf8121fd5e1b5 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Thu, 1 Feb 2024 18:40:17 +0000 Subject: [PATCH 721/978] fix(stateful): Fixed to_keras_module so that after converting a frontend nn.Module instance to a keras instance, the model parameters in the .v attribute remain as frontend torch.nn.Parameter instances and not tf.Variable instances --- ivy/stateful/converters.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/stateful/converters.py b/ivy/stateful/converters.py index 834096133f581..541829bc3d18b 100644 --- a/ivy/stateful/converters.py +++ b/ivy/stateful/converters.py @@ -507,7 +507,7 @@ def __update_param(ivy_module, x, kc): module = module.__getattribute__(key) if hasattr(module, "_update_v"): module._update_v({keys[-1]: self._parameters[kc]}) - return self._parameters[kc] + return getattr(module, keys[-1]) self._ivy_module.v = self._ivy_module.v.cont_map( functools.partial(__update_param, self._ivy_module), From 91535b3bd32b3aeaf2a8d7e3c658874a81e04ded Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Fri, 2 Feb 2024 02:14:27 +0530 Subject: [PATCH 722/978] fix: fixed fmax at paddle frontend dtype problem (#28149) fixed paddle frontend supported dtypes --- ivy/functional/frontends/paddle/math.py | 4 +++- ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index 3180215d448fc..cab705184a105 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -285,7 +285,9 @@ def floor_mod(x, y, name=None): return ivy.remainder(x, y) -@with_unsupported_dtypes({"2.6.0 and below": "bfloat16"}, "paddle") +@with_supported_dtypes( + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" +) @to_ivy_arrays_and_back def fmax(x, y, name=None): return ivy.fmax(x, y) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py index c93967b71cf46..b58b10a91b88c 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py @@ -1137,7 +1137,7 @@ def test_paddle_floor_mod( @handle_frontend_test( fn_tree="paddle.fmax", dtypes_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), num_arrays=2, shared_dtype=True + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True ), ) def test_paddle_fmax( From a8677912094b2c65e6255f89f16ed2583bfa5826 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Fri, 2 Feb 2024 02:50:37 +0530 Subject: [PATCH 723/978] fix: fixed fmin at paddle frontend facing unsupported dtype error (#28148) fixed fmin at paddle frontend --- ivy/functional/frontends/paddle/math.py | 4 +++- ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py index cab705184a105..a70fc6179477f 100644 --- a/ivy/functional/frontends/paddle/math.py +++ b/ivy/functional/frontends/paddle/math.py @@ -293,7 +293,9 @@ def fmax(x, y, name=None): return ivy.fmax(x, y) -@with_unsupported_dtypes({"2.6.0 and below": "bfloat16"}, "paddle") +@with_supported_dtypes( + {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, "paddle" +) @to_ivy_arrays_and_back def fmin(x, y, name=None): return ivy.fmin(x, y) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py index b58b10a91b88c..a7e20943574a5 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py @@ -1165,7 +1165,7 @@ def test_paddle_fmax( @handle_frontend_test( fn_tree="paddle.fmin", dtypes_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), num_arrays=2, shared_dtype=True + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True ), ) def test_paddle_fmin( From a3cb8fcce9779ba17bd81847185488692049b5ae Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 2 Feb 2024 13:48:06 +0530 Subject: [PATCH 724/978] chore(ci): disabled the gpu cron job for now --- .github/workflows/test-ivy-cron-gpu.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test-ivy-cron-gpu.yml b/.github/workflows/test-ivy-cron-gpu.yml index d382aafc3aa16..03e8f5b36851c 100644 --- a/.github/workflows/test-ivy-cron-gpu.yml +++ b/.github/workflows/test-ivy-cron-gpu.yml @@ -1,8 +1,8 @@ name: test-ivy-cron-gpu on: workflow_dispatch: - schedule: - - cron: '25 * * * *' + # schedule: + # - cron: '25 * * * *' permissions: actions: read concurrency: From 9e087d6d2544ea09a8a6449cba97e5838ffedfb1 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 2 Feb 2024 08:19:56 +0000 Subject: [PATCH 725/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 358cdc435092b..20b1a83192f9a 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 358cdc435092bc996dfcea48759fb2124c126f07 +Subproject commit 20b1a83192f9ab77ed04b34f2f05f3967af4f86f From b38db03be956b7b5f70f487633fe9192e73559d6 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Fri, 2 Feb 2024 08:25:44 +0000 Subject: [PATCH 726/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 579ba7b74c501..4c05da8755e00 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -15,8 +15,11 @@ Top Contributors * - V\. Sai Suraj - `Sai-Suraj-27 `_ - Merging Master Gold, Debugging Dynamo Silver -Rising Contributors -------------------- + * - samunder singh + - `samthakur587 `_ + - Merging Master Gold, Debugging Dynamo Silver +Core Contributors +----------------- .. list-table:: :widths: 50 50 50 :header-rows: 1 @@ -24,6 +27,6 @@ Rising Contributors * - Name - Github ID - Badges - * - samunder singh - - `samthakur587 `_ - - Merging Master Silver, Debugging Dynamo Silver + * - Muhammad ishaque + - `MuhammadNizamani `_ + - Merging Master Bronze From 30ad9eea471aa052dd73cfd3ea9e9d9d8356ada9 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 2 Feb 2024 08:27:46 +0000 Subject: [PATCH 727/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 4c05da8755e00..43e214b9d18ed 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,6 +27,6 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze From 271d45485f643f217e146471fc56e84ef1001658 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Fri, 2 Feb 2024 08:29:11 +0000 Subject: [PATCH 728/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 43e214b9d18ed..4c05da8755e00 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,6 +27,6 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze From 6f32c6ae14936a7418a2eebfc8ce6e6d251388e9 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 2 Feb 2024 08:30:57 +0000 Subject: [PATCH 729/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 4c05da8755e00..43e214b9d18ed 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,6 +27,6 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze From e786e88fd8b734af010a2f3de2590de21d1e5858 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 2 Feb 2024 15:41:14 +0530 Subject: [PATCH 730/978] feat: added the erfinv function to ivy's experimental API (#28159) --- .../array/experimental/elementwise.py | 31 +++++++ .../container/experimental/elementwise.py | 91 +++++++++++++++++++ .../backends/jax/experimental/elementwise.py | 9 ++ .../numpy/experimental/elementwise.py | 12 +++ .../paddle/experimental/elementwise.py | 10 ++ .../tensorflow/experimental/elementwise.py | 10 ++ .../torch/experimental/elementwise.py | 13 +++ .../ivy/experimental/elementwise.py | 36 ++++++++ .../test_core/test_elementwise.py | 38 +++++++- 9 files changed, 249 insertions(+), 1 deletion(-) diff --git a/ivy/data_classes/array/experimental/elementwise.py b/ivy/data_classes/array/experimental/elementwise.py index f48d1b303fc55..80eb526cb7093 100644 --- a/ivy/data_classes/array/experimental/elementwise.py +++ b/ivy/data_classes/array/experimental/elementwise.py @@ -1191,3 +1191,34 @@ def erfc( ivy.array([1.00000000e+00, 1.84270084e+00, 2.80259693e-45]) """ return ivy.erfc(self._data, out=out) + + def erfinv( + self: ivy.Array, + /, + *, + out: Optional[ivy.Array] = None, + ) -> ivy.Array: + """ivy.Array instance method variant of ivy.erfinv. This method simply + wraps the function, and so the docstring for ivy.erfinv also applies to + this method with minimal changes. + + Parameters + ---------- + self + Input array with real or complex valued argument. + out + Alternate output array in which to place the result. + The default is None. + + Returns + ------- + ret + Values of the inverse error function. + + Examples + -------- + >>> x = ivy.array([0, -1., 10.]) + >>> x.erfinv() + ivy.array([1.00000000e+00, 1.84270084e+00, 2.80259693e-45]) + """ + return ivy.erfinv(self._data, out=out) diff --git a/ivy/data_classes/container/experimental/elementwise.py b/ivy/data_classes/container/experimental/elementwise.py index 939c32874fc50..402e0fa1fac1e 100644 --- a/ivy/data_classes/container/experimental/elementwise.py +++ b/ivy/data_classes/container/experimental/elementwise.py @@ -3491,3 +3491,94 @@ def erfc( } """ return self.static_erfc(self, out=out) + + @staticmethod + def static_erfinv( + x: Union[ivy.Array, ivy.NativeArray, ivy.Container], + /, + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + out: Optional[ivy.Container] = None, + ) -> ivy.Container: + """ivy.Container static method variant of ivy.erfinv. This method + simply wraps the function, and so the docstring for ivy.erfinv also + applies to this method with minimal changes. + + Parameters + ---------- + x + The container whose array contains real or complex valued argument. + key_chains + The key-chains to apply or not apply the method to. Default is ``None``. + to_apply + If True, the method will be applied to key_chains, otherwise key_chains + will be skipped. Default is ``True``. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + out + optional output container, for writing the result to. + + Returns + ------- + ret + container with values of the inverse error function. + + Examples + -------- + >>> x = ivy.Container(a=ivy.array([1., 2.]), b=ivy.array([-3., -4.])) + >>> ivy.Container.static_erfinv(x) + { + a: ivy.array([0.15729921, 0.00467773]), + b: ivy.array([1.99997795, 2.]) + } + """ + return ContainerBase.cont_multi_map_in_function( + "erfinv", + x, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + out=out, + ) + + def erfinv( + self: ivy.Container, + /, + *, + out: Optional[ivy.Container] = None, + ) -> ivy.Container: + """ivy.Container instance method variant of ivy.erfinv. This method + simply wraps the function, and so the docstring for ivy.erfinv also + applies to this method with minimal changes. + + Parameters + ---------- + self + The container whose array contains real or complex valued argument. + out + optional output container, for writing the result to. + + Returns + ------- + ret + container with values of the inverse error function. + + Examples + -------- + With one :class:`ivy.Container` input: + >>> x = ivy.Container(a=ivy.array([1., 2., 3.]), b=ivy.array([-1., -2., -3.])) + >>> x.erfinv() + { + a: ivy.array([1.57299206e-01, 4.67773480e-03, 2.20904985e-05]), + b: ivy.array([1.84270084, 1.99532223, 1.99997795]) + } + """ + return self.static_erfinv(self, out=out) diff --git a/ivy/functional/backends/jax/experimental/elementwise.py b/ivy/functional/backends/jax/experimental/elementwise.py index 1880fd049e412..363bc6a658213 100644 --- a/ivy/functional/backends/jax/experimental/elementwise.py +++ b/ivy/functional/backends/jax/experimental/elementwise.py @@ -499,3 +499,12 @@ def erfc( out: Optional[JaxArray] = None, ) -> JaxArray: return js.special.erfc(x) + + +def erfinv( + x: JaxArray, + /, + *, + out: Optional[JaxArray] = None, +) -> JaxArray: + return js.special.erfinv(x) diff --git a/ivy/functional/backends/numpy/experimental/elementwise.py b/ivy/functional/backends/numpy/experimental/elementwise.py index 895a0daf0f271..ab35f7d972aa7 100644 --- a/ivy/functional/backends/numpy/experimental/elementwise.py +++ b/ivy/functional/backends/numpy/experimental/elementwise.py @@ -602,3 +602,15 @@ def is_pos_inf(op): return np.where(underflow, result_underflow, result_no_underflow).astype( input_dtype ) + + +# TODO: Remove this once native function is available. +# Compute an approximation of the error function complement (1 - erf(x)). +def erfinv( + x: np.ndarray, + /, + *, + out: Optional[np.ndarray] = None, +) -> np.ndarray: + with ivy.ArrayMode(False): + return np.sqrt(2) * erfc(x) diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 7fabf0b78ef52..e0c53010b1cf2 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -815,3 +815,13 @@ def is_pos_inf(op): result = paddle.squeeze(result, axis=-1) return result + + +@with_supported_dtypes( + {"2.6.0 and below": ("float32", "float64")}, + backend_version, +) +def erfinv( + x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None +) -> paddle.Tensor: + return paddle.erfinv(x) diff --git a/ivy/functional/backends/tensorflow/experimental/elementwise.py b/ivy/functional/backends/tensorflow/experimental/elementwise.py index 8f5b53c24a1dd..977e0d0584c87 100644 --- a/ivy/functional/backends/tensorflow/experimental/elementwise.py +++ b/ivy/functional/backends/tensorflow/experimental/elementwise.py @@ -566,3 +566,13 @@ def erfc( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.math.erfc(x) + + +@with_supported_dtypes({"2.15.0 and below": ("float",)}, backend_version) +def erfinv( + x: Union[tf.Tensor, tf.Variable], + /, + *, + out: Optional[Union[tf.Tensor, tf.Variable]] = None, +) -> Union[tf.Tensor, tf.Variable]: + return tf.math.erfinv(x) diff --git a/ivy/functional/backends/torch/experimental/elementwise.py b/ivy/functional/backends/torch/experimental/elementwise.py index 309139a7bbf62..0b7b23d89f67b 100644 --- a/ivy/functional/backends/torch/experimental/elementwise.py +++ b/ivy/functional/backends/torch/experimental/elementwise.py @@ -442,3 +442,16 @@ def erfc( out: Optional[torch.Tensor] = None, ) -> torch.Tensor: return torch.special.erfc(x) + + +@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +def erfinv( + x: torch.Tensor, + /, + *, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + return torch.special.erfinv(x, out=out) + + +erfinv.support_native_out = True diff --git a/ivy/functional/ivy/experimental/elementwise.py b/ivy/functional/ivy/experimental/elementwise.py index 83025fd5dd56f..c2680ceb4fe06 100644 --- a/ivy/functional/ivy/experimental/elementwise.py +++ b/ivy/functional/ivy/experimental/elementwise.py @@ -1637,3 +1637,39 @@ def erfc( ivy.array([0.00467773, 1.84270084, 1. ]) """ return ivy.current_backend(x).erfc(x, out=out) + + +@handle_exceptions +@handle_nestable +@handle_array_like_without_promotion +@handle_out_argument +@to_native_arrays_and_back +@handle_device +def erfinv( + x: Union[ivy.Array, ivy.NativeArray], + /, + *, + out: Optional[ivy.Array] = None, +): + """Compute the inverse error function. + + Parameters + ---------- + x + Input array of real or complex valued argument. + out + optional output array, for writing the result to. + It must have a shape that the inputs broadcast to. + + Returns + ------- + ret + Values of the inverse error function. + + Examples + -------- + >>> x = ivy.array([0, 0.5, -1.]) + >>> ivy.erfinv(x) + ivy.array([0.0000, 0.4769, -inf]) + """ + return ivy.current_backend(x).erfinv(x, out=out) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py index 12e3bd938b063..03ca8d09b42dc 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py @@ -1,5 +1,5 @@ # global -from hypothesis import strategies as st +from hypothesis import assume, strategies as st # local import ivy @@ -510,6 +510,42 @@ def test_erfc( ) +# erfinv +@handle_test( + fn_tree="functional.ivy.experimental.erfinv", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + min_value=-1, + max_value=1, + abs_smallest_val=1e-05, + ), +) +def test_erfinv( + *, + dtype_and_x, + backend_fw, + test_flags, + fn_name, + on_device, +): + input_dtype, x = dtype_and_x + if on_device == "cpu": + assume("float16" not in input_dtype and "bfloat16" not in input_dtype) + test_values = True + if backend_fw == "numpy": + # the numpy backend requires an approximation which doesn't pass the value tests + test_values = False + helpers.test_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_name=fn_name, + on_device=on_device, + test_values=test_values, + x=x[0], + ) + + # fix @handle_test( fn_tree="functional.ivy.experimental.fix", From 323b33dd02a92096de6efc0b5528ee54891975b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kacper=20Ko=C5=BCdo=C5=84?= <102428159+Kacper-W-Kozdon@users.noreply.github.com> Date: Sat, 3 Feb 2024 20:12:53 +0100 Subject: [PATCH 731/978] feat: added Ivy.unflatten (#28079) Co-authored-by: joaozenobio --- .../array/experimental/manipulation.py | 56 ++++++ .../container/experimental/manipulation.py | 182 +++++++++++++++++- .../backends/jax/experimental/manipulation.py | 2 +- .../numpy/experimental/manipulation.py | 2 +- .../paddle/experimental/manipulation.py | 16 +- .../tensorflow/experimental/manipulation.py | 2 +- .../torch/experimental/manipulation.py | 2 +- .../ivy/experimental/manipulation.py | 4 +- .../test_torch/test_miscellaneous_ops.py | 14 +- .../test_core/test_manipulation.py | 80 ++++++++ 10 files changed, 342 insertions(+), 18 deletions(-) diff --git a/ivy/data_classes/array/experimental/manipulation.py b/ivy/data_classes/array/experimental/manipulation.py index 013af82658b0a..6cdfeb97689f0 100644 --- a/ivy/data_classes/array/experimental/manipulation.py +++ b/ivy/data_classes/array/experimental/manipulation.py @@ -1134,6 +1134,62 @@ def take( self, indices, axis=axis, mode=mode, fill_value=fill_value, out=out ) + def unflatten( + self: ivy.Array, + /, + shape: Union[Tuple[int], ivy.Array, ivy.NativeArray], + dim: Optional[int] = 0, + *, + out: Optional[ivy.Array] = None, + ) -> ivy.Array: + """ivy.Array instance method variant of ivy.unflatten. This method + simply wraps the function, and so the docstring for ivy.unflatten also + applies to this method with minimal changes. + + Parameters + ---------- + self + input array + shape + array indices. Must have an integer data type. + dim + axis over which to unflatten. If `axis` is negative, + the function must determine the axis along which to select values + by counting from the last dimension. + By default, the flattened input array is used. + out + optional output array, for writing the result to. It must + have a shape that the inputs broadcast to. + + Returns + ------- + ret + an array having the same data type as `x`. + The output array must have the same rank + (i.e., number of dimensions) as `x` and + must have the same shape as `x`, + except for the axis specified by `dim` + which is replaced with a tuple specified in `shape`. + + + Examples + -------- + With 'ivy.Array' input: + + >>> x = ivy.array([[1.2, 2.3, 3.4, 4.5], + [5.6, 6.7, 7.8, 8.9]]) + >>> shape = (2, 2) + >>> y = x.unflatten(shape=shape, dim=dim, out=y) + >>> print(y) + ivy.array([[[1.2, 2.3], [3.4, 4.5]], [[5.6, 6.7], [7.8, 8.9]]]) + """ + return ivy.unflatten( + self._data, + shape=shape, + dim=dim, + out=out, + ) + def trim_zeros( self: ivy.Array, /, diff --git a/ivy/data_classes/container/experimental/manipulation.py b/ivy/data_classes/container/experimental/manipulation.py index 20e72671746e1..fb293ce7ff254 100644 --- a/ivy/data_classes/container/experimental/manipulation.py +++ b/ivy/data_classes/container/experimental/manipulation.py @@ -4065,6 +4065,180 @@ def trim_zeros( """ return self._static_trim_zeros(self, trim=trim) + @staticmethod + def _static_unflatten( + x: Union[int, ivy.Array, ivy.NativeArray, ivy.Container], + /, + shape: Union[Tuple[int], ivy.Array, ivy.NativeArray, ivy.Container], + dim: Optional[Union[int, ivy.Container]] = 0, + *, + out: Optional[Union[ivy.Array, ivy.Container]] = None, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + """ivy.Container static method variant of ivy.unflatten. This method + simply wraps the function, and so the docstring for ivy.unflatten also + applies to this method with minimal changes. + + Parameters + ---------- + x + input array + shape + array indices. Must have an integer data type. + dim + axis over which to select values. If `axis` is negative, + the function must determine the axis along which to select values + by counting from the last dimension. + By default, the flattened input array is used. + out + optional output array, for writing the result to. It must + have a shape that the inputs broadcast to. + key_chains + The key-chains to apply or not apply the method to. + Default is ``None``. + to_apply + If True, the method will be applied to key_chains, + otherwise key_chains will be skipped. Default is ``True``. + prune_unapplied + Whether to prune key_chains for which the function was + not applied. Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + + Returns + ------- + ret + an array having the same data type as `x`. + The output array must have the same rank + (i.e., number of dimensions) as `x` and + must have the same shape as `x`, + except for the axis specified by `axis` + whose size must equal the number of elements in `indices`. + + + Examples + -------- + With 'ivy.Container' input: + + >>> x = ivy.Container(a = ivy.array([[True, False, False, True], + [False, True, False, True]])), + ... b = ivy.array([[1.2, 2.3, 3.4, 4.5], + [5.6, 6.7, 7.8, 8.9]]), + ... c = ivy.array([[1, 2, 3, 4], + [5, 6, 7, 8]])) + >>> dim = 1 + >>> shape = (2, 2) + >>> y = ivy.Container._static_unflatten(x, shape=shape, dim=dim) + >>> print(y) + { + a: ivy.array([[[True, False], [False, True]], + [[False, True], [False, True]]]) + b: ivy.array([[[1.2, 2.3], [3.4, 4.5]], [[5.6, 6.7], [7.8, 8.9]]]) + c: ivy.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) + } + """ + return ContainerBase.cont_multi_map_in_function( + "unflatten", + x, + shape=shape, + dim=dim, + out=out, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + + def unflatten( + self: ivy.Container, + /, + shape: Union[Tuple[int], ivy.Array, ivy.NativeArray, ivy.Container], + dim: Optional[Union[int, ivy.Container]] = 0, + *, + out: Optional[Union[ivy.Array, ivy.Container]] = None, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + """ivy.Container instance method variant of ivy.unflatten. This method + simply wraps the function, and so the docstring for ivy.unflatten also + applies to this method with minimal changes. + + Parameters + ---------- + self + input array + shape + array indices. Must have an integer data type. + dim + axis over which to unflatten. If `axis` is negative, + the function must determine the axis along which to select values + by counting from the last dimension. + By default, the flattened input array is used. + out + optional output array, for writing the result to. It must + have a shape that the inputs broadcast to. + key_chains + The key-chains to apply or not apply the method to. + Default is ``None``. + to_apply + If True, the method will be applied to key_chains, + otherwise key_chains will be skipped. Default is ``True``. + prune_unapplied + Whether to prune key_chains for which the function was + not applied. Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + + Returns + ------- + ret + an array having the same data type as `x`. + The output array must have the same rank + (i.e., number of dimensions) as `x` and + must have the same shape as `x`, + except for the axis specified by `dim` + which is replaced with a tuple specified in `shape`. + + + Examples + -------- + With 'ivy.Container' input: + + >>> x = ivy.Container(a = ivy.array([[True, False, False, True], + [False, True, False, True]])), + ... b = ivy.array([[1.2, 2.3, 3.4, 4.5], + [5.6, 6.7, 7.8, 8.9]]), + ... c = ivy.array([[1, 2, 3, 4], + [5, 6, 7, 8]])) + >>> dim = 1 + >>> shape = (2, 2) + >>> y = x.unflatten(shape=shape, dim=dim) + >>> print(y) + { + a: ivy.array([[[True, False], [False, True]], + [[False, True], [False, True]]]) + b: ivy.array([[[1.2, 2.3], [3.4, 4.5]], [[5.6, 6.7], [7.8, 8.9]]]) + c: ivy.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) + } + """ + return self._static_unflatten( + self, + shape=shape, + dim=dim, + out=out, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + def concat_from_sequence( self: ivy.Container, @@ -4130,11 +4304,11 @@ def concat_from_sequence( >>> print(z) { 'a': ivy.array([[[0, 1], - [3, 2]], - [[2, 3], - [1, 0]]]), + [3, 2]], + [[2, 3], + [1, 0]]]), 'b': ivy.array([[[4, 5], - [1, 0]]]) + [1, 0]]]) } """ new_input_sequence = ( diff --git a/ivy/functional/backends/jax/experimental/manipulation.py b/ivy/functional/backends/jax/experimental/manipulation.py index 36759c9dd1dfd..59ee341ab7870 100644 --- a/ivy/functional/backends/jax/experimental/manipulation.py +++ b/ivy/functional/backends/jax/experimental/manipulation.py @@ -475,8 +475,8 @@ def trim_zeros(a: JaxArray, /, *, trim: Optional[str] = "bf") -> JaxArray: def unflatten( x: JaxArray, /, - dim: int = 0, shape: Tuple[int] = None, + dim: int = 0, *, out: Optional[JaxArray] = None, order: Optional[str] = None, diff --git a/ivy/functional/backends/numpy/experimental/manipulation.py b/ivy/functional/backends/numpy/experimental/manipulation.py index a4a7c9ed12756..17b57a75f0f33 100644 --- a/ivy/functional/backends/numpy/experimental/manipulation.py +++ b/ivy/functional/backends/numpy/experimental/manipulation.py @@ -607,8 +607,8 @@ def put_along_axis( def unflatten( x: np.ndarray, /, - dim: int = 0, shape: Tuple[int] = None, + dim: Optional[int] = 0, *, out: Optional[np.ndarray] = None, order: Optional[str] = None, diff --git a/ivy/functional/backends/paddle/experimental/manipulation.py b/ivy/functional/backends/paddle/experimental/manipulation.py index 788a73d263c76..c6a482ee60b2d 100644 --- a/ivy/functional/backends/paddle/experimental/manipulation.py +++ b/ivy/functional/backends/paddle/experimental/manipulation.py @@ -908,12 +908,26 @@ def put_along_axis( ] +@with_supported_dtypes( + { + "2.6.0 and below": ( + "int32", + "int64", + "float64", + "complex128", + "float32", + "complex64", + "bool", + ) + }, + backend_version, +) @handle_out_argument def unflatten( x: paddle.Tensor, /, - dim: int = 0, shape: Tuple[int] = None, + dim: int = 0, *, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: diff --git a/ivy/functional/backends/tensorflow/experimental/manipulation.py b/ivy/functional/backends/tensorflow/experimental/manipulation.py index e03aebe12f749..e188f00a8aaae 100644 --- a/ivy/functional/backends/tensorflow/experimental/manipulation.py +++ b/ivy/functional/backends/tensorflow/experimental/manipulation.py @@ -571,8 +571,8 @@ def trim_zeros(a: tf.Tensor, /, *, trim: Optional[str] = "bf") -> tf.Tensor: def unflatten( x: tf.Tensor, /, - dim: int = 0, shape: Tuple[int] = None, + dim: Optional[int] = 0, *, out: Optional[tf.Tensor] = None, name: Optional[str] = None, diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index 485884c6511ed..97dd7183fa442 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -649,8 +649,8 @@ def trim_zeros(a: torch.Tensor, /, *, trim: Optional[str] = "bf") -> torch.Tenso def unflatten( x: torch.Tensor, /, - dim: int = 0, shape: Tuple[int] = None, + dim: Optional[int] = 0, *, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index a4bf5fd435a47..d46b2bed23bc7 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -2884,9 +2884,9 @@ def trim_zeros( def unflatten( x: Union[ivy.Array, ivy.NativeArray], /, - *, dim: int, shape: Tuple[int], + *, out: Optional[ivy.Array] = None, ) -> ivy.Array: """Expand a dimension of the input tensor over multiple dimensions. @@ -2930,4 +2930,4 @@ def unflatten( >>> ivy.unflatten(torch.randn(5, 12, 3), dim=-2, shape=(2, 2, 3, 1, 1)).shape torch.Size([5, 2, 2, 3, 1, 1, 3]) """ - return current_backend(x).unflatten(x, dim=dim, shape=shape, out=out) + return ivy.current_backend(x).unflatten(x, dim=dim, shape=shape, out=out) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 5a77b6cfbbe6e..5b15e0ec81308 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -1788,8 +1788,8 @@ def test_torch_triu_indices( ), get_axis=helpers.get_axis( shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), - max_size=1, - min_size=1, + max_size=0, + min_size=0, force_int=True, ), ) @@ -1804,10 +1804,9 @@ def test_torch_unflatten( shape, get_axis, ): - if type(get_axis) is not tuple: - axis = get_axis - else: - axis = 0 if get_axis is None else get_axis[0] + axis = get_axis + if type(axis) is tuple: + axis = 0 if not get_axis else get_axis[0] dtype, x = dtype_and_values def factorization(n): @@ -1835,7 +1834,8 @@ def get_factor(n): next = get_factor(n) factors.append(next) n //= next - + if len(factors) > 1: + factors.remove(1) return factors shape_ = ( diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py index 87b09dccecfd6..d88849c914204 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py @@ -2,6 +2,7 @@ from hypothesis import strategies as st, assume import hypothesis.extra.numpy as nph import numpy as np +import math # local import ivy @@ -1470,6 +1471,85 @@ def test_trim_zeros( ) +# unflatten +@handle_test( + fn_tree="functional.ivy.experimental.unflatten", + shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), + dtype_and_values=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_num_dims=1, + shape_key="shape", + ), + get_axis=helpers.get_axis( + shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), + max_size=0, + min_size=0, + force_int=True, + ), +) +def test_unflatten( + *, + dtype_and_values, + on_device, + fn_name, + test_flags, + backend_fw, + shape, + get_axis, +): + axis = get_axis + if type(axis) is tuple: + axis = 0 if not get_axis else get_axis[0] + dtype, x = dtype_and_values + + def factorization(n): + factors = [1] + + def get_factor(n): + x_fixed = 2 + cycle_size = 2 + x = 2 + factor = 1 if n % 2 else 2 + + while factor == 1: + for count in range(cycle_size): + if factor > 1: + break + x = (x * x + 1) % n + factor = math.gcd(x - x_fixed, n) + + cycle_size *= 2 + x_fixed = x + + return factor + + while n > 1: + next = get_factor(n) + factors.append(next) + n //= next + + if len(factors) > 1: + factors.remove(1) + return factors + + shape_ = ( + tuple(factorization(shape[axis])) + if tuple(factorization(shape[axis])) + else shape + ) + helpers.test_function( + input_dtypes=dtype, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_name=fn_name, + on_device=on_device, + test_values=False, + x=x[0], + shape=shape_, + dim=axis, + ) + + @handle_test( fn_tree="functional.ivy.experimental.unfold", dtype_values_axis=helpers.dtype_values_axis( From ba08c5668926cef35d472524fcce9280c56b5833 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Sat, 3 Feb 2024 20:35:06 +0000 Subject: [PATCH 732/978] feat(frontends): Added erfinv and erfinv_ to torch frontend along with tests --- .../frontends/torch/miscellaneous_ops.py | 5 ++ ivy/functional/frontends/torch/tensor.py | 12 +++ .../test_torch/test_miscellaneous_ops.py | 31 ++++++++ .../test_frontends/test_torch/test_tensor.py | 77 +++++++++++++++++++ 4 files changed, 125 insertions(+) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index ee0143f3b70df..b9d15f8a976df 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -239,6 +239,11 @@ def einsum(equation, *operands): return ivy.einsum(equation, *operands) +@to_ivy_arrays_and_back +def erfinv(input, *, out=None): + return ivy.erfinv(input, out=out) + + @to_ivy_arrays_and_back def finfo(dtype): return ivy.finfo(dtype) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index ec96b640d5092..22195e6f3008d 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2279,6 +2279,18 @@ def _set(index): return self + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + def erfinv(self, *, out=None): + return torch_frontend.erfinv(self, out=out) + + @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + def erfinv_(self, *, out=None): + ret = self.erfinv(out=out) + self._ivy_array = ivy.inplace_update( + self._ivy_array, ivy.astype(ret.ivy_array, self._ivy_array.dtype) + ) + return self + # Method aliases absolute, absolute_ = abs, abs_ clip, clip_ = clamp, clamp_ diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 5b15e0ec81308..46eb2ada3d210 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -1017,6 +1017,37 @@ def test_torch_einsum( ) +# erfinv +@handle_frontend_test( + fn_tree="torch.erfinv", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + min_value=-1, + max_value=1, + abs_smallest_val=1e-05, + ), +) +def test_torch_erfinv( + *, + dtype_and_x, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + input=x[0], + ) + + @handle_frontend_test( fn_tree="torch.flatten", dtype_input_axes=helpers.dtype_values_axis( diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index a0e89163f2f76..b5490c5ac5f5e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -6374,6 +6374,83 @@ def test_torch_erf_( ) +# erfinv_ tests +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="erfinv_", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + min_value=-1, + max_value=1, + abs_smallest_val=1e-05, + ), +) +def test_torch_erfinv( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + +# erfinv_ tests +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="erfinv_", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + min_value=-1, + max_value=1, + abs_smallest_val=1e-05, + ), + test_inplace=st.just(True), +) +def test_torch_erfinv_( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # exp @handle_frontend_method( class_tree=CLASS_TREE, From d382882aafb0e19cccc8145cfcaa6cc4f53a77c4 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Sun, 4 Feb 2024 12:49:28 -0800 Subject: [PATCH 733/978] fix: Fix Ivy Failing Test: torch - elementwise.deg2rad (#28171) fixed deg2rad by adding rtol_ and atol_ --- .../test_ivy/test_functional/test_core/test_elementwise.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index dd4d079fa9f9d..f33207b66ad68 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -652,6 +652,8 @@ def test_deg2rad(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): backend_to_test=backend_fw, fn_name=fn_name, on_device=on_device, + atol_=1e-2, + rtol_=1e-2, x=x[0], ) From 345322a5d8c00d61460a1567b71e06ce5ed9be14 Mon Sep 17 00:00:00 2001 From: Suyash Gupta Date: Mon, 5 Feb 2024 12:39:54 +0530 Subject: [PATCH 734/978] fix: Fix Ivy Failing Test: numpy - manipulation.swapaxes (#28042) --- ivy/functional/backends/numpy/manipulation.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/numpy/manipulation.py b/ivy/functional/backends/numpy/manipulation.py index 23303b6fbba8e..19023b3a23ab9 100644 --- a/ivy/functional/backends/numpy/manipulation.py +++ b/ivy/functional/backends/numpy/manipulation.py @@ -1,12 +1,14 @@ # global import math from numbers import Number -from typing import Union, Tuple, Optional, List, Sequence +from typing import List, Optional, Sequence, Tuple, Union + import numpy as np # local import ivy from ivy.func_wrapper import with_unsupported_dtypes + from . import backend_version @@ -233,6 +235,8 @@ def swapaxes( copy: Optional[bool] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: + if copy: + x = x.copy() return np.swapaxes(x, axis0, axis1) From 8ddbb7933802fff08707226b3f6b8bd860944ee8 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 5 Feb 2024 13:35:13 +0530 Subject: [PATCH 735/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index b8794d03c5abb..87463cc45c8ac 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.6.2" +__version__ = "0.0.7.0" From 8693a94f1bd234cf6ab120a54785f78ee8f5db0e Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 5 Feb 2024 14:25:03 +0530 Subject: [PATCH 736/978] Update requirement_mappings_gpu.json --- docker/requirement_mappings_gpu.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docker/requirement_mappings_gpu.json b/docker/requirement_mappings_gpu.json index a851f62b1ce3f..ade51df83cc09 100644 --- a/docker/requirement_mappings_gpu.json +++ b/docker/requirement_mappings_gpu.json @@ -2,6 +2,6 @@ "jax": ["dm-haiku", "flax"], "numpy": ["numpy"], "mxnet": ["mxnet"], - "torch": ["torch-scatter", "torchvision"], + "torch": ["torchvision", "torch-scatter"], "tensorflow": ["tensorflow-probability"] } From 6fb618f8018761617475c803d62b50f851ba57d1 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 5 Feb 2024 14:40:05 +0530 Subject: [PATCH 737/978] fix: hardcoded the index url for installing torchvision on the gpu dockerfile --- docker/gpu_framework_directory.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docker/gpu_framework_directory.py b/docker/gpu_framework_directory.py index ba365c1efb467..3dee4b7bf7750 100644 --- a/docker/gpu_framework_directory.py +++ b/docker/gpu_framework_directory.py @@ -43,6 +43,13 @@ def install_pkg(path, pkg, base="fw/"): " --no-cache-dir", shell=True, ) + subprocess.run( + f"yes |pip3 install --upgrade torchvision --index-url" + f" https://download.pytorch.org/whl/cu121 --target" + f" {path} --default-timeout=100 --extra-index-url" + " --no-cache-dir", + shell=True, + ) elif pkg.split("==")[0] if "==" in pkg else pkg == "jax": subprocess.run( f"yes |pip install --upgrade --target {path} 'jax[cuda12_pip]' -f" From c856413e80b41863713d2a7a81b9e5aa781b79b1 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Mon, 5 Feb 2024 05:49:14 -0800 Subject: [PATCH 738/978] fix: Fix Ivy Failing Test: paddle - elementwise.divide (#28074) fixed paddle TODO to change x1/x2 at paddle backend by paddle.divide(x1,x2) --- ivy/functional/backends/paddle/elementwise.py | 17 ++++++++--------- .../test_core/test_elementwise.py | 3 ++- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 21183c2915cfd..abaa47581ce6e 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -399,15 +399,14 @@ def divide( *, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: - if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): - if paddle.is_complex(x1) or paddle.is_complex(x2): - angle_value = paddle.angle(x1) - paddle.angle(x2) - abs_value = paddle.abs(x1) / paddle.abs(x2) - return paddle.complex( - abs_value * paddle.cos(angle_value), abs_value * paddle.sin(angle_value) - ) - x1, x2, ret_dtype = _elementwise_helper(x1, x2) - return (x1 / x2).astype(ret_dtype) + if paddle.is_complex(x1) or paddle.is_complex(x2): + angle_value = paddle.angle(x1) - paddle.angle(x2) + abs_value = paddle.abs(x1) / paddle.abs(x2) + return paddle.complex( + abs_value * paddle.cos(angle_value), abs_value * paddle.sin(angle_value) + ) + x1, x2, _ = _elementwise_helper(x1, x2) + return x1 / x2 @with_supported_dtypes( diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index f33207b66ad68..b7d461e0607f5 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -661,8 +661,9 @@ def test_deg2rad(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): # divide @handle_test( fn_tree="functional.ivy.divide", + test_gradients=st.just(False), dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("numeric", full=False), num_arrays=2, large_abs_safety_factor=2, small_abs_safety_factor=2, From decce5635a519117db3f9266e07cc7bfdf4b6bb7 Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Mon, 5 Feb 2024 16:19:44 +0000 Subject: [PATCH 739/978] (feat)(torch frontends): added the frontend functions for `torch.Tensor.bernoulli_` and `torch.Tensor.numel` --- ivy/functional/frontends/torch/random_sampling.py | 4 ++-- ivy/functional/frontends/torch/tensor.py | 15 +++++++++++++-- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/ivy/functional/frontends/torch/random_sampling.py b/ivy/functional/frontends/torch/random_sampling.py index 77f1c96f49230..88dacdb40b0ee 100644 --- a/ivy/functional/frontends/torch/random_sampling.py +++ b/ivy/functional/frontends/torch/random_sampling.py @@ -13,9 +13,9 @@ "torch", ) @to_ivy_arrays_and_back -def bernoulli(input, *, generator=None, out=None): +def bernoulli(input, p, *, generator=None, out=None): seed = generator.initial_seed() if generator is not None else None - return ivy.bernoulli(input, seed=seed, out=out) + return ivy.bernoulli(p, logits=input, seed=seed, out=out) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 22195e6f3008d..fbaa3dc37d9c4 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1201,8 +1201,19 @@ def dot(self, tensor): return torch_frontend.dot(self, tensor) @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") - def bernoulli(self, *, generator=None, out=None): - return torch_frontend.bernoulli(self._ivy_array, generator=generator, out=out) + def bernoulli(self, p, *, generator=None, out=None): + return torch_frontend.bernoulli( + self._ivy_array, p, generator=generator, out=out + ) + + @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") + def bernoulli_(self, p, *, generator=None, out=None): + self.ivy_array = self.bernoulli(p, generator=generator, out=out).ivy_array + return self + + def numel(self): + shape = self.shape + return int(ivy.astype(ivy.prod(shape), ivy.int64)) # Special Methods # # -------------------# From 8f9217ea719faacb3b069feeaaa16bb4d6e6cccd Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 5 Feb 2024 23:47:34 +0530 Subject: [PATCH 740/978] fix: Fixed `paddle_backend.divide` by adding an if condition to separate dtypes (#28191) --- ivy/functional/backends/paddle/elementwise.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index abaa47581ce6e..408e841b0475c 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -399,12 +399,13 @@ def divide( *, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: - if paddle.is_complex(x1) or paddle.is_complex(x2): - angle_value = paddle.angle(x1) - paddle.angle(x2) - abs_value = paddle.abs(x1) / paddle.abs(x2) - return paddle.complex( - abs_value * paddle.cos(angle_value), abs_value * paddle.sin(angle_value) - ) + if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): + if paddle.is_complex(x1) or paddle.is_complex(x2): + angle_value = paddle.angle(x1) - paddle.angle(x2) + abs_value = paddle.abs(x1) / paddle.abs(x2) + return paddle.complex( + abs_value * paddle.cos(angle_value), abs_value * paddle.sin(angle_value) + ) x1, x2, _ = _elementwise_helper(x1, x2) return x1 / x2 From e8e66951530ad93971fcbca2feac4378decf3b0d Mon Sep 17 00:00:00 2001 From: NripeshN Date: Tue, 6 Feb 2024 08:44:30 +0000 Subject: [PATCH 741/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 43e214b9d18ed..4c05da8755e00 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,6 +27,6 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze From f150b9eec9233847283196506467e0b302fab210 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 6 Feb 2024 08:45:44 +0000 Subject: [PATCH 742/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 4c05da8755e00..43e214b9d18ed 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,6 +27,6 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze From 2c465d6de04d04bdee0d7b07ede0bbbeb66b69b0 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Tue, 6 Feb 2024 04:24:49 -0800 Subject: [PATCH 743/978] FIX! Fix Ivy Failing Test: paddle - elementwise.allclose (#28166) fixed allclose not supported the bfloat16 for all backend --- .../test_experimental/test_core/test_elementwise.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py index 03ca8d09b42dc..3e4b7cf584661 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_elementwise.py @@ -217,6 +217,7 @@ def test_allclose( dtype_and_x, rtol, atol, equal_nan, test_flags, backend_fw, fn_name, on_device ): input_dtype, x = dtype_and_x + assume("bfloat16" not in input_dtype) helpers.test_function( input_dtypes=input_dtype, test_flags=test_flags, From 1f5876bc8bec097a751952ecd0f27f0dc8fc5cf3 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 7 Feb 2024 12:50:44 +0530 Subject: [PATCH 744/978] fix: Fixed failing docstring tests (#28172) --- .../array/experimental/activations.py | 2 +- .../array/experimental/linear_algebra.py | 4 +- ivy/data_classes/array/experimental/losses.py | 6 +- .../array/experimental/manipulation.py | 6 +- ivy/data_classes/array/losses.py | 6 +- .../container/experimental/activations.py | 13 +-- .../container/experimental/losses.py | 12 +- .../container/experimental/manipulation.py | 10 +- ivy/data_classes/container/losses.py | 12 +- .../tensorflow/experimental/layers.py | 4 +- ivy/functional/ivy/creation.py | 2 +- ivy/functional/ivy/data_type.py | 4 +- ivy/functional/ivy/device.py | 8 +- ivy/functional/ivy/elementwise.py | 39 ++++--- .../ivy/experimental/activations.py | 11 +- ivy/functional/ivy/experimental/layers.py | 25 ++-- .../ivy/experimental/linear_algebra.py | 4 +- ivy/functional/ivy/experimental/losses.py | 16 +-- .../ivy/experimental/manipulation.py | 16 +-- ivy/functional/ivy/general.py | 29 +++-- ivy/functional/ivy/layers.py | 6 +- ivy/functional/ivy/linear_algebra.py | 64 ++++------ ivy/functional/ivy/losses.py | 43 ++++--- ivy/functional/ivy/manipulation.py | 14 ++- ivy/functional/ivy/nest.py | 16 +-- ivy/functional/ivy/searching.py | 9 +- ivy/functional/ivy/statistical.py | 24 +--- ivy_tests/test_docstrings.py | 110 +++++------------- 28 files changed, 221 insertions(+), 294 deletions(-) diff --git a/ivy/data_classes/array/experimental/activations.py b/ivy/data_classes/array/experimental/activations.py index 6e44b4240c190..79538a0a4e5b6 100644 --- a/ivy/data_classes/array/experimental/activations.py +++ b/ivy/data_classes/array/experimental/activations.py @@ -325,7 +325,7 @@ def hardtanh( >>> x = ivy.array([-1., .2, 1.]) >>> y = x.hardtanh() >>> print(y) - ivy.array([-1., 1., 1.]) + ivy.array([-1. , 0.2, 1. ]) """ return ivy.hardtanh(self._data, min_val=min_val, max_val=max_val, out=out) diff --git a/ivy/data_classes/array/experimental/linear_algebra.py b/ivy/data_classes/array/experimental/linear_algebra.py index 09ff0484e31ea..865c4a1296942 100644 --- a/ivy/data_classes/array/experimental/linear_algebra.py +++ b/ivy/data_classes/array/experimental/linear_algebra.py @@ -832,7 +832,7 @@ def general_inner_product( >>> a = ivy.array([1, 2, 3]) >>> b = ivy.array([4, 5, 6]) - >>> result = a.general_inner_product(b, n_modes=1) + >>> result = a.general_inner_product(b, 1) >>> print(result) ivy.array(32) @@ -844,7 +844,7 @@ def general_inner_product( >>> a = ivy.array([[1, 1], [1, 1]]) >>> b = ivy.array([[1, 2, 3, 4],[1, 1, 1, 1]]) - >>> result = a.general_inner_product(b, n_modes=1) + >>> result = a.general_inner_product(b, 1) >>> print(result) ivy.array([[2, 3, 4, 5], [2, 3, 4, 5]]) diff --git a/ivy/data_classes/array/experimental/losses.py b/ivy/data_classes/array/experimental/losses.py index e06132caf1638..8912d815ff5a0 100644 --- a/ivy/data_classes/array/experimental/losses.py +++ b/ivy/data_classes/array/experimental/losses.py @@ -98,7 +98,7 @@ def log_poisson_loss( ivy.array([1.28402555, 1.28402555, 1.03402555, 1.28402555]) >>> z = ivy.array([0.1, 0.1, 0.7, 0.1]) - >>> loss = x.x.log_poisson_loss(z, reduction='mean') + >>> loss = x.log_poisson_loss(z, reduction='mean') >>> print(loss) ivy.array(1.1573164) """ @@ -353,9 +353,9 @@ def poisson_nll_loss( -------- >>> input_tensor = ivy.array([1, 2, 3, 4], dtype=ivy.float64) >>> target_tensor = ivy.array([2, 2, 2, 2], dtype=ivy.float64) - >>> loss = poisson_nll_loss(input_tensor, target_tensor, log_input=True) + >>> loss = input_tensor.poisson_nll_loss(target_tensor, log_input=True) >>> print(loss) - ivy.array(16.1978) + ivy.array(16.1977562) """ return ivy.poisson_nll_loss( self._data, diff --git a/ivy/data_classes/array/experimental/manipulation.py b/ivy/data_classes/array/experimental/manipulation.py index 6cdfeb97689f0..af3292542a678 100644 --- a/ivy/data_classes/array/experimental/manipulation.py +++ b/ivy/data_classes/array/experimental/manipulation.py @@ -1177,9 +1177,11 @@ def unflatten( With 'ivy.Array' input: >>> x = ivy.array([[1.2, 2.3, 3.4, 4.5], - [5.6, 6.7, 7.8, 8.9]]) + ... [5.6, 6.7, 7.8, 8.9]]) + >>> dim = 1 >>> shape = (2, 2) - >>> y = x.unflatten(shape=shape, dim=dim, out=y) + >>> y = ivy.zeros([2, 2, 2]) + >>> x.unflatten(shape=shape, dim=dim, out=y) >>> print(y) ivy.array([[[1.2, 2.3], [3.4, 4.5]], [[5.6, 6.7], [7.8, 8.9]]]) """ diff --git a/ivy/data_classes/array/losses.py b/ivy/data_classes/array/losses.py index b11f9d9399e3b..216ef9e4e2322 100644 --- a/ivy/data_classes/array/losses.py +++ b/ivy/data_classes/array/losses.py @@ -50,7 +50,7 @@ def cross_entropy( >>> y = ivy.array([0.25, 0.25, 0.25, 0.25]) >>> z = x.cross_entropy(y) >>> print(z) - ivy.array(1.3862944) + ivy.array(0.34657359) """ return ivy.cross_entropy( self._data, pred, axis=axis, epsilon=epsilon, reduction=reduction, out=out @@ -110,7 +110,7 @@ def binary_cross_entropy( >>> y = ivy.array([0.7, 0.8, 0.2]) >>> z = x.binary_cross_entropy(y) >>> print(z) - ivy.array([0.357, 0.223, 0.223]) + ivy.array(0.26765382) """ return ivy.binary_cross_entropy( self._data, @@ -170,7 +170,7 @@ def sparse_cross_entropy( >>> y = ivy.array([0.7, 0.8, 0.2]) >>> z = x.sparse_cross_entropy(y) >>> print(z) - ivy.array([0.223, 0.223, 0.357]) + ivy.array([0.07438118, 0.07438118, 0.11889165]) """ return ivy.sparse_cross_entropy( self._data, pred, axis=axis, epsilon=epsilon, reduction=reduction, out=out diff --git a/ivy/data_classes/container/experimental/activations.py b/ivy/data_classes/container/experimental/activations.py index e42c7d270d00c..98347733a7a72 100644 --- a/ivy/data_classes/container/experimental/activations.py +++ b/ivy/data_classes/container/experimental/activations.py @@ -968,10 +968,10 @@ def _static_hardtanh( Examples -------- >>> x = x = ivy.Container(a=ivy.array([0.39, -2.0]), b=ivy.array([2., -0.2])) - >>> y = ivy.Container.static_hardtanh(x) + >>> y = ivy.Container._static_hardtanh(x) >>> print(y) { - a: ivy.array([0.39, -1.]), + a: ivy.array([0.3899, -1.]), b: ivy.array([1., -0.2]) } """ @@ -1033,11 +1033,11 @@ def hardtanh( Examples -------- - >>> x = x = ivy.Container(a=ivy.array([0.39, -2.0]), b=ivy.array([2., -0.2])) - >>> y = ivy.Container.static_hardtanh(x) + >>> x = ivy.Container(a=ivy.array([0.39, -2.0]), b=ivy.array([2., -0.2])) + >>> y = ivy.Container.hardtanh(x) >>> print(y) { - a: ivy.array([0.39, -1.]), + a: ivy.array([0.389999, -1.]), b: ivy.array([1., -0.2]) } """ @@ -1820,8 +1820,7 @@ def hardshrink( Examples -------- - >>> import ivy.numpy as np - >>> x = ivy.Container(a=np.array([1., -2.]), b=np.array([0.4, -0.2])) + >>> x = ivy.Container(a=ivy.array([1., -2.]), b=ivy.array([0.4, -0.2])) >>> y = ivy.Container.hardshrink(x) >>> print(y) { diff --git a/ivy/data_classes/container/experimental/losses.py b/ivy/data_classes/container/experimental/losses.py index 26fc89086aadc..6247eb3a3dcf7 100644 --- a/ivy/data_classes/container/experimental/losses.py +++ b/ivy/data_classes/container/experimental/losses.py @@ -143,7 +143,7 @@ def l1_loss( >>> z = x.l1_loss(y) >>> print(z) { - a: ivy.array(1.), + a: ivy.array(0.), b: ivy.array(0.) } """ @@ -314,8 +314,8 @@ def log_poisson_loss( >>> z = x.log_poisson_loss(y) >>> print(z) { - a: ivy.array(1.), - b: ivy.array(0.) + a: ivy.array(3.3890561), + b: ivy.array(123.413159) } """ return self._static_log_poisson_loss( @@ -478,12 +478,12 @@ def smooth_l1_loss( -------- >>> x = ivy.Container(a=ivy.array([1, 0, 2]), b=ivy.array([3, 2, 1])) >>> y = ivy.Container(a=ivy.array([0.6, 0.2, 0.3]), - b=ivy.array([0.8, 0.2, 0.2])) + ... b=ivy.array([0.8, 0.2, 0.2])) >>> z = x.smooth_l1_loss(y) >>> print(z) { - a: ivy.array(0.9), - b: ivy.array(0.25) + a: ivy.array(0.43333333), + b: ivy.array(1.10666666) } """ return self._static_smooth_l1_loss( diff --git a/ivy/data_classes/container/experimental/manipulation.py b/ivy/data_classes/container/experimental/manipulation.py index fb293ce7ff254..0c54a775d5a43 100644 --- a/ivy/data_classes/container/experimental/manipulation.py +++ b/ivy/data_classes/container/experimental/manipulation.py @@ -4212,19 +4212,19 @@ def unflatten( With 'ivy.Container' input: >>> x = ivy.Container(a = ivy.array([[True, False, False, True], - [False, True, False, True]])), + ... [False, True, False, True]]), ... b = ivy.array([[1.2, 2.3, 3.4, 4.5], - [5.6, 6.7, 7.8, 8.9]]), + ... [5.6, 6.7, 7.8, 8.9]]), ... c = ivy.array([[1, 2, 3, 4], - [5, 6, 7, 8]])) + ... [5, 6, 7, 8]])) >>> dim = 1 >>> shape = (2, 2) >>> y = x.unflatten(shape=shape, dim=dim) >>> print(y) { a: ivy.array([[[True, False], [False, True]], - [[False, True], [False, True]]]) - b: ivy.array([[[1.2, 2.3], [3.4, 4.5]], [[5.6, 6.7], [7.8, 8.9]]]) + [[False, True], [False, True]]]), + b: ivy.array([[[1.2, 2.3], [3.4, 4.5]], [[5.6, 6.7], [7.8, 8.9]]]), c: ivy.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) } """ diff --git a/ivy/data_classes/container/losses.py b/ivy/data_classes/container/losses.py index 60dff4e8e4d2a..52c31b3b7f175 100644 --- a/ivy/data_classes/container/losses.py +++ b/ivy/data_classes/container/losses.py @@ -157,8 +157,8 @@ def cross_entropy( >>> z = x.cross_entropy(y) >>> print(z) { - a:ivy.array(0.5108256), - b:ivy.array(1.609438) + a: ivy.array(0.17027519), + b: ivy.array(0.53647931) } """ return self._static_cross_entropy( @@ -348,8 +348,8 @@ def binary_cross_entropy( >>> z = x.binary_cross_entropy(y) >>> print(z) { - a: ivy.array([0.511, 0.223, 0.357]), - b: ivy.array([1.61, 0.223, 1.61]) + a: ivy.array(0.36354783), + b: ivy.array(1.14733934) } """ return self._static_binary_cross_entropy( @@ -517,8 +517,8 @@ def sparse_cross_entropy( >>> z = x.sparse_cross_entropy(y) >>> print(z) { - a: ivy.array([1.61, 0.511, 0.511]), - b: ivy.array([0.223, 0.223, 1.61]) + a: ivy.array([0.53647929, 0.1702752, 0.1702752]), + b: ivy.array([0.07438118, 0.07438118, 0.53647929]) } """ return self._static_sparse_cross_entropy( diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index fd9a1cbace641..f13eb3e9290c9 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -1403,8 +1403,8 @@ def rfft_operations(x, rank, norm_factor): }, ) norm_factor = tf.cast(norm_factor, tf.complex128) - x = x / norm_factor x = tf.cast(x, tf.complex128) + x = x / norm_factor return x @@ -1542,7 +1542,7 @@ def rfftn( s: Optional[Union[int, Tuple[int]]] = None, axes: Optional[Union[int, Tuple[int]]] = None, *, - norm: Optional[str] = [("forward", "ortho", "backward")], + norm: str = "backward", out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: result = _rfftn_helper(x, s, axes, norm) diff --git a/ivy/functional/ivy/creation.py b/ivy/functional/ivy/creation.py index c032bc3b69134..b84c4c5277e96 100644 --- a/ivy/functional/ivy/creation.py +++ b/ivy/functional/ivy/creation.py @@ -2021,7 +2021,7 @@ def one_hot( } >>> x = ivy.Container(a=ivy.array([2]), \ - b=ivy.array([]), c=ivy.native_array([4])) + b=ivy.array([], dtype=ivy.int32), c=ivy.native_array([4])) >>> y = 7 >>> z = x.one_hot(y) >>> print(z) diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index 5739c59c551e8..9baf15ddf4cda 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -680,7 +680,7 @@ def finfo( >>> x = ivy.array([1.3,2.1,3.4], dtype=ivy.float64) >>> print(ivy.finfo(x)) - finfo(resolution=1e-15, min=-1.7976931348623157e+308, / + finfo(resolution=1e-15, min=-1.7976931348623157e+308, \ max=1.7976931348623157e+308, dtype=float64) >>> x = ivy.array([0.7,8.4,3.14], dtype=ivy.float16) @@ -694,7 +694,7 @@ def finfo( >>> print(ivy.finfo(c)) { x: finfo(resolution=0.001, min=-6.55040e+04, max=6.55040e+04, dtype=float16), - y: finfo(resolution=1e-15, min=-1.7976931348623157e+308, / + y: finfo(resolution=1e-15, min=-1.7976931348623157e+308, \ max=1.7976931348623157e+308, dtype=float64) } """ diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index 9187040ad1ffc..fbfbaa35ecb67 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -743,7 +743,7 @@ def tpu_is_available() -> bool: -------- >>> ivy.set_backend("torch") >>> print(ivy.tpu_is_available()) - True + False """ return ivy.current_backend().tpu_is_available() @@ -1221,7 +1221,13 @@ def function_supported_devices( Examples -------- >>> import ivy + >>> ivy.set_backend('numpy') >>> print(ivy.function_supported_devices(ivy.ones)) + ('cpu',) + + >>> ivy.set_backend('torch') + >>> x = ivy.function_supported_devices(ivy.ones) + >>> x = sorted(x) ('cpu', 'gpu') """ ivy.utils.assertions.check_true( diff --git a/ivy/functional/ivy/elementwise.py b/ivy/functional/ivy/elementwise.py index 7997380dec22b..793da8e10e05d 100644 --- a/ivy/functional/ivy/elementwise.py +++ b/ivy/functional/ivy/elementwise.py @@ -333,7 +333,7 @@ def acosh( With :class:`ivy.Container` input: - >>> x = ivy.Container(a=ivy.array([1, 2, 10]), b=ivy.array([1., 10, 6])) + >>> x = ivy.Container(a=ivy.array([1., 2., 10.]), b=ivy.array([1., 10., 6.])) >>> y = ivy.acosh(x) >>> print(y) { @@ -1200,7 +1200,8 @@ def bitwise_invert( With :class:`ivy.Container` input: - >>> x = ivy.Container(a=[False, True, False], b=[True, True, False]) + >>> x = ivy.Container(a=ivy.array([False, True, False]), + ... b=ivy.array([True, True, False])) >>> y = ivy.bitwise_invert(x) >>> print(y) { @@ -1220,7 +1221,7 @@ def bitwise_invert( >>> x = False >>> y = ivy.bitwise_invert(x) >>> print(y) - ivy.array(True) + True """ return ivy.current_backend(x).bitwise_invert(x, out=out) @@ -1851,7 +1852,7 @@ def cosh( -------- With :class:`ivy.Array` input: - >>> x = ivy.array([1, 2, 3, 4]) + >>> x = ivy.array([1., 2., 3., 4.]) >>> y = ivy.cosh(x) >>> print(y) ivy.array([1.54,3.76,10.1,27.3]) @@ -2287,7 +2288,7 @@ def exp( -------- With :class:Number: - >>> x = 3 + >>> x = 3. >>> y = ivy.exp(x) >>> print(y) ivy.array(20.08553692) @@ -4230,12 +4231,12 @@ def log2( >>> y = ivy.empty_like(x) >>> ivy.log2(x, out=y) >>> print(y) - ivy.array([[nan, 0., 2.58, inf],[inf, nan, nan, nan]]) + ivy.array([[nan, 0., 2.58, inf],[-inf, nan, nan, nan]]) >>> x = ivy.array([[float('nan'), 1, 7.0, float('+inf')], ... [+0, -3.0, -8, float('-inf')]]) >>> ivy.log2(x, out=x) >>> print(x) - ivy.array([[nan, 0., 2.81, inf],[inf, nan, nan, nan]]) + ivy.array([[nan, 0., 2.81, inf],[-inf, nan, nan, nan]]) With :class:`ivy.Container` input: >>> x = ivy.Container(a=ivy.array([0.0, float('nan')]), @@ -5959,7 +5960,7 @@ def sinh( -------- With :class:`ivy.Array` input: - >>> x = ivy.array([1, 2, 3]) + >>> x = ivy.array([1., 2., 3.]) >>> y = ivy.sinh(x) >>> print(y) ivy.array([1.18, 3.63, 10.]) @@ -6757,12 +6758,12 @@ def maximum( >>> x = ivy.array([1, 5, 9, 8, 3, 7]) >>> y = ivy.array([[9], [3], [2]]) - >>> z = ivy.zeros((3, 6)) + >>> z = ivy.zeros((3, 6), dtype=ivy.int32) >>> ivy.maximum(x, y, out=z) >>> print(z) - ivy.array([[9., 9., 9., 9., 9., 9.], - [3., 5., 9., 8., 3., 7.], - [2., 5., 9., 8., 3., 7.]]) + ivy.array([[9, 9, 9, 9, 9, 9], + [3, 5, 9, 8, 3, 7], + [2, 5, 9, 8, 3, 7]]) >>> x = ivy.array([[7, 3]]) >>> y = ivy.array([0, 7]) @@ -6847,12 +6848,12 @@ def minimum( >>> x = ivy.array([1, 5, 9, 8, 3, 7]) >>> y = ivy.array([[9], [3], [2]]) - >>> z = ivy.zeros((3, 6)) + >>> z = ivy.zeros((3, 6), dtype=ivy.int32) >>> ivy.minimum(x, y, out=z) >>> print(z) - ivy.array([[1.,5.,9.,8.,3.,7.], - [1.,3.,3.,3.,3.,3.], - [1.,2.,2.,2.,2.,2.]]) + ivy.array([[1, 5, 9, 8, 3, 7], + [1, 3, 3, 3, 3, 3], + [1, 2, 2, 2, 2, 2]]) >>> x = ivy.array([[7, 3]]) >>> y = ivy.array([0, 7]) @@ -6962,7 +6963,7 @@ def deg2rad( -------- With :class:`ivy.Array` input: - >>> x=ivy.array([0,90,180,270,360]) + >>> x=ivy.array([0,90,180,270,360], dtype=ivy.float32) >>> y=ivy.deg2rad(x) >>> print(y) ivy.array([0., 1.57079633, 3.14159265, 4.71238898, 6.28318531]) @@ -6988,7 +6989,7 @@ def deg2rad( With :class:`ivy.Container` input: >>> x=ivy.Container(a=ivy.array([-0,20.1,-50.5,-ivy.nan]), - ... b=ivy.array([0,90,180,270,360])) + ... b=ivy.array([0,90.,180,270,360], dtype=ivy.float32)) >>> y=ivy.deg2rad(x) >>> print(y) { @@ -6996,7 +6997,7 @@ def deg2rad( b: ivy.array([0., 1.57079633, 3.14159265, 4.71238898, 6.28318531]) } - >>> x=ivy.Container(a=ivy.array([0,90,180,270,360]), + >>> x=ivy.Container(a=ivy.array([0,90,180,270,360], dtype=ivy.float32), ... b=ivy.native_array([0,-1.5,-50,ivy.nan])) >>> y=ivy.deg2rad(x) >>> print(y) diff --git a/ivy/functional/ivy/experimental/activations.py b/ivy/functional/ivy/experimental/activations.py index f9788a93ffadf..f486b57c87960 100644 --- a/ivy/functional/ivy/experimental/activations.py +++ b/ivy/functional/ivy/experimental/activations.py @@ -559,15 +559,14 @@ def hardtanh( >>> ivy.hardtanh(x, out=y) >>> print(y) ivy.array([ 1., 0.7, -1.]) - >>> x = ivy.array([[1.1, 2.2, 3.3], - ... [-0.4, 0.5, -6.6]]) + >>> x = ivy.array([[1.1, 2.2, 3.3],[-0.4, 0.5, -6.6]]) >>> ivy.hardtanh(x, out=x) >>> print(x) - ivy.array([[ 1., 1., 1.], - [-0.4, 0.5, -1.]]) + ivy.array([[ 1., 1., 1.],[-0.4, 0.5, -1.]]) + With :class:`ivy.Container` input: >>> x = ivy.Container(a=ivy.array([0.0, -1.2]), b=ivy.array([0.4, -0.2])) - >>> x = ivy.hardtanhx, out=x) + >>> x = ivy.hardtanh(x, out=x) >>> print(x) { a: ivy.array([0., -1.]), @@ -953,7 +952,7 @@ def hardshrink( >>> x = ivy.array([-1.0, 1.0, 2.0]) >>> y = x.hardshrink() >>> print(y) - ivy.array([-0.5, 0.5, 1.5]) + ivy.array([-1., 1., 2.]) >>> x = ivy.array([[-1.3, 3.8, 2.1], [1.7, 4.2, -6.6]]) >>> y = ivy.hardshrink(x) >>> print(y) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 05aaddc089b6a..bf7ad024f9ae4 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -92,14 +92,14 @@ def max_pool1d( [[16., 17., 18., 19.]]]) >>> x = ivy.arange(0, 24.).reshape((2, 3, 4)) - >>> print(ivy.max_pool1d(x, 2, 2, [(1,0)], data_format="NCW", dilation=2, ceil_mode=True)) - ivy.array([[[ 1., 3.], - [ 5., 7.], - [ 9., 11.]], - - [[13., 15.], - [17., 19.], - [21., 23.]]]) + >>> print(ivy.max_pool1d(x, 2, 2, [(1,0)], data_format="NCW", dilation=1, ceil_mode=True)) + ivy.array([[[ 0., 2., 3.], + [ 4., 6., 7.], + [ 8., 10., 11.]], + + [[12., 14., 15.], + [16., 18., 19.], + [20., 22., 23.]]]) """ # noqa: E501 return ivy.current_backend(x).max_pool1d( x, @@ -591,7 +591,7 @@ def pool( Examples -------- >>> x = ivy.arange(12.).reshape((2, 1, 3, 2)) - >>> print(ivy.pool(x, (2, 2), 'MAX', (1, 1), 'SAME')) + >>> print(ivy.pool(x, (2, 2), 'MAX', strides=(1, 1), padding='SAME')) ivy.array([[[[ 1., 2.], [ 3., 4.], [ 4., 5.]]], @@ -599,7 +599,7 @@ def pool( [ 9., 10.], [10., 11.]]]]) >>> x = ivy.arange(48.).reshape((2, 4, 3, 2)) - >>> print(ivy.pool(x, 3, 'AVG', 1, 'VALID')) + >>> print(ivy.pool(x, 3, 'AVG', strides=1, padding='VALID')) ivy.array([[[[ 8., 9.]], [[14., 15.]]], [[[32., 33.]], @@ -2947,7 +2947,8 @@ def rfft( >>> x = ivy.array([2.3,3.14,7.2]) >>> y = ivy.zeros(2) >>> ivy.rfft(x, out=y) - ivy.array([12.639999+0.j , -2.87 +3.516063j]) + >>> print(x) + ivy.array([2.29999995, 3.1400001 , 7.19999981]) >>> x = ivy.array([-1.2, 3.4, -5.6]) >>> ivy.rfft(x, n=4, out=x) @@ -3031,7 +3032,7 @@ def rfftn( Examples -------- >>> x = ivy.array([1, 2, 3, 4], dtype=ivy.float32) - >>> result = ivy.rfftn(x, s=(4,)) + >>> result = ivy.rfftn(x, s=(4,), axes=(0,)) >>> print(result) ivy.array([10.+0.j, -2.+2.j, -2.+0.j]) diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index 46ff186bd66bd..cad3733c69dcc 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -1903,7 +1903,7 @@ def general_inner_product( >>> a = ivy.array([1, 2, 3]) >>> b = ivy.array([4, 5, 6]) - >>> result = ivy.general_inner_product(a, b, n_modes=1) + >>> result = ivy.general_inner_product(a, b, 1) >>> print(result) ivy.array(32) @@ -1915,7 +1915,7 @@ def general_inner_product( >>> a = ivy.array([[1, 1], [1, 1]]) >>> b = ivy.array([[1, 2, 3, 4],[1, 1, 1, 1]]) - >>> result = ivy.general_inner_product(a, b, n_modes=1) + >>> result = ivy.general_inner_product(a, b, 1) >>> print(result) ivy.array([[2, 3, 4, 5], [2, 3, 4, 5]]) diff --git a/ivy/functional/ivy/experimental/losses.py b/ivy/functional/ivy/experimental/losses.py index bcf72c68008fd..11177553a1cef 100644 --- a/ivy/functional/ivy/experimental/losses.py +++ b/ivy/functional/ivy/experimental/losses.py @@ -138,11 +138,11 @@ def l1_loss( -------- >>> x = ivy.array([1.0, 2.0, 3.0]) >>> y = ivy.array([0.5, 2.5, 2.0]) - >>> print(ivy.l1_loss(x, y)) - ivy.array(0.6) + >>> ivy.l1_loss(x, y) + ivy.array(0.666) >>> a = ivy.array([[1.0, 2.0], [3.0, 4.0]]) >>> b = ivy.array([[0.5, 1.5], [2.5, 3.5]]) - >>> print(ivy.l1_loss(a, b)) + >>> ivy.l1_loss(a, b) ivy.array(0.5) """ loss = ivy.abs(target - input) @@ -258,12 +258,12 @@ def smooth_l1_loss( Examples -------- - >>> input = ivy.array([1.0, 2.0, 3.0]) - >>> target = ivy.array([2.5, 1.8, 3.2]) + >>> x = ivy.array([1.0, 2.0, 3.0]) + >>> y = ivy.array([2.5, 1.8, 3.2]) >>> ivy.smooth_l1_loss(x, y, beta=1.0) ivy.array(0.3467) - >>> input = ivy.array([1.0, 2.0, 3.0]) - >>> target = ivy.array([6.0, 2.0, 3.0]) + >>> x = ivy.array([1.0, 2.0, 3.0]) + >>> y = ivy.array([6.0, 2.0, 3.0]) >>> ivy.smooth_l1_loss(x, y, beta=1.0) ivy.array(1.5) >>> input = ivy.array([2.0, 3.0, 5.0, 7.0]) @@ -559,7 +559,7 @@ def poisson_nll_loss( -------- >>> input_tensor = ivy.array([1, 2, 3, 4], dtype=ivy.float64) >>> target_tensor = ivy.array([2, 2, 2, 2], dtype=ivy.float64) - >>> loss = poisson_nll_loss(input_tensor, target_tensor, log_input=False) + >>> loss = ivy.poisson_nll_loss(input_tensor, target_tensor, log_input=False) >>> print(loss) ivy.array(0.91097307) """ diff --git a/ivy/functional/ivy/experimental/manipulation.py b/ivy/functional/ivy/experimental/manipulation.py index d46b2bed23bc7..a1467eddf7271 100644 --- a/ivy/functional/ivy/experimental/manipulation.py +++ b/ivy/functional/ivy/experimental/manipulation.py @@ -1797,10 +1797,10 @@ def put_along_axis( >>> axis = 1 >>> indices = ivy.argmax(arr, axis=axis, keepdims=True) >>> value = 100 - >>> ivy.put_along_axis(arr, indices, value, axis, mode='add') + >>> ivy.put_along_axis(arr, indices, value, axis, mode='sum') >>> print(arr) - ivy.array([[ 10, 130, 20], - [ 160, 40, 50]]) + ivy.array([[10, 30, 20], + [60, 40, 50]]) """ arr_shape = arr.shape @@ -2627,17 +2627,17 @@ def choose( Examples -------- >>> choices = ivy.array([[0, 1, 2, 3], [10, 11, 12, 13], - [20, 21, 22, 23], [30, 31, 32, 33]]) - >>> print(choose(ivy.array([2, 3, 1, 0]), choices)) + ... [20, 21, 22, 23],[30, 31, 32, 33]]) + >>> print(ivy.choose(choices, ivy.array([2, 3, 1, 0])) ivy.array([20, 31, 12, 3]) >>> arr = ivy.array([2, 4, 1, 0]) - >>> print(choose(arr, choices, mode='clip')) # 4 goes to 3 (4-1) + >>> print(ivy.choose(choices, arr, mode='clip')) # 4 goes to 3 (4-1) ivy.array([20, 31, 12, 3]) >>> arr = ivy.array([2, 4, 1, 0]) - >>> print(choose(arr, choices, mode='wrap')) # 4 goes to (4 mod 4) + >>> print(ivy.choose(choices, arr, mode='wrap')) # 4 goes to (4 mod 4) ivy.array([20, 1, 12, 3]) """ - return ivy.current_backend(arr).choose(arr, choices, out=out, mode=mode) + return ivy.current_backend().choose(arr, choices, out=out, mode=mode) @handle_array_function diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index f19a1c4b0face..4150033e2a5cf 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -214,18 +214,11 @@ def get_referrers_recursive( Examples -------- >>> import gc - >>> def example_function(): - ... obj = [1, 2, 3] - ... return get_referrers_recursive(obj, max_depth=2) + >>> example_function = lambda: (obj := [1, 2, 3]) and ivy.get_referrers_recursive(obj, max_depth=2) >>> result = example_function() >>> print(result) - Container( - 'ref_id_1': Container( - 'ref_id_2': 'tracked', - 'ref_id_3': 'tracked' - ) - ) - """ + {repr:[1,2,3]} + """ # noqa: E501 seen_set = ivy.default(seen_set, set()) local_set = ivy.default(local_set, set()) ret_cont = ivy.Container( @@ -1056,7 +1049,7 @@ def clip_vector_norm( >>> print(y) { a: ivy.array([0., 0.894, 1.79]), - b: ivy.array([2.449, 2.65, 2.83]) + b: ivy.array([1.27279221, 1.69705628, 2.12132034]) } """ norm = ivy.vector_norm(x, keepdims=True, ord=p) @@ -2157,13 +2150,16 @@ def set_min_base(val: float) -> None: >>> print(x) 1e-05 - Set the minimum base to 1e-04: + >>> # Set the minimum base to 1e-04: >>> ivy.set_min_base(1e-04) Retrieve the minimum base: >>> y = ivy.min_base >>> print(y) 1e-04 + + >>> # unset the min_base + >>> ivy.unset_min_base() """ global min_base_stack @@ -2547,6 +2543,9 @@ def set_tmp_dir(tmp_dr: str) -> None: >>> y = ivy.tmp_dir >>> print(y) /my_tmp + + >>> # Unset the tmp_dr + >>> ivy.unset_tmp_dir() """ global tmp_dir_stack ivy.utils.assertions.check_isinstance(tmp_dr, str) @@ -2859,10 +2858,10 @@ def set_item( >>> val = ivy.array([10, 10]) >>> ivy.set_item(x, query, val) >>> print(x) - ivy.array([10, 10, 20]) + >>> x = ivy.array([[0, -1, 20], [5, 2, -8]]) - >>> query = ([1, 1]) + >>> query = ivy.array([1, 1]) >>> val = ivy.array([10, 10]) >>> y = ivy.set_item(x, query, val, copy=True) >>> print(y) @@ -4188,7 +4187,7 @@ def vmap( >>> x = ivy.array(ivy.arange(60).reshape((3, 5, 4))) >>> y = ivy.array(ivy.arange(40).reshape((5, 4, 2))) >>> z = ivy.vmap(ivy.matmul, (1, 0), 1)(x, y) - >>> print(z.shape) + >>> z.shape (3, 5, 2) """ # TODO: optimize in the numpy and tensorflow backends and extend functionality diff --git a/ivy/functional/ivy/layers.py b/ivy/functional/ivy/layers.py index ceabe86041d31..d832aa88a4d30 100644 --- a/ivy/functional/ivy/layers.py +++ b/ivy/functional/ivy/layers.py @@ -518,9 +518,9 @@ def scaled_dot_product_attention( >>> result = ivy.scaled_dot_product_attention(q,k,v,scale=1,mask=mask) >>> print(result) - ivy.array([[[0.40000001, 1.29999995], - ... [2.19994521, 3.09994531], - ... [4.30000019, 5.30000019]]]) + ivy.array([[[2.30000019, 3.23333359], + [2.30000019, 3.23333359], + [2.30000019, 3.23333359]]]) >>> q = ivy.array([[[0.2, 1.], [2.2, 3.], [4.4, 5.6]]]) >>> k = ivy.array([[[0.6, 1.5], [2.4, 3.3], [4.2, 5.1]]]) diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index 8831c28b7b64a..95c2ae8ef3890 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -1661,16 +1661,8 @@ def outer( [3.], [4.]]) - A 3-D Example - - >>> x = ivy.array([[[1., 2.], - [3., 4.]], - [[5., 6.], - [7., 8.]]]) - >>> y = ivy.array([[[9., 10.], - [11., 12.]], - [[13., 14.], - [15., 16.]]]) + >>> x = ivy.array([[[1., 2.],[3., 4.]],[[5., 6.],[7., 8.]]]) + >>> y = ivy.array([[[9., 10.],[11., 12.]],[[13., 14.],[15., 16.]]]) >>> d = ivy.outer(x, y) >>> print(d) ivy.array([[ 9., 10., 11., 12., 13., 14., 15., 16.], @@ -1953,6 +1945,7 @@ def slogdet( >>> print(y) slogdet(sign=ivy.array(1.), logabsdet=ivy.array(1.60943794)) + >>> ivy.set_backend('numpy') # As the precision of results depends on backend. >>> x = ivy.array([[1.2, 2.0, 3.1], ... [6.0, 5.2, 4.0], ... [9.0, 8.0, 7.0]]) @@ -1962,6 +1955,7 @@ def slogdet( With :class:`ivy.Container` input: + >>> ivy.unset_backend() # unset backend again. >>> x = ivy.Container(a=ivy.array([[1.0, 2.0], ... [3.0, 4.0]]), ... b=ivy.array([[1.0, 2.0], @@ -2037,13 +2031,9 @@ def solve( Examples -------- With class:`ivy.Array` input: - >>> A = ivy.array([[1.1, 1.2, 1.3], - [2.1, 2.2, 2.3], - [3.1, 3.2, 3.3]]), - >>> B = ivy.array([[1.1], - [2.1], - [3.1]]), - >>> x = solve(A,B); + >>> A = ivy.array([[1.1, 1.2, 1.3], [2.1, 2.2, 2.3], [3.1, 3.2, 3.3]]), + >>> B = ivy.array([[1.1], [2.1], [3.1]]), + >>> x = ivy.solve(A,B); >>> print(x) ivy.array([[1], [0], @@ -2052,20 +2042,14 @@ def solve( (1,3) With shape(A) = (2,3,3) and shape(B) = (2,3,1): - >>> A = ivy.array([[[11.1, 11.2, 11.3], - [12.1, 12.2, 12.3], - [13.1, 13.2, 13.3]], - [[21.1, 21.2, 21.3], - [22.1, 22.2, 22.3], - [23.1, 23.2, 23.3]] - ]), + >>> A = ivy.array([[[11.1, 11.2, 11.3],[12.1, 12.2, 12.3],[13.1, 13.2, 13.3]], [[21.1, 21.2, 21.3],[22.1, 22.2, 22.3],[23.1, 23.2, 23.3]]]), >>> B = ivy.array([[[11.1], [12.1], [13.1]], [[21.1], [22.1], [23.1]]]), - >>> x = solve(A,B); + >>> x = ivy.solve(A,B); >>> print(x) ivy.array([[[1], [0], @@ -2077,13 +2061,9 @@ def solve( (2,1,3) With shape(A) = (3,3) and shape(B) = (3,2): - >>> A = ivy.array([[1.1, 1.2, 1.3], - [2.1, 2.2, 2.3], - [3.1, 3.2, 3.3]]), - >>> B = ivy.array([[1.1, 2.2], - [2.1, 4.2], - [3.1, 6.2]]), - >>> x = solve(A,B); + >>> A = ivy.array([[1.1, 1.2, 1.3], [2.1, 2.2, 2.3], [3.1, 3.2, 3.3]]), + >>> B = ivy.array([[1.1, 2.2], [2.1, 4.2], [3.1, 6.2]]), + >>> x = ivy.solve(A,B); >>> print(x) ivy.array([[[1], [0], @@ -2095,18 +2075,16 @@ def solve( (2,1,3) With class:`ivy.Container` input: - >>> A = ivy.array([[1.1, 1.2, 1.3], - [2.1, 2.2, 2.3], - [3.1, 3.2, 3.3]]), + >>> A = ivy.array([[1.1, 1.2, 1.3], [2.1, 2.2, 2.3], [3.1, 3.2, 3.3]]), >>> B = ivy.container(B1 = ivy.array([[1.1], [2.1], [3.1]]), B2 = ivy.array([[2.2], [4.2], [6.2]])) - >>> x = solve(A,B); + >>> x = ivy.solve(A,B); >>> print(x) { B1:([[1],[0],[0]]), B2:([[2],[0],[0]]) } - """ + """ # noqa: E501 return current_backend(x1, x2).solve(x1, x2, adjoint=adjoint, out=out) @@ -2317,7 +2295,7 @@ def svdvals( >>> x = ivy.native_array([[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], ... [2.0, 1.0, 3.0], [3.0, 4.0, 5.0]]) - >>> print(x.shape) + >>> x.shape (4, 3) >>> x = ivy.native_array([[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], @@ -2450,7 +2428,7 @@ def tensordot( >>> x = ivy.native_array([[1., 2.], [2., 3.]]) >>> y = ivy.native_array([[3., 4.], [4., 5.]]) - >>> res = ivy.tensordot(x, y, axes = (1,1)) + >>> res = ivy.tensordot(x, y, axes = ([1],[1])) >>> print(res) ivy.array([[11., 14.], [18., 23.]]) @@ -2632,7 +2610,7 @@ def trace( ... [7, 0, 6]]) ... ) >>> offset = ivy.Container(a=1, b=0) - >>> y = ivy.trace(x, offset) + >>> y = ivy.trace(x, offset=offset) >>> print(y) { a: ivy.array(6), @@ -2882,13 +2860,13 @@ def vector_norm( ivy.array([4.64158917]) - >>> x = ivy.array([1,2,3,4], dtype = ivy.float16) - >>> z = ivy.empty(shape = 1) + >>> x = ivy.array([1.,2.,3.,4.], dtype = ivy.float16) + >>> z = ivy.empty(shape = 1, dtype=ivy.float16) >>> y = ivy.vector_norm(x, ord = 0, out = z) >>> print(y) ivy.array(4.) - >>> x = ivy.arange(8).reshape((2,2,2)) + >>> x = ivy.arange(8, dtype=ivy.float32).reshape((2,2,2)) >>> y = ivy.vector_norm(x, axis = (0,1), ord = float("-inf")) >>> print(y) ivy.array([0, 1]) diff --git a/ivy/functional/ivy/losses.py b/ivy/functional/ivy/losses.py index 8310df572f06c..a76db473ffbd3 100644 --- a/ivy/functional/ivy/losses.py +++ b/ivy/functional/ivy/losses.py @@ -72,11 +72,11 @@ def cross_entropy( >>> x = ivy.array([0, 0, 1, 0]) >>> y = ivy.array([0.25, 0.25, 0.25, 0.25]) >>> print(ivy.cross_entropy(x, y)) - ivy.array(1.3862944) + ivy.array(0.34657359) >>> z = ivy.array([0.1, 0.1, 0.7, 0.1]) >>> print(ivy.cross_entropy(x, z)) - ivy.array(0.35667497) + ivy.array(0.08916873) """ ivy.utils.assertions.check_elem_in_list(reduction, ["none", "sum", "mean"]) pred = ivy.clip(pred, epsilon, 1 - epsilon) @@ -142,7 +142,7 @@ def binary_cross_entropy( >>> y = ivy.array([0.2, 0.8, 0.3, 0.8]) >>> z = ivy.binary_cross_entropy(x, y) >>> print(z) - ivy.array([0.223,0.223,0.357,1.61]) + ivy.array(0.60309976) >>> x = ivy.array([[0, 1, 1, 0]]) >>> y = ivy.array([[2.6, 6.2, 3.7, 5.3]]) @@ -154,24 +154,26 @@ def binary_cross_entropy( >>> y = ivy.array([[2.6, 6.2, 3.7, 5.3]]) >>> pos_weight = ivy.array([1, 2, 3, 4]) >>> z = ivy.binary_cross_entropy(x, y, pos_weight=pos_weight, from_logits=True) - ivy.array([[2.67164493e+00, 4.05471958e-03, 7.32684899e-02, 5.30496836e+00]]) + ivy.array(2.01348412) >>> x = ivy.array([[0, 1, 1, 0]]) >>> y = ivy.array([[2.6, 6.2, 3.7, 5.3]]) >>> pos_weight = ivy.array([1, 2, 3, 4]) >>> z = ivy.binary_cross_entropy(x, y, pos_weight=pos_weight, from_logits=True, reduction='sum', axis=1) + >>> print(z) ivy.array([8.05393649]) >>> x = ivy.array([[0, 1, 1, 0]]) >>> y = ivy.array([[2.6, 6.2, 3.7, 5.3]]) >>> z = ivy.binary_cross_entropy(x, y, reduction='none', epsilon=0.5) + >>> print(z) ivy.array([[11.49992943, 3.83330965, 3.83330965, 11.49992943]]) >>> x = ivy.array([[0, 1, 0, 0]]) >>> y = ivy.array([[0.6, 0.2, 0.7, 0.3]]) >>> z = ivy.binary_cross_entropy(x, y, epsilon=1e-3) >>> print(z) - ivy.array([[0.916,1.61,1.2,0.357]]) + ivy.array(1.02136981) With :class:`ivy.NativeArray` input: @@ -179,7 +181,7 @@ def binary_cross_entropy( >>> y = ivy.native_array([0.2, 0.7, 0.2, 0.6]) >>> z = ivy.binary_cross_entropy(x, y) >>> print(z) - ivy.array([0.223,0.357,0.223,0.511]) + ivy.array(0.32844672) With a mix of :class:`ivy.Array` and :class:`ivy.NativeArray` inputs: @@ -187,7 +189,7 @@ def binary_cross_entropy( >>> y = ivy.native_array([0.1, 0.2, 0.8, 0.6]) >>> z = ivy.binary_cross_entropy(x, y) >>> print(z) - ivy.array([0.105,0.223,0.223,0.511]) + ivy.array(0.26561815) With :class:`ivy.Container` input: @@ -195,7 +197,10 @@ def binary_cross_entropy( >>> y = ivy.Container(a=ivy.array([0.6, 0.2, 0.3]),b=ivy.array([0.8, 0.2, 0.2])) >>> z = ivy.binary_cross_entropy(x, y) >>> print(z) - {a:ivy.array([0.511,0.223,0.357]),b:ivy.array([1.61,0.223,1.61])} + { + a: ivy.array(0.36354783), + b: ivy.array(1.14733934) + } With a mix of :class:`ivy.Array` and :class:`ivy.Container` inputs: @@ -204,7 +209,7 @@ def binary_cross_entropy( >>> z = ivy.binary_cross_entropy(x, y) >>> print(z) { - a: ivy.array([0.357, 0.223, 0.223]) + a: ivy.array(0.26765382) } Instance Method Examples @@ -215,7 +220,7 @@ def binary_cross_entropy( >>> y = ivy.array([0.8, 0.2, 0.2, 0.2]) >>> z = ivy.binary_cross_entropy(x, y) >>> print(z) - ivy.array([0.223, 0.223, 0.223, 0.223]) + ivy.array(0.22314337) """ # noqa: E501 ivy.utils.assertions.check_elem_in_list(reduction, ["none", "sum", "mean"]) @@ -309,24 +314,24 @@ def sparse_cross_entropy( >> x = ivy.array([2]) >> y = ivy.array([0.1, 0.1, 0.7, 0.1]) >> print(ivy.sparse_cross_entropy(x, y)) - ivy.array([0.35667494]) + ivy.array([0.08916873]) >>> x = ivy.array([3]) >>> y = ivy.array([0.1, 0.1, 0.7, 0.1]) >>> print(ivy.cross_entropy(x, y)) - ivy.array(21.79329094) + ivy.array(5.44832274) >>> x = ivy.array([2,3]) >>> y = ivy.array([0.1, 0.1]) >>> print(ivy.cross_entropy(x, y)) - ivy.array(11.512926) + ivy.array(5.75646281) With :class:`ivy.NativeArray` input: >>> x = ivy.native_array([4]) >>> y = ivy.native_array([0.1, 0.2, 0.1, 0.1, 0.5]) >>> print(ivy.sparse_cross_entropy(x, y)) - ivy.array([0.693]) + ivy.array([0.13862944]) With :class:`ivy.Container` input: @@ -334,7 +339,7 @@ def sparse_cross_entropy( >>> y = ivy.Container(a=ivy.array([0.1, 0.2, 0.1, 0.1, 0.5])) >>> print(ivy.sparse_cross_entropy(x, y)) { - a: ivy.array([0.693]) + a: ivy.array([0.13862944]) } With a mix of :class:`ivy.Array` and :class:`ivy.NativeArray` inputs: @@ -342,7 +347,7 @@ def sparse_cross_entropy( >>> x = ivy.array([0]) >>> y = ivy.native_array([0.1, 0.2, 0.6, 0.1]) >>> print(ivy.sparse_cross_entropy(x,y)) - ivy.array([2.3]) + ivy.array([0.57564628]) With a mix of :class:`ivy.Array` and :class:`ivy.Container` inputs: @@ -350,7 +355,7 @@ def sparse_cross_entropy( >>> y = ivy.Container(a=ivy.array([0.1, 0.2, 0.6, 0.1])) >>> print(ivy.sparse_cross_entropy(x,y)) { - a: ivy.array([2.3]) + a: ivy.array([0.57564628]) } Instance Method Examples @@ -360,7 +365,7 @@ def sparse_cross_entropy( >>> x = ivy.array([2]) >>> y = ivy.array([0.1, 0.1, 0.7, 0.1]) >>> print(x.sparse_cross_entropy(y)) - ivy.array([0.357]) + ivy.array([0.08916873]) With :class:`ivy.Container` input: @@ -368,7 +373,7 @@ def sparse_cross_entropy( >>> y = ivy.Container(a=ivy.array([0.1, 0.1, 0.7, 0.1])) >>> print(x.sparse_cross_entropy(y)) { - a: ivy.array([0.357]) + a: ivy.array([0.08916873]) } """ ivy.utils.assertions.check_elem_in_list(reduction, ["none", "sum", "mean"]) diff --git a/ivy/functional/ivy/manipulation.py b/ivy/functional/ivy/manipulation.py index a039a9159e3a0..b128f99d62f6e 100644 --- a/ivy/functional/ivy/manipulation.py +++ b/ivy/functional/ivy/manipulation.py @@ -1214,9 +1214,17 @@ def split( >>> x = ivy.Container(a=ivy.array([10, 45, 2])) >>> y = ivy.split(x) >>> print(y) - { - a:(list[3],shape=[1]) - } + [ + { + a: ivy.array([10]) + }, + { + a: ivy.array([45]) + }, + { + a: ivy.array([2]) + } + ] """ return current_backend(x).split( x, diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index 10c15293d3e67..60e9f1f279f43 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -239,7 +239,7 @@ def insert_into_nest_at_index(nest: Iterable, index: Tuple, value) -> None: >>> nest = [[1, 2], [3, 4]] >>> index = (1, 1) >>> value = 99 - >>> insert_into_nest_at_index(nest, index, value) + >>> ivy.insert_into_nest_at_index(nest, index, value) >>> print(nest) [[1, 2], [3, 99, 4]] """ @@ -1093,18 +1093,12 @@ def nested_map( ... ) >>> function = lambda a : a + 1 >>> ivy.nested_map(function, x) - { - a: ivy.array([[2, 3, 4], - [10, 9, 8]]), - b: ivy.array([[5, 6, 7], - [13, 14, 15]]) - } >>> print(x) { - a: ivy.array([[2, 3, 4], - [10, 9, 8]]), - b: ivy.array([[5, 6, 7], - [13, 14, 15]]) + a: ivy.array([[1, 2, 3], + [9, 8, 7]]), + b: ivy.array([[4, 5, 6], + [12, 13, 14]]) } >>> nest = ([1, 2], [3, 4], [5, 6], {"a": 1, "b": 2, "c": 3}) diff --git a/ivy/functional/ivy/searching.py b/ivy/functional/ivy/searching.py index 0faf2e0efd258..9dd2c434990c8 100644 --- a/ivy/functional/ivy/searching.py +++ b/ivy/functional/ivy/searching.py @@ -92,9 +92,10 @@ def argmax( ivy.array([1]) >>> x = ivy.array([-0., 1., -1.]) - >>> ivy.argmax(x, out=x) - >>> print(x) - ivy.array([1]) + >>> z = ivy.zeros((1,3), dtype=ivy.int64) + >>> ivy.argmax(x, out=z) + >>> print(z) + ivy.array(1) >>> x = ivy.array([[1., -0., -1.], [-2., 3., 2.]]) >>> y = ivy.argmax(x, axis=1) @@ -112,7 +113,7 @@ def argmax( ivy.array([0, 2]) int64 >>> x = ivy.array([[4., 0., -1.],[2., -3., 6], [2., -3., 6]]) - >>> z = ivy.zeros((1,3), dtype=ivy.int64) + >>> z = ivy.zeros((3,1), dtype=ivy.int64) >>> y = ivy.argmax(x, axis=1, keepdims=True, out=z) >>> print(z) ivy.array([[0],[2],[2]]) diff --git a/ivy/functional/ivy/statistical.py b/ivy/functional/ivy/statistical.py index e6d80c8809c49..d160973ae184f 100644 --- a/ivy/functional/ivy/statistical.py +++ b/ivy/functional/ivy/statistical.py @@ -1099,9 +1099,7 @@ def cumprod( >>> print(y) ivy.array([1, 2, 6]) - >>> x = ivy.array([[2, 3], - [5, 7], - [11, 13]]) + >>> x = ivy.array([[2, 3],[5, 7],[11, 13]]) >>> y = ivy.zeros((3, 2)) >>> ivy.cumprod(x, axis=1, exclusive=True, out=y) >>> print(y) @@ -1119,7 +1117,7 @@ def cumprod( >>> x = ivy.array([[2, 3],[5, 7],[11, 13]]) >>> y = ivy.zeros((3, 2)) >>> x.cumprod(axis=0, exclusive=True, out=y) - >>> print(x) + >>> print(y) ivy.array([[1., 1.], [2., 3.], [10., 21.]]) @@ -1142,12 +1140,7 @@ def cumprod( b: ivy.array([1, 3, 12]) } - >>> x = ivy.Container(a=ivy.array([[2, 3], - [5, 7], - [11, 13]]), - b=ivy.array([[3, 4], - [4, 5], - [5, 6]])) + >>> x = ivy.Container(a=ivy.array([[2, 3],[5, 7],[11, 13]]), b=ivy.array([[3, 4],[4, 5],[5, 6]])) >>> y = ivy.Container(a = ivy.zeros((3, 2)), b = ivy.zeros((3, 2))) >>> ivy.cumprod(x, axis=1, exclusive=True, out=y) >>> print(y) @@ -1160,12 +1153,7 @@ def cumprod( [1, 5]]) } - >>> x = ivy.Container(a=ivy.array([[2, 3], - [5, 7], - [11, 13]]), - b=ivy.array([[3, 4], - [4, 5], - [5, 6]])) + >>> x = ivy.Container(a=ivy.array([[2, 3],[5, 7],[11, 13]]), b=ivy.array([[3, 4],[4, 5],[5, 6]])) >>> x.cumprod(axis=0, exclusive=True, out=x) >>> print(x) { @@ -1174,9 +1162,9 @@ def cumprod( [10, 21]]), b: ivy.array([[1, 1], [3, 4], - [15, 42]]) + [12, 20]]) } - """ + """ # noqa: E501 return current_backend(x).cumprod( x, axis=axis, exclusive=exclusive, reverse=reverse, dtype=dtype, out=out ) diff --git a/ivy_tests/test_docstrings.py b/ivy_tests/test_docstrings.py index 0f582920243ef..0cc34ffed62ff 100644 --- a/ivy_tests/test_docstrings.py +++ b/ivy_tests/test_docstrings.py @@ -6,6 +6,7 @@ import numpy as np import sys + warnings.filterwarnings("ignore", category=DeprecationWarning) import pytest @@ -115,93 +116,38 @@ def check_docstring_examples_run( # the temp skip list consists of functions # which have an issue with their implementation skip_list_temp = [ - "outer", - "argmax", - "split", - "det", - "cumprod", - "sinc", - "grad", - "try_else_none", - # all examples are wrong including functional/ivy - "einops_reduce", - "max_unpool1d", - "pool", - "put_along_axis", - "result_type", - # works only if no backend set - "rfftn", - # examples works but exec throws error or generate diff results - "scaled_dot_product_attention", - "searchsorted", - # generates different results in different backends - "eigh_tridiagonal", - "log_poisson_loss", + "outer", # Failing only torch backend as inputs must be 1-D. + "pool", # Maximum recursion depth exceeded ivy.pool + "put_along_axis", # Depends on scatter_nd for numpy. + "result_type", # Different ouput coming for diff backends in 1st example. + "scaled_dot_product_attention", # Different backends giving different answers. + "eigh_tridiagonal", # Failing only for TF backend "dct", - "idct", - "set_item", - "l1_normalize", - "histogram", - "native_array", - "function_supported_devices", - "acosh", - "bitwise_invert", - "cosh", - "exp", - "sinh", - "reciprocal", - "deg2rad", - "value_and_grad", - "vector_norm", - "set_nest_at_index", - "set_nest_at_indices", - "layer_norm", - "where", - "trace", - "eigvalsh", - "conv2d_transpose", - # fails due to different backend and their view types - "sequence_length", - "max_pool1d", - "vmap", - "inner", - "slogdet", - "svdvals", - "nested_map", - "dill", - "hardtanh", - "hardshrink", - "rfft", - "general_inner_product", - "l1_loss", - "smooth_l1_loss", - "poisson_nll_loss", - "choose", - "cummax", - "one_hot", - "tpu_is_available", - "log2", - "maximum", - "minimum", - "get_referrers_recursive", - "clip_vector_norm", - "set_min_base", - "scatter_flat", - "scatter_nd", + "choose", # Maximum recurion depth exceeded (No backend choose fn). + "idct", # Function already failing for all 5 backends. + "set_item", # Different errors for diff backends (jax, torch) + "l1_normalize", # Function already failing for all 5 backends. + "histogram", # Failing for TF, Torch backends (TODO's left) + "value_and_grad", # Failing only for Torch backend. (Requires_grad=True) + "layer_norm", # Failing only for Torch backend. + "eigvalsh", # Failing only Jax Backend + only for Native Array Example. + "conv2d_transpose", # Function already failing for all 5 backends. + "solve", + "one_hot", # One small example failing for all backends except torch. + "scatter_flat", # Function Already failing for 3 backends + "scatter_nd", # + "execute_with_gradients", # Function Already failing for 4 backends. "gather", "multiprocessing", - "execute_with_gradients", - "solve", - "tensordot", - "cross_entropy", - "binary_cross_entropy", - "sparse_cross_entropy", - "reptile_step", - "insert_into_nest_at_index", "if_else", + "trace_graph", # SystemExit: Please sign up for free pilot access. + "dill", + "smooth_l1_loss", # Function already failing for all 5 backends. + "cummax", # Function already failing for all 5 backends. + "insert_into_nest_at_index", "while_loop", - "trace_graph", - "set_tmp_dir", + "argmax", + "native_array", ] # skip list for array and container docstrings From 935cde8ebd48d8b57c4d93599b6e406943ced374 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 7 Feb 2024 14:29:51 +0530 Subject: [PATCH 745/978] fix: fixed the inefficiency when using ivy.conv_general_dilated in a depthwise manner, replaced the loop by using tf.nn.depthwise_conv2d (#28208) --- ivy/functional/backends/tensorflow/layers.py | 32 +++++++------------- 1 file changed, 11 insertions(+), 21 deletions(-) diff --git a/ivy/functional/backends/tensorflow/layers.py b/ivy/functional/backends/tensorflow/layers.py index 300afb74ae168..a9d3d7dd40f63 100644 --- a/ivy/functional/backends/tensorflow/layers.py +++ b/ivy/functional/backends/tensorflow/layers.py @@ -467,27 +467,17 @@ def conv_general_dilated( dilations=dilations, ) else: - res = tf.concat( - [ - tf.nn.conv2d( - x[..., i : i + filters.shape[-2]], - filters[..., j : j + filters.shape[-1] // feature_group_count], - strides, - padding, - data_format, - dilations, - ) - for i, j in zip( - range(0, x.shape[-1], filters.shape[-2]), - range( - 0, - filters.shape[-1], - filters.shape[-1] // feature_group_count, - ), - ) - ], - axis=-1, - ) + with ivy.ArrayMode(False): + if not isinstance(padding, str): + padding = padding[1:-1] + res = depthwise_conv2d( + x, + tf.transpose(filters, (0, 1, 3, 2)), + strides, + padding, + data_format=data_format, + dilations=dilations, + ) else: x, padding = _pad_before_conv(x, padding, dims, data_format) if dims == 1: From 0c3a4a9509e75852f36eb0438a3ae100eef9e7a0 Mon Sep 17 00:00:00 2001 From: Vismay Suramwar <83938053+Vismay-dev@users.noreply.github.com> Date: Wed, 7 Feb 2024 03:03:48 -0600 Subject: [PATCH 746/978] fix: Fixing pytest discovery issues (#28158) Co-authored-by: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Co-authored-by: NripeshN --- ivy/functional/frontends/__init__.py | 1 + .../frontends/tensorflow/keras/activations.py | 21 +++++++++++++++++-- ivy/functional/ivy/data_type.py | 7 ++++++- ivy/functional/ivy/device.py | 2 +- ivy/functional/ivy/general.py | 2 +- 5 files changed, 28 insertions(+), 5 deletions(-) diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 013a7e3fc26f8..4ae0d2ddfa489 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -11,6 +11,7 @@ "sklearn": "1.3.0", "xgboost": "1.7.6", "torchvision": "0.15.2.", + "mindspore": "2.0.0", } diff --git a/ivy/functional/frontends/tensorflow/keras/activations.py b/ivy/functional/frontends/tensorflow/keras/activations.py index 9abc0a84825ad..1bbffa3d5f375 100644 --- a/ivy/functional/frontends/tensorflow/keras/activations.py +++ b/ivy/functional/frontends/tensorflow/keras/activations.py @@ -16,6 +16,21 @@ ] +# --- Helpers --- # +# --------------- # + + +# note: defined to avoid AST call extraction of +# 'tf_frontend.keras.activations.__dict__.items() +# or 'tf_frontend.keras.activations.__dict__.values()' +def _get_tf_keras_activations(): + return tf_frontend.keras.activations.__dict__.items() + + +# --- Main --- # +# ------------ # + + @with_supported_dtypes( {"2.15.0 and below": ("float16", "float32", "float64")}, "tensorflow", @@ -132,13 +147,15 @@ def serialize(activation, use_legacy_format=False, custom_objects=None): if custom_func == activation: return name + tf_keras_frontend_activations = _get_tf_keras_activations() + # Check if the function is in the ACTIVATION_FUNCTIONS list if activation.__name__ in ACTIVATION_FUNCTIONS: return activation.__name__ # Check if the function is in the TensorFlow frontend activations - elif activation in tf_frontend.keras.activations.__dict__.values(): - for name, tf_func in tf_frontend.keras.activations.__dict__.items(): + elif activation in [fn for name, fn in tf_keras_frontend_activations]: + for name, tf_func in tf_keras_frontend_activations: if tf_func == activation: return name diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py index 9baf15ddf4cda..4b074b58a3795 100644 --- a/ivy/functional/ivy/data_type.py +++ b/ivy/functional/ivy/data_type.py @@ -153,7 +153,7 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): continue is_frontend_fn = "frontend" in fn.__module__ is_backend_fn = "backend" in fn.__module__ and not is_frontend_fn - is_einops_fn = "einops" in fn.__name__ + is_einops_fn = hasattr(fn, "__name__") and "einops" in fn.__name__ if is_backend_fn: f_supported = get_fn(fn, False) if hasattr(fn, "partial_mixed_handler"): @@ -183,6 +183,7 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): if is_frontend_fn: frontends = { "jax_frontend": "ivy.functional.frontends.jax", + "jnp_frontend": "ivy.functional.frontends.jax.numpy", "np_frontend": "ivy.functional.frontends.numpy", "tf_frontend": "ivy.functional.frontends.tensorflow", "torch_frontend": "ivy.functional.frontends.torch", @@ -197,6 +198,10 @@ def _nested_get(f, base_set, merge_fn, get_fn, wrapper=set): if "(" in key: key = key.split("(")[0] frontend_module = ".".join(key.split(".")[:-1]) + if ( + frontend_module == "" + ): # single edge case: fn='frontend_outputs_to_ivy_arrays' + continue frontend_fl = {key: frontend_fn} res += list( _get_functions_from_string( diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index fbfbaa35ecb67..afdf6105b6e97 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -1169,7 +1169,7 @@ def _get_devices(fn: Callable, complement: bool = True) -> Tuple: is_backend_fn = "backend" in fn.__module__ is_frontend_fn = "frontend" in fn.__module__ - is_einops_fn = "einops" in fn.__name__ + is_einops_fn = hasattr(fn, "__name__") and "einops" in fn.__name__ if not is_backend_fn and not is_frontend_fn and not is_einops_fn: if complement: supported = set(all_devices).difference(supported) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index 4150033e2a5cf..c29a69563ae1b 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -3988,7 +3988,7 @@ def _get_devices_and_dtypes(fn, recurse=True, complement=True): is_frontend_fn = "frontend" in fn.__module__ is_backend_fn = "backend" in fn.__module__ and not is_frontend_fn - is_einops_fn = "einops" in fn.__name__ + is_einops_fn = hasattr(fn, "__name__") and "einops" in fn.__name__ if not is_backend_fn and not is_frontend_fn and not is_einops_fn: if complement: all_comb = _all_dnd_combinations() From 252047ce188c42c81bfbec3b1562e6789c7a3ed4 Mon Sep 17 00:00:00 2001 From: M Talha Khalil Date: Wed, 7 Feb 2024 15:47:19 +0500 Subject: [PATCH 747/978] feat: Add tensorflow GatherNd raw_ops (#27745) --- .../frontends/tensorflow/raw_ops.py | 5 +++ .../test_tensorflow/test_raw_ops.py | 36 +++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/raw_ops.py b/ivy/functional/frontends/tensorflow/raw_ops.py index 1db6e68e803af..89367fe724f53 100644 --- a/ivy/functional/frontends/tensorflow/raw_ops.py +++ b/ivy/functional/frontends/tensorflow/raw_ops.py @@ -619,6 +619,11 @@ def Gather(*, params, indices, validate_indices=None, name="Gather"): return ivy.gather(params, indices, axis=0, batch_dims=0) +@to_ivy_arrays_and_back +def GatherNd(*, params, indices, validate_indices=None, name="GatherNd"): + return ivy.gather_nd(params, indices, batch_dims=0) + + @to_ivy_arrays_and_back def Greater(*, x, y, name="Greater"): x, y = check_tensorflow_casting(x, y) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index 027d7b72c34db..62cdde61ce9df 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -2132,6 +2132,42 @@ def test_tensorflow_Gather( # NOQA ) +# GatherNd +@handle_frontend_test( + fn_tree="tensorflow.raw_ops.GatherNd", + params_indices_axis_batch_dims=helpers.array_indices_axis( + array_dtypes=helpers.get_dtypes("valid"), + indices_dtypes=["int64"], + min_num_dims=5, + max_num_dims=10, + min_dim_size=1, + max_dim_size=5, + indices_same_dims=False, + ), + test_with_out=st.just(False), +) +def test_tensorflow_GatherNd( + *, + params_indices_axis_batch_dims, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + input_dtypes, params, indices, axis, batch_dims = params_indices_axis_batch_dims + helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + params=params, + indices=indices, + ) + + # Greater @handle_frontend_test( fn_tree="tensorflow.raw_ops.Greater", From f6c11a704eeab2fc90edd66797086ca15f88d625 Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Wed, 7 Feb 2024 14:58:09 +0400 Subject: [PATCH 748/978] Revert "feat: Add tensorflow GatherNd raw_ops" (#28210) --- .../frontends/tensorflow/raw_ops.py | 5 --- .../test_tensorflow/test_raw_ops.py | 36 ------------------- 2 files changed, 41 deletions(-) diff --git a/ivy/functional/frontends/tensorflow/raw_ops.py b/ivy/functional/frontends/tensorflow/raw_ops.py index 89367fe724f53..1db6e68e803af 100644 --- a/ivy/functional/frontends/tensorflow/raw_ops.py +++ b/ivy/functional/frontends/tensorflow/raw_ops.py @@ -619,11 +619,6 @@ def Gather(*, params, indices, validate_indices=None, name="Gather"): return ivy.gather(params, indices, axis=0, batch_dims=0) -@to_ivy_arrays_and_back -def GatherNd(*, params, indices, validate_indices=None, name="GatherNd"): - return ivy.gather_nd(params, indices, batch_dims=0) - - @to_ivy_arrays_and_back def Greater(*, x, y, name="Greater"): x, y = check_tensorflow_casting(x, y) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index 62cdde61ce9df..027d7b72c34db 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -2132,42 +2132,6 @@ def test_tensorflow_Gather( # NOQA ) -# GatherNd -@handle_frontend_test( - fn_tree="tensorflow.raw_ops.GatherNd", - params_indices_axis_batch_dims=helpers.array_indices_axis( - array_dtypes=helpers.get_dtypes("valid"), - indices_dtypes=["int64"], - min_num_dims=5, - max_num_dims=10, - min_dim_size=1, - max_dim_size=5, - indices_same_dims=False, - ), - test_with_out=st.just(False), -) -def test_tensorflow_GatherNd( - *, - params_indices_axis_batch_dims, - frontend, - test_flags, - fn_tree, - backend_fw, - on_device, -): - input_dtypes, params, indices, axis, batch_dims = params_indices_axis_batch_dims - helpers.test_frontend_function( - input_dtypes=input_dtypes, - backend_to_test=backend_fw, - frontend=frontend, - test_flags=test_flags, - fn_tree=fn_tree, - on_device=on_device, - params=params, - indices=indices, - ) - - # Greater @handle_frontend_test( fn_tree="tensorflow.raw_ops.Greater", From 4b150d4cf0848961fdca53fef1ede5acb45678c4 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Wed, 7 Feb 2024 11:06:07 +0000 Subject: [PATCH 749/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 43e214b9d18ed..4c05da8755e00 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,6 +27,6 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze From b4defbc5fbe44da4af16be1441f6fa043578f00a Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 7 Feb 2024 11:07:22 +0000 Subject: [PATCH 750/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 4c05da8755e00..43e214b9d18ed 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,6 +27,6 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze From dc7be7ef23d20d7ce858bc4d41db93781a380bad Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Wed, 7 Feb 2024 14:02:28 +0000 Subject: [PATCH 751/978] fix: broadcasting issue in compositional set_item + added example to set_item test (#28181) --- ivy/functional/ivy/general.py | 10 ------ .../test_functional/test_core/test_general.py | 33 +++++++++++++++++-- 2 files changed, 31 insertions(+), 12 deletions(-) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index c29a69563ae1b..416619538d4ca 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -2931,16 +2931,6 @@ def _broadcast_to(input, target_shape): return ivy.reshape(input, target_shape) else: input = input if len(input.shape) else ivy.expand_dims(input, axis=0) - new_dims = () - i_i = len(input.shape) - 1 - for i_t in range(len(target_shape) - 1, -1, -1): - if len(input.shape) + len(new_dims) >= len(target_shape): - break - if i_i < 0 or target_shape[i_t] != input.shape[i_i]: - new_dims += (i_t,) - else: - i_i -= 1 - input = ivy.expand_dims(input, axis=new_dims) return ivy.broadcast_to(input, target_shape) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index e37e69b61ba1e..f213c90474c80 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -6,7 +6,7 @@ from types import SimpleNamespace import pytest -from hypothesis import given, assume, strategies as st +from hypothesis import given, assume, example, strategies as st import numpy as np from collections.abc import Sequence @@ -15,7 +15,11 @@ import ivy import ivy_tests.test_ivy.helpers as helpers -from ivy_tests.test_ivy.helpers import handle_test, BackendHandler +from ivy_tests.test_ivy.helpers import ( + handle_test, + BackendHandler, + test_parameter_flags as pf, +) from ivy_tests.test_ivy.helpers.assertions import assert_all_close from ivy_tests.test_ivy.test_functional.test_core.test_elementwise import pow_helper @@ -1643,6 +1647,31 @@ def test_set_inplace_mode(mode): container_flags=st.just([False]), test_with_copy=st.just(True), ) +@example( + dtypes_x_query_val=( + ["int32", "int32"], + np.ones((1, 3, 3, 3)), + (slice(None, None, None), slice(None, None, None), slice(None, None, None), 1), + np.zeros((3, 1)), + ), + copy=False, + fn_name="set_item", + test_flags=pf.FunctionTestFlags( + ground_truth_backend="numpy", + num_positional_args=3, + instance_method=False, + with_out=False, + with_copy=False, + test_gradients=False, + test_trace=False, + transpile=False, + as_variable=[False], + native_arrays=[False], + container=[False], + precision_mode=False, + test_cython_wrapper=False, + ), +) def test_set_item( dtypes_x_query_val, copy, From 4c1a7edd6a07cabb314b174100ba2fed8fd448fb Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Wed, 7 Feb 2024 22:00:09 +0500 Subject: [PATCH 752/978] (fix): added the `_asarray_to_native_arrays_and_back` attribute to the `ivy._asarray_to_native_arrays_and_back` decorator to be able to identify whether ivy.asarray has been decorated with the function --- ivy/functional/ivy/creation.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/ivy/creation.py b/ivy/functional/ivy/creation.py index b84c4c5277e96..5a837dcd93bcc 100644 --- a/ivy/functional/ivy/creation.py +++ b/ivy/functional/ivy/creation.py @@ -153,6 +153,7 @@ def _asarray_to_native_arrays_and_back_wrapper(*args, dtype=None, **kwargs): dtype = ivy.default_dtype(dtype=dtype, as_native=True) return to_ivy(fn(*new_args, dtype=dtype, **kwargs)) + _asarray_to_native_arrays_and_back_wrapper._asarray_to_native_arrays_and_back = True return _asarray_to_native_arrays_and_back_wrapper From 12647e96aa6b853983cd4addcdef19f2fda7a923 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Wed, 7 Feb 2024 21:37:05 +0000 Subject: [PATCH 753/978] fix(dev): Added a check to fix retrieving the correct device when running with tensorflow backend and in tf's graph mode --- ivy/functional/backends/tensorflow/device.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/tensorflow/device.py b/ivy/functional/backends/tensorflow/device.py index dd7c4cea4f6c9..6805d3013ca4b 100644 --- a/ivy/functional/backends/tensorflow/device.py +++ b/ivy/functional/backends/tensorflow/device.py @@ -34,6 +34,7 @@ def dev( dv = x.device if as_native: return dv + dv = dv if dv else ivy.default_device(as_native=False) return as_ivy_dev(dv) From b206d3edc2802f547d8f5502c29f37ac2c883d29 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Wed, 7 Feb 2024 21:41:09 +0000 Subject: [PATCH 754/978] fix(nn.Module): Replaced references to .built with ._built to avoid name clashes with the backend tf.keras.Model stateful subclassed module. Also modified the call method to deal with multiple inputs when called as a keras module --- ivy/functional/frontends/torch/nn/modules/module.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 75363c39f0548..7656ea87e970a 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -69,7 +69,7 @@ def _create_variables(self, device=None, dtype=None): def _build(self, *args, **kwargs): for module in self.__dict__.values(): if isinstance(module, Module) and module is not self: - if not module.built: + if not module._built: module.build( *module._args, dynamic_backend=module._dynamic_backend, @@ -108,7 +108,10 @@ def forward(self, *input: Any) -> None: ) def call(self, inputs, *args, training=None, mask=None, **kwargs): - return self.forward(inputs, *args, **kwargs) + if isinstance(inputs, (list, tuple)): + return self.forward(*inputs, *args, **kwargs) + else: + return self.forward(inputs, *args, **kwargs) def _forward(self, *a, **kw): ret = self._call_impl(*a, **kw) @@ -197,7 +200,7 @@ def parameters(self, recurse: bool = True) -> Iterator[Parameter]: def named_parameters( self, prefix: str = "", recurse: bool = True, remove_duplicate: bool = True ) -> Iterator[Tuple[str, Parameter]]: - if not getattr(self, "built", False): + if not getattr(self, "_built", False): self.build( *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs ) @@ -214,7 +217,7 @@ def children(self) -> Iterator["Module"]: yield module def named_children(self) -> Iterator[Tuple[str, "Module"]]: - if not getattr(self, "built", False): + if not getattr(self, "_built", False): self.build( *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs ) @@ -234,7 +237,7 @@ def named_modules( prefix: str = "", remove_duplicate: bool = True, ): - if not getattr(self, "built", False): + if not getattr(self, "_built", False): self.build( *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs ) From 74238fcd376d023406b13544b6763ce3cd876bba Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Wed, 7 Feb 2024 22:17:40 +0000 Subject: [PATCH 755/978] fix(tf.keras.Model): Added a _get_input_shapes helper func to retrieve the input shapes during model building. Also added a number of tf.autograph.experimental.do_not_convert decorators to avoid transforming the code for the custom Model subclass. Removed all references of _keras_built attribute and replaced all references of built with _built to prevent name clashes with parent Model class. --- ivy/functional/backends/tensorflow/module.py | 85 ++++++++++++++++---- 1 file changed, 71 insertions(+), 14 deletions(-) diff --git a/ivy/functional/backends/tensorflow/module.py b/ivy/functional/backends/tensorflow/module.py index c00046ce22e27..919f21b630924 100644 --- a/ivy/functional/backends/tensorflow/module.py +++ b/ivy/functional/backends/tensorflow/module.py @@ -1,6 +1,7 @@ # global from __future__ import annotations import re +import os import tensorflow as tf import functools import logging @@ -156,6 +157,7 @@ def tree_unflatten(values: List[Any], spec: TreeSpec) -> PyTree: class ModelHelpers: @staticmethod + @tf.autograph.experimental.do_not_convert def _get_first_array(*args, **kwargs): arr = None flattened_args = tf.nest.flatten((args, kwargs)) @@ -170,6 +172,21 @@ def _get_first_array(*args, **kwargs): return arr @staticmethod + @tf.autograph.experimental.do_not_convert + def _get_input_shapes(*args, **kwargs): + flattened_args = tf.nest.flatten((args, kwargs)) + arr_candidates = tf.nest.map_structure( + lambda x: x if isinstance(x, (tf.Tensor, tf.Variable)) else False, + flattened_args, + ) + input_shapes = [] + for arr_candidate in arr_candidates: + if arr_candidate is not False: + input_shapes.append(arr_candidate.shape) + return input_shapes + + @staticmethod + @tf.autograph.experimental.do_not_convert def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): if ModelHelpers._dict_has_key_chain(v, orig_key_chain): ret_cont = ModelHelpers._dict_at_key_chain(v, orig_key_chain) @@ -189,6 +206,7 @@ def _extract_v(v, keychain_mappings: dict, orig_key_chain, /): return ret_cont @staticmethod + @tf.autograph.experimental.do_not_convert def _remove_duplicate_variables(vs, created, /): created_ids = tf.nest.map_structure(lambda x: id(x), created) vs_ids = tf.nest.map_structure(lambda x: id(x), vs) @@ -221,6 +239,7 @@ def found_dup_callback(x, kc): return vs, keychain_mappings @staticmethod + @tf.autograph.experimental.do_not_convert def _dict_set_at_key_chain(in_dict, key_chain, val, inplace=False): keys = re.split("[/.]", key_chain) if inplace: @@ -236,6 +255,7 @@ def _dict_set_at_key_chain(in_dict, key_chain, val, inplace=False): return cont @staticmethod + @tf.autograph.experimental.do_not_convert def _dict_at_key_chain(dict, key_chain, ignore_key_errors=False): keys = re.split("[/.]", key_chain) ret = dict @@ -249,6 +269,7 @@ def _dict_at_key_chain(dict, key_chain, ignore_key_errors=False): return ret @staticmethod + @tf.autograph.experimental.do_not_convert def _dict_has_key_chain(dict, key_chain): keys = re.split("[/.]", key_chain) ret = dict @@ -260,6 +281,7 @@ def _dict_has_key_chain(dict, key_chain): return True @staticmethod + @tf.autograph.experimental.do_not_convert def _dict_prune_key_chain(in_dict, key_chain): keys_in_chain = re.split("[/.]", key_chain) out_dict = {} @@ -284,6 +306,7 @@ def _dict_prune_key_chain(in_dict, key_chain): return out_dict @staticmethod + @tf.autograph.experimental.do_not_convert def _addindent(s_, numSpaces): s = s_.split("\n") # don't do anything for single-line stuff @@ -301,7 +324,6 @@ class Model(tf.keras.Model, ModelHelpers): _with_partial_v = None _store_vars = True _built = False - _keras_built = False _v = None _buffers = None _module_dict = None @@ -338,7 +360,6 @@ def __init__( self._with_partial_v = with_partial_v self._store_vars = store_vars self._built = False - self._keras_built = False self._v_from_constructor = v if isinstance(v, dict) or v is None else dict(v) self._v = v if v is not None else dict() self._buffers = dict(buffers or {}) @@ -356,6 +377,7 @@ def __init__( return self.build(*args, dynamic_backend=dynamic_backend, **kwargs) + @tf.autograph.experimental.do_not_convert def _find_variables( self, /, @@ -370,7 +392,7 @@ def _find_variables( return vs _visited[id(obj)] = True if isinstance(obj, Model) and obj is not self: - if not obj.built and without_initialisation: + if not obj._built and without_initialisation: return lambda: obj._build_and_return_v( *obj._args, dynamic_backend=self._dynamic_backend, **obj._kwargs ) @@ -418,17 +440,20 @@ def _find_variables( vs[k[1:] if k[0] == "_" else k] = ret return vs + @tf.autograph.experimental.do_not_convert def _find_buffers(self): if hasattr(self, "_module_dict"): for key, sub_module in self._module_dict.items(): if len(sub_module._buffers) > 0: self._buffers[key] = sub_module._buffers + @tf.autograph.experimental.do_not_convert def _build_and_return_v(self, *args, **kwargs): if not self._built: self.build(*args, **kwargs) return self.v + @tf.autograph.experimental.do_not_convert def _assign_weights(self): model_weights = {} existing_ids = [id(w) for w in self.weights] @@ -474,6 +499,7 @@ def _sort_weights(model_weights, weights): if model_weights: self.set_weights(_sort_weights(model_weights, self.weights)) + @tf.autograph.experimental.do_not_convert def build( self, *args, @@ -547,6 +573,7 @@ def build( return v_ret if bool(v_ret) or isinstance(built, bool) else built + @tf.autograph.experimental.do_not_convert def _wrap_call_methods( self, keychain_mappings, /, *, key="", obj=None, _visited=None ): @@ -587,11 +614,11 @@ def _wrap_call_methods( ) return + @tf.autograph.experimental.do_not_convert def _call(self, *args, v=None, buffers=None, **kwargs): - if not self._built or not self._keras_built: - first_arr = self._get_first_array(*args, **kwargs) - + if not self._built or not self.built: if not self._built: + first_arr = self._get_first_array(*args, **kwargs) self.build( *args, **kwargs, @@ -599,11 +626,18 @@ def _call(self, *args, v=None, buffers=None, **kwargs): dtype=first_arr.dtype if first_arr is not None else tf.float32, ) - if not self._keras_built: - self.inputs = tf.nest.flatten(args) - super(Model, self).build( # noqa: UP008 - first_arr.shape if first_arr is not None else tf.TensorShape(None) - ) + if not self.built: + # Don't use `keras` build method + if os.environ.get("USE_KERAS_BUILD", "False").lower() == "false": + self.inputs = tf.nest.flatten(args) + + input_shapes = self._get_input_shapes(*args, **kwargs) + if len(input_shapes) == 0: + input_shapes = tf.TensorShape(None) + elif len(input_shapes) == 1: + input_shapes = input_shapes[0] + + super(Model, self).build(input_shapes) # noqa: UP008 # If `v` was provided, replace with the module's v replace_v = False @@ -630,6 +664,7 @@ def _call(self, *args, v=None, buffers=None, **kwargs): return self.__call__(*args, **kwargs) return super(Model, self).__call__(*args, **kwargs) # noqa: UP008 + @tf.autograph.experimental.do_not_convert def _rebuild(self): logging.warning( "Building the module again as a trainable module was modified, " @@ -640,6 +675,7 @@ def _rebuild(self): self._built = False self.build(*self._args, **self._kwargs) + @tf.autograph.experimental.do_not_convert def _compute_module_dict(self): self._module_dict = dict() for key, value in self.__dict__.items(): @@ -649,6 +685,7 @@ def _compute_module_dict(self): else: self._module_dict[key] = value._module_dict + @tf.autograph.experimental.do_not_convert def _fn_with_var_arg_wrapper( self, *a, fn, v_fn, keychain_mappings, orig_key_chain, **kw ): @@ -657,6 +694,7 @@ def _fn_with_var_arg_wrapper( v = v_fn(self.v, keychain_mappings, orig_key_chain) return fn(*a, **kw, v=v) + @tf.autograph.experimental.do_not_convert def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): _fn_with_var_arg_wrapper = functools.partial( self._fn_with_var_arg_wrapper, @@ -668,15 +706,18 @@ def _fn_with_var_arg(self, fn, v_fn, /, keychain_mappings, orig_key_chain): _fn_with_var_arg_wrapper.wrapped = True return _fn_with_var_arg_wrapper + @tf.autograph.experimental.do_not_convert def register_buffer(self, name: str, value: Union[tf.Tensor, tf.Variable]): if value is not None: self._buffers.update({name: value}) else: self.__setattr__(name, value) + @tf.autograph.experimental.do_not_convert def register_parameter(self, name: str, value: Union[tf.Tensor, tf.Variable]): self._v.update({name: value}) + @tf.autograph.experimental.do_not_convert def train(self, mode: bool = True): self._training = mode for module in self.children(): @@ -684,9 +725,11 @@ def train(self, mode: bool = True): self.trainable = mode return self + @tf.autograph.experimental.do_not_convert def eval(self): return self.train(mode=False) + @tf.autograph.experimental.do_not_convert def call(self, inputs, training=None, mask=None): raise NotImplementedError( "When subclassing the `Model` class, you should implement a `call` method." @@ -695,18 +738,22 @@ def call(self, inputs, training=None, mask=None): # Methods to be Optionally Overridden # # -----------------------------------# + @tf.autograph.experimental.do_not_convert def _create_variables(self, *, device=None, dtype=None): return {} + @tf.autograph.experimental.do_not_convert def _build(self, *args, **kwargs) -> bool: return True + @tf.autograph.experimental.do_not_convert def _forward(self, *args, **kwargs): raise NotImplementedError( "When subclassing the `Model` class, you should " "implement a `_forward` method." ) + @tf.autograph.experimental.do_not_convert def _extra_repr(self) -> str: return "" @@ -748,6 +795,7 @@ def module_dict(self): # Dunder Methods # # ---------------# + @tf.autograph.experimental.do_not_convert def __call__( self, *args, @@ -755,12 +803,18 @@ def __call__( buffers=None, **kwargs, ): + # TODO: Temp workaround to avoid `call`` from being transformed by AutoGraph + if not hasattr(self.__class__.call, "autograph_info__"): + setattr(self.__class__.call, "autograph_info__", True) ret = self._call(*args, v=v, buffers=buffers, **kwargs) return ret + @tf.autograph.experimental.do_not_convert def __getattr__(self, name): if name == "v": - if not super().__getattribute__("_v") and not getattr(self, "built", False): + if not super().__getattribute__("_v") and not getattr( # noqa: E501 + self, "_built", False + ): return self._build_and_return_v( *self._args, dynamic_backend=self._dynamic_backend, **self._kwargs ) @@ -774,6 +828,7 @@ def __getattr__(self, name): return super().__getattribute__(name) + @tf.autograph.experimental.do_not_convert def __setattr__(self, name, value): if name in ["v", "buffers"]: name = "_" + name @@ -782,7 +837,7 @@ def __setattr__(self, name, value): if ( hasattr(self, "_build_mode") and self.build_mode == "on_init" - and getattr(self, "built", False) + and getattr(self, "_built", False) ): self._rebuild() return ret @@ -791,12 +846,13 @@ def __setattr__(self, name, value): if ( hasattr(self, "_build_mode") and self.build_mode == "on_init" - and getattr(self, "built", False) + and getattr(self, "_built", False) ): self._rebuild() return ret return super().__setattr__(name, value) + @tf.autograph.experimental.do_not_convert def __delattr__(self, name): if hasattr(self, name): if isinstance(getattr(self, name), Model): @@ -806,6 +862,7 @@ def __delattr__(self, name): return super().__delattr__(name) + @tf.autograph.experimental.do_not_convert def __repr__(self): extra_lines = [] extra_repr = self._extra_repr() From 54e3f62a27207b17cb90f24cccb972ed9767c710 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Wed, 7 Feb 2024 22:19:39 +0000 Subject: [PATCH 756/978] fix(nn.Module): Temporarily add a try-except block in model.call to deal with multiple arguments when run as a keras model --- ivy/functional/frontends/torch/nn/modules/module.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/nn/modules/module.py b/ivy/functional/frontends/torch/nn/modules/module.py index 7656ea87e970a..e2c6059051fee 100644 --- a/ivy/functional/frontends/torch/nn/modules/module.py +++ b/ivy/functional/frontends/torch/nn/modules/module.py @@ -109,7 +109,10 @@ def forward(self, *input: Any) -> None: def call(self, inputs, *args, training=None, mask=None, **kwargs): if isinstance(inputs, (list, tuple)): - return self.forward(*inputs, *args, **kwargs) + try: + return self.forward(*inputs, *args, **kwargs) + except Exception: + return self.forward(inputs, *args, **kwargs) else: return self.forward(inputs, *args, **kwargs) From e39c260a790a031c2de94d6066acb7c5a2a15198 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 8 Feb 2024 13:09:14 +0530 Subject: [PATCH 757/978] feat: enabled backend_compile=True in the tracer tests --- ivy_tests/test_ivy/helpers/function_testing.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 11694dce9920d..2974d9407928b 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -49,7 +49,7 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non ): t_globals.CURRENT_TRACED_DATA[ t_globals.CURRENT_RUNNING_TEST.fn_name - ][backend] = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs) + ][backend] = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs, backend_compile=True) elif ( t_globals.CURRENT_RUNNING_TEST.fn_name not in t_globals.CURRENT_TRACED_DATA @@ -59,7 +59,7 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non ] = {} t_globals.CURRENT_TRACED_DATA[ t_globals.CURRENT_RUNNING_TEST.fn_name - ][backend] = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs) + ][backend] = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs, backend_compile=True) fn = t_globals.CURRENT_TRACED_DATA[ t_globals.CURRENT_RUNNING_TEST.fn_name ][backend] From 417394522ecf324fadb6db979bfb1c08ef09f5a1 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 8 Feb 2024 07:40:31 +0000 Subject: [PATCH 758/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy_tests/test_ivy/helpers/function_testing.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 2974d9407928b..3f0e31a0932f3 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -49,7 +49,9 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non ): t_globals.CURRENT_TRACED_DATA[ t_globals.CURRENT_RUNNING_TEST.fn_name - ][backend] = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs, backend_compile=True) + ][backend] = ivy_backend.trace_graph( + fn, args=args, kwargs=kwargs, backend_compile=True + ) elif ( t_globals.CURRENT_RUNNING_TEST.fn_name not in t_globals.CURRENT_TRACED_DATA @@ -59,7 +61,9 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non ] = {} t_globals.CURRENT_TRACED_DATA[ t_globals.CURRENT_RUNNING_TEST.fn_name - ][backend] = ivy_backend.trace_graph(fn, args=args, kwargs=kwargs, backend_compile=True) + ][backend] = ivy_backend.trace_graph( + fn, args=args, kwargs=kwargs, backend_compile=True + ) fn = t_globals.CURRENT_TRACED_DATA[ t_globals.CURRENT_RUNNING_TEST.fn_name ][backend] From 4dee494e6fea445253ebc4224b29705ea91e04df Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 8 Feb 2024 15:26:40 +0000 Subject: [PATCH 759/978] fix: ensure correct offsets dtype and rank for ivy gather call in nearest interpolate function torch requires int64 for indices and the indices need to be same rank as x. --- ivy/functional/ivy/experimental/layers.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index bf7ad024f9ae4..27974eeb898f7 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1473,7 +1473,11 @@ def nearest_interpolate(x, dims, size, scale, exact): for d in range(dims): n = size[d] offsets = (ivy.arange(n, dtype="float32") + off) * scale[d] - offsets = ivy.astype(ivy.floor(ivy.astype(offsets, "float32")), "int32") + offsets = ivy.astype(ivy.floor(ivy.astype(offsets, "float32")), "int64") + num_dims_to_add = x.ndim - offsets.ndim + if num_dims_to_add > 0: + for _ in range(num_dims_to_add): + offsets = ivy.expand_dims(offsets, axis=0) x = ivy.gather(x, offsets, axis=d + 2) return x From d38a31205e7e130bc17139a6145c3eed7ab130c1 Mon Sep 17 00:00:00 2001 From: Suyash Gupta Date: Fri, 9 Feb 2024 02:22:16 +0530 Subject: [PATCH 760/978] fix: Fix Ivy Failing Test: paddle - elementwise.multiply (#28056) fixed ivy.multiply --- ivy/functional/backends/paddle/elementwise.py | 28 ++++++++++--------- .../test_core/test_elementwise.py | 9 ++++-- 2 files changed, 21 insertions(+), 16 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 408e841b0475c..48763d3bdf157 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -1,15 +1,16 @@ # global -from typing import Union, Optional - import math +from typing import Optional, Union + import paddle -import ivy.functional.backends.paddle as paddle_backend + import ivy +import ivy.functional.backends.paddle as paddle_backend from ivy import promote_types_of_inputs from ivy.func_wrapper import ( - with_unsupported_device_and_dtypes, with_supported_device_and_dtypes, with_supported_dtypes, + with_unsupported_device_and_dtypes, with_unsupported_dtypes, ) @@ -340,15 +341,8 @@ def less( return paddle.less_than(x1, x2) -@with_unsupported_dtypes( - { - "2.6.0 and below": ( - "int8", - "int16", - "uint8", - "float16", - ) - }, +@with_supported_dtypes( + {"2.6.0 and below": ("bool", "int32", "int64", "float32", "float64", "complex")}, backend_version, ) def multiply( @@ -359,6 +353,14 @@ def multiply( out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) + if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): + if paddle.is_complex(x1) or paddle.is_complex(x2): + a, b = x1.real(), x1.imag() + c, d = x2.real(), x2.imag() + real = a * c - b * d + imag = a * d + b * c + return paddle.complex(real, imag) + return paddle.multiply(x1, x2).astype(ret_dtype) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index b7d461e0607f5..18dc1cc661344 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -2,15 +2,17 @@ # global import math + import numpy as np -from hypothesis import assume, strategies as st +from hypothesis import assume +from hypothesis import strategies as st # local import ivy import ivy_tests.test_ivy.helpers as helpers +import ivy_tests.test_ivy.helpers.globals as test_globals from ivy_tests.test_ivy.helpers import handle_test from ivy_tests.test_ivy.helpers.pipeline_helper import BackendHandler -import ivy_tests.test_ivy.helpers.globals as test_globals _one = np.asarray(1, dtype="uint8") _zero = np.asarray(0, dtype="uint8") @@ -1483,8 +1485,9 @@ def test_minimum( @handle_test( fn_tree="functional.ivy.multiply", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2 + available_dtypes=helpers.get_dtypes("valid"), num_arrays=2 ), + ground_truth_backend="torch", ) def test_multiply(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): input_dtype, x = dtype_and_x From c60b3a2098e1e5cabf8d720cfd5a87dcb7b59b2f Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Fri, 9 Feb 2024 03:36:01 +0000 Subject: [PATCH 761/978] fix: allow torch backend split to infer final split size (#28230) --- ivy/functional/backends/torch/manipulation.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/functional/backends/torch/manipulation.py b/ivy/functional/backends/torch/manipulation.py index 3e18e83eb33c9..c124e3aab9a38 100644 --- a/ivy/functional/backends/torch/manipulation.py +++ b/ivy/functional/backends/torch/manipulation.py @@ -241,6 +241,10 @@ def split( torch.tensor(dim_size) / torch.tensor(num_or_size_splits) ) elif isinstance(num_or_size_splits, list): + if num_or_size_splits[-1] == -1: + # infer the final size split + remaining_size = dim_size - sum(num_or_size_splits[:-1]) + num_or_size_splits[-1] = remaining_size num_or_size_splits = tuple(num_or_size_splits) return list(torch.split(x, num_or_size_splits, axis)) From 81a0371922ebb18b740ec476c1c690f4185b4261 Mon Sep 17 00:00:00 2001 From: Deeptendu Santra <55111154+Dsantra92@users.noreply.github.com> Date: Thu, 8 Feb 2024 21:26:15 -0800 Subject: [PATCH 762/978] Fix the reduce method for Ivy Shape (#28212) --- ivy/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 1a074aec61900..52d73cf067b33 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -312,7 +312,7 @@ def __rmod__(self, other): return other % self._shape def __reduce__(self): - return (self._shape,) + return (self.__class__, (self._shape,)) def as_dimension(self, other): if isinstance(other, self._shape): From 9789ea5392d9585d65acfa308a9907fb50a120d5 Mon Sep 17 00:00:00 2001 From: Felix Hirwa Nshuti Date: Fri, 9 Feb 2024 14:57:02 +0530 Subject: [PATCH 763/978] fix: `Shape.__bool__` method tests (#28218) --- ivy/__init__.py | 2 +- ivy_tests/test_ivy/test_misc/test_shape.py | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 52d73cf067b33..1e828280504d4 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -294,7 +294,7 @@ def __rmul__(self, other): return self def __bool__(self): - return self._shape.__bool__() + return self._shape[0].__bool__() def __div__(self, other): return self._shape // other diff --git a/ivy_tests/test_ivy/test_misc/test_shape.py b/ivy_tests/test_ivy/test_misc/test_shape.py index f20c34bb3a386..e7ce71505161a 100644 --- a/ivy_tests/test_ivy/test_misc/test_shape.py +++ b/ivy_tests/test_ivy/test_misc/test_shape.py @@ -5,6 +5,8 @@ from ivy_tests.test_ivy.helpers import handle_method +CLASS_TREE = "ivy.Shape" + @handle_method( method_tree="Shape.__add__", @@ -44,6 +46,7 @@ def test_shape__add__( @handle_method( + init_tree=CLASS_TREE, method_tree="Shape.__bool__", dtype_and_x=helpers.dtype_and_values( available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), @@ -69,7 +72,7 @@ def test_shape__bool__( backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, - init_all_as_kwargs_np={"data": x[0]}, + init_all_as_kwargs_np={"shape_tup": (x[0],)}, init_input_dtypes=dtype, method_input_dtypes=[], method_all_as_kwargs_np={}, From cd17340715138feed4852198127d23256192e971 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 9 Feb 2024 15:32:04 +0530 Subject: [PATCH 764/978] fix: added a reverse check to check_tensorflow_casting in the tensorflow frontend to deal with the first argument being a scalar --- ivy/functional/frontends/tensorflow/__init__.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/__init__.py b/ivy/functional/frontends/tensorflow/__init__.py index fb8077c3672b7..1a82bd751722d 100644 --- a/ivy/functional/frontends/tensorflow/__init__.py +++ b/ivy/functional/frontends/tensorflow/__init__.py @@ -74,6 +74,9 @@ def check_tensorflow_casting(x1, x2): if hasattr(x1, "dtype") and not hasattr(x2, "dtype"): x1 = ivy.asarray(x1) x2 = ivy.asarray(x2, dtype=x1.dtype) + elif hasattr(x2, "dtype") and not hasattr(x1, "dtype"): + x2 = ivy.asarray(x2) + x1 = ivy.asarray(x1, dtype=x2.dtype) else: x1 = ivy.asarray(x1) if not hasattr(x2, "dtype"): From e845510825b31bfff91cbaeaec5464b643bf6726 Mon Sep 17 00:00:00 2001 From: Felix Hirwa Nshuti Date: Fri, 9 Feb 2024 15:37:50 +0530 Subject: [PATCH 765/978] Revert "fix: `Shape.__bool__` method tests" (#28231) --- ivy/__init__.py | 2 +- ivy_tests/test_ivy/test_misc/test_shape.py | 5 +---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 1e828280504d4..52d73cf067b33 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -294,7 +294,7 @@ def __rmul__(self, other): return self def __bool__(self): - return self._shape[0].__bool__() + return self._shape.__bool__() def __div__(self, other): return self._shape // other diff --git a/ivy_tests/test_ivy/test_misc/test_shape.py b/ivy_tests/test_ivy/test_misc/test_shape.py index e7ce71505161a..f20c34bb3a386 100644 --- a/ivy_tests/test_ivy/test_misc/test_shape.py +++ b/ivy_tests/test_ivy/test_misc/test_shape.py @@ -5,8 +5,6 @@ from ivy_tests.test_ivy.helpers import handle_method -CLASS_TREE = "ivy.Shape" - @handle_method( method_tree="Shape.__add__", @@ -46,7 +44,6 @@ def test_shape__add__( @handle_method( - init_tree=CLASS_TREE, method_tree="Shape.__bool__", dtype_and_x=helpers.dtype_and_values( available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), @@ -72,7 +69,7 @@ def test_shape__bool__( backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, - init_all_as_kwargs_np={"shape_tup": (x[0],)}, + init_all_as_kwargs_np={"data": x[0]}, init_input_dtypes=dtype, method_input_dtypes=[], method_all_as_kwargs_np={}, From 47926c6c266d0f5cda848043905227f80284e310 Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Fri, 9 Feb 2024 10:53:19 +0000 Subject: [PATCH 766/978] fix: use of ivy.Shape in conditions (#28224) --- ivy/__init__.py | 2 +- ivy_tests/test_ivy/test_misc/test_shape.py | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 52d73cf067b33..5e0cfbfd48cc6 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -294,7 +294,7 @@ def __rmul__(self, other): return self def __bool__(self): - return self._shape.__bool__() + return builtins.bool(self._shape) def __div__(self, other): return self._shape // other diff --git a/ivy_tests/test_ivy/test_misc/test_shape.py b/ivy_tests/test_ivy/test_misc/test_shape.py index f20c34bb3a386..6fe8a1e8c4355 100644 --- a/ivy_tests/test_ivy/test_misc/test_shape.py +++ b/ivy_tests/test_ivy/test_misc/test_shape.py @@ -1,6 +1,7 @@ from hypothesis import assume, strategies as st import numpy as np +import ivy import ivy_tests.test_ivy.helpers as helpers from ivy_tests.test_ivy.helpers import handle_method @@ -682,3 +683,13 @@ def test_shape__sub__( class_name=class_name, method_name=method_name, ) + + +def test_shape_in_conditions(): + shape = ivy.Shape((1, 2)) + condition_is_true = True if shape else False + assert condition_is_true + + shape = ivy.Shape(()) + condition_is_true = True if shape else False + assert not condition_is_true From 568de6b6984f9110c4e1726561a8e43e4e0f6a7e Mon Sep 17 00:00:00 2001 From: Lyngkhoi <78148524+fleventy-5@users.noreply.github.com> Date: Sat, 10 Feb 2024 11:23:10 +0530 Subject: [PATCH 767/978] fix(torch-frontend): fix failing test for miscellaneous_ops.torch.clone (#28202) --- ivy_tests/test_ivy/helpers/function_testing.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 3f0e31a0932f3..0914fe641c0e2 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -987,6 +987,11 @@ def test_frontend_function( ret_ = ret_.data if hasattr(first_array, "requires_grad"): first_array = first_array.detach() + if hasattr(ret_, "requires_grad"): + ret_ = ret_.detach() + if backend_to_test == "tensorflow": + first_array = first_array.numpy() + ret_ = ret_.numpy() assert not np.may_share_memory(first_array, ret_) elif test_flags.inplace: assert _is_frontend_array(ret) From 2bff09c6ffe630d072589a4061f393b47edfadde Mon Sep 17 00:00:00 2001 From: Deeptendu Santra <55111154+Dsantra92@users.noreply.github.com> Date: Fri, 9 Feb 2024 23:02:13 -0800 Subject: [PATCH 768/978] add __reduce__ method to IvyGlobalProps (#28234) Co-authored-by: ivy-branch --- ivy/__init__.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/ivy/__init__.py b/ivy/__init__.py index 5e0cfbfd48cc6..a3ec566d6609e 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -7,6 +7,7 @@ import numpy as np import sys import inspect +import importlib import os from collections.abc import Sequence @@ -1540,6 +1541,14 @@ def __setattr__(self, name, value, internal=False): ) self.__dict__[name] = value + def __reduce__(self): + def _get_module_and_replace_name(module_name: str): + module = importlib.import_module(module_name) + module.__class__ = self.__class__ + return module + + return (_get_module_and_replace_name, (self.__name__,)) + if ( "ivy" in sys.modules From 24bd1ce21b7d870403a4fb77c734db3cf3f48b19 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Sat, 10 Feb 2024 04:25:56 -0800 Subject: [PATCH 769/978] fix: Ivy Failing Test: paddle - creation.ones_like (#28188) --- ivy/functional/backends/paddle/creation.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index f4411ff0ba279..e3b802febecae 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -11,6 +11,7 @@ import ivy from ivy.func_wrapper import ( with_unsupported_device_and_dtypes, + with_supported_device_and_dtypes, ) from ivy.functional.ivy.creation import ( _asarray_to_native_arrays_and_back, @@ -471,6 +472,22 @@ def ones( return paddle.ones(shape=shape).cast(dtype) +@with_supported_device_and_dtypes( + { + "2.6.0 and below": { + "cpu": ( + "int32", + "int64", + "float64", + "float32", + "complex128", + "complex64", + "bool", + ) + } + }, + backend_version, +) def ones_like( x: paddle.Tensor, /, From 1603886ddbf13759ff340d1dfe2447d1f8a8d4e2 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sat, 10 Feb 2024 18:50:13 +0530 Subject: [PATCH 770/978] feat: Updated `jax` version mapping from `0.4.23` to `0.4.24` (#28237) --- ivy/functional/backends/jax/__init__.py | 24 ++++---- ivy/functional/backends/jax/elementwise.py | 40 ++++++------- .../backends/jax/experimental/elementwise.py | 2 +- .../backends/jax/experimental/layers.py | 6 +- .../backends/jax/experimental/random.py | 2 +- .../backends/jax/experimental/sorting.py | 2 +- .../backends/jax/experimental/statistical.py | 6 +- ivy/functional/backends/jax/general.py | 4 +- ivy/functional/backends/jax/linear_algebra.py | 56 +++++++++---------- ivy/functional/backends/jax/manipulation.py | 2 +- ivy/functional/backends/jax/random.py | 2 +- ivy/functional/backends/jax/searching.py | 4 +- ivy/functional/backends/jax/sorting.py | 2 +- ivy/functional/backends/jax/statistical.py | 6 +- ivy/functional/frontends/__init__.py | 2 +- ivy/functional/frontends/jax/lax/operators.py | 8 +-- .../jax/nn/non_linear_activations.py | 2 +- .../frontends/jax/numpy/creation.py | 6 +- ivy/functional/frontends/jax/numpy/linalg.py | 4 +- ivy/functional/frontends/jax/numpy/logic.py | 4 +- .../jax/numpy/mathematical_functions.py | 12 ++-- .../frontends/jax/numpy/searching_sorting.py | 4 +- .../frontends/jax/numpy/statistical.py | 6 +- ivy/functional/frontends/jax/random.py | 32 +++++------ 24 files changed, 119 insertions(+), 119 deletions(-) diff --git a/ivy/functional/backends/jax/__init__.py b/ivy/functional/backends/jax/__init__.py index 33d48e0bfc5cc..6168ec1b4ac84 100644 --- a/ivy/functional/backends/jax/__init__.py +++ b/ivy/functional/backends/jax/__init__.py @@ -102,7 +102,7 @@ def _array_unflatten(aux_data, children): # update these to add new dtypes valid_dtypes = { - "0.4.23 and below": ( + "0.4.24 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -121,7 +121,7 @@ def _array_unflatten(aux_data, children): ) } valid_numeric_dtypes = { - "0.4.23 and below": ( + "0.4.24 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -140,7 +140,7 @@ def _array_unflatten(aux_data, children): } valid_int_dtypes = { - "0.4.23 and below": ( + "0.4.24 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -153,12 +153,12 @@ def _array_unflatten(aux_data, children): } valid_uint_dtypes = { - "0.4.23 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) + "0.4.24 and below": (ivy.uint8, ivy.uint16, ivy.uint32, ivy.uint64) } valid_float_dtypes = { - "0.4.23 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) + "0.4.24 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) } -valid_complex_dtypes = {"0.4.23 and below": (ivy.complex64, ivy.complex128)} +valid_complex_dtypes = {"0.4.24 and below": (ivy.complex64, ivy.complex128)} # leave these untouched @@ -173,12 +173,12 @@ def _array_unflatten(aux_data, children): # invalid data types # update these to add new dtypes -invalid_dtypes = {"0.4.23 and below": ()} -invalid_numeric_dtypes = {"0.4.23 and below": ()} -invalid_int_dtypes = {"0.4.23 and below": ()} -invalid_float_dtypes = {"0.4.23 and below": ()} -invalid_uint_dtypes = {"0.4.23 and below": ()} -invalid_complex_dtypes = {"0.4.23 and below": ()} +invalid_dtypes = {"0.4.24 and below": ()} +invalid_numeric_dtypes = {"0.4.24 and below": ()} +invalid_int_dtypes = {"0.4.24 and below": ()} +invalid_float_dtypes = {"0.4.24 and below": ()} +invalid_uint_dtypes = {"0.4.24 and below": ()} +invalid_complex_dtypes = {"0.4.24 and below": ()} # leave these untouched invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) diff --git a/ivy/functional/backends/jax/elementwise.py b/ivy/functional/backends/jax/elementwise.py index c4a84e65d9048..dc2089baf89ec 100644 --- a/ivy/functional/backends/jax/elementwise.py +++ b/ivy/functional/backends/jax/elementwise.py @@ -28,7 +28,7 @@ def abs( return jnp.where(x != 0, jnp.absolute(x), 0) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def acos(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arccos(x) @@ -52,12 +52,12 @@ def add( return jnp.add(x1, x2) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def asin(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arcsin(x) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def asinh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arcsinh(x) @@ -71,12 +71,12 @@ def atan2(x1: JaxArray, x2: JaxArray, /, *, out: Optional[JaxArray] = None) -> J return jnp.arctan2(x1, x2) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def atanh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.arctanh(x) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def bitwise_and( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -88,14 +88,14 @@ def bitwise_and( return jnp.bitwise_and(x1, x2) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def bitwise_invert( x: Union[int, JaxArray], /, *, out: Optional[JaxArray] = None ) -> JaxArray: return jnp.bitwise_not(x) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def bitwise_left_shift( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -107,7 +107,7 @@ def bitwise_left_shift( return jnp.left_shift(x1, x2) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def bitwise_or( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -119,7 +119,7 @@ def bitwise_or( return jnp.bitwise_or(x1, x2) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def bitwise_right_shift( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -131,7 +131,7 @@ def bitwise_right_shift( return jnp.right_shift(x1, x2) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def bitwise_xor( x1: Union[int, JaxArray], x2: Union[int, JaxArray], @@ -143,7 +143,7 @@ def bitwise_xor( return jnp.bitwise_xor(x1, x2) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def ceil(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -155,7 +155,7 @@ def cos(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.cos(x) -@with_unsupported_dtypes({"0.4.23 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("float16",)}, backend_version) def cosh(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.cosh(x) @@ -195,7 +195,7 @@ def expm1(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.expm1(x) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def floor(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -203,7 +203,7 @@ def floor(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.floor(x) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def floor_divide( x1: Union[float, JaxArray], x2: Union[float, JaxArray], @@ -251,7 +251,7 @@ def isfinite(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.isfinite(x) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def isinf( x: JaxArray, /, @@ -432,7 +432,7 @@ def pow( return jnp.power(x1, x2) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def remainder( x1: Union[float, JaxArray], x2: Union[float, JaxArray], @@ -520,7 +520,7 @@ def trapz( @with_unsupported_dtypes( - {"0.4.23 and below": ("complex", "float16", "bfloat16")}, backend_version + {"0.4.24 and below": ("complex", "float16", "bfloat16")}, backend_version ) def tan(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.tan(x) @@ -532,7 +532,7 @@ def tanh( return jnp.tanh(x) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def trunc(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: if "int" in str(x.dtype): return x @@ -572,7 +572,7 @@ def angle( # ------# -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def erf(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jax.scipy.special.erf(x) @@ -623,7 +623,7 @@ def isreal(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.isreal(x) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def fmod( x1: JaxArray, x2: JaxArray, diff --git a/ivy/functional/backends/jax/experimental/elementwise.py b/ivy/functional/backends/jax/experimental/elementwise.py index 363bc6a658213..8ea92a5094b85 100644 --- a/ivy/functional/backends/jax/experimental/elementwise.py +++ b/ivy/functional/backends/jax/experimental/elementwise.py @@ -50,7 +50,7 @@ def sinc(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: @with_supported_dtypes( - {"0.4.23 and below": ("float16", "float32", "float64")}, backend_version + {"0.4.24 and below": ("float16", "float32", "float64")}, backend_version ) def lgamma(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jlax.lgamma(x) diff --git a/ivy/functional/backends/jax/experimental/layers.py b/ivy/functional/backends/jax/experimental/layers.py index 3b66486a28dfe..335b0745e2ce2 100644 --- a/ivy/functional/backends/jax/experimental/layers.py +++ b/ivy/functional/backends/jax/experimental/layers.py @@ -440,7 +440,7 @@ def avg_pool3d( return res -@with_supported_dtypes({"0.4.23 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"0.4.24 and below": ("float32", "float64")}, backend_version) def dct( x: JaxArray, /, @@ -822,7 +822,7 @@ def ifftn( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, backend_version + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version ) def embedding( weights: JaxArray, @@ -870,7 +870,7 @@ def rfft( return ret -@with_unsupported_dtypes({"0.4.23 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("float16", "complex")}, backend_version) def rfftn( x: JaxArray, s: Optional[Sequence[int]] = None, diff --git a/ivy/functional/backends/jax/experimental/random.py b/ivy/functional/backends/jax/experimental/random.py index 19093eda961ea..9dc36ed0fb3bb 100644 --- a/ivy/functional/backends/jax/experimental/random.py +++ b/ivy/functional/backends/jax/experimental/random.py @@ -56,7 +56,7 @@ def beta( return jax.random.beta(rng_input, a, b, shape, dtype) -@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("bfloat16",)}, backend_version) def gamma( alpha: Union[float, JaxArray], beta: Union[float, JaxArray], diff --git a/ivy/functional/backends/jax/experimental/sorting.py b/ivy/functional/backends/jax/experimental/sorting.py index c73727cc612c7..b6255d7919ef3 100644 --- a/ivy/functional/backends/jax/experimental/sorting.py +++ b/ivy/functional/backends/jax/experimental/sorting.py @@ -23,7 +23,7 @@ def invert_permutation( # lexsort -@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("bfloat16",)}, backend_version) def lexsort( keys: JaxArray, /, diff --git a/ivy/functional/backends/jax/experimental/statistical.py b/ivy/functional/backends/jax/experimental/statistical.py index c2ac4780dcee9..0f67e8c5e7c28 100644 --- a/ivy/functional/backends/jax/experimental/statistical.py +++ b/ivy/functional/backends/jax/experimental/statistical.py @@ -10,7 +10,7 @@ @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16",)}, + {"0.4.24 and below": ("bfloat16",)}, backend_version, ) def histogram( @@ -121,7 +121,7 @@ def histogram( @with_unsupported_dtypes( - {"0.4.23 and below": ("complex64", "complex128")}, backend_version + {"0.4.24 and below": ("complex64", "complex128")}, backend_version ) def median( input: JaxArray, @@ -406,7 +406,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "bfloat16", "bool", ) diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index 2b1cd31da7661..7bed7585f613b 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -103,7 +103,7 @@ def array_equal(x0: JaxArray, x1: JaxArray, /) -> bool: return bool(jnp.array_equal(x0, x1)) -@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("bfloat16",)}, backend_version) def to_numpy(x: JaxArray, /, *, copy: bool = True) -> np.ndarray: if copy: return np.array(_to_array(x)) @@ -422,7 +422,7 @@ def vmap( ) -@with_unsupported_dtypes({"0.4.23 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("float16", "bfloat16")}, backend_version) def isin( elements: JaxArray, test_elements: JaxArray, diff --git a/ivy/functional/backends/jax/linear_algebra.py b/ivy/functional/backends/jax/linear_algebra.py index 70cfd1c32047d..8d6660109a08e 100644 --- a/ivy/functional/backends/jax/linear_algebra.py +++ b/ivy/functional/backends/jax/linear_algebra.py @@ -20,7 +20,7 @@ @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def cholesky( @@ -34,7 +34,7 @@ def cholesky( return ret -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def cross( x1: JaxArray, x2: JaxArray, @@ -51,14 +51,14 @@ def cross( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def det(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.linalg.det(x) -@with_unsupported_dtypes({"0.4.23 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("float16", "bfloat16")}, backend_version) def eig(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> Tuple[JaxArray]: result_tuple = NamedTuple( "eig", [("eigenvalues", JaxArray), ("eigenvectors", JaxArray)] @@ -67,7 +67,7 @@ def eig(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> Tuple[JaxArray]: return result_tuple(eigenvalues, eigenvectors) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def diagonal( x: JaxArray, /, @@ -104,7 +104,7 @@ def tensorsolve( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def eigh( @@ -118,7 +118,7 @@ def eigh( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def eigvalsh( @@ -127,14 +127,14 @@ def eigvalsh( return jnp.linalg.eigvalsh(x, UPLO=UPLO) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def inner(x1: JaxArray, x2: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: x1, x2 = ivy.promote_types_of_inputs(x1, x2) return jnp.inner(x1, x2) @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def inv( @@ -155,7 +155,7 @@ def inv( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matmul( @@ -181,7 +181,7 @@ def matmul( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matrix_norm( @@ -202,13 +202,13 @@ def matrix_norm( return jnp.linalg.norm(x, ord=ord, axis=axis, keepdims=keepdims) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def matrix_power(x: JaxArray, n: int, /, *, out: Optional[JaxArray] = None) -> JaxArray: return jnp.linalg.matrix_power(x, n) @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def matrix_rank( @@ -239,7 +239,7 @@ def matrix_rank( @with_unsupported_dtypes( - {"0.4.23 and below": ("int", "float16", "complex")}, + {"0.4.24 and below": ("int", "float16", "complex")}, backend_version, ) def matrix_transpose( @@ -251,7 +251,7 @@ def matrix_transpose( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def outer( @@ -266,7 +266,7 @@ def outer( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def pinv( @@ -284,7 +284,7 @@ def pinv( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def qr( @@ -296,7 +296,7 @@ def qr( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def slogdet( @@ -309,7 +309,7 @@ def slogdet( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def solve( @@ -351,7 +351,7 @@ def solve( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svd( @@ -368,7 +368,7 @@ def svd( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def svdvals( @@ -378,7 +378,7 @@ def svdvals( return jnp.linalg.svd(x, compute_uv=False) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def tensordot( x1: JaxArray, x2: JaxArray, @@ -392,7 +392,7 @@ def tensordot( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def trace( @@ -407,7 +407,7 @@ def trace( return jnp.trace(x, offset=offset, axis1=axis1, axis2=axis2, out=out) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def vecdot( x1: JaxArray, x2: JaxArray, /, *, axis: int = -1, out: Optional[JaxArray] = None ) -> JaxArray: @@ -415,7 +415,7 @@ def vecdot( return jnp.tensordot(x1, x2, axes=(axis, axis)) -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def vector_norm( x: JaxArray, /, @@ -445,7 +445,7 @@ def vector_norm( # ------# -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def diag( x: JaxArray, /, @@ -457,7 +457,7 @@ def diag( @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "complex")}, + {"0.4.24 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def vander( @@ -473,7 +473,7 @@ def vander( @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/jax/manipulation.py b/ivy/functional/backends/jax/manipulation.py index 30b6f2d9d7055..360333e8a186c 100644 --- a/ivy/functional/backends/jax/manipulation.py +++ b/ivy/functional/backends/jax/manipulation.py @@ -226,7 +226,7 @@ def clip( return x -@with_unsupported_dtypes({"0.4.23 and below": ("uint64",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("uint64",)}, backend_version) def constant_pad( x: JaxArray, /, diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index c2e98759fe2c4..4422cec77481f 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -83,7 +83,7 @@ def random_normal( return jax.random.normal(rng_input, shape, dtype=dtype) * std + mean -@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/jax/searching.py b/ivy/functional/backends/jax/searching.py index 2e2a321aa26fb..b149e64cc38d1 100644 --- a/ivy/functional/backends/jax/searching.py +++ b/ivy/functional/backends/jax/searching.py @@ -12,7 +12,7 @@ # ------------------ # -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def argmax( x: JaxArray, /, @@ -38,7 +38,7 @@ def argmax( return ret -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def argmin( x: JaxArray, /, diff --git a/ivy/functional/backends/jax/sorting.py b/ivy/functional/backends/jax/sorting.py index fde2f9e9910df..acee3f979316d 100644 --- a/ivy/functional/backends/jax/sorting.py +++ b/ivy/functional/backends/jax/sorting.py @@ -78,7 +78,7 @@ def searchsorted( # msort -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, backend_version) def msort( a: Union[JaxArray, list, tuple], /, diff --git a/ivy/functional/backends/jax/statistical.py b/ivy/functional/backends/jax/statistical.py index d03e9411f2561..b9e0610698256 100644 --- a/ivy/functional/backends/jax/statistical.py +++ b/ivy/functional/backends/jax/statistical.py @@ -42,7 +42,7 @@ def max( @with_unsupported_dtypes( - {"0.4.23 and below": "bfloat16"}, + {"0.4.24 and below": "bfloat16"}, backend_version, ) def mean( @@ -147,7 +147,7 @@ def var( # ------# -@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16", "bool")}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": ("bfloat16", "bool")}, backend_version) def cumprod( x: JaxArray, /, @@ -183,7 +183,7 @@ def cumprod( return jnp.flip(x, axis=axis) -@with_unsupported_dtypes({"0.4.23 and below": "bool"}, backend_version) +@with_unsupported_dtypes({"0.4.24 and below": "bool"}, backend_version) def cumsum( x: JaxArray, axis: int = 0, diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 4ae0d2ddfa489..841453cc1aeae 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -5,7 +5,7 @@ "torch": "2.1.2", "tensorflow": "2.15.0", "numpy": "1.25.2", - "jax": "0.4.23", + "jax": "0.4.24", "scipy": "1.10.1", "paddle": "2.6.0", "sklearn": "1.3.0", diff --git a/ivy/functional/frontends/jax/lax/operators.py b/ivy/functional/frontends/jax/lax/operators.py index c0967b50436d7..9f1cc9b554f63 100644 --- a/ivy/functional/frontends/jax/lax/operators.py +++ b/ivy/functional/frontends/jax/lax/operators.py @@ -157,7 +157,7 @@ def broadcast(operand, sizes): @with_supported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "float32", "float64", @@ -309,7 +309,7 @@ def cosh(x): @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16", "float16", "bool", "complex64", "complex128")}, + {"0.4.24 and below": ("bfloat16", "float16", "bool", "complex64", "complex128")}, "jax", ) @to_ivy_arrays_and_back @@ -400,7 +400,7 @@ def erf(x): @with_supported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "float32", "float64", @@ -465,7 +465,7 @@ def imag(x): @with_unsupported_dtypes( - {"0.4.23 and below": ("bool", "bfloat16")}, + {"0.4.24 and below": ("bool", "bfloat16")}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/nn/non_linear_activations.py b/ivy/functional/frontends/jax/nn/non_linear_activations.py index 71114b968d1b4..afbaac59e1948 100644 --- a/ivy/functional/frontends/jax/nn/non_linear_activations.py +++ b/ivy/functional/frontends/jax/nn/non_linear_activations.py @@ -289,7 +289,7 @@ def sigmoid(x): @with_supported_dtypes( - {"0.4.23 and below": ("complex", "float")}, + {"0.4.24 and below": ("complex", "float")}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/numpy/creation.py b/ivy/functional/frontends/jax/numpy/creation.py index 0ee3781d3c64b..1b72e1ea7819b 100644 --- a/ivy/functional/frontends/jax/numpy/creation.py +++ b/ivy/functional/frontends/jax/numpy/creation.py @@ -17,7 +17,7 @@ @with_unsupported_device_and_dtypes( { - "0.4.23 and below": { + "0.4.24 and below": { "cpu": ( "float16", "bflooat16", @@ -196,7 +196,7 @@ def iterable(y): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -217,7 +217,7 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/frontends/jax/numpy/linalg.py b/ivy/functional/frontends/jax/numpy/linalg.py index 4e014dee3178f..57c69ee5b1596 100644 --- a/ivy/functional/frontends/jax/numpy/linalg.py +++ b/ivy/functional/frontends/jax/numpy/linalg.py @@ -88,7 +88,7 @@ def multi_dot(arrays, *, precision=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"0.4.23 and below": ("float32", "float64")}, + {"0.4.24 and below": ("float32", "float64")}, "jax", ) def norm(x, ord=None, axis=None, keepdims=False): @@ -127,7 +127,7 @@ def svd(a, /, *, full_matrices=True, compute_uv=True, hermitian=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.23 and below": ("float16", "bfloat16")}, "jax") +@with_unsupported_dtypes({"0.4.24 and below": ("float16", "bfloat16")}, "jax") def tensorinv(a, ind=2): old_shape = ivy.shape(a) prod = 1 diff --git a/ivy/functional/frontends/jax/numpy/logic.py b/ivy/functional/frontends/jax/numpy/logic.py index e1bc10cd40f16..1c5b45f0d80ed 100644 --- a/ivy/functional/frontends/jax/numpy/logic.py +++ b/ivy/functional/frontends/jax/numpy/logic.py @@ -101,7 +101,7 @@ def equal(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, "jax") +@with_unsupported_dtypes({"0.4.24 and below": ("bfloat16",)}, "jax") def fromfunction(function, shape, *, dtype=float, **kwargs): def canonicalize_shape(shape, context="shape argument"): if isinstance(shape, int): @@ -285,7 +285,7 @@ def right_shift(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16", "bool")}, "jax") +@with_unsupported_dtypes({"0.4.24 and below": ("bfloat16", "bool")}, "jax") def setxor1d(ar1, ar2, assume_unique=False): common_dtype = ivy.promote_types(ivy.dtype(ar1), ivy.dtype(ar2)) ar1 = ivy.asarray(ar1, dtype=common_dtype) diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py index c68a4740223b0..0fee3841f509c 100644 --- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py +++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py @@ -76,7 +76,7 @@ def around(a, decimals=0, out=None): @with_unsupported_dtypes( - {"0.4.23 and below": ("bfloat16",)}, + {"0.4.24 and below": ("bfloat16",)}, "jax", ) @to_ivy_arrays_and_back @@ -420,7 +420,7 @@ def expm1( @with_unsupported_dtypes( - {"0.4.23 and below": ("uint16",)}, + {"0.4.24 and below": ("uint16",)}, "jax", ) @to_ivy_arrays_and_back @@ -584,7 +584,7 @@ def minimum(x1, x2, /): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.23 and below": ("complex",)}, "jax") +@with_unsupported_dtypes({"0.4.24 and below": ("complex",)}, "jax") def mod(x1, x2, /): x1, x2 = promote_types_of_jax_inputs(x1, x2) return ivy.remainder(x1, x2) @@ -626,7 +626,7 @@ def negative( @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "bfloat16", "float16", ) @@ -671,7 +671,7 @@ def polyadd(a1, a2): @with_unsupported_dtypes( - {"0.4.23 and below": ("float16",)}, + {"0.4.24 and below": ("float16",)}, "jax", ) @to_ivy_arrays_and_back @@ -713,7 +713,7 @@ def polydiv(u, v, *, trim_leading_zeros=False): @with_unsupported_dtypes( - {"0.4.23 and below": ("float16",)}, + {"0.4.24 and below": ("float16",)}, "jax", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/jax/numpy/searching_sorting.py b/ivy/functional/frontends/jax/numpy/searching_sorting.py index cf0973d83d4a4..397031ad1d606 100644 --- a/ivy/functional/frontends/jax/numpy/searching_sorting.py +++ b/ivy/functional/frontends/jax/numpy/searching_sorting.py @@ -16,7 +16,7 @@ @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -111,7 +111,7 @@ def argwhere(a, /, *, size=None, fill_value=None): @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "uint8", "int8", "bool", diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py index cc2a966b8a9f2..0b20517c66187 100644 --- a/ivy/functional/frontends/jax/numpy/statistical.py +++ b/ivy/functional/frontends/jax/numpy/statistical.py @@ -103,7 +103,7 @@ def corrcoef(x, y=None, rowvar=True): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"0.4.23 and below": ("float16", "bfloat16")}, "jax") +@with_unsupported_dtypes({"0.4.24 and below": ("float16", "bfloat16")}, "jax") def correlate(a, v, mode="valid", precision=None): if ivy.get_num_dims(a) != 1 or ivy.get_num_dims(v) != 1: raise ValueError("correlate() only support 1-dimensional inputs.") @@ -574,7 +574,7 @@ def ptp(a, axis=None, out=None, keepdims=False): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.23 and below": ("complex64", "complex128", "bfloat16", "bool", "float16")}, + {"0.4.24 and below": ("complex64", "complex128", "bfloat16", "bool", "float16")}, "jax", ) def quantile( @@ -599,7 +599,7 @@ def quantile( @handle_jax_dtype -@with_unsupported_dtypes({"0.4.23 and below": ("bfloat16",)}, "jax") +@with_unsupported_dtypes({"0.4.24 and below": ("bfloat16",)}, "jax") @to_ivy_arrays_and_back def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=None): axis = tuple(axis) if isinstance(axis, list) else axis diff --git a/ivy/functional/frontends/jax/random.py b/ivy/functional/frontends/jax/random.py index 6fbc288c0aeb6..4a63a1d81baf1 100644 --- a/ivy/functional/frontends/jax/random.py +++ b/ivy/functional/frontends/jax/random.py @@ -38,7 +38,7 @@ def PRNGKey(seed): @to_ivy_arrays_and_back @with_supported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float32", "float64", ) @@ -70,7 +70,7 @@ def bernoulli(key, p=0.5, shape=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -85,7 +85,7 @@ def beta(key, a, b, shape=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -133,7 +133,7 @@ def cauchy(key, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -149,7 +149,7 @@ def dirichlet(key, alpha, shape=None, dtype="float32"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.23 and below": "uint32"}, + {"0.4.24 and below": "uint32"}, "jax", ) def double_sided_maxwell(key, loc, scale, shape=(), dtype="float64"): @@ -168,7 +168,7 @@ def double_sided_maxwell(key, loc, scale, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -196,7 +196,7 @@ def fold_in(key, data): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -212,7 +212,7 @@ def gamma(key, a, shape=None, dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -231,7 +231,7 @@ def generalized_normal(key, p, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -255,7 +255,7 @@ def gumbel(key, shape=(), dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -270,7 +270,7 @@ def loggamma(key, a, shape=None, dtype="float64"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.23 and below": ("float16", "bfloat16")}, + {"0.4.24 and below": ("float16", "bfloat16")}, "jax", ) def logistic(key, shape=(), dtype="float64"): @@ -301,7 +301,7 @@ def maxwell(key, shape, dtype="float64"): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -358,7 +358,7 @@ def orthogonal(key, n, shape=(), dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "0.4.23 and below": ( + "0.4.24 and below": ( "float16", "bfloat16", ) @@ -393,7 +393,7 @@ def permutation(key, x, axis=0, independent=False): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.23 and below": ("unsigned", "int8", "int16")}, + {"0.4.24 and below": ("unsigned", "int8", "int16")}, "jax", ) def poisson(key, lam, shape=None, dtype=None): @@ -404,7 +404,7 @@ def poisson(key, lam, shape=None, dtype=None): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.23 and below": ("unsigned", "int8", "int16")}, + {"0.4.24 and below": ("unsigned", "int8", "int16")}, "jax", ) def rademacher(key, shape, dtype="int64"): @@ -418,7 +418,7 @@ def rademacher(key, shape, dtype="int64"): @handle_jax_dtype @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"0.4.23 and below": ("unsigned", "int8", "int16")}, + {"0.4.24 and below": ("unsigned", "int8", "int16")}, "jax", ) def randint(key, shape, minval, maxval, dtype="int64"): From 3277232de7c4a704f6cbd873d11799efb394811d Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sat, 10 Feb 2024 18:58:54 +0530 Subject: [PATCH 771/978] feat: Updated `torch` version mapping form `2.1.2` to `2.2` (#28236) --- ivy/functional/backends/torch/__init__.py | 24 +- ivy/functional/backends/torch/activations.py | 20 +- ivy/functional/backends/torch/creation.py | 8 +- ivy/functional/backends/torch/data_type.py | 4 +- ivy/functional/backends/torch/elementwise.py | 102 ++--- .../torch/experimental/activations.py | 26 +- .../backends/torch/experimental/creation.py | 6 +- .../torch/experimental/elementwise.py | 28 +- .../backends/torch/experimental/layers.py | 38 +- .../torch/experimental/linear_algebra.py | 6 +- .../backends/torch/experimental/losses.py | 12 +- .../torch/experimental/manipulation.py | 10 +- .../backends/torch/experimental/norms.py | 12 +- .../backends/torch/experimental/random.py | 6 +- .../backends/torch/experimental/sorting.py | 4 +- .../torch/experimental/statistical.py | 16 +- ivy/functional/backends/torch/general.py | 12 +- ivy/functional/backends/torch/layers.py | 30 +- .../backends/torch/linear_algebra.py | 52 +-- ivy/functional/backends/torch/manipulation.py | 8 +- ivy/functional/backends/torch/norms.py | 2 +- ivy/functional/backends/torch/random.py | 2 +- ivy/functional/backends/torch/searching.py | 4 +- ivy/functional/backends/torch/set.py | 8 +- ivy/functional/backends/torch/sorting.py | 8 +- ivy/functional/backends/torch/statistical.py | 14 +- ivy/functional/frontends/__init__.py | 2 +- .../frontends/torch/blas_and_lapack_ops.py | 2 +- .../frontends/torch/comparison_ops.py | 32 +- .../frontends/torch/creation_ops.py | 12 +- .../indexing_slicing_joining_mutating_ops.py | 4 +- ivy/functional/frontends/torch/linalg.py | 60 +-- .../frontends/torch/miscellaneous_ops.py | 38 +- .../nn/functional/convolution_functions.py | 12 +- .../torch/nn/functional/distance_functions.py | 6 +- .../torch/nn/functional/dropout_functions.py | 10 +- .../torch/nn/functional/layer_functions.py | 4 +- .../torch/nn/functional/linear_functions.py | 2 +- .../torch/nn/functional/loss_functions.py | 32 +- .../non_linear_activation_functions.py | 46 +- .../frontends/torch/nn/functional/norms.py | 8 +- .../torch/nn/functional/pooling_functions.py | 22 +- .../torch/nn/functional/sparse_functions.py | 2 +- .../torch/nn/functional/vision_functions.py | 12 +- .../frontends/torch/pointwise_ops.py | 106 ++--- .../frontends/torch/random_sampling.py | 10 +- .../frontends/torch/reduction_ops.py | 38 +- ivy/functional/frontends/torch/tensor.py | 418 +++++++++--------- .../frontends/torch/tensor_functions.py | 6 +- ivy/functional/frontends/torch/utilities.py | 2 +- ivy/functional/frontends/torchvision/ops.py | 4 +- 51 files changed, 674 insertions(+), 678 deletions(-) diff --git a/ivy/functional/backends/torch/__init__.py b/ivy/functional/backends/torch/__init__.py index e82a5063499f8..a9df06e5a6129 100644 --- a/ivy/functional/backends/torch/__init__.py +++ b/ivy/functional/backends/torch/__init__.py @@ -129,7 +129,7 @@ def rep_method(*args, **kwargs): # update these to add new dtypes valid_dtypes = { - "2.1.2 and below": ( + "2.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -147,7 +147,7 @@ def rep_method(*args, **kwargs): valid_numeric_dtypes = { - "2.1.2 and below": ( + "2.2 and below": ( ivy.int8, ivy.int16, ivy.int32, @@ -163,13 +163,13 @@ def rep_method(*args, **kwargs): } valid_int_dtypes = { - "2.1.2 and below": (ivy.int8, ivy.int16, ivy.int32, ivy.int64, ivy.uint8) + "2.2 and below": (ivy.int8, ivy.int16, ivy.int32, ivy.int64, ivy.uint8) } valid_float_dtypes = { - "2.1.2 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) + "2.2 and below": (ivy.bfloat16, ivy.float16, ivy.float32, ivy.float64) } -valid_uint_dtypes = {"2.1.2 and below": (ivy.uint8,)} -valid_complex_dtypes = {"2.1.2 and below": (ivy.complex64, ivy.complex128)} +valid_uint_dtypes = {"2.2 and below": (ivy.uint8,)} +valid_complex_dtypes = {"2.2 and below": (ivy.complex64, ivy.complex128)} # leave these untouched valid_dtypes = _dtype_from_version(valid_dtypes, backend_version) @@ -182,17 +182,17 @@ def rep_method(*args, **kwargs): # invalid data types # update these to add new dtypes invalid_dtypes = { - "2.1.2 and below": ( + "2.2 and below": ( ivy.uint16, ivy.uint32, ivy.uint64, ) } -invalid_numeric_dtypes = {"2.1.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_int_dtypes = {"2.1.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_float_dtypes = {"2.1.2 and below": ()} -invalid_uint_dtypes = {"2.1.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} -invalid_complex_dtypes = {"2.1.2 and below": ()} +invalid_numeric_dtypes = {"2.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_int_dtypes = {"2.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_float_dtypes = {"2.2 and below": ()} +invalid_uint_dtypes = {"2.2 and below": (ivy.uint16, ivy.uint32, ivy.uint64)} +invalid_complex_dtypes = {"2.2 and below": ()} invalid_dtypes = _dtype_from_version(invalid_dtypes, backend_version) # leave these untouched diff --git a/ivy/functional/backends/torch/activations.py b/ivy/functional/backends/torch/activations.py index e341d123ec230..13cf0113beb56 100644 --- a/ivy/functional/backends/torch/activations.py +++ b/ivy/functional/backends/torch/activations.py @@ -18,14 +18,14 @@ import ivy.functional.backends.torch as torch_backend -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def relu( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: return torch.relu(x) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def leaky_relu( x: torch.Tensor, /, @@ -37,7 +37,7 @@ def leaky_relu( return torch.nn.functional.leaky_relu(x, alpha) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def gelu( x: torch.Tensor, /, @@ -51,7 +51,7 @@ def gelu( return torch.nn.functional.gelu(x) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def sigmoid( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -63,7 +63,7 @@ def sigmoid( sigmoid.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def softmax( x: torch.Tensor, /, @@ -80,7 +80,7 @@ def softmax( return torch.nn.functional.softmax(x, axis) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def softplus( x: torch.Tensor, /, @@ -97,7 +97,7 @@ def softplus( # Softsign -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def softsign(x: torch.Tensor, /, out: Optional[torch.Tensor] = None) -> torch.Tensor: # return x / (1 + torch.abs(x)) return torch.nn.functional.softsign(x) @@ -107,7 +107,7 @@ def softsign(x: torch.Tensor, /, out: Optional[torch.Tensor] = None) -> torch.Te @with_unsupported_dtypes( - {"2.1.2 and below": ("float16",)}, + {"2.2 and below": ("float16",)}, backend_version, ) def log_softmax( @@ -128,7 +128,7 @@ def log_softmax( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16",)}, + {"2.2 and below": ("float16",)}, backend_version, ) def mish( @@ -146,7 +146,7 @@ def mish( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "complex", "float16", ) diff --git a/ivy/functional/backends/torch/creation.py b/ivy/functional/backends/torch/creation.py index 4674ddbd17399..ab6351d5054f7 100644 --- a/ivy/functional/backends/torch/creation.py +++ b/ivy/functional/backends/torch/creation.py @@ -47,7 +47,7 @@ def _differentiable_linspace(start, stop, num, *, device, dtype=None): return res -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def arange( start: float, /, @@ -95,7 +95,7 @@ def _stack_tensors(x, dtype): return x -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, backend_version) @_asarray_to_native_arrays_and_back @_asarray_infer_device @_asarray_handle_nestable @@ -166,7 +166,7 @@ def empty_like( return torch.empty_like(x, dtype=dtype, device=device) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, backend_version) def eye( n_rows: int, n_cols: Optional[int] = None, @@ -276,7 +276,7 @@ def _slice_at_axis(sl, axis): @with_unsupported_device_and_dtypes( - {"2.1.2 and below": {"cpu": ("float16",)}}, backend_version + {"2.2 and below": {"cpu": ("float16",)}}, backend_version ) def linspace( start: Union[torch.Tensor, float], diff --git a/ivy/functional/backends/torch/data_type.py b/ivy/functional/backends/torch/data_type.py index 0fa729c4812e1..76db94f8a1ae4 100644 --- a/ivy/functional/backends/torch/data_type.py +++ b/ivy/functional/backends/torch/data_type.py @@ -72,7 +72,7 @@ def smallest_normal(self): # -------------------# -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def astype( x: torch.Tensor, dtype: torch.dtype, @@ -181,7 +181,7 @@ def as_ivy_dtype( ) -@with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("uint16",)}, backend_version) def as_native_dtype( dtype_in: Union[torch.dtype, str, bool, int, float, np.dtype], ) -> torch.dtype: diff --git a/ivy/functional/backends/torch/elementwise.py b/ivy/functional/backends/torch/elementwise.py index 3e2a4d69d7a21..b12773813fdea 100644 --- a/ivy/functional/backends/torch/elementwise.py +++ b/ivy/functional/backends/torch/elementwise.py @@ -38,7 +38,7 @@ def add( add.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_xor( x1: Union[int, bool, torch.Tensor], @@ -54,7 +54,7 @@ def bitwise_xor( bitwise_xor.support_native_out = True -@with_supported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_supported_dtypes({"2.2 and below": ("complex",)}, backend_version) def imag( val: torch.Tensor, /, @@ -67,7 +67,7 @@ def imag( imag.support_native_out = False -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def expm1(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -77,7 +77,7 @@ def expm1(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te expm1.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_invert( x: Union[int, bool, torch.Tensor], /, *, out: Optional[torch.Tensor] = None @@ -95,7 +95,7 @@ def isfinite(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch return torch.isfinite(x) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def isinf( x: torch.Tensor, @@ -130,7 +130,7 @@ def equal( equal.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def less_equal( x1: Union[float, torch.Tensor], @@ -146,7 +146,7 @@ def less_equal( less_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_and( x1: Union[int, bool, torch.Tensor], @@ -162,7 +162,7 @@ def bitwise_and( bitwise_and.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def ceil(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -176,7 +176,7 @@ def ceil(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten ceil.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def floor(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -190,7 +190,7 @@ def floor(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te floor.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def fmin( x1: torch.Tensor, x2: torch.Tensor, @@ -204,7 +204,7 @@ def fmin( fmin.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def asin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -214,7 +214,7 @@ def asin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten asin.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def asinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -224,7 +224,7 @@ def asinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te asinh.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sign( x: torch.Tensor, @@ -246,7 +246,7 @@ def sign( sign.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sqrt(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -256,7 +256,7 @@ def sqrt(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten sqrt.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def cosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -266,7 +266,7 @@ def cosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten cosh.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log10(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -276,14 +276,14 @@ def log10(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te log10.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log2(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) return torch.log2(x, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def log1p(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -299,7 +299,7 @@ def isnan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te return torch.isnan(x) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def less( x1: Union[float, torch.Tensor], @@ -330,7 +330,7 @@ def multiply( multiply.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def cos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -371,7 +371,7 @@ def divide( divide.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def greater( x1: Union[float, torch.Tensor], @@ -387,7 +387,7 @@ def greater( greater.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def greater_equal( x1: Union[float, torch.Tensor], @@ -403,7 +403,7 @@ def greater_equal( greater_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def acos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -413,7 +413,7 @@ def acos(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten acos.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float",)}, backend_version) @handle_numpy_arrays_in_specific_backend def lcm( x1: torch.Tensor, @@ -459,7 +459,7 @@ def logical_or( logical_or.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def acosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -469,7 +469,7 @@ def acosh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te acosh.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sin(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -505,7 +505,7 @@ def not_equal( not_equal.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def tanh( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None @@ -517,7 +517,7 @@ def tanh( tanh.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def floor_divide( x1: Union[float, torch.Tensor], @@ -538,7 +538,7 @@ def floor_divide( floor_divide.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_or( x1: Union[int, bool, torch.Tensor], @@ -554,7 +554,7 @@ def bitwise_or( bitwise_or.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def sinh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -619,7 +619,7 @@ def pow( pow.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def round( x: torch.Tensor, /, *, decimals: int = 0, out: Optional[torch.Tensor] = None @@ -660,7 +660,7 @@ def trapz( trapz.support_native_out = False -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def trunc(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -693,7 +693,7 @@ def abs( abs.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def logaddexp( x1: torch.Tensor, x2: torch.Tensor, /, *, out: Optional[torch.Tensor] = None @@ -705,7 +705,7 @@ def logaddexp( logaddexp.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def logaddexp2( x1: Union[torch.Tensor, float, list, tuple], @@ -724,7 +724,7 @@ def logaddexp2( logaddexp2.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) @handle_numpy_arrays_in_specific_backend def tan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -734,7 +734,7 @@ def tan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens tan.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def atan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -745,7 +745,7 @@ def atan(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version ) # TODO Fixed in PyTorch 1.12.1 (this note excludes complex) @handle_numpy_arrays_in_specific_backend def atan2( @@ -758,7 +758,7 @@ def atan2( atan2.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def log(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -768,7 +768,7 @@ def log(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens log.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def exp(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -809,7 +809,7 @@ def subtract( subtract.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def remainder( x1: Union[float, torch.Tensor], @@ -837,7 +837,7 @@ def remainder( remainder.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def atanh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -847,7 +847,7 @@ def atanh(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Te atanh.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_right_shift( x1: Union[int, bool, torch.Tensor], @@ -864,7 +864,7 @@ def bitwise_right_shift( bitwise_right_shift.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def bitwise_left_shift( x1: Union[int, bool, torch.Tensor], @@ -884,7 +884,7 @@ def bitwise_left_shift( # ------# -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) @handle_numpy_arrays_in_specific_backend def erf(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) @@ -894,7 +894,7 @@ def erf(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tens erf.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def minimum( x1: Union[float, torch.Tensor], @@ -913,7 +913,7 @@ def minimum( minimum.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def maximum( x1: Union[float, torch.Tensor], @@ -932,7 +932,7 @@ def maximum( maximum.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) @handle_numpy_arrays_in_specific_backend def reciprocal( x: Union[float, torch.Tensor], /, *, out: Optional[torch.Tensor] = None @@ -945,7 +945,7 @@ def reciprocal( @with_unsupported_dtypes( - {"2.1.2 and below": ("complex64", "complex128")}, backend_version + {"2.2 and below": ("complex64", "complex128")}, backend_version ) @handle_numpy_arrays_in_specific_backend def deg2rad(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: @@ -956,7 +956,7 @@ def deg2rad(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch. @with_unsupported_dtypes( - {"2.1.2 and below": ("complex64", "complex128")}, backend_version + {"2.2 and below": ("complex64", "complex128")}, backend_version ) @handle_numpy_arrays_in_specific_backend def rad2deg(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: @@ -966,7 +966,7 @@ def rad2deg(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch. rad2deg.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) @handle_numpy_arrays_in_specific_backend def trunc_divide( x1: Union[float, torch.Tensor], @@ -990,7 +990,7 @@ def isreal(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.T @with_unsupported_dtypes( - {"2.1.2 and below": ("bfloat16", "complex")}, + {"2.2 and below": ("bfloat16", "complex")}, backend_version, ) @handle_numpy_arrays_in_specific_backend diff --git a/ivy/functional/backends/torch/experimental/activations.py b/ivy/functional/backends/torch/experimental/activations.py index f947baa9d40b0..e487d99bb5fa1 100644 --- a/ivy/functional/backends/torch/experimental/activations.py +++ b/ivy/functional/backends/torch/experimental/activations.py @@ -10,7 +10,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def logit( x: torch.Tensor, /, @@ -22,7 +22,7 @@ def logit( return torch.logit(x, eps=eps, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex", "float16")}, backend_version) def thresholded_relu( x: torch.Tensor, /, @@ -33,14 +33,14 @@ def thresholded_relu( return torch.threshold(x, threshold=threshold, value=0) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def relu6( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: return torch.nn.functional.relu6(x) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def logsigmoid( input: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -49,7 +49,7 @@ def logsigmoid( return torch.nn.functional.logsigmoid(input) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def selu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: ret = torch.nn.functional.selu(x) if ivy.exists(out): @@ -57,12 +57,12 @@ def selu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Ten return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def silu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.nn.functional.silu(x) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def elu( x: torch.Tensor, /, *, alpha: float = 1.0, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -74,7 +74,7 @@ def elu( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "complex", "float16", "bfloat16", @@ -93,7 +93,7 @@ def celu( return torch.celu(x, alpha=alpha) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def hardtanh( x: torch.Tensor, /, @@ -108,7 +108,7 @@ def hardtanh( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def tanhshrink( x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -118,7 +118,7 @@ def tanhshrink( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def threshold( x: torch.Tensor, /, @@ -133,7 +133,7 @@ def threshold( return ivy.astype(ret, x.dtype) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def softshrink( x: torch.Tensor, /, *, lambd: float = 0.5, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -154,7 +154,7 @@ def scaled_tanh( return alpha * torch.nn.functional.tanh(beta * x) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def hardshrink( x: torch.Tensor, /, *, lambd: float = 0.5, out: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/ivy/functional/backends/torch/experimental/creation.py b/ivy/functional/backends/torch/experimental/creation.py index 2c332f82d06ea..546cde45eac66 100644 --- a/ivy/functional/backends/torch/experimental/creation.py +++ b/ivy/functional/backends/torch/experimental/creation.py @@ -20,7 +20,7 @@ @with_unsupported_device_and_dtypes( - {"2.1.2 and below": {"cpu": ("float16",)}}, + {"2.2 and below": {"cpu": ("float16",)}}, backend_version, ) def kaiser_window( @@ -87,7 +87,7 @@ def vorbis_window( vorbis_window.support_native_out = False -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def hann_window( size: int, /, @@ -152,7 +152,7 @@ def unsorted_segment_min( return res -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def blackman_window( size: int, /, diff --git a/ivy/functional/backends/torch/experimental/elementwise.py b/ivy/functional/backends/torch/experimental/elementwise.py index 0b7b23d89f67b..db54833224dd5 100644 --- a/ivy/functional/backends/torch/experimental/elementwise.py +++ b/ivy/functional/backends/torch/experimental/elementwise.py @@ -16,7 +16,7 @@ @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "complex64", "complex128", ) @@ -40,7 +40,7 @@ def amax( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "complex64", "complex128", ) @@ -62,12 +62,12 @@ def amin( amin.support_native_out = True -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, backend_version) def lgamma(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.lgamma(x, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def fmax( x1: torch.Tensor, x2: torch.Tensor, @@ -82,7 +82,7 @@ def fmax( fmax.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def sinc(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: x = _cast_for_unary_op(x) return torch.sinc(x, out=out) @@ -158,7 +158,7 @@ def count_nonzero( count_nonzero.support_native_out = False -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def nansum( x: torch.Tensor, /, @@ -227,7 +227,7 @@ def signbit( signbit.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def hypot( x1: torch.Tensor, x2: torch.Tensor, @@ -252,7 +252,7 @@ def allclose( return torch.tensor(ret) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def fix( x: torch.Tensor, /, @@ -265,7 +265,7 @@ def fix( fix.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def nextafter( x1: torch.Tensor, x2: torch.Tensor, @@ -319,7 +319,7 @@ def gradient( @with_supported_dtypes( - {"2.1.2 and below": ("float16", "float32", "float64")}, + {"2.2 and below": ("float16", "float32", "float64")}, backend_version, ) def xlogy( @@ -382,7 +382,7 @@ def _are_suitable_types_for_torch_lerp(input, end, weight): return True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def lerp( input: torch.Tensor, end: torch.Tensor, @@ -421,7 +421,7 @@ def modf( return fractional_part, integer_part -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def digamma( x: torch.Tensor, /, @@ -434,7 +434,7 @@ def digamma( digamma.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def erfc( x: torch.Tensor, /, @@ -444,7 +444,7 @@ def erfc( return torch.special.erfc(x) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def erfinv( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index c2a6a3f501794..150b0e41f2024 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -29,7 +29,7 @@ def _determine_depth_max_pooling(x, kernel, strides, dims, data_format="channel_ return x, kernel, strides, depth_pooling -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def max_pool1d( x: torch.Tensor, kernel: Union[int, Tuple[int, ...]], @@ -94,7 +94,7 @@ def max_pool1d( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -170,7 +170,7 @@ def max_pool2d( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -282,7 +282,7 @@ def _get_specific_pad(x_shape, kernel, strides, padding, dims): return padding, pad_specific -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def avg_pool1d( x: torch.Tensor, kernel: Union[int, Tuple[int]], @@ -374,7 +374,7 @@ def _adjust_num_padded_values_to_ceil( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -478,7 +478,7 @@ def avg_pool2d( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -581,7 +581,7 @@ def avg_pool3d( return res -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, backend_version) def dct( x: torch.Tensor, /, @@ -694,7 +694,7 @@ def idct( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -740,7 +740,7 @@ def fft( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", "complex", @@ -774,7 +774,7 @@ def dropout( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16",)}, + {"2.2 and below": ("float16",)}, backend_version, ) def dropout1d( @@ -797,7 +797,7 @@ def dropout1d( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16",)}, + {"2.2 and below": ("float16",)}, backend_version, ) def dropout2d( @@ -822,7 +822,7 @@ def dropout2d( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -881,7 +881,7 @@ def ifft( return torch.fft.ifft(x, n, dim, norm, out=out).resolve_conj() -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def embedding( weights: torch.Tensor, indices: torch.Tensor, @@ -954,19 +954,19 @@ def interpolate( ) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def adaptive_max_pool2d( input: torch.Tensor, output_size: Union[Sequence[int], int] ) -> torch.Tensor: return torch.nn.functional.adaptive_max_pool2d(input, output_size) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def adaptive_avg_pool1d(input, output_size): return torch.nn.functional.adaptive_avg_pool1d(input, output_size) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def adaptive_avg_pool2d(input, output_size, /, *, data_format: str = "NHWC"): squeeze = False if input.ndim == 3: @@ -982,7 +982,7 @@ def adaptive_avg_pool2d(input, output_size, /, *, data_format: str = "NHWC"): return ret -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def fft2( x: torch.Tensor, *, @@ -1048,7 +1048,7 @@ def rfft( return ret -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def rfftn( x: torch.Tensor, s: Optional[Sequence[int]] = None, @@ -1086,7 +1086,7 @@ def rfftn( # stft @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index 84badc28138d0..ed3dee38a717d 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -12,7 +12,7 @@ from ivy.functional.ivy.experimental.linear_algebra import _check_valid_dimension_size -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def diagflat( x: torch.Tensor, /, @@ -176,7 +176,7 @@ def solve_triangular( solve_triangular.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def multi_dot( x: Sequence[torch.Tensor], /, @@ -213,7 +213,7 @@ def lu_factor( raise IvyNotImplementedException() -@with_unsupported_dtypes({"2.1.1 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def dot( a: torch.Tensor, b: torch.Tensor, diff --git a/ivy/functional/backends/torch/experimental/losses.py b/ivy/functional/backends/torch/experimental/losses.py index 42a65a78451fe..aaab1a95d2eb5 100644 --- a/ivy/functional/backends/torch/experimental/losses.py +++ b/ivy/functional/backends/torch/experimental/losses.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( - {"2.1.2 and below": ("unit8", "int8", "int16", "int32", "int64", "bool")}, + {"2.2 and below": ("unit8", "int8", "int16", "int32", "int64", "bool")}, backend_version, ) def l1_loss( @@ -30,7 +30,7 @@ def l1_loss( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "complex", "uint8", "int8", @@ -59,7 +59,7 @@ def smooth_l1_loss( @with_unsupported_dtypes( - {"2.1.2 and below": ("uint8", "int8", "int16", "int32", "int64", "bool")}, + {"2.2 and below": ("uint8", "int8", "int16", "int32", "int64", "bool")}, backend_version, ) def huber_loss( @@ -77,7 +77,7 @@ def huber_loss( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "uint8", "int8", @@ -104,7 +104,7 @@ def soft_margin_loss( @with_supported_dtypes( - {"2.1.2 and below": ("float",)}, + {"2.2 and below": ("float",)}, backend_version, ) def kl_div( @@ -156,7 +156,7 @@ def poisson_nll_loss( @with_supported_device_and_dtypes( { - "2.1.2 and below": { + "2.2 and below": { "cpu": ("float16", "float32", "float64"), "gpu": ("float16", "float32", "float64"), } diff --git a/ivy/functional/backends/torch/experimental/manipulation.py b/ivy/functional/backends/torch/experimental/manipulation.py index 97dd7183fa442..c0164e4c067a6 100644 --- a/ivy/functional/backends/torch/experimental/manipulation.py +++ b/ivy/functional/backends/torch/experimental/manipulation.py @@ -64,7 +64,7 @@ def heaviside( @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex64", "complex128")}, + {"2.2 and below": ("float32", "float64", "complex64", "complex128")}, backend_version, ) def pad( @@ -242,7 +242,7 @@ def fliplr( fliplr.support_native_out = False -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def i0( x: torch.Tensor, /, @@ -335,7 +335,7 @@ def atleast_3d( return transformed -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def take_along_axis( arr: torch.Tensor, indices: torch.Tensor, @@ -413,7 +413,7 @@ def expand( expand.support_native_out = False -@with_unsupported_dtypes({"2.1.2 and below": ("complex", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex", "float16")}, backend_version) def unique_consecutive( x: torch.Tensor, /, @@ -443,7 +443,7 @@ def column_stack( return torch.column_stack(arrays) -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, backend_version) +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, backend_version) def put_along_axis( arr: torch.Tensor, indices: torch.Tensor, diff --git a/ivy/functional/backends/torch/experimental/norms.py b/ivy/functional/backends/torch/experimental/norms.py index f29b0283833c2..e17a2c42a8e62 100644 --- a/ivy/functional/backends/torch/experimental/norms.py +++ b/ivy/functional/backends/torch/experimental/norms.py @@ -18,7 +18,7 @@ def l1_normalize( l1_normalize.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def l2_normalize( x: torch.Tensor, /, @@ -32,7 +32,7 @@ def l2_normalize( l2_normalize.support_native_out = True -@with_supported_dtypes({"2.1.2 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.2 and below": ("float",)}, backend_version) def local_response_norm( x: torch.Tensor, size, @@ -56,7 +56,7 @@ def local_response_norm( return ret -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def batch_norm( x: torch.Tensor, mean: torch.Tensor, @@ -102,7 +102,7 @@ def batch_norm( ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def instance_norm( x: torch.Tensor, mean: torch.Tensor, @@ -150,7 +150,7 @@ def instance_norm( ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def group_norm( x: torch.Tensor, num_groups: int = 1, @@ -175,7 +175,7 @@ def group_norm( return xnormalized -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def lp_normalize( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/experimental/random.py b/ivy/functional/backends/torch/experimental/random.py index 5532f5914a42f..2226b4b75ff7a 100644 --- a/ivy/functional/backends/torch/experimental/random.py +++ b/ivy/functional/backends/torch/experimental/random.py @@ -13,7 +13,7 @@ # dirichlet -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def dirichlet( alpha: Union[torch.tensor, float, Sequence[float]], /, @@ -32,7 +32,7 @@ def dirichlet( ) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, backend_version) def beta( alpha: Union[float, torch.Tensor], beta: Union[float, torch.Tensor], @@ -53,7 +53,7 @@ def beta( return ret -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, backend_version) def gamma( alpha: Union[float, torch.Tensor], beta: Union[float, torch.Tensor], diff --git a/ivy/functional/backends/torch/experimental/sorting.py b/ivy/functional/backends/torch/experimental/sorting.py index e37526f3fb7d1..609eb6b69d3bf 100644 --- a/ivy/functional/backends/torch/experimental/sorting.py +++ b/ivy/functional/backends/torch/experimental/sorting.py @@ -33,7 +33,7 @@ def lexsort( return torch.tensor([0]) _, result = torch.sort(keys[0], dim=axis, stable=True) # result = torch.argsort(keys[0], dim=axis, stable=True) - # only valid for torch > 2.1.2 + # only valid for torch > 2.2 if shape[0] == 1: return result for i in range(1, shape[0]): @@ -41,7 +41,7 @@ def lexsort( ind = key[result] _, temp = torch.sort(ind, dim=axis, stable=True) # temp = torch.argsort(ind, dim=axis, stable=True) - # only valid for torch > 2.1.2 + # only valid for torch > 2.2 result = result[temp] return result diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index f44069500b9c1..f8cfbaa6a64a9 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -12,7 +12,7 @@ @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "uint8", "int8", "int16", @@ -139,7 +139,7 @@ def histogram( histogram.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bool")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bool")}, backend_version) def median( input: torch.Tensor, /, @@ -170,7 +170,7 @@ def median( median.support_native_out = False -@with_supported_dtypes({"2.1.2 and below": ("float",)}, backend_version) +@with_supported_dtypes({"2.2 and below": ("float",)}, backend_version) def nanmean( a: torch.Tensor, /, @@ -365,7 +365,7 @@ def _compute_quantile_wrapper( ) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def quantile( a: torch.Tensor, q: Union[torch.Tensor, float], @@ -446,7 +446,7 @@ def _nanmedian(input, axis, keepdims): return ret -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def nanmedian( input: torch.Tensor, /, @@ -534,7 +534,7 @@ def igamma( igamma.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def cov( x1: torch.Tensor, x2: torch.Tensor = None, @@ -591,7 +591,7 @@ def cov( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "complex")}, + {"2.2 and below": ("float16", "complex")}, backend_version, ) def cummax( @@ -628,7 +628,7 @@ def cummax( @with_unsupported_dtypes( { - "2.1.2 and below": ("uint8", "float16", "bfloat16"), + "2.2 and below": ("uint8", "float16", "bfloat16"), "1.12.1 and above": ("uint8", "float16"), }, backend_version, diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index af88439c9ee57..ea02caf0707f3 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -54,7 +54,7 @@ def is_native_array(x, /, *, exclusive=False): return False -@with_unsupported_dtypes({"2.1.2 and below": ("complex", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex", "bfloat16")}, backend_version) def array_equal(x0: torch.Tensor, x1: torch.Tensor, /) -> bool: x0, x1 = ivy.promote_types_of_inputs(x0, x1) return torch.equal(x0, x1) @@ -354,7 +354,7 @@ def multiprocessing(context: Optional[str] = None): @with_unsupported_dtypes( { - "2.1.2 and below": ("bfloat16",), + "2.2 and below": ("bfloat16",), }, backend_version, ) @@ -406,7 +406,7 @@ def scatter_flat( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -513,7 +513,7 @@ def shape( return ivy.Shape(x.shape) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, backend_version) def vmap_v_1p13p1_and_below( func: Callable, in_axes: Union[int, Sequence[int], Sequence[None]] = 0, @@ -531,7 +531,7 @@ def new_fun(*args): return _vmap -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, backend_version) def vmap_v_2p0p0_and_above( func: Callable, in_axes: Union[int, Sequence[int], Sequence[None]] = 0, @@ -550,7 +550,7 @@ def new_fun(*args): @with_unsupported_dtypes( - {"2.1.2 and below": ("bfloat16", "float16", "complex", "bool")}, backend_version + {"2.2 and below": ("bfloat16", "float16", "complex", "bool")}, backend_version ) def isin( elements: torch.tensor, diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index e628b11acd34c..7a04b2d7bf698 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -14,7 +14,7 @@ @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex")}, + {"2.2 and below": ("float32", "float64", "complex")}, backend_version, ) def multi_head_attention( @@ -117,7 +117,7 @@ def multi_head_attention( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def linear( @@ -254,7 +254,7 @@ def _tranpose_padding( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -287,7 +287,7 @@ def conv1d( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv1d_v_1p9p0_and_above( @@ -325,7 +325,7 @@ def conv1d_v_1p9p0_and_above( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", "complex", @@ -379,7 +379,7 @@ def conv1d_transpose( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -412,7 +412,7 @@ def conv2d( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv2d_v_1p9p0_and_above( @@ -450,7 +450,7 @@ def conv2d_v_1p9p0_and_above( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", "complex", @@ -507,7 +507,7 @@ def conv2d_transpose( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", "complex", @@ -548,7 +548,7 @@ def depthwise_conv2d( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version ) # noinspection PyUnresolvedReferences def conv3d( @@ -580,7 +580,7 @@ def conv3d( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, backend_version + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version ) def conv3d_v_1p9p0_and_above( x: torch.Tensor, @@ -616,7 +616,7 @@ def conv3d_v_1p9p0_and_above( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) # noinspection PyUnresolvedReferences @@ -669,7 +669,7 @@ def conv3d_transpose( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_dilated( @@ -718,7 +718,7 @@ def conv_general_dilated( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_dilated_v_1p9p0_and_above( @@ -772,7 +772,7 @@ def conv_general_dilated_v_1p9p0_and_above( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "complex")}, backend_version, ) def conv_general_transpose( diff --git a/ivy/functional/backends/torch/linear_algebra.py b/ivy/functional/backends/torch/linear_algebra.py index 59302f23b3468..6db582134e52c 100644 --- a/ivy/functional/backends/torch/linear_algebra.py +++ b/ivy/functional/backends/torch/linear_algebra.py @@ -18,7 +18,7 @@ @with_unsupported_dtypes( - {"2.1.2 and below": ("bfloat16", "float16", "complex")}, + {"2.2 and below": ("bfloat16", "float16", "complex")}, backend_version, ) def cholesky( @@ -42,7 +42,7 @@ def cholesky( cholesky.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) def cross( x1: torch.Tensor, x2: torch.Tensor, @@ -70,7 +70,7 @@ def cross( cross.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def det(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: return torch.linalg.det(x, out=out) @@ -90,7 +90,7 @@ def diagonal( return torch.diagonal(x, offset=offset, dim1=axis1, dim2=axis2) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def eigh( x: torch.Tensor, /, *, UPLO: str = "L", out: Optional[torch.Tensor] = None ) -> Tuple[torch.Tensor]: @@ -104,7 +104,7 @@ def eigh( eigh.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def eigvalsh( x: torch.Tensor, /, *, UPLO: str = "L", out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -114,7 +114,7 @@ def eigvalsh( eigvalsh.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def inner( x1: torch.Tensor, x2: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -134,7 +134,7 @@ def inner( inner.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def inv( x: torch.Tensor, /, @@ -160,7 +160,7 @@ def inv( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "bool")}, backend_version + {"2.2 and below": ("float16", "bfloat16", "bool")}, backend_version ) def matmul( x1: torch.Tensor, @@ -193,7 +193,7 @@ def matmul( matmul.support_native_out = True -@with_supported_dtypes({"2.1.2 and below": ("float", "complex")}, backend_version) +@with_supported_dtypes({"2.2 and below": ("float", "complex")}, backend_version) def matrix_norm( x: torch.Tensor, /, @@ -209,7 +209,7 @@ def matrix_norm( matrix_norm.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def eig( x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None ) -> Tuple[torch.Tensor]: @@ -223,7 +223,7 @@ def eig( eig.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def matrix_power( x: torch.Tensor, n: int, /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -233,7 +233,7 @@ def matrix_power( matrix_power.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def matrix_rank( x: torch.Tensor, /, @@ -281,7 +281,7 @@ def matrix_transpose( return torch.swapaxes(x, -1, -2) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def outer( x1: torch.Tensor, x2: torch.Tensor, @@ -296,7 +296,7 @@ def outer( outer.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def pinv( x: torch.Tensor, /, @@ -312,7 +312,7 @@ def pinv( pinv.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def tensorsolve( x1: torch.Tensor, x2: torch.Tensor, @@ -324,7 +324,7 @@ def tensorsolve( return torch.linalg.tensorsolve(x1, x2, dims=axes) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def qr( x: torch.Tensor, /, @@ -346,7 +346,7 @@ def qr( return ret -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def slogdet( x: torch.Tensor, /, @@ -361,7 +361,7 @@ def slogdet( slogdet.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def solve( x1: torch.Tensor, x2: torch.Tensor, @@ -397,7 +397,7 @@ def solve( return ret -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def svd( x: torch.Tensor, /, *, full_matrices: bool = True, compute_uv: bool = True ) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]: @@ -414,7 +414,7 @@ def svd( return results(D) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def svdvals( x: torch.Tensor, /, @@ -430,7 +430,7 @@ def svdvals( # ToDo: re-add int32 support once # (https://github.com/pytorch/pytorch/issues/84530) is fixed -@with_supported_dtypes({"2.1.2 and below": ("float32",)}, backend_version) +@with_supported_dtypes({"2.2 and below": ("float32",)}, backend_version) def tensordot( x1: torch.Tensor, x2: torch.Tensor, @@ -449,7 +449,7 @@ def tensordot( return ret -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def trace( x: torch.Tensor, /, @@ -489,7 +489,7 @@ def vecdot( vecdot.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("integer",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("integer",)}, backend_version) def vector_norm( x: torch.Tensor, /, @@ -515,7 +515,7 @@ def vector_norm( # ----- # -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def diag( x: torch.Tensor, /, @@ -526,7 +526,7 @@ def diag( return torch.diag(x, diagonal=k) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version) def vander( x: torch.tensor, /, @@ -552,7 +552,7 @@ def vander( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "complex", "unsigned", ) diff --git a/ivy/functional/backends/torch/manipulation.py b/ivy/functional/backends/torch/manipulation.py index c124e3aab9a38..023fb00a7409c 100644 --- a/ivy/functional/backends/torch/manipulation.py +++ b/ivy/functional/backends/torch/manipulation.py @@ -90,7 +90,7 @@ def permute_dims( @with_unsupported_dtypes( - {"2.1.2 and below": ("bfloat16",)}, + {"2.2 and below": ("bfloat16",)}, backend_version, ) def reshape( @@ -249,9 +249,7 @@ def split( return list(torch.split(x, num_or_size_splits, axis)) -@with_unsupported_dtypes( - {"2.1.2 and below": ("int8", "int16", "uint8")}, backend_version -) +@with_unsupported_dtypes({"2.2 and below": ("int8", "int16", "uint8")}, backend_version) def repeat( x: torch.Tensor, /, @@ -319,7 +317,7 @@ def swapaxes( @with_unsupported_dtypes( - {"2.1.2 and below": ("bool", "float16", "complex")}, backend_version + {"2.2 and below": ("bool", "float16", "complex")}, backend_version ) def clip( x: torch.Tensor, diff --git a/ivy/functional/backends/torch/norms.py b/ivy/functional/backends/torch/norms.py index 4d2803259ad58..d6c2793b68cb0 100644 --- a/ivy/functional/backends/torch/norms.py +++ b/ivy/functional/backends/torch/norms.py @@ -5,7 +5,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def layer_norm( x: torch.Tensor, normalized_idxs: List[int], diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index efc61ba4c52a1..944413c523b21 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -63,7 +63,7 @@ def random_normal( random_normal.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, backend_version) def multinomial( population_size: int, num_samples: int, diff --git a/ivy/functional/backends/torch/searching.py b/ivy/functional/backends/torch/searching.py index 847d9b6da30d4..57480f4913b59 100644 --- a/ivy/functional/backends/torch/searching.py +++ b/ivy/functional/backends/torch/searching.py @@ -13,7 +13,7 @@ # ------------------ # -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def argmax( x: torch.Tensor, /, @@ -41,7 +41,7 @@ def argmax( return ret -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def argmin( x: torch.Tensor, /, diff --git a/ivy/functional/backends/torch/set.py b/ivy/functional/backends/torch/set.py index 333d90e14c47f..03e0a6077bb7c 100644 --- a/ivy/functional/backends/torch/set.py +++ b/ivy/functional/backends/torch/set.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( { - "2.1.2 and below": ("complex", "float16"), + "2.2 and below": ("complex", "float16"), }, backend_version, ) @@ -84,7 +84,7 @@ def unique_all( @with_unsupported_dtypes( { - "2.1.2 and below": ("float16",), + "2.2 and below": ("float16",), }, backend_version, ) @@ -98,7 +98,7 @@ def unique_counts(x: torch.Tensor, /) -> Tuple[torch.Tensor, torch.Tensor]: @with_unsupported_dtypes( { - "2.1.2 and below": ("float16",), + "2.2 and below": ("float16",), }, backend_version, ) @@ -124,7 +124,7 @@ def unique_inverse( @with_unsupported_dtypes( { - "2.1.2 and below": ("float16", "complex"), + "2.2 and below": ("float16", "complex"), }, backend_version, ) diff --git a/ivy/functional/backends/torch/sorting.py b/ivy/functional/backends/torch/sorting.py index bbb7475faf966..eac46ae04472f 100644 --- a/ivy/functional/backends/torch/sorting.py +++ b/ivy/functional/backends/torch/sorting.py @@ -8,7 +8,7 @@ from . import backend_version -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def argsort( x: torch.Tensor, /, @@ -29,7 +29,7 @@ def argsort( argsort.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def sort( x: torch.Tensor, /, @@ -51,7 +51,7 @@ def sort( # msort -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def msort( a: Union[torch.Tensor, list, tuple], /, *, out: Optional[torch.Tensor] = None ) -> torch.Tensor: @@ -61,7 +61,7 @@ def msort( msort.support_native_out = True -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def searchsorted( x: torch.Tensor, v: torch.Tensor, diff --git a/ivy/functional/backends/torch/statistical.py b/ivy/functional/backends/torch/statistical.py index eb4666237ae0c..3fcfbd15ee414 100644 --- a/ivy/functional/backends/torch/statistical.py +++ b/ivy/functional/backends/torch/statistical.py @@ -14,7 +14,7 @@ # -------------------# -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) def min( x: torch.Tensor, /, @@ -81,7 +81,7 @@ def max( max.support_native_out = True -@with_supported_dtypes({"2.1.2 and below": ("float", "complex")}, backend_version) +@with_supported_dtypes({"2.2 and below": ("float", "complex")}, backend_version) def mean( x: torch.Tensor, /, @@ -116,7 +116,7 @@ def _infer_dtype(dtype: torch.dtype) -> torch.dtype: # the function to break the upcasting rule defined in the Array API Standard @with_unsupported_dtypes( { - "2.1.2 and below": ("uint8", "float16", "bfloat16"), + "2.2 and below": ("uint8", "float16", "bfloat16"), }, backend_version, ) @@ -144,7 +144,7 @@ def prod( @with_unsupported_dtypes( - {"2.1.2 and below": ("int8", "int16", "int32", "int64", "float16")}, + {"2.2 and below": ("int8", "int16", "int32", "int64", "float16")}, backend_version, ) def std( @@ -182,7 +182,7 @@ def std( # Function does support uint8, but allowing support for unsigned will cause # the function to break the upcasting rule defined in the Array API Standard @with_unsupported_dtypes( - {"2.1.2 and below": ("uint8", "float16", "bfloat16")}, backend_version + {"2.2 and below": ("uint8", "float16", "bfloat16")}, backend_version ) def sum( x: torch.Tensor, @@ -245,7 +245,7 @@ def var( # TODO: bfloat16 support is added in PyTorch 1.12.1 @with_unsupported_dtypes( { - "2.1.2 and below": ("uint8", "float16", "bfloat16", "bool"), + "2.2 and below": ("uint8", "float16", "bfloat16", "bool"), }, backend_version, ) @@ -336,7 +336,7 @@ def cumsum( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16",)}, + {"2.2 and below": ("float16",)}, backend_version, ) def einsum( diff --git a/ivy/functional/frontends/__init__.py b/ivy/functional/frontends/__init__.py index 841453cc1aeae..6e71d220f4e32 100644 --- a/ivy/functional/frontends/__init__.py +++ b/ivy/functional/frontends/__init__.py @@ -2,7 +2,7 @@ versions = { - "torch": "2.1.2", + "torch": "2.2", "tensorflow": "2.15.0", "numpy": "1.25.2", "jax": "0.4.24", diff --git a/ivy/functional/frontends/torch/blas_and_lapack_ops.py b/ivy/functional/frontends/torch/blas_and_lapack_ops.py index 116fb8c80934c..a1c8cd9bbe77b 100644 --- a/ivy/functional/frontends/torch/blas_and_lapack_ops.py +++ b/ivy/functional/frontends/torch/blas_and_lapack_ops.py @@ -201,7 +201,7 @@ def svd(input, some=True, compute_uv=True, *, out=None): return ret -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def trapezoid(y, x=None, *, dx=None, dim=-1): if x is not None: diff --git a/ivy/functional/frontends/torch/comparison_ops.py b/ivy/functional/frontends/torch/comparison_ops.py index c5e244189f127..051b0cfffd35a 100644 --- a/ivy/functional/frontends/torch/comparison_ops.py +++ b/ivy/functional/frontends/torch/comparison_ops.py @@ -59,7 +59,7 @@ def allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False): return ivy.all(ret) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def argsort(input, dim=-1, descending=False): return ivy.argsort(input, axis=dim, descending=descending) @@ -99,14 +99,14 @@ def fmin(input, other, *, out=None): ) -@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def greater(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.greater(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def greater_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -144,7 +144,7 @@ def isfinite(input): @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex", "bool")}, "torch" + {"2.2 and below": ("float16", "bfloat16", "complex", "bool")}, "torch" ) @to_ivy_arrays_and_back def isin(elements, test_elements, *, assume_unique=False, invert=False): @@ -199,7 +199,7 @@ def isnan(input): return ivy.isnan(input) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def isneginf(input, *, out=None): is_inf = ivy.isinf(input) @@ -207,7 +207,7 @@ def isneginf(input, *, out=None): return ivy.logical_and(is_inf, neg_sign_bit, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def isposinf(input, *, out=None): is_inf = ivy.isinf(input) @@ -215,14 +215,14 @@ def isposinf(input, *, out=None): return ivy.logical_and(is_inf, pos_sign_bit, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def isreal(input): return ivy.isreal(input) @with_unsupported_dtypes( - {"2.1.2 and below": ("bfloat16", "float16", "bool", "complex")}, "torch" + {"2.2 and below": ("bfloat16", "float16", "bool", "complex")}, "torch" ) @to_ivy_arrays_and_back def kthvalue(input, k, dim=-1, keepdim=False, *, out=None): @@ -246,48 +246,48 @@ def kthvalue(input, k, dim=-1, keepdim=False, *, out=None): return ret -@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def less(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.less(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def less_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.less_equal(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def maximum(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.maximum(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex64", "complex128")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex64", "complex128")}, "torch") @to_ivy_arrays_and_back def minimum(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.minimum(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def msort(input, *, out=None): return ivy.sort(input, axis=0, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def not_equal(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.not_equal(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back # TODO: the original torch.sort places * right before `out` def sort(input, *, dim=-1, descending=False, stable=False, out=None): @@ -296,7 +296,7 @@ def sort(input, *, dim=-1, descending=False, stable=False, out=None): return namedtuple("sort", ["values", "indices"])(values, indices) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def topk(input, k, dim=None, largest=True, sorted=True, *, out=None): if dim is None: diff --git a/ivy/functional/frontends/torch/creation_ops.py b/ivy/functional/frontends/torch/creation_ops.py index 6e583d2dd8a20..343f0974ae986 100644 --- a/ivy/functional/frontends/torch/creation_ops.py +++ b/ivy/functional/frontends/torch/creation_ops.py @@ -12,7 +12,7 @@ @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def arange( start=0, end=None, @@ -74,7 +74,7 @@ def asarray( return ivy.asarray(obj, copy=copy, dtype=dtype, device=device) -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def complex( real, @@ -214,7 +214,7 @@ def heaviside(input, values, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def linspace( start, end, @@ -231,7 +231,7 @@ def linspace( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def logspace( start, end, @@ -283,7 +283,7 @@ def ones_like_v_0p4p0_and_above( return ret -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def polar( abs, @@ -295,7 +295,7 @@ def polar( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def range( *args, dtype=None, diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py index 6715f68b64bf2..7244d46ffad01 100644 --- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py +++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py @@ -74,7 +74,7 @@ def conj(input): # diagonal_scatter @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "float16", ) @@ -215,7 +215,7 @@ def index_copy(input, dim, index, source, *, out=None): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "uint16", "uint32", "uint64", diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index 67d662d72f97e..f53fc7744bf5b 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -9,7 +9,7 @@ @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def cholesky(input, *, upper=False, out=None): return ivy.cholesky(input, upper=upper, out=out) @@ -31,14 +31,14 @@ def cholesky_ex(input, *, upper=False, check_errors=False, out=None): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64", "complex")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64", "complex")}, "torch") def cond(input, p=None, *, out=None): return ivy.cond(input, p=p, out=out) @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def cross(input, other, *, dim=None, out=None): return torch_frontend.miscellaneous_ops.cross(input, other, dim=dim, out=out) @@ -46,7 +46,7 @@ def cross(input, other, *, dim=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def det(A, *, out=None): return ivy.det(A, out=out) @@ -63,13 +63,13 @@ def divide(input, other, *, rounding_mode=None, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, "torch") def eig(input, *, out=None): return ivy.eig(input, out=out) @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64", "complex128")}, + {"2.2 and below": ("float32", "float64", "complex32", "complex64", "complex128")}, "torch", ) def eigh(A, UPLO="L", *, out=None): @@ -78,7 +78,7 @@ def eigh(A, UPLO="L", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def eigvals(input, *, out=None): ret = ivy.eigvals(input) @@ -89,7 +89,7 @@ def eigvals(input, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def eigvalsh(input, UPLO="L", *, out=None): ret = ivy.eigvalsh(input, UPLO=UPLO, out=out) @@ -102,7 +102,7 @@ def eigvalsh(input, UPLO="L", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def inv(A, *, out=None): return ivy.inv(A, out=out) @@ -110,7 +110,7 @@ def inv(A, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def inv_ex(A, *, check_errors=False, out=None): if ivy.any(ivy.det(A) == 0): @@ -129,7 +129,7 @@ def inv_ex(A, *, check_errors=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def lu_factor(A, *, pivot=True, out=None): return ivy.lu_factor(A, pivot=pivot, out=out) @@ -137,21 +137,21 @@ def lu_factor(A, *, pivot=True, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matmul(input, other, *, out=None): return ivy.matmul(input, other, out=out) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64", "complex")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64", "complex")}, "torch") def matrix_exp(A): return ivy.matrix_exp(A) @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_norm(input, ord="fro", dim=(-2, -1), keepdim=False, *, dtype=None, out=None): if "complex" in ivy.as_ivy_dtype(input.dtype): @@ -163,7 +163,7 @@ def matrix_norm(input, ord="fro", dim=(-2, -1), keepdim=False, *, dtype=None, ou @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_power(A, n, *, out=None): return ivy.matrix_power(A, n, out=out) @@ -171,7 +171,7 @@ def matrix_power(A, n, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_rank(A, *, atol=None, rtol=None, hermitian=False, out=None): return ivy.matrix_rank(A, atol=atol, rtol=rtol, hermitian=hermitian, out=out) @@ -179,7 +179,7 @@ def matrix_rank(A, *, atol=None, rtol=None, hermitian=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def multi_dot(tensors, *, out=None): return ivy.multi_dot(tensors, out=out) @@ -187,7 +187,7 @@ def multi_dot(tensors, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex64", "complex128")}, "torch" + {"2.2 and below": ("float32", "float64", "complex64", "complex128")}, "torch" ) def norm(input, ord=None, dim=None, keepdim=False, *, dtype=None, out=None): if dim is None and (ord is not None): @@ -207,7 +207,7 @@ def norm(input, ord=None, dim=None, keepdim=False, *, dtype=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def pinv(input, *, atol=None, rtol=None, hermitian=False, out=None): # TODO: add handling for hermitian @@ -226,7 +226,7 @@ def pinv(input, *, atol=None, rtol=None, hermitian=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def qr(A, mode="reduced", *, out=None): if mode == "reduced": @@ -244,7 +244,7 @@ def qr(A, mode="reduced", *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def slogdet(A, *, out=None): sign, logabsdet = ivy.slogdet(A) @@ -260,7 +260,7 @@ def slogdet(A, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def solve(A, B, *, left=True, out=None): if left: @@ -274,7 +274,7 @@ def solve(A, B, *, left=True, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def solve_ex(A, B, *, left=True, check_errors=False, out=None): try: @@ -302,7 +302,7 @@ def solve_ex(A, B, *, left=True, check_errors=False, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def svd(A, /, *, full_matrices=True, driver=None, out=None): # TODO: add handling for driver and out @@ -311,7 +311,7 @@ def svd(A, /, *, full_matrices=True, driver=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def svdvals(A, *, driver=None, out=None): if driver in ["gesvd", "gesvdj", "gesvda", None]: @@ -322,7 +322,7 @@ def svdvals(A, *, driver=None, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def tensorinv(input, ind=2, *, out=None): not_invertible = "Reshaped tensor is not invertible" @@ -349,14 +349,14 @@ def tensorinv(input, ind=2, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def tensorsolve(A, B, dims=None, *, out=None): return ivy.tensorsolve(A, B, axes=dims, out=out) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("integer", "float", "complex")}, "torch") +@with_supported_dtypes({"2.2 and below": ("integer", "float", "complex")}, "torch") def vander(x, N=None): if len(x.shape) < 1: raise RuntimeError("Input dim must be greater than or equal to 1.") @@ -389,7 +389,7 @@ def vander(x, N=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def vecdot(x, y, *, dim=-1, out=None): if "complex" in ivy.as_ivy_dtype(x.dtype): @@ -399,7 +399,7 @@ def vecdot(x, y, *, dim=-1, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def vector_norm(input, ord=2, dim=None, keepdim=False, *, dtype=None, out=None): return ivy.vector_norm( diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index b9d15f8a976df..8c3bbb335f849 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -74,7 +74,7 @@ def broadcast_shapes(*shapes): return ivy.broadcast_shapes(*shapes) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def broadcast_to(tensor, shape): return ivy.broadcast_to(tensor, shape) @@ -92,7 +92,7 @@ def cartesian_prod(*tensors): return ret -@with_unsupported_dtypes({"2.1.2 and below": "float16"}, "torch") +@with_unsupported_dtypes({"2.2 and below": "float16"}, "torch") @to_ivy_arrays_and_back def cdist(x1, x2, p=2.0, compute_mode="use_mm_for_euclid_dist_if_necessary"): if len(x1.shape) == 2 and len(x2.shape) == 2: @@ -138,7 +138,7 @@ def clone(input, *, memory_format=None): return ivy.copy_array(input) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bool")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bool")}, "torch") @to_ivy_arrays_and_back def corrcoef(input): if len(ivy.shape(input)) > 2: @@ -155,7 +155,7 @@ def cov(input, /, *, correction=1, fweights=None, aweights=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def cross(input, other, dim=None, *, out=None): if dim is None: dim = -1 @@ -166,7 +166,7 @@ def cross(input, other, dim=None, *, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "uint16", "uint32", "uint64", @@ -194,7 +194,7 @@ def cumprod(input, dim, *, dtype=None, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.2 and below": ("uint8", "bfloat16", "float16"), "1.12.1": ()}, + {"2.2 and below": ("uint8", "bfloat16", "float16"), "1.12.1": ()}, "torch", ) def cumsum(input, dim, *, dtype=None, out=None): @@ -209,7 +209,7 @@ def diag(input, diagonal=0, *, out=None): @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) @to_ivy_arrays_and_back def diagflat(x, offset=0, name=None): @@ -217,7 +217,7 @@ def diagflat(x, offset=0, name=None): return arr -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def diagonal(input, offset=0, dim1=0, dim2=1): return ivy.diagonal(input, offset=offset, axis1=dim1, axis2=dim2) @@ -225,14 +225,14 @@ def diagonal(input, offset=0, dim1=0, dim2=1): @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.2 and below": ("int8", "float16", "bfloat16", "bool")}, "torch" + {"2.2 and below": ("int8", "float16", "bfloat16", "bool")}, "torch" ) def diff(input, n=1, dim=-1, prepend=None, append=None): return ivy.diff(input, n=n, axis=dim, prepend=prepend, append=append, out=None) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def einsum(equation, *operands): if len(operands) == 1 and isinstance(operands[0], (list, tuple)): operands = operands[0] @@ -294,14 +294,14 @@ def kron(input, other, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("int8",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("int8",)}, "torch") def lcm(input, other, *, out=None): return ivy.lcm(input, other, out=out) @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", "integer", @@ -339,7 +339,7 @@ def ravel(input): return ivy.reshape(input, (-1,)) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def renorm(input, p, dim, maxnorm, *, out=None): # Torch hardcodes this magic number @@ -380,7 +380,7 @@ def renorm(input, p, dim, maxnorm, *, out=None): @with_supported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "int32", "int64", ) @@ -510,7 +510,7 @@ def searchsorted( return ret -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def tensordot(a, b, dims=2, out=None): a, b = promote_types_of_torch_inputs(a, b) @@ -518,7 +518,7 @@ def tensordot(a, b, dims=2, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def trace(input): if "int" in input.dtype: input = input.astype("int64") @@ -532,7 +532,7 @@ def tril(input, diagonal=0, *, out=None): return ivy.tril(input, k=diagonal, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("int8", "uint8", "int16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("int8", "uint8", "int16")}, "torch") @to_ivy_arrays_and_back def tril_indices(row, col, offset=0, *, dtype=ivy.int64, device="cpu", layout=None): sample_matrix = ivy.tril(ivy.ones((row, col), device=device), k=offset) @@ -568,7 +568,7 @@ def vander(x, N=None, increasing=False): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def view_as_complex(input): if ivy.shape(input)[-1] != 2: raise ivy.exceptions.IvyError("The last dimension must have a size of 2") @@ -586,7 +586,7 @@ def view_as_complex(input): @with_supported_dtypes( - {"2.1.2 and below": ("complex64", "complex128")}, + {"2.2 and below": ("complex64", "complex128")}, "torch", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py index 2ca1b3a09086b..89b4bcf3c7f67 100644 --- a/ivy/functional/frontends/torch/nn/functional/convolution_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/convolution_functions.py @@ -107,7 +107,7 @@ def _get_transpose_pad(padding, output_padding, dims): # ------------ # -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -121,7 +121,7 @@ def conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -135,7 +135,7 @@ def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): return _conv( @@ -149,7 +149,7 @@ def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose1d( input, @@ -188,7 +188,7 @@ def conv_transpose1d( ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose2d( input, @@ -227,7 +227,7 @@ def conv_transpose2d( ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def conv_transpose3d( input, diff --git a/ivy/functional/frontends/torch/nn/functional/distance_functions.py b/ivy/functional/frontends/torch/nn/functional/distance_functions.py index 029079540ca98..04429e99172d0 100644 --- a/ivy/functional/frontends/torch/nn/functional/distance_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/distance_functions.py @@ -4,7 +4,7 @@ from ivy.func_wrapper import with_unsupported_dtypes -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def cosine_similarity(x1, x2, *, dim=1, eps=1e-08): x1, x2 = torch_frontend.promote_types_of_torch_inputs(x1, x2) @@ -28,7 +28,7 @@ def cosine_similarity(x1, x2, *, dim=1, eps=1e-08): return cosine -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): x1, x2 = torch_frontend.promote_types_of_torch_inputs(x1, x2) @@ -42,7 +42,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): return ivy.vector_norm(x1 - x2 + eps, ord=p, axis=output_dim - 1, keepdims=keepdim) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def pdist(input, p=2): x = ivy.array( diff --git a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py index f7782aa74b377..a4d2b296661ad 100644 --- a/ivy/functional/frontends/torch/nn/functional/dropout_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/dropout_functions.py @@ -7,7 +7,7 @@ # ToDo: this function will be simplified once ivy.alpha_dropout is implemented @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle") def alpha_dropout(input, p=0.5, training=False, inplace=False): if p == 0.0 or not training or input.shape == () or input.shape == (0,): @@ -28,13 +28,13 @@ def alpha_dropout(input, p=0.5, training=False, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def dropout(input, p=0.5, training=True, inplace=False): return ivy.dropout(input, p, scale=True, training=training) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def dropout1d(input, p=0.5, training=True, inplace=False): if inplace: return ivy.dropout1d(input, p, training=training, data_format="NCW", out=input) @@ -42,7 +42,7 @@ def dropout1d(input, p=0.5, training=True, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def dropout2d(input, p=0.5, training=True, inplace=False): if input.ndim < 2: raise ValueError("Feature dropout requires at least 2 dimensions in the input") @@ -55,7 +55,7 @@ def dropout2d(input, p=0.5, training=True, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def dropout3d(input, p=0.5, training=True, inplace=False): if inplace: return ivy.dropout3d( diff --git a/ivy/functional/frontends/torch/nn/functional/layer_functions.py b/ivy/functional/frontends/torch/nn/functional/layer_functions.py index 0a28dd7bf91d0..6c7221673e2b0 100644 --- a/ivy/functional/frontends/torch/nn/functional/layer_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/layer_functions.py @@ -72,7 +72,7 @@ def _lstm_packed( @with_supported_device_and_dtypes( - {"2.1.2 and below": {"cpu": ("float32", "float64")}}, + {"2.2 and below": {"cpu": ("float32", "float64")}}, "torch", ) @to_ivy_arrays_and_back @@ -84,7 +84,7 @@ def lstm(*args, **kwargs): @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def multi_head_attention_forward( query, key, diff --git a/ivy/functional/frontends/torch/nn/functional/linear_functions.py b/ivy/functional/frontends/torch/nn/functional/linear_functions.py index 6246a013db9e9..fba4a5f50b699 100644 --- a/ivy/functional/frontends/torch/nn/functional/linear_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/linear_functions.py @@ -4,7 +4,7 @@ from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def linear(input, weight, bias=None): return ivy.linear(input, weight, bias=bias) diff --git a/ivy/functional/frontends/torch/nn/functional/loss_functions.py b/ivy/functional/frontends/torch/nn/functional/loss_functions.py index 6c9acb5fe3578..ef13df7557bfd 100644 --- a/ivy/functional/frontends/torch/nn/functional/loss_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/loss_functions.py @@ -72,7 +72,7 @@ def _get_reduction_string(size_average, reduce): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def binary_cross_entropy( input, target, weight=None, size_average=None, reduce=None, reduction="mean" ): @@ -113,7 +113,7 @@ def binary_cross_entropy_with_logits( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def cosine_embedding_loss( input1, input2, target, margin=0.0, size_average=None, reduce=None, reduction="mean" ): @@ -214,7 +214,7 @@ def cross_entropy( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("bool", "integer")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bool", "integer")}, "torch") def gaussian_nll_loss(input, target, var, full=False, eps=1e-6, reduction="mean"): input, target = torch_frontend.promote_types_of_torch_inputs(input, target) target, var = torch_frontend.promote_types_of_torch_inputs(target, var) @@ -246,7 +246,7 @@ def gaussian_nll_loss(input, target, var, full=False, eps=1e-6, reduction="mean" @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def hinge_embedding_loss( input, @@ -281,7 +281,7 @@ def huber_loss( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def kl_div( input, target, size_average=None, reduce=None, reduction="mean", log_target=False ): @@ -297,7 +297,7 @@ def kl_div( @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("float", "complex")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float", "complex")}, "torch") def l1_loss( input, target, @@ -312,7 +312,7 @@ def l1_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def margin_ranking_loss( input1, input2, @@ -331,7 +331,7 @@ def margin_ranking_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def mse_loss(input, target, size_average=None, reduce=None, reduction="mean"): reduction = _get_reduction(reduction, size_average, reduce) result = ivy.square(input - target) @@ -340,7 +340,7 @@ def mse_loss(input, target, size_average=None, reduce=None, reduction="mean"): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def multilabel_margin_loss( input, target, size_average=None, reduce=None, reduction="mean" ): @@ -360,7 +360,7 @@ def multilabel_margin_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def multilabel_soft_margin_loss( input, target, @@ -390,7 +390,7 @@ def multilabel_soft_margin_loss( @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "int8", "int16", "int32")}, "torch" + {"2.2 and below": ("float16", "int8", "int16", "int32")}, "torch" ) def nll_loss( input, @@ -436,7 +436,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def poisson_nll_loss( input, target, @@ -463,7 +463,7 @@ def poisson_nll_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def smooth_l1_loss( input, target, @@ -476,7 +476,7 @@ def smooth_l1_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def soft_margin_loss( input, target, @@ -488,7 +488,7 @@ def soft_margin_loss( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def triplet_margin_loss( anchor, positive, @@ -543,7 +543,7 @@ def pairwise_distance(x1, x2, *, p=2.0, eps=1e-06, keepdim=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def triplet_margin_with_distance_loss( anchor, positive, diff --git a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py index fab88dd69bc05..55a5f5d35371f 100644 --- a/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/non_linear_activation_functions.py @@ -7,7 +7,7 @@ @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "complex", "float16", ) @@ -38,7 +38,7 @@ def elu_(input, alpha=1.0): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -63,7 +63,7 @@ def glu(input, dim=-1): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def gumbel_softmax(logits, tau=1, hard=False, eps=1e-10, dim=-1): gumbels = -ivy.empty_like(logits).exponential().log() gumbels = (logits + gumbels) / tau @@ -100,30 +100,30 @@ def hardswish(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def hardtanh(input, min_val=-1.0, max_val=1.0, inplace=False): less = ivy.where(ivy.less(input, min_val), min_val, input) return ivy.where(ivy.greater(input, max_val), max_val, less).astype(input.dtype) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def hardtanh_(input, min_val=-1.0, max_val=1.0): return hardtanh(input, min_val=min_val, max_val=max_val, inplace=True) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def leaky_relu(input, negative_slope=0.01, inplace=False): return ivy.leaky_relu(input, alpha=negative_slope) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def leaky_relu_(input, negative_slope=0.01): return leaky_relu(input, negative_slope=negative_slope, inplace=True) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("float",)}, "torch") +@with_supported_dtypes({"2.2 and below": ("float",)}, "torch") def local_response_norm(input, size, alpha=0.0001, beta=0.75, k=1.0): non_batched = input.ndim == 3 if non_batched: @@ -137,7 +137,7 @@ def local_response_norm(input, size, alpha=0.0001, beta=0.75, k=1.0): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def log_softmax(input, dim=None, _stacklevel=3, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -149,7 +149,7 @@ def log_softmax(input, dim=None, _stacklevel=3, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -188,7 +188,7 @@ def relu(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") def relu6(input, inplace=False): return ivy.relu6(input) @@ -199,7 +199,7 @@ def relu_(input): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def rrelu(input, lower=1.0 / 8, upper=1.0 / 3, training=False, inplace=False): if training: # alpha = ivy.random_uniform(low=lower, high=upper) @@ -212,13 +212,13 @@ def rrelu(input, lower=1.0 / 8, upper=1.0 / 3, training=False, inplace=False): ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def rrelu_(input, lower=1.0 / 8, upper=1.0 / 3, training=False): return rrelu(input, lower=lower, upper=upper, training=training, inplace=True) @to_ivy_arrays_and_back -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def scaled_dot_product_attention( query, key, value, attn_mask=None, dropout_p=0.0, is_causal=False, scale=None ): @@ -239,19 +239,19 @@ def selu(input, inplace=False): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def sigmoid(input): return ivy.sigmoid(input) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def silu(input, inplace=False): return ivy.multiply(input, ivy.sigmoid(input)) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def softmax(input, dim=None, _stacklevel=3, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -259,7 +259,7 @@ def softmax(input, dim=None, _stacklevel=3, dtype=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def softmin(input, dim=None, dtype=None): if dtype: input = ivy.astype(ivy.array(input), ivy.as_ivy_dtype(dtype)) @@ -269,7 +269,7 @@ def softmin(input, dim=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -293,23 +293,23 @@ def softsign(input): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def tanh(input): return ivy.tanh(input) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def tanhshrink(input): return ivy.subtract(input, ivy.tanh(input)) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def threshold(input, threshold, value, inplace=False): return ivy.where(ivy.greater(input, threshold), input, value) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def threshold_(input, threshold, value): return threshold(input, threshold, value, inplace=True) diff --git a/ivy/functional/frontends/torch/nn/functional/norms.py b/ivy/functional/frontends/torch/nn/functional/norms.py index b1f5531fcd6aa..7418d9f6f8f9b 100644 --- a/ivy/functional/frontends/torch/nn/functional/norms.py +++ b/ivy/functional/frontends/torch/nn/functional/norms.py @@ -5,7 +5,7 @@ @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "float16", ) @@ -43,7 +43,7 @@ def batch_norm( @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -58,7 +58,7 @@ def group_norm(input, num_groups, weight=None, bias=None, eps=1e-05): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "float16", ) @@ -93,7 +93,7 @@ def instance_norm( @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-05): shape = ivy.shape(input) if isinstance(normalized_shape, int) and normalized_shape == shape[-1]: diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 03cf6a1e78a12..6cdfdc3ba299b 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -11,7 +11,7 @@ @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "float16", ) @@ -25,7 +25,7 @@ def adaptive_avg_pool1d(input, output_size): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -39,7 +39,7 @@ def adaptive_avg_pool2d(input, output_size): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "float16", ) @@ -57,7 +57,7 @@ def adaptive_max_pool2d( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16",)}, + {"2.2 and below": ("float16",)}, "torch", ) @to_ivy_arrays_and_back @@ -83,7 +83,7 @@ def avg_pool1d( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16",)}, + {"2.2 and below": ("float16",)}, "torch", ) @to_ivy_arrays_and_back @@ -111,7 +111,7 @@ def avg_pool2d( @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16")}, + {"2.2 and below": ("float16", "bfloat16")}, "torch", ) @to_ivy_arrays_and_back @@ -140,7 +140,7 @@ def avg_pool3d( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -172,7 +172,7 @@ def lp_pool1d(input, norm_type, kernel_size, stride=None, ceil_mode=False): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -201,7 +201,7 @@ def lp_pool2d(input, norm_type, kernel_size, stride=None, ceil_mode=False): return ivy.pow(ivy.multiply(out, kernel_mul), p).astype(input.dtype) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool1d( input, @@ -227,7 +227,7 @@ def max_pool1d( ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool2d( input, @@ -253,7 +253,7 @@ def max_pool2d( ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def max_pool3d( input, diff --git a/ivy/functional/frontends/torch/nn/functional/sparse_functions.py b/ivy/functional/frontends/torch/nn/functional/sparse_functions.py index d0ef9cd0f3976..a351132d3b362 100644 --- a/ivy/functional/frontends/torch/nn/functional/sparse_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/sparse_functions.py @@ -33,7 +33,7 @@ def embedding( return ret -@with_supported_dtypes({"2.1.2 and below": ("int64",)}, "torch") +@with_supported_dtypes({"2.2 and below": ("int64",)}, "torch") @to_ivy_arrays_and_back def one_hot(tensor, num_classes=-1): return ivy.astype(ivy.one_hot(tensor, num_classes), tensor.dtype) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index e6d96dbfbb367..5fda10efd2900 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -30,7 +30,7 @@ def _handle_padding_shape(padding, n, mode): # ------------ # -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def affine_grid(theta, size, align_corners=False): if len(size) == 4: @@ -93,7 +93,7 @@ def cubic_conv2(A, x): return ((A * x - 5 * A) * x + 8 * A) * x - 4 * A -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def grid_sample( input, grid, mode="bilinear", padding_mode="zeros", align_corners=False @@ -348,7 +348,7 @@ def grid_sample_padding(grid, padding_mode, align_corners, borders=None): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "float16", ) @@ -505,7 +505,7 @@ def reflect(x, low2, high2): return x -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample( input, @@ -523,7 +523,7 @@ def upsample( ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample_bilinear(input, size=None, scale_factor=None): return interpolate( @@ -531,7 +531,7 @@ def upsample_bilinear(input, size=None, scale_factor=None): ) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def upsample_nearest(input, size=None, scale_factor=None): return interpolate(input, size=size, scale_factor=scale_factor, mode="nearest") diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py index 60169dc556b10..7ae00ab085319 100644 --- a/ivy/functional/frontends/torch/pointwise_ops.py +++ b/ivy/functional/frontends/torch/pointwise_ops.py @@ -15,13 +15,13 @@ def abs(input, *, out=None): return ivy.abs(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def acos(input, *, out=None): return ivy.acos(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def acosh(input, *, out=None): return ivy.acosh(input, out=out) @@ -37,13 +37,13 @@ def add(input, other, *, alpha=1, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def addcdiv(input, tensor1, tensor2, *, value=1, out=None): return ivy.add(input, ivy.multiply(value, ivy.divide(tensor1, tensor2)), out=out) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def addcmul(input, tensor1, tensor2, *, value=1, out=None): return ivy.add(input, ivy.multiply(value, ivy.multiply(tensor1, tensor2)), out=out) @@ -53,32 +53,32 @@ def angle(input, *, out=None): return ivy.angle(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def asin(input, *, out=None): return ivy.asin(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def asinh(input, *, out=None): return ivy.asinh(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def atan(input, *, out=None): return ivy.atan(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def atan2(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) return ivy.atan2(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def atanh(input, *, out=None): return ivy.atanh(input, out=out) @@ -119,13 +119,13 @@ def bitwise_xor(input, other, *, out=None): return ivy.bitwise_xor(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def ceil(input, *, out=None): return ivy.ceil(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def clamp(input, min=None, max=None, *, out=None): ivy.utils.assertions.check_all_or_any_fn( @@ -154,7 +154,7 @@ def copysign(input, other, *, out=None): return ivy.copysign(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def cos(input, *, out=None): return ivy.cos(input, out=out) @@ -183,31 +183,31 @@ def div(input, other, *, rounding_mode=None, out=None): return ivy.divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def erf(input, *, out=None): return ivy.erf(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") @to_ivy_arrays_and_back def erfc(input, *, out=None): return 1.0 - ivy.erf(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def exp(input, *, out=None): return ivy.exp(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def exp2(input, out=None): return ivy.exp2(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def expm1(input, out=None): return ivy.expm1(input, out=out) @@ -225,7 +225,7 @@ def float_power(input, exponent, *, out=None): return ivy.float_power(input, exponent, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def floor(input, *, out=None): return ivy.floor(input, out=out) @@ -236,7 +236,7 @@ def floor_divide(input, other, *, out=None): return ivy.floor_divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def fmod(x1, x2, out=None): return ivy.fmod(x1, x2, out=out) @@ -247,31 +247,31 @@ def frac(input, *, out=None): return input - ivy.sign(input) * ivy.floor(ivy.abs(input)) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def frexp(input, *, out=None): return ivy.frexp(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def gradient(input, *, spacing=1, dim=None, edge_order=1): return ivy.gradient(input, spacing=spacing, edge_order=edge_order, axis=dim) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def hypot(input, other, *, out=None): return ivy.hypot(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def i0(input, *, out=None): return ivy.i0(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def igamma(input, other, *, out=None): return ivy.igamma(input, x=other, out=out) @@ -282,7 +282,7 @@ def imag(input): return ivy.imag(input) -@with_supported_dtypes({"2.1.2 and below": ("float16", "float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float16", "float32", "float64")}, "torch") @to_ivy_arrays_and_back def ldexp(input, other, *, out=None): value = ivy.pow(2, other, out=out) @@ -290,49 +290,49 @@ def ldexp(input, other, *, out=None): return value -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def lerp(input, end, weight, *, out=None): return ivy.lerp(input, end, weight, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def lgamma(input, *, out=None): return ivy.lgamma(input, out=out) @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def log(input, *, out=None): return ivy.log(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log10(input, *, out=None): return ivy.log10(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log1p(input, *, out=None): return ivy.log1p(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def log2(input, *, out=None): return ivy.log2(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def logaddexp(x1, x2, out=None): return ivy.logaddexp(x1, x2, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def logaddexp2(x1, x2, out=None): return ivy.logaddexp2(x1, x2, out=out) @@ -361,13 +361,13 @@ def logical_xor(input, other, *, out=None): return ivy.logical_xor(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") @to_ivy_arrays_and_back def logit(input, eps=None, *, out=None): return ivy.logit(input, eps=eps, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def masked_fill(input, mask, value): return ivy.where(mask, value, input, out=input) @@ -380,7 +380,7 @@ def mul(input, other, *, out=None): @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def mvlgamma(input, p, *, out=None): ivy.assertions.check_greater( p, 1, allow_equal=True, message="p has to be greater than or equal to 1" @@ -395,19 +395,19 @@ def mvlgamma(input, p, *, out=None): ) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def nan_to_num(input, nan=0.0, posinf=None, neginf=None, *, out=None): return ivy.nan_to_num(input, nan=nan, posinf=posinf, neginf=neginf, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bool",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bool",)}, "torch") @to_ivy_arrays_and_back def negative(input, *, out=None): return ivy.negative(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, "torch") @to_ivy_arrays_and_back def nextafter(input, other, *, out=None): input, other = torch_frontend.promote_types_of_torch_inputs(input, other) @@ -419,7 +419,7 @@ def positive(input, *, out=None): return ivy.positive(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bool",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bool",)}, "torch") @to_ivy_arrays_and_back def pow(input, exponent, *, out=None): if not ivy.is_array(exponent): @@ -462,7 +462,7 @@ def remainder(input, other, *, out=None): return ivy.remainder(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def round(input, *, decimals=0, out=None): m = ivy.full(input.shape, 10.0**decimals) @@ -471,7 +471,7 @@ def round(input, *, decimals=0, out=None): return ivy.divide(rounded, m, out=out).astype(input.dtype) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def rsqrt(input, *, out=None): return ivy.reciprocal(ivy.sqrt(input), out=out) @@ -490,43 +490,43 @@ def sgn(input, *, out=None): return ivy.sign(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sigmoid(input, *, out=None): return ivy.sigmoid(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def sign(input, *, out=None): return ivy.sign(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def signbit(input, *, out=None): return ivy.signbit(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sin(input, *, out=None): return ivy.sin(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sinc(input, *, out=None): return ivy.sinc(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sinh(input, *, out=None): return ivy.sinh(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def sqrt(input, *, out=None): return ivy.sqrt(input, out=out) @@ -543,13 +543,13 @@ def subtract(input, other, *, alpha=1, out=None): return ivy.subtract(input, other * alpha, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def tan(input, *, out=None): return ivy.tan(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def tanh(input, *, out=None): return ivy.tanh(input, out=out) @@ -561,13 +561,13 @@ def true_divide(input, other, *, out=None): return ivy.divide(input, other, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def trunc(input, *, out=None): return ivy.trunc(input, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "tensorflow") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "tensorflow") @to_ivy_arrays_and_back def xlogy(input, other, *, out=None): return ivy.xlogy(input, other, out=out) diff --git a/ivy/functional/frontends/torch/random_sampling.py b/ivy/functional/frontends/torch/random_sampling.py index 88dacdb40b0ee..105e983209e64 100644 --- a/ivy/functional/frontends/torch/random_sampling.py +++ b/ivy/functional/frontends/torch/random_sampling.py @@ -5,7 +5,7 @@ @with_supported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float32", "float64", ) @@ -26,7 +26,7 @@ def manual_seed(seed: int): @with_supported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float32", "float64", ) @@ -49,7 +49,7 @@ def multinomial(input, num_samples, replacement=False, *, generator=None, out=No @with_supported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float32", "float64", ) @@ -64,7 +64,7 @@ def normal(mean, std, *, generator=None, out=None): @with_supported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float32", "float64", ) @@ -256,7 +256,7 @@ def seed() -> int: @with_supported_dtypes( - {"2.1.2 and below": ("uint8",)}, + {"2.2 and below": ("uint8",)}, "torch", ) @to_ivy_arrays_and_back diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index e1a2e9715585e..03d6ec6d91fb8 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -18,14 +18,14 @@ def all(input, dim=None, keepdim=False, *, out=None): return ret -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def amax(input, dim=None, keepdim=False, *, out=None): return ivy.max(input, axis=dim, keepdims=keepdim, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def amin(input, dim=None, keepdim=False, *, out=None): @@ -34,9 +34,7 @@ def amin(input, dim=None, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "complex")}, "torch" -) +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16", "complex")}, "torch") def aminmax(input, *, dim=None, keepdim=False, out=None): minmax_tuple = namedtuple("minmax", ["min", "max"]) return minmax_tuple( @@ -55,7 +53,7 @@ def any(input, dim=None, keepdim=False, *, out=None): return ret -@with_unsupported_dtypes({"2.1.2 and below": ("complex", "bool")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex", "bool")}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def argmax(input, dim=None, keepdim=False): @@ -71,7 +69,7 @@ def argmin(input, dim=None, keepdim=False): @numpy_to_torch_style_args @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.2 and below": ("uint8", "int8")}, + {"2.2 and below": ("uint8", "int8")}, "torch", ) def count_nonzero(input, dim=None): @@ -131,7 +129,7 @@ def mean(input, dim=None, keepdim=False, *, dtype=None, out=None): return ivy.mean(input, axis=dim, keepdims=keepdim, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex", "float16", "bool")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex", "float16", "bool")}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def median(input, dim=None, keepdim=False, *, out=None): @@ -168,7 +166,7 @@ def median(input, dim=None, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back @with_unsupported_dtypes( - {"2.1.2 and below": ("complex64", "complex128")}, + {"2.2 and below": ("complex64", "complex128")}, "torch", ) def min(*input, dim=None, keepdim=False, out=None): @@ -195,7 +193,7 @@ def moveaxis(input, source, destination): return ivy.moveaxis(input, source, destination) -@with_supported_dtypes({"2.1.2 and below": ("float",)}, "torch") +@with_supported_dtypes({"2.2 and below": ("float",)}, "torch") @numpy_to_torch_style_args @to_ivy_arrays_and_back def nanmean(input, dim=None, keepdim=False, *, dtype=None, out=None): @@ -240,7 +238,7 @@ def nanmedian(input, dim=None, keepdim=False, *, out=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float", "int")}, + {"2.2 and below": ("float", "int")}, "torch", ) def nansum(input, dim=None, keepdim=False, *, dtype=None): @@ -250,7 +248,7 @@ def nansum(input, dim=None, keepdim=False, *, dtype=None): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float", "complex")}, + {"2.2 and below": ("float", "complex")}, "torch", ) def norm(input, p="fro", dim=None, keepdim=False, out=None, dtype=None): @@ -276,7 +274,7 @@ def norm(input, p="fro", dim=None, keepdim=False, out=None, dtype=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -292,7 +290,7 @@ def prod(input, dim=None, keepdim=False, *, dtype=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def quantile(input, q, dim=None, keepdim=False, *, interpolation="linear", out=None): return ivy.quantile( input, q, axis=dim, keepdims=keepdim, interpolation=interpolation, out=out @@ -301,14 +299,14 @@ def quantile(input, q, dim=None, keepdim=False, *, interpolation="linear", out=N @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("float16", "bool", "integer")}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("float16", "bool", "integer")}, "torch") def std(input, dim=None, unbiased=True, keepdim=False, *, out=None): return ivy.std(input, axis=dim, correction=int(unbiased), keepdims=keepdim, out=out) @numpy_to_torch_style_args @to_ivy_arrays_and_back -@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def std_mean(input, dim, unbiased, keepdim=False, *, out=None): temp_std = ivy.std( input, axis=dim, correction=int(unbiased), keepdims=keepdim, out=out @@ -323,7 +321,7 @@ def sum(input, dim=None, keepdim=False, *, dtype=None, out=None): return ivy.sum(input, axis=dim, dtype=dtype, keepdims=keepdim, out=out) -@with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") +@with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") @to_ivy_arrays_and_back def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None): if dim is not None: @@ -342,7 +340,7 @@ def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=No @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "complex", ) @@ -364,7 +362,7 @@ def unique_consecutive(input, return_inverse=False, return_counts=False, dim=Non @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -379,7 +377,7 @@ def var(input, dim, unbiased, keepdim=False, *, out=None): @to_ivy_arrays_and_back @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index fbaa3dc37d9c4..f470a9860420b 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -149,20 +149,20 @@ def reshape(self, *args, shape=None): else: raise ValueError("reshape() got no values for argument 'shape'") - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @with_unsupported_dtypes({"2.6.0 and below": ("float16",)}, "paddle") def reshape_as(self, other): return torch_frontend.reshape(self, other.shape) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def add(self, other, *, alpha=1): return torch_frontend.add(self, other, alpha=alpha) - # @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + # @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def divide(self, other, *, out=None): return torch_frontend.divide(self, other, out=out) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def sub(self, other, *, alpha=1): return torch_frontend.sub(self, other, alpha=alpha) @@ -177,105 +177,105 @@ def any(self, dim=None, keepdim=False): def all(self, dim=None, keepdim=False): return torch_frontend.all(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def add_(self, other, *, alpha=1): self.ivy_array = self.add(other, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addmm(self, mat1, mat2, *, beta=1, alpha=1): return torch_frontend.addmm(self, mat1, mat2, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addmm_(self, mat1, mat2, *, beta=1, alpha=1): self.ivy_array = self.addmm(mat1, mat2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addmv(self, mat, vec, *, beta=1, alpha=1): return torch_frontend.addmv(self, mat, vec, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addmv_(self, mat, vec, *, beta=1, alpha=1): self.ivy_array = torch_frontend.addmv( self, mat, vec, beta=beta, alpha=alpha ).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addbmm(self, batch1, batch2, *, beta=1, alpha=1): return torch_frontend.addbmm(self, batch1, batch2, beta=beta, alpha=alpha) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addbmm_(self, batch1, batch2, *, beta=1, alpha=1): self.ivy_array = self.addbmm(batch1, batch2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def subtract_(self, other, *, alpha=1): self.ivy_array = self.sub(other, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def asin(self): return torch_frontend.asin(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def asin_(self): self.ivy_array = self.asin().ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def sum(self, dim=None, keepdim=False, *, dtype=None): return torch_frontend.sum(self, dim=dim, keepdim=keepdim, dtype=dtype) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def sin(self): return torch_frontend.sin(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def sin_(self): self.ivy_array = self.sin().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def sinh(self): return torch_frontend.sinh(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def sinh_(self): self.ivy_array = self.sinh().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def cos(self): return torch_frontend.cos(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def cos_(self): self.ivy_array = self.cos().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def cosh(self): return torch_frontend.cosh(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def cosh_(self): self.ivy_array = self.cosh().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def atan(self): return torch_frontend.atan(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def atan_(self): self.ivy_array = self.atan().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def atan2(self, other): return torch_frontend.atan2(self, other) @@ -321,56 +321,56 @@ def float(self, memory_format=None): def double(self): return self.to(torch_frontend.float64) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def asinh(self): return torch_frontend.asinh(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def asinh_(self): self.ivy_array = self.asinh().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def tan(self): return torch_frontend.tan(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def tan_(self): self.ivy_array = self.tan().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def tanh(self): return torch_frontend.tanh(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def tanh_(self): self.ivy_array = self.tanh().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def atanh(self): return torch_frontend.atanh(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def atanh_(self): self.ivy_array = self.atanh().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def log(self): return torch_frontend.log(self) - @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def log2_(self): self.ivy_array = self.log2().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def logit(self): return torch_frontend.logit(self) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "uint16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "uint16")}, "torch") def copy_(self, other, non_blocking=False): ivy.utils.assertions.check_one_way_broadcastable( self.ivy_array.shape, torch_frontend.tensor(other).ivy_array.shape @@ -378,31 +378,31 @@ def copy_(self, other, non_blocking=False): self._ivy_array = torch_frontend.tensor(other).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def log_(self): self.ivy_array = self.log().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def log2(self): return torch_frontend.log2(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def relu(self): return torch_frontend.nn.functional.relu(self) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") def amax(self, dim=None, keepdim=False): return torch_frontend.amax(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") def amin(self, dim=None, keepdim=False): return torch_frontend.amin(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("complex", "float16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("complex", "float16")}, "torch") def aminmax(self, dim=None, keepdim=False): return torch_frontend.aminmax(self, dim=dim, keepdim=keepdim) @@ -413,7 +413,7 @@ def abs_(self): self.ivy_array = self.abs().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def logical_and(self, other): return torch_frontend.logical_and(self, other) @@ -424,11 +424,11 @@ def logical_not_(self): self.ivy_array = ivy.astype(self.logical_not().ivy_array, self.dtype) return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def logical_or(self, other): return torch_frontend.logical_or(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def logical_xor(self, other): return torch_frontend.logical_xor(self, other) @@ -438,14 +438,14 @@ def bitwise_not(self): def bitwise_and(self, other): return torch_frontend.bitwise_and(self, other) - @with_supported_dtypes({"2.1.2 and below": ("integer",)}, "torch") + @with_supported_dtypes({"2.2 and below": ("integer",)}, "torch") def bitwise_or(self, other): return torch_frontend.bitwise_or(self, other) def bitwise_left_shift(self, other): return torch_frontend.bitwise_left_shift(self, other) - @with_supported_dtypes({"2.1.2 and below": ("integer",)}, "torch") + @with_supported_dtypes({"2.2 and below": ("integer",)}, "torch") def bitwise_or_(self, other): self.ivy_array = self.bitwise_or(other).ivy_array return self @@ -477,13 +477,13 @@ def new_ones( size, dtype=dtype, device=device, requires_grad=requires_grad ) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def floor(self, *, out=None): return torch_frontend.floor(self) @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "uint8", "uint32", @@ -500,7 +500,7 @@ def not_equal(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "uint8", "uint32", @@ -522,19 +522,19 @@ def eq(self, other): def equal(self, other): return torch_frontend.equal(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def erf(self, *, out=None): return torch_frontend.erf(self, out=out) @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "bfloat16")}, "torch" + {"2.2 and below": ("float32", "float64", "bfloat16")}, "torch" ) def erf_(self, *, out=None): self.ivy_array = self.erf(out=out).ivy_array return self @with_supported_device_and_dtypes( - {"2.1.0 and below": {"cpu": ("float32", "float64")}}, + {"2.2 and below": {"cpu": ("float32", "float64")}}, "torch", ) def erfc_(self, *, out=None): @@ -634,11 +634,11 @@ def to(self, *args, **kwargs): ) return cast_tensor - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def acos(self): return torch_frontend.acos(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def acos_(self): self.ivy_array = self.acos().ivy_array return self @@ -658,7 +658,7 @@ def new_tensor( _data = ivy.asarray(data, copy=True, dtype=dtype, device=device) return torch_frontend.tensor(_data) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def view_as(self, other): return self.view(size=other.shape) @@ -690,7 +690,7 @@ def detach_(self): self.ivy_array = self.detach().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("uint16",)}, "torch") @numpy_to_torch_style_args def unsqueeze(self, dim): return torch_frontend.unsqueeze(self, dim) @@ -789,7 +789,7 @@ def max(self, dim=None, keepdim=False): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "complex", "bfloat16", "bool", @@ -815,15 +815,15 @@ def is_cuda(self): def is_meta(self): return "meta" in ivy.dev(self.ivy_array) - @with_unsupported_dtypes({"2.1.2 and below": ("uint16", "bool")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("uint16", "bool")}, "torch") def positive(self): return torch_frontend.positive(self) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def pow(self, exponent): return torch_frontend.pow(self, exponent) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def pow_(self, exponent): self.ivy_array = self.pow(exponent).ivy_array return self @@ -844,7 +844,7 @@ def matmul(self, other): return torch_frontend.matmul(self, other) @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" + {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_power(self, n, *, out=None): return torch_frontend.linalg.matrix_power(self, n, out=out) @@ -853,20 +853,20 @@ def argwhere(self): return torch_frontend.argwhere(self) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("complex", "bool")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("complex", "bool")}, "torch") def argmax(self, dim=None, keepdim=False): return torch_frontend.argmax(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") def argmin(self, dim=None, keepdim=False): return torch_frontend.argmin(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") def argsort(self, dim=-1, descending=False): return torch_frontend.argsort(self, dim=dim, descending=descending) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def ceil(self): return torch_frontend.ceil(self) @@ -889,22 +889,22 @@ def permute(self, *args, dims=None): raise ValueError("permute() got no values for argument 'dims'") @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def mean(self, dim=None, keepdim=False): return torch_frontend.mean(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @numpy_to_torch_style_args def nanmean(self, dim=None, keepdim=False): return torch_frontend.nanmean(self, dim=dim, keepdim=keepdim) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") @numpy_to_torch_style_args def nansum(self, dim=None, keepdim=False): return torch_frontend.nansum(self, dim=dim, keepdim=keepdim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def median(self, dim=None, keepdim=False): return torch_frontend.median(self, dim=dim, keepdim=keepdim) @@ -922,32 +922,32 @@ def flatten(self, start_dim=0, end_dim=-1): return torch_frontend.flatten(self, start_dim, end_dim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def cumsum(self, dim, *, dtype=None): return torch_frontend.cumsum(self, dim, dtype=dtype) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def cumsum_(self, dim, *, dtype=None): self.ivy_array = self.cumsum(dim, dtype=dtype).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def inverse(self): return torch_frontend.inverse(self) - @with_unsupported_dtypes({"2.1.2 and below": ("bool", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bool", "bfloat16")}, "torch") def neg(self): return torch_frontend.negative(self) - @with_unsupported_dtypes({"2.1.2 and below": ("bool",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bool",)}, "torch") def neg_(self): self.ivy_array = torch_frontend.negative(self).ivy_array return self __neg__ = neg - @with_unsupported_dtypes({"2.1.2 and below": ("bool", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bool", "bfloat16")}, "torch") def negative(self): return torch_frontend.negative(self) @@ -970,7 +970,7 @@ def type(self, dtype=None, non_blocking=False, **kwargs): else: return str(self.dtype) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def type_as(self, other): if self.dtype != other.dtype: return torch_frontend.tensor(ivy.astype(self.ivy_array, other.dtype)) @@ -985,7 +985,7 @@ def squeeze(self, dim=None): return torch_frontend.squeeze(self, dim) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("uint16",)}, "torch") def squeeze_(self, dim=None): self.ivy_array = self.squeeze(dim).ivy_array return self @@ -1009,35 +1009,35 @@ def tril_(self, diagonal=0): def index_select(self, dim, index): return torch_frontend.index_select(self, dim, index) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def clamp(self, min=None, max=None): return torch_frontend.clamp(self, min=min, max=max) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def clamp_(self, min=None, max=None): self.ivy_array = self.clamp(min=min, max=max).ivy_array return self @with_unsupported_dtypes( - {"2.1.2 and below": ("bool", "bfloat16", "float16", "complex")}, "torch" + {"2.2 and below": ("bool", "bfloat16", "float16", "complex")}, "torch" ) def clamp_min(self, min=None): return torch_frontend.clamp(self, min=min) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def sqrt(self): return torch_frontend.sqrt(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def rsqrt(self): return torch_frontend.rsqrt(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def rsqrt_(self): self.ivy_array = self.rsqrt().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def sqrt_(self): self.ivy_array = self.sqrt().ivy_array return self @@ -1048,7 +1048,7 @@ def where(self, condition, other): def clone(self, memory_format=None): return torch_frontend.tensor(ivy.array(self.ivy_array, copy=True)) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def acosh(self): return torch_frontend.acosh(self) @@ -1061,38 +1061,38 @@ def masked_fill_(self, mask, value): self.ivy_array = self.masked_fill(mask, value).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def index_add_(self, dim, index, source, *, alpha=1): self.ivy_array = torch_frontend.index_add( self, dim, index, source, alpha=alpha ).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def index_add(self, dim, index, source, *, alpha=1): return torch_frontend.index_add( self._ivy_array, dim, index, source, alpha=alpha ) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def acosh_(self): self.ivy_array = self.acosh().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def numpy(self): return np_frontend_array(self.ivy_array) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def sigmoid(self): return torch_frontend.sigmoid(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def sigmoid_(self): self.ivy_array = self.sigmoid().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def softmax(self, dim=None, dtype=None): return torch_frontend.nn.functional.softmax(self, dim=dim, dtype=dtype) @@ -1124,7 +1124,7 @@ def remainder(self, other, *, out=None): return torch_frontend.remainder(self, other, out=out) @with_supported_dtypes( - {"2.1.2 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" + {"2.2 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" ) def reciprocal_(self): self.ivy_array = torch_frontend.reciprocal(self).ivy_array @@ -1142,12 +1142,12 @@ def bitwise_and_(self, other): self.ivy_array = self.bitwise_and(other).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def atan2_(self, other): self.ivy_array = self.atan2(other).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def fmax(self, other): return torch_frontend.fmax(self, other) @@ -1157,20 +1157,20 @@ def fmin(self, other): def msort(self): return torch_frontend.msort(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def trunc(self): return torch_frontend.trunc(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def trunc_(self): self.ivy_array = self.trunc().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def fix(self): return torch_frontend.fix(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def fix_(self): self.ivy_array = self.fix().ivy_array return self @@ -1181,11 +1181,11 @@ def isinf(self): def is_complex(self): return torch_frontend.is_complex(self._ivy_array) - @with_unsupported_dtypes({"2.1.2 and below": ("uint16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("uint16", "bfloat16")}, "torch") def is_floating_point(self): return torch_frontend.is_floating_point(self._ivy_array) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def isreal(self): return torch_frontend.isreal(self._ivy_array) @@ -1196,17 +1196,17 @@ def addr_(self, vec1, vec2, *, beta=1, alpha=1): self.ivy_array = self.addr(vec1, vec2, beta=beta, alpha=alpha).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def dot(self, tensor): return torch_frontend.dot(self, tensor) - @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def bernoulli(self, p, *, generator=None, out=None): return torch_frontend.bernoulli( self._ivy_array, p, generator=generator, out=out ) - @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def bernoulli_(self, p, *, generator=None, out=None): self.ivy_array = self.bernoulli(p, generator=generator, out=out).ivy_array return self @@ -1226,19 +1226,19 @@ def __bool__(self): "Use a.any() or a.all()" ) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __add__(self, other): return torch_frontend.add(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __mod__(self, other): return torch_frontend.remainder(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __pow__(self, exponent): return self.pow(exponent) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __rpow__(self, other): return torch_frontend.pow(other, self) @@ -1260,21 +1260,21 @@ def __iter__(self): for i in range(self.shape[0]): yield self[i] - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __radd__(self, other): return torch_frontend.add(other, self) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __mul__(self, other): return torch_frontend.mul(self, other) - @with_unsupported_dtypes({"2.1.2 and below": "bfloat16"}, "torch") + @with_unsupported_dtypes({"2.2 and below": "bfloat16"}, "torch") def __matmul__(self, other): return torch_frontend.matmul(self, other) @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "int8", "int16", @@ -1287,14 +1287,14 @@ def __matmul__(self, other): def __rmul__(self, other): return torch_frontend.mul(other, self) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __sub__(self, other): return torch_frontend.subtract(self, other) def __truediv__(self, other): return torch_frontend.div(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def __floordiv__(self, other): return torch_frontend.floor_divide(self, other) @@ -1349,39 +1349,39 @@ def __float__(self): item = item.real return float(item) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __eq__(self, other): return torch_frontend.eq(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("complex",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("complex",)}, "torch") def __gt__(self, other): return torch_frontend.greater(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __ge__(self, other): return torch_frontend.greater_equal(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __ne__(self, other): return self.ne(other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __rsub__(self, other): return torch_frontend.subtract(other, self) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __lt__(self, other): return torch_frontend.less(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __le__(self, other): return torch_frontend.less_equal(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def __or__(self, other): return torch_frontend.bitwise_or(self, other) - @with_supported_dtypes({"2.1.2 and below": ("integer", "bool")}, "torch") + @with_supported_dtypes({"2.2 and below": ("integer", "bool")}, "torch") def __invert__(self): return torch_frontend.bitwise_not(self) @@ -1415,7 +1415,7 @@ def item(self): ) @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def cumprod(self, dim, dtype=None): return torch_frontend.cumprod(self, dim, dtype=dtype) @@ -1428,26 +1428,26 @@ def cov(self, /, *, correction=1, fweights=None, aweights=None): self, correction=correction, fweights=fweights, aweights=aweights ) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, "torch") def exp(self): return torch_frontend.exp(self) @with_supported_dtypes( - {"2.1.2 and below": ("bfloat16", "float32", "float64")}, "torch" + {"2.2 and below": ("bfloat16", "float32", "float64")}, "torch" ) def expm1(self): return torch_frontend.expm1(self) # remove "bfloat16" from the below decorator after fixing ivy.Array.__repr__ method @with_unsupported_dtypes( - {"2.1.2 and below": ("bfloat16", "float16", "complex")}, "torch" + {"2.2 and below": ("bfloat16", "float16", "complex")}, "torch" ) def expm1_(self): self.ivy_array = torch_frontend.expm1(self).ivy_array return self # fmt: off - @with_unsupported_dtypes({"2.1.2 and below": ("int8", "int16", "int32", "int64", "uint8", "bool", "float16",)},"torch",) # noqa + @with_unsupported_dtypes({"2.2 and below": ("int8", "int16", "int32", "int64", "uint8", "bool", "float16",)},"torch",) # noqa def exp_(self): self.ivy_array = self.exp().ivy_array return self @@ -1456,33 +1456,33 @@ def exp_(self): def mul(self, other): return torch_frontend.mul(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def ceil_(self): self.ivy_array = torch_frontend.ceil(self).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def mul_(self, other): self.ivy_array = self.mul(other).ivy_array # the return dtype is the same as the input dtype self.ivy_array = self.to(self.dtype).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, "torch") def round(self, *, decimals=0): return torch_frontend.round(self, decimals=decimals) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, "torch") def round_(self, *, decimals=0): self.ivy_array = self.round(decimals=decimals).ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def cross(self, other, dim=-1): return torch_frontend.cross(self, other, dim=dim) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def det(self): return torch_frontend.det(self) @@ -1502,13 +1502,13 @@ def nonzero(self, as_tuple=False): def mm(self, mat2): return torch_frontend.mm(self, mat2) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, "torch") def square(self): return torch_frontend.square(self._ivy_array) @with_supported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "float32", "float64", @@ -1527,16 +1527,16 @@ def square_(self): self.ivy_array = torch_frontend.square(self._ivy_array).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def log10(self): return torch_frontend.log10(self._ivy_array) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def log10_(self): self.ivy_array = self.log10().ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("uint16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("uint16",)}, "torch") def zero_(self): ret = torch_frontend.zeros_like(self) self.ivy_array = ivy.inplace_update(self.ivy_array, ret) @@ -1547,7 +1547,7 @@ def short(self, memory_format=None): return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def prod(self, dim=None, keepdim=False, *, dtype=None): return torch_frontend.prod(self, dim=dim, keepdim=keepdim, dtype=dtype) @@ -1559,7 +1559,7 @@ def div_(self, other, *, rounding_mode=None): return self @with_supported_dtypes( - {"2.1.2 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" + {"2.2 and below": ("float16", "float32", "float64", "bfloat16")}, "torch" ) def true_divide_(self, other): self.ivy_array = self.div(other, rounding_mode=None).ivy_array @@ -1575,26 +1575,26 @@ def normal_(self, mean=0, std=1, *, generator=None): ) return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addcdiv(self, tensor1, tensor2, *, value=1): return torch_frontend.addcdiv(self, tensor1, tensor2, value=value) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addcmul(self, tensor1, tensor2, *, value=1): return torch_frontend.addcmul(self, tensor1, tensor2, value=value) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addcmul_(self, tensor1, tensor2, *, value=1): self.ivy_array = self.addcmul(tensor1, tensor2, value=value).ivy_array return self sign_decorator_dtypes = ("float16", "complex", "bool") - @with_unsupported_dtypes({"2.1.2 and below": sign_decorator_dtypes}, "torch") + @with_unsupported_dtypes({"2.2 and below": sign_decorator_dtypes}, "torch") def sign(self): return torch_frontend.sign(self._ivy_array) - @with_unsupported_dtypes({"2.1.2 and below": sign_decorator_dtypes}, "torch") + @with_unsupported_dtypes({"2.2 and below": sign_decorator_dtypes}, "torch") def sign_(self): self.ivy_array = self.sign().ivy_array return self @@ -1605,11 +1605,11 @@ def std(self, dim=None, unbiased=True, keepdim=False, *, out=None): self, dim=dim, unbiased=unbiased, keepdim=keepdim, out=out ) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def fmod(self, other, *, out=None): return torch_frontend.fmod(self, other, out=out) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def fmod_(self, other): self.ivy_array = self.fmod(other).ivy_array return self @@ -1620,96 +1620,96 @@ def norm(self, p="fro", dim=None, keepdim=False, dtype=None): def tolist(self): return self._ivy_array.to_list() - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def multiply(self, other, *, out=None): return torch_frontend.multiply(self, other, out=out) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def multiply_(self, other, *, out=None): self.ivy_array = torch_frontend.multiply(self, other, out=out).ivy_array return self @numpy_to_torch_style_args - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def topk(self, k, dim=None, largest=True, sorted=True): return torch_frontend.topk(self, k, dim=dim, largest=largest, sorted=sorted) rshift_dtypes = ("float16", "bfloat16", "float32", "float64", "bool", "complex") - @with_unsupported_dtypes({"2.1.2 and below": rshift_dtypes}, "torch") + @with_unsupported_dtypes({"2.2 and below": rshift_dtypes}, "torch") def bitwise_right_shift(self, other, *, out=None): return torch_frontend.bitwise_right_shift(self._ivy_array, other) @with_supported_dtypes( - {"2.1.2 and below": ("uint8", "int8", "int32", "int64")}, "torch" + {"2.2 and below": ("uint8", "int8", "int32", "int64")}, "torch" ) def bitwise_right_shift_(self, other, *, out=None): self.ivy_array = self.bitwise_right_shift(other, out=out).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def logdet(self): chol = torch_frontend.cholesky(self) return 2 * torch_frontend.sum( torch_frontend.log(torch_frontend.real(torch_frontend.diagonal(chol))) ) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def copysign(self, other, *, out=None): return torch_frontend.copysign(self, other, out=out) @with_supported_dtypes( - {"2.1.2 and below": ("float16", "float32", "float64")}, "torch" + {"2.2 and below": ("float16", "float32", "float64")}, "torch" ) def copysign_(self, other, *, out=None): self.ivy_array = self.copysign(other, out=out).ivy_array return self @with_unsupported_dtypes( - {"2.1.2 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.2 and below": ("complex", "bfloat16", "bool")}, "torch" ) def greater(self, other, *, out=None): return torch_frontend.greater(self, other, out=out) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "bool")}, "torch") def greater_(self, other): self.ivy_array = ivy.astype(self.greater(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.2 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.2 and below": ("complex", "bfloat16", "bool")}, "torch" ) def greater_equal(self, other, *, out=None): return torch_frontend.greater_equal(self, other, out=out) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "bool")}, "torch") def greater_equal_(self, other): self.ivy_array = ivy.astype(self.greater_equal(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.2 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.2 and below": ("complex", "bfloat16", "bool")}, "torch" ) def less(self, other, *, out=None): return torch_frontend.less(self, other, out=out) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "bool")}, "torch") def less_(self, other): self.ivy_array = ivy.astype(self.less(other).ivy_array, self.dtype) return self @with_unsupported_dtypes( - {"2.1.2 and below": ("complex", "bfloat16", "bool")}, "torch" + {"2.2 and below": ("complex", "bfloat16", "bool")}, "torch" ) def less_equal(self, other, *, out=None): return torch_frontend.less_equal(self, other, out=out) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "bool")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "bool")}, "torch") def less_equal_(self, other): self.ivy_array = ivy.astype(self.less_equal(other).ivy_array, self.dtype) return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def eq_(self, other): self.ivy_array = ivy.astype( torch_frontend.eq(self, other).ivy_array, self.dtype @@ -1738,14 +1738,14 @@ def stride(self, dim=None): return strides @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "bfloat16")}, "torch" + {"2.2 and below": ("float32", "float64", "bfloat16")}, "torch" ) def log1p(self): promoted_type = ivy.promote_types(self.dtype, "float32") res = torch_frontend.log1p(self) return res.to(promoted_type) - @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def log1p_(self): promoted_type = ivy.promote_types(self.dtype, "float32") res = torch_frontend.log1p(self) @@ -1766,14 +1766,14 @@ def baddbmm_(self, batch1, batch2, *, beta=1, alpha=1): def bmm(self, mat2): return torch_frontend.bmm(self, mat2=mat2) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def floor_(self): self.ivy_array = self.floor().ivy_array return self @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "complex", "float64", @@ -1789,7 +1789,7 @@ def diff(self, n=1, dim=-1, prepend=None, append=None): def diag(self, diagonal=0): return torch_frontend.diag(self, diagonal=diagonal) - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def diagonal(self, offset=0, dim1=0, dim2=1): return torch_frontend.diagonal(self, offset=offset, dim1=dim1, dim2=dim2) @@ -1797,14 +1797,14 @@ def gather(self, dim, index): return torch_frontend.gather(self, dim=dim, index=index) @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add_(self, dim, index, src): self.ivy_array = ivy.put_along_axis(self.ivy_array, index, src, dim, mode="sum") return self @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_(self, dim, index, src, *, reduce=None): if reduce is None: @@ -1821,7 +1821,7 @@ def scatter_(self, dim, index, src, *, reduce=None): return self @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce_(self, dim, index, src, reduce, *, include_self=True): if reduce == "prod": @@ -1832,19 +1832,19 @@ def scatter_reduce_(self, dim, index, src, reduce, *, include_self=True): return self @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add(self, dim, index, src): return torch_frontend.scatter_add(self, dim, index, src) @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter(self, dim, index, src): return torch_frontend.scatter_reduce(self, dim, index, src, reduce="replace") @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce(self, dim, index, src, reduce, *, include_self=True): return torch_frontend.scatter_reduce(self, dim, index, src, reduce=reduce) @@ -1855,14 +1855,14 @@ def take_along_dim(self, indices, dim): def movedim(self, source, destination): return torch_frontend.movedim(self, source=source, destination=destination) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def addcdiv_(self, tensor1, tensor2, *, value=1): self.ivy_array = self.addcdiv( tensor1=tensor1, tensor2=tensor2, value=value ).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, "torch") def cholesky(self, upper=False): return torch_frontend.cholesky(self, upper=upper) @@ -1901,11 +1901,11 @@ def backward(self, gradient=None, retain_graph=None, create_graph=False): else: next_function(_grad_list[idx]) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def logaddexp(self, other): return torch_frontend.logaddexp(self, other) - @with_unsupported_dtypes({"2.1.2 and below": ("float16",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") def logaddexp2(self, other): self.ivy_array = torch_frontend.logaddexp2(self, other).ivy_array return self @@ -1930,17 +1930,17 @@ def adjoint(self): return torch_frontend.adjoint(self) @with_unsupported_dtypes( - {"2.1.2 and below": ("int16", "float16", "bfloat16")}, "torch" + {"2.2 and below": ("int16", "float16", "bfloat16")}, "torch" ) def conj(self): return torch_frontend.conj(self) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "bfloat16")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def svd(self, some=True, compute_uv=True, *, out=None): return torch_frontend.svd(self, some=some, compute_uv=compute_uv, out=out) @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16", "float32", "float64", "complex")}, + {"2.2 and below": ("float16", "bfloat16", "float32", "float64", "complex")}, "torch", ) def gcd(self, other, *, out=None): @@ -1948,7 +1948,7 @@ def gcd(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", "uint16", @@ -1968,7 +1968,7 @@ def char(self): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", "float32", @@ -1985,7 +1985,7 @@ def lcm(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", "float32", @@ -2006,7 +2006,7 @@ def lcm_(self, other, *, out=None): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "int8", "uint8", @@ -2023,7 +2023,7 @@ def triu_(self, diagonal=0): return self @with_unsupported_dtypes( - {"2.1.2 and below": ("float16", "bfloat16")}, + {"2.2 and below": ("float16", "bfloat16")}, "torch", ) def quantile(self, q, dim=None, keepdim=False, *, interpolation="linear", out=None): @@ -2033,7 +2033,7 @@ def quantile(self, q, dim=None, keepdim=False, *, interpolation="linear", out=No @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "int8", "int16", "uint8", @@ -2065,7 +2065,7 @@ def random_( @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "integer", "unsigned", "bfloat16", @@ -2084,13 +2084,13 @@ def uniform_(self, from_=0, to=1, *, generator=None): ) return self - @with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") + @with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") def frac(self, name=None): return torch_frontend.frac(self._ivy_array) @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -2102,7 +2102,7 @@ def sinc(self): @with_supported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float32", "float64", "bfloat16", @@ -2114,7 +2114,7 @@ def sinc_(self): self.ivy_array = torch_frontend.sinc(self).ivy_array return self - @with_unsupported_dtypes({"2.1.2 and below": ("uint8",)}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("uint8",)}, "torch") def index_fill(self, dim, index, value): arr = torch_frontend.moveaxis(self, dim, 0) arr[ivy.to_list(index)] = value @@ -2123,7 +2123,7 @@ def index_fill(self, dim, index, value): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "int8", "uint8", @@ -2146,7 +2146,7 @@ def unique_consecutive(self, return_inverse, return_counts, dim): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "uint16", "uint32", "uint64", @@ -2163,7 +2163,7 @@ def cummax(self, dim): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "int8", "uint8", @@ -2181,7 +2181,7 @@ def triu(self, diagonal=0): return torch_frontend.triu(self, diagonal) @with_unsupported_dtypes( - {"2.1.2 and below": ("bfloat16",)}, + {"2.2 and below": ("bfloat16",)}, "torch", ) def xlogy_(self, *, other, out=None): @@ -2190,7 +2190,7 @@ def xlogy_(self, *, other, out=None): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "uint8", "uint32", @@ -2207,7 +2207,7 @@ def ne(self, other): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "uint8", "uint32", @@ -2224,7 +2224,7 @@ def ne_(self, other): @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "bfloat16", "int8", "uint8", @@ -2244,7 +2244,7 @@ def unique(self, sorted=True, return_inverse=False, return_counts=False, dim=Non @with_unsupported_dtypes( { - "2.1.2 and below": ( + "2.2 and below": ( "float16", "bfloat16", ) @@ -2254,7 +2254,7 @@ def unique(self, sorted=True, return_inverse=False, return_counts=False, dim=Non def xlogy(self, *, other, out=None): return torch_frontend.xlogy(self, other, out=out) - @with_unsupported_dtypes({"2.1.2 and below": "complex"}, "torch") + @with_unsupported_dtypes({"2.2 and below": "complex"}, "torch") def minimum(self, other, *, out=None): return torch_frontend.minimum(self, other=other, out=out) @@ -2262,7 +2262,7 @@ def rad2deg(self, *, out=None): return torch_frontend.rad2deg(self, out=out) @with_supported_dtypes( - {"2.1.2 and below": "valid"}, + {"2.2 and below": "valid"}, "torch", ) def corrcoef(self): @@ -2290,11 +2290,11 @@ def _set(index): return self - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def erfinv(self, *, out=None): return torch_frontend.erfinv(self, out=out) - @with_unsupported_dtypes({"2.1.2 and below": ("float16", "complex")}, "torch") + @with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") def erfinv_(self, *, out=None): ret = self.erfinv(out=out) self._ivy_array = ivy.inplace_update( diff --git a/ivy/functional/frontends/torch/tensor_functions.py b/ivy/functional/frontends/torch/tensor_functions.py index 34fa5f29d7034..4a1512c147f4e 100644 --- a/ivy/functional/frontends/torch/tensor_functions.py +++ b/ivy/functional/frontends/torch/tensor_functions.py @@ -31,7 +31,7 @@ def numel(input): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter(input, dim, index, src): return ivy.put_along_axis(input, index, src, dim, mode="replace") @@ -39,7 +39,7 @@ def scatter(input, dim, index, src): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_add(input, dim, index, src): return ivy.put_along_axis(input, index, src, dim, mode="sum") @@ -47,7 +47,7 @@ def scatter_add(input, dim, index, src): @to_ivy_arrays_and_back @with_supported_dtypes( - {"2.1.2 and below": ("float32", "float64", "int32", "int64")}, "torch" + {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) def scatter_reduce(input, dim, index, src, reduce, *, include_self=True): mode_mappings = { diff --git a/ivy/functional/frontends/torch/utilities.py b/ivy/functional/frontends/torch/utilities.py index 728c788a61569..b53e5fe6aa8e0 100644 --- a/ivy/functional/frontends/torch/utilities.py +++ b/ivy/functional/frontends/torch/utilities.py @@ -20,7 +20,7 @@ def _assert(condition, message): # ------------ # -@with_supported_dtypes({"2.1.2 and above": ("int64",)}, "torch") +@with_supported_dtypes({"2.2 and above": ("int64",)}, "torch") @to_ivy_arrays_and_back def bincount(x, weights=None, minlength=0): return ivy.bincount(x, weights=weights, minlength=minlength) diff --git a/ivy/functional/frontends/torchvision/ops.py b/ivy/functional/frontends/torchvision/ops.py index 582003655838c..4d1a27185730e 100644 --- a/ivy/functional/frontends/torchvision/ops.py +++ b/ivy/functional/frontends/torchvision/ops.py @@ -38,7 +38,7 @@ def box_iou(boxes1, boxes2): @with_unsupported_device_and_dtypes( { - "2.1.2 and below": { + "2.2 and below": { "cpu": ("float16",), } }, @@ -64,7 +64,7 @@ def remove_small_boxes(boxes, min_size): return ivy.nonzero((w >= min_size) & (h >= min_size))[0] -@with_supported_dtypes({"2.1.2 and below": ("float32", "float64")}, "torch") +@with_supported_dtypes({"2.2 and below": ("float32", "float64")}, "torch") @to_ivy_arrays_and_back def roi_align( input, boxes, output_size, spatial_scale=1.0, sampling_ratio=1, aligned=False From e6e72f97c94e2518dc16e8bd63d49ec322579a97 Mon Sep 17 00:00:00 2001 From: David Adlai Nettey <42801341+Adlai-1@users.noreply.github.com> Date: Sat, 10 Feb 2024 13:44:58 +0000 Subject: [PATCH 772/978] fix: changed docstring (#28201) Co-authored-by: ivy-branch --- ivy/functional/ivy/device.py | 43 +++++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 13 deletions(-) diff --git a/ivy/functional/ivy/device.py b/ivy/functional/ivy/device.py index afdf6105b6e97..b3c1c7a72845b 100644 --- a/ivy/functional/ivy/device.py +++ b/ivy/functional/ivy/device.py @@ -826,30 +826,47 @@ def default_device( @handle_exceptions def set_default_device(device: Union[ivy.Device, ivy.NativeDevice], /) -> None: - """Set the default device to given device instance. + """Sets the default device to the argument provided in the function. Parameters ---------- device - The device to set as the default device + The device to be set as the default device. + + Returns + ------- + ret + The new default device. Examples -------- - >>> ivy.set_default_device("cpu") >>> ivy.default_device() 'cpu' - >>> ivy.set_backend("torch") - >>> ivy.set_default_device("gpu:0") - >>> ivy.default_device(as_native=True) - device(type='cuda', index=0) + >>> ivy.set_backend('jax') + >>> ivy.set_default_device('gpu:0') + >>> ivy.default_device() + 'gpu:0' - >>> import torch - >>> ivy.set_backend("torch") - >>> device = torch.device("cuda") - >>> ivy.set_default_device(device) - >>> ivy.default_device(as_native=True) - device(type='cuda') + >>> ivy.set_backend('torch') + >>> ivy.set_default_device('gpu:1') + >>> ivy.default_device() + 'gpu:1 + + >>> ivy.set_backend('tensorflow') + >>> ivy.set_default_device('tpu:0) + >>> ivy.default_device() + 'tpu:0 + + >>> ivy.set_backend('paddle') + >>> ivy.set_default_device('cpu) + >>> ivy.default_device() + 'cpu' + + >>> ivy.set_backend('mxnet') + >>> ivy.set_default_device('cpu') + >>> ivy.default_device() + 'cpu' """ global default_device_stack default_device_stack.append(device) From 494f13b707d6aa925d2e9e2f3534e43903f400b9 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 11 Feb 2024 18:53:57 +0530 Subject: [PATCH 773/978] feat: Updated `ruff` configuration and it's pre-commit version according to the latest release (#28247) --- .pre-commit-config.yaml | 2 +- pyproject.toml | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index ef72c32b06d33..c8efbbb2c9b06 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: - id: check-toml - id: end-of-file-fixer - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.1.13 + rev: v0.2.1 hooks: # Run the linter. - id: ruff diff --git a/pyproject.toml b/pyproject.toml index 19d04d5dcdd2e..c0e38e22ac6ae 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,6 +27,7 @@ exclude = ["__init__.py"] line-length = 88 target-version = "py38" +[tool.ruff.lint] select = [ # pyflakes "F", @@ -36,7 +37,7 @@ select = [ "D", "I002", # Missing required import. "UP008", # Checks for super calls that pass redundant arguments. - "PGH002", # deprecated-log-warn. + "G010", # deprecated-log-warn. "PLR1722", # Use sys.exit() instead of exit() and quit(). "TRY004", # Prefer TypeError exception for invalid type. "PT014", # pytest-duplicate-parametrize-test-cases. @@ -64,13 +65,14 @@ ignore = [ "D213", # Multi-line docstring summary should start at the second line. "D209", # Multi-line docstring closing quotes should be on a separate line. "D400", # First line should end with a period. + "D413", # Missing blank line after last section of docstrings. "D401", # First line of docstring should be in imperative mood. "D415", # First line should end with a period, question mark, or exclamation point. "D416", # Section name should end with a colon ("Attributes"). "D417", # Missing argument description in the docstring for argument "X". ] -[tool.ruff.per-file-ignores] +[tool.ruff.lint.per-file-ignores] 'ivy/functional/(frontends|backends)/(?!.*/func_wrapper\.py$).*(?!__init__\.py$)' = ["D"] "**/__init__.py" = ["F401","F403","F405","F811","F821", "E501"] "ivy/functional/frontends/paddle/**" = ["F401", "F403", "F405"] From 12787e5ecd883f7c5536e9c5ac8d20b4d790f959 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 11 Feb 2024 16:08:21 +0000 Subject: [PATCH 774/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 43e214b9d18ed..89a47ae2b8403 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -14,10 +14,10 @@ Top Contributors - Badges * - V\. Sai Suraj - `Sai-Suraj-27 `_ - - Merging Master Gold, Debugging Dynamo Silver + - Merging Master Gold, Ivy Inspector Bronze * - samunder singh - `samthakur587 `_ - - Merging Master Gold, Debugging Dynamo Silver + - Merging Master Gold, Ivy Inspector Bronze Core Contributors ----------------- .. list-table:: @@ -27,6 +27,15 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Sanjay Suthar + - `Sanjay8602 `_ + - Merging Master Bronze, Ivy Inspector Bronze + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze + * - nitesh kesharwani + - `NiteshK84 `_ + - Ivy Inspector Bronze + * - sarvesh kesharwani + - `Sarvesh-Kesharwani `_ + - Ivy Inspector Bronze From be2b520e2b2d421586e70d430cad9940fa15bb4d Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 11 Feb 2024 16:09:40 +0000 Subject: [PATCH 775/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 89a47ae2b8403..7b2e16cf42392 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze * - nitesh kesharwani From 388ed9f68ca276dcbeef40ad26e08ca2e4803b91 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 11 Feb 2024 16:13:33 +0000 Subject: [PATCH 776/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 7b2e16cf42392..ef46ccf2d43c4 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -1,7 +1,7 @@ Contributor Leaderboard ======================= -This page lists all of our amazing Contributors who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. +This page lists all of our amazing Contributors who have contributed to the project! We are grateful for your contributions and we hope to see you grow with the project! The ranks listed here are based on the `level of contribution `_\. Top Contributors ---------------- @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze * - nitesh kesharwani From 69c5cecd231b3444e72690c0156c980f4bd576e5 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 11 Feb 2024 16:14:50 +0000 Subject: [PATCH 777/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index ef46ccf2d43c4..d08dc6a964173 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze * - nitesh kesharwani From 08db7e04ec427c5e35a7fa66065f4bea1d19dbf6 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 11 Feb 2024 16:26:35 +0000 Subject: [PATCH 778/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index d08dc6a964173..ef46ccf2d43c4 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze * - nitesh kesharwani From bb106e58c1175c84f40d7549ad24a5dceb1d1433 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 11 Feb 2024 16:27:55 +0000 Subject: [PATCH 779/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index ef46ccf2d43c4..d08dc6a964173 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze * - nitesh kesharwani From fc1c0fbe4f146fc9a03924b507345232a1c8f317 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 11 Feb 2024 17:21:46 +0000 Subject: [PATCH 780/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 50 ++++++++++++++++++++++++++++--- 1 file changed, 46 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index d08dc6a964173..464a2bc683d24 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -17,7 +17,7 @@ Top Contributors - Merging Master Gold, Ivy Inspector Bronze * - samunder singh - `samthakur587 `_ - - Merging Master Gold, Ivy Inspector Bronze + - Merging Master Gold, Merging Wizard, Ivy Inspector Bronze Core Contributors ----------------- .. list-table:: @@ -27,15 +27,57 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - - Merging Master Bronze + - Merging Master Bronze, Merging Wizard * - nitesh kesharwani - `NiteshK84 `_ - Ivy Inspector Bronze * - sarvesh kesharwani - `Sarvesh-Kesharwani `_ - Ivy Inspector Bronze +Contributors +------------ +.. list-table:: + :widths: 50 50 50 + :header-rows: 1 + + * - Name + - Github ID + - Badges + * - David Adlai Nettey + - `Adlai-1 `_ + - Merging Master + * - Garima Saroj + - `AndroGari `_ + - Merging Master, Ivy Inspector + * - Jackson McClintock + - `jacksondm33 `_ + - Merging Master, Ivy Inspector + * - Kacper Kożdoń + - `Kacper-W-Kozdon `_ + - Merging Master + * - Mostafa Gamal + - `Mr-Array22 `_ + - Merging Master, Ivy Inspector + * - R E Zera Marveen Lyngkhoi + - `fleventy-5 `_ + - Merging Master + * - Rahul Prem + - `rp097 `_ + - Merging Master, Ivy Inspector + * - Rohit Kumar Salla + - `rohitsalla `_ + - Merging Master, Ivy Inspector + * - Sheroz Khan + - `ksheroz `_ + - Merging Master + * - Suyash Gupta + - `sgalpha01 `_ + - Debugging Dynamo, Merging Master, Merging Wizard + * - Waqar Ahmed + - `waqaarahmed `_ + - Merging Master, Ivy Inspector From 0334ff89ca5eedd4acdb3fae2aff83ea8432a74a Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 11 Feb 2024 17:23:03 +0000 Subject: [PATCH 781/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 464a2bc683d24..74d320b024950 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze, Merging Wizard * - nitesh kesharwani @@ -63,7 +63,7 @@ Contributors * - Mostafa Gamal - `Mr-Array22 `_ - Merging Master, Ivy Inspector - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master * - Rahul Prem From 5f367de86a651dba3b836b9154ef0043c498488b Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 11 Feb 2024 17:37:12 +0000 Subject: [PATCH 782/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 40 +++++++++++++++---------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 74d320b024950..8c93b142c8217 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -12,12 +12,12 @@ Top Contributors * - Name - Github ID - Badges - * - V\. Sai Suraj - - `Sai-Suraj-27 `_ - - Merging Master Gold, Ivy Inspector Bronze * - samunder singh - `samthakur587 `_ - Merging Master Gold, Merging Wizard, Ivy Inspector Bronze + * - V\. Sai Suraj + - `Sai-Suraj-27 `_ + - Merging Master Gold, Ivy Inspector Bronze Core Contributors ----------------- .. list-table:: @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze, Merging Wizard * - nitesh kesharwani @@ -48,36 +48,36 @@ Contributors * - Name - Github ID - Badges - * - David Adlai Nettey - - `Adlai-1 `_ - - Merging Master + * - Suyash Gupta + - `sgalpha01 `_ + - Debugging Dynamo, Merging Master, Merging Wizard * - Garima Saroj - `AndroGari `_ - Merging Master, Ivy Inspector * - Jackson McClintock - `jacksondm33 `_ - Merging Master, Ivy Inspector - * - Kacper Kożdoń - - `Kacper-W-Kozdon `_ - - Merging Master * - Mostafa Gamal - `Mr-Array22 `_ - Merging Master, Ivy Inspector - * - R E Zera Marveen Lyngkhoi - - `fleventy-5 `_ - - Merging Master * - Rahul Prem - `rp097 `_ - Merging Master, Ivy Inspector * - Rohit Kumar Salla - `rohitsalla `_ - Merging Master, Ivy Inspector - * - Sheroz Khan - - `ksheroz `_ - - Merging Master - * - Suyash Gupta - - `sgalpha01 `_ - - Debugging Dynamo, Merging Master, Merging Wizard * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector + * - David Adlai Nettey + - `Adlai-1 `_ + - Merging Master + * - Kacper Kożdoń + - `Kacper-W-Kozdon `_ + - Merging Master + * - R E Zera Marveen Lyngkhoi + - `fleventy-5 `_ + - Merging Master + * - Sheroz Khan + - `ksheroz `_ + - Merging Master From 036875bb46bfbbaa28fe50d206014a57bc211f47 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 11 Feb 2024 17:38:26 +0000 Subject: [PATCH 783/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 8c93b142c8217..e359c13c4280f 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze, Merging Wizard * - nitesh kesharwani @@ -75,7 +75,7 @@ Contributors * - Kacper Kożdoń - `Kacper-W-Kozdon `_ - Merging Master - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master * - Sheroz Khan From 280ce0f73428eb42aedf193a48abc6e16f3e5251 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 12 Feb 2024 10:24:34 +0000 Subject: [PATCH 784/978] fix: match torch frontend unflatten signature with native torch as seen at https://pytorch.org/docs/stable/generated/torch.unflatten.html --- ivy/functional/frontends/torch/miscellaneous_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 8c3bbb335f849..e76fc96b4f775 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -555,7 +555,7 @@ def triu_indices(row, col, offset=0, dtype="int64", device="cpu", layout=None): @to_ivy_arrays_and_back -def unflatten(input, /, *, dim, sizes): +def unflatten(input, dim, sizes): return ivy.unflatten(input, dim=dim, shape=sizes, out=None) From 8dcc33b895240395686db165c710ac31708aa691 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 13 Feb 2024 12:12:23 +0530 Subject: [PATCH 785/978] fix: Fixed triggering of workflows due to `labeling` of the PR's (#28250) --- .github/workflows/array-api-intelligent-tests-pr.yml | 2 +- .github/workflows/dockerfile-image.yml | 2 +- .github/workflows/intelligent-tests-pr.yml | 2 +- .github/workflows/test-docstrings.yml | 2 +- scripts/generate_intelligent_tests_workflow.py | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/array-api-intelligent-tests-pr.yml b/.github/workflows/array-api-intelligent-tests-pr.yml index 2bb007f86ba61..e67478445676e 100644 --- a/.github/workflows/array-api-intelligent-tests-pr.yml +++ b/.github/workflows/array-api-intelligent-tests-pr.yml @@ -1,7 +1,7 @@ name: array-api-intelligent-tests-pr on: pull_request: - types: [ labeled, opened, synchronize, reopened, review_requested ] + types: [opened, synchronize, reopened, review_requested ] permissions: actions: read diff --git a/.github/workflows/dockerfile-image.yml b/.github/workflows/dockerfile-image.yml index 3f82ea05ea63c..fd19c2b90ab7c 100644 --- a/.github/workflows/dockerfile-image.yml +++ b/.github/workflows/dockerfile-image.yml @@ -4,7 +4,7 @@ on: push: branches: [ "main" ] pull_request: - types: [labeled, review_requested] + types: [review_requested] branches: [ "main" ] jobs: diff --git a/.github/workflows/intelligent-tests-pr.yml b/.github/workflows/intelligent-tests-pr.yml index ece59285375a0..91e08239a9d23 100644 --- a/.github/workflows/intelligent-tests-pr.yml +++ b/.github/workflows/intelligent-tests-pr.yml @@ -2,7 +2,7 @@ name: intelligent-tests-pr on: workflow_dispatch: pull_request: - types: [labeled, opened, synchronize, reopened, review_requested] + types: [opened, synchronize, reopened, review_requested] permissions: actions: read diff --git a/.github/workflows/test-docstrings.yml b/.github/workflows/test-docstrings.yml index c8b7f6bf519f1..77be6f4e6c969 100644 --- a/.github/workflows/test-docstrings.yml +++ b/.github/workflows/test-docstrings.yml @@ -2,7 +2,7 @@ name: test-docstrings on: push: pull_request: - types: [labeled, opened, synchronize, reopened, review_requested] + types: [opened, synchronize, reopened, review_requested] workflow_dispatch: jobs: run-docstring-tests: diff --git a/scripts/generate_intelligent_tests_workflow.py b/scripts/generate_intelligent_tests_workflow.py index 6b8b8a3a301cb..6cdf8ff51b7dd 100644 --- a/scripts/generate_intelligent_tests_workflow.py +++ b/scripts/generate_intelligent_tests_workflow.py @@ -5,7 +5,7 @@ print("on:") print(" workflow_dispatch:") print(" pull_request:") -print(" types: [ labeled, opened, synchronize, reopened, review_requested ]") +print(" types: [opened, synchronize, reopened, review_requested ]") print() print("permissions:") print(" actions: read") From 8f733d71b927c459498051df5b6c34e927772fe8 Mon Sep 17 00:00:00 2001 From: Felix Hirwa Nshuti Date: Tue, 13 Feb 2024 15:02:11 +0530 Subject: [PATCH 786/978] fix: fixing tests for `Shape` `__add__` and `__radd__` methods (#28263) --- ivy_tests/test_ivy/test_misc/test_shape.py | 50 ++++++++++------------ 1 file changed, 22 insertions(+), 28 deletions(-) diff --git a/ivy_tests/test_ivy/test_misc/test_shape.py b/ivy_tests/test_ivy/test_misc/test_shape.py index 6fe8a1e8c4355..c42f74180293f 100644 --- a/ivy_tests/test_ivy/test_misc/test_shape.py +++ b/ivy_tests/test_ivy/test_misc/test_shape.py @@ -7,19 +7,19 @@ from ivy_tests.test_ivy.helpers import handle_method +CLASS_TREE = "ivy.Shape" +DUMMY_DTYPE = ["int32"] + + @handle_method( + init_tree=CLASS_TREE, method_tree="Shape.__add__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - num_arrays=2, - large_abs_safety_factor=2.5, - small_abs_safety_factor=2.5, - safety_factor_scale="log", - shared_dtype=True, - ), + shape_1=helpers.get_shape(), + shape_2=helpers.get_shape(), ) def test_shape__add__( - dtype_and_x, + shape_1, + shape_2, method_name, class_name, ground_truth_backend, @@ -28,17 +28,16 @@ def test_shape__add__( method_flags, on_device, ): - dtype, x = dtype_and_x helpers.test_method( on_device=on_device, ground_truth_backend=ground_truth_backend, backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, - init_all_as_kwargs_np={"shape": x[0]}, - init_input_dtypes=dtype, - method_input_dtypes=dtype, - method_all_as_kwargs_np={"other": x[1]}, + init_all_as_kwargs_np={"shape_tup": shape_1}, + init_input_dtypes=DUMMY_DTYPE, + method_input_dtypes=DUMMY_DTYPE, + method_all_as_kwargs_np={"other": shape_2}, class_name=class_name, method_name=method_name, ) @@ -462,18 +461,14 @@ def test_shape__mul__( @handle_method( + init_tree=CLASS_TREE, method_tree="Shape.__radd__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - num_arrays=2, - large_abs_safety_factor=2.5, - small_abs_safety_factor=2.5, - safety_factor_scale="log", - shared_dtype=True, - ), + shape_1=helpers.get_shape(), + shape_2=helpers.get_shape(), ) def test_shape__radd__( - dtype_and_x, + shape_1, + shape_2, method_name, class_name, backend_fw, @@ -482,17 +477,16 @@ def test_shape__radd__( method_flags, on_device, ): - dtype, x = dtype_and_x helpers.test_method( on_device=on_device, ground_truth_backend=ground_truth_backend, backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, - init_all_as_kwargs_np={"shape": x[0]}, - init_input_dtypes=dtype, - method_input_dtypes=dtype, - method_all_as_kwargs_np={"other": x[1]}, + init_all_as_kwargs_np={"shape_tup": shape_1}, + init_input_dtypes=DUMMY_DTYPE, + method_input_dtypes=DUMMY_DTYPE, + method_all_as_kwargs_np={"other": shape_2}, class_name=class_name, method_name=method_name, ) From dbd9113f3f680f6aeb499ee2d3040a05d4c4111b Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 09:53:58 +0000 Subject: [PATCH 787/978] refactor: move the factorization and sizes generating logic out of the tests test_unflatten and test_torch_unflatten this should perhaps be converted to a hypothesis strategies so that failures can capture full detail instead of standalone function --- .../hypothesis_helpers/general_helpers.py | 37 +++++++++++++++ .../test_torch/test_miscellaneous_ops.py | 46 ++----------------- .../test_core/test_manipulation.py | 46 ++----------------- 3 files changed, 46 insertions(+), 83 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 13369be1461dd..631cfbd85196d 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -648,3 +648,40 @@ def embedding_helper(draw, mixed_fn_compos=True): ) padding_idx = draw(st.integers(min_value=0, max_value=num_embeddings - 1)) return dtype_indices + dtype_weight, indices[0], weight[0], padding_idx + + +def sizes_(shape, axis): + def factorization(n): + factors = [1] + + def get_factor(n): + x_fixed = 2 + cycle_size = 2 + x = 2 + factor = 1 if n % 2 else 2 + while factor == 1: + for count in range(cycle_size): + if factor > 1: + break + x = (x * x + 1) % n + factor = math.gcd(x - x_fixed, n) + + cycle_size *= 2 + x_fixed = x + + return factor + + while n > 1: + next = get_factor(n) + factors.append(next) + n //= next + if len(factors) > 1: + factors.remove(1) + return factors + + shape_ = ( + tuple(factorization(shape[axis])) + if tuple(factorization(shape[axis])) + else shape + ) + return shape_ diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 46eb2ada3d210..402f94bfc95a7 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -8,6 +8,7 @@ # local import ivy import ivy_tests.test_ivy.helpers as helpers +from ivy_tests.test_ivy.helpers.hypothesis_helpers.general_helpers import sizes_ from ivy_tests.test_ivy.helpers import handle_frontend_test from ivy_tests.test_ivy.test_functional.test_core.test_linalg import ( _get_dtype_value1_value2_axis_for_tensordot, @@ -1817,7 +1818,7 @@ def test_torch_triu_indices( min_num_dims=1, shape_key="shape", ), - get_axis=helpers.get_axis( + axis=helpers.get_axis( shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), max_size=0, min_size=0, @@ -1833,47 +1834,10 @@ def test_torch_unflatten( test_flags, backend_fw, shape, - get_axis, + axis, ): - axis = get_axis - if type(axis) is tuple: - axis = 0 if not get_axis else get_axis[0] dtype, x = dtype_and_values - - def factorization(n): - factors = [1] - - def get_factor(n): - x_fixed = 2 - cycle_size = 2 - x = 2 - factor = 1 if n % 2 else 2 - - while factor == 1: - for count in range(cycle_size): - if factor > 1: - break - x = (x * x + 1) % n - factor = math.gcd(x - x_fixed, n) - - cycle_size *= 2 - x_fixed = x - - return factor - - while n > 1: - next = get_factor(n) - factors.append(next) - n //= next - if len(factors) > 1: - factors.remove(1) - return factors - - shape_ = ( - tuple(factorization(shape[axis])) - if tuple(factorization(shape[axis])) - else shape - ) + sizes = sizes_(shape, axis) helpers.test_frontend_function( input_dtypes=dtype, frontend=frontend, @@ -1884,7 +1848,7 @@ def get_factor(n): test_values=False, input=x[0], dim=axis, - sizes=shape_, + sizes=sizes, ) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py index d88849c914204..2c67fe9e25aca 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py @@ -2,11 +2,11 @@ from hypothesis import strategies as st, assume import hypothesis.extra.numpy as nph import numpy as np -import math # local import ivy import ivy_tests.test_ivy.helpers as helpers +from ivy_tests.test_ivy.helpers.hypothesis_helpers.general_helpers import sizes_ from ivy_tests.test_ivy.helpers import handle_test, create_concatenable_arrays_dtypes from ivy.functional.ivy.experimental.manipulation import _check_bounds from ivy_tests.test_ivy.test_functional.test_core.test_manipulation import _get_splits @@ -1480,7 +1480,7 @@ def test_trim_zeros( min_num_dims=1, shape_key="shape", ), - get_axis=helpers.get_axis( + axis=helpers.get_axis( shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), max_size=0, min_size=0, @@ -1495,48 +1495,10 @@ def test_unflatten( test_flags, backend_fw, shape, - get_axis, + axis, ): - axis = get_axis - if type(axis) is tuple: - axis = 0 if not get_axis else get_axis[0] + shape_ = sizes_(shape, axis) dtype, x = dtype_and_values - - def factorization(n): - factors = [1] - - def get_factor(n): - x_fixed = 2 - cycle_size = 2 - x = 2 - factor = 1 if n % 2 else 2 - - while factor == 1: - for count in range(cycle_size): - if factor > 1: - break - x = (x * x + 1) % n - factor = math.gcd(x - x_fixed, n) - - cycle_size *= 2 - x_fixed = x - - return factor - - while n > 1: - next = get_factor(n) - factors.append(next) - n //= next - - if len(factors) > 1: - factors.remove(1) - return factors - - shape_ = ( - tuple(factorization(shape[axis])) - if tuple(factorization(shape[axis])) - else shape - ) helpers.test_function( input_dtypes=dtype, backend_to_test=backend_fw, From 90eb2992d2aa19674fbfea90d20101aa5f605fd2 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 09:58:19 +0000 Subject: [PATCH 788/978] test: remove max and min size restrictions for unflatten tests --- .../test_frontends/test_torch/test_miscellaneous_ops.py | 2 -- .../test_experimental/test_core/test_manipulation.py | 2 -- 2 files changed, 4 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 402f94bfc95a7..b6e2e6ddf54d3 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -1820,8 +1820,6 @@ def test_torch_triu_indices( ), axis=helpers.get_axis( shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), - max_size=0, - min_size=0, force_int=True, ), ) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py index 2c67fe9e25aca..2c2c5cc7ca50c 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_manipulation.py @@ -1482,8 +1482,6 @@ def test_trim_zeros( ), axis=helpers.get_axis( shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), - max_size=0, - min_size=0, force_int=True, ), ) From d15467d3d8639acda3092e17179877524dfddcbf Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 10:08:28 +0000 Subject: [PATCH 789/978] feat: add unflatten as torch frontend Tensor method and the test tests pass. --- ivy/functional/frontends/torch/tensor.py | 3 ++ .../test_frontends/test_torch/test_tensor.py | 49 +++++++++++++++++++ 2 files changed, 52 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index f470a9860420b..54c6d552d6268 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -823,6 +823,9 @@ def positive(self): def pow(self, exponent): return torch_frontend.pow(self, exponent) + def unflatten(self, dim, sizes): + return torch_frontend.unflatten(self, dim, sizes) + @with_unsupported_dtypes({"2.2 and below": ("bfloat16",)}, "torch") def pow_(self, exponent): self.ivy_array = self.pow(exponent).ivy_array diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index b5490c5ac5f5e..d6338be9e6ad6 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -21,6 +21,7 @@ # local import ivy_tests.test_ivy.helpers as helpers +from ivy_tests.test_ivy.helpers.hypothesis_helpers.general_helpers import sizes_ from ivy_tests.test_ivy.test_frontends.test_torch.test_blas_and_lapack_ops import ( _get_dtype_and_3dbatch_matrices, _get_dtype_input_and_matrices, @@ -13800,6 +13801,54 @@ def test_torch_unbind( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="unflatten", + shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), + dtype_and_values=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_num_dims=1, + shape_key="shape", + ), + axis=helpers.get_axis( + shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), + force_int=True, + ), +) +def test_torch_unflatten( + *, + dtype_and_values, + on_device, + frontend, + backend_fw, + shape, + axis, + frontend_method_data, + init_flags, + method_flags, +): + dtype, x = dtype_and_values + sizes = sizes_(shape, axis) + helpers.test_frontend_method( + init_input_dtypes=dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=dtype, + method_all_as_kwargs_np={ + "dim": axis, + "sizes": sizes, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # unfold @handle_frontend_method( class_tree=CLASS_TREE, From ae9c228c586965dadc74574f8959d7fc1d3c860d Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 10:37:48 +0000 Subject: [PATCH 790/978] feat: add clamp_min_ to torch frontend inplace version of clamp_min --- ivy/functional/frontends/torch/tensor.py | 4 +++ .../test_frontends/test_torch/test_tensor.py | 35 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 54c6d552d6268..91c1f5b86db55 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1027,6 +1027,10 @@ def clamp_(self, min=None, max=None): def clamp_min(self, min=None): return torch_frontend.clamp(self, min=min) + def clamp_min_(self, min=None): + self.ivy_array = self.clamp_min(min).ivy_array + return self + @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch") def sqrt(self): return torch_frontend.sqrt(self) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index d6338be9e6ad6..35b33d1996e2a 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -4871,6 +4871,41 @@ def test_torch_clamp_min( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="clamp_min_", + input_and_ranges=_get_clip_min_inputs(), + test_inplace=st.just(True), +) +def test_torch_clamp_min_( + input_and_ranges, + frontend_method_data, + init_flags, + backend_fw, + frontend, + on_device, + method_flags, +): + x_dtype, x, min = input_and_ranges + helpers.test_frontend_method( + init_input_dtypes=x_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=x_dtype, + method_all_as_kwargs_np={ + "min": min, + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # clip @handle_frontend_method( class_tree=CLASS_TREE, From 77ccffb6b89b38b0da68ebeda31a288f71af19c4 Mon Sep 17 00:00:00 2001 From: M Talha Khalil Date: Tue, 13 Feb 2024 15:41:33 +0500 Subject: [PATCH 791/978] feat: Add tensorflow GatherNd raw ops (#28211) --- .../frontends/tensorflow/raw_ops.py | 9 +++++ .../test_tensorflow/test_raw_ops.py | 38 +++++++++++++++++++ 2 files changed, 47 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/raw_ops.py b/ivy/functional/frontends/tensorflow/raw_ops.py index 1db6e68e803af..61c87dcb5c76b 100644 --- a/ivy/functional/frontends/tensorflow/raw_ops.py +++ b/ivy/functional/frontends/tensorflow/raw_ops.py @@ -619,6 +619,15 @@ def Gather(*, params, indices, validate_indices=None, name="Gather"): return ivy.gather(params, indices, axis=0, batch_dims=0) +@with_supported_dtypes( + {"2.15.0 and below": ("int32", "int64", "float32", "float64")}, + "tensorflow", +) +@to_ivy_arrays_and_back +def GatherNd(*, params, indices, name=None): + return ivy.gather_nd(params, indices, batch_dims=0) + + @to_ivy_arrays_and_back def Greater(*, x, y, name="Greater"): x, y = check_tensorflow_casting(x, y) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py index 027d7b72c34db..ad9b5ee4f3114 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py @@ -2132,6 +2132,44 @@ def test_tensorflow_Gather( # NOQA ) +# GatherNd +@handle_frontend_test( + fn_tree="tensorflow.raw_ops.GatherNd", + params_indices_axis_batch_dims=helpers.array_indices_axis( + array_dtypes=helpers.get_dtypes("valid"), + indices_dtypes=["int32", "int64"], + min_num_dims=3, + max_num_dims=3, + min_dim_size=3, + max_dim_size=3, + axis_zero=True, + disable_random_axis=True, + indices_same_dims=True, + ), + test_with_out=st.just(False), +) +def test_tensorflow_GatherNd( + *, + params_indices_axis_batch_dims, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + input_dtypes, params, indices = params_indices_axis_batch_dims + helpers.test_frontend_function( + input_dtypes=input_dtypes, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + params=params, + indices=indices, + ) + + # Greater @handle_frontend_test( fn_tree="tensorflow.raw_ops.Greater", From 2f2442a76da791f2d92c27c79fa42b67b7fcf982 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 13 Feb 2024 16:43:23 +0530 Subject: [PATCH 792/978] fix: Fixed `paddle_backend.i0` (#28184) --- ivy/functional/backends/paddle/experimental/manipulation.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy/functional/backends/paddle/experimental/manipulation.py b/ivy/functional/backends/paddle/experimental/manipulation.py index c6a482ee60b2d..8c7f314743d64 100644 --- a/ivy/functional/backends/paddle/experimental/manipulation.py +++ b/ivy/functional/backends/paddle/experimental/manipulation.py @@ -311,6 +311,10 @@ def fliplr( return paddle.flip(m, axis=1) +@with_unsupported_dtypes( + {"2.6.0 and below": ("bfloat16", "float16")}, + backend_version, +) def i0( x: paddle.Tensor, /, From 7664577eed0ec2f27adcaddd95d92d77872de59b Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 13 Feb 2024 16:45:17 +0530 Subject: [PATCH 793/978] fix: Fixed `paddle_backend.copysign` (#28178) --- ivy/functional/backends/paddle/experimental/elementwise.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index e0c53010b1cf2..027aaea7987a5 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -137,6 +137,9 @@ def ldexp( return ivy.astype(ret, out_dtype, copy=False) +@with_unsupported_device_and_dtypes( + {"2.6.0 and below": {"cpu": ("float16", "bfloat16")}}, backend_version +) def copysign( x1: Union[paddle.Tensor, Number], x2: Union[paddle.Tensor, Number], From 2f1d92ddad3582d2d9ea1c984986d227bf462845 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 13 Feb 2024 16:45:48 +0530 Subject: [PATCH 794/978] fix: Fixed `paddle_backend.signbit` (#28180) --- ivy/functional/backends/paddle/experimental/elementwise.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 027aaea7987a5..0ecef27c3ec71 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -217,6 +217,9 @@ def _tensor(val): ) +@with_unsupported_device_and_dtypes( + {"2.6.0 and below": {"cpu": ("float16",)}}, backend_version +) def signbit( x: Union[paddle.Tensor, float, int, list, tuple], /, From 902cf55140ca688b4d64bd30157f967d452b3208 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 20:56:36 +0000 Subject: [PATCH 795/978] feat: added `broadcast_tensors` funtion for torch frontend --- .../frontends/torch/tensor_functions.py | 5 +++ .../test_torch/test_tensor_functions.py | 34 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor_functions.py b/ivy/functional/frontends/torch/tensor_functions.py index 4a1512c147f4e..36dc356c96e7c 100644 --- a/ivy/functional/frontends/torch/tensor_functions.py +++ b/ivy/functional/frontends/torch/tensor_functions.py @@ -4,6 +4,11 @@ from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back +@to_ivy_arrays_and_back +def broadcast_tensors(*tensors): + return ivy.broadcast_arrays(*tensors) + + @to_ivy_arrays_and_back def is_complex(input): return ivy.is_complex_dtype(input) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor_functions.py index 920ffe8a46ce3..123130f2a0119 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor_functions.py @@ -10,6 +10,40 @@ ) +# broadcast_tensors +@handle_frontend_test( + fn_tree="torch.broadcast_tensors", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_num_dims=1, + num_arrays=2, + ), +) +def test_torch_broadcast_tensors( + *, + dtype_and_x, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + input_dtype, x = dtype_and_x + kw = {} + for i, array in enumerate(x): + kw[f"x{i}"] = array + test_flags.num_positional_args = len(kw) + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + on_device=on_device, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + **kw, + ) + + @handle_frontend_test( fn_tree="torch.is_complex", dtype_and_x=helpers.dtype_and_values( From 58227ae570c8562ad51a135e165f35e9af3415a6 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 21:17:43 +0000 Subject: [PATCH 796/978] feat: add torch.special.erfc in torch frontend and turn the implementation in pointwise ops into an alias for the special func --- erfissues.py | 5 +++++ ivy/functional/frontends/torch/__init__.py | 1 + ivy/functional/frontends/torch/pointwise_ops.py | 9 +++------ ivy/functional/frontends/torch/special/__init__.py | 1 + .../frontends/torch/special/special_funcs.py | 13 +++++++++++++ 5 files changed, 23 insertions(+), 6 deletions(-) create mode 100644 erfissues.py create mode 100644 ivy/functional/frontends/torch/special/__init__.py create mode 100644 ivy/functional/frontends/torch/special/special_funcs.py diff --git a/erfissues.py b/erfissues.py new file mode 100644 index 0000000000000..3331f8968a491 --- /dev/null +++ b/erfissues.py @@ -0,0 +1,5 @@ +import torch +print(torch.special.erfc(torch.tensor([0, -1., 10.]))) +from ivy.functional.frontends import torch as ivy_torch +print(ivy_torch.special.erfc(ivy_torch.tensor([0, -1., 10.]))) +print(ivy_torch.erfc(ivy_torch.tensor([0, -1., 10.]))) \ No newline at end of file diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index af031aa7c9d26..e9f0986016442 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -261,6 +261,7 @@ def promote_types_of_torch_inputs( from . import nn from .nn.functional import softmax, relu, lstm +from . import special from . import tensor from .tensor import * from . import blas_and_lapack_ops diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py index 7ae00ab085319..9c0c4601c3522 100644 --- a/ivy/functional/frontends/torch/pointwise_ops.py +++ b/ivy/functional/frontends/torch/pointwise_ops.py @@ -10,6 +10,9 @@ ) +erfc = torch_frontend.special.erfc + + @to_ivy_arrays_and_back def abs(input, *, out=None): return ivy.abs(input, out=out) @@ -189,12 +192,6 @@ def erf(input, *, out=None): return ivy.erf(input, out=out) -@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") -@to_ivy_arrays_and_back -def erfc(input, *, out=None): - return 1.0 - ivy.erf(input, out=out) - - @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") @to_ivy_arrays_and_back def exp(input, *, out=None): diff --git a/ivy/functional/frontends/torch/special/__init__.py b/ivy/functional/frontends/torch/special/__init__.py new file mode 100644 index 0000000000000..7dc36a681a948 --- /dev/null +++ b/ivy/functional/frontends/torch/special/__init__.py @@ -0,0 +1 @@ +from .special_funcs import * diff --git a/ivy/functional/frontends/torch/special/special_funcs.py b/ivy/functional/frontends/torch/special/special_funcs.py new file mode 100644 index 0000000000000..a48c5a2bc006d --- /dev/null +++ b/ivy/functional/frontends/torch/special/special_funcs.py @@ -0,0 +1,13 @@ +import ivy +from ivy.func_wrapper import ( + with_unsupported_dtypes, +) +from ivy.functional.frontends.torch.func_wrapper import ( + to_ivy_arrays_and_back, +) + + +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch") +@to_ivy_arrays_and_back +def erfc(input, *, out=None): + return 1.0 - ivy.erf(input, out=out) From 1bb05457a0f54135e26dc894fc1e2745f77dea91 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 13 Feb 2024 21:19:24 +0000 Subject: [PATCH 797/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- erfissues.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/erfissues.py b/erfissues.py index 3331f8968a491..6e52db5dcd230 100644 --- a/erfissues.py +++ b/erfissues.py @@ -1,5 +1,7 @@ import torch -print(torch.special.erfc(torch.tensor([0, -1., 10.]))) + +print(torch.special.erfc(torch.tensor([0, -1.0, 10.0]))) from ivy.functional.frontends import torch as ivy_torch -print(ivy_torch.special.erfc(ivy_torch.tensor([0, -1., 10.]))) -print(ivy_torch.erfc(ivy_torch.tensor([0, -1., 10.]))) \ No newline at end of file + +print(ivy_torch.special.erfc(ivy_torch.tensor([0, -1.0, 10.0]))) +print(ivy_torch.erfc(ivy_torch.tensor([0, -1.0, 10.0]))) From c00356a1b4057359622522d51037438c315240fc Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 21:25:59 +0000 Subject: [PATCH 798/978] chore: remove erfissues.py file --- erfissues.py | 7 ------- 1 file changed, 7 deletions(-) delete mode 100644 erfissues.py diff --git a/erfissues.py b/erfissues.py deleted file mode 100644 index 6e52db5dcd230..0000000000000 --- a/erfissues.py +++ /dev/null @@ -1,7 +0,0 @@ -import torch - -print(torch.special.erfc(torch.tensor([0, -1.0, 10.0]))) -from ivy.functional.frontends import torch as ivy_torch - -print(ivy_torch.special.erfc(ivy_torch.tensor([0, -1.0, 10.0]))) -print(ivy_torch.erfc(ivy_torch.tensor([0, -1.0, 10.0]))) From 39258f4cddd043bd4feea4c0b849363f7a986029 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 21:28:00 +0000 Subject: [PATCH 799/978] test: add alias for torch frontend erfc test --- .../test_ivy/test_frontends/test_torch/test_pointwise_ops.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py index b8dc1f212a862..52c15b10bd760 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py @@ -1181,7 +1181,8 @@ def test_torch_erf( # erfc @handle_frontend_test( - fn_tree="torch.erfc", + fn_tree="torch.special.erfc", + aliases=["torch.erfc"], dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("float"), ), From 69afe1f77277f8e0503313638a5964cd94d88ef8 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 21:34:07 +0000 Subject: [PATCH 800/978] feat: add torch front special.erfinv function and make the exisiting implementation into an alias in accordance with pytorch docs --- ivy/functional/frontends/torch/miscellaneous_ops.py | 8 +++----- ivy/functional/frontends/torch/special/special_funcs.py | 5 +++++ .../test_frontends/test_torch/test_miscellaneous_ops.py | 3 ++- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index e76fc96b4f775..1044114e25727 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -5,6 +5,9 @@ import ivy.functional.frontends.torch as torch_frontend +erfinv = torch_frontend.special.erfinv + + @to_ivy_arrays_and_back def atleast_1d(*tensors): return ivy.atleast_1d(*tensors) @@ -239,11 +242,6 @@ def einsum(equation, *operands): return ivy.einsum(equation, *operands) -@to_ivy_arrays_and_back -def erfinv(input, *, out=None): - return ivy.erfinv(input, out=out) - - @to_ivy_arrays_and_back def finfo(dtype): return ivy.finfo(dtype) diff --git a/ivy/functional/frontends/torch/special/special_funcs.py b/ivy/functional/frontends/torch/special/special_funcs.py index a48c5a2bc006d..e8343d59565bd 100644 --- a/ivy/functional/frontends/torch/special/special_funcs.py +++ b/ivy/functional/frontends/torch/special/special_funcs.py @@ -11,3 +11,8 @@ @to_ivy_arrays_and_back def erfc(input, *, out=None): return 1.0 - ivy.erf(input, out=out) + + +@to_ivy_arrays_and_back +def erfinv(input, *, out=None): + return ivy.erfinv(input, out=out) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index b6e2e6ddf54d3..8bac08b6f069b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -1020,7 +1020,8 @@ def test_torch_einsum( # erfinv @handle_frontend_test( - fn_tree="torch.erfinv", + fn_tree="torch.special.erfinv", + aliases=["torch.erfinv"], dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("float"), min_value=-1, From 3957146032aa4b075340228695bc92a5b1a71c46 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 21:45:08 +0000 Subject: [PATCH 801/978] feat: add torch frontend special function erfcx and the corresponding test because of its independece on erfc it seems to sometimes fail with value mismatches similar to those in erfc. Needs fix for erfc in backend implementations. --- .../frontends/torch/special/special_funcs.py | 7 +++++ .../test_torch/test_special_funcs.py | 30 +++++++++++++++++++ 2 files changed, 37 insertions(+) create mode 100644 ivy_tests/test_ivy/test_frontends/test_torch/test_special_funcs.py diff --git a/ivy/functional/frontends/torch/special/special_funcs.py b/ivy/functional/frontends/torch/special/special_funcs.py index e8343d59565bd..738fcaf278fa2 100644 --- a/ivy/functional/frontends/torch/special/special_funcs.py +++ b/ivy/functional/frontends/torch/special/special_funcs.py @@ -13,6 +13,13 @@ def erfc(input, *, out=None): return 1.0 - ivy.erf(input, out=out) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex", "bfloat16")}, "torch") +@to_ivy_arrays_and_back +def erfcx(input, *, out=None): + ret = erfc(input) * ivy.exp(input**2) + return ret + + @to_ivy_arrays_and_back def erfinv(input, *, out=None): return ivy.erfinv(input, out=out) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_special_funcs.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_special_funcs.py new file mode 100644 index 0000000000000..56bac4271b7bb --- /dev/null +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_special_funcs.py @@ -0,0 +1,30 @@ +# local +import ivy_tests.test_ivy.helpers as helpers +from ivy_tests.test_ivy.helpers import handle_frontend_test + + +@handle_frontend_test( + fn_tree="torch.special.erfcx", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + ), +) +def test_torch_erfcx( + *, + dtype_and_x, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + input=x[0], + ) From d1619252c91af1f7450f937778bc943bb0711726 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 13 Feb 2024 21:47:59 +0000 Subject: [PATCH 802/978] test: generalise test_torch_broadcast_tensors to have multiple tensors to broadcast instead of just 2 --- .../test_ivy/test_frontends/test_torch/test_tensor_functions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor_functions.py index 123130f2a0119..9f4632ec3bddc 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor_functions.py @@ -16,7 +16,7 @@ dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("valid"), min_num_dims=1, - num_arrays=2, + num_arrays=helpers.ints(min_value=2, max_value=5), ), ) def test_torch_broadcast_tensors( From d006c3d9e8456c0ca8e43552befa610f14212f01 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 14 Feb 2024 12:41:52 +0530 Subject: [PATCH 803/978] feat: Updated `black` formatter to latest version and modified files accordingly (#28282) --- .pre-commit-config.yaml | 2 +- ivy/__init__.py | 80 +++---- ivy/data_classes/container/base.py | 183 ++++++++------- .../factorized_tensor/cp_tensor.py | 10 +- .../factorized_tensor/tucker_tensor.py | 10 +- ivy/func_wrapper.py | 108 +++++---- ivy/functional/backends/jax/random.py | 10 +- ivy/functional/backends/mxnet/creation.py | 22 +- .../mxnet/experimental/linear_algebra.py | 12 +- .../backends/mxnet/experimental/norms.py | 24 +- ivy/functional/backends/mxnet/set.py | 14 +- .../numpy/experimental/elementwise.py | 172 +++++++------- ivy/functional/backends/numpy/random.py | 10 +- .../paddle/experimental/elementwise.py | 86 +++---- ivy/functional/backends/paddle/general.py | 12 +- ivy/functional/backends/paddle/gradients.py | 10 +- ivy/functional/backends/paddle/set.py | 14 +- .../tensorflow/experimental/layers.py | 12 +- ivy/functional/backends/tensorflow/module.py | 20 +- ivy/functional/backends/tensorflow/random.py | 10 +- .../backends/torch/experimental/gradients.py | 20 +- .../torch/experimental/statistical.py | 10 +- ivy/functional/backends/torch/random.py | 10 +- ivy/functional/ivy/experimental/layers.py | 32 +-- .../ivy/experimental/linear_algebra.py | 14 +- .../ivy/experimental/sparse_array.py | 20 +- ivy/functional/ivy/meta.py | 28 ++- ivy/functional/ivy/nest.py | 18 +- ivy/stateful/module.py | 20 +- ivy/utils/binaries.py | 10 +- ivy_tests/test_ivy/conftest.py | 14 +- .../test_ivy/helpers/function_testing.py | 212 ++++++++++-------- ivy_tests/test_ivy/helpers/multiprocessing.py | 74 +++--- ivy_tests/test_ivy/helpers/testing_helpers.py | 16 +- scripts/backend_generation/tree_generation.py | 20 +- 35 files changed, 743 insertions(+), 596 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c8efbbb2c9b06..a20dff79ae6fc 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -13,7 +13,7 @@ repos: - id: ruff args: [ --fix ] - repo: https://github.com/psf/black-pre-commit-mirror - rev: 24.1.1 + rev: 24.2.0 hooks: - id: black language_version: python3 diff --git a/ivy/__init__.py b/ivy/__init__.py index a3ec566d6609e..00e5039fd4099 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -930,45 +930,47 @@ def __deepcopy__(self, memo): # defines ivy.globals attribute -globals_vars = GlobalsDict({ - "backend_stack": backend_stack, - "default_device_stack": device.default_device_stack, - "valid_dtypes": valid_dtypes, - "valid_numeric_dtypes": valid_numeric_dtypes, - "valid_int_dtypes": valid_int_dtypes, - "valid_uint_dtypes": valid_uint_dtypes, - "valid_complex_dtypes": valid_complex_dtypes, - "valid_devices": valid_devices, - "invalid_dtypes": invalid_dtypes, - "invalid_numeric_dtypes": invalid_numeric_dtypes, - "invalid_int_dtypes": invalid_int_dtypes, - "invalid_float_dtypes": invalid_float_dtypes, - "invalid_uint_dtypes": invalid_uint_dtypes, - "invalid_complex_dtypes": invalid_complex_dtypes, - "invalid_devices": invalid_devices, - "array_significant_figures_stack": array_significant_figures_stack, - "array_decimal_values_stack": array_decimal_values_stack, - "warning_level_stack": warning_level_stack, - "queue_timeout_stack": general.queue_timeout_stack, - "array_mode_stack": general.array_mode_stack, - "inplace_mode_stack": general.inplace_mode_stack, - "soft_device_mode_stack": device.soft_device_mode_stack, - "shape_array_mode_stack": general.shape_array_mode_stack, - "show_func_wrapper_trace_mode_stack": general.show_func_wrapper_trace_mode_stack, - "min_denominator_stack": general.min_denominator_stack, - "min_base_stack": general.min_base_stack, - "tmp_dir_stack": general.tmp_dir_stack, - "precise_mode_stack": general.precise_mode_stack, - "nestable_mode_stack": general.nestable_mode_stack, - "exception_trace_mode_stack": general.exception_trace_mode_stack, - "default_dtype_stack": data_type.default_dtype_stack, - "default_float_dtype_stack": data_type.default_float_dtype_stack, - "default_int_dtype_stack": data_type.default_int_dtype_stack, - "default_uint_dtype_stack": data_type.default_uint_dtype_stack, - "nan_policy_stack": nan_policy_stack, - "dynamic_backend_stack": dynamic_backend_stack, - "cython_wrappers_stack": cython_wrappers_stack, -}) +globals_vars = GlobalsDict( + { + "backend_stack": backend_stack, + "default_device_stack": device.default_device_stack, + "valid_dtypes": valid_dtypes, + "valid_numeric_dtypes": valid_numeric_dtypes, + "valid_int_dtypes": valid_int_dtypes, + "valid_uint_dtypes": valid_uint_dtypes, + "valid_complex_dtypes": valid_complex_dtypes, + "valid_devices": valid_devices, + "invalid_dtypes": invalid_dtypes, + "invalid_numeric_dtypes": invalid_numeric_dtypes, + "invalid_int_dtypes": invalid_int_dtypes, + "invalid_float_dtypes": invalid_float_dtypes, + "invalid_uint_dtypes": invalid_uint_dtypes, + "invalid_complex_dtypes": invalid_complex_dtypes, + "invalid_devices": invalid_devices, + "array_significant_figures_stack": array_significant_figures_stack, + "array_decimal_values_stack": array_decimal_values_stack, + "warning_level_stack": warning_level_stack, + "queue_timeout_stack": general.queue_timeout_stack, + "array_mode_stack": general.array_mode_stack, + "inplace_mode_stack": general.inplace_mode_stack, + "soft_device_mode_stack": device.soft_device_mode_stack, + "shape_array_mode_stack": general.shape_array_mode_stack, + "show_func_wrapper_trace_mode_stack": general.show_func_wrapper_trace_mode_stack, + "min_denominator_stack": general.min_denominator_stack, + "min_base_stack": general.min_base_stack, + "tmp_dir_stack": general.tmp_dir_stack, + "precise_mode_stack": general.precise_mode_stack, + "nestable_mode_stack": general.nestable_mode_stack, + "exception_trace_mode_stack": general.exception_trace_mode_stack, + "default_dtype_stack": data_type.default_dtype_stack, + "default_float_dtype_stack": data_type.default_float_dtype_stack, + "default_int_dtype_stack": data_type.default_int_dtype_stack, + "default_uint_dtype_stack": data_type.default_uint_dtype_stack, + "nan_policy_stack": nan_policy_stack, + "dynamic_backend_stack": dynamic_backend_stack, + "cython_wrappers_stack": cython_wrappers_stack, + } +) _default_globals = copy.deepcopy(globals_vars) diff --git a/ivy/data_classes/container/base.py b/ivy/data_classes/container/base.py index b782245f53dae..bb004b709a37f 100644 --- a/ivy/data_classes/container/base.py +++ b/ivy/data_classes/container/base.py @@ -1367,15 +1367,17 @@ def cont_flatten_key_chain( if below_depth and num_keys > below_depth: pre_keys = flat_keys[0:below_depth] del flat_keys[0:below_depth] - return "/".join([ - k - for k in [ - "/".join(pre_keys), - replacement.join(flat_keys), - "/".join(post_keys), + return "/".join( + [ + k + for k in [ + "/".join(pre_keys), + replacement.join(flat_keys), + "/".join(post_keys), + ] + if k ] - if k - ]) + ) @staticmethod def cont_trim_key(key, max_length): @@ -1697,16 +1699,18 @@ def cont_all_true( Boolean, whether all entries are boolean True. """ return bool( - np.prod([ - v - for k, v in self.cont_as_bools( - assert_is_bool, - key_chains, - to_apply, - prune_unapplied, - map_sequences, - ).cont_to_iterator() - ]) + np.prod( + [ + v + for k, v in self.cont_as_bools( + assert_is_bool, + key_chains, + to_apply, + prune_unapplied, + map_sequences, + ).cont_to_iterator() + ] + ) ) def cont_all_false( @@ -1742,16 +1746,18 @@ def cont_all_false( Boolean, whether all entries are boolean False. """ return not bool( - np.sum([ - v - for k, v in self.cont_as_bools( - assert_is_bool, - key_chains, - to_apply, - prune_unapplied, - map_sequences, - ).cont_to_iterator() - ]) + np.sum( + [ + v + for k, v in self.cont_as_bools( + assert_is_bool, + key_chains, + to_apply, + prune_unapplied, + map_sequences, + ).cont_to_iterator() + ] + ) ) def cont_slice_via_key(self, slice_key): @@ -1843,11 +1849,15 @@ def cont_unstack_conts(self, axis, keepdims=False, dim_size=None): if keepdims: # noinspection PyTypeChecker return [ - self[( - slice(i, i + 1, 1) - if axis == 0 - else tuple([slice(None, None, None)] * axis + [slice(i, i + 1, 1)]) - )] + self[ + ( + slice(i, i + 1, 1) + if axis == 0 + else tuple( + [slice(None, None, None)] * axis + [slice(i, i + 1, 1)] + ) + ) + ] for i in range(dim_size) ] # noinspection PyTypeChecker @@ -3690,10 +3700,12 @@ def _pre_pad_alpha_line(str_in): padded = True return "\\n" + indent_str + indented_key_str + str_in - leading_str_to_keep = ", ".join([ - _pre_pad_alpha_line(s) if s[0].isalpha() and i != 0 else s - for i, s in enumerate(leading_str_to_keep.split(", ")) - ]) + leading_str_to_keep = ", ".join( + [ + _pre_pad_alpha_line(s) if s[0].isalpha() and i != 0 else s + for i, s in enumerate(leading_str_to_keep.split(", ")) + ] + ) local_indent_str = "" if padded else indent_str leading_str = leading_str_to_keep.split("\\n")[-1].replace('"', "") remaining_str = array_str_in_split[1] @@ -3710,23 +3722,25 @@ def _pre_pad_alpha_line(str_in): uniform_indent_wo_overflow_list = list( filter(None, uniform_indent_wo_overflow.split("\\n")) ) - uniform_indent = "\n".join([ - ( - local_indent_str + extra_indent + " " + s - if ( - s[0].isnumeric() - or s[0] == "-" - or s[0:3] == "..." - or max(ss in s[0:6] for ss in ["nan, ", "inf, "]) - ) - else ( - indent_str + indented_key_str + s - if (not s[0].isspace() and s[0] != '"') - else s + uniform_indent = "\n".join( + [ + ( + local_indent_str + extra_indent + " " + s + if ( + s[0].isnumeric() + or s[0] == "-" + or s[0:3] == "..." + or max(ss in s[0:6] for ss in ["nan, ", "inf, "]) + ) + else ( + indent_str + indented_key_str + s + if (not s[0].isspace() and s[0] != '"') + else s + ) ) - ) - for s in uniform_indent_wo_overflow_list - ]) + for s in uniform_indent_wo_overflow_list + ] + ) indented = uniform_indent # 10 dimensions is a sensible upper bound for the number in a single array for i in range(2, 10): @@ -3832,14 +3846,16 @@ def _align_arrays(str_in): def _add_newline(str_in): str_in_split = str_in.split("\n") str_split_size = len(str_in_split) - return "\n".join([ - ( - ("\n" * self._print_line_spacing + ss) - if i == (str_split_size - 1) - else ss - ) - for i, ss in enumerate(str_in_split) - ]) + return "\n".join( + [ + ( + ("\n" * self._print_line_spacing + ss) + if i == (str_split_size - 1) + else ss + ) + for i, ss in enumerate(str_in_split) + ] + ) json_dumped_str = '":'.join( [_add_newline(s) for s in json_dumped_str.split('":')] @@ -3850,9 +3866,12 @@ def _add_newline(str_in): json_dumped_str = ( json_dumped_str_split[0] + ", " - + ", ".join([ - "'".join(ss.split("'")[1:]) for ss in json_dumped_str_split[1:] - ]) + + ", ".join( + [ + "'".join(ss.split("'")[1:]) + for ss in json_dumped_str_split[1:] + ] + ) ) json_dumped_str = ( json_dumped_str.replace(":shape", ", shape") @@ -3863,24 +3882,26 @@ def _add_newline(str_in): # color keys json_dumped_str_split = json_dumped_str.split('":') split_size = len(json_dumped_str_split) - json_dumped_str = '":'.join([ - ( - ' "'.join( - sub_str.split(' "')[:-1] - + [ - termcolor.colored( - ivy.Container.cont_trim_key( - sub_str.split(' "')[-1], self._key_length_limit - ), - self._default_key_color, - ) - ] + json_dumped_str = '":'.join( + [ + ( + ' "'.join( + sub_str.split(' "')[:-1] + + [ + termcolor.colored( + ivy.Container.cont_trim_key( + sub_str.split(' "')[-1], self._key_length_limit + ), + self._default_key_color, + ) + ] + ) + if i < split_size - 1 + else sub_str ) - if i < split_size - 1 - else sub_str - ) - for i, sub_str in enumerate(json_dumped_str_split) - ]) + for i, sub_str in enumerate(json_dumped_str_split) + ] + ) # remove quotation marks, shape tuple, and color other elements of the dict ret = ( json_dumped_str.replace('"', "") diff --git a/ivy/data_classes/factorized_tensor/cp_tensor.py b/ivy/data_classes/factorized_tensor/cp_tensor.py index e81c18f929f6e..7def7d8288202 100644 --- a/ivy/data_classes/factorized_tensor/cp_tensor.py +++ b/ivy/data_classes/factorized_tensor/cp_tensor.py @@ -68,10 +68,12 @@ def to_unfolded(self, mode): return ivy.CPTensor.cp_to_unfolded(self, mode) def cp_copy(self): - return CPTensor(( - ivy.copy_array(self.weights), - [ivy.copy_array(self.factors[i]) for i in range(len(self.factors))], - )) + return CPTensor( + ( + ivy.copy_array(self.weights), + [ivy.copy_array(self.factors[i]) for i in range(len(self.factors))], + ) + ) def mode_dot(self, matrix_or_vector, mode, keep_dim=False, copy=True): """N-mode product of a CP tensor and a matrix or vector at the diff --git a/ivy/data_classes/factorized_tensor/tucker_tensor.py b/ivy/data_classes/factorized_tensor/tucker_tensor.py index 17f5d27f6c0c3..5984be2efe365 100644 --- a/ivy/data_classes/factorized_tensor/tucker_tensor.py +++ b/ivy/data_classes/factorized_tensor/tucker_tensor.py @@ -83,10 +83,12 @@ def to_unfolded(self, mode): return TuckerTensor.tucker_to_unfolded(self, mode) def tucker_copy(self): - return TuckerTensor(( - deepcopy(self.core), - [deepcopy(self.factors[i]) for i in range(len(self.factors))], - )) + return TuckerTensor( + ( + deepcopy(self.core), + [deepcopy(self.factors[i]) for i in range(len(self.factors))], + ) + ) def to_vec(self): return TuckerTensor.tucker_to_vec(self) diff --git a/ivy/func_wrapper.py b/ivy/func_wrapper.py index 7338bec329843..5e02cb26cde62 100644 --- a/ivy/func_wrapper.py +++ b/ivy/func_wrapper.py @@ -1658,14 +1658,16 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func([ - item, - ( - _dtype_device_wrapper_creator("unsupported_dtypes", tuple)( - *self.args, **self.kwargs - ) - )(globals_getter_func()[item]), - ]) + globals_getter_func( + [ + item, + ( + _dtype_device_wrapper_creator( + "unsupported_dtypes", tuple + )(*self.args, **self.kwargs) + )(globals_getter_func()[item]), + ] + ) class with_supported_dtypes(contextlib.ContextDecorator): @@ -1692,14 +1694,16 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func([ - item, - ( - _dtype_device_wrapper_creator("supported_dtypes", tuple)( - *self.args, **self.kwargs - ) - )(globals_getter_func()[item]), - ]) + globals_getter_func( + [ + item, + ( + _dtype_device_wrapper_creator( + "supported_dtypes", tuple + )(*self.args, **self.kwargs) + )(globals_getter_func()[item]), + ] + ) class with_unsupported_devices(contextlib.ContextDecorator): @@ -1726,14 +1730,16 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func([ - item, - ( - _dtype_device_wrapper_creator("unsupported_devices", tuple)( - *self.args, **self.kwargs - ) - )(globals_getter_func()[item]), - ]) + globals_getter_func( + [ + item, + ( + _dtype_device_wrapper_creator( + "unsupported_devices", tuple + )(*self.args, **self.kwargs) + )(globals_getter_func()[item]), + ] + ) class with_supported_devices(contextlib.ContextDecorator): @@ -1760,14 +1766,16 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func([ - item, - ( - _dtype_device_wrapper_creator("supported_devices", tuple)( - *self.args, **self.kwargs - ) - )(globals_getter_func()[item]), - ]) + globals_getter_func( + [ + item, + ( + _dtype_device_wrapper_creator( + "supported_devices", tuple + )(*self.args, **self.kwargs) + )(globals_getter_func()[item]), + ] + ) class with_unsupported_device_and_dtypes(contextlib.ContextDecorator): @@ -1816,14 +1824,16 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func([ - item, - ( - _dtype_device_wrapper_creator( - "unsupported_device_and_dtype", tuple - )(*self.args, **self.kwargs) - )(globals_getter_func()[item]), - ]) + globals_getter_func( + [ + item, + ( + _dtype_device_wrapper_creator( + "unsupported_device_and_dtype", tuple + )(*self.args, **self.kwargs) + )(globals_getter_func()[item]), + ] + ) class with_supported_device_and_dtypes(contextlib.ContextDecorator): @@ -1872,14 +1882,16 @@ def __exit__(self, *exec): if globals_getter_func().get(item, None): if isinstance(globals_getter_func()[item], FunctionType): # we need to add the decorator - globals_getter_func([ - item, - ( - _dtype_device_wrapper_creator( - "supported_device_and_dtype", tuple - )(*self.args, **self.kwargs) - )(globals_getter_func()[item]), - ]) + globals_getter_func( + [ + item, + ( + _dtype_device_wrapper_creator( + "supported_device_and_dtype", tuple + )(*self.args, **self.kwargs) + )(globals_getter_func()[item]), + ] + ) class override(contextlib.ContextDecorator): diff --git a/ivy/functional/backends/jax/random.py b/ivy/functional/backends/jax/random.py index 4422cec77481f..ef0555fabf6d7 100644 --- a/ivy/functional/backends/jax/random.py +++ b/ivy/functional/backends/jax/random.py @@ -106,10 +106,12 @@ def multinomial( if probs is None: probs = ( - jnp.ones(( - batch_size, - population_size, - )) + jnp.ones( + ( + batch_size, + population_size, + ) + ) / population_size ) orig_probs_shape = list(probs.shape) diff --git a/ivy/functional/backends/mxnet/creation.py b/ivy/functional/backends/mxnet/creation.py index 5da540614b9e3..d32d312efc394 100644 --- a/ivy/functional/backends/mxnet/creation.py +++ b/ivy/functional/backends/mxnet/creation.py @@ -35,16 +35,18 @@ def arange( @_asarray_handle_nestable @_asarray_inputs_to_native_shapes def asarray( - obj: Union[( - None, - mx.ndarray.NDArray, - bool, - int, - float, - NestedSequence, - SupportsBufferProtocol, - np.ndarray, - )], + obj: Union[ + ( + None, + mx.ndarray.NDArray, + bool, + int, + float, + NestedSequence, + SupportsBufferProtocol, + np.ndarray, + ) + ], /, *, copy: Optional[bool] = None, diff --git a/ivy/functional/backends/mxnet/experimental/linear_algebra.py b/ivy/functional/backends/mxnet/experimental/linear_algebra.py index 458c945791b83..dd31f5eeb070d 100644 --- a/ivy/functional/backends/mxnet/experimental/linear_algebra.py +++ b/ivy/functional/backends/mxnet/experimental/linear_algebra.py @@ -15,11 +15,13 @@ def eigh_tridiagonal( Union[(Tuple[(int, int)], List[int], None, mx.ndarray.NDArray)] ] = None, tol: Optional[float] = None, -) -> Union[( - None, - mx.ndarray.NDArray, - Tuple[(Union[(None, mx.ndarray.NDArray)], Union[(None, mx.ndarray.NDArray)])], -)]: +) -> Union[ + ( + None, + mx.ndarray.NDArray, + Tuple[(Union[(None, mx.ndarray.NDArray)], Union[(None, mx.ndarray.NDArray)])], + ) +]: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/mxnet/experimental/norms.py b/ivy/functional/backends/mxnet/experimental/norms.py index da6b8b5311adf..19fea95289a8d 100644 --- a/ivy/functional/backends/mxnet/experimental/norms.py +++ b/ivy/functional/backends/mxnet/experimental/norms.py @@ -26,11 +26,13 @@ def batch_norm( eps: float = 1e-05, momentum: float = 0.1, out: Optional[None] = None, -) -> Tuple[( - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], -)]: +) -> Tuple[ + ( + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + ) +]: raise IvyNotImplementedException() @@ -46,11 +48,13 @@ def instance_norm( eps: float = 1e-05, momentum: float = 0.1, out: Optional[None] = None, -) -> Tuple[( - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], -)]: +) -> Tuple[ + ( + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + ) +]: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/mxnet/set.py b/ivy/functional/backends/mxnet/set.py index 1617ed1539d12..cb9a9cc9906e6 100644 --- a/ivy/functional/backends/mxnet/set.py +++ b/ivy/functional/backends/mxnet/set.py @@ -6,12 +6,14 @@ def unique_all( x: Union[(None, mx.ndarray.NDArray)], /, *, axis: Optional[int] = None -) -> Tuple[( - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], - Union[(None, mx.ndarray.NDArray)], -)]: +) -> Tuple[ + ( + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + Union[(None, mx.ndarray.NDArray)], + ) +]: raise IvyNotImplementedException() diff --git a/ivy/functional/backends/numpy/experimental/elementwise.py b/ivy/functional/backends/numpy/experimental/elementwise.py index ab35f7d972aa7..821c287a722b5 100644 --- a/ivy/functional/backends/numpy/experimental/elementwise.py +++ b/ivy/functional/backends/numpy/experimental/elementwise.py @@ -338,16 +338,18 @@ def modf( # ---digamma---# kLanczosGamma = 7 # aka g kBaseLanczosCoeff = 0.99999999999980993227684700473478 -kLanczosCoefficients = np.array([ - 676.520368121885098567009190444019, - -1259.13921672240287047156078755283, - 771.3234287776530788486528258894, - -176.61502916214059906584551354, - 12.507343278686904814458936853, - -0.13857109526572011689554707, - 9.984369578019570859563e-6, - 1.50563273514931155834e-7, -]) +kLanczosCoefficients = np.array( + [ + 676.520368121885098567009190444019, + -1259.13921672240287047156078755283, + 771.3234287776530788486528258894, + -176.61502916214059906584551354, + 12.507343278686904814458936853, + -0.13857109526572011689554707, + 9.984369578019570859563e-6, + 1.50563273514931155834e-7, + ] +) def digamma( @@ -397,36 +399,40 @@ def digamma( # --- LGAMMA --- # LANCZOS_N = 13 lanczos_g = 6.024680040776729583740234375 -lanczos_num_coeffs = np.array([ - 23531376880.410759688572007674451636754734846804940, - 42919803642.649098768957899047001988850926355848959, - 35711959237.355668049440185451547166705960488635843, - 17921034426.037209699919755754458931112671403265390, - 6039542586.3520280050642916443072979210699388420708, - 1439720407.3117216736632230727949123939715485786772, - 248874557.86205415651146038641322942321632125127801, - 31426415.585400194380614231628318205362874684987640, - 2876370.6289353724412254090516208496135991145378768, - 186056.26539522349504029498971604569928220784236328, - 8071.6720023658162106380029022722506138218516325024, - 210.82427775157934587250973392071336271166969580291, - 2.5066282746310002701649081771338373386264310793408, -]) -lanczos_den_coeffs = np.array([ - 0.0, - 39916800.0, - 120543840.0, - 150917976.0, - 105258076.0, - 45995730.0, - 13339535.0, - 2637558.0, - 357423.0, - 32670.0, - 1925.0, - 66.0, - 1.0, -]) +lanczos_num_coeffs = np.array( + [ + 23531376880.410759688572007674451636754734846804940, + 42919803642.649098768957899047001988850926355848959, + 35711959237.355668049440185451547166705960488635843, + 17921034426.037209699919755754458931112671403265390, + 6039542586.3520280050642916443072979210699388420708, + 1439720407.3117216736632230727949123939715485786772, + 248874557.86205415651146038641322942321632125127801, + 31426415.585400194380614231628318205362874684987640, + 2876370.6289353724412254090516208496135991145378768, + 186056.26539522349504029498971604569928220784236328, + 8071.6720023658162106380029022722506138218516325024, + 210.82427775157934587250973392071336271166969580291, + 2.5066282746310002701649081771338373386264310793408, + ] +) +lanczos_den_coeffs = np.array( + [ + 0.0, + 39916800.0, + 120543840.0, + 150917976.0, + 105258076.0, + 45995730.0, + 13339535.0, + 2637558.0, + 357423.0, + 32670.0, + 1925.0, + 66.0, + 1.0, + ] +) def sinpi(x): @@ -512,45 +518,53 @@ def func(x): # --- erfc --- # # Polynomials for computing erf/erfc. Originally from cephes library. # https://netlib.org/cephes/doubldoc.html -kErfcPCoefficient = np.array([ - 2.46196981473530512524e-10, - 5.64189564831068821977e-1, - 7.46321056442269912687e0, - 4.86371970985681366614e1, - 1.96520832956077098242e2, - 5.26445194995477358631e2, - 9.34528527171957607540e2, - 1.02755188689515710272e3, - 5.57535335369399327526e2, -]) -kErfcQCoefficient = np.array([ - 1.00000000000000000000e0, - 1.32281951154744992508e1, - 8.67072140885989742329e1, - 3.54937778887819891062e2, - 9.75708501743205489753e2, - 1.82390916687909736289e3, - 2.24633760818710981792e3, - 1.65666309194161350182e3, - 5.57535340817727675546e2, -]) -kErfcRCoefficient = np.array([ - 5.64189583547755073984e-1, - 1.27536670759978104416e0, - 5.01905042251180477414e0, - 6.16021097993053585195e0, - 7.40974269950448939160e0, - 2.97886665372100240670e0, -]) -kErfcSCoefficient = np.array([ - 1.00000000000000000000e0, - 2.26052863220117276590e0, - 9.39603524938001434673e0, - 1.20489539808096656605e1, - 1.70814450747565897222e1, - 9.60896809063285878198e0, - 3.36907645100081516050e0, -]) +kErfcPCoefficient = np.array( + [ + 2.46196981473530512524e-10, + 5.64189564831068821977e-1, + 7.46321056442269912687e0, + 4.86371970985681366614e1, + 1.96520832956077098242e2, + 5.26445194995477358631e2, + 9.34528527171957607540e2, + 1.02755188689515710272e3, + 5.57535335369399327526e2, + ] +) +kErfcQCoefficient = np.array( + [ + 1.00000000000000000000e0, + 1.32281951154744992508e1, + 8.67072140885989742329e1, + 3.54937778887819891062e2, + 9.75708501743205489753e2, + 1.82390916687909736289e3, + 2.24633760818710981792e3, + 1.65666309194161350182e3, + 5.57535340817727675546e2, + ] +) +kErfcRCoefficient = np.array( + [ + 5.64189583547755073984e-1, + 1.27536670759978104416e0, + 5.01905042251180477414e0, + 6.16021097993053585195e0, + 7.40974269950448939160e0, + 2.97886665372100240670e0, + ] +) +kErfcSCoefficient = np.array( + [ + 1.00000000000000000000e0, + 2.26052863220117276590e0, + 9.39603524938001434673e0, + 1.20489539808096656605e1, + 1.70814450747565897222e1, + 9.60896809063285878198e0, + 3.36907645100081516050e0, + ] +) # Evaluate the polynomial given coefficients and `x`. diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py index 4d3daa4a00c6e..17a9d19fc4698 100644 --- a/ivy/functional/backends/numpy/random.py +++ b/ivy/functional/backends/numpy/random.py @@ -69,10 +69,12 @@ def multinomial( np.random.seed(seed) if probs is None: probs = ( - np.ones(( - batch_size, - population_size, - )) + np.ones( + ( + batch_size, + population_size, + ) + ) / population_size ) orig_probs_shape = list(probs.shape) diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py index 0ecef27c3ec71..c26898376ea69 100644 --- a/ivy/functional/backends/paddle/experimental/elementwise.py +++ b/ivy/functional/backends/paddle/experimental/elementwise.py @@ -715,45 +715,53 @@ def digamma( # --- erfc --- # # Polynomials for computing erf/erfc. Originally from cephes library. # https://netlib.org/cephes/doubldoc.html -kErfcPCoefficient = paddle.to_tensor([ - 2.46196981473530512524e-10, - 5.64189564831068821977e-1, - 7.46321056442269912687e0, - 4.86371970985681366614e1, - 1.96520832956077098242e2, - 5.26445194995477358631e2, - 9.34528527171957607540e2, - 1.02755188689515710272e3, - 5.57535335369399327526e2, -]) -kErfcQCoefficient = paddle.to_tensor([ - 1.00000000000000000000e0, - 1.32281951154744992508e1, - 8.67072140885989742329e1, - 3.54937778887819891062e2, - 9.75708501743205489753e2, - 1.82390916687909736289e3, - 2.24633760818710981792e3, - 1.65666309194161350182e3, - 5.57535340817727675546e2, -]) -kErfcRCoefficient = paddle.to_tensor([ - 5.64189583547755073984e-1, - 1.27536670759978104416e0, - 5.01905042251180477414e0, - 6.16021097993053585195e0, - 7.40974269950448939160e0, - 2.97886665372100240670e0, -]) -kErfcSCoefficient = paddle.to_tensor([ - 1.00000000000000000000e0, - 2.26052863220117276590e0, - 9.39603524938001434673e0, - 1.20489539808096656605e1, - 1.70814450747565897222e1, - 9.60896809063285878198e0, - 3.36907645100081516050e0, -]) +kErfcPCoefficient = paddle.to_tensor( + [ + 2.46196981473530512524e-10, + 5.64189564831068821977e-1, + 7.46321056442269912687e0, + 4.86371970985681366614e1, + 1.96520832956077098242e2, + 5.26445194995477358631e2, + 9.34528527171957607540e2, + 1.02755188689515710272e3, + 5.57535335369399327526e2, + ] +) +kErfcQCoefficient = paddle.to_tensor( + [ + 1.00000000000000000000e0, + 1.32281951154744992508e1, + 8.67072140885989742329e1, + 3.54937778887819891062e2, + 9.75708501743205489753e2, + 1.82390916687909736289e3, + 2.24633760818710981792e3, + 1.65666309194161350182e3, + 5.57535340817727675546e2, + ] +) +kErfcRCoefficient = paddle.to_tensor( + [ + 5.64189583547755073984e-1, + 1.27536670759978104416e0, + 5.01905042251180477414e0, + 6.16021097993053585195e0, + 7.40974269950448939160e0, + 2.97886665372100240670e0, + ] +) +kErfcSCoefficient = paddle.to_tensor( + [ + 1.00000000000000000000e0, + 2.26052863220117276590e0, + 9.39603524938001434673e0, + 1.20489539808096656605e1, + 1.70814450747565897222e1, + 9.60896809063285878198e0, + 3.36907645100081516050e0, + ] +) # Evaluate the polynomial given coefficients and `x`. diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 2d1804e87c315..0f9747fe6353e 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -70,11 +70,13 @@ def _squeeze_helper(query, x_ndim): ) if any(slice_squeeze): - squeeze_indices = tuple([ - idx - for idx, val in enumerate(slice_squeeze) - if (val is False and query[idx] is not None) - ]) + squeeze_indices = tuple( + [ + idx + for idx, val in enumerate(slice_squeeze) + if (val is False and query[idx] is not None) + ] + ) elif return_scalar: squeeze_indices = () else: diff --git a/ivy/functional/backends/paddle/gradients.py b/ivy/functional/backends/paddle/gradients.py index 0a0a9ab9b7c80..925e49c865bc1 100644 --- a/ivy/functional/backends/paddle/gradients.py +++ b/ivy/functional/backends/paddle/gradients.py @@ -116,10 +116,12 @@ def execute_with_gradients( xs = xs1 if isinstance(xs, ivy.Container): duplicate_indices = list( - chain.from_iterable([ - map(lambda x: x.split("/"), duplicate_index_chain[1:]) - for duplicate_index_chain in required_duplicate_index_chains - ]) + chain.from_iterable( + [ + map(lambda x: x.split("/"), duplicate_index_chain[1:]) + for duplicate_index_chain in required_duplicate_index_chains + ] + ) ) xs = ivy.set_nest_at_indices(xs, duplicate_indices, None, shallow=False) diff --git a/ivy/functional/backends/paddle/set.py b/ivy/functional/backends/paddle/set.py index 789218824f1d6..1d73d6b200496 100644 --- a/ivy/functional/backends/paddle/set.py +++ b/ivy/functional/backends/paddle/set.py @@ -63,12 +63,14 @@ def unique_all( axis = 0 values_ = paddle.moveaxis(values, axis, 0) values_ = paddle.reshape(values_, (values_.shape[0], -1)) - sort_idx = paddle.to_tensor([ - i[0] - for i in sorted( - enumerate(values_.numpy().tolist()), key=lambda x: tuple(x[1]) - ) - ]) + sort_idx = paddle.to_tensor( + [ + i[0] + for i in sorted( + enumerate(values_.numpy().tolist()), key=lambda x: tuple(x[1]) + ) + ] + ) values = paddle.gather(values, sort_idx, axis=axis) counts = paddle.gather(counts, sort_idx) indices = paddle.gather(indices, sort_idx) diff --git a/ivy/functional/backends/tensorflow/experimental/layers.py b/ivy/functional/backends/tensorflow/experimental/layers.py index f13eb3e9290c9..3aa7d1126f5fe 100644 --- a/ivy/functional/backends/tensorflow/experimental/layers.py +++ b/ivy/functional/backends/tensorflow/experimental/layers.py @@ -1208,11 +1208,13 @@ def shape_initialization(shape, axes, x): def rank_initialization(axes): rank = tf.size(axes) - with tf.control_dependencies([ - tf.debugging.assert_less_equal( - rank, 3, message="N-D FFT supported only up to 3-D." - ) - ]): + with tf.control_dependencies( + [ + tf.debugging.assert_less_equal( + rank, 3, message="N-D FFT supported only up to 3-D." + ) + ] + ): rank = tf.identity(rank) return rank diff --git a/ivy/functional/backends/tensorflow/module.py b/ivy/functional/backends/tensorflow/module.py index 919f21b630924..9c7d670aa977d 100644 --- a/ivy/functional/backends/tensorflow/module.py +++ b/ivy/functional/backends/tensorflow/module.py @@ -84,10 +84,12 @@ def __repr__(self, indent: int = 0) -> str: indent += len(repr_prefix) children_specs_str += self.children_specs[0].__repr__(indent) children_specs_str += "," if len(self.children_specs) > 1 else "" - children_specs_str += ",".join([ - "\n" + " " * indent + child.__repr__(indent) - for child in self.children_specs[1:] - ]) + children_specs_str += ",".join( + [ + "\n" + " " * indent + child.__repr__(indent) + for child in self.children_specs[1:] + ] + ) repr_suffix: str = f"{children_specs_str}])" return repr_prefix + repr_suffix @@ -426,10 +428,12 @@ def _find_variables( if ( v is not None and k[0:2] != "__" - and not k.startswith(( - "_module_dict", - "_self_", - )) + and not k.startswith( + ( + "_module_dict", + "_self_", + ) + ) ): ret = self._find_variables( obj=v, diff --git a/ivy/functional/backends/tensorflow/random.py b/ivy/functional/backends/tensorflow/random.py index dcb320508614d..65828a02669d9 100644 --- a/ivy/functional/backends/tensorflow/random.py +++ b/ivy/functional/backends/tensorflow/random.py @@ -80,10 +80,12 @@ def multinomial( ) -> Union[tf.Tensor, tf.Variable]: if probs is None: probs = ( - tf.ones(( - batch_size, - population_size, - )) + tf.ones( + ( + batch_size, + population_size, + ) + ) / population_size ) diff --git a/ivy/functional/backends/torch/experimental/gradients.py b/ivy/functional/backends/torch/experimental/gradients.py index a959d5ab83e03..b6c0a7cedf6e4 100644 --- a/ivy/functional/backends/torch/experimental/gradients.py +++ b/ivy/functional/backends/torch/experimental/gradients.py @@ -34,10 +34,12 @@ def backward(ctx, upstream): def vjp(func: Callable, *primals): flattened_primals, ret_idxs = _flatten_containers(primals) - unique_keys = list({ - ivy.index_nest(ret_idxs, i) - for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) - }) + unique_keys = list( + { + ivy.index_nest(ret_idxs, i) + for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) + } + ) def grad_fn(*x_in): ret, idxs = _flatten_containers( @@ -93,10 +95,12 @@ def vjpfun(*x_in): def jvp(func: Callable, primals, tangents): flattened_primals, ret_idxs = _flatten_containers(primals) flattened_tangents, _ = _flatten_containers(tangents) - unique_keys = list({ - ivy.index_nest(ret_idxs, i) - for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) - }) + unique_keys = list( + { + ivy.index_nest(ret_idxs, i) + for i in ivy.nested_argwhere(ret_idxs, lambda x: isinstance(x, str)) + } + ) def grad_fn(*x_in): ret, idxs = _flatten_containers( diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index f8cfbaa6a64a9..d5aa9e44c085a 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -292,10 +292,12 @@ def _handle_axis(a, q, fn, keepdims=False, axis=None): for i, s in enumerate(sorted(keep)): a = torch.moveaxis(a, s, i) - a = a.view([ - *a.shape[:nkeep], - -1, - ]) + a = a.view( + [ + *a.shape[:nkeep], + -1, + ] + ) axis_arg = -1 ret = fn(a, q, axis=axis_arg) diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py index 944413c523b21..f4ee4e0cdf2ad 100644 --- a/ivy/functional/backends/torch/random.py +++ b/ivy/functional/backends/torch/random.py @@ -78,10 +78,12 @@ def multinomial( ) -> torch.Tensor: if probs is None: probs = ( - torch.ones(( - batch_size, - population_size, - )) + torch.ones( + ( + batch_size, + population_size, + ) + ) / population_size ) if seed: diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 27974eeb898f7..38ba820389006 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -1405,11 +1405,13 @@ def _tf_area_interpolate(x, size, scale, dims): d_in, d_in1, d_index = _tf_area_indices(d_dim, scale[0]) h_in, h_in1, h_index = _tf_area_indices(h_dim, scale[1]) w_in, w_in1, w_index = _tf_area_indices(w_dim, scale[2]) - sum_data = ivy.zeros(( - d_index[1] - d_index[0], - h_index[1] - h_index[0], - w_index[1] - w_index[0], - )) + sum_data = ivy.zeros( + ( + d_index[1] - d_index[0], + h_index[1] - h_index[0], + w_index[1] - w_index[0], + ) + ) for d_ind in range(d_index[0], d_index[1]): scale_z = _tf_area_dim_scale( d_ind, d_in, scale[0], d_in1 @@ -1912,14 +1914,18 @@ def interpolate( right = int(math.ceil(p_j + 2)) top = int(math.floor(p_i - 2)) bottom = int(math.ceil(p_i + 2)) - kernel_w = ivy.array([ - _mitchellcubic_kernel((p_j - j) * scale_w) - for i in range(left, right) - ]) - kernel_h = ivy.array([ - _mitchellcubic_kernel((p_i - i) * scale_h) - for j in range(top, bottom) - ]) + kernel_w = ivy.array( + [ + _mitchellcubic_kernel((p_j - j) * scale_w) + for i in range(left, right) + ] + ) + kernel_h = ivy.array( + [ + _mitchellcubic_kernel((p_i - i) * scale_h) + for j in range(top, bottom) + ] + ) left_pad = max(0, -left) right_pad = max(0, right - in_width) top_pad = max(0, -top) diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index cad3733c69dcc..f98ec8a896e14 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -1051,12 +1051,14 @@ def svd_flip( ) V = V * signs[:, None] if ivy.shape(U)[1] > ivy.shape(V)[0]: - signs = ivy.concat(( - signs, - ivy.ones( - ivy.shape(U)[1] - ivy.shape(V)[0], - ), - )) + signs = ivy.concat( + ( + signs, + ivy.ones( + ivy.shape(U)[1] - ivy.shape(V)[0], + ), + ) + ) U = U * signs[: ivy.shape(U)[1]] return U, V diff --git a/ivy/functional/ivy/experimental/sparse_array.py b/ivy/functional/ivy/experimental/sparse_array.py index 623a38a918afa..4a82fb4f97ad9 100644 --- a/ivy/functional/ivy/experimental/sparse_array.py +++ b/ivy/functional/ivy/experimental/sparse_array.py @@ -766,10 +766,12 @@ def _bsr_to_dense_coordinates(self): for col in cols: for col_index in range(nblockcols): for row_index in range(nblockrows): - all_coordinates.append([ - nblockrows * row + row_index, - nblockcols * col + col_index, - ]) + all_coordinates.append( + [ + nblockrows * row + row_index, + nblockcols * col + col_index, + ] + ) return all_coordinates def _bsc_to_dense_coordinates(self): @@ -785,10 +787,12 @@ def _bsc_to_dense_coordinates(self): for row in rows: for col_index in range(nblockcols): for row_index in range(nblockrows): - all_coordinates.append([ - nblockrows * row + row_index, - nblockcols * col + col_index, - ]) + all_coordinates.append( + [ + nblockrows * row + row_index, + nblockcols * col + col_index, + ] + ) return all_coordinates def to_dense_array(self, *, native=False): diff --git a/ivy/functional/ivy/meta.py b/ivy/functional/ivy/meta.py index 5b3151c9accc6..f468ded38a0e3 100644 --- a/ivy/functional/ivy/meta.py +++ b/ivy/functional/ivy/meta.py @@ -88,10 +88,12 @@ def cost_fn_with_variable(v): else variables.cont_prune_key_chains(outer_v, ignore_none=True) ) - inner_grads = ivy.Container({ - k: ivy.zeros_like(v) if k not in inner_grads else inner_grads[k] - for k, v in var.cont_to_iterator() - }) + inner_grads = ivy.Container( + { + k: ivy.zeros_like(v) if k not in inner_grads else inner_grads[k] + for k, v in var.cont_to_iterator() + } + ) if batched: inner_grads = ivy.multiply(inner_grads, num_tasks) @@ -151,14 +153,16 @@ def _train_task( if keep_innver_v else variables.cont_prune_key_chains(inner_v, ignore_none=True) ) - inner_update_grads = ivy.Container({ - k: ( - ivy.zeros_like(v) - if k not in inner_update_grads - else inner_update_grads[k] - ) - for k, v in var.cont_to_iterator() - }) + inner_update_grads = ivy.Container( + { + k: ( + ivy.zeros_like(v) + if k not in inner_update_grads + else inner_update_grads[k] + ) + for k, v in var.cont_to_iterator() + } + ) if batched: inner_update_grads = ivy.multiply(inner_update_grads, num_tasks) diff --git a/ivy/functional/ivy/nest.py b/ivy/functional/ivy/nest.py index 60e9f1f279f43..2725361c86bba 100644 --- a/ivy/functional/ivy/nest.py +++ b/ivy/functional/ivy/nest.py @@ -1341,14 +1341,16 @@ def copy_nest( return class_instance(**dict(zip(nest._fields, ret_list))) return class_instance(tuple(ret_list)) elif check_fn(nest, list): - return class_instance([ - copy_nest( - i, - include_derived=include_derived, - to_mutable=to_mutable, - ) - for i in nest - ]) + return class_instance( + [ + copy_nest( + i, + include_derived=include_derived, + to_mutable=to_mutable, + ) + for i in nest + ] + ) elif check_fn(nest, dict): class_instance = type(nest) dict_ = { diff --git a/ivy/stateful/module.py b/ivy/stateful/module.py index 12a16f95f39dc..d8ad7d80455d1 100644 --- a/ivy/stateful/module.py +++ b/ivy/stateful/module.py @@ -803,10 +803,12 @@ def _create_variables(self, device=None, dtype=None): def _build(self, *args, **kwargs): self._native_params = ivy.Container( OrderedDict( - sorted([ - (k.replace(".", "/"), v) - for k, v in dict(self._native_module.named_parameters()).items() - ]) + sorted( + [ + (k.replace(".", "/"), v) + for k, v in dict(self._native_module.named_parameters()).items() + ] + ) ), dynamic_backend=False, ) @@ -834,10 +836,12 @@ def _create_variables(self, device=None, dtype=None): def _build(self, *args, **kwargs): self._native_params = ivy.Container( OrderedDict( - sorted([ - (k.replace(".", "/"), v) - for k, v in dict(self._native_module.named_parameters()).items() - ]) + sorted( + [ + (k.replace(".", "/"), v) + for k, v in dict(self._native_module.named_parameters()).items() + ] + ) ), dynamic_backend=False, ) diff --git a/ivy/utils/binaries.py b/ivy/utils/binaries.py index 5f050892f2044..8b22ed383a159 100644 --- a/ivy/utils/binaries.py +++ b/ivy/utils/binaries.py @@ -33,10 +33,12 @@ def check_for_binaries(): for path in binaries_paths: if not os.path.exists(path): if initial: - config_str = "\n".join([ - f"{module} : {', '.join(configs)}" - for module, configs in available_configs.items() - ]) + config_str = "\n".join( + [ + f"{module} : {', '.join(configs)}" + for module, configs in available_configs.items() + ] + ) logging.warning( "\tSome binaries seem to be missing in your system. This could " "be either because we don't have compatible binaries for your " diff --git a/ivy_tests/test_ivy/conftest.py b/ivy_tests/test_ivy/conftest.py index 3501bdbf4dc01..3776351090e77 100644 --- a/ivy_tests/test_ivy/conftest.py +++ b/ivy_tests/test_ivy/conftest.py @@ -198,12 +198,14 @@ def pytest_configure(config): continue for trace_graph in trace_modes: for implicit in implicit_modes: - TEST_PARAMS_CONFIG.append(( - device, - backend_str, - trace_graph, - implicit, - )) + TEST_PARAMS_CONFIG.append( + ( + device, + backend_str, + trace_graph, + implicit, + ) + ) process_cl_flags(config) diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 0914fe641c0e2..4e0f7126b1dd4 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -529,15 +529,17 @@ def test_function( if mod_backend[backend_to_test]: # multiprocessing proc, input_queue, output_queue = mod_backend[backend_to_test] - input_queue.put(( - "function_backend_computation", - backend_to_test, - test_flags, - all_as_kwargs_np, - input_dtypes, - on_device, - fn_name, - )) + input_queue.put( + ( + "function_backend_computation", + backend_to_test, + test_flags, + all_as_kwargs_np, + input_dtypes, + on_device, + fn_name, + ) + ) ( ret_from_target, ret_np_flat_from_target, @@ -576,20 +578,22 @@ def test_function( # compute the return with a Ground Truth backend if mod_backend[ground_truth_backend]: proc, input_queue, output_queue = mod_backend[ground_truth_backend] - input_queue.put(( - "function_ground_truth_computation", - ground_truth_backend, - on_device, - args_np, - arg_np_arrays, - arrays_args_indices, - kwargs_np, - arrays_kwargs_indices, - kwarg_np_arrays, - input_dtypes, - test_flags, - fn_name, - )) + input_queue.put( + ( + "function_ground_truth_computation", + ground_truth_backend, + on_device, + args_np, + arg_np_arrays, + arrays_args_indices, + kwargs_np, + arrays_kwargs_indices, + kwarg_np_arrays, + input_dtypes, + test_flags, + fn_name, + ) + ) ( ret_from_gt, ret_np_from_gt_flat, @@ -621,13 +625,15 @@ def test_function( if test_flags.transpile: if mod_backend[backend_to_test]: proc, input_queue, output_queue = mod_backend[backend_to_test] - input_queue.put(( - "transpile_if_required_backend", - backend_to_test, - fn_name, - args_np, - kwargs_np, - )) + input_queue.put( + ( + "transpile_if_required_backend", + backend_to_test, + fn_name, + args_np, + kwargs_np, + ) + ) else: _transpile_if_required_backend( backend_to_test, fn_name, args=args_np, kwargs=kwargs_np @@ -1274,23 +1280,25 @@ def gradient_test( if mod_backend[backend_to_test]: # do this using multiprocessing proc, input_queue, output_queue = mod_backend[backend_to_test] - input_queue.put(( - "gradient_backend_computation", - backend_to_test, - args_np, - arg_np_vals, - args_idxs, - kwargs_np, - kwarg_np_vals, - kwargs_idxs, - input_dtypes, - test_flags, - on_device, - fn, - test_trace, - xs_grad_idxs, - ret_grad_idxs, - )) + input_queue.put( + ( + "gradient_backend_computation", + backend_to_test, + args_np, + arg_np_vals, + args_idxs, + kwargs_np, + kwarg_np_vals, + kwargs_idxs, + input_dtypes, + test_flags, + on_device, + fn, + test_trace, + xs_grad_idxs, + ret_grad_idxs, + ) + ) grads_np_flat = output_queue.get() else: @@ -1314,24 +1322,26 @@ def gradient_test( if mod_backend[ground_truth_backend]: # do this using multiprocessing proc, input_queue, output_queue = mod_backend[ground_truth_backend] - input_queue.put(( - "gradient_ground_truth_computation", - ground_truth_backend, - on_device, - fn, - input_dtypes, - all_as_kwargs_np, - args_np, - arg_np_vals, - args_idxs, - kwargs_np, - kwarg_np_vals, - test_flags, - kwargs_idxs, - test_trace, - xs_grad_idxs, - ret_grad_idxs, - )) + input_queue.put( + ( + "gradient_ground_truth_computation", + ground_truth_backend, + on_device, + fn, + input_dtypes, + all_as_kwargs_np, + args_np, + arg_np_vals, + args_idxs, + kwargs_np, + kwarg_np_vals, + test_flags, + kwargs_idxs, + test_trace, + xs_grad_idxs, + ret_grad_idxs, + ) + ) grads_np_from_gt_flat = output_queue.get() else: grads_np_from_gt_flat = test_gradient_ground_truth_computation( @@ -1739,22 +1749,24 @@ def test_method( if mod_backend[backend_to_test]: # yep, multiprocessing proc, input_queue, output_queue = mod_backend[backend_to_test] - input_queue.put(( - "method_backend_computation", - init_input_dtypes, - init_flags, - backend_to_test, - init_all_as_kwargs_np, - on_device, - method_input_dtypes, - method_flags, - method_all_as_kwargs_np, - class_name, - method_name, - init_with_v, - test_trace, - method_with_v, - )) + input_queue.put( + ( + "method_backend_computation", + init_input_dtypes, + init_flags, + backend_to_test, + init_all_as_kwargs_np, + on_device, + method_input_dtypes, + method_flags, + method_all_as_kwargs_np, + class_name, + method_name, + init_with_v, + test_trace, + method_with_v, + ) + ) ( ret, ret_np_flat, @@ -1803,24 +1815,26 @@ def test_method( if mod_backend[ground_truth_backend]: # yep, multiprocessing proc, input_queue, output_queue = mod_backend[ground_truth_backend] - input_queue.put(( - "method_ground_truth_computation", - ground_truth_backend, - on_device, - org_con_data, - args_np_method, - met_arg_np_vals, - met_args_idxs, - kwargs_np_method, - met_kwarg_np_vals, - met_kwargs_idxs, - method_input_dtypes, - method_flags, - class_name, - method_name, - test_trace, - v_np, - )) + input_queue.put( + ( + "method_ground_truth_computation", + ground_truth_backend, + on_device, + org_con_data, + args_np_method, + met_arg_np_vals, + met_args_idxs, + kwargs_np_method, + met_kwarg_np_vals, + met_kwargs_idxs, + method_input_dtypes, + method_flags, + class_name, + method_name, + test_trace, + v_np, + ) + ) ( ret_from_gt, ret_np_from_gt_flat, diff --git a/ivy_tests/test_ivy/helpers/multiprocessing.py b/ivy_tests/test_ivy/helpers/multiprocessing.py index 86f2d20971336..39234c644de27 100644 --- a/ivy_tests/test_ivy/helpers/multiprocessing.py +++ b/ivy_tests/test_ivy/helpers/multiprocessing.py @@ -101,19 +101,21 @@ def backend_proc(input_queue, output_queue): ) # ret_from_target to be none, because main process has # framework imports blocked - output_queue.put(( - (None), - ret_np_flat_from_target, - ret_device, - args_np, - arg_np_arrays, - arrays_args_indices, - kwargs_np, - arrays_kwargs_indices, - kwarg_np_arrays, - test_flags, - input_dtypes, - )) + output_queue.put( + ( + (None), + ret_np_flat_from_target, + ret_device, + args_np, + arg_np_arrays, + arrays_args_indices, + kwargs_np, + arrays_kwargs_indices, + kwarg_np_arrays, + test_flags, + input_dtypes, + ) + ) elif data[0] == "function_ground_truth_computation": # it's the ground_truth return computation ( @@ -150,13 +152,15 @@ def backend_proc(input_queue, output_queue): fn_name, ) # ret_from gt is none because main process has frameworks is None - output_queue.put(( - (None), - ret_np_from_gt_flat, - ret_from_gt_device, - test_flags, - fw_list, - )) + output_queue.put( + ( + (None), + ret_np_from_gt_flat, + ret_from_gt_device, + test_flags, + fw_list, + ) + ) elif data[0] == "gradient_backend_computation": # gradient testing , part where it uses the backend ( @@ -279,20 +283,22 @@ def backend_proc(input_queue, output_queue): method_with_v, ) # ret is none here, because main process doesn't import framework - output_queue.put(( - (None), - ret_np_flat, - ret_device, - org_con_data, - args_np_method, - met_arg_np_vals, - met_args_idxs, - kwargs_np_method, - met_kwarg_np_vals, - met_kwargs_idxs, - v_np, - fw_list, - )) + output_queue.put( + ( + (None), + ret_np_flat, + ret_device, + org_con_data, + args_np_method, + met_arg_np_vals, + met_args_idxs, + kwargs_np_method, + met_kwarg_np_vals, + met_kwargs_idxs, + v_np, + fw_list, + ) + ) elif data[0] == "method_ground_truth_computation": ( diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index 6c76e6e9f645a..5830b076674f6 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -231,13 +231,15 @@ def _get_method_supported_devices_dtypes( if mod_backend[backend_str]: # we gotta do this using multiprocessing proc, input_queue, output_queue = mod_backend[backend_str] - input_queue.put(( - "method supported dtypes", - method_name, - class_module.__name__, - class_name, - backend_str, - )) + input_queue.put( + ( + "method supported dtypes", + method_name, + class_module.__name__, + class_name, + backend_str, + ) + ) supported_device_dtypes[backend_str] = output_queue.get() else: supported_device_dtypes[backend_str] = ( diff --git a/scripts/backend_generation/tree_generation.py b/scripts/backend_generation/tree_generation.py index 51834c55bb8c6..7c94d01ef603c 100644 --- a/scripts/backend_generation/tree_generation.py +++ b/scripts/backend_generation/tree_generation.py @@ -292,15 +292,17 @@ def generate(config_file): generated_file.write(astunparse.unparse(tree_to_write)) subprocess.run(["black", "-q", backend_generation_path]) - subprocess.run([ - "autoflake", - "-i", - "--remove-all-unused-imports", - "--ignore-init-module-imports", - "--quiet", - "-r", - backend_generation_path, - ]) + subprocess.run( + [ + "autoflake", + "-i", + "--remove-all-unused-imports", + "--ignore-init-module-imports", + "--quiet", + "-r", + backend_generation_path, + ] + ) if __name__ == "__main__": From 9e9c0866fde670ca0cf2a08bf078c20b9be969e9 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Wed, 14 Feb 2024 13:46:03 +0530 Subject: [PATCH 804/978] feat: Added a decorator function, which will be used to test `explicit examples` (#28251) --- docs/overview/deep_dive/ivy_tests.rst | 51 +++++++- ivy_tests/test_ivy/helpers/testing_helpers.py | 113 +++++++++++++++++- .../test_functional/test_core/test_general.py | 25 ++-- 3 files changed, 167 insertions(+), 22 deletions(-) diff --git a/docs/overview/deep_dive/ivy_tests.rst b/docs/overview/deep_dive/ivy_tests.rst index 673f7e8dee994..9b3639dd385df 100644 --- a/docs/overview/deep_dive/ivy_tests.rst +++ b/docs/overview/deep_dive/ivy_tests.rst @@ -63,6 +63,7 @@ Ivy Tests .. _`num_positional_args`: https://github.com/unifyai/ivy/blob/e50f71e283313caa9737f3c284496022ac67b58b/ivy_tests/test_ivy/helpers/testing_helpers.py#L78 .. _`CI Pipeline`: continuous_integration.rst .. _`Hypothesis docs`: https://hypothesis.readthedocs.io/en/latest/data.html#core-strategies +.. _`this`: https://github.com/unifyai/ivy/blob/8dcc33b895240395686db165c710ac31708aa691/ivy_tests/test_ivy/test_functional/test_core/test_general.py#L1650 On top of the Array API `test suite`_, which is included as a submodule mapped to the folder :code:`test_array_api`, there is also a collection of Ivy tests, located in subfolder `test_ivy`_. @@ -221,7 +222,7 @@ Ivy Test Decorators - Why do we need to handle test decorators? -In order to run a test, a lot of pre-processing must be done, e.g. import the function, does it support complex data type? does it run on CPU? how many parameters does it take? are they positional or keyword only, or both? and a lot of information about the function that is being tested, this allows us later to run the test efficiently and in a **complete** way. all of this happens at collecting time. +In order to run a test, a lot of pre-processing must be done, e.g. import the function, does it support complex data type? does it run on CPU? how many parameters does it take? are they positional or keyword only, or both? and a lot of information about the function that is being tested, this allows us later to run the test efficiently and in a **complete** way. All of this happens at collecting time. - What do the handle test decorators do? @@ -241,14 +242,15 @@ This is not an exhaustive list of what the :code:`handle_test` decorators actual - Why do we have multiple handle test decorators? -Having multiple test decorators is mainly for efficiency, `handle_test` could do what `handle_frontend_test` does, it just handles the parameters slightly different, and this can be inferred at run time, but we choose to separate the decorator for general different usages, currently we have 4 separate decorators +Having multiple test decorators is mainly for efficiency, `handle_test` could do what `handle_frontend_test` does, it just handles the parameters slightly different, and this can be inferred at run time, but we choose to separate the decorator for general different usages, currently we have 5 separate decorators 1. :code:`handle_test` 2. :code:`handle_method` 3. :code:`handle_frontend_test` 4. :code:`handle_frontend_method` +5. :code:`handle_example` -One of the few differences between the 4 decorators is that they generate different kinds of flags, some generate more or less, but they all share the same general structure. +One of the few differences between the 5 decorators is that they generate different kinds of flags, some generate more or less, but they all share the same general structure. - Integration @@ -359,6 +361,49 @@ Let's look at the data produced by this strategy -: These values are then unpacked, converted to :class:`ivy.Array` class, with corresponding dtypes. The test then runs on the newly created arrays with specified data types. +Adding Explicit Examples to tests +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +In certain cases where we'd like to test certain examples explicitly which are outliers and it isn't feasible to define them as a strategy, +we can use the :code:`@handle_example` decorator. One such example is `this`_ where we need to test `ivy.set_item` with slice objects. + +Hypothesis allows us to test with an explicit example deterministically using the `@example`_ decorator. Our :code:`@handle_example` decorator is a wrapper around this. +Which helps us to use the default values of the test_flags, method_flags allowing us to easily test explicit examples for the ivy functional tests, frontend_tests, methods, and frontend_methods. + +We have to pass one of the following 4 arguments as `True` to the :code:`@handle_example` decorator depending on what test we are dealing with. +1. `test_example` +2. `test_frontend_example` +3. `test_method_example` +4. `test_frontend_method_example` + +The following example shows, how we can use the :code:`@handle_example` decorator to test the one of the frontend functions by adding an explicit example. + +.. code-block:: python + @handle_frontend_test( + fn_tree="paddle.acos", + dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float"),), + ) + @handle_example( + test_frontend_example=True, + dtype_and_x=(["float32"], [np.array(9.0, dtype=np.float32)]), + fn_tree="ivy.functional.frontends.paddle.acos", + test_flags={ + "native_arrays": [True], + "with_copy": True, + "with_out": True, + }, + ) + def test_some_function( + *, + dtype_and_x, + fn_tree, + frontend, + test_flags, + backend_fw, + ): + pass + + Why do we need helper functions? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index 5830b076674f6..37f87c76abda5 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -7,7 +7,7 @@ import functools from typing import List, Optional -from hypothesis import given, strategies as st +from hypothesis import given, strategies as st, example # local import ivy.functional.frontends.numpy as np_frontend @@ -939,3 +939,114 @@ def _create_transpile_report( json_object = json.dumps(data, indent=6) with open(file_name, "w") as outfile: outfile.write(json_object) + + +def handle_example( + *, + test_example: bool = False, + test_frontend_example: bool = False, + test_method_example: bool = False, + test_frontend_method_example: bool = False, + **given_kwargs, +): + if test_example: + test_flags = given_kwargs.get("test_flags", {}) + flags = pf.FunctionTestFlags( + ground_truth_backend=test_flags.get("ground_truth_backend", "numpy"), + num_positional_args=test_flags.get("num_positional_args", 0), + instance_method=test_flags.get("instance_method", False), + with_out=test_flags.get("with_out", False), + with_copy=test_flags.get("with_copy", False), + test_gradients=test_flags.get("test_gradients", False), + test_trace=test_flags.get("test_trace", False), + transpile=test_flags.get("transpile", False), + as_variable=test_flags.get("as_variable", [False]), + native_arrays=test_flags.get("native_arrays", [False]), + container=test_flags.get("container", [False]), + precision_mode=test_flags.get("precision_mode", False), + test_cython_wrapper=test_flags.get("test_cython_wrapper", False), + ) + + given_kwargs["test_flags"] = flags + + elif test_frontend_example: + test_flags = given_kwargs.get("test_flags", {}) + flags = pf.FrontendFunctionTestFlags( + num_positional_args=test_flags.get("num_positional_args", 0), + with_out=test_flags.get("with_out", False), + with_copy=test_flags.get("with_copy", False), + inplace=test_flags.get("inplace", False), + as_variable=test_flags.get("as_variable", [False]), + native_arrays=test_flags.get("native_arrays", [False]), + test_trace=test_flags.get("test_trace", False), + generate_frontend_arrays=test_flags.get("generate_frontend_arrays", False), + transpile=test_flags.get("transpile", False), + precision_mode=test_flags.get("precision_mode", False), + ) + + given_kwargs["test_flags"] = flags + + elif test_method_example: + method_flags = given_kwargs.get("method_flags", {}) + init_flags = given_kwargs.get("init_flags", {}) + flags_1 = pf.MethodTestFlags( + num_positional_args=method_flags.get("num_positional_args", 0), + as_variable=method_flags.get("as_variable", [False]), + native_arrays=method_flags.get("native_arrays", [False]), + container_flags=method_flags.get("container", [False]), + precision_mode=method_flags.get("precision_mode", False), + ) + + flags_2 = pf.InitMethodTestFlags( + num_positional_args=init_flags.get("num_positional_args", 0), + as_variable=init_flags.get("as_variable", [False]), + native_arrays=init_flags.get("native_arrays", [False]), + precision_mode=init_flags.get("precision_mode", False), + ) + + given_kwargs["method_flags"] = flags_1 + given_kwargs["init_flags"] = flags_2 + + elif test_frontend_method_example: + method_flags = given_kwargs.get("method_flags", {}) + init_flags = given_kwargs.get("init_flags", {}) + flags_1 = pf.FrontendMethodTestFlags( + num_positional_args=method_flags.get("num_positional_args", 0), + as_variable=method_flags.get("as_variable", [False]), + native_arrays=method_flags.get("native_arrays", [False]), + precision_mode=method_flags.get("precision_mode", False), + inplace=method_flags.get("inplace", False), + test_trace=method_flags.get("test_trace", False), + generate_frontend_arrays=method_flags.get( + "generate_frontend_arrays", False + ), + ) + + flags_2 = pf.FrontendInitTestFlags( + num_positional_args=init_flags.get("num_positional_args", 0), + as_variable=init_flags.get("as_variable", [False]), + native_arrays=init_flags.get("native_arrays", [False]), + ) + + given_kwargs["method_flags"] = flags_1 + given_kwargs["init_flags"] = flags_2 + + def test_wrapper(test_fn): + + hypothesis_test_fn = example(**given_kwargs)(test_fn) + + @functools.wraps(hypothesis_test_fn) + def wrapped_test(*args, **kwargs): + try: + hypothesis_test_fn(*args, **kwargs) + except Exception as e: + # A string matching is used instead of actual exception due to + # exception object in with_backend is different from global Ivy + if e.__class__.__qualname__ == "IvyNotImplementedException": + pytest.skip("Function not implemented in backend.") + else: + raise e + + return wrapped_test + + return test_wrapper diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index f213c90474c80..ebeecffba73dc 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -6,7 +6,7 @@ from types import SimpleNamespace import pytest -from hypothesis import given, assume, example, strategies as st +from hypothesis import given, assume, strategies as st import numpy as np from collections.abc import Sequence @@ -18,7 +18,7 @@ from ivy_tests.test_ivy.helpers import ( handle_test, BackendHandler, - test_parameter_flags as pf, + handle_example, ) from ivy_tests.test_ivy.helpers.assertions import assert_all_close from ivy_tests.test_ivy.test_functional.test_core.test_elementwise import pow_helper @@ -1647,7 +1647,11 @@ def test_set_inplace_mode(mode): container_flags=st.just([False]), test_with_copy=st.just(True), ) -@example( +@handle_example( + test_example=True, + test_flags={ + "num_positional_args": 3, + }, dtypes_x_query_val=( ["int32", "int32"], np.ones((1, 3, 3, 3)), @@ -1656,21 +1660,6 @@ def test_set_inplace_mode(mode): ), copy=False, fn_name="set_item", - test_flags=pf.FunctionTestFlags( - ground_truth_backend="numpy", - num_positional_args=3, - instance_method=False, - with_out=False, - with_copy=False, - test_gradients=False, - test_trace=False, - transpile=False, - as_variable=[False], - native_arrays=[False], - container=[False], - precision_mode=False, - test_cython_wrapper=False, - ), ) def test_set_item( dtypes_x_query_val, From c32c879688cb2f372aaa98776257fa1858d88227 Mon Sep 17 00:00:00 2001 From: Ogban Ugot Date: Wed, 14 Feb 2024 09:20:40 +0100 Subject: [PATCH 805/978] fix: Frontend Failing Test: torch - tensor.torch.Tensor.unique (#28283) --- ivy/functional/backends/torch/set.py | 2 +- ivy/functional/frontends/torch/tensor.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/torch/set.py b/ivy/functional/backends/torch/set.py index 03e0a6077bb7c..a7eee8289918f 100644 --- a/ivy/functional/backends/torch/set.py +++ b/ivy/functional/backends/torch/set.py @@ -66,7 +66,7 @@ def unique_all( [i[0] for i in sorted(enumerate(values_), key=lambda x: tuple(x[1]))] ) ivy_torch = ivy.current_backend() - values = ivy_torch.gather(values, sort_idx, axis=axis) + values = values.index_select(dim=axis, index=sort_idx) counts = ivy_torch.gather(counts, sort_idx) indices = ivy_torch.gather(indices, sort_idx) inv_sort_idx = ivy_torch.invert_permutation(sort_idx) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 91c1f5b86db55..faef7db5d4e1c 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -2242,6 +2242,7 @@ def ne_(self, other): "float16", "complex128", "complex64", + "bool", ) }, "torch", From c690bb8180744175ae587057ea760ad746bb2222 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 14 Feb 2024 10:54:51 +0000 Subject: [PATCH 806/978] fix: fix test_torch_log_softmax by passing dtype as is instead of converting to ivy otherwise get error like got (int, dtype=FloatDtype), but expected one of: (int dim, torch.dtype dtype) --- .../test_functional/test_non_linear_activation_functions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py index 953e6865a11c7..f40c7e7ff2432 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py @@ -660,7 +660,7 @@ def test_torch_log_softmax( input=x[0], dim=axis, _stacklevel=3, - dtype=ivy.as_ivy_dtype(dtypes[0]), + dtype=dtypes[0], ) ivy.previous_backend() From 3a8f810d19a78c9f65738e9e29b1c211ff6279e5 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 14 Feb 2024 11:01:22 +0000 Subject: [PATCH 807/978] chore: remove additional set_backend call in test_torch_log_softmax --- .../test_functional/test_non_linear_activation_functions.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py index f40c7e7ff2432..162ef1b2e73b6 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py @@ -649,7 +649,6 @@ def test_torch_log_softmax( backend_fw, ): input_dtype, x, axis = dtype_x_and_axis - ivy.set_backend(backend_fw) helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -662,7 +661,6 @@ def test_torch_log_softmax( _stacklevel=3, dtype=dtypes[0], ) - ivy.previous_backend() # logsigmoid From 6b40c71dfbd3a6ab8ac97f9faf581ab4cafe9134 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 14 Feb 2024 11:09:22 +0000 Subject: [PATCH 808/978] feat: add log_softmax torch frontend Tenor method and the test --- ivy/functional/frontends/torch/tensor.py | 4 ++ .../test_frontends/test_torch/test_tensor.py | 45 +++++++++++++++++++ 2 files changed, 49 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index faef7db5d4e1c..c7cf6500500dd 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1161,6 +1161,10 @@ def fmax(self, other): def fmin(self, other): return torch_frontend.fmin(self, other) + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch") + def log_softmax(self, dim=None, _stack_level=3, dtype=None): + return torch_frontend.nn.functional.log_softmax(self, dim=dim, dtype=dtype) + def msort(self): return torch_frontend.msort(self) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 35b33d1996e2a..c75bf6b7e8da9 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -8824,6 +8824,51 @@ def test_torch_log_( ) +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="log_softmax", + dtype_x_and_axis=helpers.dtype_values_axis( + available_dtypes=helpers.get_dtypes("float"), + min_num_dims=1, + max_axes_size=1, + force_int_axis=True, + valid_axis=True, + ), + dtypes=helpers.get_dtypes("float", none=False, full=False), +) +def test_torch_log_softmax( + *, + dtype_x_and_axis, + dtypes, + on_device, + frontend, + backend_fw, + frontend_method_data, + init_flags, + method_flags, +): + input_dtype, x, axis = dtype_x_and_axis + + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "dim": axis, + "dtype": dtypes[0], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # logaddexp @handle_frontend_method( class_tree=CLASS_TREE, From f63086dbed6e8195be5649e8d6baa0823730f958 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 14 Feb 2024 11:51:40 +0000 Subject: [PATCH 809/978] feat: add isfinite as torch frontend Tensor method with the test --- ivy/functional/frontends/torch/tensor.py | 3 ++ .../test_frontends/test_torch/test_tensor.py | 38 +++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index c7cf6500500dd..39a31acbdf5c2 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1165,6 +1165,9 @@ def fmin(self, other): def log_softmax(self, dim=None, _stack_level=3, dtype=None): return torch_frontend.nn.functional.log_softmax(self, dim=dim, dtype=dtype) + def isfinite(self): + return torch_frontend.isfinite(self) + def msort(self): return torch_frontend.msort(self) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index c75bf6b7e8da9..42516a37a047b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -8159,6 +8159,44 @@ def test_torch_is_quantized( ivy.previous_backend() +# isfinite +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="isfinite", + dtype_and_input=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + min_value=-np.inf, + max_value=np.inf, + ), +) +def test_torch_isfinite( + *, + dtype_and_input, + on_device, + frontend, + backend_fw, + frontend_method_data, + init_flags, + method_flags, +): + input_dtype, x = dtype_and_input + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # isinf @handle_frontend_method( class_tree=CLASS_TREE, From de4d23cf4a25be31dc26fb11325447adde9dc47f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 14 Feb 2024 12:02:04 +0000 Subject: [PATCH 810/978] feat: add `__iand__` for torch frontend Tensor method and the test --- ivy/functional/frontends/torch/tensor.py | 4 ++ .../test_frontends/test_torch/test_tensor.py | 41 +++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 39a31acbdf5c2..a8645b3cc36b5 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1402,6 +1402,10 @@ def __invert__(self): def __and__(self, other): return torch_frontend.bitwise_and(self, other) + def __iand__(self, other): + self.ivy_array = self.bitwise_and(other).ivy_array + return self + def __array__(self, dtype=None): if dtype is None: return ivy.to_numpy(self.ivy_array) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 42516a37a047b..d2e44049ba870 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -777,6 +777,47 @@ def test_torch___gt__( raise +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="__iand__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=st.one_of(st.just(("bool",)), helpers.get_dtypes("integer")), + num_arrays=2, + min_value=-1e04, + max_value=1e04, + allow_inf=False, + ), + test_inplace=st.just(True), +) +def test_torch___iand__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "other": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __invert__ @handle_frontend_method( class_tree=CLASS_TREE, From 9365fa45da68fb8f0716fb93fb215acb18956601 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Wed, 14 Feb 2024 13:22:40 +0000 Subject: [PATCH 811/978] feat: add Tensor.new method in torch frontend with the test --- ivy/functional/frontends/torch/tensor.py | 3 ++ .../test_frontends/test_torch/test_tensor.py | 33 +++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index a8645b3cc36b5..f994e203694d7 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -1406,6 +1406,9 @@ def __iand__(self, other): self.ivy_array = self.bitwise_and(other).ivy_array return self + def new(self): + return torch_frontend.tensor([], dtype=self.dtype, device=self.device) + def __array__(self, dtype=None): if dtype is None: return ivy.to_numpy(self.ivy_array) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index d2e44049ba870..7385564716774 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -10280,6 +10280,39 @@ def test_torch_negative( ) +# new +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="new", + dtype_and_x=helpers.dtype_and_values(), +) +def test_torch_new_( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # new_empty (not actually intuitive for testing) @handle_frontend_method( class_tree=CLASS_TREE, From c3980e69128ea41856b5e6a08adf1fb2d619e6c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kacper=20Ko=C5=BCdo=C5=84?= <102428159+Kacper-W-Kozdon@users.noreply.github.com> Date: Wed, 14 Feb 2024 14:31:06 +0100 Subject: [PATCH 812/978] fix: array_indices_axis helper updated to use args to control vals from dtypes_and_values helper (#28168) --- .../hypothesis_helpers/array_helpers.py | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py index a0d522617220d..81434c0b726c2 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py @@ -802,6 +802,12 @@ def array_indices_axis( *, array_dtypes, indices_dtypes=get_dtypes("valid"), + abs_smallest_val=None, + min_value=None, + max_value=None, + large_abs_safety_factor=1.1, + small_abs_safety_factor=1.1, + safety_factor_scale="linear", disable_random_axis=False, axis_zero=False, allow_inf=False, @@ -826,6 +832,37 @@ def array_indices_axis( list of data type to draw the array dtype from. indices_dtypes list of data type to draw the indices dtype from. + abs_smallest_val + sets the absolute smallest value to be generated for float data types, + this has no effect on integer data types. If none, the default data type + absolute smallest value is used. + min_value + minimum value of elements in the array. + max_value + maximum value of elements in the array. + large_abs_safety_factor + A safety factor of 1 means that all values are included without limitation, + + when a "linear" safety factor scaler is used, a safety factor of 2 means + that only 50% of the range is included, a safety factor of 3 means that + only 33% of the range is included etc. + + when a "log" safety factor scaler is used, a data type with maximum + value of 2^32 and a safety factor of 2 transforms the maximum to 2^16. + small_abs_safety_factor + A safety factor of 1 means that all values are included without limitation, + this has no effect on integer data types. + + when a "linear" safety factor scaler is used, a data type with minimum + representable number of 0.0001 and a safety factor of 2 transforms the + minimum to 0.0002, a safety factor of 3 transforms the minimum to 0.0003 etc. + + when a "log" safety factor scaler is used, a data type with minimum + representable number of 0.5 * 2^-16 and a safety factor of 2 transforms the + minimum to 0.5 * 2^-8, a safety factor of 3 transforms the minimum to 0.5 * 2^-4 + safety_factor_scale + The operation to use for the safety factor scaling. Can be "linear" or "log". + Default value = "linear". disable_random_axis axis is randomly generated with hypothesis if False. If True, axis is set to 0 if axis_zero is True, -1 otherwise. @@ -961,6 +998,12 @@ def array_indices_axis( max_num_dims=max_num_dims, min_dim_size=min_dim_size, max_dim_size=max_dim_size, + abs_smallest_val=abs_smallest_val, + min_value=min_value, + max_value=max_value, + large_abs_safety_factor=large_abs_safety_factor, + small_abs_safety_factor=small_abs_safety_factor, + safety_factor_scale=safety_factor_scale, ) ) x_dtype = x_dtype[0] From 0ece06be485baf02f573e9d67faa977cc5eb0b98 Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Wed, 14 Feb 2024 17:11:11 +0000 Subject: [PATCH 813/978] fix: handling of None in torch frontend pad + extended test (#28279) --- .../frontends/torch/nn/functional/vision_functions.py | 1 + .../test_torch/test_nn/test_functional/test_vision_functions.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/nn/functional/vision_functions.py b/ivy/functional/frontends/torch/nn/functional/vision_functions.py index 5fda10efd2900..513d5fd3f57de 100644 --- a/ivy/functional/frontends/torch/nn/functional/vision_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/vision_functions.py @@ -395,6 +395,7 @@ def interpolate( @to_ivy_arrays_and_back def pad(input, pad, mode="constant", value=0): + value = 0 if value is None else value mode_dict = { "constant": "constant", "reflect": "reflect", diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py index 912c3e82599be..58c58e87939ac 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_vision_functions.py @@ -106,7 +106,7 @@ def _pad_helper(draw): ) padding = draw(_pad_generator(shape, mode)) if mode == "constant": - value = draw(helpers.ints(min_value=0, max_value=4)) + value = draw(helpers.ints(min_value=0, max_value=4) | st.none()) else: value = 0.0 return dtype, input[0], padding, value, mode From d3258a90c88f2a491c0df3a4fd3720e9d9aeda7b Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Thu, 15 Feb 2024 07:46:21 +0000 Subject: [PATCH 814/978] fix(keras.Model): Rewrote the _get_input_shapes method to correctly handle non-tensor like arguments and also avoid using tf.nest.flatten to avoid unpacking tuples in the arguments --- ivy/functional/backends/tensorflow/module.py | 21 ++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/ivy/functional/backends/tensorflow/module.py b/ivy/functional/backends/tensorflow/module.py index 9c7d670aa977d..a6487f0377604 100644 --- a/ivy/functional/backends/tensorflow/module.py +++ b/ivy/functional/backends/tensorflow/module.py @@ -175,16 +175,17 @@ def _get_first_array(*args, **kwargs): @staticmethod @tf.autograph.experimental.do_not_convert - def _get_input_shapes(*args, **kwargs): - flattened_args = tf.nest.flatten((args, kwargs)) - arr_candidates = tf.nest.map_structure( - lambda x: x if isinstance(x, (tf.Tensor, tf.Variable)) else False, - flattened_args, - ) + def _get_input_shapes(*args): input_shapes = [] - for arr_candidate in arr_candidates: - if arr_candidate is not False: - input_shapes.append(arr_candidate.shape) + for x in args: + if isinstance(x, (tf.Tensor, tf.Variable)): + input_shapes.append(x.shape) + else: + try: + x = tf.convert_to_tensor(x) + input_shapes.append(x.shape) + except Exception: + input_shapes.append(None) return input_shapes @staticmethod @@ -635,7 +636,7 @@ def _call(self, *args, v=None, buffers=None, **kwargs): if os.environ.get("USE_KERAS_BUILD", "False").lower() == "false": self.inputs = tf.nest.flatten(args) - input_shapes = self._get_input_shapes(*args, **kwargs) + input_shapes = self._get_input_shapes(*args) if len(input_shapes) == 0: input_shapes = tf.TensorShape(None) elif len(input_shapes) == 1: From e01811f4f1482429515f2bf04fac87e3ad3d373e Mon Sep 17 00:00:00 2001 From: Yusha Arif <101613943+YushaArif99@users.noreply.github.com> Date: Thu, 15 Feb 2024 08:13:36 +0000 Subject: [PATCH 815/978] (refactor)(torch_frontend): refactored the implementation of the frontend `torch.Tensor.to` method to avoid an isinstance check which causes issues during the s2s translation. --- ivy/functional/frontends/torch/tensor.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index f994e203694d7..95d737be609a3 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -576,7 +576,9 @@ def to(self, *args, **kwargs): ) return cast_tensor if ( - isinstance(args[0], (ivy.Dtype, ivy.NativeDtype)) + isinstance(args[0], ivy.NativeDtype) + or isinstance(args[0], ivy.Dtype) + and hasattr(args[0], "as_native_dtype") or args[0] in ivy._all_ivy_dtypes_str ): if self.dtype == ivy.as_ivy_dtype(args[0]): From d80c86b34afc670beac6c0e65977b3d681588209 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Thu, 15 Feb 2024 12:58:59 -0800 Subject: [PATCH 816/978] fix: Ivy Failing Test: paddle - linalg.outer (#28285) fixed the dtype support at paddle backend --- ivy/functional/backends/paddle/linear_algebra.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/ivy/functional/backends/paddle/linear_algebra.py b/ivy/functional/backends/paddle/linear_algebra.py index cac523656a3b0..cdad53a1fbf81 100644 --- a/ivy/functional/backends/paddle/linear_algebra.py +++ b/ivy/functional/backends/paddle/linear_algebra.py @@ -14,6 +14,7 @@ with_unsupported_device_and_dtypes, with_unsupported_dtypes, with_supported_dtypes, + with_supported_device_and_dtypes, ) from .elementwise import _elementwise_helper @@ -398,6 +399,14 @@ def matrix_transpose( return paddle.transpose(x, perm=perm) +@with_supported_device_and_dtypes( + { + "2.6.0 and below": { + "cpu": ("int32", "int64", "float64", "complex128" "float32", "complex64") + } + }, + backend_version, +) def outer( x1: paddle.Tensor, x2: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: From 2e07d8ac37e799256a3000397f5d43c7c13f35ef Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Fri, 16 Feb 2024 10:40:50 +0000 Subject: [PATCH 817/978] fix: torch frontend linspace working with `dtype=None` + array inputs. and extended test (#28296) --- ivy/functional/frontends/torch/creation_ops.py | 4 ++-- .../test_frontends/test_torch/test_creation_ops.py | 11 ++++++++++- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/creation_ops.py b/ivy/functional/frontends/torch/creation_ops.py index 343f0974ae986..920756f7e814b 100644 --- a/ivy/functional/frontends/torch/creation_ops.py +++ b/ivy/functional/frontends/torch/creation_ops.py @@ -226,8 +226,8 @@ def linspace( layout=None, requires_grad=False, ): - ret = ivy.linspace(start, end, num=steps, dtype=dtype, device=device, out=out) - return ret + dtype = torch_frontend.get_default_dtype() if dtype is None else dtype + return ivy.linspace(start, end, num=steps, dtype=dtype, device=device, out=out) @to_ivy_arrays_and_back diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_creation_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_creation_ops.py index 859ddfa5df3cf..136390818d19e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_creation_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_creation_ops.py @@ -7,6 +7,7 @@ import ivy_tests.test_ivy.helpers as helpers import ivy_tests.test_ivy.helpers.globals as test_globals from ivy_tests.test_ivy.helpers import handle_frontend_test, BackendHandler +from ivy_tests.test_ivy.helpers.testing_helpers import handle_example # --- Helpers --- # @@ -611,6 +612,14 @@ def test_torch_heaviside( num=st.integers(min_value=1, max_value=10), dtype=helpers.get_dtypes("float", full=False), ) +@handle_example( + test_frontend_example=True, + start=np.array(0), + stop=1, + num=2, + dtype=[None], + fn_tree="ivy.functional.frontends.torch.linspace", +) def test_torch_linspace( *, start, @@ -624,7 +633,7 @@ def test_torch_linspace( backend_fw, ): helpers.test_frontend_function( - input_dtypes=[], + input_dtypes=[] if isinstance(start, float) else ["int64"], backend_to_test=backend_fw, frontend=frontend, test_flags=test_flags, From a723025bf552452d960cbd37423c0aa3a9ca9c48 Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Fri, 16 Feb 2024 10:45:33 +0000 Subject: [PATCH 818/978] fix: frontend searchsorted should only fail when `side` is explicitly set to `'left'` + generalised test (#28298) --- .../frontends/torch/miscellaneous_ops.py | 17 +++++++++-------- .../test_torch/test_miscellaneous_ops.py | 16 +++++++++++----- 2 files changed, 20 insertions(+), 13 deletions(-) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 1044114e25727..98074a690de62 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -491,17 +491,18 @@ def searchsorted( *, out_int32=False, right=False, - side="left", + side=None, out=None, sorter=None, ): - if right and side == "left": - raise ivy.exceptions.IvyError( - "side and right can't be set to opposites, got side of left" - " while right was True" - ) - if right: - side = "right" + if side == "left": + if right: + raise ivy.exceptions.IvyError( + "side and right can't be set to opposites, got side of left" + " while right was True" + ) + elif side is None: + side = "right" if right else "left" ret = ivy.searchsorted(sorted_sequence, values, side=side, out=out, sorter=sorter) if out_int32: ret = ivy.astype(ret, "int32") diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 8bac08b6f069b..96573d30622fb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -1579,10 +1579,10 @@ def test_torch_rot90( max_num_dims=1, num_arrays=2, ), - side=st.sampled_from(["left", "right"]), + side=st.sampled_from(["left", "right", None]), out_int32=st.booleans(), - right=st.just(False), - test_with_out=st.just(False), + right=st.sampled_from([True, False, None]), + test_with_out=st.booleans(), ) def test_torch_searchsorted( dtype_x_v, @@ -1595,6 +1595,13 @@ def test_torch_searchsorted( backend_fw, on_device, ): + potential_kwargs = {} + if side == "left" and right: + right = None # this combo will cause an exception + if side is not None: + potential_kwargs["side"] = side + if right is not None: + potential_kwargs["right"] = right input_dtypes, xs = dtype_x_v use_sorter = st.booleans() if use_sorter: @@ -1612,10 +1619,9 @@ def test_torch_searchsorted( on_device=on_device, sorted_sequence=xs[0], values=xs[1], - side=side, out_int32=out_int32, - right=right, sorter=sorter, + **potential_kwargs, ) From 4409f8a7f46e05e28860e56df19c24aed4bbf61c Mon Sep 17 00:00:00 2001 From: Nripesh Niketan <86844847+NripeshN@users.noreply.github.com> Date: Fri, 16 Feb 2024 16:08:19 +0400 Subject: [PATCH 819/978] docs : Updated the contributor rewards doc (#28246) --- docs/overview/contributing/contributor_rewards.rst | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/docs/overview/contributing/contributor_rewards.rst b/docs/overview/contributing/contributor_rewards.rst index f2cdd3c3225ff..07dd0f6b6db4b 100644 --- a/docs/overview/contributing/contributor_rewards.rst +++ b/docs/overview/contributing/contributor_rewards.rst @@ -6,14 +6,13 @@ We award a range of badges, each designed to formally recognize the specific ach Badges ~~~~~~~ -**Debugging Dynamos** - These badges are awarded to contributors who demonstrate exceptional skill in identifying and reporting issues. -It recognizes the crucial role of pinpointing problems which is fundamental in maintaining the integrity and performance of our codebase. +**Debugging Dynamos** - These badges are earned by creating useful issues. If you find a problem that isn't listed as an open task, report it by creating a new issue. Make sure to describe the problem thoroughly. If your issue is confirmed as useful and marked as a "Useful Issue" by our team, you'll receive the badge as recognition for your valuable contribution to improving our codebase. -**Merging Master** - These badges are formal recognitions for contributors whose pull requests consistently meet our high standards of quality and are successfully merged into the main codebase. +**Merging Master** - These badges are formal recognitions for contributors whose pull requests consistently meet our standards of quality and are successfully merged into the main codebase. -**Merging Wizard** - These exclusive badges are awarded to contributors who successfully get *priority* pull requests merged. This recognition is for handling complex, high-priority tasks that have a substantial impact on the project's progress and success. Priority pull requests are those associated with `"Priority Open" issues `_ found within each framework. +**Merging Wizard** - These exclusive badges are awarded to contributors who successfully get *priority* pull requests merged. This recognition is for handling complex, high-priority tasks that have a substantial impact on the project's progress and success. Priority pull requests are those that close `"Priority Open" issues `_ found within each framework. -**Ivy Inspectors** - These badges are given in acknowledgment of the essential role played by those who review our pull requests. It honours the commitment to quality and diligence in ensuring that each code merge aligns with our high standards. +**Ivy Inspectors** - These badges are given in acknowledgment of the essential role played by those who review our pull requests. It honours the commitment to quality and diligence in ensuring that each code merge aligns with our standards. Each badge comes in four distinct tiers – Initial, Bronze, Silver, and Gold, mirroring your growing expertise and commitment in these areas. From 7cc544f8669b96f1af9f87ab5da41f40fa339d42 Mon Sep 17 00:00:00 2001 From: Ogban Ugot Date: Fri, 16 Feb 2024 14:08:16 +0100 Subject: [PATCH 820/978] fix: Frontend Failing Test: torch - tensor.torch.Tensor.new_zeros (#28304) --- .../test_frontends/test_torch/test_tensor.py | 23 +++++++++---------- 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 7385564716774..a8d1d4904ced0 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -352,11 +352,12 @@ def _repeat_helper(draw): @st.composite -def _requires_grad(draw): - dtype = draw(_dtypes())[0] +def _requires_grad_and_dtypes(draw): + dtypes = draw(_dtypes()) + dtype = dtypes[0] if ivy.is_int_dtype(dtype) or ivy.is_uint_dtype(dtype): - return draw(st.just(False)) - return draw(st.booleans()) + return draw(st.just(False)), dtypes + return draw(st.booleans()), dtypes @st.composite @@ -10404,14 +10405,12 @@ def test_torch_new_full( min_dim_size=1, max_dim_size=10, ), - dtypes=_dtypes(), - requires_grad=_requires_grad(), + requires_grad_and_dtypes=_requires_grad_and_dtypes(), ) def test_torch_new_ones( dtype_and_x, size, - dtypes, - requires_grad, + requires_grad_and_dtypes, on_device, frontend_method_data, init_flags, @@ -10420,6 +10419,7 @@ def test_torch_new_ones( backend_fw, ): input_dtype, x = dtype_and_x + requires_grad, dtypes = requires_grad_and_dtypes helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -10493,14 +10493,12 @@ def test_torch_new_tensor( min_dim_size=1, max_dim_size=10, ), - dtypes=_dtypes(), - requires_grad=_requires_grad(), + requires_grad_and_dtypes=_requires_grad_and_dtypes(), ) def test_torch_new_zeros( dtype_and_x, size, - dtypes, - requires_grad, + requires_grad_and_dtypes, on_device, frontend_method_data, init_flags, @@ -10509,6 +10507,7 @@ def test_torch_new_zeros( backend_fw, ): input_dtype, x = dtype_and_x + requires_grad, dtypes = requires_grad_and_dtypes helpers.test_frontend_method( init_input_dtypes=input_dtype, backend_to_test=backend_fw, From 7ee4aae2ff392cd482ef18b254a55d1d03bfcf87 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Fri, 16 Feb 2024 14:56:55 +0000 Subject: [PATCH 821/978] fix: convert builtin types to tf.TensorShape in tf backend reshape (#28305) --- ivy/functional/backends/tensorflow/manipulation.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/backends/tensorflow/manipulation.py b/ivy/functional/backends/tensorflow/manipulation.py index 5e35641ab3c26..fc62760080b08 100644 --- a/ivy/functional/backends/tensorflow/manipulation.py +++ b/ivy/functional/backends/tensorflow/manipulation.py @@ -124,6 +124,8 @@ def reshape( ] if order == "F": return _reshape_fortran_tf(x, shape) + if isinstance(shape, (int, list, tuple)): + shape = tf.TensorShape(shape) return tf.reshape(x, shape) From 6004903ff471706655c891a30ec042f87aefc383 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 17 Feb 2024 15:57:24 +0000 Subject: [PATCH 822/978] refactor: move helper dims_and_offsets to general hypothesis helpers and remove duplications making additional functionality easier to add --- .../helpers/hypothesis_helpers/general_helpers.py | 14 ++++++++++++++ .../test_frontends/test_paddle/test_linalg.py | 13 +------------ .../test_paddle/test_tensor/test_tensor.py | 14 +------------- .../test_torch/test_miscellaneous_ops.py | 13 +------------ .../test_frontends/test_torch/test_tensor.py | 14 +------------- 5 files changed, 18 insertions(+), 50 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 631cfbd85196d..572800b997bf8 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -685,3 +685,17 @@ def get_factor(n): else shape ) return shape_ + + +@st.composite +def dims_and_offset(draw, shape): + shape_actual = draw(shape) + dim1 = draw(get_axis(shape=shape, force_int=True)) + dim2 = draw(get_axis(shape=shape, force_int=True)) + while dim1 == dim2: + dim2 = draw(get_axis(shape=shape, force_int=True)) + + offset = draw( + st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) + ) + return dim1, dim2, offset diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py index 019bc40ada839..a5aa23037461d 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_linalg.py @@ -171,17 +171,6 @@ def _transpose_helper(draw): return dtype, x, perm -@st.composite -def dims_and_offset(draw, shape): - shape_actual = draw(shape) - dim1 = draw(helpers.get_axis(shape=shape, force_int=True)) - dim2 = draw(helpers.get_axis(shape=shape, force_int=True)) - offset = draw( - st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) - ) - return dim1, dim2, offset - - # Helpers # # ------ # @@ -706,7 +695,7 @@ def test_paddle_eigvalsh( available_dtypes=helpers.get_dtypes("valid"), shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape"), ), - axis_and_offset=dims_and_offset( + axis_and_offset=helpers.dims_and_offset( shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape") ), ) diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index eff1506aae721..fe5e3dda8add5 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -424,18 +424,6 @@ def _reshape_helper(draw): return dtypes, x, reshape_shape -# diagonal -@st.composite -def dims_and_offset(draw, shape): - shape_actual = draw(shape) - dim1 = draw(helpers.get_axis(shape=shape, force_int=True)) - dim2 = draw(helpers.get_axis(shape=shape, force_int=True)) - offset = draw( - st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) - ) - return dim1, dim2, offset - - # expand helper function @st.composite def dtypes_x_shape(draw): @@ -2755,7 +2743,7 @@ def test_paddle_device( available_dtypes=helpers.get_dtypes("valid"), shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape"), ), - dims_and_offset=dims_and_offset( + dims_and_offset=helpers.dims_and_offset( shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape") ), ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py index 96573d30622fb..90fb791284ad3 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py @@ -191,17 +191,6 @@ def complex_strategy( return tuple(shape) -@st.composite -def dims_and_offset(draw, shape): - shape_actual = draw(shape) - dim1 = draw(helpers.get_axis(shape=shape, force_int=True)) - dim2 = draw(helpers.get_axis(shape=shape, force_int=True)) - offset = draw( - st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) - ) - return dim1, dim2, offset - - # cross @st.composite def dtype_value1_value2_axis( @@ -900,7 +889,7 @@ def test_torch_diagflat( available_dtypes=helpers.get_dtypes("float"), shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape"), ), - dims_and_offset=dims_and_offset( + dims_and_offset=helpers.dims_and_offset( shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape") ), ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index a8d1d4904ced0..26e8c5ece6238 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -417,18 +417,6 @@ def _unfold_args(draw): return values_dtype, values, axis, size, step -# diagonal -@st.composite -def dims_and_offset(draw, shape): - shape_actual = draw(shape) - dim1 = draw(helpers.get_axis(shape=shape, force_int=True)) - dim2 = draw(helpers.get_axis(shape=shape, force_int=True)) - offset = draw( - st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) - ) - return dim1, dim2, offset - - # --- Main --- # # ------------ # @@ -5898,7 +5886,7 @@ def test_torch_diag( available_dtypes=helpers.get_dtypes("valid"), shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape"), ), - dims_and_offset=dims_and_offset( + dims_and_offset=helpers.dims_and_offset( shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape") ), ) From 8c8fd6d778a323208a0b4297d8dc108734af95ae Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 17 Feb 2024 16:48:45 +0000 Subject: [PATCH 823/978] refactor: remove copy of dims_and_offset helper and make the call from helpers in test_jax_diagonal --- .../test_jax/test_numpy/test_indexing.py | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py index 4d76bfcc9a139..5065fbd54c3a5 100644 --- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py +++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_indexing.py @@ -53,18 +53,6 @@ def _get_dtype_square_x(draw): return dtype_x -# diagonal -@st.composite -def dims_and_offset(draw, shape): - shape_actual = draw(shape) - dim1 = draw(helpers.get_axis(shape=shape, force_int=True)) - dim2 = draw(helpers.get_axis(shape=shape, force_int=True)) - offset = draw( - st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) - ) - return dim1, dim2, offset - - # unravel_index @st.composite def max_value_as_shape_prod(draw): @@ -217,7 +205,7 @@ def test_jax_diag_indices_from( available_dtypes=helpers.get_dtypes("float"), shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape"), ), - dims_and_offset=dims_and_offset( + dims_and_offset=helpers.dims_and_offset( shape=st.shared(helpers.get_shape(min_num_dims=2), key="shape") ), ) From 5f50540f845aac0f9743964d875de660ad3ea57f Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sat, 17 Feb 2024 16:56:14 +0000 Subject: [PATCH 824/978] feat: implement `diag_embed` for torch frontend and the test the implementation might be pushed to backends to simplify frontned. the test is minimal and needs to test for dims and offsets which is doable locally but can cause random healthcheck failure. looking to fix and push. --- .../frontends/torch/miscellaneous_ops.py | 49 +++++++++++++++++++ .../test_frontends/test_torch/test_linalg.py | 28 +++++++++++ 2 files changed, 77 insertions(+) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 98074a690de62..61624d2398762 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -211,6 +211,55 @@ def diag(input, diagonal=0, *, out=None): return ivy.diag(input, k=diagonal) +@to_ivy_arrays_and_back +def diag_embed( + input, + offset=0, + dim1=-2, + dim2=-1, +): + def _handle_dim(rank, idx): + if idx >= 0 and idx < rank: + return idx + if idx < 0: + idx = idx + rank + if idx < 0 or idx >= rank: + raise IndexError + return idx + + input_type = ivy.dtype(input) + rank = input.ndim + 1 + dim1 = _handle_dim(rank, dim1) + dim2 = _handle_dim(rank, dim2) + if dim1 > dim2: + dim1, dim2 = dim2, dim1 + offset = -offset + last_dim = list(input.shape)[-1] + if offset != 0: + # add padding to match the new size + t_shape = list(input.shape) + t_shape[-1] = abs(offset) + z = ivy.zeros(t_shape, dtype=input.dtype, device=input.device) + pair = (z, input) if offset > 0 else (input, z) + input = ivy.concat(pair, axis=-1) + last_dim += abs(offset) + input = input.expand_dims(axis=dim1).moveaxis(-1, dim2) + # generate ranges shifting indices based on offset + a_range = ivy.arange(last_dim, device=input.device, dtype=ivy.int64) + b_range = ivy.arange( + offset, last_dim + offset, device=input.device, dtype=ivy.int64 + ) + # broadcast + cond = a_range == b_range.expand_dims(axis=-1) + cond_shape = [last_dim if i in (dim1, dim2) else 1 for i in range(len(input.shape))] + cond = cond.reshape(cond_shape) + if input.dtype == ivy.bool: + ret = cond.logical_and(input) + else: + ret = ivy.where(cond, input, 0) + return ret.astype(input_type) + + @with_supported_dtypes( {"2.2 and below": ("float32", "float64", "int32", "int64")}, "torch" ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index cb1f13a438072..5c91c765d6a35 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -424,6 +424,34 @@ def test_torch_det( ) +@handle_frontend_test( + fn_tree="torch.diag_embed", + dtype_and_values=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + shape=st.shared(helpers.get_shape(min_num_dims=1, max_num_dims=2), key="shape"), + ), +) +def test_torch_diag_embed( + *, + dtype_and_values, + test_flags, + on_device, + fn_tree, + frontend, + backend_fw, +): + input_dtype, value = dtype_and_values + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + test_flags=test_flags, + frontend=frontend, + fn_tree=fn_tree, + on_device=on_device, + input=value[0], + ) + + # eig # TODO: Test for all valid dtypes once ivy.eig supports complex data types @handle_frontend_test( From d54867882cf90b21298c638f3dcdce1f3e00db8b Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 18 Feb 2024 11:04:29 +0000 Subject: [PATCH 825/978] test: make test_torch_diag_embed more comprehensive by generating dims and offsets --- .../test_ivy/test_frontends/test_torch/test_linalg.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 5c91c765d6a35..d3f67357a94cc 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -430,10 +430,14 @@ def test_torch_det( available_dtypes=helpers.get_dtypes("float"), shape=st.shared(helpers.get_shape(min_num_dims=1, max_num_dims=2), key="shape"), ), + dims_and_offsets=helpers.dims_and_offset( + shape=st.shared(helpers.get_shape(min_num_dims=1, max_num_dims=2), key="shape"), + ), ) def test_torch_diag_embed( *, dtype_and_values, + dims_and_offsets, test_flags, on_device, fn_tree, @@ -441,6 +445,7 @@ def test_torch_diag_embed( backend_fw, ): input_dtype, value = dtype_and_values + dim1, dim2, offset = dims_and_offsets helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -449,6 +454,9 @@ def test_torch_diag_embed( fn_tree=fn_tree, on_device=on_device, input=value[0], + offset=offset, + dim1=dim1, + dim2=dim2, ) From 87f546f22eee74f29a2da3bb60b972a8b296a6e5 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 18 Feb 2024 11:10:29 +0000 Subject: [PATCH 826/978] test: make additional logic in dims_and_offset helper conditional and turn it off by default as it was previously when used in other tests to avoid needless looping --- .../helpers/hypothesis_helpers/general_helpers.py | 8 ++++---- .../test_ivy/test_frontends/test_torch/test_linalg.py | 1 + 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py index 572800b997bf8..a6f86024384b2 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/general_helpers.py @@ -688,13 +688,13 @@ def get_factor(n): @st.composite -def dims_and_offset(draw, shape): +def dims_and_offset(draw, shape, ensure_dim_unique=False): shape_actual = draw(shape) dim1 = draw(get_axis(shape=shape, force_int=True)) dim2 = draw(get_axis(shape=shape, force_int=True)) - while dim1 == dim2: - dim2 = draw(get_axis(shape=shape, force_int=True)) - + if ensure_dim_unique: + while dim1 == dim2: + dim2 = draw(get_axis(shape=shape, force_int=True)) offset = draw( st.integers(min_value=-shape_actual[dim1], max_value=shape_actual[dim1]) ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index d3f67357a94cc..bad6d36ba6920 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -432,6 +432,7 @@ def test_torch_det( ), dims_and_offsets=helpers.dims_and_offset( shape=st.shared(helpers.get_shape(min_num_dims=1, max_num_dims=2), key="shape"), + ensure_dim_unique=True, ), ) def test_torch_diag_embed( From 4cd84c7dc9c4ab53ab773c7c07619dbf553e4c8c Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Sun, 18 Feb 2024 22:04:46 +0530 Subject: [PATCH 827/978] feat: Updated `ruff` pre-commit version (#28315) --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index a20dff79ae6fc..75efc76c1548d 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: - id: check-toml - id: end-of-file-fixer - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.2.1 + rev: v0.2.2 hooks: # Run the linter. - id: ruff From 9fbdbcc13610b366b1c43dada7b2f614fdf1e082 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 18 Feb 2024 19:21:22 +0000 Subject: [PATCH 828/978] refactor: move lu_factor to ivy experimental as all its backend setups are in experimental modules all backend implementations are set up in experimental submods although they currently raise not implemented error and need implementations. --- .../ivy/experimental/linear_algebra.py | 35 +++++++++++++++++++ ivy/functional/ivy/linear_algebra.py | 35 ------------------- 2 files changed, 35 insertions(+), 35 deletions(-) diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index f98ec8a896e14..9bcf56eb56af7 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -460,6 +460,41 @@ def adjoint( return current_backend(x).adjoint(x, out=out) +@handle_exceptions +@handle_backend_invalid +@handle_nestable +@handle_array_like_without_promotion +@handle_out_argument +@to_native_arrays_and_back +@handle_device +def lu_factor( + A: Union[ivy.Array, ivy.NativeArray], + /, + *, + pivot: bool = True, + out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, +) -> Tuple[Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray]]: + """ + Parameters + ---------- + A + tensor of shape (*, m, n) where * is zero or more batch dimensions. + + pivot + Whether to compute the LU decomposition with partial pivoting, or the regular LU + decomposition. pivot = False not supported on CPU. Default: True. + + out + tuple of two tensors to write the output to. Ignored if None. Default: None. + + Returns + ------- + ret + A named tuple (LU, pivots). + """ + return current_backend(A).lu_factor(A, pivot=pivot, out=out) + + @handle_exceptions @handle_backend_invalid @handle_nestable diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index 95c2ae8ef3890..b0f7b47bc4691 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -3081,41 +3081,6 @@ def vector_to_skew_symmetric_matrix( return current_backend(vector).vector_to_skew_symmetric_matrix(vector, out=out) -@handle_exceptions -@handle_backend_invalid -@handle_nestable -@handle_array_like_without_promotion -@handle_out_argument -@to_native_arrays_and_back -@handle_device -def lu_factor( - A: Union[ivy.Array, ivy.NativeArray], - /, - *, - pivot: bool = True, - out: Optional[Union[ivy.Array, ivy.NativeArray]] = None, -) -> Tuple[Union[ivy.Array, ivy.NativeArray], Union[ivy.Array, ivy.NativeArray]]: - """ - Parameters - ---------- - A - tensor of shape (*, m, n) where * is zero or more batch dimensions. - - pivot - Whether to compute the LU decomposition with partial pivoting, or the regular LU - decomposition. pivot = False not supported on CPU. Default: True. - - out - tuple of two tensors to write the output to. Ignored if None. Default: None. - - Returns - ------- - ret - A named tuple (LU, pivots). - """ - return current_backend(A).lu_factor(A, pivot=pivot, out=out) - - @handle_exceptions @handle_backend_invalid @handle_nestable From 3d3ba73211cf543550a21c494a3890c2719f4a12 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 18 Feb 2024 19:21:45 +0000 Subject: [PATCH 829/978] test: add some assumptions for dim values in test_torch_diag to ensure both dims are not the same --- .../test_ivy/test_frontends/test_torch/test_linalg.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index bad6d36ba6920..89ed457355945 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -2,7 +2,7 @@ import math import sys import numpy as np -from hypothesis import strategies as st, assume +from hypothesis import strategies as st, assume, settings, HealthCheck # local import ivy @@ -435,6 +435,7 @@ def test_torch_det( ensure_dim_unique=True, ), ) +@settings(suppress_health_check=list(HealthCheck)) def test_torch_diag_embed( *, dtype_and_values, @@ -447,6 +448,11 @@ def test_torch_diag_embed( ): input_dtype, value = dtype_and_values dim1, dim2, offset = dims_and_offsets + num_of_dims = len(np.shape(value[0])) + if dim1 < 0: + assume(dim1 + num_of_dims != dim2) + if dim2 < 0: + assume(dim1 != dim2 + num_of_dims) helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, From 170d9a1038bbd660da74a3bf549c683b0bd0452a Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 18 Feb 2024 20:34:44 +0000 Subject: [PATCH 830/978] feat: implemented lu_factor for the backend tf, jax and torch along with the test --- .../jax/experimental/linear_algebra.py | 3 +- .../tensorflow/experimental/linear_algebra.py | 3 +- .../torch/experimental/linear_algebra.py | 3 +- .../test_core/test_linalg.py | 33 +++++++++++++++++++ 4 files changed, 36 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/linear_algebra.py b/ivy/functional/backends/jax/experimental/linear_algebra.py index 0f1841e41f1a6..b1af97b101abb 100644 --- a/ivy/functional/backends/jax/experimental/linear_algebra.py +++ b/ivy/functional/backends/jax/experimental/linear_algebra.py @@ -9,7 +9,6 @@ import ivy from ivy.functional.ivy.experimental.linear_algebra import _check_valid_dimension_size -from ivy.utils.exceptions import IvyNotImplementedException from . import backend_version @@ -181,7 +180,7 @@ def lu_factor( pivot: Optional[bool] = True, out: Optional[JaxArray] = None, ) -> Tuple[JaxArray]: - raise IvyNotImplementedException() + return jla.lu(x) def dot( diff --git a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py index 4d54923e2e850..7b4276df1903b 100644 --- a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py @@ -7,7 +7,6 @@ from ivy.functional.ivy.experimental.linear_algebra import _check_valid_dimension_size from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes -from ivy.utils.exceptions import IvyNotImplementedException from .. import backend_version @@ -236,7 +235,7 @@ def lu_factor( pivot: Optional[bool] = True, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Tuple[tf.Tensor]: - raise IvyNotImplementedException() + return tf.linalg.lu(x) @with_supported_dtypes( diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index ed3dee38a717d..606045e0472cc 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -6,7 +6,6 @@ import ivy from ivy.func_wrapper import with_unsupported_dtypes -from ivy.utils.exceptions import IvyNotImplementedException from .. import backend_version from ivy.functional.ivy.experimental.linear_algebra import _check_valid_dimension_size @@ -210,7 +209,7 @@ def lu_factor( pivot: Optional[bool] = True, out: Optional[torch.Tensor] = None, ) -> Tuple[torch.Tensor]: - raise IvyNotImplementedException() + return torch.linalg.lu_factor(x, pivot=pivot, out=out) @with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py index 655b8149eb478..c459255a13a53 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py @@ -1380,6 +1380,39 @@ def test_kronecker(*, data, test_flags, backend_fw, fn_name, on_device): ) +# lu_factor +@handle_test( + fn_tree="functional.ivy.experimental.lu_factor", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + min_num_dims=2, + max_num_dims=2, + min_dim_size=2, + max_dim_size=5, + ), + test_gradients=st.just(False), +) +def test_lu_factor(dtype_x, test_flags, backend_fw, fn_name, on_device): + dtype, x = dtype_x + ret = helpers.test_function( + input_dtypes=dtype, + test_flags=test_flags, + on_device=on_device, + backend_to_test=backend_fw, + fn_name=fn_name, + x=x[0], + test_values=False, + return_flat_np_arrays=True, + ) + # check decomp is correct manually by getting the values from test_function above + # this is because the decomposition is not unique and test_values will not work + LU, p = ret.LU, ret.p + L = np.tril(LU, -1) + np.eye(LU.shape[0]) + U = np.triu(LU) + P = np.eye(LU.shape[0])[p] + assert np.allclose(L @ U, P @ x[0]) + + @handle_test( fn_tree="functional.ivy.experimental.make_svd_non_negative", data=_make_svd_nn_data(), From 2fbece33d431338b6335ea6c7cde61e637f49602 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 18 Feb 2024 20:54:44 +0000 Subject: [PATCH 831/978] fix: return a consistent namedtuple return across backends for lu factor function --- ivy/functional/backends/jax/experimental/linear_algebra.py | 7 +++++-- .../backends/tensorflow/experimental/linear_algebra.py | 6 ++++-- .../backends/torch/experimental/linear_algebra.py | 6 ++++-- 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/linear_algebra.py b/ivy/functional/backends/jax/experimental/linear_algebra.py index b1af97b101abb..c1375b16d1445 100644 --- a/ivy/functional/backends/jax/experimental/linear_algebra.py +++ b/ivy/functional/backends/jax/experimental/linear_algebra.py @@ -2,7 +2,7 @@ from typing import Optional, Tuple, Sequence, Union import jax.numpy as jnp import jax.scipy.linalg as jla - +from collections import namedtuple from ivy.func_wrapper import with_supported_dtypes from ivy.functional.backends.jax import JaxArray @@ -180,7 +180,10 @@ def lu_factor( pivot: Optional[bool] = True, out: Optional[JaxArray] = None, ) -> Tuple[JaxArray]: - return jla.lu(x) + ret = jla.lu(x) + ret_tuple = namedtuple("lu_factor", ["LU", "p"]) + ret_1 = ret[1] + return ret_tuple((ret_1 - jnp.eye(*ret_1.shape)) + ret[2], ret[0]) def dot( diff --git a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py index 7b4276df1903b..b2ac0a29a5b4a 100644 --- a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py @@ -1,7 +1,7 @@ from typing import Union, Optional, Tuple, List, Sequence import tensorflow as tf from functools import reduce as _reduce - +from collections import namedtuple import ivy from ivy.functional.ivy.experimental.linear_algebra import _check_valid_dimension_size @@ -235,7 +235,9 @@ def lu_factor( pivot: Optional[bool] = True, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Tuple[tf.Tensor]: - return tf.linalg.lu(x) + ret = tf.linalg.lu(x) + ret_tuple = namedtuple("lu_factor", ["LU", "p"]) + return ret_tuple(ret.lu, ret.p) @with_supported_dtypes( diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index 606045e0472cc..7c7db98f604e2 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -1,6 +1,6 @@ # global import math - +from collections import namedtuple import torch from typing import Optional, Tuple, Sequence, Union @@ -209,7 +209,9 @@ def lu_factor( pivot: Optional[bool] = True, out: Optional[torch.Tensor] = None, ) -> Tuple[torch.Tensor]: - return torch.linalg.lu_factor(x, pivot=pivot, out=out) + ret = torch.linalg.lu_factor(x, pivot=pivot, out=out) + ret_tuple = namedtuple("lu_factor", ["LU", "p"]) + return ret_tuple(ret.LU, ret.pivots) @with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) From 1084760322346539cedaa1ed9d60c51ebfce3587 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 18 Feb 2024 20:57:11 +0000 Subject: [PATCH 832/978] fix: update typehint to match with returned value of a tuple of two tensors --- ivy/functional/backends/jax/experimental/linear_algebra.py | 2 +- .../backends/tensorflow/experimental/linear_algebra.py | 2 +- ivy/functional/backends/torch/experimental/linear_algebra.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/jax/experimental/linear_algebra.py b/ivy/functional/backends/jax/experimental/linear_algebra.py index c1375b16d1445..ac6fe6354152b 100644 --- a/ivy/functional/backends/jax/experimental/linear_algebra.py +++ b/ivy/functional/backends/jax/experimental/linear_algebra.py @@ -179,7 +179,7 @@ def lu_factor( *, pivot: Optional[bool] = True, out: Optional[JaxArray] = None, -) -> Tuple[JaxArray]: +) -> Tuple[JaxArray, JaxArray]: ret = jla.lu(x) ret_tuple = namedtuple("lu_factor", ["LU", "p"]) ret_1 = ret[1] diff --git a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py index b2ac0a29a5b4a..302202903afe4 100644 --- a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py @@ -234,7 +234,7 @@ def lu_factor( *, pivot: Optional[bool] = True, out: Optional[Union[tf.Tensor, tf.Variable]] = None, -) -> Tuple[tf.Tensor]: +) -> Tuple[tf.Tensor, tf.Tensor]: ret = tf.linalg.lu(x) ret_tuple = namedtuple("lu_factor", ["LU", "p"]) return ret_tuple(ret.lu, ret.p) diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index 7c7db98f604e2..23940e11c6b25 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -208,7 +208,7 @@ def lu_factor( *, pivot: Optional[bool] = True, out: Optional[torch.Tensor] = None, -) -> Tuple[torch.Tensor]: +) -> Tuple[torch.Tensor, torch.Tensor]: ret = torch.linalg.lu_factor(x, pivot=pivot, out=out) ret_tuple = namedtuple("lu_factor", ["LU", "p"]) return ret_tuple(ret.LU, ret.pivots) From b967bc88e7a15c270f8587a4ec8a5190bbc5e45a Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Sun, 18 Feb 2024 20:58:52 +0000 Subject: [PATCH 833/978] fix: fix tf version for cond function --- .../backends/tensorflow/experimental/linear_algebra.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py index 302202903afe4..ee759ecf57927 100644 --- a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py @@ -186,7 +186,7 @@ def multi_dot( return dot_out -@with_unsupported_dtypes({"1.25.0 and below": ("float16", "bfloat16")}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("float16", "bfloat16")}, backend_version) def cond( x: Union[tf.Tensor, tf.Variable], /, From 7a4786f8ece384494ffd072fa7c503775883548e Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Mon, 19 Feb 2024 11:14:11 +0530 Subject: [PATCH 834/978] feat: added the tf.__operators__.add and tf.keras.backend.mean frontends for the convnext model transpilation (#28325) --- .../frontends/tensorflow/__init__.py | 1 + .../frontends/tensorflow/__operators__.py | 5 +++ .../frontends/tensorflow/keras/backend.py | 4 ++ .../test_tensorflow/test___operators__.py | 38 +++++++++++++++++ .../test_keras/test_backend.py | 41 +++++++++++++++++++ 5 files changed, 89 insertions(+) create mode 100644 ivy/functional/frontends/tensorflow/__operators__.py create mode 100644 ivy_tests/test_ivy/test_frontends/test_tensorflow/test___operators__.py diff --git a/ivy/functional/frontends/tensorflow/__init__.py b/ivy/functional/frontends/tensorflow/__init__.py index 1a82bd751722d..9c1d731b8a586 100644 --- a/ivy/functional/frontends/tensorflow/__init__.py +++ b/ivy/functional/frontends/tensorflow/__init__.py @@ -103,6 +103,7 @@ def check_tensorflow_casting(x1, x2): from .math import * from . import nest from . import nn +from . import __operators__ from . import quantization from . import random from . import general_functions diff --git a/ivy/functional/frontends/tensorflow/__operators__.py b/ivy/functional/frontends/tensorflow/__operators__.py new file mode 100644 index 0000000000000..7945e8f863764 --- /dev/null +++ b/ivy/functional/frontends/tensorflow/__operators__.py @@ -0,0 +1,5 @@ +import ivy.functional.frontends.tensorflow as tf_frontend + + +def add(x, y, name=None): + return tf_frontend.math.add(x, y, name=name) diff --git a/ivy/functional/frontends/tensorflow/keras/backend.py b/ivy/functional/frontends/tensorflow/keras/backend.py index 0b52cef263d56..d5d9e033e7053 100644 --- a/ivy/functional/frontends/tensorflow/keras/backend.py +++ b/ivy/functional/frontends/tensorflow/keras/backend.py @@ -29,6 +29,10 @@ def dot(x, y): return ivy.dot(x, y) +def mean(x, axis=None, keepdims=False): + return tf_frontend.reduce_mean(x, axis, keepdims) + + @to_ivy_arrays_and_back def rnn( step_function, diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test___operators__.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test___operators__.py new file mode 100644 index 0000000000000..c5728e0085ee3 --- /dev/null +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test___operators__.py @@ -0,0 +1,38 @@ +# global +from hypothesis import strategies as st + +# local +import ivy_tests.test_ivy.helpers as helpers +from ivy_tests.test_ivy.helpers.testing_helpers import handle_frontend_test + + +# add +@handle_frontend_test( + fn_tree="tensorflow.__operators__.add", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + shared_dtype=True, + ), + test_with_out=st.just(False), +) +def test_tensorflow___operators___add( + *, + dtype_and_x, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x=x[0], + y=x[1], + ) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py index 15a4e171fa146..54d0e272d528e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py @@ -70,6 +70,47 @@ def test_tensorflow_keras_backend_bias_add( ) +# mean +@handle_frontend_test( + fn_tree="tensorflow.keras.backend.mean", + dtype_x_axis=helpers.dtype_values_axis( + available_dtypes=helpers.get_dtypes("float"), + force_int_axis=True, + valid_axis=True, + min_num_dims=1, + large_abs_safety_factor=24, + small_abs_safety_factor=24, + safety_factor_scale="log", + ), + keepdims=st.booleans(), + test_with_out=st.just(False), +) +def test_tensorflow_keras_backend_mean( + *, + dtype_x_axis, + keepdims, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + input_dtype, x, axis = dtype_x_axis + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + atol=1e-1, + rtol=1e-1, + on_device=on_device, + x=x[0], + axis=axis, + keepdims=keepdims, + ) + + @handle_frontend_test( fn_tree="tensorflow.keras.backend.rnn", rnn_args=_lstm_helper(), From f52c3568560f9f56223adff725556f024c0ebd75 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 09:22:39 +0000 Subject: [PATCH 835/978] fix: specify unsupported types for lu_factor in torch and tf backends --- .../backends/tensorflow/experimental/linear_algebra.py | 3 +++ ivy/functional/backends/torch/experimental/linear_algebra.py | 1 + 2 files changed, 4 insertions(+) diff --git a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py index ee759ecf57927..c8c7436fd663a 100644 --- a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py @@ -228,6 +228,9 @@ def cond( return k +@with_unsupported_dtypes( + {"2.15.0 and below": ("integer", "float16", "bfloat16")}, backend_version +) def lu_factor( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index 23940e11c6b25..971f6bc16e2d8 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -202,6 +202,7 @@ def cond( cond.support_native_out = False +@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def lu_factor( x: torch.Tensor, /, From 058beccc91e650be56f7fd2509478cbd8ccd6c60 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Mon, 19 Feb 2024 13:46:26 +0400 Subject: [PATCH 836/978] feat: inbuilt reward system --- .vaunt/badges/badge_01-00.png | Bin 133298 -> 0 bytes .vaunt/badges/badge_01-01.png | Bin 157547 -> 0 bytes .vaunt/badges/badge_01-02.png | Bin 160563 -> 0 bytes .vaunt/badges/badge_01-03.png | Bin 120372 -> 0 bytes .vaunt/badges/badge_01-04.png | Bin 153618 -> 0 bytes .vaunt/badges/badge_02-00.png | Bin 136502 -> 0 bytes .vaunt/badges/badge_02-01.png | Bin 167817 -> 0 bytes .vaunt/badges/badge_02-02.png | Bin 147829 -> 0 bytes .vaunt/badges/badge_02-03.png | Bin 99890 -> 0 bytes .vaunt/badges/badge_02-04.png | Bin 159437 -> 0 bytes .vaunt/badges/badge_03-00.png | Bin 146647 -> 0 bytes .vaunt/badges/badge_03-01.png | Bin 168043 -> 0 bytes .vaunt/badges/badge_03-02.png | Bin 157176 -> 0 bytes .vaunt/badges/badge_03-03.png | Bin 126985 -> 0 bytes .vaunt/badges/badge_03-04.png | Bin 165908 -> 0 bytes .vaunt/badges/badge_04-00.png | Bin 161435 -> 0 bytes .vaunt/badges/badge_04-01.png | Bin 209744 -> 0 bytes .vaunt/badges/badge_04-02.png | Bin 170297 -> 0 bytes .vaunt/badges/badge_04-03.png | Bin 131450 -> 0 bytes .vaunt/badges/badge_04-04.png | Bin 182599 -> 0 bytes .vaunt/badges/badge_05-00.png | Bin 131948 -> 0 bytes .vaunt/badges/badge_05-01.png | Bin 159935 -> 0 bytes .vaunt/badges/badge_05-02.png | Bin 137138 -> 0 bytes .vaunt/badges/badge_05-03.png | Bin 112041 -> 0 bytes .vaunt/badges/badge_05-04.png | Bin 155769 -> 0 bytes .vaunt/badges/badge_06-00.png | Bin 147454 -> 0 bytes .vaunt/badges/badge_06-01.png | Bin 169523 -> 0 bytes .vaunt/badges/badge_06-02.png | Bin 148525 -> 0 bytes .vaunt/badges/badge_06-03.png | Bin 123277 -> 0 bytes .vaunt/badges/badge_06-04.png | Bin 167564 -> 0 bytes .vaunt/config.yaml | 162 ---------------------------------- 31 files changed, 162 deletions(-) delete mode 100644 .vaunt/badges/badge_01-00.png delete mode 100644 .vaunt/badges/badge_01-01.png delete mode 100644 .vaunt/badges/badge_01-02.png delete mode 100644 .vaunt/badges/badge_01-03.png delete mode 100644 .vaunt/badges/badge_01-04.png delete mode 100644 .vaunt/badges/badge_02-00.png delete mode 100644 .vaunt/badges/badge_02-01.png delete mode 100644 .vaunt/badges/badge_02-02.png delete mode 100644 .vaunt/badges/badge_02-03.png delete mode 100644 .vaunt/badges/badge_02-04.png delete mode 100644 .vaunt/badges/badge_03-00.png delete mode 100644 .vaunt/badges/badge_03-01.png delete mode 100644 .vaunt/badges/badge_03-02.png delete mode 100644 .vaunt/badges/badge_03-03.png delete mode 100644 .vaunt/badges/badge_03-04.png delete mode 100644 .vaunt/badges/badge_04-00.png delete mode 100644 .vaunt/badges/badge_04-01.png delete mode 100644 .vaunt/badges/badge_04-02.png delete mode 100644 .vaunt/badges/badge_04-03.png delete mode 100644 .vaunt/badges/badge_04-04.png delete mode 100644 .vaunt/badges/badge_05-00.png delete mode 100644 .vaunt/badges/badge_05-01.png delete mode 100644 .vaunt/badges/badge_05-02.png delete mode 100644 .vaunt/badges/badge_05-03.png delete mode 100644 .vaunt/badges/badge_05-04.png delete mode 100644 .vaunt/badges/badge_06-00.png delete mode 100644 .vaunt/badges/badge_06-01.png delete mode 100644 .vaunt/badges/badge_06-02.png delete mode 100644 .vaunt/badges/badge_06-03.png delete mode 100644 .vaunt/badges/badge_06-04.png delete mode 100644 .vaunt/config.yaml diff --git a/.vaunt/badges/badge_01-00.png b/.vaunt/badges/badge_01-00.png deleted file mode 100644 index 510aac570e088d5700049abbed44190977b72f4c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 133298 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

    KRG@<1c-V4h~emz)&w- zNz(l<^pm z7#ffIZWUrEl?E$)MbU6Uyd7v)3PmNY+=<@aCYJ;nP1VIKP z5K(#_jfRr`HSSE2GR*;VrYpFY&KX!OfaT%+BvJEUoad~MC!^Qr@&$u21t%I%9jUOa zKmzjWNK`f%v@opUQ&P5&L|mN=1s^lf#8X#O&Ri_;CutxpkWip_?N!Y!O77hz)Ahkr z2pLC=)_aqxcg@XU$G?STmh9V^=3`rc<74=lK<3$*alZI%>Sj%sb}7CWN;Vl!Wt?@1 zC^4XYAb-m~({09j>cZeP>U6yt-BszT|7JlJ%?=;)ijNjJYvO&(N0rhiIV=%9ZQ62;3+lPM6`a@ zPO5FMiMhDg+~tdiZ~H^zxR^{Ay>+M-XXdoYNeK761}ZDFl1zUQkmpr~_&rqLizz7rNc z>J0fbbpgi*2-0k@z_#quYy#4ydR3JM%>Z@9O%b1&J^aU0m}rC93RQlE%U)vffpvxCXhdvP+z5MH@I=-bY2*-Goe&2`Ic1K;{f}+XT>)Vk_ z@uX8v96>G}7=}{FTg@?}_CW7;*R;KqMvd@OMuXN_Z`*bWVRUB%5ny&JzTV+k`cdr# znbNsTV|xB3`R6)gFh2O9hw^0euR3q+73n13_6>OmzqEjL7Fwu0y}>ljY7H^Lr|s^d zPw(r|x`S3ug9CT|l!uBB@cSPAnWo?zwGao^zzRRvuayF>+-&`q!z?iK#sD#(`p<4l z`GrC&N*8uw$+e5q_QNba0{AOx2XHO`US)pXu!vKEz|QhvU}JHqx=&!VUN*@7YqVv( zt2xBS1W<-4e-L)Aj9;5~F@YZ;10rZ1h@qg$Cdpn7b*% zgh266a(#!AHp9h`oetOt(32pFYu3CLnjUTnkb(VYN$De#g;_Mpn{ggctWi_i_Pn5d zFWNbH4v(YGi3MMqspSq-knxHrqIH-rBV^fkBO%NDut(mdibF$8hZ#H8p|$FxGswWj zG2E!v_A=7iD=o5Q76oe3TM%^Va?Bxo|HhuG>sIZ8l$;m=g-)WD6QXq-S+@X0A7RXQ zun3`7{NMdWk9vdLLCU9-hHkSZk4acfznm9#9$8#F*7wI?p_ZV*a2jhxR2N#lZ8nmN| zGCV6r#P=$|EN)g8QtEG2>JyqSvS__@bhUYWw<}(cDl8FYko&W z3?B}R4_5IHy2_n+A=e3A`&A**^R=E6-y%)88`nVXYplNJ00z@NoHddKm@`3x7A_*J z6<$Mrp;nPsT{qDFB&1<{47HqGXGfnKCF%6S7vvbni1Po*#546ip zOl7xXT^OHfPAdUNU35JZsM8ddwB(34zha~S-yt`ayM$7%NJ-BfA|O8V*fMqyIJgh} zzhU9QnhPjBbf9nZ=<$3^Fci%5Z#>+8{d|L^U*|+H#Be428o!$k8lQ984~LMTdH!h~ zJ~$T7j}8g^`vlpREMb<&Hy+KEg1cni9>B}#Gfw(~TQH?KPO0y;2lxzX)r1^z9LhhzlMxkFP zwGQm1^QCu2U0#4W-MJfk`^&tC#L7uvep78*^IM?{@9?X&nWIiQxPvA7W~B1e8lMke3vOgF;bDfMRN*W=5gUmc+RT$V!2U z0Jr&oSxK45ThaDK>O+^1m${JPRNh|_Wth5Z3=!x3Wy%R$GbliAAaeVYzI#%cCf8({ zw{u*)c#fO!OBlvytkIo(f2Tu-EEKOdZbH@UZdm{7(*g zs8P-|O0Q*zd^B8b>f(-2J}~pddmu#flA>Z_I64O80tW|@!oo3t&Dp=aZy@h_vi9{1 z0CnE)ddy$(CYr{#!S~v6yHvKwL)^aKlD-78AcKQzxMBSn1kd6$vu}g)IbkYX@h_LR zg+o<;B;z0$N-K)V^w#Bi;`@6|1iMu7M}n(*R*P*_DV1l~R+xxZ2Q!W{G#?N4(_3A2 zDmEGNiU-E~5<_{8h%@ot5%^LYP7`LsMStC3`x4LH|J>M_STenqeHMsL_nLlyI}icq zM?hZdf7o+n|)$WpRMxmz!*mH4F4T;u+vq|09ZizE>jtM9Hh3^KJq#lUk!JU0G|v z$3OQEQm)U$k4XKi{jBc5*W->EU=%`FsqoA3dC8{xG29J`;P!%a;@)(CAHO1?2&?H& zytWNE8C(URY+(a_5w6Ko)tX@}HZ(bGpcZuB2Hf^Z_}*ZKi%x|Y453zEV_(^t$r!DG zQpzQ_?0||O%WG`Kn3;WST5;Rf(_S6;YH7D;uOI7p=qSF|e%pCGxA*QSxVe~YJz39N z_Nf{4{&68msj9tR$|HCzXQbcGA>9U#B4F{>`s6zg#g9qXzY`|&+S?~f1|2k-j|)e` zsrqRxq8|`HEuBKZh2lbc#*`x*OfWX9haDL}q1QbP+ZkCttt@yuEr^5cG@i2Usn4sI z2V8kAyuF1m-2|um+rs*R@F&uH26AM!5|4DqPIsYmwxjTv$aIO$UpW(O6weOfW815+ zFhHqxjz;n5M8C0iNf2vGm+tr9Mgp_t`->Ft~Q38DugI;mWGM5^|=zmjF@Zrc^y@a6o0 zf6w;B3ZVc$>@5G@trE!rmSsFFQ^GFvX|Lz`+A{sHjUIA+b|j-Ua`l?Fs8b&oOO%L< zj1)C31MOa-O8JM5YSapuH~#u_SOklYCT6p;q(H7W`mIHau<3)*s?Dd%A*b(-+)Zl~ z#jYnI@H`MQ0$^F1^o02P00oglfoI=@-|G6@Cr|ke2w0W`L`OE_5J*GYCB#rMK00~> zM@#s!;-*I50}xZMsiI2c^EBzDSS!x5v`%K$*CF7&@t&L|EY#cf<%`1wLyv&o8V!hi zo?!DU6wjak#)m(+iY4-rxQlf+lKy};7qE#Zex;fJFE$%U1Y|9Je2c@7ulh`1xGM&( zdkCoOdHm5nt*KtpX)+!905M%Rfl~Z1`auA+fDlCQfzNtgdZecI<|KFiC$B}WC0D=X z`T%sl8nRlhf{;X|!m7HjQD9jD^tN~1{Jk@)jlpY7!@&zj!P1}72;(*DUc6e@^n>K%-j~4ZFmSbP|mY7iOJ_GBWcwM6WyaAF}xv z4S&tBUZzLdIZnp>I1FVUkpI$?JMxHdX2~o+cqbh@m)@T*gE3u6Ijby7c<&$y58c%a zpnWy1_AkGB$8(nT*9-(}&WQHAAh0Yn|Hu%97U5qtgIfCSkn-YV20hN$>k+YYV4U?V z?92!Y1R_)E|Kla2SYJ;a1iH}W?!1>u8pqR7m<{VP%X`-M&xf}n0=}L)sP}wH5dlW zk@=QMEwaFG9i5psKv4;Yybk4ku7Kkj3%ML`_t$U9b&MN<2gMxa_tDn+CuH9Evi$mx zFYOV|)co_NRhf-WBrIyQo9;5c0mYF$Ga&q_PQ~<47@RZq+CFAY`*!+e1zviWvgFTO zv_9@Q6X`{aQ)WVs>$Dp4N+4_dl#+OMf0+@1j^4aivYzOWH~>j@D`i57G5&KLoL8-H@L;+I?%q(&t@Lqq8>UGd}9 z{HPLAaTdH>Q7Xb#!6+tB0J$N+yyPZ_(o8>+3s~>L&5vqV2<4`{9XP_3aek8bbV**Dr$^L}$pO~IQ`^>5& zYr;j?O$mI%eeSz!G5oF5h>-acHVlNG9vJ2gg76zUcd6Q3*(@as4S5dw;8xLmN(U~R zXXQOmkEXeg+nNsX2D|xaOM-Pa!sI2pk`gwTmECFx%-r$=OO;0&}^V3sHaOOy4Gi-G9b!F$;4HYJG%bjhm zZVRZUXK)zhS=ntJF(64qHUnw1jKe>9WUUKBu|t1OV0kR#rv^`{lnRQbL!P^Ut`z9-d;=qz}4fr=)AdeHp`o- zWTvDp5A8;pH%eiC&*Y5|i|UcSG%z++YdaAP6&;X>gw5Ol7a!Rg^3Y_M=;9cJsvAU+bcl6jG&P+!eLB4oxGuZzo?BM$ z)u8mH6i7;0uL&R01(Rkxlui^Ut7>?j6=^Ja0s;U`56tsP{dk?-2}4C?w%<-c~tAFR>*vj23yy_#R1sEyE^17z%xxmR0FtBSAB@Q@`JaOBXNJy zgm3z%z)=ad+}L0jF`!1q5d^-`=A<8(&j$0|WIux$p3eh?ajli%7m91-k&<#`wC;1~ zcAGnmq7wVacHg{$hhc&T{g3bczo&z^7XK1do8e*=l{yA!fGlGCd$7IWD{QZ!DUyw_ z(oRpBHV+50+?s)$wUP&9PpTlKXhjN&nr@8D2ym!Cuuoto4S%g54|UP!=9|&XKEt$q zFOK?hRUJH6zj27$WoRxnmUQ^SR-Td&Z!!^EH#q6L-|pjB@CL0n zc?N?ODl$g4%p31yWdIs%&^#aCi=qZTRgez&Z71XG90hKRcg55aW?&!})mj!gJPMen z`${opk};6$ca#UGZ({r^TxJnIH%2>be}Owx7qqE6D+jBrRVd;bo}Nza(htCPz5HBh z0r10ZOU?@5UYF)?4nhY?SAuVf&f_K0GaPx!Ejd1+cJE6B&T)=odQ~3(w6_nf%HI}d z=<)1)3TJ+MTTrbye#Ks%+Iva&6x^V-Pgh)nt*sj2vCt4fe3TkJx^Hq=G|(xbo{1~u64!u?5Sh7e0jS0P4X|1RJTOWCA7<>w_VWh-O!P1hI4Y_ zO#yTr>@UZkpAEnEldJD&U;;^ebRetPKD+sC30*hSTJhBbSgXg!$GO5W>*rConj}ca z?m8&Ny4j2bAfN*W9Y-+28ttJhfZYB-KX!Et)vIr(=WG%C%PXu4`545z;El)Rq8e21 zF2vOr*N5zt6hwWD#ro*c>0lE3LB;z@qRjv;PKx`P-1ngkSO&pv*OR*n7Kht$=qmVM zCV%s>j=W2B#(a&FRFsG5LBk?1+o!Jo%y=pLiQP!Ub~o;BnDnU)7YRKmXgi5{@nM+! zWx*`Qvs^WeK3Rui#e?f@M`ZzUjZ1Yq3bfB}vuNv3wVxZDoU&bVX6--H@LYIg6KUUHd_e;x3Pd_N3VW zb{lU>;6+BWJGDf)7)~dsP3D$rk=bsVs$@j358KSvPM{k5b zuk|~1e@$(ptaMyo_X8Z&G`7v8{TdewtV?H*GN!B4YNGM_&!@i^GV(PH1C;2j(lnBxj3GSv#O8)lSxyp!S(1XMX7wpp_plD%ARCBd=QR0{_Lq(p} zoW4ewnI2d4c&;ywemrG76Ne4LHwkh0?wg@zL-25$S?Q})3mY4oeMs$0*_T8;)r~gH z59t04djK^9h125!9WEbkRPkpl25&w<8zKJTJB|fI2PP=mLIO<9OgaJlo%%i}0rGR< z@~-Fe@PK5R^FxtFkXmMjAz9slHx{sVY;0_7VA2u3v?OVuCvwa}jaYNhV^EpU zunz|J9q)}=x0E|eaL3JmETz}P>ddDhq|ZjBSVyEVthFxLgf>s%&{y8L>ZtD8BL>}{vmP793wHbM)2w=E=^Ofo{3hNr8ieQ zgrCv^-V|E^Tw3Fl_QL=07yr1dsp!gdOj?-)0}od#@RBK}W*g ziMhU^{bbQcNQkF59zMhW&=*>nv*Q&|S5mT1`iqaO&+>ea+i1+j#E)7ye1Ajd7XiFgfW?%%#);u z!_1~jWTJINt58Z%u=FfvW)$dX63 zU1N~kZUqEivu^@npCyr7RH3ULl1b#QQ)n=`m-9ylZ8p*+i9 zw&4nXtI!AE6K7jOvyX2th@BjTy(ux^9AH>w&TOxVFdhHTmKxHnT*Pt0x;mT|et)XO z@$tC-O`C=!?n0x*MK1we@p>D>c@v=;dPtd+hoUK8FJ0kIvg=HJqqPUzOa53nd%aa! zy@>lcdh;6-?p^X+tcay&yGSi?&Gu~_LVYhVl+MKxtRIPY8Ki6*wZO3QIGx7nk?6l4 z5jNb7pzy+9|H-!zn$a6MdKNktc%+gp-j2ZFfNiPd_dq$&v4YnOR*b7jf}(?L0kYi3 zK}<$-Mm?PXalv6MzstV6`owKdiBbP8gbqoxJaW)+u-e;FXv#^U#kv{c+uO1URq(*5 z3-)wdiU-bGQj$P@ijWAozY*ItCc&Ag_LKX*)*^FKmXCKA@BHCmfPbc>C#48@MaUw= z03@ceGTRc8PlH6pF#o;RDBA1j7E5F->I9&_Oimm8t=judRF^zC1&D5Y&7$y%^nRIuP~X$@FNZrzJv^lZLl&h>1x2Od2%DM)DmV{Q(LG+B%ei@Z=0c)}FmDFCw1FmreDhi~I zj?RZbAo4TN8gk#K3Z!LSziD4Wws&{g=isW)Bn-HP3KNW&dDA&U4V~k>qh2#^VdaMs zQDEUww(&n%+^>0|KE5PXr!CCPv)U7Mpuxd?eoXvj{GJczA=0kC^Id*)&EAJHS6NWwxrF0uWfE99r!Ur~<1em^&qK zRFo7s{e=mgDd0Oi+uKccvQq+^@qQ3oDt~az#7coMNdJa6*$A2p?exTHmfpJrjsVw@ zCs!gP_kmnlfK--kk{#SvQG*7T-YDx{Lc?Hf@M~oRI}Qq&{_w!d3-{uWde{lwM#~RH zS3mmJyPe*7|NI#j%Z4w*qxac{fuQh1BDx-lbigPWgNN`U_3p2HvoC3&Yo5|Q9wW%| z?wuFp|7!uR+d2|$HuJIj8p6wbK)z#(Iww*W2m2hJTv&g8*D<#3ARt1gL17mLrdN@) zd_95p5$gtnc(D?o1fqhS#|9Kr?uhVfFRf#k7OrY&$3xJ+J)b}raV-#W#X9Sz@Rjk# zrT){##UTvFiM%kW$zs&x`_=E?IB9EcVS$oQ>Fwawr!cj7o4Ut&OFnL6ZG8`{0S88H zbDHWEcyPH16Pl`Th@Im0quu%1Yz^TvnM}MEur-Ezv{>51*Uo*RybQs~C zx@01O0lHO40c zPmqtAzaErDKL<*P{SBKhVH##e9w)f#He2$bXbwB%DoQk?4DYQ+p%v=2@y=yLD<;8` zb>o7&YgWyhyALR-ph$nzX?f7uu!wK9C1hI`+gtq30Q$ZJeGuaUSj^O}Wd1l3$2Xw= z;fbUM2znOz6dx!h%m<`Ae3fejc3?UffH*2sY!Tcf%Agl4zS#*H=9F_{k?^7*$`jgy#{Z&r9d7J~e4hs>GRGPrzG z66k7?^l$;0zu0Uf(L~*R2fw@H8c*M<0D1?Zxmw8Y^7E_)-)k2+fz%PJ%rbJv?mt~= zp_RQB3{GXVO|6nJWje&7$;|l}AHxm(514McKl<^KvoI+PBM^t8iHMqbl@_XNytODQ zW_yUJbm%*0LwWhLl2+F0!S#-l;V`#vr8e;6ge5Gf8u25$@9>RQD(!p z|IX%+l%vOtfzOdo1VH6CKb-Jd+9IQv;sNwm#`R>)Lw;{KipOI?UoO&L#+Dkny2Fez z{g6_~;8}?`#iPZZ(JL?jy2#41b9Bj34FF+3FK-F=Zcn(m5j}S9u>fi|C4@cg!EZe! z#=m^32L}6An1k(A!@&&1c;0A(`cOLN9hccC z8cb@6-7Z~%0ht0T*|l*2y2s6cqO^p9iT9Ov63gksZ_rHaSSo6n9T52UvRh(E8w)oI zl`f{+i~Rk^PEWEz4Qz)WX_DBmK0eiGzqU;U@AvhvcR}>sr&|Eqy*%U3OVxlY`ElYz zdRZh=;F2hMmx&>Nq)5UzF`H!8MTK z)t36}e$UM^t;=G}BaL49@>>d;cBoJoIq5Yto+JKs?x6H~e0K^*ciao9%kLorYAzu- zhf;x*0K42}w_VKqB<@(i; zb+SR}R+xKDHZfv*3(uL4GAIdB$fgpyC8!r8x}gU^ev=bwdw*H08Rv^1RaonN^ zNZWaM4CDo;g!zlaiZyooN#>&it1-2j?b~rBi$DV4)gl03PH}FW+ConxaK(g5*^Dgu zIZ`0K+&niVNi{?8`JwYh3D9erX8TV*29SG~iY_~v;QYA}CF~rJ@r2T2qkE#9g}Xip zGB;j^;OeQvQ1G9P}zUo11FPy-Wo6{?qX zCLS;QQs_Rg_F+F2tXKj|ybieev-O5&yRG`bsm|tuGI>z>7hDSBs@xl0rwLRLN7vJ{ z<2B6R^E=9g`@#=~)Y=2o+vwA1pj`e?=~}c}DXe=Wjq3m?{k8d^g+rYU(L1rfG->nz z_w4%qIX_IW^1|BpxskzB)HrjvKJ(Xi=S#)kZ78rXB;@M5nz^aC-^Qw4yusdgRW+W5t)Ij(GEMH< zO9ZKh3&Z0XTcOJ?&WU?D_#TfDzoaCx4_Jtd<)v=O^^Ks^y(ckM3kP!Wb~c`?R4{+Y ze>jr{qVbGS!T=`VOpQUVKOcen?bjNIs;wyPAGY*UD!vk!P_1o>F*mmBa(WDqbJ&nFd#1^Rqjt|p?!M-#@kWp@g-T; zF5E(Opg1-FU$>1FcG1QNWtb{1t2+?^H0sGKD4@#&uIOYCbRXVkz3pdy9I29P)=k>6(6V(ao}hFc-3^kNBqOCFk3|otugUXEiUrD z&B}0Glf9Izkaqk-=Ym#6%&y%t=6z{tY#`ZGCwBHlk(7H%0+rA=5yh@=MDxMReBb;y zBC$^=66hVx^K4dfCLc=}C#$_i(f%X%N-_e}lq8EcJ| z1C4A@fcU=#KNsKllF~y}KCHQf z+}eV#Epr6tT?U)wxA<6LY^5zHyTUfnH!X<5?bB0%A5_!CC@qC;sfmCDLUCO1W!(u+ zi44F)-*M>4#meiwxmS-$B&nYddRw8XK9hQ@j*1LaoY@&nz(p>Oe*b3kLY5?~v#aX~ zR;MDF`d-Z>!tPR`fLD4W5)i#Lrhei)Df7BPi&R>~<{XJN*k)JD`?UxPcW=c%DT+sM z&?78GW)~Sw(%Ib?CsidxNp$l@%IJ`FPU0vC3mvK>wdBPcT-Tm;fudj)3Ng^;2S3}^ zo{Y9>Al8(<@1Qts;bJ<9D2;6IVKRns1l`v9i7rt>Bn=+k4Pt2tSs^E)#EKCySqyOhI6-NH3RF?V5H24mD^72MvOXl!p;v`tq4;_7 zzs%!W`&xH~7(1h3#5rfWe-vN4YD>xdI?;9gEMm;$Yyr^+&V@wNQ{dkgX_+}v=11! z?R)2ve|tCueCjGTXq$QM*^LM97a?DZNQ_1)tQDGRh#6-OTK8LAI|8+sqcS>x3hXV$ z9a#L;BW{LXK@*UkuSsEoa>w1<$}Y~_>S^;H6`^g{hqpCr?MO4+8eB;E+pqN#w!)}a zZnBcl>eqw^%xi7UMz7bdj{gPSlDv5Z=xR0@UW-$JpM%WoGyo0wkx9y13f01=Nydj0 ze!4-n(-ppHyVZe5V4!Wf_nVpohn~m-!3XFM+wKN#PEcM6@*2`zv8#7fEWNU>Dlrsi zI$R_1Lkb%Sd!NxgSjyhTc?_|I>(~}() znU3<&JEoPB4D9s7?h`~O;$10`>(H)zR&HC3_khXu$3@jpT8t4Yggfma+O#|%E3@Qf z(&LNkmGm?W$aS0V!@z;7mGyFRsDSgW?{lJBvR^3g*S#iB)8GTDx_fPoDyr4yfkfKRZ>K8q-rwqQ2V$NE^ z;HCrgJ@BB#>uGY{%n^7ocX;|cAU5s4ui8`71im%)k?ukwn~H@tC?9&&f&#GG#V_6f zy9S6n?3AR+i0&(C)N(9x_}PTJn8Bq` zeT0%@1l2Rb>sJyRv#@{P)}7STOwt8xtB-o5%y@0nApkr@9OI)UvwkUA(U9Cz0?mN^OkeP}m*@?wBT%*xTnyZy>##vfJoGj-#lUAuBG zIBu3aG!m-p;WbA_ReHL1Mn_pJ9YZPG=kx9)75aF%-mP-0#CtkInR`c<7LvNV%$dr7 zV()u>mb51Smks;!(yU>%)&NVW?j=q?{r#;hXsU;9m5Td=VCM^N&QPxAQc*Zb&Pr8p z8EWJ9%j~kDapZ**K_esO-z%2bh!W#-w^;iAAy;|~e%Z)BQ7aFrSv~hvKGLzv{w^c; zih`&+n~XP0WCKnREP;v?A2_O)E3ZvfsNrk_21NL%uTIddAPVwDE%}SYmeXG0vZK)3 zR&fF(iFi>e3oXn9qB*rm?F|NzhjunKU2@7e5Hy|TfTy>TYS)`T%o9T>84j(bP}q5b zr!-TzvrN&MRpc5y2xg~XNAB&}`|sJ!-_E?24nlKJ{dHRPVnyBk%Uc%{C0xy?_O+QU z6IZ{ba?v@9Y*T?B?yAdw^u)dfc}mheVxDYwws-N7 z0#Rbpv6J-PKMeEqjHQUCs+NLGrPOny^>N*PWm`|Z-EN|m$(lzCjJRQ}{UtgmhABcu z*XO^Q-xb_5#XS&c6U@Q`CR*)jZ*q3VLN9cXZ^fD>e`=$5?cD{KzP!B?$^W9+pS;5W zLCi6((#%;T=8b8srcB5gAZ!~=67{l??N~YD=+`XELPvsl=m@(8;iRTAN8atob#uwd zH<%Y9LbW%GY>>p_x}ROfWiuHBzkj}Ef-CCw$6ti#puz6|oA(tUxl`bC&H?`*Q}u#y ztD9TgfBm6(R!TSG+fmH2f2)9@}7rVkHgVx$GL}atYDI%1F%gL9F9n zw;oA_@K}PtH-_NrbvV161xI&2b&O*LYO?JTIjkLbVM*gvTkFGbkxMD|>us!D71chz zY2VTQeb}6kwmPIR7SEjh=vcTr^=suE3x`95r^==iu?wpQYgD5!WWpzNO+w9BjT)Zk3KXuJMzRfb_#?;|*z zvZK6;9RWC!=2x{a;o1O>knllO1kXe*2ZxV9ra5O)uwivZ5qiZk+qz12M4E#_Gv;yM z>14vSH!L{9V)dUbG(jXgR&DN=Z$AdVz#@_mXNuJl+OGG$?+o-bmW(W;uP~`!c>FC3 zCIH!Lz3|^mBhl>4@v!l_60|_ac$>>=uq5kNG_8X8doxjq`+Y1MhaB6{j`wW~#Rzgy zPBX3WuM-`^VX zX2to9;dY^Y4y{n?PR=*-SzG-f3#?!eyOL3466I>fNp2AOx*%z6DyuS=*2c15Gh-Xh zI`*3kB*wqUx6iBpt_s~f8kPoR%IY?%0jacub~QkxY5C$A_gfab!fETUw&}z@JANBj zaPEX)vB;9kNZe5j$IelS^`MP@8Bf3r`%UfW3wb0}A19^foSJwrz1@xQfrJh=R<$DN zE~G8JPdN9(W8Mh7uu4Pm3;fTsw)}lGN*;GC{&9%rh;K&8aHq*xL#p9W%_KAD?p&%0 z!prmd8!GU~jJ&!*tLXKoOj(Nv2uPjH|x)mid1Hy}(GU=N+>>Gy< zeT4JL>-d7}o<2lJ!7XWOn#?1Yy$*FisXE>7o41YK15>yYef@y}0@L`2Nu~h7T$hJG6B$tx!d*VXk^MLZ?rb0R5%vL` z|8l7W@F_o!RJw|B^7a|owAzs$%W+3js@t(|e1v(o5l>lOs_%RB3)muVYy6ab0=0=LXRdKuI=p_NIL_VoL#tkO`6SVn*YSa88E6*=P!wK zZqM`=KSUv`rM?Bfd`>k(2U};?&ecZyO7gLp(}Z`IXH+ z^!0vDuF;=PaZBtCdY?Y~g@y1Q{+#*8FHsiOmTN6kF@?CF8k$Un?6A4Fu86O`NjWvB zdkwE{gS~) z%gq^HzccP!ZjLy%Cf9W@xBSImUaloKeeOz`H&~y36TC6*6YSd{-XNWKQD9Ms)bIIa zW{h4LiHSnJcEExyE$-$z>PVCaVxmc7DMde_kx^tfWWI<`_dvhSb;e8?1zE(UoOWC3 z+Qp&uPHp6Wq!n>!&={X@;uT3l%PFa$O`Buis^TdUw&Q+by21nocKS&54gP6@~+aJ`EF2~%jomuA?OxP^I-b$B;eg1CaXLE9~ z&4q6e#QWu;P{HX@P9pGTa|Cujdyoi3`<4*qN9+v7smU>@#%FIo<+}5KIRyMWP!O0H zH!p47(SbRf>oJf1&}V*ai!yqj#_U7&M(8aEoaEo~*3UubVBIoj|Mr#r+jjZ= zD|V3m2G&+HyAST=j)YPCRl-dF<7%bhmH+!A`{rUIfT78G{99zub}2^=(KsCbW^K*$ zWfR!Y85|Q{dccjz^{%PTkv5Kc%)^FoXa0kC{0tTQbX}(a+ES1R`H_y@ z-QEArI2}kBU;gst8k_Uf5Q(vPK-NQ=hT=Ri^=4k9L0I%CIGPF7P``#HR+ZNrB(1nb zcg|{EZ&(E7*4pKT*p{o6b!xh~aC2Kd1j}q%x(a}KQ|>j^ZY-AnGz7*;=c=%e`cfWjOXRu9R5gtRAhf_*<)WHkCnOeAj;Zq{yCWSsN`jP4 z$-9YvBNH@D^+%lDT(-HJpuW($Q0w<^(f5o?}Bq==f#KmW%rRnrfI|Jd`UKgvA@MRJTDNzFBR}9tGS&EhYCq{*k1waG*cp zp@X?l2DWvSfq8z9@%RDNu@}Pr2I%E+@A@WE)+NQ2p6wt@@BgYi5l#K>jaw3EmHkR3 zwnwgN@Xq7jW~|!C+nYPDOMDt4prEwD*zzGoGNg^ay?mNhmCv|Vg}~S&WoW6aXQ1)M zh2(rbUHv>DUB_dJjXw}Z{Ao^H?Bh6{r>+Gn`Me>-W2*w(Hg7bhh*3rM^}UL{2kZRF zB#+-4pBg{?BrjAd99a*gpRUf`B=mPq#~6z8_$6_@Z{#6Ef~cGp8YqR$&QX`ZBf2p92J+nF0bzKi0ozo&Hzt8!h$T>!)G(kM)>c?Ma=8cR$=|MTlVQD? z!PBU(F7C1kfDW{bGq+;j_RW$0+tU`Wrow!^$aNY_>N*{gS<({RKAae`O{c&8=|3|c zC*OGO6@7`6d8PGi676n?Bx6?!mjG`BLu`(++}7!)ncVh8!+y;Qow8q%3U~vX_bJ^Z zm9tk%G@oP|%7pQK+=~z|Q&{_xF@d_<#*Tdg1g}cNBPU;xW=@&{9XMVokZa!ANMk7m zPP(tfU8XqR*e=s?n$ilc{*>=rUvz!7=ETykb6kcPDNQB0g{I%spBt+FP*Fd4(jb;l ziPeH2RAd%>AO%<)-uY+cI{5bZI)KQBqzAeyE8S0;F)0${pt*#=p1g@LATME7RFSG<$6cyG`=U?9cSXR=yrZtHu3HA5g>bRNY?xW3e#~hDx^oVpXTUv{f z(E_~hUg5UfEC{;{G!*hh(A2zGIp1HoCNyws7AwC!CA zdr>z@V@n)|Yl*zSv}gZ4y(VD-$E$eCOwqaSA&g4jO4ki1_i~XueR=P*0iGeH)}~n? zOcrv&q#c{t1(Nohp`EKV%e}T@J$+X}M^0v(5eqFz^3Zr2xh%}Z`LGS6% zijsTvhlxMnJXN*tb77Ic0UFxU#WOvtMrcq^{j9>mq19E=oC*5lJA=xU+^DJPx8D;~ z^pVTl zWNzCGMKdxH;LosT|5+%nf1@oREsOqmicwgQ8l4s#^7caLtF1TblA-(Duz$6~5sVXb zZ~E?UwBCwMs@}u&69Ze)wiqz4UAY%6UE^{yidk=dFzgfALKt_en9Grj$7IrS(%SOA5sc|g+ClOx{zCfO z(>cv!{=qb6tk88}+>E>)(EUKt-G21M$aZS*!M#Wn>q9AGUR6vH{`~DM)dAkX7rqo| z1%O|4OtqtARIWJZmRd-%HzObz{JeeaX_K9`JF~icv*weRdX1{KcFoVwy%u;ZiCyt9 zW3ul#HuLh$y0A?<@vMteeBzNuC4t6_O(F>+*cA287myh70KV-7dc{~;7*F)E%x&FA zws7^J!@05(Ypa(GkCvU7#sOn@q7fY6|tkizs1D6DI(B zO5`L~U-M%fFQ0ZbfW*j?5?=O6Wqs$a6jFcs>jM6}#C*QwpwdDu0)71!p$~kgYJOD3 zh-_%-*=kwu{JcSSy6(XYaRLbiJWL9QisqA zZ__?B`FT)q6X4s+mgIpntiqOCcH^kT&0{Yto()`U>0@zu1gz__?-_;)bdGfZ$(<80vW7rUN#|1}4{|F_q%FMOdELS0Q_otI2_GF0{xLc7s? zJhoW^Y|{Olcsb=blVb{_SjSwW08gjHlPwqcz=`tlZeR80d_6}uvc22dUb8wj5WDxl zDNjY*&FaL4NqX8>qY5PPT?1=QIIGO3MIdE1{U52aXw z@yPF`6Q2A?T;X-mu9lC9?^o#eh3Ly{$uDnC%0;$%)J+25?L|}V~EohO=q(;vKd;>B;rJl>DPReY>iSp87%J6x2I{>sR03 zLxr7MKAtXLz@)l zqrmRNcxs0VsSHd0qyepy4AUq#V}S=&)!=oCKV5=px|DG5btF4YYKe{}{F(^B1HT*n zjMw(RG)Xr3izH&Gnewi5UIbqFw^>t5VB;;^bKw39_bNyeC|Y_pdav5C%ASM%S@T!e z3LaTe86P6~mCA?86F76m86=C$Gry@^tCqXoO}dGO*tZJmH3}yK{^BE`M!G7c zX6Jg3t)>4<+w(TV4S$S#l{EtZwS>MpUpK?~PQKG*s4MV1=F|PIWTxqH7*t)ej#_Aa zej;@K9=L-f7OUH}b)enz$0<%f6t1eBb849{p2d1sNH~-GCs(8U7r`hGuQY3?`l5KP zA)T#T`bKd4ff+!P{TGZNd_`Ji#S1GK|C2^k4a*LKW&ty{)pTem-qdap_u8+d#$RZY zfhR}QYJkXS+2~O9fO>4`>y2eUDpYjySdA=4TnOkvvlNjQt)Tjv0`T*VC95(Q%j*x^ zct%-;96evoia!Z%1||vaL9=OtQSu`u|No`9fb@Gi#(7}^CR*t!hX6$2ytwk>p%~84 zd3(>hPK{a%!Xaki-Kb%7(Ta&PC)B^C+4d7VoIA8{au2184fA+OquknlJr&$Vu({ zrFZ8p9Y+@~C9z)tLFN*FC4|?r6N5U@LaAY0P(>73YW{OiCuQVdHgwvBvJxP%@>inK zl}P+Zir}?p0<)G`I!zF;7s2}W#@Rv(39w`6jo4t2)GViIQW&3VX7MeBlxJV@%cyRk zs@GmS6&jG5Z=E(w-Isl$vmAg2Bzjq35?s5#n4N3$K_1u&JBj4Ug|st7NXRVZXAYzZ zrK|*NmjU!YqII0?gjYZ7QgXOKmsr!1aG&P39;R&x5Ec+FDJEq^ONjr8tAJ{csl?ip zFvl-3RO>+C%6ZV8ju0;vD+xExs$j};DTB$_ewt|N6RVt_lD|Mo-XP7+jsTu`Y%M0% zR#&g|f1kxWxB@8!gPchTPfWgK*NVaL5P}1gZKDeTg;?-s@1qxlmUmsJ!8q}IA+s-r zfi-Q%%mEu%0UMD$0d-=&9}U zS@vW^JvAM}nc3%?|Io=Q_Wc#$jO50tuxhi*X*(j+edSw=4|Ws;N9tY8k)f zDbz<|lfU7PD-$D41brGj#WGz3sN+Gjtk~eEZ;XNdqW0+!AN|RhsYrqJnw`T(cyeO$!L?3kP|r-i zfKU)R^c2S1d^Bj?z$?7O>le}S9FYC`h)pXS`+mJ!IHXeeN_siE_Al5>{O!c>Z6&ft zL?-$jLekv{EoKxU>&vL|Z$BkF@nsLkC&CcE`e%Uq2$s>Z9QbfDpj%sxF{OubWj@hP zujb`L6SM>7R`ojkr(-L4>{_G>u$mCkCIZ@52Kr@KsXo7g*cF*j6MryzjSzpY5F}10 zpzEG{U8{i@=OU%jMj#T~qt&^|0_ut72R)5am0GMC>>wX86Kq^gYcYZZY_Vr_lE4v%s zIa&Jl47K)?;Z{Jn(z6KGL`{sBaHUC(CAs@21?pi5x)qnH2@y8y1J)%5YBD!h!h%Y|l ze>lplM8R?u(ea;2cN$S{Zz#=nxbS)<*<*76f)l+JwK7i*YUn4FOzymAY}-|rd4yte z_ph06+AGPPM^kg!M9>U`HUoUEJb*$-Bz`D5P3a zo^p9iN0uF&m6ZI^k|{(F2Nqs{m|}>|#>W+1vb5{ud&?-lzz{bQ z+na~`RVRLC(@otYtU(Z@B2k3Fi5|@t$#dVm-eiXh@G!m?o)Szht0X4D`@>gN$xp13 zF1L8HaCS}4Il2&jc5O2QzFTO_p9c?F6w(x`GJG07X5dBs9tjPHD712rmD1vGF4c&U zH*%8V9n7BrmohYc*R&0jY01b@R*>^33H)JHK)@J_uDmW_Wow_t;qjZ-k;rN2R38oieybrRp}*kbLg?(+o~5fdPCa3 zg&ZbXC@`T>6-wNd2Fd>(Dx)qzu;;9-WvZ`#<y z9&&d}H@rY$NE04a!06}z$|fcJ_$AD7^C@dth!Uvtvao*0WwhtYE@7Roj=pknaqtSN$hp@PV$?l>`Vw0z@<;scw_ayv_ja9i5b# zvULi~Q48JDorMM7J4$4Ayz6mz@3{JcT3(Jk_Yylzzsj-ixpUxwEiU?|v+y$ZNq6sO zxy3OB)0mcCv&(PUQTB%}yslbW<>e(X6)v$WK`Nay$%b+*X$t}B2GV5{oRTJ=lkIY- z6b7SrKFJjm7SA9naLJ|8?tQ8wilvsx}I5fB1T_E(#?Cy*{JA=+v@nNk9)1Rz72*X>F^OcC|2y?Q@06i)cuRN;c!h)hyMe%zr zpJGRc=TadoY)uJ?3S=DySGRN!mkHgS$P0H=Iwcw8jlDqh%nJM1U?m%Tn2 zT1>T8rmQgZ&3L*IXI{mBKQi^^Us$f<@isAIJJ}+Enn!xSONwxbIq4zTuFOmFl$?r8 z@T2dCodcYM=H5l;8VVyaysJYa=!Si0l_vKN@h?1c=n2u02ovP@^f2fuWvnDDA=K6DKzq<7VgDdfpE~!Hx0Zmw%rJ+wEa&{LTziF=uvMDvU~13 zc}jwqmro=;b5b7^>y?-N#p24KCJnzkI!;x}O%badqg})^&wj%y)>?xG`SCZuX%q*8}{%DcJqY@*t; zh9Rg=i!>%_YpnCx)#KYaFNY5mW(QNON(e+eU@Lg%%-R3>8&&|K!FppXC9+Cyy7V1O zggGQ^kj@VFJFF9H@9HRJI!Q6CG|ev8=S7X{zz^ zpb5ybNUpKh`Y!IC@+N*yjpQoQ@rQqng8A3gCwJK!ymm!W<{$#_L_I@D8%J$|&3y|; zENqgfmyuw6G!H2f7Wv^C?SBl;j*PM-Skft%RCm!sZsa!Qb>L(-&niJN!s{{Sb4KP(CDq{q`Z6H zdlp{-Ma`8l2+#Y0yvJbq%TZV;73vR+Fi73X(3r{XEQa`v0{HZg8LYE{TPlATDI4FE z5}K06cY3d2M4>`WE(v2LbY`_Jgp2Bswl2zn{3&G0(_SOvvkx5RQF(^9_HV%}=lrO2hO0P${K43)_u*$pmp|G8 zPpP*^XWhWDX|@_Fd8%96`MDm)7% zU$s zq>yyL4Rc(RDXgfHpECHQvfYKd_w$b{%sLFDB&V(G4(W1ZNJ)4ju^cvJwVn?LENUsd zppg11-5*Bz7rLy!>*}KYIzy}*BKG#IPB*$uRgky6C_Y8Et<~JccaUP6{9>GBQ}=fF zw-A^3#L^Hq!$W&1Yh0yO*T$Q>$@p+{ z?MA8Y!)WFEZ$y92P)>FebyOiWtkR3713NXgDAg`I*7wlGJ)r2q<$t-uNTWDKWQ>O8 z*?+;OIlj<}6j(+;z?^KQl9;>F-fxn~hffwtcp84DX)?{0s5oAttxzkFd~xmHGBcDg zcFGomu5E_US6uP^l4>fDc#n&4ZI0AxB=Fet2G#ARU z|H%?6Vq^-s-ivu^WbO~qK4j?uA{+7upo4VA%%3^8SsA55DJ81rrSRsbk37_C`8f%1 zT^=u~0$xwBiZ(8aOq|UY*4w9 zwj!$Uh$C82>*g@!*CBxS_Gmx+{;Vd2+G3^HsmiW$nf+v<4ap!@t^n;dJ^vC6rIE5e%uiXU<@kGCK78`y*qj`ihK z&ebIXD)24*g@A!g~j{ZD^ylv%V%g7Zywkg2ZwZT@o>H-5cKki zb|lNTp+iKaQX*rdnm%Yqh(Zw74-z3Vk=?k&j6{$QVlK1vva|Db`)Gv|MERhC=_jRU z?{P_X1S3vD0`IOs;rEQ>vRg%Bs&=sHgI<1R`ci=lppjA*FOQ0UPUuX>WmJ>&*R99to9A|8KU z6Ek`2AQ*p9wkeV;j~O)T&-(XjnQOU)aOe7gMX9LimhheMXkzLJBo;qF+MExn@dce# z@pUU{BC$B)fX~{zKY%?qAkU@DtNv?wr) zE}iVA@pxifdL%#dcxn_n^F3U|@Vk$4Kz&Ona&qNzR}o}2!fA0F^q%j}w21x7xod%j zngs{Z7J*C=r|#kvYLYCo49s-RLC@SDqFSJ~+<3An531e+p~n&ii0PYK7>kgQc}p0= zo)Z0@4(bUgq7x3fd-z2B*o>h11D2HGk(it<(Zc9^8dqkG<7}&PO_hUt$9g+^{+5~T zwg$G;=;rs0Uj|8cYcW#tlcIZ)&4+O`5q||?<+e)#G5lC zek9<4EL$D(r3CLED2&P%;!rG_f(=$3eaK`8HoQpuH8?vTat3#2m*`51w3U!4T(8`- zPFk^2_MQ*p2~}EGXuXYhjnT&YTHR%V6tI<#%F>|8Y8>bpjt_#tBhU?{dSO+j3N{es z(EZ9`kEbw5;eeRUXmqmH+6s61d8C-(a^d|YHy80vt0Ss^N#n2V5Bjg2K{a9= z#kh@Er;}ECzdWI*nhFh?(EdXAa+CiqvUlVdpP{3Ry)ZF{b<~gtZ3==>CE`8s;#uno zalkN%v`X=}&?jj5ld3v4ye(huv9qr)(byOZv|{Uhdwq7D6g=33QoWMJ8Vq~RbGZad6`h2}&+`}9>GAt2;X0PexME=#Ks zwla6n5gvzNcUA0x|7ij4d41j+FNVA{u@P)N{~F`_>0r~6H)csBa7uNI|Fv|&+n`qnZ^7gWn`n%2gG1~MI0iC{Uts%61yOYo2#+V*M+m#eZ^*P1 zTD9Rl+^gkyC@z!4C+-9l4ZKvBGDOJoGI1)cWI1#lsT_sz*AYB}Fn$GOlpWa31O+=>XGE**Xm!#=>h&%X2_ zEBI1PyzUI@aarZ>MY1zAJuVXR<(jqpcL(((jzkrYCq%)4u8*c15_r;=_xA+qEeCdJ zH1Its%iaL{F<~{e=IyV{V5j>oYY`pxTFG!Pr77;sgO{WJai zd)c{tm8L;aL6A`X?xM019l3@xA?)my(c)0`MoFWhX8ll?BMNA@by}9LcDgTn=EGss zPX&`Y>YIfV4BD6$y{#E}ihA)+`PWJTZV?9<$`zHl|>J^97vzjc$w*50Z8zjcOUR|r7&j%{62 z?ox?Nf$+Iy3xNo8zCI`z!$FJiZl9%W!Tvy0t`#m21=7wf1%P~5=itq<&~k=-5=%a( zNc>u1arUeX@qJpt+*v6}KM`rL+r1Xh%?`%7X~_~t@n1r%=YykeqT>vnpXwO3d)BF( zJEBZ|&|~~a2)z3U$kNHiP$?MQ&a(w)aMgVD;KfN35&$xoESQddMsQ@1vzY>37QhMR@tLV52=n2OBie-KPovL} zJXORli}{OZkn{&u6LR8M0`I?lyNT7jbs^hm^ClX2_;Q);Z`86+m?$pf7g#dOJe{E zBaJ>j*1~>!4Oo2&>|26b{JNeN$%m8*g1U&t!sgwswSYpGv8F2`6%R|;JFEjWW;oS# zrC+}omzJ@~k->P^bXR#JU88#g@@Qm$I@2<6yzz1HJJ-aTs3mUpxRk#_`XP?hY5kuM zAm?+-HURe=2ASxF-?0og4RzzfpK}CLF|q5MMLDrT0cZCj%6j){k;} z`7DfPN#nmr!(4#^qfk+4`&yIG7oKq=xMp5YKi9Z|y3({!7p zc8F4Vg__3`!2J1r)4^Yu*^*EL*t^quHiko>^v32o()mYOQEa%(rT~;?8C39lVM3S? zrRrDc5?+19P!ap<_D}NfuB=D|vA5tZZzZ6oH#=*Shz2B?i_lg3J~XgJ)Wz z7p+8OAUY|<)%T)}er1JB$7r69=dKg=G{$$0ac=g>A=(AdUPn>&Z%DUS01lSYWLyJW zw`Djt37-Y`HAcC6MNGXMS^4WByp)T6D!XE=1O4V0)1;9*M{y^}Y3S%fW&Mo|;J-Z1 z8Qaf3%S7s#N}z^NKMfa4eK9OTdhapc5xC4@_T8d~eItDsGnw#r(_BI3 zmey6&gI;N@w7?w)A{R!O$(nY3qnj|2eI+f#^=nsGn|o`?&P{|5w2a9#6I!hBj(@^3 zh%L5tez|=>RR6wA92JCwiU(NS0uJ}=-7q;Xd;l#nAp6 z>+3u4FZLMe?s^XK&h4CMIuB6&q%bRhT^&2`j@Ia-is-4yU!Vtanxqj%J8n~}k}w{M zx!7CK8p)eBnFw^IuYi-46o%alIFK~Hp$>sdCKf=@dNmu@pEHRf@Z=icS8;H71LK{T zMA>7)Kcy~ps7vtida$q{c%B5Jz(&dyL#LC;J?d2<+l>Y)V0&KlsQznP-3rtfi6a8q zvXGyr6t3PKVjp7})L-}AS&ROV<+ODoZJ3fnb^jg1E?Vj{c7r?c4}o_Y$Rh#gDdyFvX)uPtjr$z8&*xQMlT98}s3_#DF2Z_RJuEIWw4{UY%LiSZ z;%i|Jt&CYlt>0FDg7TCS7&z1}JbGlLPnTKff?Rm>Igf~c+;G@uS%3TTs7psR&h(P% z)By%zB0(YxCIG=&m{$lq@=```07J(T-NeL1(M+;DMsCj`k|xxI1kudtBMpqvuDM(m zrS(Up1ANqDO;E$gFT;btuTa(Uv9|Z@WQfq27Qw0ANyd%1?rLvPI#fLS|9nhB(K*kq^O+{#f z+_Rg{^AmG01exkO+JYyOIw^edO{b@0<7_8$<55W%aUXgxp#XZa75nEDL#Pl0bH9vN z!Z?7r6qu=*Q(C=3%>RX)D5@eVqew*F@|yjj_W7d0#oH*zkOq6gE5vl zRCH7?x3)xq=6Dfs-?^kb3!ofm)d>p03W z?O!4gv$M!X*%OhUbhlJ~Nq8i5{}p1O2PZJ!q^K*%-t7tqnO!L5CL2W|-g74TTJgKU z9b#A#i~S=}C?gCLwo-vx$9_Q>zzwPH3tx8($lSzWhey`QFqI(aBC=^)IB)ZzppK>B7?Sg7Cf68-@OE57uLPJlKFuI3FBav9 z*ok=vt87U%HNR|tIMFrY>`Tt9MG!niZC^a+xMF|w*z(8}=sFzkmm4C4UDv=;6fx7b;ZLXf3qjzEDDu`2@w5FSU8%IJD3>- z)4z`G95~^;N#XR;haRC?7HX^XV$E0g*??(L{1n-V~zzZw$rH4HtB{`y^fmn~N2P7)zEVjg`S~0WMP}a=@mbF+`FGudP*=4Z#04PN%iPjhLA`) zL#naUraRYRgGcpxFOC~B>zVDO5OKF+WZ;oW>}X>9`bX4SJUht2PafZRp~P}^OC~C$h+%@&P&3zhU#}uVFnm}u8O7?{#Sut}(U3K=^3|QC$>cIT@8RTQeA}2>vtM?5{Ok@Hsd_rV_1d`SG=2lh+@d)s!D%&4KZ74Y^NNV8`Je|VFD87I& z;lQn^pwmDSa5L)ht)Lp>-Ry2n+DfANA6OV_57RdBAmND%F7&!2FDp5QL!R7?S-Jep zZzdjo6+Fb+ycanP4I;;kL-7VY8}(SRQl~cud2rd$RrAz5#44T*IT**+5h<^t#0l6# zzkffh@^H*Rdh!Tw-EXQZm0+X_V9X4pJ$yIp_r3F%JZwGY(B-59jvTzdb;Q!3sAB;? z9@8SVXTR0iY45l0MNaKp1|nUJzCU;hJpY);-XwzXA0WsD#N!M?H{P)%hKdf9^nu3) z*HlJ%Ng8?oU3I$S)x&O6`H~&Dx!2vfLrY9mlx739W;NNFz3uiu<7)pZ} zW9rR)aw*`dN1VCut>A`{ujS%4CG-#?L_g?EP=O?=9-7KDpw5&S3PhCU zUeDkx)wWSGD=R6v$!cCdbQu&lJyYew)(nx*r?f<&E&6T3A>4om3oVXw%50kt=GPr4 z{?p6059d7(jG!GN(~7z9N*dd*)K8JCft(Vtz7YGW3Iz!eZ@ukc={U^K^*k04R`7;+ z9oqbx6jv(#B@%TZ9^L%5YIsRg>;I|X{hA^tZ&6G8%g%=a>Ip4$eWOtSaKtJaDP$m3 z9lebly*0wA&e3E8D@^WTIA+#Z1&H+%)c*`Sgqsr04Ly{wn3Afev(xNtghV`KvFn&u z_-8sCBgY4Q&%Ql>&DzDf@eG%GZ-ebJd=JJ*cUZ8NgfY9vv&o`$XAD#UXzqL42*2;A zCta*Fr09=Qj(Bo7V62Iw3)$007QwYbr=vtx@FWKr&ynG((fDyme|e_Y9^XWC(Kc)Kq^hX`v*EC!t^ zD$pod8oyxuTgI(t4-?+Uv2jY-965^_QgO(%akybe{_<*Vt!s$eMy$@I&;yjhithy_ zK_H2`S_ejXd#d^Lr%!jl-@IUZbu3s3Qz{3zyB!2@U`KYJZpJ~&#belE64IVO4@M`; zVU-1G%dzm~aAh&cl(15|a@MB!?MiT@u=s(6KsKkB6O!`#Jsmq=Uj+Y$^XmA_3xx)gAvb@Va-=Dmb<+$;wwjF&x* zwx^iZ{9$Gn6OO6}eJ!23U++i7s(wIE(e|toM>=bU)z6%w2pB=PuvCVI!0We1Xxr&0 z-uBr!oTvXfZ{GGeug8NN?=hdaqo`59+9a>1^=sMHK4XdPbKZ+~{0LXNVnhyXdOxEMdi<5%>P6M{_b|}L1yPS|$QN<8aY; zAzw3*4er)5_N1nKnHn?cXH~q6J;B6V3Q2K>%!2kve zg8xU;RR=}cz3rtzknRTQ6zK-(ZV)7;yStVUX{5WmrMpX{VG$&iX6am-?|HwO-^?@2 zu>bAZbDneG*L}sKMdL5uzpeFup;S*Zcgw$6OX7V-=ANX|VH8UZi6S z$pWdh#U`=uS#Uk`{JAU40kg*Ro4FZe;+=P~F8eG8#%#aCW=lc-Rl-CM&zcE@TI@!f7 zB+6Y%>4Y=W!t(3|YY*$URJT$L{2p)A+h&560(b4w zCjX@lgCIO6Re8V2D-m^Br2H>+`j;`I~~ZiO!{fmqvGHm_Bc#aS&3% zi=?Mzt$gOlSIcUdkr6UnQixfWnJZpd$)Ek!xm(Ff@YY>4HE*==bSN+S=RU@|-)^ej z7CbYEP zItQW*ur>eq0S2I9HYJ>hg|WIE;T08E%z?vRL*!W(JG(vUYPP<40-qa|>CYI7+$aU3 zpF-f7cvbVude@AH&#z|%G^Y1f`C>FC3X$LC&g6YoR`EP4-~g|9rCDK8Sz?+8wbe$a z%mBo;LuchhNK9z@fnm~b-Ev!~I?_bcqp}T@AwR)HW!zCw5c!1%U}O(d+)858*2qL=;S^cD)o6-0s0N;p2SbXu z4rJ03WWe*S$nUKVPj#7Crm|yy8jfnIeY^9seP`d49JF$oDqw^_@9#UR`^bkLi2m^A z^LV+-h)nuDw{|MOdzZ4%{ZDhBBi7B(w%$vAm!00Ql8O@q_rx{wav<~y!#vM)5^q>! zfEevw^d$`h5IIFdO?+-%zn%q;y3Y`2@RPm;iUMHBVO;-BAimt1mS@whcp=Msu+r+3 zP13-iM^W$PYpJJ-U639B5I*o_;2}e#iXDcok|yi}So|A;54QHzWv#aMQ!YWyu>x?O zS_2uSV)<6J_ZvYf>o=qPyf?VRxw>!C5$xRnh)Evp0oEoNcvWzkwu9oivV^*3b9l`l zDXLN%II9IMwd{Cii_awR9$gU2L4qjcu8oE9qFRIM6$*NB-1ZUT*?zft!{D&qX+fKd z($mt;H(?RA7dBm&E<9C~W80xpcZcNsTgVJ6RG0{1`1$9Ydc8Qi2Z*LH$U!NGX_ zPjf?9+c)(uNFvXntmgyb&;7cczEThyp4mgT&|AB{&CT}}oZe|Et*TK%Btlk>=m9o{ z{qQa}*qf*oZBTX{^2MK?p13K>)LDDZ7Q%v$;pbDhNUE>StA&}NHRD&Rp+Y~ezTd1q z-AUxy901scrwWG)P{f@G9XHzeje>vY_!bc}x;k+y1=WN(5F=cCA<8?^bT7BH=~_S>m5ZPKp9Z4>Maalbo_?hD>Nu(jd2 z$J0oDkV}Nvx>%AaM^|?I$be~qQ(aD~7kgdNx`Y20Wz!G5o&;uaA_$y61l3Vs_?1IK z=oA#rxf_CSE0}*wi79C(W^dNV9f`mBeM`#64x0=W;`TWY5fXeLC_R*U`rR62_1V=-{!bqW@0HvAeN?fY427@p_v>c%A9>lrKc;vj zdNw5Rzy1=jtS5>R<5_|@R<2f*{TRa}ca|#7K z2Ubon51pPVqhN*oD=R|(#h>Q?xGr%^zgjyj)xj@Ej~%_e`MIXZ3T-N)BZH!F5@WmY z8wnx@+CwAwCjPCJbNDVkWe`Oz2NtqIvbaT4-B}HUYO_OsY8|&Mt&Ka{4=U*+kRUmrS@2b8frPjV;u*0k(j8g1%k73x+?DplR4@en~swtrrsrP_((mj_Z}vJO_SVvljD<_LtCkH!C6 zZurv{_0^qsr;GRpexWpNI)QdL9%1ke)MRAB!~1fN z*IL-t%jdHZsD9VQ8j;c0{q8%(VvI%Tz`%lKkA8YqI;+Lk`B?Dav67qy1JVGPRz?~zq#yg;4;XV!Zgas~)ad3Jc z#E@p+!l>;nlw&WWJ1gETJD8><^dr5Gu=30*=_eHy3^8v)h>W7+;y-#!6l3*t>Fzc9 zPlumsL+&Nl5$Aysv4R?tdO7u}@>;laR{2_js^luUHpjtHZ&~1OXzx?5B}pTj40d>A z5w;oeN4Dxa$y}~@HdYCCbX5v+X{GWLDWoZ6sEh{ngl530JHLwZXPNu=NSKmqw!OGf z;$+L!z3JDN>3!sSCV?#vj&^XZd_{+_%_rgZt)hwZDihxmhyETTTSXz?9j>+W*1qAl z&X3r6x1rWswwykMdAEbsW_9nDtf=x$U)rep(5QM&hwdih^0R8+d3{ey(}iFrDo9H{ zUmx<;)YVl?q?GNVhk_n;Z~qRjFuP6FP$F8q!IgW+x;4Qu-ue5zYu*~gb5tP7q2}FB z^sR--DWaeGd3MvicTj&OhUAQe9Pu-(`w849)1EDyYvShx9=%RiX1qombz zO)(1-eoi;?B6+!^2o`Cvq59!Iec>FuQ+hYeC`uy!1kIPIU*$czR4&0APq$(KTeoj7 zwEc@$+eCiaqWWjc89#PH@+WO=r4dqJ18Qj-%!4Pn|oj>B3-$$^1Q@1+I ztt^QRgng1|?2yP2SlB~ZS*uZp4(|m~2C4h=c8#Ec^Y#mF>s?Isf_sq*#9~VPeuAf$)NEaNZsjn>5w-}r#7`a! z5)`rmBgri4C^>-#R^^WpM)}*AH`oAzcewKkOb0-4Z*++ZoRli6rf?w$$U6_28MyCL zyFI(HY8=(`Q{uTAL^&ot0ElV0Sw)Gg=kI{8*k&o?lEYq)zEhac9E31QEQPJBgH2ij zL(t<7P})1ZVfN1Bd8LaBGO^afs(ChR#S?pGuE>J$4 zcfdmouzn_p0_P>=c?mJEi}dYx{v0D(FN>w6w=YvjS7y$Ut9|Ec?azCw=cU=sLxCnQ zzmSFPtpNo~@q&JapJ{Buj!2>ed=|{!R)=s4am@+I)Pj@GnCDA2;FzOZ9on6VG|Fy_UGTI^Gj+H)Z_m2!StU!+9YjueA%I% z7g0g>oF2jH{!bHKojzk^<&vKW8<~(ik(6CuELk8xl56YQ<0W%q9YJytAz11BMo2_> zaVviJ4oE@tVVtX?f2V*uDYuOiv5iBRPUt#y){W5jShqPgCU$=@-t8#szez{Y2|E(- zI9s|ngrN>tF8%R$In|mO>qyT@C>PoPa4hDJ<(1DK&#{j7UOecIIG#c*TG;soH=fcD zA5iUxQ??)V=Gq?f%|f9Z?-}-bYq9s?A!>O5OS!rW8-dCR`+r;jr-E(;%;Kbvghhn1 z@=8}NIV!S;#Bmkz223WJ;uVbg(Hcb*7d-Ns>L?iv9JSlb6^eP)6uVXqcNlb>&JB{j z#qn-Be|vHP4?JF-=Q;_C&`xq^Gvc>kw`j+fEZF+uS|+sA+6>l>5W*aVa+Nno~SfiL+yP{DbY3p=O#jF(aDnHV*Oy z_Ok{R@bt7Nq<7!ZF9-fM4mj_`G8Kuop08*_nzUxyA5PpBaJ>`gy{-&K41&$bP@_!u z>H@UQ!@0XQ$NllT$nB-`GMNu* zeZx$B8{j`z1(-7V^_*rRxErz0PK9)UP?4ygU(TK=Ieek?-|bUD5SXoL9+BXvCU=4y z@i4;mHe6?M-h=-<(*9O?@ZN6wEo=h;!jPiJ{+#0~H^A7X-N52PPd8ZHG2UQ6Q39PRKHZJbF*#epnY$qs^~8qFe$@v|BhDEIC+BT zDcYtT=BLg=ddpMLgZoQ4ltgqOn%5zvFY}?qcAe)M_8T)_At{#U(~{amf!xBp8C1j)i7$vFP3Z_DvG<1LleuV*ODJP`^=q=tR(7Sw9}B4V za3adgi3;F;Q9`fVGJoSSNIHlNj-MXBz2di3S>MwdQDMVYM;TwX?YKdUm#u|6DUdt5 zvU2e$bo_4V@OvWAX<9^o#+U=Y51lpc&$pbI#}7>TR#Xf7XISa?WfWrOm%7A(2fx`< z(J!)d@U7wNfB!bK@c{PZ{&Z+3TC5tPdU+o&8Ak;fPUx9BiiLjFDg19o?jvL{btJY- z;?nr&ssAYAxtxXts<&4r-}%EhvM0yy`I8TC9Zk}6>9%uS!K+O4*2{Z)RSy8IsHQ~kZsMR(Hsl$jTfCJ#8dXxiNAr0_oKaxL! zKk`asHq0n*)Dh>*7Uwif^OJ^pde{TN zuXpM7-vW2q&i}S_VeNSfh4L@>6U4c&8sUFc?bGb79`wkc?V4Thyk5S12dW+YJJ%*H zH%}-Na&yDWKgXYW+5Fjq`@V-Xz?bi42?a3{z7U@k5J+*;+0&u#Q}@ zU_rO4Yvy5srR^X}rLXsWNmdg7obAuDi&9f{j{h{(Z$bFQ|0}Cof4!fmqL)0?KI2jK zI;8o~bV2R)%LOBu26=o|1%xN!kmrEuX+U&KuZt}CcMjZRD0D%aUt8%OD|^e;)}&Fr z=;pH+Xr5O~d(?;oGGlJOn!f~uyOs1hzXz5r0J?)c453uZ5IeF5Z4j-H+PZx8ahr~5 zqUWFvCcN+Fwjm}bxWE-JRNv6pkiaP?=-SP)t722PYvv;BcVft}`sRFob^UCBV_xBX z+kMT0`H$`3d6>;3a1_n zPqWv?#LmVBln0oO7r73+=ppq#cq_)q%LWZ6pc5gK8LcZ^l}{-uKh^$bYEB z*Wn%)>~EGz_@*Y?c;A+-P(>!UtcbyduC+5?1vO

    >0QaJpJFXsf`lSz(7s5^pi*Z?Vp~Z+cfip`Q^#O- zMWKmH;-?l+$2hnmNz%OgoRq!Gz&}3K16!Zj_&i0mxY*+1nJ>0~?Tg0Uw;#0Ouj;L* zC#thv-g_f*!-K zuDN{cyQ}pI@-``je?}`Yr4GewE-Jm7bg5N0dR3|69>1!S$D~s~S)Sq01j0+St@2)p zAz3;m?((K2^Ww!M0UChDG(sJI4jv__1mZ!d<{@{L9}ha@k7BuQ^+-XFjXG6=oTAYy zBe*kFfLV8yrJ`Dbc#}btY(UC`Suv0$f8kzPm@p7Dd}TSK#9zhD&d_Kb7{{n^qslyc z6o|gIuvY;1o6-AR#F*4P{mAe)*s-Uq{No90KKaMt)#iO+?fkO+hYUviL;Us}sNa8n zU08n%MtiTO1Q^6|O^ZE}^N_|FYOItMVzA9Akq)!f<~^m7tmGp?u?yHI=^CCh+EW=rZ1j>Psu8(FbQje_C-($uG{J#)@ccu;43-jh{>cHqrYkgs2m3{ z1zIHua&0hP0s8uXz8pY>QE5?Z;He3_y?5;}vF$#r> z38)f`B~axHiTetTU&Ytt5$xkyXwH$?(RT(3Ve!ugI5?OHvCo)4v{>|1*@=*>tLk!- zk%rkiXwOn$?sG+It#0YlPMv5~(C7%(zfZC32G)Y;rs~tri6-~R#WT0U=LjAJ0O(iu_ zX(~WjC=M+aKjr3qG$rav>7T9I4=MDpUm$UFkAZ7^nw#lC%)PLD4uWjCE!2J@PCHSVrbp z7bC4YK@~w&-Q)d8rhA|8C%=dY!eUyJ_K7K79n`txuf1IhIM8*IC5-}^E^=@Dp6OUi zsv#%>q!qr`ty${mH!|%4~DTMym z-MouysWJ z=Lu=f5vY1Js3bGiR1@hvlTGs(j?o8H<)Kl2r3i{8Oegy0QX!pMO4SP4oC3Nfi;Q_Q zHKg5&rMQ*L`hlHL@rfj3!(uL{gI%I`mE3QnNYQONOE{K{SW>s1QDuH>ml}9dh3l~? zEzq`4exbj)SdLpE5@9#c+=tUi!gb?H@;mMzTl-BWA^hzt7(Q8OVqu7xM723uA|eA9I`KXqjW-|Cdq)?Ycc- z_aLj(t^W7l8*iHu=3^LeK@Z40DzsTDcNc4G^&|Tm9X=6aRXfNOrpjbkzKlt6rYn{L zdS8xW&B_AJD&QGpmJ3d0F}NYbtf!2n-$Xo9rx&XV%<8RP=Y@S9GiDiwet3Um?+vJ1 zOMaGkWbTaO&&rhP2hQGerxUsQefGuJ6;X??YZFi~y2<>ep-Cie)FLX8l}i>k+6TIn zRxXr7Taa9DRf;0mE0V}Xm@)-KQH+?xNw~kQt4>3}3`9(iV#y>})T!%)kByz3 zU=R<~ec~NNb@sI0W@g^a+X)70r(u=@0(B@9c?S)P&3C4^4YI%}kByVO_X#;~z)GrvbR(sJgNoJ>7e5z&g65kH}d zBM!$CuScaP`H9xizG~eCG7O=KnTyXr55#X;UiMDg3wC!D&^(~NMG>XsT2 zZiEdu^B}HO9>Eu7-r~!#+bSPDv`7_61dX;%Fz)u?#}0!zv5vAW#>iGO@*kq^PNv^b zCl#J5uQFu(Oa|W%-`=J*Zsn%_x5+vNau!ncjH7@f`*z9L-_dN;&E(;j=to0C$PHfk ze%(=yJ0)K2M#w##f~v!uF3TT*=GXTe9p{>eW}qeai~cA)fqQu_^g5Y&D3k@0QUr0e z6$dc{|A#`UEo6ToL@0aHqvcYYm#N!w$s7kAMfY}lXY}2LbMzJKR)Koun;tRW-fe3p zJdDW7Zol-u{H5ebiqa-7k&WZ~--qAaB(E==%}~N;v4eFaAV|a=>?CS;f_!=x<}}#s zAD@jYwefYtsf3N5r$gr={RBq9z$bkc`a9(^w;X0u4#+p}N!f}-{>p@OcB*v?sB@-I zxOUjJkdl38hlePoz2(P{6p&zq?)K?|Y&#~t!VJXr@`-rM^OSD#o? zflg#=f2P#+c8t!$iDKqRX`-#JM!n>0b@ekhz2My8Vto*AUEj+?$5GqpoM)Gg%P4~$Qk_EYBr1K_Jhrii3Ht*HMaq? z&W|;N!M$nSk1Grq*@caD@Fn*-A|_YOg@+VB;cudw*|F73G$FiVOEDk5sA@HQgdF-d zb$lsv9HMWK>rIOV%*4K26mYbnYOAM9=9}yn7*{X${aj6eTW_uPyqBe>fC&Emu*54` ze*8sZ{YnIKfXay(r(~Jm5+mJGT8b#P1Ks0J^C9M_TozBLZ}%s*p}xhTpUx zIC=8e{?KVEs&u!GSRg;qxV~H-8oyoe$00<)iS7meGd}sO=+`z|iNN;<=GN9@+Ab`9 z)9!g;dOc7b_ay{SISSb_$r)`4KHS?`rlkv_{C0xA8~eVf&raPP-}&|m|09MfDY=Oq zi%O`0S{-HJI6&nFQe7?KS5)qBvc)vyV*@rkAB+F=19A+r&wO59Z4JG>V($Kc9&!kv ziWx4A0Nxj~XIOxU_eXDUh=IzK!)TDbTlZ0bc~KP$l~D=DXcH0Ei62?rK7CS)i>)vm zG#ZlUrRrTN#eij7V9b#k7sD(F3qQ3hP22xO1NPGO^slsF1f?zT0Cluul?Y!9yeDtG za9lVu$>-#P=^w&S?$#?N1K~U9{bJ6Y|9_X+*D^?1H1=IJHzxf9rb*I z+3cw@ZGLAt6k}Io5YLc!*)@$Ti-y*xvFF* zUU)Zt6gPfT*l%>4W8OB@4gPx)=9PQy!A@eD7z(tlKGl9DeI(1N#&$J zQ9`kJ7Z)b*XzqXZ9AsjxO0vI$m6mw+=yOnr7v*10f11a~d0&`NpYtFz+8dK(IYdk7 z@MVaBu;vcyj;ik==57eK$>Z(cG#i3|;=1z_2LydIrc=>7@ra35EDg143XvUpN=LlP zF{CRI&+=V294qX_JINP-JK*pH@y3LXx9MH<0Nxd+>W zJkm`}#W8gLAmB-6Z;WT7@q2nNh?`{eaBORC_HIpt!@gUr4sPx-`8tM3ucI)B97Sfg z-bYF>OidCRExWo=(pC>;Ay$V4s%3($P&|<#m(d!S zwEcCJ1=Fi6sTtb;1TYm#H7ARe7r>p4t3N!bCqbU2VROE}u+TD0F;DZ#>VMq(7_2nm zN}7jXWMdp-Onw{E(00Z}nk<;^4L4)LsM+f;^<7^O_;1Z>H<3Pma-o`N)M#`7@_(~` zn8$qj(N9>d*73l6cefb~UtL}8-Xi=KsC{xgf9wAWb=4^7m1i+%Fs zrQzwuk*00R#s8zHCl2K_7vABW8F@Y=z*7YfsqDLxw1sgHQJsB03}0H**VaYi*r9x+$8i z?RLto4=6Bh{l(R{6KVOhm=Y$hr<7U z?9DgxXi2)ALox&@z-bv3mOTd#a?U$ z7NR;^atPpr@$ld`NG8!Rs27>w9eJ`oC70^I(op;OgZs3|A=Pxu&Wo&-zH+7VQ@G|! z0=(ReI1$xLSHj;8wLZ$%hkH&{2YcO406d_F@kl-eW_wY!6Z>6rP?jY&I|^rxIy^M+ zqyueI@f?$W0It6LPAg-$X=z7nm5#>Vgp)Us^>mH36&>U&<&A-&cJp^ya%5@(vJyI@ z1Q(IKdggI*mU6?dBCiPg-E^`kz6%c<4(%AoI{@0bA~AoG z>g9_7f2adlG~KD5>!;mP-D>6tg*T78ZufAy8Jol6IyYU%uMCDuU>PN7-H{CJ;9}1@ z5wdHpE1M2110a-8$AC+Id<3s?W?sqz*Nc?z(TLvd@RdAN+Acjs-cW%!!qr3IBc%P< zaLQ>_;YKLIWA{<)_tFy08Vav*Gm-9|TU*!XNEv^PQ``UUXksVyo6Zq%PUXs{qvE9)=8z%MC8WigCR;i*T{l}_1) zK1mk5m7->PNyc)NS#*_ZDqffRnu-nUo03clRl>r;0-jLqy6ZtLCFoNY>q#xy5w`*~ z)L=@NP6mow)*+_jrqXMl0v|Sj5kp5EukgLhDgBYoUh3}r13R3~ng67dHICL~ZiviIz5MN`2CJCam!jn^8W`N%=-(qgcE z3wft60tbB)oK$N}9N}Wb2~DoEVx%6{js4di@x{9>CN9p?l6Df_^M1v2c5HO-m_s=y z+D%PZbh%%26*iW34FB_;lt48iJYl<(2i-&AHyU`-K`ewjGZ6pv`IgDEU^n!pJ~Nv$ z6Tt77Zcjcd<)pXpMYoQgzn?cQytjE!j6uGlJuSu0jPUVChX$lZK-TspiA@93ZMD3; zyc#GO-~V!2YW&pCIp(_6r&yZg@=bBq0lq>j19pTKS*D)^$Al*B*8>d<-D_~!KRG;^ z=qul8N_p2Xw>&7?6X04f9rkMn&NE1@R`(H?PE-4|)iL*9)t5RUIPFvckjyUN^hMwa z*00UeuAeLlvi6M@R0F9kYc@aR-f+eaO>qd_RH-;1qL%bZ)rMi0fpj-$&MBP^#&2Y#N@ey^e71hJ%J^@2MY&dvQ>H@K~*>6-n%lmBG z`^LALfQO@o$Qfh4Fnu|K>5=K-rS~TG%vOs&MOnJ8i+#Fai@)m&d6*i5q3+Tm+=sR)?mi zFpd&baf@xcdXRid)N0-_1lPyMt$4&RuhJ;xtCApSrxhd-Kw@eMTFB> zTe$OP{be=6zOs85t{II@6Z&0Yf4l!1QF}#Nm5tsis^rB^b$)1H-*f(tPUj%>y8#I= zG<Uj^B7v=SAopE$6j;s=>9WQPCtRt1nxJ_WBY1y2X`d?H(NjqTHT5 zW66n{IYGWTq?bQHOXrEh7PXfKF}WKg>ej2{FFbE>^k=KKAfX?~HL2Fk6=+-ruxso) zbQDhpnTe{skx)NI%%jT7dWdBI?Jq{KpP|5|lA5A}-zKBU_5gA0iFCds_7)^lZgNpo zQb|eaKa|-p(tm}Y{}h=f5;iq;YO9N}hfjxm1^#ekQDz7G_l=UJ^bIC278p1Bdt+^8 z@jk^!{_9EY-RbMKsQZQgSr5$Sr8OCu>%RA=HhBeS5(9!8q192cF;2; zn3Aeh!LLrJ3%|wB+-vs==4?uoR+!DDP?Jq}e`b$o!?l||r9y!~(5Kr{T{%|ju+rsn z)h330%iW`k)~_*$DhGgw3G>=?Ks?T< zng{0p>X9tlw&7<_LwMrtuu+(8I{nu6=L_~AR%R7N_+L|Vai$CuY2t`; zTaY-a%R$bN&wl<3jqcK3G9)>~f4=$Mah96}Q`=HOFKpiT1-V>BP*}xe`BwS+pxT>! zynb?gHVNf7fJe4=^;(rkb{kKXc2&g^S!IFhvwBAwG8B<*h}2naiRG}L|Nc+IQ4@pZ zzd4LWnXi)xXprOxH@l5!;MaAF0beCzLUUCa6D6513Q3!QsBg*6v;4vhx;vQ0@*Xu`kquJM=t?RQOe=i0e>sc>uQRB z8^F(Vy7J6F!wUB?)oB%AJlWDof-OZd_}*&fw;1G;&+ox|C4LdU{6#p+iE-9BnPx_ZFfJ79Y35@+e+_o&ZS|n?z-u@ut89<#Qz2l? zqc(OZ|9wmb-z%+Mshz@P(-a~^G|J+VW57}|v;dNS*lE)~ZgjN=8nmf)hUqK&p??m9 zr*X2}b7kGL-|0PlS0xZj2hO3dHc~Zy{#xA(}@6C2SjYmAazAvdyx6+W*tEBtsT!$^@FR9n* zy8ev|bdeIgm{eG6YsZBD&V&%AkUO2kBVF!*ixT&~dQ)dZnq>U|bDkJYs(n3(NVw~& zt9;#M=Jwtn-Y@&_#9 zjQmBB$VN+U>T-O^pBTH{v(}Q50a)h2u`TXcTYbhiVRw^q;=FigjH)8wrfH!s-Dv?{ z_X<7UT&R7hha%O}wjdr1DP~T<+wD)IpDXUwF5<5SZ%RL_!H#>VhDlPjN!# z%abzB7G(Lx&4?wh^5$YhsvZcg$p}VivyAp=N%J3G zw^_WOA86@rbXgCF>eCc@uUZUF@;zU0|3l}*&?~4X;uj=)3^^2bLu5jQ(1$u<1y1^e zzjih8XL@2aE8%%ju7K9alO7E{t=sY?)+*2$+|`z_eV*8~P-h7$;Ms!Df&oR0|Eae>DD=cw!d>?ziBaK~#_AvJb>aUyQ&>9i*bT*RjOv39x?o|q9GF*RB~lO-=s3|Z*=pikVUwIX8bH-lPTTG|4TK@Sx<-7YLD z^(s(2dOeZv_ef}Gq;P$FpI=R=Ux%S$1w0-&Xo`0!r;*Jc5vbOrC$+cN4*cPulkZhU zXX*)%pskL@hIIwH?!a&aC~`GeQZ-oqxRQymW#XM4Wt62{!3)RnGbnNHF%mkjgqs83XmT-bY?)7HYqHvl2 zo&WiURPY&*ut9hZM`y6T#@K%`fM!CHl3H2kD6LCM5k@kd6&7vMo=xE{=P^F51K-lx>+Xm>uScAs_3rNsRR{@`!IP?D4iGA=Al{CRndF zA$d@9s~v;3dfY8F6OJN#!}pNj@N%xZEGU;B7mhstb#er3CdB&_V|t#1iOl@ijHww> z4+?uD&T{vgwe0&#Q%Nn!ffx`1m<&jWs+A8GD&LYFaSNr1D?hQr8yvv|~drnHI-ZMj$; z@tORh9J$#Ja{nk#OQS9_9fg!~aHMFh&%*ghttBTN{F#dC<*;*OlEWS_#;Gzf;i)jq zUN-u!+U}GkNv=6Pg9&wbHEcanyetlTn4eG55Y0k9Fqtj=Lc#^PNMs>ze`@7 zDsFVX${(OpFG5{iBHTJ^*gnzf>!o^`dv+7&(*k&0ywrn2R4o+<)i9hsX1=?-~0Eb-~p!9ez58b+; ztgf?%YgL6?7dy)x!Dvga4oCSg5Cl{;qaov0Ys_0E)z9);Q;OaV)$~c4ibzN|H#puI z0CMSxye#B`N*Xu%E8tDVM+Lu2Qf{2@sIfe8VQ>(gA8Ka^rB`S96MxgE#ZYv(ZJ=-w zglN#gAeQ@=(u=lc2$xml2Y7&P@uCNMqh3Y*_NT<#4EJKrHvnK1GuTLo0PQ`qhtbY0 z@u;Vdm7}WHFB6nv^qJ%bTdM1E;4%zU54Q2#r(b(je&7K0BaHtH2&Wl2%+>mOm*oy? zw$(WjqFC+3dKX;NSuTTSW&BvSIcOhr*7COsc2EdUIIuo;I;!@1r}l4J_!Kz86n3X5 zlJlZdF*O^R7N@dyw=~EAk#vaC>s#0Isnb7YZ*;76ZvSSHv`a4WKznfJ+=kM=hn=Tz zf3d#RLUZOkew+too`b?0J$pq;M&yB#L?z>NBRQ1sB5_5vjvRd5NSKgG93dQZjaYV5@%tkSOr?ruZlk+k!>M`O zq|Qx+1lI037d_9ZWN%~_gUwJ`9a$fzba}cyz|rat)GR$uyPRW9`On84M;*@lh`+ym z9zV7n{>bd6*0ncQH~M+wMwe%my)1OUp^3d<>1>;x(+}-s?_KZ^-RbO5$S5g!7w$=> z+^Cz`yr|LcRQ=bqqT`hKs+4B7H9{-6Obj{{-N_`2ER0yi=G6hDwg_; z|I+g~77js!Ozdhp5VsNimxc9(G8*JLbA=&k>7h<^GKOGtIBInTgsQK@yIbRnXlY2| zLVN{Vm>UE%Hi{2kmgjW|E*2yL%lpFQT2)SM7ih+Lmkh)B`znFUH~D#iN#E;(f0kt! zwy>9)|2)<+$SGhmPQYVFog6bA7c5)wB3$n;`f?mbH7sUL5|@OK?4L!24BW#nHsFo+ zgj`9Y)gDKOW2b-Drz9y}`%-#l5N--UZF9)4lGF<`5VFQQzJ>xm+IiJAf)#2TUJU0W zVLxq>^jS*j631HyzcJ*>vMV_1vZNwra1R-?{%V)k%!eCtkB>NRTXbsE62N)J1LuyZ z$IB>bOHuDLVjgsF?1V;?8K*D)sXH2>?zT~HV-rq<@{&Q&SW+7w0q`3(p)mac9$P5h zT^t4dx2oIbR~yh^=DD{OGk7fRS{(c;{ilUY)h|+6aI;sxy=_nP=sRPDLkuk~za= z;^@5o_%!}a42;g%i~XY?l&c;dPD@9#@eak|_{I@~P7{#67cEK?E@6iWSWNeEQ+ zm^&k%Oo$n;#cgn{^=mIwwm9$2UYezCp(_2BdnO`Ob=<-xqep$5FU6dvx|8BNtVpKE zZkTsNS7=!?tJ%ebu7W?CJ*s}Z05iN2*;N9$V9Bl}7!DEpgJP&(z}IsSw-AUE`M3{S=8-D%)0aoi+(-6gb`ev`n^r zs-;zx5Os@YHTUvoCcw)n=C+r=ALz#8=L=ST)F#pRXO&v06`Q{4ldTSEd!1Xo*eMs& z2Md0@dx!O}>|5W{Lf^2O@fC)HqqAjadE671U$Gc+F^v~;*D}TJkKU$`DaiJ?Afpx{CFwmS+@sM#;t)IfseH3ciW7+$*pFgww)x{-&7s~5BFBx9&(}7cQN6!!X1R4 zq7F>+Ots{#OrG{RxAcJ&S)admQOlz2r~xCQwg0h!O$krP*4b;$KD;*};lGIDUl-D& z+NXG@3bdO=izms@Y#AXec#}-FCL8ZIVWVB#Qg$9Dq$1*>tsK6Na?OZeqDCjvrwxwi zwYqpfw7`iM>%*}$)CYG)K_~-3KHMPASNj3<>Bp=Mq?G$l$!YSHjCy0vQG7X{>JG#S z{ZM2Tm4gh}NI4vy8U@pC1rxAL38UIgS3B7-0cyP2Ofy5$ifYq=c-GV^_>>rAPs*hp zCiSJ-b$#9kY~;ti&wmjPnGRki^M-XGs#I7>{Kn1%p(`<%>G#{ z{c1A&>ppmS=i!W#UhdLC2ix{X-ZTYpiY3GSIm?5cMhNcUFu^N*Oq+uC@}9qzoWm1A zhr8!9v4G2lchIw{AxuhbjKB9bZn;QwO4KpX8=<^atys4DuH1W?urF7uyeZbIiL1j@ z)z3p7DntG1Fz-to(J_|1TbL223?iH9vs7u;5nC7lmw<#oGSO+L^5mBfzzZ*&w_oWo|u)fNY&Ur_PitNp^)3Cjy*$#POQKbSH?iJjHl8ZmB#0Xi+ z>X{9c{-%PV!hd@a!}!Xz9+xLzN)!P?8G@p1Dj(`sWEAn+8AuT% zV1TiaNTuQBdKwPDFkHV}q;347eP5$hvpP5KCkTD0xLKNtb6$!(JpJ?^P@?zd2ksTW z_GSHdEsT+{KNlnT5*5O#t_L`ezpfsz?oTU&LVqa|FwGzOKt4}ZccL6a?jRqp>VZ;f zya?EN;5D|1{k!c$^9b_=4q!^k)*yy$UVEY+)LlO8X7kb}X)LUJ+&TU`rq#{Di(uM# z!jNQI0q4K9j9ywQxtUmDA?SK%*+MTztbuBmPAHZAv!VD@lioWUF@>Iev;2I{AQofm zRNTkL7*ls?3_(6XVh^eeWI9b%IP+!41dM`rx?t}XLL$n?~wCf+a;HPAUiDm|DT zfAN`RLYU5~DLV{F;sfwiROoFZt5{RS$x{pX9I+>FQn#I$b>hY!V0>yD? zTO2#<3pjFWGb7+^`G$Q@?WMt{avIKvtu6=EBx^vF?%|ETv?v8pR^d?*u!k_KCT|j< zNspFN37IMZ7r{;o`~>6&+&x%chj?h@;%&2j9>fj3fgcwC&azMF=~ti?f_8;+vBDu_ zxQNAG2@WT22B0FQrV_uLu^K`@cWAiPe4SH^^B#g&m(Pby0}EDDY8YW811wLR4u%y{ zHI|79_oeIenfL-@;DR-YIo~+o^=pC)CBJ#NX`kZ0p8T09lS4|~@=?5otr8w}nUTa9 z)VtNZN9e*|wqE?>qNjL5;{6;S6G(=HI!uP28JJNGdP#v-ki6MdMVDPn^(VxLqNQXy z%d353d^wixaiWC6_hxb>5arl!&e-kjy!4-h^V2VU{~O{bUVS>0)!hk?zfOXn zefbbsd=`vLBhlGd9i$e~riU)tKd5smrp1}J^miSuG+`p}I0O~Wwm0QLguZ*xI+1T{ z#NG7#3yOO7XONf}wG#e)|DmFXRIvBAZ3g^5eGhXRKRYDair-P}4o0J=&`kxlR0YoB zpON7sYGq8!{xj~UQ*UHuCjML9aXCM3kSf3%l1K3AzTMea6W-i`;+15%D4sWlw{gD7 zmn4%z^a%Qv1a}4=J{^>m6|#So`Oc{DX;u`2Q^{5W#H-*PNHb)^Z0vTV9$-_0pAJia z@lvcYU~v~pcAPPAWFKRV)0^zW@2-doKd^s=9+^qM_6;ggX;i(Q(uEvu-ZljDoq29Q zYF}?sefk~XvmE`f!RUXq4IY_R1Q{5M{fAw?pgSgofh#OONp7c%?TrA10CU&#taQQF zD`7p^;C|r6;Xyf_?<5l$3X5&n?a>jZLV>0D)g}t^@Q`CM=n2h@ov`3XCd~u(mx{+<5M1i~VKZ-NAy-4W-b)sMlg(#QkG2%;itr{7|ViVW%_Vc+ zAe0!fkMSJyzldJHyW|gEJ(&5SG)mit_$>8oH8KQ1TOOW1)6R@Ze5EqK8$+*NN)n^! zJT7kz@aPQC2Lav#Js)Y2>AOlnm&k9w>Xg5#;763Llra2^7opKq(d5*3KOO6K#j2~a zU=gq*8u}fRk3M;-#SHTMNe^tt{PBnhkU(cP0hN-Cl~^SMLL8 z-D%DQLR1Z}qLAXYVd+l>8Qg`LHB8XaA97f9BNRBG8_)x8SkLMQ-}Pyk?;%m3Vxvmh z!}r)Apev6b*!Z)fgK=sovvd`ZtfFf`HVE>17oaI)Dx{YIL|07XsPugShf%^RvXOag=vumn~&F zN*ViQg1f?h(7jaT01Yok$(<)Io(jqbnKQrVI*q`$9-j1P4KuE#ZHU=x%`>cAKoJqm zCV)rjS)y76ic`jFqogBE-oS<}9WXF?RnWW!++xtHML#W@EO9(B2`_pZ;bd*4wrEo2o2y387%E#Vyd6-06WJmpxI zBoagsuZQ3SH0AmSm5}fU9{a3(Ef3se1t~Yo@OutyOHg2J2q%{xL2aJnlEt#mx0Jp9 zCE-jR<5tu8rOfm>&OAf#jt zrw`wg}l<^$?n@zT6!~5r!GmG=6?D%b|?OKu4-Q)ah34mEGr(x9*ROv~Le>#{=FwNAT(k4U>|XDw>92O;2gaMxKoS_ia%mJZJE>vHfBDJs7qfGR7wC5T{C=f(7X zL-lVKk&l08iu6h0G$qBs$b6ZO6*}n?VJTQ0Mkr{-%IV5ePNYhY^99^kolP?MU_|-Q{8_c{(mk&#Kj+p*q6PA z%q74acMzTkF?wcGd893sI+j%=np$@F*+n9zdof<;RCbh>(PW~w>QDE|w&u4gk`k^(rQzqEe zYHEa+JQ+myTdPp3%D^cIQnr)8Q-%J@y0_bem9r)yUt1N^e0}z8lM+lhgpKgF_0ivW z+!6hQL#xv>^)8v03jJXj*y$i062<|G%7%u9j~O&k%;b4uame^!ybnpzG)BQ0zr$KJ z+Q`umBlD&)04gP+5sot63*r(vY}UZzb%MXaI|)k@WOL z4ayEZxn^1oJAPX2b5Ghmw?Ml(%>H^g(o)@0_zB!xf&z4bX(LO)$~&ZOF=(*@;d#$w z8%vI~>0~GhZNOB13jqjx)D6M_mt96wfBMjd#U$BsCu!UV0x^!dUU>`72mi$$BNdKeG6~ENH&=o3p5IRG1Uc>j#8e2dAz}_*i zg!_vB<%mc?xpY7krA;z?swaEQX?l!lRI4;uEdIV!8(D-JCxA_cqu-F_U9{ykArqcV z@ha)tD1Gbu`HxNAyzF}UcWTmAJn*u5`i=J}!h4G)7ol7#vPC0f>d*UK5yxMNSZQ$o zs&C98??*o0%ZCBH(ZmO}Kn<6sg^b6YYOyPARkeGb~0(3O0hwtnjM~nH-oTx=dq=|J&XRF zS#>o`-_~(FzG#7d5FOVSzrun+FDoe%fBoMp-NR~|x_#0_N+vTV)X?b^QuznyTqJdQ ztunUhnMR9A96v8Whug>UJd_dT>b6Thdg^?pvExl^|Iq>U!lrHxG7@cxt9P*YDw^%HC zT`}vMl9urna-6GrhDteLPLTc;b!5-r6Mj?^*|{*_?Sm^8W|}=Oi9gJ6-Mb*k2TTXs zneIm|@fqpNZ&U%!ESKz%dPm~MCt`5jb2Oy*Yq?SX8lr0TWJ*t7iF;QCgAH*Gt!_e8 z%x#QyUs2Z`u4*EgwDkFV8okw9tw#ZK7*i-b&PZcb$;14UE(=LU)FwG;yL*WKOY>OEgn#rHSJ&UvG z8eEjX#Qt?^1=yU{qQn>lzJQf?_Q{9bK28giHd|4afVn3>?1!weINch5*~eic-ox*@ z@e@bB9M3j!MGbI%P>%_7J8=B;yX;cwx4IM2cicDe zUoNe20+5FA6mYG){n{d|0O~G4gM8LN*~BCW|E-Z^^*Nt<|p^XqT zy67~Ij#dgEqj4{U_FX+hTxZpBoei=a8NWI-H%u}Pchx0^Y$TB}6!Y@J^jWO|%`@n~ zZvtf4^7f#GPfTj13Waet)D4bWG4I@&sqm6{1Oa$IZI=Wg47oBpG&E#h%v+*)q(9YI z*#!zeXF+2V%S9I*uKjDre?(-aa4rk_2v^5Bud{n589eEuu{f;6 zJrVWuTWIkP1Kux#3sE-i2+OYu1qm;|C2JF*3kTeuJK-yDGBCrRaZdOkFFhXba0`v* zc&v0)Rp$2Ew-OLZh+U6yYpuJXp;}Fc>e+o)YOGu7s9BBKS4DgY^`FeyVLqbHTLC~` zh{>-7C&87pp>%~7l!r{mDiPi4*<+B7#>as&)hxW$xD6#x$7c;Xye~K|$WYNDr?c-n z9COWy$V|Zs_O}g1DY=C3S-qK8UUb+R@todav_}KU4hk<%3dWD0I-g>EI<{!0ro%Sl z9|2|~P{dhOB8_f=@sVr=D^b+$q&( z+JiP1n$7u>>g_g@$>nGN)&8r2fx0qfFrlDpZIEaJ&NRI^4mECloH*dCQxX}A=d=kQL zs-WH(S5=iJ+h^Igc{LQbrndG4*E%{;F^Xd?en#Z!XR8=UjgkgArW>&AC+GvBvZPXm zVnT{hJqO%A&4d7U036YI{}WLjvHXYMVC0E#vBuxXG_a7~_WaFIB77Rpp-yGTQfW}ysK%m4Hu&?#P)EPN%K_TOnh##)33;F91dXP@=)_EKU~(RHKX?qJ9(jsh z|HFEuw9QSy%9|`b#&;dqUOIggPV2vUZ23K|4Qv=i09@-<`0qbLRd+BFAStdYxXvBf zFUd5yUezlUgdoSIq-LR<1s`Ngv8L#yO{>I$0^Ta;yw#2!QzJRde)-VY*jp_PQ!?{4d~^~Ujqx$4=E;qe)$*zy`;m_~%3hFkuU@A7 z^Q$NA>CbkM#qsYqe*t#+oL)%hGa!0)rkUHPfxPns<0*A0JfzsnduIQlYeO1PDq5Xn z_~o=!AJV|$6@H;hqt%7Ap0MTOAzE*9w4R%mDQT=UwG#dWivnT^rUS3$6#FY&<@F}y zt$6?qtWa030R)n2bW_uCSkU z>ZQCBz);$(a8=K@G}^l~#o4mS`_J26 z$blsjj7687?#!zw@j8x9D(+&+b`m9k`W5x{vjG$s9p%<;{^bbM^2?B~36a>9&xtBH zvz(-A-?*}(=xaIVsSH-6urI$a)$sb@VRL38T2qGbnRE54md=5ER6|1m>iOF=c)zxt zgLL(@gA3L*s4R~Ytik&qPe-RbMFQg@FbFhetC?37>6yZ$EjaMCb02cx&igfAx&+?_$sr-v)@T5~Dgw>80`t*>|gV)^rE z9+Re*AKG^(Y;;a<*UE_I`jtR25F5RKQ^kHkABx5TcKC%c_P>Kgh2l2k zN~%e8dt`E9MR@O-3E=uym7(3e_CdH=4bGaWb?UV}#wEFa^WfDqvs;z^(~3GSfG(E- z$>ez1!?I?|vF)gSEi5l3+Nna=t8twfNxS%0zHPBvs{tbzcu)eZ-t62gzq_iheAGLD zUarzyjW0^6rvo1*+*8aAKC9f?Sbh=ublp3(-glD{>m*dK2ua9r!AZN*m1{d)UjPup|k&8$xP;bd)Z`mj4DxU;Pdg4@K5Wp(l%=t=OnRT;%Nf!DILeRUH`n^&q7i~7KPkp z^kAwJ3R);yntUt}QXO+tw@?P~sv)yeB7S%9M##rESM``4U|a!UV#JF%vhQ$P*@ZS9 ztD!Y50lg_E5Wg5l{d?}^=>Z)Ow@Jl_pOu(IA2iUA8f%Rt!hJOr6PB%(4^ZS?sz#i% z#mBQ$VYgn%M?6kY=5~n%CPB3cB*vcxRx+>f9kYH`#T(`=Zr_5$^q_FJR&fwV54#a|@~<{&lu zJmsO>5YbA(<;VFI#Woh5%sMrjtO9511xeZgt0s1VFv_6i#zdSH!}>ZUSCsodv)SeI z5{SBRwnl4Da1zISWapfOb4gb;KsRvZHtAXEe5futN>c|GnY|MQ)FVtNy9K!LXvPK? z86qp#T**$97NGb{WTR#V0R|9JdzbCnpK;{M{Hd48inhbXawh0cQpui6{!7 zfltQqi+)vvf$>a6RPUx=6%u>%CEs6X9(6-)1>JB2llFK%B10Z$5q zMMv52lQu0O&89WB4Xp;9AA`T&HDh-a*L(CM{@Ze&Ck$H1g!R-?q2>zJ`qAOW&rAvR zR{AXgTR=BaL1CeddUt`Wsd|l1@jX(qof$$2ZU)NEsI`S81tIBGz4k(h=2iLiKbOZF zlK^xB&stzClGbJjWRnh%#m~U7L76>oeP($#I+yrUsxSc{@28A?JAWvcIjUC?FhY;`lBnlZ>j2T?MS!#b zPO^aUT>@vyuocvknbFNXO{>(2o#8Xz?5{}vQI64fPDjc6C7@@RVV!#Jr+HOIO-b)w zrYI`Z88mrhz67M3epZJ-uZt;upN&_eSD)7DlShjlQcJFf4lCzM6Zd_KzXcbhcydVm zx+f!%C)vsS_||XC;_SeR9{c)f$E95aWqV2m5ZC+$su8;MyH$!0Y*qH+3Sv=@A1~Qn zOS7PcKP#X({Im&-N&NK&|#^&T<9cH8m{>J_y?bwkjudPa9YA2xS`n zu8ucef%ayWP%TPE?jb+h&5r5&i&{I^q!L(<#aAp^;e>*j!B{Mmg{LNGs!VYo;P7M5x%w^=W@c_A zVei#)B+RILye{3bbfjd4Hh37uud&h<^rVLHwjhx1LX?$D8gr&GIQsD1d}Zgc(XiF> zqx=q#f$knU8+Vyywc>U3-evCuOf!94#(I>%lanJ8YI$(dcuLC&8d#c+d@DhpkprVI zD*wDS-i|tcov@$0J{8(Re%*e;`^)nuhvWQY!0}v$C)&{o&BW0{Yf}08OR>wRL(be5u^Xw>6+6{tf zUQxsk3|+M61zw#5E-ncgoMr}#ZEytj6FyM{uK5Zv@6>jSAI_T^UwxoZnww&$V&wc` zOvY}YMX5tS&7}3?R(wsRySrVp%yN3~-H{_uwfL{boz zT5K84dz-$rLtB&Yq@nLpROFSJ6Z3+{ik!i$V5lWBl)0~-@zAyrBe=)_d@7Ef@@<-lVO}6GO=JMoEj#!~cx+)y z!sDes3Nfs1L!ki0FmxGLTY<{J7P86$eRScJ0kKMUVaQI;kB{OhjJ-UfI&F^#NqKlyZjN z4czlW@k>*HY6ptrMYuRMCU)#^;#WFnQKR$WuA;UnEN^hU)J{3T9Wu3)ySRZ{kVl9L6G9IVm!P7wH+&$6CYP{3v8Oee1jtn)k64=NwtdacF;7$#W~DVmM2mNW_^bg?o#wKw3IG z<09!KGrG>OH}8N8c((X*+KPJzDciBE#NncXNHp^19D9c!XDVM(skm66gyrtFJj6zd z<`nXFoMy}YCGexqH}*4@zV(hbdJ8%2kqh2w6Y5Ot`2`qmPE*4j;$(0D<39ij8j-Lk zMcH)$3A<)U(-6)64u?DO=AL(;dx@z0{UA+q%H#5jUl7FiqI7m&GX{eE>^4vBvW84? zfuVu%f{1tH10QIb5874Vl8@wd3iSoFG0|Vu^9DZZn|+~cdmLb3$?mRYZ$HvEi_TiU zq%C&93jQO2pR7>kxm`W7QQ!6>GHmn#CQo+wgT4co+Xs!1!6iIFNN;hfvCSBOp9dKL z;AgHe7MS7*i?n>{pXrsSDDCs-+y)40L^eiPSMfy`C&4qmEghIk+V_t(HE3|A0nk}u zbaiDVN49XnK)wW>+pkUsuQO->py^)X!3>k^-$?i%;Ed`K{4R9ZU+dP>;uEUPkjSsK zhsZ=9H4QhkDHM_J#zN`=Wu-}=j)w0#7wdmQH4U(QZPI&=fug&8-+rN}U&y;Rn|Of& zc+99)O5wt1XJ!H=lIE!Sh4Q3s2Emd5tl0G|U0Pyqvj3?}mx(uSK}@40`2#;CC2Fth zqYcKzCOx3ik5J8uaA^3ZS5Eq#{w%*658^ntYQMTcH=+ITg9Q0D;C&+n7Wo&4PvQ@&c2v;Rjl44Wur|oItZ-*9>{KH7cPVK!IpZFB8@KuJ z!ssOYE@`+v_aJxT48?`=(4;H%x)@nvWkuCPTb=7jsj+H1P%l2EF*-B9fLrgGV0>oI z-EzkmwPD~*O+b;NfeR@tTsu5mdlJ5(Bp(|Z7r*ek|3_#dW=cbOV;S7$a|E2u*~Qe* zfq%^i#oTW`oyVqj4aTp?ASjZT3Gr)&vk&~vHl4mVe*+4>}$y}U>pof)3_`yV=*kK-dQ{5S}pg{j~! z#ZJMTLbJkK32elkmPmg7<+Je)3 z1r2jkQ^1xgvHhjaU-iZuXLMU$wX8QeLtreKqKm@`pJe5MkL*J zizw+#(sCLihIUqG-%ljkkupj9a7pJp2xla`OUUDdSANj^70)pYSQr6j?9-pM2jmvH zq#r)*$avW4OW#AEb!l3Xf==XCkmjdU<2OaupY`nbsj>zDkzTl}QPe*bP{#4?@^Nq5 zW0w!0=KGaUNI)&-Ed;%YvE2Y_OE}#vdz0^~CG{;VnN|4TA{Nv%c1t4u&GmnhbqYmn zeUlY|){>lgiP--Lepg9^8*$@70mYqz^)4%vDvW}w;oo0McR+Cvz98X_uX`;3cN3V! zj@(-kK}dc{%&VT^U=}5*2Z;q6h26{R!Yr>1m>Z&5t zmgNU!z1{D4%d9E9)Fs~lP|>FD`2dH$j5sy|^gp3HM@3~N;4uXJaWwpt`0#yv0BG&g z`~8MNc9aPM#MdwS^VTK6gWAQ*vz;t6sV?gafm7huLcP~u%^&K(b)0`uv4iPqnAVF;zAjVrmSAJ6jDkE^v_RZetz zjiAj0#S|jh2n^{eMmwfV=Xr zgvgF%?qL?z>H`$LIcdH)S;0EdVyyAs*_LbkK3ns7PYN1#SQk6C_-NC7twAWqfaTAF z@@dwgE%(hh1w4@COSmCqq^J^bpqhaFn1B^b*?;u)HQeY<{wsfoUTyB9JFJQf7B&70 zOF%^i-^!Dl-h=sg9P@fXfcaBLX4k91XKuHBZ{Knz=y@GWOW=hmsQ}&RTwnK4%CNO? z95I;egVR~qEeizKPCCdI`5a~WI)66bP}OK|J7tok=yQ$F3)?SQ&(qUBkV2HdjemNM zOW!8)*Qwz&E^8&E#N>fQ12-7M^G;&%q*i|w*su!UcmHasWJr(~TVNx!dnWbFuuyo# z8q@U=2+%-9Y61$Pg0_fe zz4QedoJ0ZD$EbN$<{$|x-ru0>$e?S-X@?7{`z@gm(L2p@PG{id8ZxSH%Hz~?1&*Wj zb0C6Ghn4hSV@k8Fk;aqO4RjD~Jm^Oz`cp@mzfjw0FG{PRR27yk#UCn1OnE#sgYFhJ7R)w1p% zeJqCf`Nj2%pyBl}zT3}Zj#{_G<)5u*Jgl0zt6)0pEQu!RNL9*7?MRe2%m=7d$@lNv zttY_w{z~Y|MCdHq>xqj2waTbOghZ>LKAvvZIOtx%SVcwqho`SGBVXIgOUhcQ(p}8J zThC8_lP6@HMjuCWb#`L~?SMg@z!EbVd0$f8Rb>&i&DmZ;in-^)g*yOd!PEEh0y1{DOOgMYVjWHgrJ&M-$LYeAYD}bL}1Aq zcydp+NRPaEz#~WDV6xCaRasFUp(-jeU#xqHJ6-#xwo0$2J-LBaR7JTvYLzm2;kdWf zDQ197q2Rd!197o^ZzD%@l^739EDr4#cTL+u&&B@i#GWS)1)inh$CV!(H$SYV!>$g6 z)<;BGV2(y2J^8^(^TIHoEi&~VHV#B2NZ?ZbC`Azk0sXfWs5edq-Rsnk8typx%!d{* zgyR2a7Hoof+7awGK-o8&lN8=Xa=Wr}Puz1_$R$`rvgAfLerfhBwWKus{mZY* zhu`vLU!$MM;wPhyw2a1gJZe83l$>0e2Z|YosWWHCMG$sAflrVw5G>K9I1-b7H^Uh3 z#^uGnf0ml7w*@_FX(b$-oWD~;-vcJw-@fP(rTNcf`gzm7V3B$qaZamnd{i0sCOmK2 z0aFajI7mO);5d8IM{FJ+d=qPoPd)zro~#e%qs;sBX7RkL)~vcHRAe}9<&!pw$C^P% zXhXp%ql2_j(09!2y~$G)rsxvOU;K*PqnfV|ml`=d+awN-ye%j&P0}3U{Nwr>Rd(;7 zyNfsN(gF7Nnxf!s@|~`qKTln**ey`slm1<~-xhlMQEa~;O#=4~Z?w{|eV&rs5_W6x z>eD>0ga#P(R9Pk<`T*5m*O=h5;$Bsf?TNFkSw)Go1&@qk{ z?;YtJAxcfPOC{$Sv1Q*DHU>{ELFt|-@DJo6;P%Z6Je;?2eXmAbdr>JFHR0k^Dax7#%?Mbr z`ZH|thN*57O%e(Pajlmh4;(v*r{7?Wpb!yJn@gtF{(1>1u{vz~BNrED`=X_aD%gP% zM)d{2M+g@hwXeVC(N=Q_shr)d`%W(2RLGcWCjXg7@_(u&1OmKi)rVhlez(pX0p%H0 z2Iyq-?X2nD_`ZO#;TUI)N`AWu0fZ`@k%%6&3r9bnv;M2Or`7Vuo<74HEZa5$;2UD$ zuyTNL+vfr_n0o3yoZaPeFk4$3-SW(5G_{7g1Z*{}O9h^U8A$!4O}^PA2CoO*w@G~+ zpo5?`Zde=`P>8%$NX7OLR|w+o{!5uZMVMCNb-Pr`0X8-?jP>+O3c1w=OGFH(abe8% z@oRqAcOggRT7AI0Fd^W1A8@9wsYwEu&06>K6W*YabD6Q@ZU6XeNQR+6`@@x#@ZEd$ zRbPHm_)T@$|G-Lz2EbNy!l|*QzW!ifN(swDSC^Zz=pCDOF(EMS!VT2ykixDzYuR|& z6*bol=n2gJNxqBlvHEK_6iI&X?9|AxBUfQHFN@3WJnmTu$Fnj%2{CHiV2d z!UnW^E48yqh2il?g{n_s++k+Rlf8qF=rF6@^X!s&U>l0q#C(gw@C1H=0y_Dk@9%;@ zMkO}$L~pbRulQ0n+7`T1={e(1N%lv!_6h=jH4zSxO1G!SiY4aA$ECHOv!+z3wjm$` zm#X!Vmb&XdB~st`d~&gey4?40me1mYUJyPtMe=y7#XM};17hLjufFvz7e20)J^^LJ zQ*pGWQND$|tON+q3E*_PzE{%q+Ef+IOa3(wpY!*^p(5KJu++_-^R2x}=-Z$#w5Lo> zi$@om+?tpI2chX#e^S>`5XH`60)Z`$nMn#IDAR5Hp<<$Tufj)5^jSrRws>nt4yZ>U z9f7wBf*H@B@^$b=%8f{)adAIzd^fT$4AZ^c;1t9fzfAFYqj4q9)i`WLM#o9H4^V;T zyd=)=9;lP9oTLN1yr#jw#(s(4Gn-kegfJ+kt~A<)XxSlx16KmBoM-kMx=^i%;va`H zMP*70F>P9W0V^ItX0)rvP`}xuyKQfjWyvaimfW&Q#&@rMhVR0}xv_!|4=X)yw5+1EdAMhF@b}Bt+kKbowhq;ZtBRBo z|HZx`q@*4Qv2#e%CofbXW#byYA45{~bN}OUf#!8KH-FVqCZ7D`UQFta zRKbu7S=T{cV|^s6OOfuu*H)aIN3@QWYEs=k|2Y5byG1EGhFl z%Q$yewC<;rAY{;LP{6{|+rg7%^EG~!QQ z2Iw|x`Mh{shc$&MSQu8v$Sz*=--Iagj2~@;5YA%VW7E5Thl`NNY$`Vzq6@w#YKSub z$KeqfBBJ?gmFMw{U-lVE&=EC`rP*P4uyJ>~ejDxp@?Yn+1ztcD-Lo=14 zP}~8xP<;Ks>q@E6T;CnBH-?gsr;^j-po@p*R$mO`j>A$;up>u<+j$>ly%GQUvZwSC z_m|JtYk;xt6;6mKZop9JT)00{RPXV~wg?y{U$k+~yjD@R`Bhk7R<^!7Q4kRZJ2-IK zxW7TxIJ2?dkVxnBauhkeEhu!{gDL`T3r57pV~fBG1gW{E(hseKswRqbKBi`Y*8~cp z*7mD6s`GvIEWLk93vZB{j9=xk=roV7xWU!4xb?{97?#BMD1dE1Yaw-?@7u83`T62{eMjvQA)bl84$sA3IWI^*>V zj}ajL^RCHiIlj}gZG#hfXo^>VN;IMx!jO%s#~DKB8p?|$Ob92$+33YscsY96Bqw2H ztnj`P)9jeQD~#E-apzifioN~z{Yse6<6fIaWu#Z&?HbeRUzer$Vf||92Eb2%@QJlf zT^^=0Q{#F5OeaNpLdUMb&i`;PxOHFjdPu)B6sS6+s9y4#H8p=PS0JYyD#OoFAI+pC z!~(QRaz^ATva0rl-8bz{pgR+|TDaf5VruKBiphQd~nqrrXU|ZTqcz z<rqU!1KZovI-PEY(a$Y6)UZda$KKp)D{;cE`~uR8qm;WB`QM8_ z-Q&(#s6YFzDOj*>5m?xg+_K}x^9rl*2jSMvO)wiynhBZDH)50ktyl5Lje(_4fh*j& zz$A>4|STG+ikV^qL01V=6S z4jVB$AjbS|QIqqUZ3fMq=+STIWsol=Ujv__aB&K;?7fJGxf~YCYm#ITCyY+KKkR*u z>++(PhNeKpOx$gVwSfqIdR@adyF!~~1~&(BfJgAmE&b!2`MnH#MPx$d;!iY3gT92f zS?WuzA&G?B_wg2&d1E`%1)A7XFcX`$c-?Y=ug40Mhxl-$*v)~jKj;;6nm|QGMV=9d z&4**}wre2mRD6QK;6qS?B1y1*e!}tV`)L2fSDA?pepvs6cqudfEiFY@;ynmVxp4!l z$E8o?Ku^?Hq?)!WEOP9~SS|Uxr@ct%=U?@Bbv^1o8`yQhoO=(-NZBiKO}SjF@87|x z)}-;hLe?7QhHKEnL7AvY>4$?kzT=$c8f?4b|2cu=<>hit2(aAns7R0Lmfl8;!A^szP)J(V%VcumsxgvG5bCLZMC;ff_p^>OxthwlZc zMi840IlEEz#%+-1YH3i8#V7mf*b33IoLsyJh9wxnOC{XB@-6kPhHHdLSvQfYJ>B)g~?O7+mcq z;#DRsF-uD{26}MvS0St_V_~cW+X9u}QW)5xuD;oCVTdM#TkzWZPmLVsr$LJOiHFo! zYTAYykRO7@IW%Uy8o_euLcUzV%wSWl1t3w)2ba7aE0ZO!j?w8tidaS*2Qi@@62|2t zm@Wi^KqJ@w{U)P`MsmJHvQ03mEYBH2G9GD}`G;&%sipVy-X0>CTc91-s&fOkeYi`=>> zemEhSGnuO+aN>N;t);>eKu#MduY8DB?u7XU+)l4Iz!n}z2L;35W+&p@B`wB*sCk2V zlJ;D7hN;{sTHje!;+}@BECT&6J|EoH2b*jYXHFrRo#oOzBbz&h#VO9i>^$?cZ+LB% z*!tySaIm;v?Cqo)utV}ReInJ>RZz|wQ%3iAEZcT5LSyJCso$p>dD z^!-uiYzG=FO%gJLFRiW;#Tg6G(Mu_x2VW0J_)m#`3-Msf%-uM@T`DKv`IM#i73t3Y z+h{?1VK>47b6|po)CD^(uIo|Oda37aku{^X_y|xX1$HUEq`K{YZ+Dw`viffp{lvIYrJl?Fn;>|K|OBLJur4eGd zmub9nZ*QFyV6CV1GoDsL^g^0fGgBmQ#b+fT3$TD2&(9R0-|sBw0!1C@2uNv^kWk=Z z_6V3gE=o(3zE&PG5AO`zD_s?4sTnzH#!YKYL{crFri`YfeZ?V~;W=A0;k)wR5&R_C zB#!%Ww%^?g8}LFJ|ClKfO}5khqmwv$UkSMlsD%PPejS5F=PYwJ-r|j=ep*5AL0Wq0 zjgo7@%tsK{VqsOU8VY+@&r2uVHcamPp(_4yIkAx{rDb-%KeZHS@8ap= zjTPPn+UEssk7UGmT~yXhkA;YUM7!%fK`5@@lF<>_{FT%rCCED@>czyLa~hLvLd4~t zGhJn^P2*%G^z%1}IW$u?iqy4ZsNlH|ct6ka{O4Q?Ce2nUJ9uh{at54pvO>J3fC?Ly zV_tVeFeX#^ZJK6t!qB?6w{`vZRLy&jjy~B0^ts4Q@dF1cf6fV$s-ti-(?C1^)7u$f zs%`Yfi&c4d>6Hiu2EIJOhSoUERyeZrf zTKHTm@|+X{NMk6U<|aI(PAAU0GrBDaCTg}?jdsAcjO;5IIK+bav~`dSbj*d`zThCU zSGB7OKAh!}N)hR$Zn0^e0{|*b0}^3b6e&!T6C16ke+9{v0wtU#h-wBO4xI+p)N_nx zI9ib!pU;hv$I--5tqAgmL?{ofrPWVn*RToD?44NiOvjg>_G_wLS1o(&U|jKe!(XmT zUtcXh_VAHrC4wB3b8unCWV185gE9G}G$)8w=!-~6Rx8yY+K6~aOqZX&sO7AJ>$Ud z7sV*55O#r2zHkwQ6ES5d;-~+zMN)cb8f|NHv?XS;m2p%_>uhjD+yeg!kyAiK{nyjm zzsO6YhtJ5Hq5lPHF)@Wqf&UKt9!m*dUDs4c$OxuZey==f*NBGnYq!T4angEy#_ULM zMCYsOFr~umG8*^GeteOh3)>4Jj8_YQGwb>_x_r9GFpM$p4&6bW`Asf(2+^xYrHP1 zE-qE)`y-Xe4GkDJini#SvE{Q`t=C{UPC{TuVvf-7>UOXeI&!~*@8H~bEvPddnb&o? zJgc288|7HI-Bfs@eQNg%Z-i7flA0P1YVNS7>(Tf|t4$WC?1jt2zTf@npw-gw;;lR? zU_I48*Y)TPemI}S$#H%a9*7oHKx%=cSccDgj(A3s<=!jW{^lLy#$gf1B%#CG)GBt? zwX+OCbu7ou91T{tj_ZY(e&UwABGDxKH5 z)}%|GddzH`kHVsqBGKbWF0eC)lAzsD_@KS7;HAy4rQG;Gi@4;y=|yhczUYV9d^)s! zwVL>Yn97Z@xzmH)bk=Qf`N5s_kt6oSNvG?X(3|yl7n;zGQf+9%zvv==mBr`?kdQ7B zEkEvO^fj19Oa4o~jLo(eAn&kmd!%j(QKYc z276Yx#;Ae_sy&x~|FO^+k!3vJ7IVC)qVP*RG+yx`g-VaQ_gs8>mDTO88jm zP&EH%-=N3fy1Le7^P~vYEXpzgUS4+PD4t%|+(k)2J4n}Y=N$upVGm6L+vO7MwaZ_j z0VzGsb$)_>b2ffhBq#(^ul!UkiWmLg|FaiOnf&|XNNq789=lBYs7nMUo%=JSXA+R_LB{-KwEbb3J_k|TGuYU-$s0&}8B<<9DNdj&me<>xmKLb14C@0(wU z{l1n0kx32kfp!Apg2F`ExF4@;uJ0H&-7+h?Suw|c^7?+C_FJ~E75bFQ8=#xb?t{&f z%jqW~6|o$hy>06;K{gunm4&2O)Bb+(+i(4!qZv+MD zOw7NcMUHj`HlJOYQevI+uD98sg3_W~Y;Cbj{qk_@-~26Xp4=k7kSm!L zIqV@w2Iijipi#MD1Xb_~RGaIfuQ$$8Mq0Nf!%@OU%if2GS{TuM1-_OAtvhMz@!hN} z!CY+^EA3Z7gMYJ;Rl4+Z(T9@u_TIdPCOyF)-ur@S6I>G*+bA`c`lo0xMrWhb!~equ z)+UZ0i5fa!SX}o#*_{O_sq#2U{B)OchJ!+$qxqA=BGaLywO9ntZHZPHf{q#u`SWKg zabw@(?R^C0Oz<-VpX&u}(CTO)_r-zvI(@^2M6=r(YA2wuxRp7FoQOw>@hdR=0~>PG z3(M%_>&;FQ?ij@@@b2Bf^(QadOx?BY4B_?9@#Iu&JQ)ZF=S{LM22T^1DI_CSX91D1 zlxESrqF+=%xKIGluAlo#{}qJwMB}6NW<@PP579pBQULpT;V;SaTC}f`lbmr8fSF&| zHPF%dzJkEmyL!`9B+jhEU>46a703|8*cp;kqhTjtwUGCc2$P$*_eC#q?knDeOYWCA z{obF8Bw{t%X3Y#2h5bMmf-2pn&x1a*^V@PQK6QF*^}Lgm0zB=+0l}jV>|Q;h(20)_BO}AN4VGFbUW@AJ`oF#IHyGhI_XMx$_Il6g<{9oX|L*;ezxQcm&v9v7ZziNm{I)PSLCrGS zKP5aR9>c4A2aP=J>;k(?McwS~8=xTHPOgM|G@!D2$r?j*(My7O-jK9M{v>_=obgFk zjsrJ*1s3IhaRaoxTAPDzNE!S$txQ|JjH{7~SpmXkKrIX`7D=Nvt1zX45sNN|mB zgmGlR%O7hOep{Pgc)UL8mXpM)2z-vg9@hBjT`n-9}H6(=JM$;r)liltIfEzeaxY%^CB-|M+%$?sc(Auki|(Q_TW2)RCzcMEbL zh{sdA8%9Lh{j}4=ABqq6mt|D`B?!Nc=C7>Ow)5pKx!e?vEQE>d?{j$Y5vu(MPKmxN z&Oy7w-f;!?xcL6X?ePgxqD)0z=m6i)D5}Ka4igZezWc5XWaX2ebx?O7epC))Ls(}J zU60ryYr#*+-&o}J_>8)#&TB=tE!#?QwA~UA>+fs`K60LbF|QdYGD;-{g9RC-De*hO zE+XA-U;wThS+ycoee|Kg`{(D$(Ca6yKnmR1*e?ceBrxqDLis~J zvAUtBipVq9u5VpGk)!CsJa7UmBk~x_(3~G`0pN0cXSorm@*2WgW#hs;#wKAP1iMb@TVGWj7`I8M*Rl zDqjKBn`tQcR5Y>ErT~;mno15opcTT==guHeeV+X`8Y9qIJ_u{wRt}@ll`T`xM+Fbz7Dp8gdkWJA^Pho{^m#Tm1axIN;(08Gn!{QzlA~9 z-BDYJ)yTS*=3R9@T6c`>d47#?y0^Ah@+YUAgWP60v0{;_nJW#08bfaThU@p-^|P=% zkGw&ZVMMa1S9Oj?mL!JhM+85r7CryT<+*2ep?WJt`pPjFy=1NtSYYCoq z`8VH_hG>N6lDPT_5;zMM*=J!}1rAIanl_imY2>2Rmc@>Ds;g^q8lLvO4Tr(gFeQLN zrE7%Ic!-_w0qBp49OH8pX$w{Ly}yFh(cnyxm9sQO6cNKa#SL;l|Cp|0Uw22d)CTd2 zr!ynBur$8svgI+;909I6$}BIa=_XUKtrFat;2~J#Y%-V-6PdqriJ{1jlJ#6g9r#07^v--=TA-^-tP4S2v_iPLRz z*9`63D#v{fL_yS%)5JEDn4n7WSKSJ&!h(pbmVN))dwaJMmpXsXBXmHK6@J{)4DLp( zAaR1Om!GV3gxRL6>^`U%&!G>qHpjgicSSwA!BYyc~x z%rdKk_wOr(Es-LZ+rfO+M}gtpKtwb`y9)08)QH(5tAuS1&-AL(!w@b@8kg5n;QI&1ItWU)rIK}E*3E0ziX(#5jgDO^S zgv~l?jyDT41ANjcjyn#=F3PfId>hvz?(lwDIjvUenun&__q)s&R#rM!TR%`h&|&M)33&=j zOMB`*L*hKF|7g;{lwnv=8c(HSf^eJ@W%=OpzrW9B>O#|NP^b#mR~L4@ ze%9AV0%Dpv2Vt)@OF9U!72`i6^qgH>FmR1M9v327E4Z5v8<+I>ok-%}__V|+=<>fl znCrX@bY0My^hqMbhoW^4$~~T1(BWftaiI#7vg-Jr{%dr}Ea3{*rX0$`a0#eGb*=!k=1TObab{OJw9g@jIva=p-*%j}jcb!TM_Mbq__It|wl; z2;rXaN#HZfLj-P$il`q~Ietl&endqo>)IBA)g$o?6FfIyFBm~P`jBJe>2f^F% zY8qm!5AVyD{HPkCxQ)6F<>VGpI^p=J|em?suC7mi_pwTnMRYqd@2FU!@vKjW4* zjAnBfx^PDS^{e^uh7IZa{lMTL#{*;mi@BmA4)s~s19h_(oy$4|Jy?rwFezIlx_ri*F1E!2G`vJzC1sK(Vhf=9KNK&&Cc5dArKsj2tPbW+Sak;1 z9}L;c20xVidaZYqG#k(oowk*RDqTEIC?R0c`B_^fp@T6ZAiZzSc~foU1s&mwE9_6m zY}vB?)&#&nnJ>Q`fIK$=kfDXg4Y|j{V6zg+Vzf1K4*dp`U@UY*9cwA{7n@6(y5#z` zSg1-%NEg;*eDoOpO}w^>_&Vp6Zw2Bc;9-e{pzrCEn`!M@VNe11s<*890v7}|8fo6T ze2XTCO_v#QHk&@3nN^mon~y7BOs@Lgycr(MeXkAXP@p?6b_cxO8Y~bdOcMW z%yCBoo{bMsjs#pDxzu~4^3Vja^M&f))|tz9jHeI8hWq-x$rQ9C^7VPi`(>k5kY3}L zd(lw3HkXtUuKM8855de))7lxSh=w$q7E4(^710TeB33~x(5%SmJ#tcoj-`}mk~PSA zi64I(^3F|GNy^Y=x(?W8aK>Q_dbP!cX9S-QxJoZ>i7mu?d!lW=dpp7f6+X~Ga!dG6_v|nb( zvwDbAfc*o7`GN{lmKpbRju7u0L`X03|H*0cHtjK7LDK5 zVKJHv#_coR*<@JWdTW_~x|wsR>P0@dx>5`?P5+V)w%sa|<4b;(i@#@0KMC9z3%;Gm zxu+noSy8n?n0>4*qv#gNlkI=p#+|KqZ9r^pO;tqE&cW}LfXU3!WS$M#Pt)J&c zAQJAGeAYxoI*{E90xZ^6kKtEW?v7jUK&y1Hatqz-Yfp$7`HM9fk}mb#PuK^MKh)?u zex2YX>|4J3_7xQ$XVL&QprH1jJPl@miSbL%@-L1Z+oQe`kQ`!2&1*fUKMyjyTgC64 zB`qY{pHGK|m`r+Fy(uBLK?Olrs?0zzgYiS9uy}NpT?fVVj}BWLbK2xHBS@~NNOe?? zxeJe;>=cKrX1DP003pFiH9h;U%yR%cJ8;r{u@qykwR*5oS&M)2I9&D3hZfVHI=SE* zoeyt5J^On5qwDs^9pB5(fUSMwS`;3Y>1f>wh=~j)8H;N1UFYCVU~j z)Q?iLo!Z`PWiXwKs(y{W1;KPr(rLG0OY%~?uyyfJwCHv4CP?(ov&OeUE(Bh0kati% zd|}X0{i2NK>emN<`Qwj5)vE!8!Y|Wq=-;K1wmFhYNie+8IsBpg^rO6NW7wEvKUG*V z^_n2<(Vu4MX|j*FvXIL}*8x5m*Z`;Df{x^!U)1F!k#WChbb$!|Q=19@8X%Y9*7c^3})3xNM-*E7Q z;9V!J>f}3Hxa3M{>tmyJxD5moGP}9^t<;y%Zq815^jq(^9oP(MjkbSfW`e(9MU{m~ z=c3ID_cg{hYV^j6)a0@_-G4Aa;c{^B&>|BIl+IQ!>^U~`6^STYVmMa5Osp#aT&W(Ys+2klbGpf(kjtw!CfMM$fM@RLH;|GyRF#w=oh19ilDrI5=42 z>!;?N1r$2!zIie+b6rOS0PF@k?PG1ixDTG4t7K%9I<2~)IF;KTQ%*A*$dg@J;fO2TKb_J!%LYIicm`s6{_g7scG7CAxt0GJSBrs=mS=?};lcR5 zISlq6vw5HesECOEw=z>e<{ETh!x)%nMJ-48kw$Sv%DdX%KNoMbj+HM+PQ+UQd+`t> zRejG?#9N)K)8oSZK7;3paWuUtNDDSrNFxW# z=Erp-QyM0IO8yqFG4CCs$HRXR!%kKa_4!F31z10-B|ayGDsz5sD$f-6Q?`!yR6?kp z&xu>H#clXp%>E8KsZPW zo039R3I;F`DX3CZDZf!3Y<)ZM?Iv@T+Wz3ap0d^W*y5L9r2Ns&uK);p>BLKSZC(SaCAuBr<|ZT`v_> zbmP7#Al?w*(B*9iZzB4R(#8xPDvFhy)K=l?Es$<>CV2+J;*UNPthgKgb#sRR8#eV z0%4MF%-FaRu9;G9UUT?t3}tl-K*A&*Nh0ZXb?t%dcr}u!(-kN=n=8M4TC8fXa)jw6 z#6&H-YRTXeX&_3O zkDT^9-u8}Mo1~xA2a4P^AO|;rf|xASeO3o%>dCL!pM~K(FZ=6M_P4q3tyJQ5u`Yjz zD}bW4Vm8x&|yIuu;siUJmB2w}|f%w6Fi;sSViVOwUNbKKr<( zg9npI?DeL1HgAibXr@K+Mp3mFsp(F6Qin3kiTTsAn`H<|Gs3uvr_^a^0?;Z7K&U&# z1nks}9N}VtueEGGu1$sQHz(aKKnXd^{s8a&BizQGoYnS6q+vPrLc*7Dhwh8)p;gxM z>+4k>wchKfRI!l}sty{pshRI@%-^V^d$jQ0fC)gz);}E}yVBX7t)TffUaJioIugTMg(n&!K% zzSBRVuydLO2Fdl&9xOrZT&xVfMV~;Su6hIth>gxdI$`TnxZ1SsbH2^(r47?O)fXhu z87i#FolK5G547i=Qtqr!BG1m`Xu|%eK`nk0Ul$FSYBbu|_}1c?%}$s7&A(n}(|LY# z4C=SjyuTy=SO)L`fFJcU%-iMgn&IN_a2zX$xf9GfcX7>uy6|}!o-6TV=M9(4;B;{z4xy`B-N>XI9(v)d$aJ96NZd?s zFRJs>Z-6j{q<)u-y5M5%*d$%bYi^ZvJLiPy;|r@Bd9a^xg^5DppRnqEUJ)JyJ(bKW$}|iR z$PX4NBxdvUZS;DIPODCrwflxpWFR=pD7)algJV~Do0^!05;0)9Gyr zg{g|XV`_-<6Cm817Vec&9A##*H{34+2nNRMmdu3C&p!?Lqg8KM&NFtq(;GU8?iiW% zvN%|NMd?IweVQvIj~)&)U8K+==K1U6kczhVvt8u0V(R^{FAjEAn)35msX|^sjUUrr z2tdLH*J`G715tRBIwEpa72INCV)Kv>m?n~LwcVyh6#qi*4gqhS+6)Uw%sB8ay5Ii& z*CiLf2+~!VF}6tH(iB+KriWo4(q>?WuRA)S%nLt*Do>S@TJz`)k3(QFa(BndiJKu_Rk=&du=W(gScFPjOh%`7uWr<12x1hRS4@w5hU&t$B4YG$L(#C z=Oowa>z%RI%|+;yhq8p(rX=Pg$tR8CxK752N^fy(MhzFJdC}Vr1VIh6(ImVxI%-;yN8Pv zx*N?|u%IO&2pEGw9kSpSag3U>yRAq6{`2}C*KS>y&WBB*to8s}+kAb3At+x(_4PL1 zBOr!9Hb&=7=LjJFa-!a0mhSE-aRsR2qTc20w0~d&fo;-l0Bt8i%SCNC-ao^0T*5=^ z6+YPvcJE*pPgk%t_&#v`FZ}VTqM*Rosla5KWtfF9v>^S<5EGg;E!#38632LgS`W96 zCSQ)O`=aWtLc&LU;_H$Vaxz>wl*#KY&J9j1c~e|1E~}qE!`>I-SW2-UOAv7r6x5v! zANQ|>85FHebpu(i@a#@&!rKoEoI7hW-~4k@Tqecb#)^Kmw|@qd+h-aIdh9@}|5`ks zE}KH{%;aQ(hu`bOPy(;Z!gw;{tJ>xlR3A ztft$o_sx0_UF(}>?B2%)PNqRjH0#BoCbl$^ayt|5@!Ek5TMv4{7#DsV<1k zZeRR*H>BMq6Ei@Wkst13;CEHj$~Mg)FVkSQ@wr$89X+7@b78znzQaGzHwQ+@bb>6N zo7lYPm@oQB162H z(kikJPYFx?2Hk>4D9DgwM^d04?l$xL+|i$Zk=+X*_~IDp^4O~k{@f+t3d%zXy^&p; zAx0JO!KO1J?d&%KV|D^(bRvSU zjWB3wn~GKtD8n=V8R1T5OCnpJeG(Iwg8f(Utdr$k_k?sk<(CcTFrp2w9LH!G*o{Is zy*h9eJ~-}WMwBo#(hG`dIe#$go1*EZ5HZT-l(}rPfR{xJ6jR7A>j1 zDdK%q?5hr(XHB+PQstWFbE?LAp<;;vI|O$-w84I`ltqzzM=N?8Z#C($X_!N*fk^-^ z25v=GLh+^kc3u5Wy|oBEQ^pPXz6RfDbOraLc;{T*yMXO)cBmXJ7Z={V{J&qeP_7vm z=0*Z{mfPK7lWo5P5l`x?CZIvwAa|MI+y0PPBCv43GX;P}{#VJ>0F_+NWFY`XI9r#I zEe+9?Uv6{(*won1fpUlmG^C}Q$6tm-hSbDVO^Cg{RgMb_0Li%Pmev{PvTqaZll_$o zAUZwcoT~iubILx3wp$nHuZ>Ic&|sk(m}=RIC~{giAX@Dv#c$Z*5_=Dast~FTGKAq$ z(i{%mu8TY?q^#(--lU6qC`~4P{{sH6JsOc0O30y|-MhGG(sOo(aR#QEl<`GzavJpb zYj(WcJ~7-#@9bhGr)$~S8A2B?U$(+Iz(Y}m=(t+B>z0P!>_6GxCXZ*BlZO$47#~k! zx*U!F%G{fxH`UfB`0BPJJ?J<iF>8xTEga;2z}G}cEfdH|q?T1*a1n@x$3 zjGDTLT_0bcpG(Kqn{|h>w*R!dZVXv&PwHr0iSnooluBFH7o+cqW2G zgips^&HImzwA~K>wPY+4Ut^Y+FeBG6kWo<>l{NJzGs8>l9Ar8H>;18=oyWn)GPQx( zItnoXgl0uRDTO)bo#$!RggN9{A4HfFdVZhlH-?yfd3a?xRt^C2!t`}AsqhgKFCVdd zwSoQHIF6|S7&)8rV*$ij;Zh)ELv=WtCkNJNm?<;nhe9Q&EuDO6Upk>vF?|0`agRam z+c?J8YV}!Sj)9#rqvf=J`bun*w^3+wRIo}&bDu`t5og>4ZQO*6jqNiP5i`{?qm))so~25V!o4F~7%QPDD-Spnrm`6hqR zx>2YtJ#@i4S+{=R1f^{QBaEz9(FMfMpL+hn3LR8f$R0u%ftaeWois05Ltf1kh&>9MD zhL~j|#G=svQ4V}fv~;^+D8tR~8F`sjd%jA5b{>F^D;=2t*5nuqS0 zB9wtI^1%aC<0!S)K*OE(&aOmcYWS#W{dB)RBheN)Qowq{JKDQ7`ntBopY4S}sVBlb z8W5_NBv#|$VcRmi$=t?nYiq+I90MeA^|Mzq|G6XEG=WVUhZV9RzT&_0-+N613FP*y z%Tgx?J?tgqJt7Pn^iM6Jbb$z9omM*s5pX?cMSGBYHDSfol2j+W!(((E{=Gd=UbSvPTUad#kX!;k6vcb{!i zC3e(~1kgTe7#9yyBPa|L-c70{Ei=O@9Mg`XWJg03nrIh){-oK-o`lP-1VXRS)CIC6 zy^{7WZfOHLR_4Hy(%h5f0PZa?M=EdD!_4={b1zN-TEQ)%g$Dt%l4h1G>Dq0x5q=5+ z0q4NH^)f=V^uy9CL7iuhq#yMfdbQz#%D_1PPsP#P*6Kt#mQJq@Z8`=B7u%|CZeJ9( zpC6gEAt4xziTRtj#J1OiPon?A9h}P6IQn*^y~g52SZT&U{3$L{8L^J0&D$2rGD>TT zAM-s`nT=b$2;B^*{Ql-U)~o#J43PU1X%Q`kR3XiJ)neWtFhIY$4ehA=ts&5ho=&9W; zJxEbgqlKY1I`y5tfkAM)OSHd+xI+2StZ^LO+KM=JDH;{)Ov)9E$Wzs6Mr`>=D(lPa z8G}oub@*qF zj*dEy>~fWX`9Y~RTNOXgD`N%hPNcNOg>=^$&(r}TEop9nPQP0&Wy!_^$8GyOezGRGfUQ z#@~gtiWcOL!OK7_ECarg> zC*5nowfJo>0eg$1UxR!2p9mw?n8GsT(RiY(_c=3oX6kW9yKwfbZ_6q{mRTFrPnj(; zJ`890$Aelc(;gcMY92X-bIE6{M5ybmU5_{0S4DTsM8+vZWNp>)|7iugxY&Rh20EV{ zE(?8^*|Jt<7iF}?h2h%eG5d2(5w>kuu_Y+m96Gtp=Z{xi$NgSx(thU!UUBjI9p<5Z zZW8wq8xpjT>*+W`t9&%WGEt;0C3kkhnzzr{!t13+cSTC0I>6M7vz zyNaY_&W@t0!K^Sm?rUE2!j~ZpO~y3QUCDmrZ~C?M1TQt(_>U9s)NVGs6B=D;-kb^} z<=<2X&MToDl#oCEhnSvehV&ZHcZIg!7Abfy6)$YJ^&H|Ac_XY!zZ{z~?K_me1d)+Rp)$e4 zo+$hDW*9{kX-A1gKD}u0u^^67d!&k9QM#p9MahXtU znU(Np?{Kql&=UG}3mA4D#|3j^2_>I;vefUr#Q`<5*RLmeOO{r$n8 zwZzM)KEi^b7eBg?N{7?AiUN`ltgyt8^THv zPCW`Gu)GMjZUr46SwC0j{Wc_ry9n7KLfH)nF!nI{=6fH)sUrMT)_zK0b|!TrQ5GK= z4NQZ9-`W)M%p?OK)-9!-w}RcN_u*magFuV9`v?|TovYfSD}*TrE&(jQ1uny(+IccM z5dA|cvS(_ebw_9lf?I=XT>$w$>(%exUWF+VvyK2GY!GlQ#3=ycNDp63QOgmSdjPZr zELJ>j{LXw@nKFOgPY3hFl&jbUiEs5;Q!e9DmmGGd^YnlJ2%XvQ+Pf^ms25KrVZ~ zJbFxeok~p>Rycy*)Srdet!#`5C1AK%JvZx<)bigq3OVp6mzI_WXssdVqUbjYj|Es) zUL9~0j6aS9>9#%pX^2rx*Y<0hT*~TPhUnnFpgn}mOEwXo-vK_32>~7K2f9@05Bg^z zM8~l%G%I-FfuuSo;A7tw@HZj>ycuNrXrj+H>(F=1Aos8DCV$TD=ffGHONW~g+q^qF z(-d@aoe7Q&S&~@huzI=4JF_uyYPx?n9@?{@|D8?nhh^WckN|ype(uJ>fAL>eu78W0 z{{Y%F)fIafpz_?!=gmx)qp`=)zY}jHpW;`jHU?BCH+I#a{$vV*bcFJsNZ*!D_*!U4 z9bE+i{)gep<4E_%wN+5^Kd?(CVNxInUh*|fi76xutOH~X4I>>h1MMEUes`p6M7j;w%yNw%jM2{5tzPXU+6n$gG`T z&7ttV;81{Qs-SKZMDknu)0z5_?$#AXQb5$%sl_+nUkCQLerEka*0jaL1FIl+XFcI;Ww$17$w+oSF<>%hP}HneT{ZB-~@3$*?8 zl?c1zoz_t{L%>dc8&+gbU+N4E)AzK(?O!4hy0@QGwPy+d)3n>DKsxTx*igx64fknKPBPRt@JhQFVn{0c8ubseUlt-HQw#xKC$W3MwM78&XlCl>rj~x%*@Qbp_#i7q!!fr zC-@l~K6R|Xs{zhS9|rcmjjb&OUs`l^Y z>BATqSI7(gqR=%D+_L#MBR%z2Sf|qGYLRt)ggH$y)%)QXYXi7@efcCP zv7h^<59jQo16CvoP`-rc3SgCBZ3`4PY#V!#O$C$6%j~jHOe%d{yHd^tDs4ZWa|C;aK{5Nblnh5_q$WZ*yB=NOuy5 zj=F&Pcl@bDI?1>{e{AeUXbga%-I3<+^PqIm-xCuP;o?65L1j7ti4XT~5K<=; zoFS5L22?CVQCA9`YT-@=h%?a@hP4+Iv-T!9t>#J%CQ2=)vR+VGnrAaD|NP_XVqUix z7`Z`z$ZiV8lH4A9M=U0q$ zMoM)v`+iZ5uBG6)koMzGaZa~$L1Xpqw<_f$Bk0 zC0-v8kpeVdvFs(v93b1kgz&%SsQQrNxHZh0Zo4D~2oqZxV~Oj2Ru%6FY6Jq;pp3IDKI_H`a7YB8 zanM&k7_k470p+%)j-HBUzE+ktSFA2oNsTZ4VxF>3(-qCcxYT5((o%`>+`jK>)iNxg zEI)pd9l%6$a%9j>e(z+-8sgZM4V0}W`p5El@D)=jer*9ha~E%Sg2_x=5fzdR&A+W< z)oIf^F9uAJ0=E1{_%&WTBK53cE5;@&y@LBcF=H*kJfUUubNmssivtS?3`7WgY+U;+ zz`B7AePqD`cs@RF+AqqrE*c<5Jxc#vQ_REjPadDY%v0W*V&3a&`{cbv>qW>Hduq)F z9h%|M9rj;YuRs|-Oe7P)@;{&cT9+p7VA$3W+d>;N_5#1}B;EKKb?SHE8peEqJ2DRnqI zm=n>GNI+Y9KRMdy!e#oC^DViqlC1kz;M>p4M&GleoV%SU=X0{rNqV4bXv9y6+(_CQ z2%Xmd+9AQQ86?{u-sM4Cc$0ZLh0>wi(Y z$*1-MvtY3ie-mi*Pv5!c>RD1H&dST7zjS9pNmb_t=qKE10Ax+R#WcEr6TsRj5JPFv zyoJ)+GGEII9C3;>ygdOERqvx)9!l{3tKRS<&6BWHXT!7oG|7G#a@Izo!;@|n1Of?S z4Hc@q4(2gxCW^rBc36J@Z<7I@_CdhJ|JL-T2gBQJ?q_GnJ$vS45^x;IbEED}+W`L3 zL^;RLfT#8XqCu&{QDhGb7uJ$pNb=pTi5IURngYW{eU^Eo7$rnXH6Fw&wZWDX14`?c z+e}HFK)&%?1yJQLXJImtQZHIYbGr5edbU}a1qR*MB($d{N*pj<21~&T&k8->g}>M9 z)}F1{+Bm3V*Xe3*4vUH!unfuWN>l<*%(kERZJYy=&dFqYdq7UJ=~v4L1{8MaX=!PD z8YiDGqa%%Hv>-0-$5+T4+wl!X# z+wx_~1$hbUDLHdRCi{%&f_4PFiZ&#LA!W;cY-<}q+u&FaMPqSO~VBW`Q zb*<_ua2m6YOX~wM7rWUX%Yysq^E~A{>im3as6`mQf#C7wCD-t@1*+l#W&}t<6IYpO zMnB?BuY+&v?Q)J>fMcsU@F!}%f2$Ix%{;2EurQKqlruBxs?e7=`*(Du(KJZ1=T6rr z^5qDfW>@6@m2~CtP=4Rvk|j&@A_n#0$}7f4;_c`pM1fRg!XBoh4goGpqG^>8Ae2^G9U-Fl_Hg6j{fnN0$s6M;u+B z_vgiY$mKEbeeam9BpRhHou5b!sr|KQXrz5~TXA={^;8kIpHY*mBdbSg&ENkyw}l#g zQYkbjNv^A}PcSQK)9h@c^y}>dG0P8md3R$yKjghv8sI@?s|L7lmTo1$stLs=yE2`e zU{SZSew7OTy#zrlkm+LTqD-9x%BH}(Z@qF&1Zah9ao{`7NAaBYC zC~Z7^w<-r(pi%p@k=UjFj5w|I+$gyl)fMqefea1@+g(f;=|gXlEll0Gi$iRn9zH9} zCdJUM%}BQY%q<`6<>!7^vTFVQo$FT7ppiaeVT~>((@P;u8a(P9iL1NFW6Yk)At5n-y1`^$iG(y(SS6Zpx*Hk>Y>9hm^Hhtr%ytv%>2DaYn zAU{#FPEMMydC1SR=;EW~4qqf_dp$>KAVv4d;(Z1jjYv|i{AWcnyg78oqcJcJHjZ~B z_lLblnh|=pm`7Ef&o+E6KjA7B-$O?*-7F`SOf*HD+?6q!w~W5v8yQ*2_5?E-0|C-Z zaQeiI`$ifvbDZy!IkqBNHN3*@5)bn~rQ}JX+=OgKFD|9iwqiOa5$?G2ERCR-TxhWw zUegkn6jE^MW=Ty74i~X%qpdB}-R1b}o1*c~gNn;(`VokmoRsC@;z#BS=R@PDW^0$7Oho(dB;(my zdV0b>xWE2#!gn$f3c^xA^N!@*;#`)CEu?`y?^R2^Y&nx*!yB6+zkM^y4e}V8EYX*H z-WNTYqW#+&ts8ZF`K+)0YOZ;%i?u-O^t9Ml`L4dlL}c!a(+Mt4YRH%Um`?G-jJ1eE zdem>bge#c>X{@_ms;7k+7=+D?Z|L1S2|go0``HYuCNohOV9LR^cH&m3P6eopz<}rN zHYL+nSBOJS0D#-}RrWhjbMHR^>|tGj z2B@-UvYpI)l2Pn0LaMddrPHLj&S%axTcSZ(F6h_qGWV9VxfGYMLD!~H_l@!`XMyr+ zJ>wT~I2>-8UBHc^@EjHyb^Q_V2Rs$A*08Z$Gjh22;NqZ#G4uZES{!aFM1*W^KeBK9 z^Di`I_M;PGc)0TnIK7b8GR`pU4;K2iKBAAXwZEF^a>6&eg$j2!P&m0E{ilYYUmZoz z3eZDBDJwjjwAyZmSk>$dcEQG%4*S0DV|Vfd-@HP9vP6H#%7Rq57g#8$LAw@_P}}|s z_F}@7vQpV9=*%3JnX@K&i9Uoaw(A+QFZ3fKBTs;Pc=t;Mk?&SkR)+_iPTODG5dDrG z4evZ@z=9Ph9j}F*o`{e$7|w`*HQF3|qSQ>@F)CIT4M24UUQ1j4_aw$EF^>yH)lEEk z3|y*!$Gs@v1tpcOi0$UQ9g)uyK+q8KbQk_&-ck>-rZ3Kg-BY;VTqgPSz`DpnuQ5kP zUEeCh#Ah0QQ1JT$BvZSj$J!n)J%-lQ5*Nxn9Pg#Sfs*+QPHt{){#abTBI-!@;z#D{ zH0OA$eE>XbcKA&VJatT5T>9;B%b>1~J3uK%Me}ahkX{A-?$z|kQ5P0BinsYuWZfxx z6eH5TD@K+EzlR%#b&6ALQfmP|O`Z!zC1@na$aDP)a}?Ze!EHIZ0!U4bScKS$hj*`xW5d!gZFsxx?d?U1~L5Fr_}QX%F`|5larZAmgtWjrs+ zKQ2EFye}d!r^g%3%L$Il&r56~Hwuph4=Dj@<>;WsoX4*dVj9IV2BKy ztP!A#$>che<{ypxF{iosU#0HgJBXAgviD0*SXq0*DTd0Zyx@B#`B$@l^W1pbjpFT9A;)cT8e)Gm^dcoJAN|AS#t=?YNLVIv=j7_MN*>Nb}!-K4GsTU~e}{ zLsz0M{tfHyaW5aACFco@6G!yV0`_210Dq~Kmn$I7m-p&HTtE%Mx!OP(bj|c~_IoS+ z{d}NUb5hgyOl;v)5cOG-A^|azAt-Z4FH1*q+#*BqN;+@pFyB z4|%xPug4w*)1IDN3(?9OTC1Oq4uX2zN)I2*dc50+dH+~lP0bKSX6cF^@1&G!z{VRn zeh!hRW8i+n-~LxK!zVhA|L7EuPQ$vU_)OV;iQm=BUsVfX{pRvf*>&f7s>@@yQ$v3P zZRDP;GwbbnzR}^e*5Iu~mcikEI>~fGY3|mY*72f95b5ap-|Ms;fl?I3+Qz1P-9@}v z1mq3$k}Fn~O(x;hc_0?8J@cPzST`66j=IcAp)71YbkZ`1|90quwVMA&^s4BQzYU~N zZkwiI=ZB%<{GgOQ@ZUAJJEY=-1Q@a&Cm?p02QxC4CGwr^0Ozc{X`#j` zR6I<8DB8K;O{kSQ_tTTAa%lSoyhSyd`rSgP_`vhQTHpb%;=%NK*k8A`di5+nK5Kzr zaPEx_(NGkieXpHJDx2irBng@~bt)>FE*;?z-KLx($seCbCL9@sWGuXWYoA{I0MT4d zl8abZO?IusXfHy|9rp}~-jcU#;%^mAUI`B}69VO`D}KEe`W7_Cvw*N?9K*h5S6eM)fxkM)M}>HM3-DZ)N5Aaylvw()m7#zczfd;Q%>4KgSz4;!HI+S zoY)*PJWf+H+a1;-XqL-gc3tWgPj?hUecwuL!B~0noe%*N}>CFEr}BF?Nnc1Ob~t=duf@Qvj>jnK`$BTutatx8D;v%XjFKLvZsyP?#gujO;| z`nuc4Xm!zvRkaiFnYA%BQ>aIZaQyKhC1~kA1?Br$o~SRCS9L!`gbe-*%vm{}8+})1 zt5tM<`!ON8x8v^h9u__J3CTweY?zgQeLjQ8Xn$rnDh_;pnYW>QfhJ=lNnTSkzB(C<@Q>PlB+i@4PPoE`th^SI#zF zI-su|Do=gW#sbR=(a0C1F0)SlN5M58;lgp#z01k~cty zJO|ooE>&v7&`=R!X>N|-&B=R<20yBc>b%4>r6)?YFqd_3|wH&GJgwp`#AWJCob>} zUO1t@I2x?0k9ch*n{lV~J>WJ8?~P98Bl5|GUKjI8O(-qP%h6_YiNXlEz-`($jH?zZa7M4vkK{#>mIA4i>@P^|OmR(;UM1WDdD6%TuOvo6^bJpCgA zf#^+l^XuYlV&K>AK6n7KvsL5qONqSk5;93=6CvER?@zk}s+nx6n?r#R891zH} zkoyq^6*mR%cFQe&_O74MX@Jov=AgSrh@cL1)SBG@uY&@>TAgY?dMO+wMeh#5&s>m= zQ}G+;YI~Sd8IKjBECvYqpJpvC?)i`7L}Y% zS$pltbDccKXg^}WdyKse`nQ?v=ZQk!mr0igx2BLU6}4~Emwv8o0y?_sr@!LNeLCwE zKoa)B8#G0nAzdcTYfhS{iKM{0MpDy%pTsM0(^`@J;wGD*OIlo9EU&B_XHiNNg;*_a z_KE8dZ5|~K$ZpTg1%)7`W#PIo$YlqSgqs5tT)oc$J0ZWN*< z#A4O#L{04~EE)Krm-vC>VLQ17+?Su^?#Ad(VMP6%Zll%v6FMI`d&vrwe0_CX8b`Jju6ht54^gCz78e&Z|W;i5;v<st zcC(RV(R*~#=v?JEf8=(NP6eQf zk=R}^cyq%=?&}tATAQcmp%golb8uCIU7J}#OsUU2TrooBv@(&03E=)g<@GfThwNJN z%&+vBPX#gUxJ7-yeoUZ9_Bo;rxDTh4ZrXfiea-_h3P1_JMk6BuyCR+8?h0C>lJ$$H zlunMn7Ygmywa6MVHM|rIbWy%4Ej6y6U=D7R2il@IxXDP5l%dcczG4t5l_6b%5i?O} zA(cOV=*|0bPZ&gwF}7@JS*N$ZVjG5zfZq%-)P`f@@vaHf$lW*8sY@J5Y|nN9O~$mn zon83t@XzMpK$N-%>Trj{)#WpZv!lmaNX0hm%7G^-FAbGAy>=l5C+-0V=uj1}0Wx0w zn-h1if)n-=CJ=@M)+!*dprE0Fz8!cPRnwnL@+RTICsI0xfPtgbiJ**9P9N0Gdk{fG zJNenA)7UV6hv&eNix_{O&>(a{lV}j|M~zjJFrW2XnW#+MnH8eAVAU)~x@w;AqH3rc zKwK#TU|b)I57gjHE0qS!pJN|?J%S|V5f zklR}rW6I!(@VVEj)X!a-4;YLeTlL;>-JPv&IKZcnC~)JsO5{>|FNctf_h2vvg59 z_?ng)QBY8@84tz`&^}lvA3jy%v`xLh{p2b`%Tc0uHAz!EzLhDT^(_b2Zwyzkkl1m# zgNN_3_V*)3F+;RhN5&^^4)|4SZ6aRUblk&8jJx6nfRDJ>cmZb1W>f;wi&5y0?JIzA zNVgxMD@hEqF?=}p%?(AJC6b^XPP=b6=0)P~glf_wLr1gY)p3s9pW=5>kSQhfhdd|U zn(HwZ#{QOs7!YyXvlW@W*k?#R1ZP^Fy!H)0 z_nR&#dA1kqxZ?WxRw|s=1v#|%uj7Bqkc4TM4<56zGi0N=RK+$n+SJ~yD9aN#|mG9#wU0U@e>VeI$+}v~Bcx(fK`6}nN-wF_4>vWb0Ng>JrRM0QU znNnSYIl)F-T=e?h-(N76^Gn-^uU$DP9b+ zOo)X=jv0JW01&gm83(`~Y4ynozga&vTvw|!P!~S{&~{mFHh7PTO#t(uELS}g?qYr^ zbR)3XRh0MqQ9%}r`)o%3_A&L+M zo~3v6+U_1?dBve+i2Y~&&U~|cO4F_$F8`I37#jE%ZmV+I*4`d&rdr{{eTDl;1#?m~ zZm3EurC{JY8#9lrLQeFx<7}X;Oozk%{WiQaX;%V*gSDlhKCYg}6O|N_It$Q*G*}_$ zdg3u#?PmKgVj`4kjW3>P+lpO)8W=n~q7DkbbtfvoQeOl&t@i42a>PttNhe7z^dtp$ z`W7k)+7+$NiM*5uOC4EW3&qw<2JE5Te;-u?vcq{o!^gVutAjsRwHF6 z_=cD&m!9C}MS&C3t&@-UjZ|SpdXs#OwX&sj+YJp!%XyP6A~NEN-*^QfC6BcxaiKXO_OkrA@`f#gQu=hWaSBol;T@MxHJ8--=Veeea-F`YlDqw7`Hq+Pu}h!OLnU=l>*voh-eubQxM{|&cRF5(a-M-^ zQ5t)*khM+zho{njr&8<^Pj{~O;m0Ep>%ETlB*DYKJ7k?r8&5C9GqB@k_7f8m0d;srG!P@(G^lJQEC)8R{a-h?uQ=r~CBWydi4$01#E;KNeKc=b2Y5@YU2v)R($Nx9T8C>hDq;W%zj zXnUVvZxL=T*<|d!DF&a3A@ATc&Cdg*+%+J|+B1J_xE4R5WE!_Z3<|>SP@QMXE~w(c z;T?TWMw|i?{zLfcWMg(xQqti;x0KF?gPU`0tr-;9fqoZt}-H0t}sGTJmc}B6pi^={*Y5 zmsh~aG~7?SuVJf4lI2Rcf+H*b&coD&q(~aB9Fdgune2^$e`e8|zRZ^nL0bL5mLiJOZNlolp+S>zlZmrlxX6WkkbJeKxtQv3QoKx}pTZxZ3d!%;E+~In z=3y83=`uEJEi&|}>^SxCkYcMNZkQvbn^Rz=jh~H&F}j#$UA+ZN-|9L*XU*2N)UMuN%X?xo7}5nENhn1ouSVj*Bm@7RvnJ_NM)wArw=MvIUZrFX zTN%`LHFH7?%v)nh2P9g;W6%<^;%VZ}k{Ua4>`g1uOvh;S^UcB^Hjcx*BSKEV#b4t< z9e=IHkFF2WG=7PPbu((gyH~#6h(&DQdBYtXi4rl*W@&_@1kXZjW7U16Og}}#uo0lC zEIP4qT||IV&OG@5DtBqsCJM#8$VM0(%v?K~K_kg~f21TAwy`$%-qv>ZJaG7zgP^kt zfMPmpYW=PlKl~K6>G~-mDU~2{jN%JdCXOw5mHDF35(tRaRl)2LJ!JpzJv!(izBn03 zt$e7jRdppC&oj6MGL$jP7p?izo=WPRoYa}D>}0c`-QkDP)p?)75IJ;0- zxdb1;AVM{gBP0^fo%h+u)I>?)pMa!UOl1rzm_54#@MVaOKL6=rXo=%~%UM9tl_Es( z($t>WOSw`7Ki<+Ci6-r?0$o{EyNb*VrItFg)T8sO?x;A3B8TbtP4tJ0b~a9I;cU)| zQ}!kEoZB@XmFAlvR;!V@EM7az=lT?RD8Iwz^|Zp%F>U&Yt6LACCHq@msUX9f38=FT z0D%k-0*zzX?qbQ&_!VIM+S5}_jgjqJxUI0-dJD&z^1QI@M zqdUdZP~~a`NZ{*gcmJeWIfiAgv8_=f)d7_0cjDx^&@R+3?7?Rz#;(M{o|`J*URhwW4f&rN-kp2B!H*wZxFu$XXR3} zVlpG3tYTr%<5gmp=ml28Hn%`YjfGvC^Mhe`qI&1Ay_`MW=T0T5C36;gHQP$39W>sP zJ|IZtK82{J`gkGU94-D$s2qN8Bl9e~7|XLuiJYM5Jxf2Bn)=DaFp9wm9McP!=O1Uw zB{fa$GhF)H|CE2jm@lfzdig`~&Q(cP0GZQC@12jzHwG}0YXf&xl6 z?>WYGU)TLS-+JD6t#7^G_s7jzFms&eK9AVP-ut(I`$2R z`&&xkmz2Xlr4X);Vh9AxQVaqy6EZWmGUI~q^NVl^Sc;l)nF~RzxCG6GAy9LEsF0a} z2rw47@OO7?zq&Jn|Cd3z&ERmTs~gP85e_^6>izuy^Unv&om~H$2Q2=Q&aeO^a;?pN zT?u??_3ND-ay8sgOPCwf(gE&d<>q1L3YE5oI=VSXTRNFT>E&UrP%C>c7fYBm%+1VR z(+S~f0oC$yhI-1|xVbrt@$gu2&txMsjgN`J3}_5XP#HfC@eZc8&aq&Ub2xt0Q3sHcTJ0*+Ki zU>+3iX6EWf&R}H^b+mS~q2P41bTo5-IwE_vqIWQJgjoS17H0O=R&X0LK0zT%WRJS^ z+6n;!ib8iiz3uRcB))$aRmnf^eKuKSJ9Tg+dJCgP+rrt*QV}`kuOAf5-&4K)bEZAa5gu0pmil$d`FtdijfE!j$t`25yFc`AU zF3zi!$7%ZP*WED)~to-F?^`!5NepU?ib+21?%wajYSHaPo#o9Tc+tWv+t;FrbnS^PK7`qzp9Q(z@Tn!-qkTrODT_Dd_^mKNMC7v=_c z({i$d0`{A0;cjNHhc5&P!smmaqJTlb8#as^>|u&w$9P~&l$;=ZO5hSH3K*4_0D^~c z!!%403`Ipl0i%N;fx#F!za?)Fg3)r^&|D$TC}8j}sjy3XOfZD^-yTAvk9m+}U@=7^ z_moexHc0SNo|ONIp;yRUsyKT1C(Ki#Vw9VpS{)7@M(2X8p1!*4&pM2!2!ZqRGF0#*$;l7axehNiRtL{x}gQ&AdlYkDo1160$^%)uGvXiYCG4WT8&QRBdIu#?z!+FR-=KmqQDs1As+{GIPEoIGH}=s}9+wHx5&jTQ7i%Z+ z+h$Kp>l*2KS&wqausnSM@?pt#92eURit3=#wmhu{NK zq9Fi-uhGy@Q7{7_xX3mUvW)@(K}eCUJIEF;1RDd30|ShXj){r|p+{b)N27p{L9j3| ztOIeufH=>MnZ!Hu)W+CP7XYO zwE25S6$F0o=dbPj`)>4!)@Lx}kD4FgM!VulWpdOO*@kT|YcD3IPrG-Bb4dH?#$xQ9N~<6R9IPweu+Z)I)eyS z=Yn@(?3eT>@#Ri|IjM2AX>=aF=t7G2bdvmSU@h%r=q-AUG4YD$Is!yENl~Ve< zU$L!)$tKihTFpAO(CWYQdp zG7$5BMj;X)bo>m3xPROO83}m-k40X_AtLnf@c4(#@-je>J`2Q1^1q(=6C*X8oZNsw z`7;voLHL1a_*Wzp2AX_-BH{m)a2$lf`1iE~@CCRF0RVR>*eFQ9`4A?Ep;X;2;i~jV zyZa7m=U%*UNy?+#iILz>St@xBIdA%dPxX&(=E{-CnB+g*w>k6O&xpYB&!o#D;HOh3 z!eNFdJDlhgqxfFR)`ZO5`~k15-r)!ciDV>S{5m7iN#v$7aD4 z^CmS~I1Dz9!VFDPWhPY%4}1p?MQ>T};ul!huNHRE3<%*Fj;~V{w_CbN6}7o`HLB57 z*6ONyT}{TqpOY?nT7i>yf9YHokW}2IhENzhf;xFc16}Azz5;T zawjfTOyp+u(NWgAxWTu;1xDiOAolKr)|`bE$vpVk2A#fr;+{s*O%7c*Db`ZB?BL>q zTxvU!F1G#NSIKZ0o9sII>P)ehlg>GgGwg@toPh^DEJ|(<(@T%H(G116|2c z)TdX~v7^Sy?zbL2?}@?{H;7~`ZfC|iB__Ou>TAN(WVvFoRJbg8^xm!N9_2`^ zh|i`kb#H)KLHHqBJA<1>AB`cmTI928N8KAn@aQGW{L8zD=$Kjkp+Dsw{F_-`i+REvF`U_)p9PhyC<4nmhjn zksg1r0>BtM2<(3oVWj^&1wjcD{69b#q=za90O;lhkwvbU4(%>P3?h;vlp_$v_otu# z2|54j#QuK+;QyJ4{X{HZy_mM=bxx@za*SX` zB7sMP8Se}x!R{$|oV&UaPhOWkjO6q#4IPj***2|v^)TKli!*B}vTW@#s@ak`+&-Zt z^U1I?_LJS>X2ior{o@kCDx=M7R;`HdGdM;<>RnY?E5{7ozXcPspsc~nXVO`-ReQJAN{L)~Qx*}`uqaIE`N=7$noq$VF}YjMy8oVD%YbF59Am+;7uJlG(@ zr1bRg9K zx`)n7fK2rN#!Vm`e-lQ*<)wyDLV$!8jd+@}f&Yr^^=1%lA<<#Jn2VaEpD%>xUtOW` zGNRF+qFJ6e2V5BxQ!!DASDuFSoh7F`X&q$(NM+KNTwV_m{(J8{ysQvr$ZZJlV9?Bu z#3Ub~5S06|<18T9m3cSu%Rb~Jg2916WzLW>z5o>U&} zjpqA}C_c1c!WWalL?@A+X7R}lnsc})^hV%wii$MNdEq?g)yqsH%LB=~ijC*;gQOfk zyl$y+&0Bj4TG#-^l^{I~ejxGS0TK_g--!p60gm|0n^mK|eY`BKPctKb2VW!yL;N%G zV1h6p(+F%L%3tJ0(+i+k4sc}l;pFP<^s{=wO9P=o3gHkD{}TF{XwYjyUEP7S9?r}7 zGyVXn2*t14>aI?f2n)Br1n3p`f3q?^fR_HrMfe0DK=V&75}3<-6GDI-1r-;|!VJdc z40M9r!k+`<63IF_x&bvRdRbSfCGZL}vxoB%L2mw>J1+LGaes2h-@RbsVriN=(m!y5 zL;uKO;bP00*~5Sej3dnKpIQJm@?YivCMB_Ub>>1&!pRvfWrnPuAejr`EB`f>0V7ix zFp$cC!JyqyP?2w#M6z^8H5-SDW0$$!6g3%NLy03ndW-to{nllBRf}iA9cC5x9zDDz zadXL_2~oIx#Z!DvXm(+FD-*&{9{ku0--@)&i)=QWc|!L4iT?TA^N0{AU7VHWCZk`s z$!k-`QFK}jtq<~G*AZ5fMNKrY!O)}^BVIC<{5Lv(gRj@bN?sos)zC4E9MFjmyOtq} z;?AP;x)@250=KO0n@tKN>+Pq}%?xXLf4mphH(K^tsViXmxK?DcjJl=PCQT=+dPV0^ z^tB}|FWrj06`TEzg8`4-Q7BvY(?)ja8g|0tZVk&5tJJTSEDmpI6ch*)*Fw(;K@U_h=^cT**BR>S0CPi@3f!FN5pXEIn+*(3uL2mV zBhWw=8DLg03!o@R4^$JO&TjN(@V`A{?ghw0>Fs}un_0U;p+Hg5jT>TwoDUt^V~7?+ zBS$?)?Jq{@YzN~4Xeu|{%fSrcX7iKdT9}y#n+aO*n?Wpu`FVMT1t3CZmX^GtK)5ou z;5E14L&~M!`yY) zy!ll7uT}-s+URb>2jQBfi?;vf|38smC+1PwB0ctn&CBeP>)YcJBrlq#I?h@K4F_wp zj=6|VIa%*?k)=8Q2&Lef9oLV14-gKN80PJqy?$Oy6jAX9PoF;zj}+EshP8t_J7gCigUf z;0tynvk7r*VHBUe*qmIpc~X;-vz+Jt-iKh^-OIs2vzag1!5cTdYDs0&9^Z?*e>M1? zN%NT)OGs3oLXt_59Hywg zwyE-y{rAP6!YRAIhrE&4v;Lk|-B?Y@$(B+*olrI0#C5a8< zQx{Ed=ILHTF1*Jc(L!Hoo|J2aDd=Go0H~1*phm=R)W9vS)AET}AHj$~3_MGZ`225H z1F`>Sy!?LyHGXqjR3gG((fcQBm6fJf;6s81uMjUUpXgs;A;1eXMgD-r|3?`1KT+9w zI_{R18`Xx2_E)&U<@VsMN1k``10*AgDyyDa&KyO!2cDkN>?d7#rbeg646W`^YfIw6 z^*shFZxxexLRFIYFe!FBY2F8Z_Y#|j;y6D2-$zWzU{}?CJ>cZtoLd}j^RErr4|W#HVVp~;kQaL#IPt%W-O7# zrd^GR40zK2DV@<{=OWUZ(EiVoOyR}KeNHkSF05J(U%I-CGur(LKcdczuXG1%Iq*wQ zo=BW@dJE&Lgk@P?;my>1;zcEQXav1`=ob8dIONW`(5o+b_ocT@+{{GZ*H&vr1WMY^ z47pHo`!|umoKYw_%=2)QCKjnx_YgyAs;Wu`t?5)IwrMA72N8~xW7|@~uZYQy{P45w zsOYp09}+Zi3Fm*$30R9;3R%7>$;ft*{^Z!Zxb<=8dX=RuCQ0!9S21)FLWF5(1SCCF z9(kwo9~mH`b5uSBi?iDk(X#${#WrY0#eP3_s(kXuc0mt3{+qDwVr_?i}YI z^t>7wTToI9l&K!LGbIsHPf2KK8o%PML9SbHbzU?Jso%N92O1BU_%)q0 zQ7cN3`bq2@d}NPcR0A_!oHMA#1ol z>+1k`VnTF&A*MP+4WjbbbpS5!K_vcw2@05$7davvIK@L&l>RlO0}O7#0{{#UGVd~h zyITN9M$T|<8#f1gfC~fAcM}cB0`mc<<^5f&LM6i0)Kit^Le}EB`1$`v)Bjr-`a4Z8 zq+WK=x~)Ur|x?M#6x2r7Q3o!l_%onHMM6^6K8@SQXMCdR#oPE8Dkk4X<3dV)#L6Ke&Ra(P`T zGB_s$y>_04+;X?**thJ|Vq@{bzJF5^j{vRm<d`%%W`^==b7 zjO!#W%|+DB5#kWZ7O3zW-{&Lz+oV}t!v6AB9&b$@D7AX5X{i*#NmH~~E2c?o6ru!W zW_xL{;ZOF{6*Awaykq3zkk`_PZDX9e&#o(H+_QD4arxx&QuD5`)tQz|jO(72uCQlL(_y8?Hg+OZ*@^VYFW#vUevzm5K9&6n?2rx0#s_^Ev z?wj?7H#)X*ip~t?>q>U2?R(R1ne%Zh;ysjB3m64k`6g=eY+d{=on;kl4V1UVcok;1 z_21M#of-BRck1LCHJ+``ao=jReihip?sXV?v{ROePk5k5Ht;n9rP}eq{>Lzo#p5Y@ zIu(I;PHU;R$)EB}O`2ulkS&>O9M3l)&tmm(T7I3x{^#$1H1Hn{{6_=-(ZGK+@E;BQ zM+5)Sz<)IG9}WEfUIRyZV9@l+f?VZ0-uL0TWDgf*JkFtXw(-!nN;*y#A7%R5+-}R3 zJFVZT6jrIW;mf&AySzrgb@AxLw~KK-!g?mmh)KcdU+Y@oBuc)d;H=J8y$a3r(PX~TRD_q7-+BmF~v zdGK{+YEET#E{pWOrMQ;71PS=|Z7T?VNz1werJ9{aNyF@g5>~s|!!b*O$rzSo1V5z6 zn`ueb@}uVSPg|P{oRoKxM~=@sY3AP)7~df@c-tIB(nP+f`{_A>EIF!~dQTRgpHwzX z6Tb*<=isv0ild*+5VlyNdX;jz9_a!rE$G^yi~3>lxDVB!P!PwLa_pFZiKDP7B8p zp-drd33rr}IrXXp-a_fVVCz;{Dplx6diq*wn16OX%XEG#B6vqIc7?t*(C2Q6W(IyZ z6$py~RP=2qaGi+g21o|YS%r2S9|RUbL%FI;UQf38hCy`#R~=A2-;~Ux$uy`iYOH&; zVGZj^C|Dr2*87sod6;cHfAv8nrNb+J-tm~Z>A5wk)MKj&6_B%7W`y1gy%z!%An9mB zkbLXo_Eq72-fT21`jLehzG(?GM#b)2ufv9j9O{bPce!HZST%vpHm{scP(U*?Gsia= zazE_up4o1H9uHR`um(mnPC|E6PWIMw+Iey;F4V-;x1#pqd19)7*!1?Gn$nN_qQd+} z^rvl6XtrrQ8piyo)#s7WN6PcmTQgNrIo$PRX&tUJ8ZWA5^k>s%XJ@{O&5FMg6Bqa0 zcGxxv3Cf*W!%2QeUbhEmFH(tgm`iUf?CQtWhetbd$B~vEd(HVFofkD@2R9b_%QDb( zf?(v&LIq6mZ5<@5o8wK@`pmfyE+!IV1HI&c;vT6 zgqc%X+P641WwyNrf?TeiJ7G}K!pwc1M$lz!>mVQ`8)hA#8oU<8ErDI@tv zAiQygPdL2s)c|jR*ry4l-j!p_ivd;DcOSw&@QBTbA0gb`c64i}f|~CrYXKU?vuoK~ z{%SXR7dB~a?a6a&Wf}e8FrOK`Jl};zX&M&T_|77ocPtuYubTx9=;&Ik)j%XN1vOVp zQ()O|n&k|-Cu;VN%Fe%OG0RaS$63VMN_&;l^7?g2LrFt^LCNXp#6(?v3XlF-U{8r| zmB1<#JU{Ygq;J-wNlbk7JTs&J8%4v5=>;^MJbPb-NEgk}+x;bhFNYi!Dpm0gbxj=~ z*E|34c)c3qDn~J5rDdh)NAbzS{VPmCG&4W7G5$Pr;H6mB&MTBashrZv+{)&L%FX@4 z4~1kYCJp^4%>`yit%lVYFTC5_Iv6|nTFu{_5<5WiJUcbcW(pSF*j3va=FGd}tR6d8 zsT$(#VM?ny|310P8&4&NcBCbWT(+fNtoMFoN#AJ*mWQHdcEG)1Z4(`xskx~OB|E!W z@xF>0PETc79i$%FB%0QCySTl?;}ck0E#r^4HB>UM?AC9@oukQl!j`bY>n0`&&(6Xs z(kQ7+oa`KC-&&n+RWna>=~22>1vtWnzlIVRXRW9XHM01xe(73Ki0+Ffbqqjxo7GvM zXLx_~YbGj=>EM!0ze~a1`>w{9b$cCNc(;qgEmOa`7Uyv5k4fyZlCc%4-FtyZeBMgw zjZx!;C8BDRUtYIk>1#BP$u+?ButK-_;!V3_GAAA-;1dF@ha=(XkgOyeIyKN>Z*Qev?yM`7x3>CK#5{l^*~$+;*QHcYr1P({tN^Rp zD}*-o@0A!$N$Co^qY-|fPKg1p&sf;RKFM1bn3tN;x2VGnpL}Fz1^(i$pN84PeJ=q4n9x^g8 zfI;CQA!wd0#?Bx^?jO~j8DGSE4<}anp>ETz!0vE-m`X zt2jNBe{cYn{aKC2an^HSDx=wlB_<0ZG1_)(@&SP{y!bfmnSK%vMk?8OhKzy&W^Z5L zr|Id4vqrJ8$;p?c)kGvDBpL%=KX|G+DZ5>k1Q*%HM46qOq%-}jbITJezA@2;r{wOs ziY@=}j7v_#Na+hLE8~1?$Zct5bu_!mKfKDzVe&X+w#@aEDCp?u=tJX7<3rB329XMY zfe@2Snp+LSVyMg3&xVL}Xh3@=~n)>>eC!IIOCdYHj%khD! ze6iV$GaBKfhjD4Q(dMg@eU-~^+T-P=&-Z1#R|QK4_jPLur_4C39ub47xw3u zbeh{Hi%EB-CG_p)qo+)Hi*mRSb{cWSH#R<=`?eTsZEcP3t+umi0M~o`4$3Wa<2CW2 z{UuR+3W^tsN=nl5@)+{#>x`nJ6g@pXXU}NYR{6KAKay|FZ1iJoeIR{@f;by#0~br` z_!igI9i4KtR(^Tp+XX-t9iW!6UGJk{e?uWh%PSM+wdm{@Nm*<8o309Ftm_J~?}Wu^ z$QCYRTv@~(EbpH#?VqY^X`z|C_`;_XlLM|nKTORXbm?u_qs9cb;wFQ#IGC!(s_S+|x~9a0iUxv+I!1VVBtLp@eA$y!}kH-xCGig zJGsV>eOLxh9A`@+Tx>pkqw6wLjisu(nwQZR4S0!H6<__tVNK{^?HH7JXK$5%c}6a& z&t&C>Y2WRToOk6{oel5}+WIng<;y#O-JWStE%;g;yq&vX;i0{Ucx0t-74(Sql8~)Y zdhwgPe?|lESZSy?wb<#M$jC@Q6(O$Kv9Kb+r4aPPz_3PFN#HDPWOVt^J3eVGbn7uF zIp4GgOIyWE%v3hf{%hl!_cv! zrsk;0WVyaw!wT1-BA`@+0hQ1_es4p^E6x4Fe&d9=IGbngt?vR(b=rxhTCYJdboXL{ zF$vfMMxzw!awMB`)%q|3GBOM;EiK!C0LaT*X~2tMd;Y|_KZmv?6Ym7oh-8hVVq$FU z;@j3Z=@b{@Auvc+SCD`?~do7Wa|&T*7tg<3x{j2!cLb>dGTpQ0*sp6bIZz9@Jxaql8$i| zE8rl~)`6Jd=*V4FRh2LLt-y}LOqz_Txcd1JIh!Gcwzjso-Jtfh=jq6rf{J^+r4rKa z8GEr-rLNmAs7pE&Om;t<@A?Pu_1vD4e z@3AhQVy8Qi)#l3%}Rb7U*y%rW58ZeK4_7|QVM5wB)eZPjgheb4l2z2x;& ztsNOYwMZLi0Bf3bZ2HMTHTvN~pqOf3f4`iX8b03$KcU)Z{#$-~FBG@SU*Wo7Y9;D4 z8)<5uw`g-b&cbP`E-*u)i<|e8{YClMz8-(?tHeH17M4b@?W1=gr$t=hZ|o+yzs=O* zY&$pvfYrH*?FPe3n$Qp5g^GbhGSyZ+;Y)|!U7I$7kpf7|Z8W1WXG94!wbq7?mmVSz z_Y7)XlhECj*@3uto8#8Uz;}VCdbzX)u{&)(yDgX|FCJ<>rF@4}b2sXkS5|m*HG`RdrWQ&a)RPeT2e6gh8hCV}MJZ+RFO20G(9<3PAxipKYd7m8W`7XHLV6M_pE1 z@b*!28ST9th>ms_V~>v9Wj!N9_0;QgXj|1cMDT^u@hB)L$OUbQ4Y}7?Iu~9j@*?Q> z(1bpJ=C9GY8y*ug7zRWj1yaKw(TkMC*09tblrzX=^{h#wbyt5WZLiwCSjXB|)zsGS zhhL`};4FZ(a|eY^TS*&n&jp>)2a8>1rKLso_p1Qr{&A9T2HmJXpIx@Uj6JuYpf+!A z<9zdTDQT;{{?h^m9-J>7TCq-EXM50=->IcT1GLPBC5doup`iLWkFCnF!`o$gk; zt|#oiKzNS6VuASATVcBI%!ST3xtH)ih)qY%xZ}oFO-6qdZWK8$ilax>TsxlY>x0O* ztWl{-RZHV{0FNB38X39Aeexj)(6$2%s~6~bn1A;AonL#6mp^&R^K9yE$@$RJCPDG< zGj{f*P97l%4H{Kgem9;3}xZBkIz1{&VSXK4?GnYq+6+-H14jn=yp?$L{6A=>`;Bf zi?*kS?PG7hoQ6iilcLTI7T2b-Rf}wc!~J6S4xM*K2AcaVK zMpE)J$_jYH`tvi$sh_^mV6kzo&RqLOFGH zYAVBnVd%auEu~vF)agWBZ{K>Ju*!6YnVC_TW%3QU$jeZzNTe!Y#Z6r&rwf^H`L&va zdD9b0W!7Y$-Q_AiMjw;Lx^?STTxMo;XXov4{!(oLAcQq6mQZd{MY8vDOuW{u{M-i# zuN3%b3HHU>%)H!nGJqf!k}CDrqz)kdr8`XaGc`&p`Z@-f_G##cAJvEY`ee<`8TaI) zbu5ZPqq+k*Tb#}@{_0Zx;pV5J^LY}5XZED>|V>D5C?_QT6siXav4>5uopOsGO z*4(R6QBe`TxQhuIQ~vJc;Ba4A8K+UKNnJKP7>3v*tJ6VNIFRwyvlFA=YY=HIU7g$_mcQIuxuiecYJ-536P?|q?;@bcTS z>FC}dF-DpB%*2r9=1(6#ew31zXZ{dF5e($x{p9fYr?8nezF~Z&P3oNB22VvsrxdUn zh_Il&aFaS9G7`IBK_Z~>k#T{_%@82ie?Px0u6QjAhx5kh zs{B(q35%1?HR<%mC!6busA zoBFAYrclCrK* z62gQ4sv!EIH)NLd56uR7&!yEVtpY1QU@_1KeX)hUc9X$k=U}(YVVf-21xg{qP5tmZ zoYuNJ(%M>t4Gbo2WJI&IwKY7xR-c0pFWzs)%St59FDmMAtnW~nk0_~T=iu^jxoSR5 zu9bWWC^+sxO)uG9VFv4rCLU8`CEM>O6V{c`K2q85_#VY9ckV1VUp!ICx=Ufvy=u{) z%A0C`?_p&=!^g>#_Zh)hc8!^#LV+`UEW^6%2X_MW=j8(31$K^mdmo?+pkg8JWTR-@ z+&L_M{rbN4{ZO=1Zk#R3VmN4IWF#&*nR%mV3#O8}vp6%Nzr3I1?{iuOrAxD_Bd)Is zki|S(@pHB1Wii@Ktl!MX1;Q`h5AUDO)+9EyB%s zu7`t0g1$WyH$+$Fq;@+l4$mB>)W4(I+S!6w-%!V>XNy52vA$QHrrvWWZN9()K|(5S zov+^}4DY;)0Vx8pggif9F{R}%B9)*b&_Q@V8@c30^(B& zL;FCPkDS*$#1wN*3J?%Kd$hW&x^gU98D4I^7O?kNJ^9QS2>Xkn)2b3$pk zvXaVr;6msrIG2z>@-j}Oi7F5~6$q!N3Fwm0J>q^kajNNCZF-^MqUe>0YGX8WtTiQe zM)Y#qemaMyItJ@O6MU2I-p}4&8uuKz(&ejL_uV+T1T-ac|9&XeSz4Oe4Mf&Pd}`{` zg9EpzRdiGOdvsQ<_s{ak)POH>2IUU!?d`FUJ+Wx_4;ip$J`|SmZQ8m zXeF#R!l*3_rpAFYJu?n@+xXI;46v`r2dKk%j>T}5cge}5T937sfI4mQtFnaf$u86} zfYZoFQ%9VgdAqr}9o#_X9^ET}v)dR$`z@rJMd#z=6ST!;#fG(31C(~j4I;_t2O<-i zvnD5>2KJpiMeayb=qwmO{44iV?_SUC7st%+QPutHt?1)3V%IGp<==F_F|BV#l37JQoGXNX&|I{F%s z*f+j&adDwyBPu3wV!ML}WAHP?J<5kT0lh9ei^L@)1Ob6-oWK8yw24R)Q^d{PO&~ET zdA`MMb0ivrg0m}-GpD;`VXl6y!_Mk;bAswuyi__u>>no|TFtND`I-mq91(C8TSK8{ z6J>h3Z=D%PnFq#_DIZnpt}_7MVX?))hB?m-fuyvTyR?qB$`3Q+)>yc->S$>_Ri~6! z-?*bY39#rlZwRdiGo;kNIn$(4@urm91YGQ&L)5 z8vH<6IT!tldZ72?$D~$6X~Fj;LPU}%`fGPw(+1ab{ipGrgNQW=gjJ$Z38fS(^WIB| zKRy=E)D1IkTE<0q;}x$NYiI-k)j!F=vw{?3?DT;!b;SUBtS{fb$-!VH8ugN4KT~a> zI`Z-P2>B%`Q`gvLHS;bDB2^r5Hb&Ez%w28x-Gve7i%XvW_Uy%SZS`ZL64hO{{@vMq zi1BQVQZ?d>l<)HU&{PRHsUu~RetPL_B*uCfNqH8%JSu#6dTC5{rlw=8?Hdc_8d?ae z<4D%qMR1#raXCgII>Nc%54p`Sr5iwcy!J#Q^ep5DQCxcZGj-P6mnlD4-8b%vUr~1&)Q1`2((l=)pT_2atjkUPTYMjyejSVNkYN+tWY;yh$TvMKg#hW8~ z>t!5tAyR~_8M!EkvKL)6XG+$S*Bl${mcmN zW<5eR(oVe4iVNu&lWgXO z$dm}xD?7XI<2oj}HTiP17}gkviK~`CwQzNH_5Ihwpf`lVfsI2Ovewqtt$@6jm-fBt zMaIie1=`Z`Z==)G)9U&f-YbzL9Az*IOn|OqD)Q`juazJJfHD;iW+TCVeNa=Xt|+-W zzVT1rpKnCGJ-aCQxC6Dz&=!DLi?_kJ;4i1%lJo1t-Y26EV9KD@wDxJY(|HiQ>b@Iu zZq(HBzNnwrT3W)p7>6DU4TY79t^J+vIgrs}XKnDht||h25Xd2zxCHTp(xU_4o(SI> zLzk8Upjh9);M4S{!1D5PztBd2XaKq5H`j-r15Ugslr_8vDZ_;Ejs45zUXF^3itj!K zTR3`BbRY-O=Iyp#VjZ+5$CVYij@8p~ad81? zUT3;Jd}L^+X#n$Ap#i;OFI~tGc3P+n6F1o6*OS^+0KN%*9b@FuqaDso59&I7jQORZG96v^lU%_$Uxnj zXnGv$PYj0_pAeXDfrfz^sn+AibxT{N6?LDtE^p&}xy)Bs@VA|hd{*(qQDZ0M_RDR6 z3q9AaFq4%Iv`>OV?!ydaC8oDOywWcHKJQh3RAOLMs%ti=h9*1Oziu(Pqmb|BV2r|O zFltNKz2jHp6>Yu+6jHGXIg7(X8>8zPdXhmbEbb1K@VYkvyLiR*b#-~QwImJ>4p=9b zd~xSQThuIS5u9rBFOSj?EQRv z@vj&m#oxkjq5*hB&hza9fkJ!~An46`jBD%YWv-p6lMbJ&@6yhAJ0BJ(^9Um6oPD?c z20A*rjg#G|6E&Lp@dMIR0%knikAdGE-PNAc;-bROUT`se)Lmy!mBl-!4~qQM5um#> zMjCu>L{&fbVJrd!{0kj{2c+H}xoT5lu$Y4A`O%eGd!Z=@ArWePAT~_d3%$*_(SfoB zz9pse(FyC&LLs)7=@Ewa=D4$Z{j9yBiVAUG+>USy^Q-RLy{TfD_yF5-8qB`8xWzfC zP!+I%d3I?)5Sz*GcUIRmN}5{UL&4GSfAHxt?^$N=mv>!kWA`V|gk6q7LDXOT`sZ-h zKfJN(J*9rO_2;tyh2;pQuO{eFNV3zx&M{E`Nt;|Gk-I~24qP~n{m z`A#kJO%0gwG`5POVjS5`iY@hu3a7Rh8u2`1Z$wV6<4RYkF*SbC#oQ-5nO&GjWiCUb ziK^;AxAjm~%W0Zjd8Jt2AyB0{uJXH{=&*1~ZCO7#Z6LZeu-A#Q@2a(O)V&*T_${qa zWH2{t`_LR2iG4=6&Mc0ry;0yOzWs*xYD+&{mIq4At4V;dYeZ2M<=tDA>GCK?){oCW z&5h+X(pJjQ$bqW{sd9c`*#wsR_Lz$AeB#Rh3II>o8NfY`!ncUJvWHB=y~#E;y2fIu zMT6eIXS|sfjJ1Uyj>@eQ^kistgE6Y#e2ZG7rnWXIThiCN5U3m`p&uBJT{oXkU6fjv zP0auaZt%A@-{bjkpqvI@{lG9b?r^kKO8TeTv{mg8~zF}^U$eu3$Oqp9LmeLqnjXsTBsvAe|P}BMZ@UyQgM2Q->2@* zb}5ZrKeBtpua^{eJX#lHlSzAIcA3Yzyb0$kEh0*&T5>*;`Vv3()wiWgc&@qh!*j{K z36o|lSO%-)i1<5oxO*;<3H4O?ONCf`_F}*vL^8Q~quqE4)%Km2fHjFf%oMBj9)G1h z@utogh=9h!vbz#L2AW70&Rm_^FJcCc%{O9bK9jxQY%9CGy-uZDJd`Ctb?@C~mR~v{ zGiBFjtH~pK%;F}a79(13EAtnq2|mU%w3epjx_REhJ_0))p#GyT;Wam<dW$w&K0=bdTNc;cT_A;Czu7)1+(p-lm#ja{O!|pn+ig z?dv5+FU2&J{*%x%uhY}F`-9?@+|U>An!#E?x>00@N6|KCkEI{y(nY1W&hT`Sb+8=lgM#*CAqTJ--Jc{NBX({>-1+5#<@H0 zO+N+@U%x+lc4cJp0i_{=JD>TQ4+qGBI-+D_F}7+918q!a z2U5K~Q^ayw9M^e3-p5UTCN4g}xv6{%b;P%C)FPRKZviHiIC1*MW7k+X;INUl) zvJhWaeYYH7c*P4Lr`zfNK{Pe{>18LujljaROCK*Er!3m3m!7B#KnSS#t@mu}OT|9$ zdVMj0is`ufd?X(u4r+93NpBICozaD86cfn+fzEudUy7S(xsD%F$nl|aXIIx^E8b{J zJ?SQ})7zT?rfB|%%e_5$CLSJw7fkYAnUxtG4v0c71#xl{_sDiXHeVP>`&vv60A&<}=D1{*mFAuFLk-1*o6 zJJNgBCio(%deY`Q zlJ6u7%h4Mvl_kzn#lHHn$kAx(9F0#9C@Lzpr8eJuG1suFJ26?kw-g;p`h^p9D@l&lJjW z!9vu}MkBsXET@oNwVlX)mRmOE_KyL<#i%l>hD+N0aQk6t6Rs=?UyX1CIz$?98KR%f zusTKUc)U#Y)_d_VC>n(%YeSo(D8frrTUM3It$`EcgG5A$0{>~0Zed_}#}|DWmsSph zU{GtF-+}b4xaZGal91!!L)eS&kf9o_sE&?YJwbra0gYsBjUG*`_?fAO zq-NV2M;m-wn;-oNCH5*tglJd{h*-Z%<)>Z>qBeW1lZrmRQO#7nhgwEO5MD$9^(N&5 z9(f?2OTFvGCm-EQWU=jnao9MB@no-urMSF2IY#1b4sDhwaI_Dw1ZdOs)j4J(zRT+k z_m+!#!O@g?a_)x$5Pur+?|q9`*tLR!D(oySDX1cYmP1(TDOV9#h?je!c{7vS?kf`p zPF-PZt=)>;9CMqvsSEqN?S;NhFXxPdVLe267VBd)w4Vm>!PJRAR;fh_?;eW484s;l zRMNaDbxSO$y8{WOG4V8y#W896O%qclWOTxGoo3`-nH8-%*xI5Dx%B&FqELghsR@~<=sboi62%VR*I8|>6xQ^iP8(wF3IT`p+{$0uZdB=YH`0^K zV6U&Lx>cl>DaT42G`k%(x|w*qBG7uL`m18=sE_rECl>u4kG?M#LyNO?Lv}_bBHi*~ zC;G}D=5AFkPyo+WSC>qFMJX_Fv@e90tM>bm%wB!k87IA4h6K{(B{q3x^y>Ox*Oi{d*eL^L;sYs&pCUqHRo@xBP$xti(%2N;5X4tt~@YO zpRve0>RP+7z8}oy5BsUXBtv^oV0N?|e5yLJzjB03rWV`(Z=XB4y#Hq1*2oM-WuCz= zU*D$Dtdj>JBLo3H1n@VoVE~VDJFeQ?o`%79WE3hj&7mKa1!LBr?Y+INKWMCyzn3U@ z68Wih4!v%Ux`BRiYgQGhw?Ipqr{xFagX;3>CK!9To_{DL3Bd*LnsDS*{RTbL>x6G5 znEf37THvG!t~0Y?HG4Z?Zuq0_+4+D#?~aHzFRYf^7JoTO4fT7TR@YG8E^qE8>@D9S zio$w|bx2voq<=LcHtC%#nfj~%TCP@T9Z3R?os6!B2OkKX7qYO`p}W0@o!xWTtSj`gVEkt2GB;SYnPR42)G_; zJC>piq&aYV3tc0}|6w_Bs z8ae=^IDoAJVAVdNuN9x{u+_|~;3oByX22ZbCAF;jM{X8v6gGSd2COU{cesFHBeTbM zrYy3g8m%PqjE{j49fS(qAkGJ0>ndZhGKE%7qP23r9Nz#{(kThP%{(Z%_t2;*&ob=411I>tK!P*18o(o$0$x~~}juB#;wb91Rx|1mn^ zqp?C;>Jn0dp?m}MvXdML)W*+;+W z5t{#;T3q}-U8I;(3jF{GXFt-@%SEV0%^xyWTUWoAsL{4A6LZ>qSQJ=PVO5YaQO^p9 zEQ$O|<9d;D##S^Q(vYwnmzmkIzuq16ZMn%&Kmm<7^!EoBDJ8$BTci`6tBO}L79|K9 ztI;em^+RERhMx`;u+?U(3}a8tLyq_6P9Myl%>WpI3>Xnuu!+r}Xzo~($PdzUnf!D& zY3i2xhg@0d_Wg|(5llsWKf;JDJzMB^6>?!Ak-rYz&hRrwFk^y&TTS`3uxA%PLeKu24 z(C%Z;?WqLalndV9iB9NOE1UH6{fobT5w7e2$;sjY%L{_V!FRXPZ||Ld#te=vDFc~o z`py-6V$UDlyNsB#K^D#M#R?I(u*2P0{U9PzGXR-6)2z&!eYS)5I*wcb8Y{g{?Kci=4WQ-8*$~tVip?dTPf}TFZ7Mf;Mh5e@Eru<22 z04~pfsk0Kf9&v2@HW@~I+lsDUY$!Rhe7fGklOL@RredHI$#!yESXfxia^?>1v_9-! z_4v$`BCf-h;!fQ(~cV_}dd1ZK}_L_YtLnf&#DS6+>!T+7AH^O+8LM zFT2#s1GHNK(7Q!EHqT|^IyaYWF&$x^%H`7|_GI&ZdGaEAG~2e(%*4colgn|DH37@1 ze9o_|f7vFg8z)}dnvGU(E8A?{V!s;P)Zuf+X8Sh$>wQm}o)wqV{G_*Au7ebDsa|Sc zG13`W2=UZeRO)rr5Z`V2A`x4B{-P2%91>>#N&))ypPJ<~oLp+}geNO4Pp zjEW3D3maVWsGnfAzG_+_$a&ie^(5KB*z&!-_kLfENh_!S;aAcyHatvpbaZh^$z*hl zvLIEzToq~ajJ8|bWE?lAePoZ_KnRgRcqB_3GE0(m*9YKf{Gt;K5LiQ(-2-_AibAAP zszC;pX#2k1M%A@VP3~iQr7}jXd-ENd*&eu@{S+Vltj;T8lt`@2DX&J#a zg|yds1t-^@j<2kzJsAgc!BuJ^#W17p9Y+{X&+SQo5z3lHZ-Q@CPWzlNp$p9o%)xFV zr|30HhCatE(4|furGPk=)GZMg8ZNavu*mSqg9> z|KsNpZ3cXC4O3dhOhFWYWdmBj>t@TbqAFkk{>lyq^ROZT#4d2SIGUFLh?a$^MLj1N zR#Hxgk^19F3(Zn|Tv~B$u>-@FD0_kb4)J!W64CM3MC^k=`@8*6xNO8}q8U zKo|^F7j%B?`TNOiyXC6Jz-lp2D9iWz?ygy%Y;I9@EyoNszK0~UQGG$>_EsFA@jX_y zY7%kAF4qe6=11(1Ml0=c?cnge$eNU+yCC$nQWxQDCG(>h0(V=rayFOeH}*9p2%9~0 z%z3Kqn3yt=zi44r*)X=Hg+E=$E3r9j#2FGqW9vDN?EG4A_gMTRkIjBn@SCYAMsmR_ zjmu`9zJM~|{OTpOpEneWPc>{27e0+SsL9>4Zm1M(?lcT;6 z`9bgkUe2Z#pO~5o1oV>JvNANl*eJc@_Y(H8ED_)ppxaRrm9EAE0Go5u61?lUhVXNj z7S6Xx!#f)uzETDTt7tf^{n(Id_y@1BMhY#@$y`gbrM#f~+TW&?w$q5X(8IY`Y%IN} ztRJOoMOKoWnN{w1Reoo5z{c@rH_1Z=&xI(y88`hx|1of4VIf3&i$x zzxv#kDH({EA6wNPt8}+*YvT(VWZSv0RV%x-uDGAwz6P~URYq&Qc0jl<_y8~S4etxNZmDVEhdE4hbY;tx7WrC=w~vHx~fiJ>p6G?u&PB| zeNa?HDdLzpI71>!_F^d_Uz;8WnqqW`?|FUl5xMf#|3>nHp><=U{w#RG#|SxXX>t# zj7S*^?V!F%Kyf+6OYFb6zQ}MO)xMl?Jpn^|BDib{**xtI;6gmb!R5j%3$$m%D9Lb6`ecPGi zlvDP>9x#Ou)5TXTHc3cDkiv&X?QURm>)T8<`F-$n$)^hI8|vp`g^5DvM$bIOSCa}8 z5)uRTX-5KE_#iNjQY}+cs`2Tz&2x);X{)FEbXh7VwGRa>OiXBUNh~2e!%L^i zr`Y`G-C;|cgitey#j7~Ye~_1WxANZLFM7=?tr}x3c|pz({xAQi0O#xSgaNwUC}%R; zSj1g>88-W0nhMi;jWGTXxt}yQLw2w}vDC(@$C}}LUt^{7`RL3jlW3>fyfw3O{2iU= zDgdLZs>NvfZz(6Fp^7wXo@ zWa{E4)eP_!B}6<$L%M2eaM*8n;z4oj#_)P9NeE!PV&`=D8%|nYp9d~j-_Dbi36JEK z$wz&!SJu`ej*)h6yG{uTkn71SJS{D)BNBM0gMp)VzCPxm;Y-cl<6^yanD_YYSD34} zw1#u~=_0nllMNO|1~FFNW$SjpGY&GU5pqyAZ1?=gt#{t~*Yx^_0h&+v@lsOkH#`V|wy4!v`VUze(n-pzIhQ>y-mDwMM7Z<0IT+7ec-UK@jqfxUu(~7w`9{ zfZNv3y;+*v;*#;6sSMcDBA`$!$98Mb^)<#t?njtTL!EN?Qt2N_S?oI`KSe&zX~Iyf zRB{#8-PQx7Qz<*~0g(iH))l~laFu!R(8sno=P;1>qag#Y}?|Md^N2Mr$T zb$mR2R2CbJ9S~q37Z0FT%o2{~EK=$@y*)Il@RX_>_l`et^~Iy6+)B&Wsti0>R3ry_if4KxjOi z_ly;8-bkROiE;wo%FdY1t{GuF2W`2pqFcRYK+T_I=N#}%d;Elyp6dW<>lzai)8xd2 zKM)Y8YpBaDDEOp}r-$9;C>20RC@3qW)hdbjv9%M@WR;^h%?Ph^4h(-k?;|qorG>N#-H(Ji?QB~VEugav^A|@9Ba9P zsxFBHR$Mlk*gr6V#$Dn9Ss(czLn$h-OcoV(h$Se043}a860P-6`xP?%KmVfp+JAMB z%w>tIDnto-MgxQPkM>2sex(6~69^&C<0etwqyAI&O9iOw&T*>-F#kO&A2$ABCqPli zWKyP&aXs~O>XDFHhwIy%3e|7Xwd(5yvQBVcOEhD|U`r9NPO{(LN|y0J48_H5Kyb^_ zaX+9GocG}HNUs)QU8x__9j*C^!u%eZG83ynB>RR25A}Y3sJXyx^5CK;0;UzjUioeI z1>AJU7cfOkssL98u0TQ|6Tz|+L{wc--$T7$uKPl~a=JbE3pio$74fq~0YWqo#*suW z#z($RZh45Xw$PEoy~bo~VZx49)}v0i^sChr_beO`0dfGAMa+<%e^?h3bg`*&Fzw9d z+>bsI_i~w^e?tcGh>=iJ!~3_^si`^{VT@mHTb~4LET`7uxAC9Wkwo_0}?+f-aiPD z)fSU)qR9Dv8~!^e-ZL>d?oWKJtB=?SI{_f2WY>7z4sSk|bl059m}i)4-~_$9+lt*n zgmR}Td{nS;PnKv28%n+d;6To%`tFyGY&UBe`FN4uywV31iB@B5&yO}QE zs5>{LX(v&a%?iQ*@&VotpyMU}9vKOy*vob79A5fJu>&ZSvDTH%Ql(WLF+Dg?AXl;( z<)l7jFU!sa5N)B~=$mPft{QJUJAIBvb~G)g^Fr=BgDIL$J02%iCus`M$stI%yGkG1 zLgA1wLBVR;8&b+h+22c;ur+Ue%}t;{#WG!_G+?`@k0H9k$E+&NZOe~l?XR={onYKG zU2XJ0F+RrmD3__+P0ThV>(6Stm*Yh*ilYq&Xg>~>FC(N(E881K7M_jc{qU*5fY$97$xJ$A_rSoS+SCa~c4>&m9JVV@n=kt~tdn`9R8 zbZZ%y=Y!=%xHtdD0v!9jZshUgAMTcxNp7Z5d53u_r+D z?+4a+a&eI~;W6Xd2xe36g1K=y(8j*O$p#JjzPMG7rH`!eSs~e7SQ|^nQRRFTsKO{X zI0rFEvR`*HFibi+?;1D`K!pdx~sPyNX9dkf0mit=~ zK`fZc+O}31iI~VcdG(Yf>0d$DHsIFBfEmP;i(ZQ4eNAEY9`cdLdrtmla7mb6OMYI9M zL8EEofP1&Km*(ZX3>H+%x8-+ux%3mj&qy<@Xf=`cG&Q#nu9?B-g&3 z+nWbXmYY`jPIegx7@`!z+>4bkb=Sh^Ow==w!(FOG(W3H4Us(6b18gBP=H6mgXjkL4bzz#Pm`L_(473 zIeq#>8jA727Ip{)W)UyRPZu1M47!Grnv(s^NLEVR^D7#dE4Q1@PTSFuoydhcEu)vN zB&B`NIxP5q;uhuI=;>oS&!d_`)fV86eQ#Boo=1kA)*b;t{Wsr#1AH?e3=2%OKuNqv zN|9LTD&@||C3r|~wrS?v8mu?n@2|jvp`f6c@AMOCuwRR5;AS7mMPLjUR)A^P-b@_R z7{LR)MJC-X-=sd#j9SN^AC1+TZ=ZcdP&UnHM$8X;T)!!ujtazkX+Z?9CB%H-c|U&>jzJ5W0PXm|O51C4+KUDDNUE)4NF zTx@?v?6)e0Q(hk9C{Gy=j;<=p@g3|VGFiFPkO`AUWDeUm8oM!~pU_*$2cP{Pmyd>SX{C#ShO3s{X9&nFew=0aLl!FB*97YmDpxz0O(BwO;us1)9r$WCL?n9t_iiVCAc34;iD6uYtuCe>;39 zJt?3dhr2Tza()*X*G{;uI?HK5=knfhuLg4d0PoYfITOC_TQnDQA37Ej6S}#%IcWU_ zYt{WB8}WgN9y4(?lh=pqnG$UT#%LjrXArG29O_rxsHueT>FfE0;KCVjvkE&)N;+mJUY&xfIY;93!9pkoK)Tu3S=C9x)W9bL5e6uX}R zi_$fyKQM7%JqefUBbd@M1h8vwqjlLxUT=vyyMPMOivkLmLh~Iy0y=-s&p&CMn@}?|mQ&eq({&|RG#+)Zy(JSwxLOw@Ty(2Li}DXv$irv(u_;Jl&%;%dOI=O&^kq^CHTl8FvMes1L7G$7773G zp~fgJ0(MN`l7EDjFyj4HM$;35M7f5-fm~&DwVi2QflpWf8!H@5zAyLuS0;!m&vy@| zR}Kz`&RS)2lOwa8GeNAh6&j_lgS+{x_;oZ`Ko8@)&7jj!40D`c1ko+|^|N0PyipFm zuNCusi!o-Ft62|yoHKrYxHk4~C&~eGZ$KGGBcI9!lai7$($I}?t!6HFHb|ev04AgU zcWyQ5ZMNO&+zPaRG27&&EHIa)Y~K9N^zydwS1cZeY_`bD>U7dt$JwsZPrMaDY=M!i zN^c4*;k)dsXmn!89AFq_ML#RbgHI#4jRkIeJEYA+!h-m_N(A~yM1?rtqRkmLASOBB z^@x*9^mdSx@uy}UOFFfpO=-k;vw%bKsJrG=L!!xeHYFX|L5TS+1LBvqG&I zGA!WMQN-3B8r{S4M$rWA_c?`yh^D$|8}??NmAax-%Cw5|eXPFcXdevPnly7*{E|dx z)0A0RSfo64NTqh8j+~1Jh67mu(v3R}Kf*Mdk}nhUUn=I$R*3VLa;zu*wDWwJr(5?Ebze^KOIYyVx4sD*?e7`sjWj~}js5M@}6IWhTjRCGMx2cJEk(U?E zjvpR(oOYphUA_2cWeBO~`KrG@9K^B^PR3fZOefYZ6Ov46bc zhL4XoUpN=vWDsO=Vv{dj(jp_vb_z!~>~fQ@U1}r`^@icn7j6b1QFZ~!DyWwV;v-DO z-BIqc=-RB;bRJ6PusVPFKn@kS_4@~M!GyF-Z}=}ACst(ukr@NlxA#LshRHl`C&%m= zcOYwJnCFs;@wKz|f<}AT7NpB8n@4+_)!ztK13YCNVSp$WdG<8a+52y~CR_ZVMwDm} zm&f-F=KDYWutIrX}d=fRe zG(`+2XREHA&gpd^)XR({&!r3Q0-VBuJUiEBatw%)uSRgoI1|3Z0Lp}#sv4W+B0{ob z-v{|72V6S&H2Bkfo8WL4b7UBrO{R<|{g<+^<}PouSNa#jm(ZJC?s#7x(gBf2R8#5k z?5lke$U|u~6Q94%^Xc41Qs)z`|6PEmf&zwt#}0uD7<_PY2-PTaIOt2lL@TDJdq>UA zj&s4P33u(l;tpaE{LNpe%#o}LZ;6;R>mN&o%2ZyfT1QQL(aDFa z`a-j39AoLi6C|mw9x6LR#34z?q_VI=6l5`NHUv<3H#_&S zH(DBxeJD2SXY=>mP7j!to7_8VXYAlbi)!V$mVFIVHq&!KtgvaAGzIHXXO6oaeAh%i zSinLie?3Fyf3HIv&M8`SeQcdAXDC!cInrW`X$Hu&oV(+_cO}2_*&;wifZmBdW?zP)*I7_uO#vH5MbFnc1yEiU z&HzMXVNqEvjFSrg%{EpsvlE?Qb|VDCi1qcDa^kXo_v<;-w8?75SUyVxjRrSR6nK{4 zMs_;o+lONk)+ZjbwkD7avyUtyPAIR6j!0OZ?gzuzfr1w%sHL+EEsfh&+*YBYBM=UB zjhTZ-<=tc}`maEoQdQfrMq=wcWH5$yaI8f-vt~UW7b|&!J~H^fTs06?by^SFR)LXr zK@L4?Yu!NhyO%rR^C@dFee=rQ>EkQeoD*7$#;X?OyX#ZME?8Y%y|{Ztp%~5>>DMr8 zC;6HSGYmH6`jPp0X|j!`_5n>$5~z>XaM|EHJ-1C)bFKMTBdQ?eKtfM^V|Ye z-K>KBuCHd_3LmCok-q0;(KU6cw-bp|Dl*vWS~Fff+i8HY{nP4_=-dv@&UyZ3zx_)1 zpG`MfJF8T}L!Ua%co{VIXWLnaEK92sF@D^ICFP>&ZO} zVUy7S_u2lE3&; z5Gib$hKJBbyL2nLgBlw?h=%-i9k~U%7|nbk4C@JK?M!o(f7(0Si1_lP-$;r}02~Fb zn6#WggHSsOm2f-4@o1_mb)f1c=XwS=?qG9?Ljm0z8fKKrI>~qW^fZpaWabSNJvp5| z?_*@xly9OY|Lqw+hU6uuHI>(ZQWG_nDh&ELinExCmFb^ufP@Z+WI%TnmNLNzz@7t+ zX9*7mZBG}&ofOw7SpJ)&`(&$LyBE4dmA~lYB0kX|Ydv;0=H}O_TjhV;Tfq9yrl8cn zTGA?8WqxjkdH|t0IdWvUD~6m*V88&CLI(w-3~aUm8!c&at;zU-?}m}$?d1kJrQfDw zy08zxV!SD?(8G-L4VD5n6*6e3!t-v$i736&-uvQH{t*5F816I)gV6})NXnSKcz#@z zrbTaYhVVRlO7ZL-d(asr2p9+l;|YYZeXC#WyzQTFHxwP^u&F57<_dipEa_K$_cb61 z(yjwVF%$ui8WM-XcU?Q5{h2vF*;h=Ca)AtBC*th$tqcw_S? zov$wel|d!A`VmOdrn__lEr!UjFJ8BKcQ)hZZ^9Io8Ek&vgk?vRieiBgITqCwk3?^7 z4=JPTp(|6Ng_&6}+O?)L=+g&QKL&nTJCkF{FW?leb=kJX`kps38$ z*gm%k@m&j6Z)v%S$z{y9v@s4n38~02zfKqjEQOud-OpQxe}zAlv2;babx8iDf+Wm* znTd+7vgtKN+kGRKI!ge`HxtL97v8v<#J*%7XMD`?82jf4VTn9pPt@yQ@!GW9H0HkO zcyGcBX5vSU42FQ-B=tCwBO~)VT;%W-cGR6rTDT}uzPB!&SX?ai+$dnB-#n$5s)=7C ze&p!wh;nZ8Tt%L#8Bqu|6GA!wzY6y;tz7B0yR0yqCD?6Wq z&0Y9qMOZilGbeEV>@uf4!vEXg07rf5`;Q=asL6#x%QpJclsJo%#sdnp+Xx#F?8vL! zskg0%^yu^4J;ja1cQ+)$*jd7-Dc<1NuatqmLz`)~`5d8N zK<;~YU!D$F{cz_(%}81D7V(g&d)LDXVH$n?Y9CA7t9JTfLFQWX&e3QTz53Rr=JTRqF9T1hneopo*rO&_g5V7r&cT0mYcjk=Ivs zrR9a}(W%O*_vLTIaZ#zUWstqOKRYzw5F@eedYfmxHKghg*vdM-T=2G~ninQBG5N+u z-9;>kOAU{U94~4aGWFhW%+k#5!o}_RWnVqR%+uAJ(4cDVbYbr3N?p@UQ&V%UHM1zQ z)QN=p<+Ue00y%a(h_8&$Xf#PUU}F_~QISh-0Xn65_I@M+x7X?*b)nVx+q|kA z(ghN@aX17RFwkqvesz1>qc7RD_`3#3-!HTlb~))=n+{d*)U zfal)6b%ySJ+lyz%+#Dk}eKK8z@cE55tmy^x`*q$50DvM$`J5?2MwGV%{&xbxwu1Oo zq23UA1rnXw&lI*dnxEW!?}zWC?G(5_QzblkxN|NpF3qfwgT#n}L;+MtF&zK&_b^LO z#WFny>~iVp()JaittxSu!w*%LTq-}$&9B~f8)33mIqK@AW@E{O^=vqAW^`tApH%S* zr#PvUcBK3JjhR94ZxYD21r4g~gq#Q=sx>)u#nz6Wu>S-Mef_b)Hg;+e+@-5|0gayK z>ZFiax#AZ*8-8>=2G0c+!MYE{3XHt%!Kq8PgWcPlaJedfi1Bzba3C-0$AiZiY}%F( z6=SzFV;1yf9kOOp`J#qN8+nQ1%xxg%2x=5L`}m>F6WFe@=yCX$uxJ?l9T+j@$?2`P z(pyFy;d^PrTJw)Blg9fO=3*8MQmACs%d#F(DSbWP68@E|v09(HdyDI@HuMf3I|5W! zqCc}13=Agw7rz7f162<3D&2MCg)oEiY(¬e;7d^#^q{V%H-H{uH~dePuWCu(?X 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 z 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ℑD z6MdW~mSkZ`4p6Pl7&ryEF8oPl#iZ_^k9<003$qxYLMLc%c?w@Xj)NTa!)D%BRZj5-+2^^Q_nv6Vd1t#`Eq>g+Z~L$w7#~?DRl7t z!HkrqMwyc8R2_Kbp6C)4rL>cpZZxOu2*Y6vim#O^F3wr}sD{g(xsB%bws#w+x0i+$ zLS)6)Hj2=;o{9&%O1-rK^NlySFp$qUH`5OnvfJq7Euew{KefrZcukjegn33>QMB`R zwD77N!bC+&EMasE4IZA1ZjGmvH=ACz=)8>Yqp!2?y^ADy*wQ`9LoV%P>qln$0%0DA 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

    {9W+)P^T%di(e^`{SS? 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%0A4Q$w% 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

    UPKM1__WTGC#gPfOK{;45Q z$#k{e^X}B43AE;|wTUe^+~aDS=xzLpyyPY$*ikl8k5CH|0Ra@Cw*JBb3*p zlgrQfWj?gc>2SMLp!2NOCqNzDyCQv|aZbPQdrh!BdFH?AH}a?LJq#$%7gQ!}EhG!D z1;3rA)u8sE_HMp_^@%T^(?tU2_u9dq8FL)e#EMaDMS!x_jog<{`lF@M7f?jQ;3V~6 zz+;hW-(X-=)A}J-jF`AsHY13B*Cb2IkKSYV5j)Yii^)yDhL6RV9?HZ>DeLqSr|DQk ziw`Yf(8VN`bMGu4$=ps-!&-_r-wGq>~-Mpea4-+ zR2kyIr3z`k^a@mNI$MgeiznFOq89j~clzfmJRm}SFXsC`2D3dgc6L<&W*TCV8k~_j zoWyV~>6diLT&*`U|F;(_Ik65TIhazO3~*8LR2x^J`2l|WF_FJn9lw&yVRJ}k`3|!+ zZCtHBCAn;fGT0jvn&jHG9sA2<8Q6v3p1+B;ItF%4lIS8{XPphOwIGM8E+_h1k+m!73?XN4Kjf^8 z0Njq70x1;#J8=Y*1UBUdqghp_gcC)c26gzY7Us7&MHjif#G{yTx+r@N@^#nw zKFjeq_J64fG|I|I(fv)~V0E4|_CYV(r1XYC7ZH}6y8hX~8U|dD5Z-YFY9Kdkl0Ejl zYWd>aREfPO=7bW#?Sm`*j*@)eeVTl}-{mQk1$dv~($&>;_?LHVvO-Jje@&Dh0_9_X zHiHt>_Fi8wOid9~5bhN^fD~^)8YA;M-?A|=`%PGB$hL$@KTo~kK3gYku$i9&nhR;! z=hQ#JzePq2_e$GB5P1_5D)m)(8vWj2_Z_26k%IC_FZ8h8GPE69_k5wXS_lm1@>F&? z1g`A;3EMbC1s$;!@#Ln!71oWYO0o#m8?FEW_csApQ3hs}M=LKXl)K0M=e9J7j+vLL z=fKnIB0eD?QQl_WxeQ_nvD4Le`NE$h!2XU*RN7zHowB6G49vajkB{Zt&O1^QC zxVuj=fk~VeH0s}34VGIdbZ?G()eilcPun^TfJ9l}Zu$N1=3c^YD@Rin4WVuO+a6{I z*A8K(^vrz^&+x4GtVbD(jl!!~6qR3Ihw<$gbQ>6xIAASEq5a5L(A4@E~sJY58-32szxAy-dc4>%L-KF9JT zpCUQ|D(;9LAZe#9ezUG%tBdxLB~Dc;((@oX%p~Tu90#YBK3fr;|N3O?)At7Nb42eU z`o6jR8=IDzu?6jlYvqU^vKyLkZP}ko>j>%SJxZ`an^l4detfpkH(4!gUh2GnC@#*t zlPiK4d+HJ1bg`5Y%}QN&oWoJau?5Ar5rbt4-WCK-EJwO;j!>CaM z^?w0z^}|50YRE{l)JxD&Pf%m$K91)R_f3Ll+XPdhyDGA=@2M#`ikShvz#ThV zFcfWplf({6t4rauc8WTZa*^=A)m@E2C;+|uT5WlOorYK3m=?2eXPEs%U>Fg=r~G_Z zrcmnDB+Mi|as{$K+Dw0>boJqJ{)Z1E@jw4z$!8=j$f|k(inGe0^x=@v$j9WL(8nf1 zN)Cbzyv>_+NU|SkzopuG8@p7582zKs8X3y1Z3{;GO*BpLot4zR4VP0e=;4al@ga|n zVqWi!%mDidZUGa`%5n;K87R-6eJp*X&gopf&=ISV4r+TAclF?D9Yn?Wf+9qP0xx7+ zYM{)|+pV7@E)|V+KEApp5QUk4g~i%zmIQ9y<=k9d3U*Zl{u7bU`ws%?AmO%O9VlxnA;k1=ym`4BE;S^eEyD=OK7<)-mfA!rVFLR_2sJHICA;ssnzFg3CgI2@5|My zIf{p?!=vwdmppb4E#cR_vb;=%qt7etyW#Lls_VX=40FLJ5AzKF0-n@5LK{!~1+K3S zW&XWF>BJ;bD&KNL4`rN%eB>m@A27{#pbEEQ%qrDYC4 z*f%Goog&Cnb1fcOUiC)%VVq{t1fa;j+%Zb}!HJemtDR6PJsJ;}aXlU)oq9(b+lv27 zVjNQ4{HHyWMeqY+uX+9WN#S?v7l=%>$Vk{>97UZ1vo3y2tA-1T=sRRs{^ueOp>-;0 zTQIcR7)yE4ldhwqE83V|AVkr_yy+Pqt&nXjF4zshH1Sv19eh;0 zRHoe=?qh}ciH&aBOUhs#ll;EEJwef9!1?;Ut$S(1x>7F&*?1>?J<%h=KfdZ3J2*z3 z<;`txh>-Kci@u`XKM<_bSJC!2jvsN8D9PtVqz-&SpJvaHb9?d%Coey0 zzo5CfB|{Lw+mzf=w&=i;f$*5hIKwgI>I9FrU@@7Z21|AdDw94J01k*_d-2EW@-*J1 z!}2@C4*c{gCrWYB!w&W|qI8?VBWF8W?H6;Eu;kTY2b4KCwc&Q(!*Mw9ry zmam4F+C_vRQ9F*09q(wjQQFDSqeq)^Q8fGqy)X0^Y_*kD0RC}$>}<2;b0*Zx18-xi z%{%XxfO4iO$zZHhA^k?x^+m_?Zey*`H#=z{86k&KZn#s&w&Y_E^GR*|UGFXw{8}pO zZlXvOU>NrjG}DgWtQ>EJyQ5d%QAbeKu|bcU^ng^TH3Prn;}hX`OIOXr~%tub7*l*HkK!+Ngn>&19u_==e2ReTS= ziCjXwbIe1(QFxxzsUEbwD#pp@yx(R0$QT{YGiv*ssk;)L<`nSde;tdHr~4Bl4gK~O zcgoj^=D_2g6d9e6+Nur;7g95S)0DdL*(#7@G8Z#ToE?t2n09~ZG8Mg+`VH>ddA6i5 ze?GCSDZ=cAHfjdF8lr2^o%yZZvHxD{^5`OV)Fy4&O3Q0daN!Mk=2XRmbUw>hzDORuG+I6Wi}fC0CbVk;K<~k*qi$X6i1fwoB$g zzKiYwWF|bqL?nsEE65xC&E6P%d^Kcw-#pCv$zUcY+CnD%$4_%LAc~>Hp~6mIKZlv6 zqTdh{&Qg9nZsENBVGlh)pKCip8I$p6iKeScUCW;8a$`R!#LNw?e_dd&<*s0-mLge8 zJfAS-ovRboO^i@GaR~1n)6MsVIB5!wPR+k{K@3f2m1FVqOXxgq+BseRtsc7%acD~t$ z)&rwO7gt?B9#nZwdxhy7b=9&hS-eU{ThL;@4sD4|}_q>N;)mfCuL*PrJ-HyjS znn=thakEe9n2@}nr9LH!IQK7Jg}9D%AXFzg!(FusAir5)S0d&DjtlV9`9CZG@Xepg z>no3EHk6a)?sLvxvH2C_Uf2T0tr=2GeBz?%WZ4RaE+^?p@`V=t%Tyd`S@5AL+a`4p zMDeFozc?SVfaI;K<}@y6fgNv0*P8C7V_0K*|g6k{hA8sO>7ruGi2mwHOy!NsN15j6hjX}xaP!-1@r zli<5l3UAe?&tv)^pRHJ5LJEB()fNYdP6S7t)jW+Nopt5h4I|Iyb8;&+io}y%hyP>F zWvgA*-5NVeW;f!0)~~Ro8lJaBQldB>cS%&WVyw1rYw!LlQ}Ei4GPVndzxRdw1td8{ zhUEml58P0trJeoyOKC-N0CLJTCBW!WV874%j(e2KiXbY1hHxt?;o&S4urjM=ow2vWSk1 zH@&zmf0`x4d<&v!I3Pi`9*D=-wX@@yeEDR4&%8e99(sp0-F}De92lNv_c}SOxlO2{ zttY}Ihd`;GnZzpQhbbLj;P4MoSv6w8~2CD>6n;{R@A??fkyw03K8pT zIXji1D`J#RsPJfkSS7%lnJlz-+Kam-_}xL0n7H<@*Nf=|*N{v+%|CkGFLW9ht3-1u-`wb+T8wcj zLmwgwVzaz--}$`5O2}}2g49{{d>$*N2{r$25R*~F{cxxk1+LnxSiKB)Mt%>xOJUqW zB%eeE=@11Tc#lELRw;j}4~FxmvSZ(J5ATPRMA|)l`A$X;>*>wdkHBd2bautlecxz?1_Mggtj|%oGfgsJUzF{>D%%ya9(+}vt^QqU%4*o_Yeyt#lzanS zov91A*zV|}DF#CLmuxk9Tx-I6XR&Q<=<4fYnwuH^45_ehPklK4$1a@Ox~*^^`i!{X zWBzU4fj=6C)FtJdPbG50A7Iw<_0i&4pHQ2PET8c=qu!R6H8tSo($5yJkJ+EeU2NG? zWB~=g)04FKO0$*RNvCbe;bUGZJcU5f~qS`sHTq{=>9*w^{bhm2)n8=Y7kzELyXcrPJjv@<;nJ>9h*Dp}~d+1IsJQw^daH_^yof zff80yK(T~C|0t~pxe15Gx0%1DjhFg6l9JtDx1Q9&;wUN{Z%h?ycYx3z_x0aOn=a&E zSZKWL@T~VnX*9q#uUf+zJ1({Fut?)Z_U?YX96#+B3n2d0SSkW*`_Z@r7P#=fw^a5M zd7ulm1B(3{l{fh<`=Fw;dd{6B1(wg#qB_3?%k%BND(L*3(C_oL!-}jR<6?dD^|Q|3 zRK$7d^($#;G8*^T)`TaTi(-G9=J?~b)5IZfKDkJb5O+TLe_S#1;uQp zIlXN%H#B8%6|vp%nMQ4&40XyerDm$}O-jr7M-LO!KucNfUwQyIKMpJHL-&v4nIiPv z0*$?xYoDpdXzi zjPel=2veF-n)E6?2H)N+3K|bU_pecee%HsYcY{k^M5Ch{6XyInyc}KKB|VnPm&JkD zS6N;=-+D4rhut3y^3Qv|nC-z1+lf64pQeTpDYoyKKh||u!)G35t4Op@Ve+TT40l*2&;{aE;JAcm zZ<$dw6S#`IVqNWpabms|6=sao5QSeVN}vn}j9eDKj^Jzei_|;#Zof!=c|92z3nEJf0irqR2jLaLeyz z!9an?0ZNYaQuhxVMW-f|%^Q7AufZWmHo4Q)i584UqrIQV$RRMLtqm`CckC`Mc+Vdg?lFLs29)T7ZgRB= zQkC)|Q2B)@b#55CQ!c9pb4OaWxWg#|8(dK%H20o3JiMwki8#*g=fi2fH!}8@%~cc# zei6m5oD8Je)^ftHDz=FJwrT0xAOD$OohvS4=Nxf@y{G$BkD+7o8^4% z9hLs@?7?rhiBD2t7*ZE{YZ#3t4>3o#^&U@+cwORhQLE2as|)Y;9tC|26TLFc@&5yp zG~IWSy-rqkbs^y)>?f*(I7(H{)sq=w8&GuyE9LO4l`xE<=__s+Q8YXuqM;2#{FP8X z_p+iMZSpkzyL~*Wj`x9@=|gV*eiNm^`|tg&&C|CC$Zu1;G46) z_&{mKh{OB0g=OXPlviHjFL|a(XZWlvp;r&1`)7`RD5!l+H@sjfa3kj8mb2 zdstuWN)s!=k{f=@X!C(kon0D326tKK#!xA?RSub|7)`9Zlh2|@nA2&}yPqgqVw$DJ z9qCd|l$`W?N=wn-zKRlrIA9w)bxwK9tf0)YN}7Ph=ZPDA55}!J0f|KJx1}0)%X1u# zG8qTg-P5;x-s5y6jWC%$&!B4m+YAhm=eE?@&a|oGnkr~W``2gAFYd8ObOaKW1t6_F zo{wukk?SZqZ#D#= z#60I`=fol`NE2{)9qE@Ce2K^4WGeDQfr^sfx9OxnyVyYwY@NpYaj8|H4Iz%R^Oeyz4qEhEH_o)AQ#w#x zaN+T*d;}8=zO6y>ycVk&6fX1iWi(-k?f~d5g#q`{IiaPEtguM0Qd@`AlX&_ck;3(H ztRo(yzq#Ea+M6Fun+b-|#LW z`uzhR|9b@QWBOE~c9%g}XJY8UuWJ1g(!2%3Pqgw138WP)f;Z=N_HG$(n6?&J+L6-5 z9hpmd5}?02sw>3KO;;*|Lp#qmT7%l{ph<}%%Rt8sMD=E^HMWayBWu#Gg5YelN}LaatYT7OwK-XD-J78PSCBMoKyaoH;{4sgH}OhP#D(Rwr}45nUjEsYsdnHdzIiSYIF3CB9W++0$kw2p#$l0EnQ;qD)( zQEbjSi_36LPOlr+gBDlO0bl($UV0Yx`NwDj z==<^Mdd@bj2wiK67_81SmtDBa-|~S_O#HoOAdO!XpSW*UQ|s+vmF<|!(ft-ahe*#> zC+!R!FY^JN=hP)xaj9(%cCVfc(ldMHpRZ9ok8V2JL#$wQWL9Ud`~fq?*ln31fluuk z`3hkGur14O?pwK67@bkLjw}vz$!`*s!9_~MLgVTM8Kus+m38>VH$>!93wt|NC-V`* z!LR^bT9chXT2*=jjx?ib|NYjWiz^Pm)SN@Hcwl@DUDnmig&@z&$;`mm*(_a7(0L!r z1-SS2-w&x6dC3>P_rr8^7P{dH`qX-jqdGY3| zcAaA^nY(&ZBEf0KGI=&);+H-J)FKaf2kSy+z=?Yxc1 zqofQO#%!HNu=d|Mwk;dZ0k<7#C43E*fm!2oyM*me(W}v!?MQ!=SpN)>AwKh4!Gj8%BX}xe#RZ^&3qpB0%M@CNN!=gYBa3Qg{67FDLD{}wPTYg<{}jIIzE@y$ zYn$DpJeRN(hxtj|%nqQ;N&xguXk^a0em7LZBpB(08f7}Ok^r+30%vr0HM^xHKmqN- zTuT+4S+E0E4G%B8Irk*?Gza7v5C=f6Ri5oYuCM!R%hTgUWwk%qn88SS5aX3mN4;)4 z0Zq9seq<%#w3VV#u51YAYs+i+#h?2x*erMJ7NECBb~LnP4h{Kl^+Gw`WXf9!X zaT!}ihp>I;R>ZM{dK3XO7iMuzFR!Xx$l%rpUn*XCi!SRe(_UL!xBg{hq`micAd7O; z?{K$N9ULCStX?L&(@+=z{mSA3#2&Xp;zHe)OWsQXFq2OKsb=r(?}hDjSg1Q?(Tz3i zH;`Q&&K0_#;@AE!hL*bq+DPVZJs6sgunjdzeIm;H~I$pFg!YhZM(PO`WN4UzJVdc z2tl0zvrpsMM?Q*Y9(xMMkDqno)K2HazwY~u7(*HmvCWH4)}LRixxl4QrwG)q9_!9- zz@lAJ2huvMFξ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

  • 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%0D2(4a$?U<2AZ1ce%aL? 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 diff --git a/.vaunt/badges/badge_01-03.png b/.vaunt/badges/badge_01-03.png deleted file mode 100644 index 0738e81cafe421ad6a48309fea348d7e05ad3f53..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 120372 zcmeFZ1yq!4+crEwx3si$Gjt;*2vXABAxO>)DIkp?g3?F}NJUWK?pS_>={nz__YyIo{*T2@o8e#6aultJgI^#HwYxa)Q(@`fTpd)}lAjBG%RrMhd z=x5A7JRI=J;Pg^F1j29cV5e+~`RnHEVGllL0)HJHM7-@F=OAQZ5J&|?D%%JC^8?UI z?sqHoU#&d;*~%B`DdX$w>L_FHAZ;gXCm}3=kd&4X5VMn#5RkG*2n*OtN{Wezib{)! zJ0ieX(1*XfJ2`rwyqwYgc1R~B7bj1&hmxb0y%UR?E7Hl?Jw3Irs^>dZQf#y^tI|AV*txqnqpsPBh)XzP zdNgIRNYlg7WRRNF6}}WN@i<{ZuTC+YWaRr@4_S5n$6Mpu4&HW-moa1h`hns8o+|s# zsfswb|5u|sxZAmUfacIQm}!<>b99hFyQ1BlywsgMosf3G&@37rb}mk?;D)mo(!&nz z>WaA*^7eFbbM*uZ@pN#~Pz~S@@bH##1s)_KB4#Hn=IkUOEo|>3ASNLyDqtt#=p-N_ zF6!WjkhT{Sm3Hv@IjRlVILr`U$N-6-+h?QU4on0r4?YqSkrEVUvBT`D4QAJc5Q36| z5-gav0!S3N5)l^^LH}DnHm;t|Uf~@-jp_5tBmUNJ-Z=e0WV>?yOD{hhb!L~VD z(ud!t*_0wmt@wJ9$;s3{vpSCPb^Yp;=YQ(-FNgZwZM+J%WpwF}ve4W0pN-&HnHjJ| zR?302(rp#DFpF4c^S`+c1j4QO+YNqstcb&Z6Rdx&7`OsA8O9Y}MX44-rPzy{!7W1+ zy3iGkLK}KrcLM%f=-_APZbl-8h#)~A;4mlzyy3#Z=Z(1>b3_cqg%w1Q(1MRBVNkd* zDS{XW-!|ql)CrCSgJMGv;o&%hzgyyyL9q&uSl$Rv7!>-eRm?YcTqr{L-yXtZDZJ#< zBt;tJysDhqg0|9)kmjQ=ZXIjb6{MWD-z{$6fsr{yExtUpZ}=cru$*WBPrXM=DuNIZ z6&4W@Mo5cDiiw!R@CaQ~xqk#)2rY;pY(qp~<02wp`vqYBFc=v&Q{KH9rh5df@8m7_ z#unx<6Zkz#C?S}&gD@ci9|vxPg+l=|G7zRgP+=|zC`eR6rcnWTj-N%t(?L*J79owf z0jCi8bA!bY349uak-8X*zJZb$LRx~w;Ia}3Y8FFR4<`e(orkxprwfaU5`u|_SVR;d zjgUh8{4u8?78Mf~K}d>-ic5=2nzM`*I$$P6%0yBhFU*I1!3#q&7$vw z@&@7HghZGjC~$DWdPn48P#nCUZ{Sc|xH1Gwo4@+%G5p7qjRWiq<0=VevX8RaGF?=m zd%UUldtdbzHNg%qtjwK3ZgAy$PRVS=+)*N0l1}?PyQDdc(>HPAUK9bnjfjB8B1piL z7)hbfA6Qs$7;YGX2y;z=xrQMi2x`m~2j+?hL4bqDhXcjN#)ab{STLWnV4X+MAnKYwlK-*;0*Nzei5jtIZ|XDLu9R(K>LJPg79=Mw}phW7VJUJfYle~g4M z{i_u$M(fXf>@X8S{iEUk>6Fm_=GX8D5WN9>3Cev@WKpK65&cxB>D`|RU-gGSIjrF@ z?Pt5%6G)_PzfD*_=0t8wG#PsLKF^2mUb75a-$nUGNhnv-Wggu=V(Z$X);C{W_P#1Y z8RlDlyZ58NzUsM~0dj96Z`Xa&*rM4{6x+CaZOHhP*2%oLjquSsic5j-YRXvTrbunZ z3r`($WX~J;ViAU?zw^EQvB;ZeYpAW7)BX;Fj&oUJzhj;7Wm`U)_)&shi;_1t)M_Ot zQmt}c_KvW=NUk?y6)67XKb{$`94c?%4Y!ltjjj)IR_&a=w{-SeXf92tZN|~1m$rjI z{u%wCmh46*#6`7J)71}B@2A{Bs(e>;#7r`kz3VD$F10VWEV@84=OR5`UTSEnM6t<; zFSmC|dkpV4manu7=pAM*saVjRr@@@#K?Dxnh?G_f+yoG9HGV26)!4 z#4GkKB~2)M>W8`8@h&`GvF~@kt7xm3CnEC&kN$EK^$9t$akKO~b*-_!0H~g}4%uP3(rjv+7mfxSe^e zE&k1A5cdDfLR27i{7i*Jf5HQk357w#Vm>CMAoKV4|A)^CUqE1D7UW3Uzn=J$BlW$! z&>&I%%!DEcQIHM)%7l{OQshr2{J)ZpBVeq5UppvXAY4d6v4au7FmdxDMjS_@zDpjd zan-1g1K#uLo@9B()xzmlk>hz<4?GHLha!*7znm*nrBb#jzIAZzB;+6`j__tKa~`QE zvmON@Co0|Jt4SFw&S!tJcUd#8;+^js$r=UFVlDK_U{=>BK zyx2hW4jB;$y|Kz8B zWEXjU!KT5G@WM4u$qTKDRW^?oHA6-YrO93PNlF~t-#zSQ9F`!qoLZ+Z>vBXZmUbe0 zTXdM~o|tL}exFG~rBv}tua;b%{!lASQEtMM&Lwyl`!GqzkIIPCJCpNf0i8OF%3BqO zup7RfTpV{ZWu(s4fBBNPE^DzHzQ{^B7s1oLKt(!A`C5LXT79le(G+~S-Mqg=F?q|z?Cwc0~ zd*aK@uC%Azft};5p|AJ(>VbrY_HC9|{3haod}RlhY@e~+F+G~MTTJ;b-Ff^NQKB`o zm8of}Faf{yy*_Ee`idX<)s+4OB3X-g*0L^6ykkl-a(IXhTdU(+hvkPW3SYX>k1sOe z`|Va*srjzj7MbEhxgjJ`hVMtVtX^6p$lKKNo=o^PzaqJwMf6IvVYm(kheDvBzFC3# zW`-cg)RCX{3=e?=3K<3#{j2o+x0UJdrE7QQZNw`dD@Uy*L6?ggEt%B}q`LpCnb4S@ zk;cgJZza^_`)hj%w-toj0Jg#T1U89V+TMD)>X9?FVEoMAoPoh{j#Draj8_CnXdi1pH8Hw;B z%Bb7QjYp|acc82sBWbP|)%{PAXv&!%mAdi#L6yj$@C+=r=nA3vwpLm!YuY$u&u5vtW$T=bRf zOq^X!i@ZBu^6CP!!i$V!DhV$2FZJ9h*vLFReVB`^>FMk0a`TycK@o=E)0jUT8_V9R zTcpwK?|kngGH2@wOutkzG{vAwmJv^bG<8@yXyFHkLlzgm{Ke~~ADy2o4eK^4W?#6V zIMzhLK0MDDAoDKo(VCb~@(kzocT%Xzhfv+Ni?RWav>u)Iq}|vfuo0DxRSF1_+R9m3 zVEe|%J<)f(`7zVxly5fllUlAXKNA-}=Nm7o8%*bKOFT`PT>nIqWj5gbL9!zgvcy8I z%XMn&LS5+GvS8FH!xK}RS-`iKrqm=eMU^SsV2@8q&=x*N@x7yX{J>=H8P-X}qR0|f z+y}_8Rrm22+f4}JJ3kob+y^H=<%c}6`09M?H|dI_NzXFVzZe;CUM2VcL~Ijv~0!nV`LGpxz0bvr$wW`MCMbOs7kE2amP9BjE}>GLDHUo)v! zdQHE4Go|_{#>l|gB|zNa8jw~Z%y2{j@DKvPgXTBzptm5DeO>#`>eB&np5gfGSAQ?Q z7!Kz9PvF6ZxPXBX1Qc|?$c;fDpjjR$4EpdwdVBrUE`%8o^q5A36qLUj{RA2;22Myn z0P9i0tUvP)fFkFA-PS{TIr=)F|7yUZF8Z65i2zdi2aAY^A;9GyED~NQd=5d183j&+ z=V0e5;0-##Y~jy=i6~UOJkda*Vo^alIfB2gcJ3%)3dFgeb0;GBHSSOD_`4TeB0K{- zPZmutl+&Mfctiv$cJ8h~fAMs+`==GaM*hnkpwv_@NN)kmB)q&)igp|H@zmi3liFvUrm5hHiLWH%$0Zgy~=`SqAV(94T=2PdjlHG0G5j-E)(R57$Yxpvij<5%a*9Y-#Yr?;uIGr!0k z4%E~Q=r3nGadcryIW{Qe3BV$^{*9XcJ8@+KI|qs|MgsUH5ePw{M1QI&919Vih-tur z6&{25N%{V21%o3{2%kSKVK9Ufk%O6+FALBxSv&#m^>#vfxS}yq0osej7v;o)zUGQz z(E^U@2`(@qgR8Tv1CZocfR^awjb^b!{p}h1K+xWa#r=14I~Syr6Oa_qf(R?je3-F} z5rzo;0=)vAzZj+WbyopEQw33h9(KOyYd<-zgPo0}ow$Rj9l}9UR9IM23?X6X=qM}= z(v`h~u)TwbsI!n3m;(x}qObLn3<^v%t$|3?%#&`$pZc` zcN3l<5$&Px@5FUFnb}bzD1*u+w||TOpOxPv@#_607J{>DMfv4F*r(*FvRY@KpR|ow zjy%ab5}^31R@+R!QmmlrCt#2p$XBw@FLIguj&QC=(qlThXCr#)N^8S2U($<^->lm_ zC8;kKnqSGkl5Tdq#P#gn7g)&;UZPOiPreEQQ-^)G4=#k#O=}pcmxrV-8DZ03Tzs=c z`ufWE_A*p)H22ig?}?my1)qk5abeQ3nzvF?V&f%^I9By6 zYpS=BNjC}NIc+GD9wvym%gn3h+o!c^c&i2+e0mW{wEt~n#P0QGe&oivz$ery_l+;! zz4U#go6X?13|Cabpn953sVc7Y^&jqM`vjt6{%bqqBw|ZWC08gB4+gch;CqF7l*`Mt zh9Nyj##s(OX4ojdPmzfHvABCDP2ZodAIcuRX2yPQ&r zw&Uzm=D0YU$oiDLW)#=u3z=oN*@8PDBk&$Nju|xw)Na_*YJ>Uh(f$6mf!XJ~@6S(b zKOrdg>1QKyMKA1YxtNK&p+4{0wA@)FYv8yi+ld#zd#_~mOph+dzgdpkW$WbdM=UYT zOKwuN_i_ZbSAq|^%f@5r`aVR}%71eCaKFB#o{nFXD|a}!A$aoEpviu~(suO9`x992 z&533C4a#F5gCNei0ZRd5WB)r6JB-2AhB4}9I3=KJ6oRS|_q%Ekl{FgPh+BV!6X!d8 zJ3DUm-@FFl{?B~*|3=mL&28ZnWWTcaPu8lU#G)>ODHg&K!onibe-#TcVQ?w+r&#=d zRKxx!D%->?*w%($Z+Y4MJ5gk{J9PVM07r3{LR@Lx<6Dlezr^{4A0IOwq@4w1-pNcH zefOThNP!q-?mtpTUPcw*q?P^&_xyejV|VzAk8rCw14|}Qg_$#SU(tp3Z-1Wo@Eqy! z`N2`fU1F82!>`?LHAz^euhudaCEQnku!o9tiX}WKGpl%|df^f!ogo!=J`DEBa<@*# zcTAcvH;KYw>w1HYGIZwVEoLiY?^5b>PD85-Y_Vlm2ECO1eYg!hHhX)mbGmMly@bD> zdfOLi=pm{!^Hu(9Pmm;uR!pAbcjDI#?^GK%9=qGI#GC8a$Zw4HSK zlX`==a0U0*qdxS4H(RM(y-5Y8A4i!j;w!hhl@J& z)ZqoAzpLyIW+jRap8K&0`6Ovpu`>i~Q4tE|?`13m6ZAx)6Ywq9BHPjpXEmq|YgY=+ zLPqk2SN>30An8L9|1Fgj|5Zc;5&Q_=0`3CN81{dWJ;A?#hS1M!vqRt2XZGBDFt5x{8i0-~aS zqv`)`8Tva-f5@=nVaTpkmUJ1};aQ$A^=?;q^4~Jf&pPEZvWA=Ra9&{k<+7}kH6%Ga zZ6}R|y(ZsP%Bny36Bkl@le1!7XHx}wof_s(RPnVDl&>nHG5 z5-%lK+c%-7O<32de4dpuJd2Y>D6~0A)`q0K65XTD>y^Bz=IsB})`QNl--U@@J(fDd zkh^A%>Y93jxbm9;MgmmuLAH8scSbv_0H2zneo`mv>?K}PRqOukL;Y{T#>>z4C7n+U zl@pPloF$PfrRT0@_|Xn~<#q=Pc&uClUHX2X_^JWL0MfG>5Wj^5JRKD`~D}_cx+Otq> z$^>Trw4$=*w)f)SJ~dInr4-pNC*P~uHGL~2RNf#IH^@=pb2_3{XLROJfSalE)zdaA z1FvMWfb>|smff^=y}8!JP4%+(1^ac4>)KtP=Fqtdce!Ny>6{mFO16t_bkulyMSXgz zYIvII*ky#(-|U&!Hr;wX=0D}tBQRn8roO;$yTzpC~I{8A!ujx#Mnw?*FcG=TTtAE~EU7hmu2H$W= z4@$AAfSd4jk{XJqi(+Q)qvI)y&4KJi0jzj36_>uG?9Kw+HDOiHu&La( zcLdEfgzTR(?y^%yobvkI>$%+Ml#=}DT0PsK1wU6~g_tLEO*~5H&FuTS z>@SPiUmA2%59T?W_oT~_=CV5XXCG%v>FmvF>Ui`&HZpizb?5PAw-W9+EE=CB$lclS z=9@&$QnW+1&S70@BQr4{Mp}nu;ob^gzb)Qj(IBrdEY~m5OshCc7kopkSE6b3>@2i{ zQIT*5*I(sxuQ4G+7IOL6PVi&jDZfT??z|La_o+_(oE%??h*5>1lTMUdVWobWG&U?8 zCz+jIG5je9U7Ns(C$2YruF3Y&!w7`#!)igjPTa7@%^O^0%s3>KQ`>jZ_TbqPeyYt1 zL!K%{mRe%MPEXsm?KG^)$zW+clZz1Cohf|VX}2eh8Wmb;yhh2zFsrl*c1j`~SKB64 zf%oZ~m6ywg$fKK06}Y%N{q3P&awW30eYYz0IShEmjLONcB52(^VYN-+*zesH&E489 zA6?N@NM?5(Yr3=~dpka!A(_{t#4Sz}yM@0r_>uQjnjk@y->YcXnpR16yohPsn4C=R zE7n$Vi47R?ll6-CQ)nuE2v?X;|FO=$CNPK?I)0E87IFF=G>q_)WB}3cy?8aVKD~#irh$Ab+?@4 zc5<>1uHDF;2P=!l=H@Ln4KSk$q$05TT0<1SPc=2+5Em!s^3f?2l9H10;q)5|9xSwj z8N7!;B3K|0&n9{l3MK3_k2uZDj;%@PwGZ#LkBj5u;R&~{!G+Kg;ZV}hh}yL-2%gFu zK-Mj#HInCXZEeiVvfP?02h4!+(opfLtOD#B?_=WBKBWz6V{)!P4_-Kt&`Xyt4auG=T)s-um6ILoGg#?ul6D8%>wMtc;AQ;#B=2V8?8VK@b71n#th$`g-qXOIiko zo}M18935aHPRK2|g=Stao^SgJUPRcivx=SFh4}b*J$?NMFajkdWtgrs7RvKvUoqTj z&&woD9J6+xORV>BAVREgw#l`3R0A7m8DRy5#E&0+h)786gM)MGo*vr{)6^)-3r{xt zfb~mc6NA01opY}>e}u@=A~Q(09iiS!Ub3*ZeorQUkJpF*#6U#?kK3INyyYwN4VK}} zOZ$DZv$Qz4xZuQ=4DO{!ml?fkR5lnX)0Ci7s-mHRUuDdvsi~RS71)4;tk27-Lv|mP zmFYe5Gdh2d0Bz)I)Zle?Nzc=F5$ZV?)jYcKyt5N>K*!AN@~Sw(T*sPfyId(ZTj%+L zXVY`fCY90&rOW4Iq%FQdzJy1#zMiS(^}y_k0A`O16u+Y%1ZTxa(=UJf_KlXAnI=lO zKv{lHE-Ok#cG2xgw`Wrk*k-V`M9cMfsA_924WyToQ;CeSb=oTEMe{1K)u~R3R{YbI<*~e?=r4I)Ou2`&?R9h

    i)@M+Qypi%X+2zc8+9vBJ^50D?A{ho6> zrqb~v>p+Say_8hl114>)bP_o>!Jt`DsfCL0`)Eb{G54;kQ^gDcg?!oTOH@7TYkeX(&0afnz z&C_`-l0Ouxe~*&mMxNUg4pyp+Bk1!H;>>^!^ca39$}2WLc**>3U^jd|y>Cv=B(~^i zZ3QF8py140k^?7C;7s;og7{@4%XDXWjGndi)1DZb+&6DT%aR)d()WZ=YLD2*K(WM6 zRUpz$S2c|}TiMakgk(Dzd2k@C*PM}jwwOWl{-j`qlu0w$=b78hElBkGy8ZFV>0R>m z`I!hRG6|7+Kk`&6mplPplTgi|(24T5ByL$*W?$KH@^s8Xy%d-m7a0gGf?9kT6~g42 z7U!Z7r3`MV@-!9W7+f@&o-swe{ec_x=N)Pgjrl>@y*jN@<$$9fOU|aIrm*wFwTAJK zCNnh#!;S53%>+X~n$O~n+f~oaUYFEtPZ?7gTc5V?nHQr2*Vnrfvh*}Y+Qr|OceWah z-?%hG15>cAN;0_&xsIzBnpn~aMYPu8Hca+ zCyA^LIkWp_#}IBEwyTOmN0@g;Mi!^elsuTfEmilw^gEi7)%>LZBlqTOJQY3feH0Wd zv+%uPEq4#h)J?uX!ualEZtuv{l!MYtF^m@XF$-r6_uP(v#=OkC-n!fHJ?xtD*-+dY zZvYoovud;3x95}cgY=4)roBH35mab9pEYD1Ur9p0^@i`B)_j%g<4h5jL#6|YwSjbJ zv%}j5*VoM2@;)8R?IWImWa}Cm=}Js1-T@l?EIvN|n8*s$ARyP(SnQ~*Gj%I0Yg=nd z^Hx_^rmKsi%xjqh&CA09!0e5(PEuoD zVbNAjrD@~L4g6(~SD}tOX4krHwHPK3-lQ8PLN4iTgiz*177`=~EvrN)_XWHHgQs{X zKacFb_Cy}hj(LaHpF>igyQ6L=IhYpj`P8r5fdnlZ$azgl+jDSY z5;oSJBI)0=(Hqup>-CU%`JjG!_r3m*SzcOtYE0JrXt%H2hpVM~vP_n4;y z_vKT;@@{XI-@k%6IyrTCi1ziA6BG=Hg{Lxrz39J+zZus^_v{bJ^@|<;$PpgXkr;&) z18lY|wIzdjQH%g8oahtP*BpdbD5UKh@nZSS)Vl2ACq=WakebE8#)wACPdcy1d&E~b z`=X`@mT6lnK6H<>xE=%mfm%m2oVU{d95FsVt{~pK)OEtxE#$PM(r;U3_PVKLV~PsC zW?f!feAvGC$_B7Fm?}PZ;8FWzrWFLa?8@^D%K>jalr46Cxl1x|M-mqomo~xg_5fC* zhXCs0>+47KkbPlOUev=LiHBM3yeP)BQ-zTETW*gIHPUx$bodl9Ob-tOZ9|_hiGJO% zJ+nAaqM<5;=M7DTTUuW;bdVT6FKF0ZLA&JHjigx9ay{iKzRG^%J)bk=oi6Mohu5m2 zk(&3!zAeo@+Yjy=52b2iP{Kb>X58G`x+EOz&^T3Y5U1?Oc(BBc11wjdA5qxhZdV7vAG zJS{-H{_`beluFaX#-_}M(u3;#2Ct7bG4ExvtUsT=yW;m5PKR95#1m>9u1?TvCc8h` z>nH+Z&G~uP^6Gb8sWFi?uK9IQdiFd>s^$re`SnWUchoPJ+xt!}+yb0_oc_{xkAQ3< z5$=3}hJC6igiPV8q7_PDfu4oevOf7i^N!C0rkw2#M*uy}*J;AAaaM z?D~M7we11WXjawf^Ekaxtdw-l1f<0N`B0~>Be(hEolXg| zFEm9h)f*=`WBvK9;F=uo2RV(KrP%`V-<8;+`LXu1%F0NTm6d}!nkK|>tpd4C?lBlP z9IAWP3Dd9?8*GVN?gnF4j5Aag{J6gLI)8kIpd<7~XPvSvvi|Npj!9Pydf9t8sCwkg z)K=^^PolI+p4$Ve0fZ+AbdU_hCw`0v6D8i(%c6{kXUn})p?Z;#Fd*8^LsYqsu5YfbNmJ@E07Kp>Gq!q;c%Z{jb!-Kp+xj{O!h0&IXCp#KX9 z-^+c|0jFm1R~NZ{EYY}GF~_j`Q_|=(&-RuOMzzYu{FY9h4pTXw+z@3AM}j`i=lpT_ z?H!LAUfV74<+5+6Xbmf`jc6gH6tC4n#a)h<>6!*xrK@^DW;*ZVx2king-{2UtQK?k zS_pf*S@Q(gmOLx3U+(W1R_~ovMHe-Z(9Kb2egKTOGn~lt=;30_=%~5@6Ghv|?cLzY zY&l`!kSC|4jw$x+n@*C*ivf`}IQ$HNtA__CzqCl@bSoon(Ng^3W)c$Xtvdf0gf5v$ z{I19Af*ZT8u3AEdK9FL^)p-;K9%37zdW2DcA2m{&-{0|9k*V+^gwARg^%uWlw5#Lg zEaJ9t{$WZYzc-@)Zk&OJZAzn3Yv&N&4|pL$AYh5P)EawQgw?L_NIs;4nRs5o&rhnl zx*7zkx+Xg}0@v2EZ@%lQm&66jfkiet@zD-=m6lRV2(y*@jlXlj)ljR~L z4%?Rd34hOcc(RlyM;}2Sm~@8-)@!}^HA`F#NE3N%o<2^8hl z;!XPma$}Dmm92}*%4x2(a znD)CC43mLAhE)U?YFV19MijJUlUZy~5U><~^7!@mTJl?EMa>aYZd8*1 zzgNg74BO2zD39LJ)R)KG8p8y$N6@6a-0|I`7zK(at62hMJl*1HW;aWc8)r{m6QbT` z0@mHI`Ho(@Cqqdqy^b+XRY;OHq7h_2?GPeu(65Jca*kv+(ty30(u3` z+h@&JWmGlvj2e?II{e1T?qg@mX8l58UC^3=CD?qku+O{q@I0LYo1+LhRaH+0wWuV4`d3DHr9vXN&V60pN9M9Y8KC3 zEx3DsIi_OMio*c9vP-L0)yM-z+_PMU(0r9BM5#=8?V_fphR2w;1oZrn>WSj>)N5Vs zBO~OtRkU97HhO{r0;empQ!%sK8d}8gQ zB0f+R@Vwmh$!cwt69B5>w2X`qj4>Txtz^T(OHmS_R{Qlb;l45kC6TLy9L>{FwGB)p;VK|o6;SiGM zcAtZFX3;Ct`03vE&W9w=&+mkWIJeOy3*GPY{c zCJBmo`I1_N^;+7dWZc5Sz2mc!?3NaW=Xb*9t!L*b*1oh**M(p1d$r9P`@%CGXr*7R zc|0n>M@>G(jzaJhZmh2_NAs4q7bo)So0#CX<4TcvNfh1(0jPHEJ!$*KQBehbyPjhq zJ6+sDt?$Q``W5fd8UlC5kzwSlw_UIM%VFnl&tzQr%r&u(minj5HfJ%H{x0Q5oD|Qgo~-ybIy`+C#%3$X2qqv zJUn_p*$q$(Ex|Iys0wmi7R*wNp!OiQ+Pp3s-kl!F_lC*$=RAw+-^@(y-_%pNbq%PQ zDUQAI42AHYnLj&pqRaWn^=WqYBQ&@b5X0{7E-jt#k)Y~!V7*&0*4?6a<4&#}F-r!z zdn|2hUm`KLYHMrX_xE>wKR?RGNS1$u0kY{x^Lu=aL5RKb zoaM&W5Z%X-nThkey$ z5fgo=p~YX)LHsDO>@~FVQWIL<5hgZ2temP~w2u8kI8yc*OBlYp)9U;_D6IZXk>%dT z^(}8%rdjvS7A#=Nl9S_h6&#M~GglQ&m-7Owgi9PuhPq<jPwQlj5M zED+yA;LD5Bp3w7>i&>yd)%*Va<7Z18P4E3C2AgKrV0L)|g%2^qSCW{wbH>l7IRIBU zjP=k$pFd~|t^V93eYu(~v1 z_vXjFhR5A}X|;yPbkw7%BT%%qW_rRX8(mi?E-J>*14Ocx^ZWK6zQDFh@4kpaYz`T= zZInOsI2x45oR3*pJ*%=4`41tf%=eM*^X_5k70*-3!0dSUKv{Bi} znoK_~mct?_NCv1XDCqoXqb6Ydha6nv29IXH8V*Vc-(ODtd!T%^ut=GlIwJ`UJz==T z#pQ*YS(R;g62YSkAOt$<7H4{}{Zk-C?&sKfu#7yo4$Q>N(oFs7$(0=Ma-4#e+W1F7atCF;iyuN$ z*LBmSpHjzC4dl|kqlO9I)vd4Iw2N@7DB1I4|tZZ1O8O_F6P?*D-_29(lRR zV~G{ag^OEK%C?w1usVK67@8otcjm|zy;tsr@rDL-{QQBetgIyB8`yh)Auj)xHXm*# zSN_nzu2eGHxSF)C6}+{Xm=+$`t%1Sc6KZCKrec;W9iA3fPje~fjaBD7y4t7}DY!u<;0c$4{6 z(E8NU(dAPASH+`CJ#cbd^`6rA)lh3gr5_{N%E>~oi2H)yM&by!oH-mHN8FPAf%SvQ z!h5Eg#!{fC28mvEA$rv{B^%Z#X=`z6v{Jj=T!?C2xL2b+zhvXeZLV2lI92ED>OGr2 z$c+p)sK>(=y>czVYh`#4n`)3$06P%$%8o+#(|du?0Bl}k58VvW{J7M{w)QY7T6l_} z%4*9*%c|aaj{eqWHEh z(H4b6M7>lu>!$4FROE55)4Bq4>%cEd@s@&`TCZ-Bp!JnPT69MGEkM0HcAADO(!GyH z>Fe$p$TqzYWFku52a~RN?0a^rs)9TYJkld;J62|z4NS`h1$1x6CqgQoYzk2-`Agfg z3o+^>>`n&=OLuX$&uFw{WwnQW`+m%paZ^%*ZU@$)VV!_4D4b^*eu~|?R_~QXcftkELPGaG4BCqM)AJ^x<_?rt0 zp-j@ru|qoo276O00)AdDK7uSOX2hlXDP$^~E~ftcdT_?yvb^ZDLSOr_vpMw`wmL!@ zro`fqLx*Q8jWOh}S7f_|*}Pos7`qqyw7cs#&oG6lldnaShD_#f5o<_KvSXLI0jvw` zD$}!;gE_IIidJm_CjNnX+J~Oa8(|1Ky6|G$;_jaFC4^QwM>fG%Zwt|g#|NGlpoI7p zY~R$l=v@VhK9EHbg%bGDmH$9-NpDK$XW&?XZzfsFc-a$5+DMlsnWvqR|Bk7*EiVqQ zmU!20e*dE*r2|Czw#@@QnosDR^xmC|l31MUZpCx+rQel7`NcRYc)bYLTgDId5mp!$ ztG*UcMR9+s{I=638+NFojK|L(0xh_crRJex_a|T9G{iG1_dW6{Qta9sE0Cr6jtvCO z8w=57^-S|3P1SD2%`j2$KI;$PTg?blJGv`dKgv}Pri<|eP_ia5F>vN3Zfkn z27^n+WpD24)%KN~eTe6TZNA7elXAMD@uoWl`Px?4vSW~jlN`2K-H98NT-!|?lZm{1 zb;;1E{Hg|78T^z4)gA23de)@6-jewNOl5Maenp4@g*^E-01 zQ6g#p1Nk`0B?23n9un`<(gjk`Dn*Xe%`$@@cf9mo8|Dn6^&VyZx%7sIZ7r|>{?Q|W zpKn!BR%kpR1-ETo4cSl7d_1Z-{T7B75fPDQL(e}h7LuKFE$mRuMXvyKoU?j^R>qN| zUha4)bh;9XRp)VFpr$=v6Tx{^0roi<1F7OJZ@fYM^- ztyzEH%PAVI^h-ymPVj1dlEA?5vwJSFJ1Sx2$M5br6we%ZDu>l#bsK2So2*cCStbBK z=8Dwg5Rk)~)-cQ)H~+p+9G{u_l#18H2L55X#BLH;n47RHucjnzvpiLiSBErD{lHXawKY-bl(r$s1IufKB;7_VKzD&xt*D`<9Gi z%ZfrhW-xrp!Vx^ZsiZscLty`@3hS4hoiH+SO4-5!T$H^3*N(^^k!PztG}hg-?rpA* zf(^nTAA>rYxs?36zMj8%6LfF-Mbt?4y^U7}VGqzQ^#0_M?7rVqkDEXE^XUu=CTGVk zy_A)^A}P`qYJ`B?Wc7Z}r7nXUxZ;6#xU&NU{M3f_QIujgUE?Mf90N6MScsa8*lMBXEqO}J4hyPBp66mvUnG4Hq%9(bEjQw!dUB^$SV zs>Cn2cKNJ4j}RHiLVI`J>?wl>-!k25-+3dh*T`AXkstQDI&(0j>N0&Y5w_L!kqZDm z*E@cCOcaG!?KYxeG}ivt{ufPW85ULdhWnvAB%~V!L`u3-P^7z4N;-z_1_^l;$sv{Q z?hb`v0O=e;1{k^<&h~%Kxvu#%-`3iDt@W(?{@u?Gc|6PIBP*y5)RmXSMC%ldp!_}S z99xWXUhrK7U+_Y{X;My-jkqW1Y9*$vO-xCAcVHUDf?dGN!`Js379EYrQzb=+KnbGV z-yIu&ytqqSz1H>%7H#yh=!)C#t+l|zr$bH0(Oysp7iLj?76LecrY$9x?WAMHBjV*VAAX7th-rlfl>^p3$}#CSYXdw zcw3XckaN#b$W?$tFZCG@9cEh{Ch@4y+L@yRnq<~T*`?><&t~%LCgn`g+%9JHH_;fb zL+c>|R!ES=j^g!nDRAgDeo7TKe|VjRbzbij;%E0@Eo|z)qQ87ujC;lyeO%WyX2cpD zPHi@R4se55gPCP)80!nZ5ZyH#W$0J4hCwK5Hi(+^REFn1IBh|}v zC6x2NuNkqlcta1t$r#h+Wo5_uAs71WT#%1K{3GdN*lxGyyI9pN8}UakCo#tV0EdL# zWRuW=L32UZI%e}jX{n~@} zVKGC~shnLX?7zm9tgTsGxC|hFz{x*fpm`e6e@64X6^1J&Xd_UemiqgO3EmH+uX_4b}pI6Gx)5SsqKNQ56+7ZfFO*(Pyv({&_LuF ziDhJi*WaRmbBin=fDz}aKT!}~3A23v$!}kbcMhss3kblzt;snr*N@^cj@KYUM{T)U z4d4rTM9qhIStF?h&Mz;eR_5n-UW`IsjEcpokSu8$NH%_l$>$MIVnqu!-z@g6Bt-A-4+|Sr7se0b;q8W&~rnPdx=0 zSzi9X2QB{v&4IP&MW|@EbOQFRbp$0op_Q*MC2;i!&LyfZn$5ZjEA?lGY+Vz*CH?@h_4MK(L$5OVT-d0 zQSXEa(lv@M?CDV|#(x#xIDs6fV<)0*gDAYN1-l<|(5>W5V^E||WT!w8AYJWpcaIh{ zmdEt+I@Q6t#n7Fait9bbWRnOAvS%NRh&DW9T)kAmiCzM&juuc`H zK-qUcj__pPzyBT6-{IonX#zF)Mgg-*#v6@DwN)&&1751e*OXiww8;&sLB>P|xV`*S6N3V+XB9-dg>Q`DuzE zrEei)^iWwruV1Ok(z5F|-$mi(k&+K-$)L(GsIfqC;p%oVsh?eWor*4E7!{FzHkiCu z%qv0(yb^hWEq~~e->#!LtkeTnL?-!B;@jTPQIkF5(Xf_7AEP<0BJOs0Oms9cVa$R| z7#)wiH`$?2ZIwi#raQMB<^94{yyNK6RbfjDrHzdZI}eZ2TR#jKMG1qLWuJtIgnf7* zeyG`WX4Ja2mKDpxY9i@0S{O*`qEx-GtnAY?ADDm|6AMcnGop8|x(!(-|K6*=o)x$* zPy))lkC|k(KMb>3#hXzuok13_Nr^C&64UtgP*Tc=-!98mZ@j7IiQbWGvn`{|dnb#h zisgcar2_?Lt3;{;AMY_*?2xMLk$dU3CS1U<=@G>V{5!Z8Ru&c@0PZx&o?~ms#YO^G z+qc1LQaj?4ar?I05=?Jmbr+5rOq*f+5hkSnF$`G_7ePzB<4sNF*rggM7u{mnj$?3#>3rPpw( zwn#NAS{$*O;9%re)_hc9_{!x{mSm_lMbFE}rx4(60jSYQs%hL#)?|uNDSxZvM~yxj zP)Mr?zvwBogN;=!@S}aaYM1pQ?a`yF$GJ)uqX~3B^ywGF;ve(goq9Y~Y%#blu|{fb zjtqBzrIe&wy7~F}HO4NXnUHAxjxlT_hV^h zPo4KNIeV_mhX2<6_V1UGG5t-aP5(hZ^3v$lWkJY_-Or%A{SufFqhiIx2#Q?GPoERB z369@;)s>+N^wNp@{b8*z@(`>#ZACmmNC9z+?g!0qIM>eJo;=`l3yj(*lT$wBSq;%g z|CSA6wdK0)56gU6hvMBwr?YjQKPtQO=tNL_XX@z=0CIw{HL6s|Kl0+-(_2k+FT6vR z^MJtR8M-iIrF>GF@c|s;qZN=0PT|Gz$yb=y&eH&M4ucKsc=F z_n{X-Qab1U;2oCD_rN?O{;B8OvbpK^pkOT{~sALth;DbI*yB}wlr6%|BCbVaei zeKXpvaDvOwCM+!I1L1BMSFaupxZG{|TN~c==*WnZ>kxY6?dR%>{^pSTzv=z7yfc0( z#oPaNyQgpS1HmdCim#{9m1EV29e5go|Xcued+T&AF!xXQd0*(=@oa9nktgOC<{&B5$)p~29HCb3hwTFXq>$6d0mI8 z;Oki;2CVz8NMe=YS*USh(Xp%mgDXOr?d5dH!=Cx(cVm}cU466N>&lkl8Js)rEaOPo zp#ErrR)9zgel063@fC{ZAAdPI7jkx%Tz!9RK3x9wHB{JAI7w*XtF#@{T>KiUVgqEai$D0u$Tq&HC4u!k{%j>s+8%VKe^TD!i(~qM#uu)Rx3$g z1(-JJc~Bd-t;(LAY$7tZGBH)pI4sr)FMO3HW$|$S_uR6w9NQO2Ti}K?uK>0=7;8UW zEdOcSKj-=Mfw7Q_a!@?Ebo1!Anp^gC)C}^mGk)tu+?lLL7GOaigP#wOGdb{yS=m)N>zqKJau#(f~S0g#UktF?sbr zLnMg38uB0(+0gVjJO9^+bZ#D)j%jLV#?r;@iBsGi;I90-g2_w?X|_@ zzz6@rrm^|YK1uukxU2n}A&{{CJXWqc)WmLU88}>qq=S}eZ5dh~GR;efWFGREVM=+J zj66JWwSCm$G8`hS+t9CiNuC*hZ0TJI}_HieB)E%RP{Z^~@2=)!0psaS@@&eYRNl7;+#um;d93!mY{Rc!t@iZw33+ z^;J%fxtTH6SnHCs6)zw@)iKLD~zx zFl{UW9X-8`uesOgK*;1k1pMh~l}2yU_58Q^ zk0^>LM77*ZNDt6yyvJp5y9+CctiBzaO7Uk>WS=-pkbv<|XE?SxLm>VsOD&}p3ky&m z0xX20FFU?Gg?`j#_tFMPCcIk!^y}BJ9A9HtdDi;FP!sY4 zs~n<7)ef=WefMwc$Q7X`pBKF9r(&`j-z5O{1RgY;ByDBCEjF>r^L!N%7es+9sv8@B=}}aFKhcbQa$+T{r%Pq_+|Du^F%R)-ljDDEzVvw%`}Q( zrMgN97Ai{MDQT{ShB~cwbFjFHl~HNjarh9@?kXQHg(&*>Yn zjX<~GV^yT<2I7i`I>M!46thjAWTW}XGxp+YQ^b7!omR>$=37} zru!L{A@{v2oGuSez|-xy$2O{k?A!4c+NnjjNk`wFys|)0;p!6}o}o*IR%8 zGP1E@h3$uCpnvS`jV>2ZGVy@0#h0>e2CI{4Co2{JN+P;N#GQ$(sg(Zf=kkD89*!2V zb8zq$0EO<%s*GAm0Lq8iYnbZa6BReOir=-BUXsZ*(}^hVI%NR_E;c-HkItUDLSD62;-AcP;6e_91R9K+xiP5U(aJ&vo#$qM<-o+ z$NX1B?AG>cCEumYkA3MGS@$>gVR=Z-I2HjQNxU3DYyCC)+s1KW)ZJ0)wcHPnGkz4G zY_X!8ggeu!a{mumRPsk2q2K};2xRnAF@Q&{tgNJq`&6MV+h%Q|U9ffEp_}<%*m%MX zG26zshxHGy15D;x;#bae@`Fn*uxG1GKO+#NayJTLVxVQeVLHN+Ve2nNH{TAga&mIU z{XUP201Wm=YmBp(4OZo~bEx%*P*F5Mr=bx`bp7D?57AV>a0QA?O!P<#zzVpwpSjZ% zkktzanDM1C_I7z2U@RWcQog*IS=8F{Yeu8^z57WXtbJ?CyRN=Y(?lm>dD-Oe)?X&P z%W@6tfv#RDiY@9`)b9)R9Yx8)Oi8p=oLqxa)FW&qtza|d^ zylw0puN9>{^80DOO;WTIKSFk+f7HZzE~f7TeuYMu*!wH-s5WC2h)?%tJ})BVNgh3J z)NvG6cj)GDGCyywbKYHGu!PsPo%@(g`Fs#1!8FR+m}yq6_d#;Yt}`hS@w5hxhKUO74QBfRtUqk00n;em25-@2IUIBPD4KJ;CB zQQuaMD&_L>lBPqyIun6H*8?a3rho!)89muGzD$k) zqBixgEhldVeMRZ#x+*Kt%>)<#%~8V?9Y)1(yJnr*TmWiySShTnGs9m?!wQZ;!y=qN z-lDJjEhBlTBY=Y}$fRI+{K}@T2zY!t6grHduP>=+c;}ZEcA795G3nagenP_xIE(Y^ zPMLTh97z7R|HPEJpk4)t&?*)KBl|b57&)fElU|;J8()63YhTdH(b;;hxb)|lQT;v; zm1jv7_qDktP%BqBG0U&eA-r;@9;){IMJVyBJ~=rBa>lusOn6VCJ={R{o>%7h%)lo5 z{_Uw;^iYl#0Bx;CW3oL=C?&-Lh;>LfGjNOhkS4I^0&m=1$>aMss*Krgi@7QvUI_`O z;p(YS|GrXt+G#_%tVUBUEdZLpRT-^T5UP8PQ5E)%cY9^8Vfj9$XKmIx=J?RJr44@b zM)!aB0^J3{qC-S*vSPGqnmA+6SVY^6t37WdkL2}R0S3qCASwEPD=&)SX_IJeO5j@X z$q?8?DgrzubNrDUi16H4jbiPoZ^Jlw6#0i!ffHbWNM30DJHlBl@l8RP+n{}Z&V#4x zhyP`kHL7P2557E>z!kbkKd-q05PoPSWKz&TM$3Z6jGiTNV)+WUmrU>WOMm$qLBw?n zLaZ;_)=IBD**PuL4F-ct8)0pj^NzCOIheEYum+QpIx>HO6rwrCZy5j5z`B-0-yGOw znLwPS1mEY-+C={}f8i=|OV?yqL^in~lExf!a0!2hb_#XH2Wbh^z5{^eZfDT(9)j;R`)9Z8h zPP{l)t08ol_XAj}_1SWnen0 zXV`dDjpx+SSNPF52Rpm(&CX=uXTV;+CGpw}Z~SbSPtokvNDmQeEt;;B^Vgp8+QHQ* z2SRep3pl`3 z$P?3J7>Dz^TZ^c$u+MKGM#rOEV%~row3pIsZpv5guEXmp$Jr!~$e;<=((ha5ozJQ< zK&53$64NQoI(|8uZ8xS{I(2lJy-@ES@*Cm+&zdw6zCC7$$?Z>~6Q^{76#BU9j zO=x?sPN-sUbHv%EDlV^SQ5E0`rf3g+E`tMhjva#4OC1r@4Lm`+vJC(KCXp zm0Qg_BMW$Led+XvI^2`%x$dak$GP#7K0F>3`=9g-h*@o*V!^=%U{l8cfB(k-1T=%x z^#SQ#^O z)?qp8l~WgOMM4dR)iuYbd&bc3XNO*>4w=;3!NnRBWI~!M4iW8lrXWFQYe3RvSd)bi z3(!f%^Msr*DafU``_yY2zX?J?%#PJ|X>HDP~ z29V|-=Jw}nH-!lZ2pH5RqVQncVtLg|_3KNH&nwL~o1_he?=Dkv(nGnQ?WPk%0&Yl(6>N@@}_MnnY)$lOf&7WlPZypiS6Xb^`1>FN5Y| zU$)cx)(Z;Zqv3D-1Zon8pk#|!R(Wa^ugwZD4#`5or!07zQ8?IL6Qji}W`LsIrv;u- z)-*aMy=;wCd&|=bZ}q-zqY$6YN}}tR4(yE-g@wJrQUM3gCHlBsshL>VbmXaRB9kRf zvE}k7BE#E?97fWCjG~{-4t#1MY zeZ&HuW={te+I&7k&Bn5AVAd;7zKld|qzmsheM5AX-4(a|$iBZ#YW2(tGA^Y?`%Yw(;KTqE*BxYW z*i5=L;7Oe%WuLjywZ6juXRE6A2-)54@p~S5hkenSx*cwyE=3V?bQ7eMnY1>V8$!I^ zTXR21t>50@jRGWbh3-mjC0fUo*~9{CNQHKTCUzw!u#Ne{=)Xce6Be^G{UvU93QH<0 zb?>=VSu&UC9i^|#Z?5Q{-gOnVT-@XF0Qsgwf{L-CnSQk12bd94NlD2y%(1%DJAlNr z#bUqUef*MN;FWGY=bpLesJ;4g1kbK3({mcWeT^?zF*Ta&RN+iPu{=3>;l3lKxl^7=g`DN*PROY z%br_4-pCRL0=>y7ZRH3ve`+Rn&6X`3w`p^><5Xx5w5IFvpZ4N_(4VY7FTY37m7`!2 z5g6vCKn!f*o1a-U4|i${uaOj8;X4`wt8A#5;E|V0-^* zLG2qF^keHkLTYSmjP#{uQpiQw(l;Ttzc0qWxI|)MV(M|3ww)KG7Y5gYIXnQ_W_1VuIHyl>I3u>9 zXj+&e>&r(KP-5B2XY^g%5g;X+vh+6WPw%#Wgedh{dK!`F`+W4Jd!H7R0GsLI2adq(l_rf zrNEZeXoySq`<(oViQgR^9dG$H2%Zrh*41TODidDh*_WyF|7{{)g=W_buNZFta z-)yC}GQgI=9`+XVkwtAa20?J97o+f(E}Gk-}NYpmkKJ9BynpQ z@CU-HkkhXKBVt+N9U~e9ori}lcPy9oS{$o_@JO;BJDTy#@?E9d_6A3h-`T&e{TFp3 zR!8vAFMCEgI#$I`{9&)cQyDVU{Z_cWa(cxI0RnOfOz8S%-WZ2{f`x57yYtD5A)n{W z0thDGDQFNEy`nb$+4b?amWi>SsBxK|-h3#|J6!KzBPwv~*+_PHCfxSG{m`$ApilNo zxQ5;^;)&@SK*6{IZ5#mMA&EgeNrOES_}L4*Vh2B(Oh2fN3Rvcv5P9c1WYFvb)3)$A z?|sljg*>nrzhq^_bS#?yLEF5V8e;OTEn5gq-gGi>>{JJxlvC0t%*O|k;dbV=5T^?2 z+KVlJ`z~j$)r_5d-}w`Evu8EO@BZz!O?b}wV6l-@u~c7A?@dW@dx43o`q31HKjIF9 z;Ji|4^>LWIp1M1KG0kb?7w1PTm_oaZfE9=5Qe_o?Dpyx~wjAX9Ah5FdiVmOi7mp6) zIHvpL6D7Mo@)6QY>>y`pIZMU?KzI(;MJ>p#-Iu06Czd^8q845F1VpDT)5~(-@tC6M zBB-(Sih%?|JtJrPU(u^OAY29W${t$pj{#C5QSU_J=YL_}K~ZYj&VBvqduIq~N*WSw zB(b06x%8Wnj?Rm|nD0*zK0~9j4Mz*@>P!yM@C4Vt`Ck^}{nwZIRaJyG+9Rr9!6Xgy z?nj&Zoj8U*B547FLQH>4_hO>!ZB`Pn*mjsx_oCB;n{)1%_4^BuFOXTFBWa- zttn%v_|!78KmbeB&kM>mRa}V#_6APqi=R0e8F72htNREHgcgmz)&*TJjOPJXVrcs! zHP=5tq^50M(qO;bXP_Phqe0ij8`pkb){8zUy%!Z@HEGGAb{{_gm}(92dbFo^2?3}el)Hn!U6(oIqgSHP5Ygn(mgAQ z`JwqhOp2G%r1j(P|M1?tKa|7pcUOXEB*kykIr%Bo@k+l_TZ8P#61y$zNB07~3QWyP z@!Y|bdD?L$S`;h$(KXizG|T+_Z`|M;0d6>-l)&158gs9tVx%9}i9q{U69%%KfR3PV z;*L=@YDn0Vk&P*WqGk=}YmqVY$Ug(yi%Od&&eo)gvgVywkdLyrBr!-Q^~Vqah6P=U z+q?^!g)$^l(Sp;nKymGUWpgi+B3;M3}WFqD_ZxY5I$KXY& zWZQH1*D!gw;sKE0d>ZE|Vff_S$C51Z#xgH>l&g6SSzcAww14-knZPAu-kx=l6dN7+ z$SgOO0W6ve>!+ zsxa;uR3$KQawR<=$$}6RqU|A02$c+#$09=Y`1Bb${7s?2MDPFMY%?9>dh;CYo+u+E zP{G)ReXp$9tvRpl@0XUJCt`6Nv;X@!Cy(v#?|*#Q9x(amPk66|hDYj>i}%c z{vF{b^k^myqu5tjt9DX%kX3yEcn@_{+RSq?jhXp^ZRoF99=n3ZNrs|||6(F->^Nvj zVCg}v#j)6V!LF8K1SPar16x&9Rm9`(zo??7=CdMoNYcN49Y21sZYi|tzfQkf|Byt6 z<8*lc;rLhc6VBs4{{38cg=#y*k=r=VVMaUZ?k#r9BMqpN8^lP;shI@R^@+IkWgC%v zx<6y*;u-`@#s6-zRo6(p5BFuf9o%?Zp7j(ADCL@a_i~)iT{`=F&)jp;ea88}rf`rK zjW(=}9?i5T$|qw~*|fr%QxY(4e0q#4r`dqp4>+GFnD+7qLAF9;DysByd_^v=nS~p&~fCX`Np>@ zr!}p$4_iiIqJgM6@Q-tr85=QZE!dN6*|&~w+t~zno5z;ctGF$UsqGVr@3BsdX>$ zLS;kqr{EFHK$Py`_(sD_FZ#uY?-r{aeuO36b-|LsmjmkQSwRgl<~8;x^bauMlnh7| zW!(BCk90WN-DNSx`QG>HJ~ruFoV(@?S;&LW>%7OA>R@sJKWJ3Re3N!iqZ z?l)H*+pVl>L1yz9Xy-?gPn!-zCQtfGXQ-`mluU-{Xgv%UiLv-fjIXH+9q?OT{j4H2 zWoL=RRyK7TbKD@Q20TjUzU)PxfzU{34vy$=Z2%aq2?i_m-T3_}Gv>ho{Q7GWX=UGo0{=sx}9V!bs zP`XzT<=5MbfZGMrUuHP-i;PE15OsC4cBYFt#uE^V@I<;vv)aIBroby+g2ULx+!;^1 zTCVX$4gifb{O84oTDM-gj(_v@c&)Co<3M}<2l&9@Al^yhQ81}t7)UYU*?xcz5BiQ4P@ud__k>tJwKsT2 zm%sVj+G0v|UFYE7czz1GT4WJ%-%!xf;Nj%#rz@8V{kdooQ}(=PtaVA3H;udr-?`so zVK@t^h()4uQQtTomXkx@aWh0C0!ESv_sd|&;`lFb1MY%wD(Y6g%L>RP7ol-?A2AXc zzkrrI&eO=LNb4XjAdz=qQsy5w+4OFUoqaBoy;UQYby*b^IF29M`X0PhWFEg=nXIY0AtMa z^_M)m2RH8Sdk=}OTZS5)EIdZh^eNV+j}~fkw#7F0wO-Pd@*>qT&~QHy+96}t&M4r) z+4%zDoJo(S>mv*Qm#Bma{OgC{>-*qZg1)Bxv$NxAdx0?VXz?7q0wxxz8(76&hm`+HxExl6 z-Opv3a_%E%i*c_m25Sa%KH#}O0sOG43w!(Y+xV~a(8(k{eGi?bQKnm z*WKkhwZge=>W*dpeI%`(0&Skb#cB;vzi^YfxZhlqVKbemJkzWwz`eAhhF!oX$F$C6 zYd4TprG$IdKE5#BpyTu=-hHpK8Fekh;L;ob0j`$<4u{!_Ru0OVRxEOMT$NC1@$n{_ z+RY-`|IAtDHFlDZ-yiz;B1?;Fg6_P55ce?=DO1=7&+iKwUUCpuCAWI{Kx;~8W8Zh$ zEe@g5qgWw&(KsjjPHY{!83L-lAE@AH&rUDR=#dCJ#!QbjOJ zNNa;yO9l?C4;=Vts#t$j>4%{1}% zQ*Nhl^4CIaZ%)a6XV=1uan@i%C5t>Znd zxrq>^CnZZy=$OM78KLiA(A!*bR^FA*)VBXw9j09|Jz|&vdynt$?^m!&b$^p8�=Z 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 oNm;PI#mjd(!{?@+0PXSC&27fypxTljP zX4}-T=wZ%$2~$)L`&j}IV_QbFC9*RW4j5rmlP0dEUk_>_+hfe=U-)}YJy&@WR=Y=q z0!`P)O(akehv#_-uV*#459Y!e69&;*+Rd8J2H0u!n zQU>JOul4czVTJ);umST*tD#5~z=Y#=s^V{izYwmpo*MmV5?O?ep^V>#ina5@uNCLb zE|%a!i%;=&9v-V}$A7&Ks#F|BU6WV52dFMul`RjNHaujaYimT@C(^?89*r9~`DU}x zH~jt4cwFF^^g7N8`(mdDj=Pyx3T%JQ&e#QQtp!?l8NsFIdJIkHcot0$z zNO*)`gp^Z9Xmc=@$Lx3Z&+>Vh_Ap;O0JIQr`exbhx!aNIt*Aia?7jIW(58X_ZQt;( z*$k~j*2J<}eUN(D2bp$dYiP1V$;j$gTm0r~$@N(Lgq%Xn^bI`={Y{y&sJxA5=H}~& zyJ1*#^u3_rwoX=Fl7P&_Wzph57xuZuan3EBzyCAERupdwS%rFmu2me|ZGYE!bES-* znYd6C=9;v~t;xUzD%T-6&*4kB*!}S7#v23Z+QLc1Q-b@l&P5xYWcb6p*!SN|wVE+L z39fGhq5yDj*c6i*cII07-AH&4a(vN54rzUG0OufV0IYc z-3ax;ushcV$N_6&XR>7uU7U~N2Hw;9ig(cD*=*&S9PAmE!z1jsxa~$vg9T=uUc`>BDLQY+RV9ia!A?}b zzGd6!-6BNReT6v)KIC5O3KH60-js;gWgm;LF9cpx=gQfgXBiKa z!)K$1!5hfWr3$mk;Vh zN{`rGfR+Hy53`qP%aN(Ny2jPn$w`!z@WLKpX7OVE-O_{Gz;mc4x@rEp1mdLp8Tl~1 z!2}G&Fl1!lO6*tmC#wg~Omlw{miOw6-gKB=rKp?PPXvL`gWRaw&&5R&0e_tX+YUza zK;q<1e=X=lkT6Z259TXUl*=pz;Xi$t&a*hT=3~oRI6aW?`YRbyg%Lr60Ex9_rj=&4 zv)AKgV2^1{L0~qecPul|R3W8Gtum3_N*(C4P_pqZhP^BlyJU zLo;Xq=T_^4W#rVqJFU$x)dVmxc_><**r(Z`T6K>(cQ zzNn#CUY#({fQ_Q48)zrZZ^|8z2aRW$f6R|a?F{9!)CxelBK~zblL;Mr!P;neTlfxw z&e?$n5LSx0Wh4Cg2uGqNpDq7E?FGsz4Ro9VrA20VRo^~YM#DgJe0yTpU4Wt2qU%P? zq8`6IutF#pI&8R{DFF>tU+%k3hWQESiAvOMv|)vwbHQ_+)rDWIQ!JYa7R#z?hAE3V zzz}Q{Gc`4(kofTQs?9IydOvY>a@h>Tf7ng#uw*b8c|BX;v=3NmhNB+^P-vC3V%!O@BuEKNC?CCUR2P8D% zB56WF9c9hOvk?!HZ|o9xKJBRa!g%c`Q`T$-1r2|P#0RUkw~;6*aYWnMiPCSch;^u% z8AQ@_E(^QY zJL=8kIl1HY@kD%#X|RYgdE`%HjbsALk2C$KnB`;ayX7`Mia#N*D?h>cHH$9K^!T5M zhU1yDMUwR;{r-^PYr(m-3Q1Vr55{BfQ20T6@1^76&H9Sp_KKz$1>C1CzUPs0!v22J>pdYwg9(v14X{^a{43d6 zw+DW1CI`0${W}Q&(V3FNlK(X@Ge1Maq7`+g4NPHEl;q&d=9R-Z+vJL7X8pBJ=W-i9 z-+RAQv=BHjRV>PXfm6iXv6p;Xt_=4F=g<`Lp!f32o#ClQ{X&@i)RW5_nr#Sx5jkmq*@=Q+of6cXZnQL`e=3b_njMH>cL3%uP+=ObMj z?=4kK6}q>G-HsslAXr^W29L&5J-4i=c( z!mE(NM7)?CGGGnk4$fS^x3-D+*rMoe3`AQ4nwz`@HoGm!*z}#)FV;r9x^1PcR=vpsOFhy8t zF0gCW<1`3sSO?Oac8RJlB|XRxXyaV(_nm6jpa7AM@ddZ__6F%1K32j$k_9ZhnX*x$ z5k2Nyz4z_+LVrcK5(M?AEg{bpAX}L09cmD{*|yQ^|3{w^aV8>T_Vc zGP}y_8qi&;Qi1X+Zq4?d*7RbUF+GAT3LQ3La+V$cjUk)?>zfX_DLj$s7f2K5bOm z0y186RX`C-ZE?{yWlD{$(q;$WoaJTp!S-_ihN1i zj2hby2lZ*>OOb>`-jCKWpy)JnkJ5KHjJd3~QZ$#F#^iJv^#YO@ShtvL$%*8}6s8NN zv=euLBjw=93;ZSZy?>3sS=_SiPuc~%gNa$UMUUdIh*2>JL{~36hY5H;HfI8C<%6U{ zp}zF~+PzC5TcH9BFCdjGlkxwG2{U>=QBY9)gIN|4S$zs-PH+B zMTou~hr6dr6pikG{DFG#ly65a^4A;Y3A~)lUjG1{POp*Ho94*wcpAI^pEq8>lfEe zOtL^VJT&H-pyFmHVvBmhuShdg{`*>BGcGJGT!rB{Y8m`5=fWu{eml3=+k|JuL%#%v zjJxl)3j423F)E|cj<&f`banNilYDG*1nlwySki&k;q;3{+L1qerja1hyWl&F#{kCj z6H$Hv*YyN?eGZ&e&Q_1%#T{vJ{3b5P*>~U^aWcL1bmfANT8D^`iphe1EEDR~$zP9$ zGN*a^SDnSWlJKfc{J;kanV)y;L^!C5bbFTvxDqM(Sj+Bq^+e&5D5&k3nSJ;>U*t+(YBL_Ek$EBMEkfCe9VdaSO`wzz{UFh) zXsZbmCP%#y5o!r+KL}Jv+dk267WWqi_klvErZD+{7``kbY|2330d!f_+l@@!?9)Ul z8E|=^(a48L1kwpnzMj23uf{-~#!Mhdb-a-~&T=@DW1zPiATaeDHAXw+Z z{o|Y=qe6=W?KdNV7cPPARR_R_4Z)b~dN?_q7S*I`DCP5lwt9J0l9;0{;X{hi!7f}} z?Slhi6T=rR(<8-1#FaV?`C^48m?~g|M0^upy!u^WJw!2?e9p|B#W`}ydO&T(&2?Bf z8=LS3-)bc`c=_Xe(#zm(G?%X0Gf=g2Cr{}mNPIcj3RK~Wa3j&%VIcN}SuNFlgg(=H zL;l)rnLcy(mk;|e#^MXf>y9jy{9Gy8a5Fh%ek9Ag2o0ijppgqOelIto`@$sJ@?G$y zO#$VxMA##S;9BVDDB_u*RX!Zuy>yU}@d||9@&AtjK!vZ+X{fI6I;!h+Wd~5i? z3>tLpezZ_;Mn6K(x$tqj_vxNlUOvXK4f+O|fDrM4ww45Vj`p@y^yxO7pAHIXmO0{J(Z_el30Q;&HyD`1$PwZlLt--^wI-S((~ z)T#8h%`ktxQe46H&#Cuis0g<}IY(RhHroE9s;GcdqaYdW?#b^PK813~U zL674wD6K1r_Y;-?)lzxvGPA958st46P|ax*wkuD5WrmZDR1Iv01p0Qk=3d7!FVAVvakp^lD^r3G^NrA+(SfX3Yz1+UDc?qf+DWX2JZ z>{l#0azmrUARy&A24`y5MP%Q(eTI77-X1jtShSbJ`|3>3nsRx)W_tf_z2mdenZSu3 zmwcD|00u9#R+$WDD&6ib6|Kdbcm6>oHNL zqmhxWrgDq5k*&(06GlQrqKtV&cIV>fYx1(x*?Imn66MTSC(()`E-p?zL&D!IXWy_k z^8}`m$_Jqis4SH7+)}?3K>v>mAg|9p6m>aH@A9@=$7yNy01ltSLIX2LeGe5H&m@Ev zcrwQU$Qoq;)O`|Kh}5^FCEvP1bSt~Cp3>DTM;nHglcT9+h%(Vctny2KqbwF@ojp9hcMDu20Xnl=%!(GI44J14Zb! zuy5_CP+Il|#65U57{CE?w`CorogZ-Ep!h{d=ook2dlsWsBPEuCohsQ7Z~f0@!A6@z zsLlR;L(7YtC)#6X{!mOfH?PD!^n1sjtK}FY9651ntW;#$56Cz}8d`H0+gXeqnknJl zgne!kL`z~??}|jZi!6T;W5>tHR}xmj6ofYPqlCuUbcTGJhJ#v@lKo!UNb2h|OQ~>W z;QM8%@9|tEj5onUSmM7jX)I_xUP51hws4L2Ka3g3!OgCRFQTl8v7ReeYr@f7*{{jO zIqtsNVJl(J0t1;|q49^)_Gs{RiT)3EPa1hbT7ur-B_dBd6FH{N|AKzqj|(1j9U^%W zB07@R)q&@k1Z%YibG4CWg}w9b3p-hNi=6%7qS_GZ0pOCVy34L~a(-yyxYhR{+y2i8 zV_#zCtW&hAWFXgKd-?uq>bZvO*3gJ+K>)6R{n)Qioop5@^%E}Xd`Y@QoG@RpFd$Ok zAClbuzxa_ODD+CA`}gv1VDHB9+1tD1`*%2?D+Kn(#rtwb3G^{b1`VCHVRGA4s`~+ayHvhLG060zX zWTQV#lmllqa5^^InPlnXgM)=VRUb!QBUM@hX)Uq^@+Y^F0?x5Nl5!s~-s}18ek^6CLg~sx0~FkeQ*}o|o(ii}>KK0nvH^wY zH!n21^QJ-O+T{moy{tz-wZz>#eEN)}vB_+<;bPow^>R#+B^Ja3jolQU(G>C2f2j}k z;}9tDobLQ~;A3n)wCYMFAm>9#{J6xBB2~&`EOokxw1i>}*fFU7qkscM@QI}ok#XB5 zKpnA@qv4&V4PXaNXC{Bh|1-#78n+oCN4L%Urp}wDllwh>)6XBL;zu?0Ww*t~==D{1 z;qSrP+*v=9xB*rnyHkUfWqTtk7Lor?_yHR8zrvF^b#nqg% zsS4e0vH)SQw6$rPLkG~ekH&MpQl2a}D2n_H9)G z(P-d-7@zyygT>!wzat#Ih^XH$jem^d@?6ZVq)=}4eIHU1 zS()`cyb?I@daWkanWN6Q@kO2JoK}CF)nY-K4GA;#`aIn#(i*P@2c_l3l;rb2|0yM{ ztTCUD)kEkE{Dw?9);N=JIIa8#OJqhqyo*%v=A(ZQJ5gHoeGs^V+hMu@M!aAO;~
    t@X>#kCVbWcA3xT(*Gq}#t6N`Zu=_sjXZ~JYWeuj2K?ZsvAi--i znW|yY8oo%P&XMJ{#h?BW36W2eQ7&wkM#@x$Y=+1v1m@`I$l|bN!YpN1JDL9{xGQI+ z5P?8Xm5HRNVdLQ-uXD~WWbq%MEQo$SbeXXmuJx28#-AlJk%Y>v2|O`m8|c4yd+_ky zw-z!Gplw~dTZ{PNvU*2}2Xdtn4(E?v_})$v-?={rgHB_27>{>980hf33llKy$QyPP z`@6U6Mjnl!fC(!DkuQSH1Qh1}&p@caU^(&9CcTvDF*gXFF~^w8K$(kbF~+>!D6abPBjN#Sks^H2 ziDHS-SK2$blqqXppkEr)?|&w+nLRFnS&zlx0~1$lWg4KwZW>aYgqrh=eA9`v!7c~>+t_QA2UiTv|7~Xb79s4@Om6RNtDkU z2GYR;7~62q!!tq^*q*kVWeLA~&i4 z)KqV(TiU-IoK7`BE)^~Z%XLZ%YE@xAD>(8C- zt=NC!xox`QSu?mUz-`TmsWzX;x(*$V%AW|1AcWi zveMU!5c_AHg}vXttMQS+u`*)41uz5CKkLfk5iy4pILz zLf=cBYa_QJdq1*NX9gO6-;(8f6IcTa^=h`1DFne0?FNlP;RwOS`Vm0LmbNf~5Y|Pk zWY4qIWQ#_~Zd9s5gFX&NGn|`A9;u`R4k=R2-yM*T;W-|E>w+3R|84J=4+!Xnt%g)a zoO-sBL5eu9ZN-_EKA7_Z4tr)D5&Pd1g2Lz~^yf8VZJy0x(rmi*#)Lz zztQmVF)R#F6*6PtS0R3dhaYb$bz8Iat8to|r5LkhD=3t(TLsuQKrjO$5V;9lGR4@y zXx`3+jJ9={%46O*A<$W{v=(*pW2B&l4byp5G*K&zT&3^j=(CPhhZ+@gM`y>< zW7)j_0<@XP1r9-QOBf1_S$z_pRLiI41OyW0pDd8@`hn4v(m5{dW&KC_C@`_O2hP)! zZVIJ}zHmjL9&p$59+r6T26~_BEkKUuMBt@hR_dpzu@}BP>@BsM76SO zhY?aaLlOCe3)nNN03B1UVKb@ILanr`d7;uzqATcyeA;GBZ!ZO}{nX7G1=%grx2iE# z+@&7BW+Sh&+;NCke&_NgjAM*R77X_5dg^#-|GPT1F7zHB}LO@w*S_Cx4xv z{b>pDuD;0tNwIC@o5x75it9NH@=y?Wl9a7`^)*R>BDIbW6Hpf<42+GuU%_8C>C&xe z`8JiOju5?wT{inD-fsRoyWbs9*sf0>z&d#5RT9%s)9M|&C+89f%4@T}h0f1>$)}yC zPGiEu)jJ>0sV;H*^rFrz&ysFc;*G`BY-k*6N1O6z-vtIpmj`-AN=>`3f6R`6gN+DJ9AB|HKO6YVu@b3f;RQHL$d<#_P|Y8m`jp zm*TMCx5E?)5B%{)LSu<0Kj!XX)Zd=xkYZc4&*c8GGcZgFX49smE12Ko5{94ic>J(H z##Mu=q4mF9JnCzshQpbK3r6+40U(?$4EWtAHZIw@Zu<5%frfdZ&V2fcGvzw_j-!td z_yn}HH7P(=2#Y$ss7<2izigY!faQx70?k|K)dY+yE=NlS|XR4 z*kIlfWVD6O2nC~`<5^G=N^t;)Eux#q*UTY2ax9?d8+E08n~b?~!;{kUA^-(l&1biu znu&e+Sg5J3-SI=5K)1MPV{SE`*VNu-*-m)0gF2(p0Dem{c_5N$p9Q2uu{fe}@mh5i z=qTOW)~3MaoR|_Y+ghCUxX~N%dwotvTk~xINur3mj#^W{49Bi8c2iaf@i`3F@#2T) zp*lJyCgPrqeD35G47Fj#y+_h%G=akNLTA0Pc+f0FSZW)v+7Ecd;-2vS@m?|p02#}; zJ;%xEc^8*Orz3d1l$im43kjizl@tMev}qS#loA+FUAJRw|!+{*8KvYJQ0BcSyOqP5WbCXR~{ zO>o)H2zyt%2{*X*VQ}$pnDAQxip{oRzTY9}_HAq}cWl|+I-2Sr$X8U4X)@;f0%O?T;J@!@mWZ7!mlDg^l{>i43KV6#Vp zQ}cJL#!~78pN7d!1M|ltfvL^RQa!@S#t+fwvW`aJ98c{r9nSQ$A|Iy7_7$^4jF(X} z$vNJ%P+IiuNzpPMZZ1p9-S6>+*u5BJ1RgSA&(x|;upC8#SLY~ZDnnDbYx^?Nmzhmb7;0}x7cbr^fIJ$tt>MK#r-v%kvY%s z=vB{CFh|d*mDJZDgmRgvuf=sseP827t*htLx{MJ|Mt+>api1)iq^a#m*+R9mrgN!i zIurBK0@!UmZ>7bxv0V4>k>tUlF{)P2R=flyzms0%$>LuzCtlwR$eq#JOFD*Mi|#^f zgK{RY1OquMJo6>4otzlI!;kW0CK#bWda3?lp)8g&5Zjj2ra07ZjN^6e>>Sr8$=h4i zCvHQRumsaX@dmHDm(ZdouHLAI`h5)V{^hK8^CmPsUn=bvjH-N1?tJD@C?$O~EdizJ z@B`R<$)scB*rjhr)pzwt_AX zzo4FCzFo%DDdxqi?`(~AD0V;`gXU3E1x7lkj>?KcizsI`5>Q}_eT$BAG^qjT4KWw2 zsVYPq9@NcKRq6>jDj6!d7rv_y7Rbd`PZ(jyKG|tv$XU$wRSz<-_24sAb+eJw23EEl z`4?6XlB#U1|J;R+RiuX&aK(7)KYLlgrU6>gRo!UDF9P_>mV_^^MV5b+NQ;X{Cngd< z(L=9v3{n7#nkr?QH;ZU z0s>oQBly5pdu>Z1wEdm+M@IYK*wEcgg)R(wVi=hU6E2ML;7CY7=o39}V6DK**cUNx zCty_JZMR%u^XQ&)CEd@;mK=QgVO+d~AQ(e`JteOqeTKNg;q}>7LV;;5Rd(An8MhYZ z!0m%_8|4@mb7gCT?tmBuVgWpx-M91Ze~Wc%_C(8n5bFa`Y4G|<;4ox!(m$77BRGvs z0D8Q1G;_p};Ay0ozz9Y~I^gdNTBFs2cvL^7wy8rfIX6to4~fj5oq}e{K8Ma}5*})3 z*q)0!t$CDvH@9c0fP}2CAO>k#R^q*w<9MHKiR4bM2g}?@8~aW)>2@h$*MCrCR&YPs zKN~}V1DH{OPE^-9Ki3Zfs77^Oi%(QwYt|!7v9hsfUJ# z-On~(m6Vq7N=e1FwTX>SOccCAk0>r?N*S}>U^1%&*2dmV*IOsMT@@%_b@UEWJ;&FAtdQJ7-hCE={&#acwp6!xerz znp7}7j}(sdv9dW76sqOXN?DVY!pXaGk^s7SjNJf7SKbx>r=?TJkcW<6MFPzFv5o1r zMT#9=f1+y*+OFp$SwvGG%P5Y5JWZd}K6po2d^z9buh4le^BTAPRt??sJa#JugQGNf zyz$=gll}7NDWQyMNuS&|?N7OgAt608$3{cRzrd+Yyn0b{_k0FnDC-5CBZV#MnMJOtC;G@J~-2M(%u4+V&=Ob#=92l1&bHoZHC1XZQnJuYfg&Vq1AR zo57T5WfQX`ChN?tSHtA|ww12wGw3HQ$;}oNi^PW7T0$PWK#Ghis#AitvOuD*J?tm9 z`Y&o9ANY(td*+>(UA&)9v8Ine}#tjkzSKLnO`M#Ag=I9uA`cr`;mS#bQLjU2v<-mC(9o z1nA@DB}k~Nxv6Ow{yltm-;lRF(+Y1UfM)G>QsfNxX_L&0pih#~N$^@#r63fD{@nO? zFkPf>pA;)O>ywDs9!dVsUkIS*T;_SnZpT!xr9F>z=DxSI=uPq6YDPEwlIQx;M=O94 zm>Kwj+6PK5D>_Ug;f^B+ugGEd$+~f=GY? z5Wnlr!5`&WQaJLM83x7^YQk3Tnc}(7nYI?{+3yu)B(E zmr7cvd2=oz5-Sx7LPjNg*R5pY_ilQH&-nw&^Y>`@%rq^Tdyg6!fUmVC`DwASi`s@! zDf9+GpG?YriKh~S+>IzO684-j$+LloaBy*Qt|v%$x%*7k{2IE2SymEA;KIE*d2oOP zz`PFMXMLj07irOPLLkjgB} zA?&%992y?7Qf;A74PFEOflapoFa%HMDat;#GkhU^6vk!LuH3kWtrd@?5|G8)b71`6 zxoTx)EtDO=oqrf`64~#|Lef&=HDYGv8#q^6lQxWg!DO0N0AhOgs%+s!S&V0*%_*s0 zl$U)L7l>6h`a2fz)3#i#M%XY7PJ(e!cHBQPN(t}+Gy`cg^ucSIVPZ~PV=T^CWk*pY!BVW)-<1oWHh;9kWF(VHvFAUhBk zFXPaq&bbl?hTMC9TR@AJal5-v^66&y5#Exh6q9k3nW5O>8s@M3*=Gjs!+ZQ^m9s+( z6!hqsKYV{b6uxyzt>MJuaH@pz5fs1*56UU*Y>drXM*lsU0*a4op7zp#1E1VdrflQm zM&6`O$1!rZm_T6+c;svF zlJ8Mn!0<8GpY##<)tp-1n{sUjpqd77nYtt*i-=|x@$&2w;bv~61bvGRS2|MPV4{Qo zG=8DMO7iGzIV4o1g7MEp@5FCddCr6vGgNOk>P?QPOC^j^ae@HlaxpMBRK#4sdvse= z1lj<+2)*ibQn4J>61u&9S?nHK!LOFt(RfZmg@AKudVq#*}6Q2uW zxNGQ@o47=`$V1#J5RL3ayQl@KG<9+-SHb_TkS5Qx5GMx;1;vBx*%j-?3~|h4jW5cE zC&xNTV2Qj3@I8Bpa=XHO<&CUQfuZq@;8P;mUw!i2Lj{rwzxvemPR|PpK~U#i3z8?& zh{TA{mRm*Uih!>8@~1yRHjfBkd4S*Yp8|)VU#!KRO?j4Pz1EVyXJ3$o1=#F*c~3+e z!)Ye{4Mo6aQS5k3aAjVLQy%2 zmpZcf=-W+od`vUz@GVvLAu%N2)o!9|>eNxKhDl~#cHddyF!0Jk00?e#cZ_b`63G1k zw!!0&oK*VQ#%HPt2hcQ^u>SC>7i#vcvdSWf-=WY!C4Kd?dl0m%VQV$jQ$#HtZC?iR z(3J48q0OuCPziWrm#XKJ=F%`%!VbiCSTV`#lq}%^rxl*;^f-I1JGa?9#r|LIKTmB9 zoINLU51%812i9~DNX+k&XLR(upt9xVG~UsiL&dzO^WP@^OIU|SjROZYf@WrBtdUgK zOj#4tRK?ND=-#3B8m`XHLfz;bp#j3#{QwpXho6(N^flE0w2_(VFY^pHS>yZZ=h}0; zP?t$Dr+Ie8J+wXJ(A$;3u#;HOne6@ZB=VNyLk3Kl&M)b7GSN8JyW@HP-X0VnjVmBM z)aFaqduadf1$e~mxzxNLH48>L5Nt{>tpf4$x%#xLz7K1^ugyGYfn2l*k5B$dQ|N92 z`6k6huA)6h)~nUPv*$85$*pHYRPMtxEnDd!2kGul9jn$6%E6_##q-5C1WBPO z@jMFD>q%(16XOjO%f3?*zZv?LEjO{D-Hn~GQQeO(V%1gc%s**KTSqAv4I^9cvuh!I z#I1u5=>+hb*D>_?=~!^U%k#R}Fm=b38iwdVNLM1bfax_jtVHdiy0It@au`KG!++Eh zrmHw3-^96=gy__6x?>7Xoq^sq#MKC)Tzs{|@bvT?0>>}0dka|%Pm0OD&uqVbZ%R)L z09YT?u!^zwZ&L&}4^*KaE2NBv1HeiTodJ(gKcqp%^hv>`J!udL3*nab82)4}6U$Dini14AA{XD_2%OtsBxoMopZW(OIm{L`D01B2p#CsbvI>372RQ)H-ia1~lv@8~XUCe8i^s~} zpJHrGWxmB%re>|jY_|yNf*Y1YoJ^-we@$Iu|7(F+RmZyW+Qy;@ot1>xSaTbjp>1UlvUM@f?8o9mQulaY_j_NaTvvee z;bsFz>QnpdL-}5+CuMaJYn6r;hfn=_zMiu+gf=s(@Ru+@q|avO&>S9kc{C{OntW0? zfZWb8I_mn9B#d)D-6t7OBgO8xAK=z+*%Y3cy_Nf62BLQhBGIo1oY^kwmBfa5zeM1I zf~MrT)8zvLCH|9!XZ}RiOsWACaljfOk5~rS!R)a@x?0Tr>36opR>oqwqBoA-&dYY#2s{;dz@b6VR^Motaj8}@fqvbyt+j-y&OPT<8ETcZs9c*7nh2-<77s4MnEV(eJ~?Njm7W@9 z3D5B)Sz2@(R5!yfT8K8Uk;Z)d4)Q+i64dCKnwYXWI3&}^wr9==!SfB;HYL7^qe$=> z{QZJMy@4diK}3(;2Y+|M78uz3H?6)^N$8xDi>cy$x`VZozWatmd1Y!+pSWk;pBCVd z^+^)$co>BGqm;EYz0fpeXDpiwL&JhPnS}*#lF2&-+3VDF_EgWu`>qAjMGt-}2xsuMqZF&7w%g2NUd3S#=nbrdVTTF1~F52CS5JK==AAWWHO_s9qZ{*l(X;gIH z^YEvX94pM_!yuf%1(+vv((`COw6lHbs8G_dxtH1@ouLcFZG4(P$w5}Eq(wyj$RQ3fTvR7?{ROSDm8;gd};we}f6Kcu0t;^z# zzwp%VG`d$KpxhFlDnBHYxvv|HFwxLcvgd(iX1law)A_IO)&CmPS3uW+oeCoq?*H&S zNdr(m%t4sk81t1;>>BoS6*-eNtk806=VjgF%5%I6pW_P~{7wmtHpa4fq&JJ9-aEdz zWGDD#7Y1y`U{Y*RLY()y&oMLyIO-06#B*=nUqv0Yk79d6Ahcs45{t&XPydEbXU&2- zKJL5}mT1Z>?QDH+9DVaniMN#Y*kLQxrnEFafKpus3Hv;{9?Qr&6Zy4})Lw&-N1Inb zl4%z|QERQATwV%GqdY}Z(|i>Kiz;H|>D4r-vD5HHSL&@2a7D`?mDr8WY}r_U-_m;_ ziTjHx>=yQqr2C-@VeVnWUQYm8_iq-@^rXck{4NC5`^h>$_IN=y9{e5+3A}ohF1sKl z(tLbjAIc+a!fwN;TtfexA5zrM+k%AR*1ob=YWjy6VNW z%>5}}S+Om(s`?S$@4w8Syu|AxBtG{|e40;QIG7)KyTlmriaC`A~lcR=({EF_M_Kz=RdFrG?C>#d*-YfX;rmFgBVx@q71N{qeOr;<|_LAzqBS zqU(!RsTxY`2CQ7`gZON9Y~HFA{yLS|4XUyncp5Jmq44w?P|rB z1!oA}r9XxGZNj$0OcL@hi|UfjPsm5>Q)3O!%+*6kF{Jjz`0#hO@$qrW_2vvQYUaFg z7@HPQlu)&^V$|{jp*x;Z?+y7TPW=IPjWV4;FH}@luV*b_teRtfqaRUE~K^WLV z>nU?w>UtpW2{pgl`&=4@)>naI!8^4sMV_1qdQ_2Lh+{DKTYd>xbQ4eXg6e-3nY zdpam12iAa!EPJcGMdtS^U=Ag8!sJ)RO~l)6KPrrAJsq&`AMX+V>%|)~#ZBpnHhOU1CEM^%g}?tsQ(cwT5cA2EVTWQ zdAn5omCkdBS5h*zg5bWvy#&&aFCsf)tfX#cuS8|Np-t|v%__prAHJ}#aDDeX_z$2M zZ4~0WD5)M=?n~va5P}>5%B-k_yV^S~O|%toyoiLT)aOAM8*Z_~<*O#%J?guwBSnD^ z5m@T#_e4MxBz(V#9|;uIheowvzbz~`VvAjd*Sx&PB*QekdV52=EPQ-?40mYlgk?!A zIHGxXeT2M%f@nkJz;oa~%Opo_=QF!7zrz|ko{;>_y|e2DTOk3S^mJsIHbR9boPmx5 zHJQ@;#`HUuIbL@@${w+#DE#;x&N(mQ8^1U1Fg860vcvhw=GLEn=g%4rOb%U^g$KA| z<6Gb_bIH?RD@FuJ$pV_+y1Y@{>2ERU4}K^rNT&NsVvXl%o{0l{##1F`2zm?T+J%Cb z`BRlG%J9b&MF|7n6GxqnQeQQ#@f;IoKwXx8ST7YZ{yaEo?~x%6;_MQ}o!tbtk)Xh~ zuD)rPYr6&5z55Ioip*%;4=)ewCY&n8OO-g%1JQm`Y;@WdKrx+!q(lURHkr|-wN{ACl%E_ZL zJmt-c3?SdUzq!b2bWSN>1JZ%~j_QX~)YN2>8ELak^uAK{jcnUAYs;R8ZHu{YqMdZ# zoqWy$5x8`bf$X?QLr{9NMC6PFpivg{?r)!Vj}O5YScw|=TB&V0DJE3@vE_=1y6T=T zFyzaGkzw*_b2HB7jS`rUl8%Ai2m0GWx`%faOUK?hj$kAZ82vVV2P4@6x_b2bfk2jh zLoBIRGNl)}Uzh-ge23P+3ks9o;%Ox(e-RzNz7_@5?;Lao-?^Qx_mP+NQ0Df}_1xhD zcrpc*`F3qK>?Gh;6l{eWdy2+~0h88E^O=t;^2Q6%zufL_^N>5I;Wn zzj8A2963;@dqNTSxxyjRlPE6l<@?y5D!3pP$F13bGR#Xs!X|ty$nvmb`}C}TZ_>F8 zZ&GwVjgwbTW%3&c{_<<}d&;nYF4N(Gfe4z~u)f9LZ{KeNjqq(FqxI6D0@BZ85d5-F zF-koxm6#GO$983wzH-433)(4a2&s2^CP%>sY+_#M8+065i#RJ64_GI)jXYT@qM%kP z!tCz47G>Fyz0Az>Sjg{8ktd6?1{G!|<^MskrD)I$r_9WK@WuYg$qcw2&?>YTW-O-C(`KD3S5Mzp(46n42Fp7+SS^%YPX9F4el>p&x>Aywsiuab)>zr(&S^Fv&rD?SW>B-8)7c?y&Nq zhX>FKf`Z10Fb!fYo7mZ^pY0Kk#*B$?dxVECZNH5;nRIbl`Y}O3^jr*V_2oAB`X_Im z^gW&fGK-$iWue}C_tJ01Oj@O8Mfng0USHn#Pf?CBtggAWEQDVHp1hAgD8`6gs^dKX zttKNAc<=@vz^_m-kC>c*4}w@CZdEa7Qcg8ZSi%-(tvHNswP5X2DdIE9$*>CD}h zx0(jl;<^^EOG4zZ>-@5Ru+KQGi{cyD;BN_eFmSRz7vs zS!n0>mDudjFIDU`p4-<~<1ggX=%3w8s6I_?Z;pjBrIo7Xua(LyXk5WP{z^`AC_42JuZm`0(31&t2Qp zmdZk0J(pEZso9$fD8#}GZP--&b3m61zO9Py_Po>kE++@OjB@$&h0#M8g_Vs-z;ijk z-;Jx&ZTsocQ0@Wf2&})UTg58-?O5q+@5ecO03E|#@~v~o*t#K$Mj=Vak|uRTAy z`$J}q-iWjMX6*Rz#N@f*2Z-m!PjqbIAq8$`Pr;9HW%AwsR00yoR#GC-Mc~E0g#kOR zsRm#Orti@{5AfE;7cR$%tg?<-Vg35s_-d(@fRYi+pYn;D-t?6CC8w^k-*MC2M_>0b zhADhXc{%Nm&``FF+uy&5!s&ark4Pp7v+EKOPnr3^pjp3`x>TeqA%fm_%)dcum-z)A6B~{1U05d7y^J?e8W*x>RtiXCDGH&C#v`Vne zYhZ_^_z$0a9p82t^PqoT-P)G^v>&5kOf8M~Z)riaP7ghtQq0U#K~)c2WTC zsNs0p!J7-RI;&xVAi(l54ej_!dTZ2o@PQieO5ZeAGcGC7?P_H=zVRnS^VMIlpo z#Xogz+2yam=b1JeD_PzAx_HAF`+h8= zTr+CjtWMY>Ejz5*AF#=^zNcBnt9rPrHB-@|oX!5R2iSeTg*8fR=!Hi* z%j_9G)J(ZsQ2EZ~bI|KKT!O&lp#bM}1}tiK9C_l4;rgNvh=qW<73{m>O=cQ&_7>n&17l_=APh_q7S0!iUg5ZRZTGoVV&8~& zjDI^rA#*>e3ns=?#%6~E9nrlXCMDI6cGQ>-Bkmb;%eK|*!~>|o-YaMZBag?~>vVRe z1Fusb|64F;y%qw}j84U3?gF|$=Su}4`_ zwjVmRC;|k0yW%eJs2(PZDMxw?_$dVrsxzhJGN1WF{>41nG5@t;aWs^4|KdUFVV|{` zA?YYkNQ16NG)(WasSf_MHI>F5fsvP>3Yzg>2<3q`GoV1%Tf#{NY@5@&9nKQT@>xI& zk{Ugm(H!H{?P?lyG&D2jU78vpV@9hpTi+9Jju<6GB5e+zXPrr3l6Jt%|ksx>6Vdu;GmYfPTU{OfR4?kj+n%89P{ajo-p`EEHpG7nW8DMU zVu=moK4v!zuG}e~WV0KyMO!A=Q=UO6^FFhV(0~Gk5O&PMQ0GE1)T)Qv z%62xl_=2C4i~A)O3MXgE=_p4n2z1hQWg3J)L_|v^j{q(ca@(n#J{sR;Y(iR~wr#X8 z>gb@FGikvzs_A?N_+-+qIuK3+mJv9B3oTomvU2U9NDh#o4P`e;Gk$>i%5WpYYxIP( z=z}ar#yk%Tf+Xo`K@YlsXT;Di?T;_2_~#p_=c1-(a`0z(%vi zuSOy&A>2`)8{@spHq~;xOJrC)MuDwXT$&eDA$Am`r8Ymwz+$&2p8f=ub+0oC4G3?b zc6?uelugi=S3}JG%oM=*co14`L&h>b^$w@Px%zG6w&5!~Mc@L=^t9#UmuAn$JQqAS z3eOC9HACLm-1xnv0W&hl6l$C;!HgirM+vLpb*NxrJoF8eS)Y7}c%cTv^)om&F_3}AV5v5V7 ztdXaql?e%P4KZUr$T}28`_k7;#AW5=q`Lh_cDx{0M6@YH{*yY%Tg%W9Nt-%)NCKX8 zzgV63;cQc*PAPdtzh8b2fYxefYA#l8p0xNVxYsmi>KOK;In!ur{mUzTMeJTWkgY%r#h;m( zNI;0rkq)Np3Jz{Xbl?5f+aDV1ueEe{C(etl#+#BC&VFlVCIc{uyksIRzD(OrLO+ z5kB-zM?z9%ko%IpwUhRkJ-9;YNU~|-awSwyO|wsZf)5X`I(t#$c=Y?FA$BKcH(Ra5 zr!+2SL#smNx&`TJE6}ZyrJttk?*`B()6!KL-cUcJ)fK`&+4AsSNfOGDTY3eN z2zUyZpFTq)(V^)lrSK=UqHSLi2WHieZ$UQv^wxZ!18p1==Ujb#_5x$Bv36ePP1p@Z z6lQ}@V2xmufV^#;)f_>F&>FS5<%8G@EbXVv6Q@qK;IY|i%8Uv8-*41mZ-s{)7>D

    )^&O*L@R3x>%y%pAt_sf}Z)7ADwBv1+tk&&~+X+8(u{Vhm`!Xju!X zVSRDrk^khNwj4#PX1PEF)<&ObFW;95{gf;dY(aIIhek*VRtllR|9b&!iekYyWi-Dv z!{gP?``zSdKzYHpn4v7A54$2gkyo925GP6)=MVN^m9a5>ef{6g5tZHBIYDL1HH0_j<@CQ-3ZrPiWV%8U?N*RV*c2X@JQTAYR!?JxE6%Ij`nM3 zb=Uqz{Wxb==+v%ne4qCEudi!^@J7*Q@c#2` zyyebUZ2C~YXn)%WDy9mu2@1k%GQ`hRwdn_DEZ0mM8yhpcH_!@Pl$Ndme_b4Z!RyJNIW3t& zp;@BVwV;!sFXYy2+GgFvybr?~Prbd{AEcA_x79Lj16uHaZwbR%r}_L=56?KP<3~9r zmiGvE;a*PRODkp6OL0%P;_e>~RsxlAW z)3ijH7&j{F@6^}?7tiZ%M*Y@*EvB7}aJ*c^gX&78`7xBjB6t25N5cy%K9 z`dCp0b#`+sPM6DcC+!$CgdXGotqNvar%-A0qE&G9b(^a{U(;Nfw4A{Qyf7) zjXDVk=89p&kZCZ_)}B z_*kGWyJUJXy&w`JL*PWn$*LuQYkRLOEyN{`@ICaEF(8P|OA^N>6HIzvmq#>P)|W%2 zMMb|f*iH>8Zc)kxJ2{aUH9HCIxPoB5CQZ03@yRBCa_n5&q29dS5(yS?z#}B=06C-p zELY(z`D!cMK8e}7=>H}!)#5Vn&O}d?pwiOPYWgDRoO#fx(BTyNvM0H#ubV&t>r$J0s1XGkR}+JfJE+}E zr;_}Lw|@LN{C;GF?Y{;RS-)6R{&~Iip)Qb6HZeYxFB5feV9!CfJz$w^#2C@mm0kpy z^S~Xc9kUst1xmX}sqAjtZ-JQy93t^S;<<9-sXuxp^QWkI=Tbi!{(`B@y!#Hn%2ecm zUVgaf?X>lzgB<>u3T^V^7w+%~5?F#pyVZ0LP6}nPIJH_<`W6#= zlnH_(>3d=0Bxz~svf1X{YS>eGwxOhTf(qSxg-rQ#tv$LLb3XP5iko-R0TKbce4d(n zu0;^rzr;wOl{6T9wNe_^NdfJ)pJsN38}pQ@tEzsHVlSF>VuW^wJVB^sAjV%hv3s2| zrDuC#kxoN7lAC|a3m7=e7&S^O?k*=Ub&mHrD1Vzu08d^6;%iFTt@j3YCdz;KOG-J(ch}Y>%4)_X^ec(xSd(TO0E@&ktH0n!h3K8=xFKKo;8WIFFpaT3S zj>hpyN^Osn`*_V6%rp46jUAYb9=N9xcVa6_NZzDgb&OqZ+*jzv(HPIEmZm1BYA!}Sv~SsROe61HY+B^@iiLx4|dS6vxW8Mwo$)^VH@KDi0$SQ&_D{% z6P%1JOkEgW79BvB3$2gY(r4!(w#bfkoe|!&vkyVtbahmbqsw&R6RMqY%rIlOXckN; zRyG*NrycLy^*=2lRMN98b+cqT)?wzZbhXaSyX~9)5x1MYR#s>XlqdE2u%Dj~{W_Bh zmjSi;__!v&3!>PT+u?J-XT_9;HanT|ju)WmwO@UiO^A!LXrm@ncoQI5a-yyz5pX2; zsv2t_cP!?~_`#GbzQbYh;J|ae;NrCjuU?e^Y3WiIFcc+8$oqROf#z}d#bFaEFCp>9 zHm5;gx0=RUx3dx6cxqN|xM-BY(9pIk{yK5Xt(}d>Q1qQ6Y9@a8tk{RoWf~{~YFN*4 z=}Ch=r!_RTqH(j71129X>eip=7m_*^rYq3AH|PX(x>ZvS4nBjq6mQmXajWLQ z@N5w?FgHU^T6W{4qy}+@-$wyEF~#y`DdhNcnqdl#;7cZKdGUre%sSorSCL`?p}0L&C1?*1dph&fyab)!e7rF}N9VYaULsW-<%m?49;EoCpDo-H-;0(hk5Mb~>s z_{A=Md>gkX@)H=e+1=YaTabB*i6cv~d}me=J}?hbn|gcV_nNxsMcLuiu-yr(Fol+` zI(KMgnU}M(<(<}K^^Tnqlok!FFs!Ia=+i^5M`_@#Mh6Z2rzm{mfw+RbK$Lk4T18x~UV$3s@ z|5+Z03)pEbeT7O~K-o5YC}GVDsG?lywQW$BHP@c7*Y$2>y6-qp0*vZgV=yT7?Zq{E zMN5wMay~^}qG6GZ3(+S|`pkD)8c2qfyDl|558jsbD2*=@Y(Cq#zrl4sHAOA+1sFms z)8!>ZCN6))JvW5lSgdJvC|$3tJWbb5MQktRV_Q4YrEG%^lNS`x9)xw&M zxeE=;7g0c9Qz;^)4AZLb5OsFNE-ORDMOq=7b1{kW(g2pcy~Czmyq6BT%*iw3osne= zxREG0k-9lz!Q#3slX12Z=Jdt7l@^yOwpn<)UDt6T_o%0xiqvcSl%5o`IzY`Np>A}P zvpANy_2+SDegeEc^>oi;iSn1Jm`kjh0HY`rOCMA^IT&i2>J0}u4Qq}7W0$_Ew>h4E z-3e)=#8bVxl`NkEh%f;84TY49^nIⅈb$#NY0!r>R%fbbSg6Ew92viJDpWS4S`At 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

    &< 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 diff --git a/.vaunt/badges/badge_02-02.png b/.vaunt/badges/badge_02-02.png deleted file mode 100644 index 623667665d7fae656225f44a86d9d8cf65c57b3b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 147829 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

    LzVMB+PjyX}Bi09CCGHA3qjJO-=1| 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 L>rR=HdFcNEc}|ti diff --git a/.vaunt/badges/badge_01-04.png b/.vaunt/badges/badge_01-04.png deleted file mode 100644 index 000014f6304ddeb8a5f6580c2aef1ada19e39d3d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 153618 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 z%0A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 diff --git a/.vaunt/badges/badge_02-00.png b/.vaunt/badges/badge_02-00.png deleted file mode 100644 index 7def394f4a7e6e8a06faac0bb81099a4b227e071..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 136502 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

  • P7qpfL@PU$jMcM7y?Kjz>FWOANsadv@f;Ex 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 diff --git a/.vaunt/badges/badge_02-04.png b/.vaunt/badges/badge_02-04.png deleted file mode 100644 index b0abc6880e3c9e9dea8550310a11f4e6d57359d6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 159437 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

    igx{5xk;W9zZm-Gc(iJGk6Zzdgs!C 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 pi|iP)2&z%X<-q9P(8jY>&_fV2n*i1bhr zLw9%co?~41b=}YNt>=B$`quk>f84VMIAfp3v5#H9z4viyq?U&AH3Av}3=E8Gswzs_ z7#Ns)=pTGs;7aEZ>L~^Ww}mBG!2tdD3BthwxJ(cHwXzg&0%MS2kOp92e83P(cE2p2~Q1j5!zLPP*;C2TEX!2=N#vf>f47PR8AfQSk6h=MJ|1R=uK zAbyAdFc)U_@8LLp4F`t*mq~fSa5%)p)fVOm2Ohxq_WJ?WpAT5TT>hH}EdQcTu>>eG zq2OOv0^eExIk6@QfWxd^-N7ypc__ru)j{40W&vTmXX^s7w)b?lvW42Z zg6(x+2p3C;uBQ{k)mxwhSOft8=#E-Fb0$Zt|=lu1-!u!oC%THDX zEbafR&@Ju3whjO}<`|mITpKG(30GTJdk9P!;s|j81A=B$bpS&lw!jT*n2Q70)z%h$ z&gbL^ePZhfEX2_gqN?P9wI;0XRc}whzO88aEVVqjF+DgjMl0-TI+luUQu2VM)V<% z3miBT5atzd{kL(HNzg{x&4k4dQ}UfE9Y^OIx@t)Di58aDjN-ghTAD znSTmj`lp5cb?eE$j5z46CBnttgYDmG|3$&~^V#1v`&(nH1=iC~g42B-r!0%_UkowJ z2j!S@wY<7cdT)=(s+X(j*PtB#)1ZGD)bC+KnjSkguVeQnJ*gTWq-Sly*2837yDioV zGk7pN^9ttqH`BquV3+%C2EQy;!1BLw*1uK^m;yT~+7$Xjlrk~JSl(F!w{+pInYONQ zS6!GL1hC&sOE<8+A+abZh*%JWjfIH;9B|@Z$O#J*^A}avxjh~xi2vUn!eQj=e(%`P zU8*F(<^1{eRJLVH z_1=k5Gz-7^#3Tgxw&W)SUB$(Igo8_t^+<=G8bpacAs{DK0%DCK5b3xXRUIvP`6WT( z=o{GN0)K8W>bd|{4LFjr5Tmw^ybwrSgi%LD9&l?$U0Vl;jw{%~$<`6ds3;Gjr@kg2 z2oeX0fqs6BsILhM@e6=N1q6k~g~g3P2LGE(fIz&zm|**hiC^v@FR!cib5_7{9h?}o zA#f+aAs{XwLl8MG9|vKrDZ*fH1>u{GJJB33vL( zOdx~5sIbD+{_q1vGXnny;r}U1uK#A&*g=5*dT>2cXbT|?F?b!+L3tYgWsk7GBd}t> z_>Msb^TQTTB4vve!t!3o^~Xd=zn4iITNkjATgw-MTs_1TGw~9IQHRV;%T(G%GgD3v z1t{@?azcwQZNBTB-hddj))N-ak>B;4E6!z<8YD6A z%RIG8k-Vvcz#$BbpF>1#zjNYP{$5|iYVrJ*hIQ_X4y#grmB(DvPkRVjjkCtQ@0Ey< zzcx*2Z|!FK`l{TJiRb-}dtYLpf}gaG6E;|UEwtR%TIusp4C?F$-)J0P{je3Z^+qFs zbRBJ{n&e_422|{O$I@_1n)s2M{MV2Njl2(Gkwl%3OJ&rjA9ybLUzEZhhxd~ zQ@J)&^nik+c7Q#YbE0h8qQm~B++(>k0f_^AT9qoQlj|;(OF4E_C3@OCtV)%hW`@(= z{4&I-UAvf=G4+0mHjij`{E2SEIWtF>T2K&f5hw^J{&y(E6A`Uq(e)WoE;whm<}@?@ zHOJrGokUh+Uf#-`$i*LjP2TG!j7u zEpkFuc)Y`relC{px#Gu=A7tC`(((X~j@(76<1^-+7rP5BTU zd~?G5qb}iX8%NRGwQ>dKWs~=PyZ6PfLpO=DEbZsATj{z)u9*xj(B?K-xyt2yc4@8A zU?{CHQ1`qTj)un;aEs4msSItE@RR51bHuap?uTbbYq(K9Vs%Pn_0OPDW>lP2v<&b@ zII`V&nJ6JfR(^1hwjgP|7C6a7F&f0#_Np;sa#rRo{A7{A$o}DN}9}EB-MB>2+*hbLLvBS<9*HX_a9HP6?y=>ZU2D)B7@4-f|Jp~^x4y19ZB(JN-akpfA8#4= zjPpMs=U;=^|8D^NKQpnPh~;be;&W^zEHO`s3DeJdXymrSbjb}~Qg!kkkWP2wjng(Q z)0qbxr%q3=ec-S?vu*03!&{bl+&)4$Z(=;`5PlNEct?mI+EsZy9@e6zWqc%3K6Q43{P@1*@{alBGh2{S(Hl0}d=?;E zubSjsJxD9{d=vOiFD#$nZU?I6dB$Sm>1lSVOL0qEQ_~aY(XZqIS6eF6yTZd+YBk@f zR=ZorY`df^Kfuz?5%r7JDUhVYS0#DfCGItGdB^e%8@IHqUCy?3vwW9krCjpu+j6~C z;rAbOWTR&r(7d`JNHr%-1KbRtYa`rZ~B{2BA;TB3p>&{>9nMM6qyP#hatou& z^viKCvp)vmoEsMF=oZ9HA)6!osxsGtKh674lC#A4gGaht3;`#fcZj*>hfeeOlql~n zk`vR7iHgx=aviJ>`JC|wVSWOf?juk*fZYGDX+CK^% z(5-*nyTVU`PW1m)n}E3fMvO(oe+xtd0uovricy+s!3*lbJ;;V(dtuQ=p?8u-7?yv;wxq+zHj2)~f7Sv(#*U*5x{Jl=W>1zd z?yJLp?^&!-Cs?klaV0bSe3=GIT$XcVj<|pk>o&&tnfi!`$JDH~kn}O-gsUNIZ_q2) z{4RwUAF1eF2Y+U$hp?p$&|L{K#1#ZG4?ZCCp#GhC&>9m;{wSF<-PygCrrYPE*CsIwg4==1~T;spEIzTl?=(V~e6$tivj{me8Nbs#Qo zKwb~$XZjg{fL!F}uiIKKFe`+m>t6(n%7VYkG6A42{gaFc2!VjpKgmd7CO;X71U(Bj z5xynZmd6Pg1g*oL6BCgu!W>bXfVQ|PFI(#AmMXHZlb{vr=;LBtLv$t+eN{8U}9^k&z{s{;jBZ7TSrEx$~7#p?JgHB!(ZoI$rIvFFOYcW>i}PMh`2*h6`@hSJ))! zrg`oGzXwCx(D#9N5F@PN%RL!v2j3wFVF;x zIDuh6y922C{-VOd2Ejqje<-oAKoBBJLl}Y)Xk#)u0*S8^#KpnZ72PXvg)t)F5Jp!U zTR5W{V5pA33A)Q*Yi(-@bmbUdl@Sd8+cOrP06m1!{x>-o>H>iPT}4-3kSUrU z1{^(*E=W5=D?{V2lG4e}mItU)dEuT8V1%p9&mz|nY%U5GwiE<|EJX$R`9+05B48^k zesLgPSy=L0SPBSQ^Qi$mz+Dx!)qYmFqJLHdBp_TM4iMX)bD+ef{hbn^XZl&@{%xwC zWx$`(U7y2CK>hp0oUq1c1{QcXTqhs(?rgo(H zq`upvyCUt7hy3VXNj2^Cdl@A+9-UNAuB=UN0hQ~|`BNRD%V=ooy0zlv=evdv;@`QP zo7FptQpsi-JxG5LZ+MJitBX0n%DUtv^1HEvkl`8JZ;RT!?ME}Ds;ivm`x^D=3a#wq z7>eY_gNue-`1?@y!A}=2Sl2UlzVqW@iA&y(h>Z<@D*A}kwh5y}iF@f#$BKGp(OT+8 zLQc!PQp78gC4#4{<`mJ{&jjox#+A}7;%Zf$lstBKz6KL*o_BYHe=Ma3FOqpyP$?$q z$-caM(fx&4CrW}X3X=7J0`#_1T@8CZQ;TA1 zszlef#f9$7%ffZwBK;*OwYdD+?giV($L9sDd^Th^-7Hp!7@?BtsrE(-+1HlUyRPI> zh}~#B+ez#bW)@f&l)fLrrgA$mH;UP(5u+Qsh33xiJq%26m!s(-!|Y*FNBy^v=CzHR zL+TX-@0~lCiELdbHr1ep!cX9PYvwi2CrLlviIMz_@4*?9HFKs#lj2@2#SUFQ*}n|G zM%~U%a&JS5;PC^W-7mR);WTYqAtll~(5^GY_Wz8R|8Jni@8TAlob*@p{#mvv$}=hppuvJ)gr6VX1V?{>9-a_Ca4Pl( zEdD>ju>Yx+tzzJX`-}{8c7y1eQDU{QG^>kiKR)*HW8ZM7!D!HQ4Zcqia_3a!!_wQk^6TcV zVDT>%C<~AbOJ2)m4oflWEPLBpqq&MLNn zUNA_DkS5`fP+Zsn zDiBFBszoj{ErWvH9vA({NmY$Nh4QXDBhn#NG^8evV`jfJIt!C63j6z#WV!~IzkSX| z<#%fNmCoH(@{&QGypba*{8>72oN4$l!F))NOx}isG4C@ifzW4HP3D8^<8?<=sdP)G zGtPXw)4Hbr)UrYV{(=76T2}ZMi132AL7W-v8LVL}|El(Q|4KCYejd31MIuz-Cpi2A zJTY-W6u-dp8oG)5v%wC4Cmu-u7h-CGG(c*9T?gP&79{-#Ot3Ji_|Y@Mfo(i=OX*)z zI@rQ3`2c|7L+4%Qa5qa}&&UbRYvbx*4-~@y^pW8JS>SuXY59LQtFXz5bPUxMdC<*x z9znss)#?8&4E?=M&%QP7pv$6`8?EBf=$Q9xaBhts`EL>DCr&wc&*MGI9_JZvpOS=_ zVY~{ATa9C6DNeT)Gwtx%{`4bD9RnhHr|E`CT7zNLI4!QEVep+3!CIyrO<3)16FsW^ z>W*N_)7KTkQLMjUGW8JA65rTJN<*^5UhZIqu0D~x@kBY^wtCM&0YNoZi=;ku`*9sQYU!z-S|sYC9=ne2HM((xrO@humt!h^CSa@C-? zI=?Fv&lud}-sMi!ZwR07R8eA!$uXF-J8Giv+*&*t$_kRm6{8_d!?-&w$xjd4}6c4fI3cXHL)k(1VSFRASOSL+Y;8 zNUURtfov2^ zy>;#4)$|?8mnZe^VB9Mt=8}Wj3VAz}TgAPi?tSvSI}f~pedvyN3KmL#Jh%}dnd{h~ z!%oYV;~J&HeBC?#bIL8rO1?3;!h?ii{+R*D03eN9U?32nlFH!t~#k00x$C7k)VGtO%z{N zU|=v}s4B_pdZet?d%k9A^Fk@)b!mKNl0Lvf=qtSR&IVXhfz^l_sLXQVwA1}zt$Z1 z-D)w=$67zu5AXxV8jibQR2u1iSs;FXKe2>PIx{1q`^81^+8A2gFK$HxTOA7c4nj#M zGcyWU82EiSrb+kMF|-Isu`ohNnvqCd$+-KY7`^Lmc5(M1-F@cv8ft1HHKye?B_&(I zvu)9^x(!5eK9jSk#pZva|Xl@*2*uP#=d;XVqSJ#h!=!* zKU34t7?+au=NMgg8yK~BJL%7Qu;lu~=|bo#KA6#Zxcf2yj>4?)Uk{1WT5Ntp%$juX zy@$o86b8AMDlPot;*s~>@fWY&b9nOPgAQk01AK2O=6?R*N%zRe(HT!w-9c@&$;O&S zg()D9eq*K#g*dBSytUjWrgEnNqX; zmA1#keFC9LH1rk_dI#fmOzBrDm5kZ8FQiV_$`1!upQk4#C)Z|;2^X)rN+|cFNheUq zcPb8?&YK+uNstv)5hF^u>oe#-{s=xf7a$=<@XN~Z1?A;+WEZVMh19)0y}TB@JFI4m zi#@yS(mED*V;;x?BIY0iB>X-)G23&kJpFvFmNV|#s<3*arLXV#$Y?o~T!Z~ehH8ca z#(NDZ`iLjFof2O%y2sb*GrIkvJVO-q)}Jo&z}Yllxlxu!U@iT)^iVsRrlTVz!C2MC zAL~Y_Z&v-Nn#DBlG7Ap?}#M zB7qB74g<0}aV)H6^970**(wzTmO)-wzn@#K>b`TskMxJ1@0Sev0$D9~ilk-NlV?S= zsKmq@mnVf)lPB)X%*?<<)T%6ax`5JLGUh|6&3u{<8!zkqwTne3Kb4d?O;p1d3Avv& zMJ70rVsYl4PF>%>ci%tCTL_U?h__$72uaV%Xiy2spn(ec=m+l5!)~tw)ZaoFx=;`k6mf89-+#rJG!-97YSYlZ*dWjy*5BPjH z(~AlU#;fY;&XPhyLva|2a3Nwy&nkgpW_-j-=zdU5ioX~#Prt}1w;c4GP$%vYw^HKi zIHriXo-ndm>M9eGgE}VxQhfCUl1nJgmB|}6zk6&gk?MClxl4x5a4TlbJu-m4qv3jI z**$viwFjHx?i=HmA3uKFtAQ_eQ)2jY8{7$2Fm>|`mpA=r;EuKOI;xypi)4uJyYD37 z%G$u~7lC-UySP0|3tJ?1ESILWa!ib$)+o8xuT^aAQ$#W6zfoHlYqi)e7oBh&XnyzZ zU7!7l%E5C$tX4gp1DgK(*}IE9m#fFe$NoMG-{06Jb+HCy+^v$%)u9#u^Ui??Uy;ma zb{7khgx8R$%V?0Uyd@S!-d)PiEOJTD&+HCA4612#G`)iGJFJ=1V$-I*BB}EMn(5M6 zzE^5M1lSE9CBbncF9m_W=VGdR!!s48(Pp%*N^_9No^2WD5B}gY{p2)Vh`PKuR37oY z|41_Z_={p{_#FmOe8e|X?6Gi(Vy;^&@}``*-kI7)H&+UXX{d{KlyZ3-=vNA!Hy1#v zZ*kWXA#Tn9I*0b;XK37cU^|2qkw#nq4!XDJ zW*#-=Vl2mAHDY_!J$-i`_e6feJvu+5$Zfdu7_YNtmfFx(U>u&iAw zc7pu=ea{@_Hs+A70H6RSTH{)siX_r|m04Ny=I4FUey*sUo%=5US+}z~Z}$_f?6jF6 z*|5tPka<`iKb*DHJ<@^+C6zc3V)Q<#=v_DJ6~gLVdD~~>JdY`nN-ROAbJbLs1p<@r zWr}Vik7%2n6uym}(6v)*bnoyxznqZr4^H zAMIaVmBWzB)H0x>qw_xN&CH9QbRAIddv>f6b{}w60Sb$;gLXDq&zW;L9KPv!JkLPy zvJqCTH{bC@V6ci1;aMksYo)APFaK(1*~9!teU8aXt`Zy4om|GfMag{AK+_MZb)+CBe@e_Eu}jhTzR=5=<~+oT%-2GUWmN3m`u+F4^P^%&pB#yzhmXgg;UgJ)9Nj*IA1HnXJ%T9Z29}aHU5pF$oaED zEm)N#z(nrg2OAN98?~eI)u!`&&da8dnzLm2*g%;#YD~#p)xFWG+w*$`Yx23Bv%8$R zovDJ9$ks|ig;ez+IJEQfd}(RPza9XBi|a8;We?B{aPex&o)0E>r%IkS!Te9>GtK~=tY<6%hMN<8%JbJk#hw1arRV- z5~a?zm>Z8KHvJA|>vq0z4GYm+Yod82dIkJ8sOE`7C4;}67E~~E)Wfa9=x(8&a`~te zTV4kvA(tJ_eriySxjS2fAbq+#XPkmavOH_-w(+y})1`3vdO!mfsli$#7qlrh)KRT3 zJLelDMMN$xC*eI4m)ByHT&}QSd9frsvLB;AF23BqkWETX_CCxnZb)MIEdvg&arc>0HJE{KY{wUnYtfkia^9VdXhlh- zN3ni5$pc}GaqQ!FC!zD)zu0?X)z8kwMS#XGdag_rSTk=_ij?QhMzP<1K7-%IF*Rz$ ze(1Kp$(!7G`VQw5J7-%X+1yS!$Z$LanE0((@jJcz>e`U*`D(*+=oJCqukdc zmDrJ|Fqr{w^|}vTx?0dns;JgYHFfm~|6x;iUkbpG6w!v{K$zt^CzyV`R-7WSe^%Vn zRi8u>)rKwamMS?diH+zi(<&S)DJ>1W55bOyaA5Kza0H!Pgw*KVyH-=goZJOiFR&u- zjbp#$o`@dHRV{bc{>buWc=h-IoHCi1)o*sOJ3R6$O(S_9D!UFwzt=fgG6NT4(&23q~eue9}o$=5h7yF z4yhsd!kN1Zc_eS@qpai`LfSIBy)ZH|f?e#pZijMT>dnMoi?LTlL%S`Q(SM^F)|g{r z7PZZ0&A)sFA&N`wZl@*MMLaaj#hx(SYhU@kE?DBIWD;->28!Hrp-3gHW1sF+1E@-P zJI-zH_|D>5f))G7s@_)eSanpD3RJn>WK3275mKPo1g#CEG*!zb%#W3 zQXn6lB;IKVtf&xfeYW@5kSSMLi-BTg&5S8Vi8tXcYpgu?f_NGQ={-i+%@seW{79Jj(Ue9EphGjXNA~hd{quXxwLP2dt#dAN z6J_?m=P?8_82af3TaXvvUttna$!e@XcK1>v$CNI(KnKe9El)K4Ap&1l3lF0?0&Mku z3sB8cW9@2DEmMhdzYZX)>zuFqV>EqNbka|g8$H)@QnH}k;k{SMXU&LnVfOYJCcN*o zNAW*D{BDdSla~%U(NLJ^EA%X%AF$mH5eMMK|Fi-uhQx%5PaYi|`PW{YtokFoyd+#& zmEXR`Uy8vA(U#cB@jrnw_-<4$P68DJMeKwSL_!!jDEXN~8`~*9F|HF*P#9N_t&Wt7 z-912Tog9_muaF^uu&%)PJs!Y1Gvm^uU`H9|$_gR`dog*WQn>-Q%vREH-GZ;6pdi@@ zGa1@x(!>}q2crE}jeF{$4h}p+Ttz<5^8C$l^CX^81Gb!}TT)ZQspd#Na41X;#Ho%54 zG0q0f&j(@YXoqP8;$P-!J7km>DVa)4MV&BSG2_N=05K&)GNb)o__^GG(0grL3Ifj? zVWp7V(|O9nLR4+Z=jzkUlcTskZOH%hbSc0z8c{RAE}W*#CU>-OX)0 zEv5_xQ0D6wK6A|e9y7_Pvjy1?!{>Kw5(rnaZ7pm&obx-O5z1Qn%P%q-(la#hCC8)# zePl>XMX|IFjTA7B7BaizJ6bLHDF{LvYmOI^{g1b%oBNJVFkj&>;i+h(9Oa|@4o0CU z_vtUKpE!NkGR=yIwRjUA@+Oes+D(ct5awuhihIP_%wo9X)UiFt8lDc1rg>S0Uo|ZOVs%H5TkusMppSMU4e) z6Z_-r7b-}{-IpIm@D&!V0w(X|HWxd+Zeo`drjf(5WI=j3{DA!9n1lPw+t?S{w1s+- zK_`?!5*RHO{Bthi!xki!6$X5zQakl#!$6JE1Hkm*IFRw@kaaWwl05}fCbs>Vx?yXp z$6dmqxv{oft9W?zw&h&%AcK4=rU;M@4!FJ_;5b~;SQO0)057Rz^*=UV+F9m^>r|cA zRC}-RCaKFh!%;>{c-jbu_jKKrfE}U7`EiVHr1H6A72$vocueHSx*N_uT|iB?Esy|@ z+rsK6Rsk&Ug3cYS84d3*AdyJ6$-QjRa~h^mYP53NJ7RM-F2)yS4nq^nylkIN#7-2| zTao65Yr3uS;nA%SecSf91$==#x~2#y*9hVh8aL~4>8E^5kFG}ej9$$&5i2h_cM(oj zFVZj$mmrB}e3rUuU4EsrtZ(^a?{eajTW!idV1rt@gs^Rj8Acud78U!0f=(R?r+t|UPWtWEW2UD3^t zYnVbky*S4~G=qS_fJjajEy-ZfcDHDsJ>2q9XT}2NMhoVdqVtWTiTr>p`hqIU%-zp* zby|yvQvWxUD95V4b+tda9W-u;D~_IqvZiZ(>&pIVypOgA}hy zu(GmVZgs(46ztb?0~VN@Ti_CBPq`8g0egDh%<6wa;+q@`Fk+2ZbP*>RFEtpaO^(0) zfFq<-lOFl~!@=$%W`p5_iN4hkJI0pdi6<4G_GM;$wPd$#J9ks_KuEj2R2rPn-3!c8t}3b9u>XnQtl3)Il(0DdqyjTA1kpMn&b)RNoaj|bX(J@JW-yw%v0iT*piaQtfa;r;T zI-wIVml{0}sxWXn$7kaaKcm6pO{UKf70E-N{G@QfQ;=YkSypiCE+P_wDfH3k8Ytk% zIgEBiik+wP-n%}z+6jevGv)e8v0g1UB}Hy)##D{k&4q4-RMH@O5lK;g{_O#vt)(wS z?iZ~BSPWD8<(XpRCF=6j|8h_}54oGNV|E=EZ8bBkQB$Jn+XF-&V3H6r1+O{ZISb-0B-Qbg} zFL!rGCAFXqZ*6Jp$I#pXY}RiCTret_4n#=y3CuT?H;GJgA~AyuzS{u#WTtyl%&$OTyw`9ceU7XZZI(TpZu^ZK4&PZS@~d-P<=Zde@T&B zQ);`V$8S3-+UMj;=6DvwS%=;;)%oR(L8e9ivj9rm1;ZKHPY*Z?3?i2(%5ub!9HLWo5Sa z2F!goGssb1S1%*f2U-AzIO90+zBL8ZQD@Rew>@O107*!!Y~+3ow%rm4X+4DI=MR)S zK?PDc3&*dbFkeU74@J;>hdgaRx&f%zb;Gr zDi>F03HPPR&N)89Iua;SnBMH&=3NvOL!NJ$ky7&5irk|YiBZS-lu`wA*!4O#+Vc0cn^b$ zRyRG`Bq#g4>v&&r0YDh8LhrN1H+k9x^Vu-7}f`fzub8i;Cf+XvW4-v@O| zhBHkcgB49brk$5=H_hPPO(9x*9TnYKtdju!SnhMSzhc2AmvVy*CNtXt6EVh`BNjj! z8srb&tFBux+&Cp)!3hI1zELAM)E)Y?k`&z&(6f=Fop+Bn;k3G{Zl1^gxk{JsdW-guXWuE}WGiRf z-Yq+t9kK5+Az34Q_f}uO{xF%1P*Q*R4?rrJ-QRTbbhQfgN*l};_SPA4%O@5_j#qt5 zPu9;TS5fU(WKDojbO@Pq_djgzk>342Ts#kR#9Oh4mYC^P-#;Kg>g2HiVH?QtL-@bQ z7%A?DE1I5H-8TMKrt#=gLG)esub<9K3fI}$7S~~Ht8?=POMa%zxj@Sd|M3{b;1kOH zd@dUi<5S`lVEr*FPV;+4A`~liTrxx(K>zR@8_BG34di;3ktFqNd^+qyA?+J z3#n^(xj;fhF5GUZp(tb>kJl-yP4rzBa$v zp3AcyS>%(7d7kzRqamRPq2%N$Ab_iBMYqm~x!MpM`(W1a`t6<90j*W=hT}}=;V`vp zW7O9C#HM8ZI}<0%n`Ys&E+p95vFc;fs6#F_!Ifvx(agz@#Q0cJ$HHrtXrLXB$S1xK-yKakHAPmP)6EAR&W#>*v5uVx z2T9~_S_7TPL3A!z;E_YJfygb_fOA{pWbj@*53L=e)M{&KX)$k@=YbtBM$A10dNW*H z%$wdQpfd67H+)5P#uzRe1@;*MBMA z-upq9Gci3K#h))FrOA(Kn#uoy46G@#^zpehJ3HGeWO{!5 zb!_Y*?|1FPf%eqbdifkJQ5g-sx!5lx8+46YS5`Q=JAVvlv4sGp%-&b3Ns%o!GjF)LQ9?5RN4^IIoAQ!; zF4iGYFdXVy?6Izha`stDv~IgLE6*-#%=8`#+V1>oyr+J@5cYg1-yCSg`n{QtO_$nE2YQS#Bq6megOZ`4 zk+w-<{ugJJYz+>2Zr4|~JuDbs=I^cJAm_0)&OV)wZ_Y@-ABHo8ld$0cjmAW4yi$Yj z(l}whYaUhg#hTp3<{}NeZzUUtUx{>K*O;ew$w{Bdf57Ox^d`;R2=KiIM1CNP^`=@0 zn^sGlP4^#>*q=g>t^kU$w_h8c+=;I`11}L$c2oi=4|)C5#(}PO>&p(ER7ZG4>CbGR*039&d&FZ^9Z* z28$=i>F-W#fJ=-F43zS8U(H~7W3EWGx0Y}bB5oq(daskX7m|xvqRRZl)qBq;pH#@_ zT{{44u$&?GJ{azPz&7{EmmTTAchuqHwS9-YSH+d~p~^5;^wkWpld1L%ZKpG3iQUu|x&r^gR30Knm4 zpdUAJ>Cz=UtQ0%%X26uOS@+Cm3cGRl9I(~of$4`{RpOVWmE5$@p0sVZ6N0Z-!YEg^ zKhey+E#ku72Wi3exvyln7IyB(PwdwbX9@x0-AFRSbGyLn*JSX^AgnueL8KA~CN`o} zw>HN_?pE31{;-24^PO>&7R~q}ynOi0EpH;4e|KKr-44)SgjMQ5!}F z^;du@&VvPU=oi;UJJZn>P49>xhlJwno0r$%@X?_`J=_4;^c9|snvTC zf-mfD@WUe5Wr6>j?AN;h8%=%zH4b9{lr(+&Mu1mWe-%+W%PoU9*eHM`k8BwSdTg2~ z-@}O<%3@6x!kS^boN~9 zfCiZgwE#Q!-MlyUK+9cy-ZM6537pqR^CyRZAWv+~CR2RtBeBW{Pv0_lqH zJeRqrea>SUS^ul6tI3B->#WG#W322Ppm1zcm|3Ss;?c2@$S^acynQ4)B7uN1rC=-I zS#K2`J40uT%4&){!AaSK46;yVafUD#(~tC$-!PrntRoqWOH%_TwH8}%=Ah0JYl_EE zt4BqH*_y2|~YU zPPn6ddx-b8n6Jj+FO9tpr}tVy0eu2}|M!!zsU43U)}AG#&%5par~~jRM_cv#_wS6c zs)t?fq8aoHA|ydcoc(!wTiX#hd<_F~_0DjruNOmeXCuN48{a`MuGR!QtwCCMovx^r z(?*ovL~o`y9b*f;k6fI`f01`cWBu6cynfjb?`xy=u|Pfp#`VaMQ~!Qie-xJ%UVvA9 zU})%rjq3eV>J=Z_)6FXxwnmmuo~%#3#P~Q65`Oc>cwQmHELH zu>8RLTCc<YkcP}HE$SXDcNUxHr&KKIdTEh7Mzfrq z6dPr?4l;M;*DnvI?_bG}BiWUGorH{k8^Pg;>s=ten9p zk@JUrAfh>!YV*tG^o!-oAQcf{-$Imw;cP1Wq7!v_UVd5RUeNTzH9r<5!Yql2s3dZ5 zaj^(Eb0b`75=qEhK4{Op0 zmwiDuZeU%ml`~oY*zW^zjDeZLS=mudsuM!_!8M15!dB?Kx5`}I`PtcGT!&Q*P|2&Y zhS98Gl+@LQ3=Y0p4P$Twsww$l-`w5W_PmwuwE8od>k2@t$bZ*#(`)#Wx$$O92#}Df zw`(+wm)%M*sxX?!e6=6HE+-w^G1VT^{KdfP@~lV*8I0kE468*QyX+eWQGNXSi1a;H zqEcr{po&9br#j=}rg4pS;gzUi&HN-KHtf_MC@43)e%P2+=TP$2ix*Rg67!SBal$0i zUcK%qn>bo42En8DRMjR_r3UsknT|=Uyk>QPmo-2$ipsj@Q3VcPGScp6`RxLmhd`c< z31kxiWw9XChT1`4yLD!_rq`H}pFY9L6FV=^VXb}NRq-#VU=z9`PP|}|>r;Web;2Es)D7=ajsjm7didwa)8A;ZOJ>X!bHI$c50QpBs+n$h9Pg7CI+;}& zv^~D*;|tzynZ~bfe%ci4h|Axt9oHfW_vAb0Boq-Fiu#P#F&a&m);V68m!T}o z|D0!iyA7Fo^jaI1Dv|JXpv^p=$F*AKnRF9kg<{<;YM>1}7^Z)d#mD!HOv6r%N84#H zOilWeL%~QM{w4P@J!WH319iye4V*UQx$6Z%(Bn2nDnTu7s+bNd#!WmB5qk5A*W^>g zz2K^$Lt^AHiVW$l$CPmxlUnxO-No>S+k0wcl^ww4m|?Q3fE_f*+Lbs$tHDcT;V&KFZbB<;%X`=gS-zRxA>U zti~236?}|4*Smv98bu@Y17OCNbR;VYy98cjXFfveikVt+GU@Ko^`Y+mRe(zYTP#oK z=ONuj3^KXcA!7;YFn1?JjOkX>9fuGl%avfDlSN;KdfcsaWk0p-+u$)U%f1&jEiJ80 zRkD-Jb^h<&^y`FhHxyoG_A_dnAT3V$#&6e2(ybQ#w=7F~rO)7WS2_hHwRY_nfmjJh?ri+==zNTvXNLw!Gop z+0Iv;^ZYV0xXn%%GGSL%QZ?|X`MTjlCzGKyx2WWOcY%#jrC))H&v$wIazs+^vaP_y1Q}sSnA>(Qw?gK#9ynC z#E_x=?O=f|jYa7vca)HNj~Ato*9LU|hG*ib>0sYuh+Rd}e)-6+ZtPFJ}HsVdCT$6E{c9_PSzvn?x)Q`%vH>wS+^kjd6JI! zKGW7{xGa?*&=?PCmOb+%05iSFJfziG9O&>eIQN!@4+uRh)a$husf(RzsVNr{C@`Qe z;5paG`ZoXl+iFg1dg#%!{$-(^V=0>F*|m!pm)yENw*vOmju)GY1-6Qh7r847P23uF zltS$qc607`q6kl`#?~9^O?Zoem%i@d)u>!ITza*JBz8)c=2^f0pj0eqdD(WuWP^+O zoO}OCMcDp6!nM{k6hUQwI67*0sM2-;I_&(+dVk-oF&xR5fx2|U+}VJ0=8MOu06Tia z*XWVd-!&cb4$1v&6U&u99bq!CKA33iS#{emj0ZLbfOj<~G)T*fJmpRh2fIYrZ;XzJ zwR#EPYNX#szXKYm#>$Lzui{2@x@b5X1L>w&3348>(sY7{;=+h%wMa}$yO{UhsAl`| z@I@^CQi{}Guj1vxK>EdZhD~T9P{T7T6Ei357VfBnEdCcyXB`&R7jJzUq?K+E=?>{e z0Vz?sOG3Jb?vxUdZjq7(>FyeOXoi#;U}%Tt9)I_}@AC}*Gw1BH&;G9US!)!52gzU@ zQ#9Yr5%pK&*{(7hPOQiiR*=`_Wc4TLZffIG5tgZL}K#S^1S;Aww2KX<; zN6TPG;q?=JfT7s+J7HXscO0K{EJ*j()8iTupQpttMdvvr;}4&x--&vg&E!m>su~B- z6WGU1R2rDs31@(*B&p&@UQiV(LgcfK`PgA`Lm3$o6BCn{i0^U6gwo0ZP?39Ue={ci zch8PI zQIR@Nuqh^V-3~|E;aiTKxK;{TNR!+{O-)_djOZ3m%IckljVo)>zLy%XBjl(Lp;p+c zl}9S~H(Jo3cTH@nEZ-taXN{W!XA0;~Yf!=3v6m}+)#vxh)_iRriYMv1v*8N^P!}V$ zL=o@`=NI#xOR>eJ>Hg0wy5Ez2(klBsZ}|nW7U=^lmO{lu-+B*iH>Lt$IQ+n#0x%Jq z2}y`iqpJ^pBM7&gHra|`$nIx8=XbHOuDzUHF0tuFIIZgg?b^Op_MN)kF7J#NFA5<` zW5yM+w(++)XnYRBgAl9I`iYodv)vPK-xqx}Gdwp)-I09XVxHw|WFF`H9r7-}M9a}+4 z$%{i_uZf{qLA?6<`ZdK)UEdUKuCTWWeTEL~8VGI^jpclxF7fMx(#pZX?~%%>dSO*@P~w5;EZnBq?b z3{$@`{8LzhS$`QmYTGPhW5M%(~aM2x&%yeg_c=!`Pu!YEq<*dCfU1^NRA)CO7 zYR46T^uZ?JBbKlm|Hl+6r{>KG0G_&)k$dP)Cq0aIJs~F7h-ocPdi@<7a1|4% zcceNyjoy`J6~}xm`%}e4_j8*yG3(b`D?Y>2_)q+7stH643v|16cgE1N4X%SgIEc^m zLo_idJdmvVVM3NynpVhy_R(j53zLsC=(&QQrK+T!u&a^og6FH`cRxR}5&r0@Lt-lNx?mM{w&qJo0~ zx9f#tFTdZ@wyXZf4GV#km>T%6rU3Evktgs#<$b%P#Nb-Q&1PQ|pVXQq8gd#PtWoVl znHKQun(6lx>4)ttiMzKrG&(XSZ-Npm=~8;kxM3-ke9{3mYS$9iGNL*A0bfHpC;}{u zSmLCAzv1TSss+nNif!m6$Go9ls&K!?E`k`NkTw2{KS(|-rcBn=hg(Qe#bYQJz4$hQ z227bhpU&lJ=!bXeqKAk|wb*A_GXyd*z5g~;PB+zqQv**Fth75^e)ZrRq*{#o-y4UL|fkcH1yc(L-oS6 zZH?Df+V9$l^wq}A?zBA>G}!|sp{$;xBY+)4(_Q1(4rJ-S0bb0zaiDIT$km6cKv1YT z(m%`89svyWbQqKYbYmeXw_ya21AcS?m(xU>R701}vF75o=t$p2Ug6V8N$`R*j$T0= zvn(7P$HmcJt+K-jE(33BMIs9dHOK+6i#N2!ynZzRfN88siMBX>%605*8!}f@`vRjz7sl7`FkHW#?;1o-LPfnyW_b^N zh@+_*18>f9u!rQx%&BFK@jNj$4JsoIDt~1^F?iMJ z-I^)BzvoJQwhH!@1CDUS);85{;-$KzubPn&6{?Vw1o_&3g;ufQf@%`vN@kyrq9UDn zudc*JM7-5t3FTgC{7^mzxKk||r*(HwXH0FDNon3lI=Qp$v4fJ55M}z^WE&!ukI?sNpYfInRmjua8;R|2qK#PwRrZE(R<%7Kb%O zSsv9>E_*#pE~jZ~$x|pRU^C~$fA3h5ZeHqZ0Kw(|7ryg8M8Vb4>7@M0fg2)T1tR>n z&Bn*$31)ek$06L1pu8S`F3=YmXsOG!;@{t0VfAM3?Cd|IbJtx*3{~!UebnFXDc16Q zLv3rQLl&D$?&` z`mw=62dBda9_gicS$_?z*xMT$vTU=xw(oO0u!WE*K|pC{pnVU>e13PRM`Wd_>WV>@ zmNX3p@on!TCXB0>j-6DncdQ-94pFfHUtT2ezIh=MlMH5H_G8t$Kng%<#-z`Pq-&iM zji603(*GPvK%v3x`XwdlSR*z$Y5Kx>}oCHLj1Wl6tEg&;# z?GD)dYl`_~rG5uCS6E@9R40FdbHa{}4^lhz_XDI*>-rGjB%o8ile<}2x2Sbe;7~b| zLpYydeh@1sC zm&|%q>*Laa*>NoEWdKwa*z3Z~_a$drirg=V)4a+GXu^Ns!cLi-%{^VZ5B5Rx9l}{^ zkV8Ds>IxinriR}Uua$kw_tVd4fHr)2DJ)$~i%T{(aj2;VA^OPh+l{e9H23F`GwYdI9zXRso>lqT~8U4J+|00hAd`!I&EInQ*VgeAOm0X~4you6;M zYPQQq?Ma-=ml4LL0e~}rtq7PcJ$J7r#87GgEYqQ&;l8bCIrB_o$f5Rc11|HOFukBh zRK`>_=rb4%NC1A7<=jcJez%5@>w9~G9%TCa6mw)UBw?}Eg8rl78UKDxyee9MU1xS=HrX3Cny)8tTducM*a$8RG!-IS$6*PGZ;848KBJeM2bVr2nHjgo7^j{r-I$_w>|~V`i{@!!L1=Ot=;K6tZ>0s7@s1 zM7YTIpBsPk{OezLc6z1aBvRdwTj1?1re44Frcy_~4H|hb6%$O{@hmW#{`*`|U{Ao- z4R5iqLyQq~a?hNuX*|H*x3TXS)hd1Edow5b;%Y4B8bBPwzx#fPu5%~!fA8IqsQ^e^ z06_9}+!{d);Tr2*Ud|Nm|ZXAU?!30N?ENRH4mP}7A^Y3>{V zc`B~|ZESilycs#NTGEvXI_>H5KCw)c^!lMwt^$0o={kpOsfR*TJa=WsifZTP`rEMM zd7S+%MK?s?bci3=NSlDK%Arh{(i0G)(u<$zLo8v+#L73P3+HJj z>U71LMeA%T+-XC#mb&InPWV>}&@f>pNC*cRs9r95feGh(-0&Q6>|oDYhnlt|x z$KNhLlZQ5V+ev3Yee!B2^6h`X3s1-84E4%0^))mLLZ7R-mIA%pMnm2cFSYMuR_4@% zSnhX!QCe9!6N;b5B_z11Wc3SXMTkD}T}r3QBK>Xr5(Y;o6mH73Q$-hY6WQklI?eHZ zNUG`bo{Z=Yl0izK6OS|!ic&5LttXp!Mo2oQWIUgoKOy_2oK-xj5+vL4bMe>=2}zGG za|UVu#zqC}t1@3RStKnCY2fx2V}4%wqaiw#KAKby1o8@>Ci8Fa%Tmk&cw7k;s=ToS zPbe@b0YKZ(`s3dw9!%O{TH*oR(+)Pkw3|F#X?-EbyFVQrEKvAB-`5UxG7kt~{5_6w zJB5foY+hK}WCPCG<2ok@nAWhl)a5`k0P6+>Ks`&!w@W?i{J?5ev^eOWI5^wEJswg> z99v#U2Kk`X&PN3Pt$-;80Mgi>Kg1;qj<~jj%Y>&e?8O>K3}x(k)bJ3w9u6U-Xgh73(VtHBH8 zw9SMUfkru`F#j4l*niO}PZ7f1eui{sF`E%!UJ!J@9pt|?tw@(VIG%yN)D_srUl`D2 z20zj_mY;&@=x=uP_WOkg(|iqn^Rkx9HfnvZuXpvN=W;@^XMJ9Cty;X|Vy2v{|MI7z zKMP(xzBbWAxXp%v$}a{_d0}2rsSt08&0LLv3evr%DsegyAm8K+arxWZLa%cFk>ilj zaPfQBNr-xpa{FX19=a@_I7+#F0o19`KBH!73!~+NF|B7aVwMwPif|;y7z7MW{*U42 z4mU7fVv{PFJa;toNu6LM5pY&IF#{xY( zJWS(CPJHsEAFqj|@AiTo_XuKGN=I}IylD(8NlgMg;ruC1F2Me+X;=8M3`1S%@I;42 zviIH(@B|{{){Z?fw?^*U5YV=&@s8byt9K|L!lSjfraYR4Ecu@-UpstC?bkw#jMOUZ#!vX;ceS>X{fT%w9>=KKH;5O*f}c9sxu- zVE-319M^zKnGKjk;rj6mtH}4a!FMjN8T5=-^vl{0 z#-`YvpZpa6icKj#&UM``%=ljLBCJjyt5id0kzOnyWrccW^BMvsmrGzXIYo9;!qw|2!RdoeY#0*Lk-Md-WkdSCv`! z-*9qhV`GCjy1kT?jC{llI!&tPBgH~?y|+LiQ+L*$Zuxy z3F^XZQ(>hYb&>sbk-HJ>4zr;Ojb6Ag>z^y0gRxv=FgnpUy@QbC5#lccFA)spu6H0b zjINWYGWZ2iDd(8nKLm75!vm((X`?Nw?X+_WQu8R#1SrR|X6KYF*TU+N|6>8HhwPchHm%xwITs(x7m}2VYg!v&WYMuwQewM3?Q0$qhGn0yBhAfrr_8}T6MiN2 z=)Y76Z9TfUd)&%$C0R9`A+j=4wW@kGDX#jncUM-9-LUP1h!@^D>9kEc%qIE;)qvNzps^YHg2!0QoOLbMUVaf3>H4fP zFxm+>kwVwTs#hagW11dSv8T|Mo~h?SEQBWw=~HuogR8Ka?Z&-vRqT*R%&@a*MAn6*TkE z`C*8Nt;ZJpg##ApUMWqn}rk=zQ7kBes_+Q!j1ht*EUFgdt z@ZB;#v6gw1j`r6v(qlZ?4 zD_qo4f?-}I@i-S`e6RUp-bf_e45&;A;teIxq9Pf!drXTO=BzM%1#z4@GD$2ULCT1C ztHX2;&cyIW8%h1Rw=Q0edhNu@%gV5#bJ8a(Z|^4+u6?L!!}ApC1P`sSl~z|*GiInZ z=Qsl4=7P@ly0{B6o{hHkCvKB_IH>(((b{ZctZn^4p!wnNiWeGeoopi0BSqsJ$W+UIAYFP(^K#1t>B>VN$}MC^ z66~9BD`Q1;hBi1vy&#S}uqiLl>~ioja~uO$$AIHRIgZgni#axstK!EX{`t>Pok^_|Df4pqIHS4mi7~TPyj*Q`?kr zXK266HI-Jg6*=bK8VO95LJB^hsOhcH5DP`NC;#}27SW64*3yocK6{e6PPg-p3eikp zi5fvTt^i;^Ho&Yq7-kdEx8BWN?IUuYBVu<`YAioEg1Awf-+qv8RiIASbW#wpv5HjA zb3G5-8sEVD7n4yhGFuUv7oPtxOqTzd@>|R+hZPhCG$46WSQj$AMGiR2ZL^V%OZ(}? zvHC5X+#)EXq9_O}!<@?)oZm$%lsc-Hyq0Pw239#7cB?viUOS}8eO8SQ&o>1ZW*z4*;Qg3^EUn&=U*br1@=7>4+qO_0fh+WBN{}Oy&sj<2hFH>@YvpKU69rj0Yo3lqk?vA+m^$hc>Z~ z*MhtMIHbU--(pHcgZ-%!h?)fd3?yWNUwDBurUeNXa!NTX_vFy-J-6EDlwEDl3Hc9j zSsVDenuCF`3UiJuIJ)3tIRKJV=Ssx^Te3mNE~jx}w}NM%v}0n(YdyxISy`6W?et<| z2=pvIPd;Cnk-{t_GWGz&icnEa3|^K-S-=~6{lB>A{2O?Igw&K7-Iw6Y-0;@V zncg=$X`+cKMt|ucfZ)~b>xjDUx8v7b<1&rj+`++%nT;A5xT705K!dYR3q%Hf?l}?I zAM%z0f&Lay=S7a+;8mxM5xm3rnEkAhZ>-Ms?@@+hhgrufq0H{Xz=wGH%tm|O5}}CP zIN7XdWX0{8VysqIYzyRgJ5-FNM~@g)<}iy|)|Ts4(-$>9x;oNLt@qO@+jV#2)f3{@aTgFSy^&FLvwj6*6@ zqt&hgEd%lAhF5(CCi6zep1RN*q+n8a{2wl*Ri&nhz;cO{PmcPkT>RaPUybOH#6~)3 z@>jS3L)q+W^GuqdmyKMdxg;CS2=@bOhuGGunxB6Qop3aq+ZOWMj4n%&WVn;x3S~rC zd7A5!wi=J!jWcsB*O-5{SUKO=e!EZn4$JLEZ3_4Z{3xt&VR$1g1{xKqnRaZjNUqRGGt3VJ$uk_*n4x8#_@~TkIr-?69T$tyC99%(SAq7I zN@!lAVSexw_X!H{fTW=&nezx_;e*9uri9JU1Vx!IS z#sN99xGd|`Kn+`-+5f> z{Lok_Wa4|}M?M+9eF`@3x4?*W{d;$R{}!YkLvW^05~9!)QKv84pn0_+dBpn1u2HpV4?;!Ee7pC{tF71A>_{`Rwwp`N}z zM!4&24hbWfq8GFDZ(hXXY4agi75|bj!rW$xTUb_yGkr`=Z;sm{^GO+aG7Ageg5FUk z_n1xehA%-SXRd=i0|oy>Igm9Zn~r<36Z^dIEa^OzLjZ{igxM3Qq5BMvO;;=hzhPfn zqeKXOy5IjN>4)HvlXgKvU}Wc-^o0oGQBLO{h;1o=tzPU+yb@Ba$EmmfVXtp86c#Kt z)@>9sw57x{Tf>QQA*E3gn02jzSV4CYm*7J!(^B?f?#Q2OEa-9VxI4*ts)3rX9iV z{ApkI$oV-x5TO_GcBc6UhP77t*#J2;D@QhIOsRI0YSV`+Ap6dU07%>FV{ayqMkM9` zjt2iFe!5bAe@D5vxLA$4IhTN%^;mJ>)UEd zR+uP`rPHMB>It+eVs6grMD=e@xM&f6di&CTzR}Gh9nZn%oQoIOo)Jscp`yuJ{OHP# z9`e^L@-$AObCgU3!2*=W#yEUsn(TJ^HD<`hfCxu*;DOOv9P;sBY0#2g?~7Elx(`mN zF@@4O${fp8!VuA}&~wQGh`xX`d6*>87Jkh2+ik9(-pq*@6{Pt6iS<`SP6U0mtEhn} zO_`*}TbK9cN<1YleXke#q7N1wODB22+r6U_z;9$VsH1Cv%<)#Dd_X5X)Gl6^{>S#F z96f%AK;_NK+Ef8H?3cZlv#aY_kfhJ~pP`fH?SulTi*;#8APiC#wQ@XPJf_4}Q&(3Z zvhKfEkefXL*H4$9v3g~hFMzSn@I{X$vgnHc%PSxks-XPdg-QUclE&6gdyyWFFsS@; zb%l3LCq)srQV(8I6r}~F7V4)KL1fvWq!24_M5yS-ktFokfEO1R!xQH5<_%fHsPVC3 zVSy`HkcTtBW<-4#cK*t>D9@N8Y@M&{`9vFV;jXr+9LP3kJSM)_{y-;)oNXxt8D()<;e1a<$00 zyFfa%FBpZgn@?C3Q-xf}_x%{-YoVV0QuiANVuKX9Cc%D7S6poObvd23^`%{2V<({o zqQMMJ@eON`S+2~>q~On9vSlRED$xSgsY){Xh*uhKf)n}Ac#{&DC+!sTAhX(g`jG-TGTS-wo=!s!MHY9fexaRo5R{FM$ zhDuD|_R&4DvB!Q7EJX6Ok>MbDGK-U7`yk2mIfw+InozD`lNP|=tJUx|dE<}Sb2L9@ z9-5O6T7|W$IabV#+S<`%uQW$9JBm7I>~Jn!6iE8>PVTs0$AH#igS?LpOSOLmY>#b$ zK6zol+7ELY>SvP}0}4#oQ=Fb|ftaoRzvoj?$T*3EUjCVf^1<-GMh(NP_j~u^((BIl z3pru8%LJ*e4mhbdwywkinzM_g+W(4f+8aaN90O$ZOij`?v3cNS% zBLgl&NcuOtrK{CiP2*QPN)yMzRSCqHkQr&r}^sU=zrN)!WD=pNEMuvb9Y-3HZ z{TH+vK@|kkSv`%+LPmNYU|p^luelJqCR%z|1^Ua05p}z~yd1@C+aJAc>WxAyH7mYKY`;u0=p)$6}ZDcg-uJJVD+IxCx`>2+Ts#VRi z!Ds~4CtXk+w8~i%60pU~@Lo0^2VR%iV2VYBTn7K^#uyY!08{^kUxkVlO`J16WyXJv z6_#_(g5P~wyJLCIo zfwqgZb<;2?E5x@0`X*xjgFvRebgY_w|+_WX#-RGdJ#y!Jhc}o8!J$V z{Xd<3Mun#%$Cv;>7FSp1s=gh|cXVnj&7_Nd*0i12qB&tS9NyI!-sN+*rGz?>70s}Z z7V)c_de6;u-SO_7gnYE+!&B=B!{7=@SYEUhx7)i@`Rh8-qIe(cTYf6Q=Xq~#t}bZ}55t3&V$xND3? zlpv8Qt1!Bdfp+_8ADQcRE!Ec%YoyDlTZ2Me4wV`wT@956nb$)R_#(U|#`dh{xnp}S zhmuX(#ZBvxhHI{vGdFPyLT`K%_PRtD4kNHql9HYijEdu3d9~s7@fuBLUN~r_iUu9; z7XlFE$-jysDNmrpP^z)$i!t-RyYO&18+1hdY73F&C!5m+UH^9zWOFiwMyo66gB(1} z(luj$Xt7zk&FIJPdECc5RnnumGDaShQGoBCfM(kCS3|~o5Aon%uwPQ;C4RT*6rX=4 zG3g`BM@k(0gP*5b(U7JehD6wq@eW;_OV~SIr1$-GG}T7N9cB>3fwHf|5EDg&gxVDsuXbAtJKqL zjf>yG%a(9QNzw7t?anSn_aTr?uzX&=!AKn+j}A_pcsX~Tv?T>huGr|c4))oUB99a< zTMFX$$i3Noj2p`DQ zg>p7ohpj04psweizkese^yc^-%8rFh&G~)mFZw=ZWvcOv#BBvG7{Vi8WYBXq%i^*R zvnOJ@QYa6xXt0&c!J>|N7V{f|4J0&8ey@%zJ6oSBZfm?X9~gbtc_n->n7|?frR)>A z(Q(H?2^Vp@wK`fCNPM^($p0$WK@0hSb7-3oq1Vmc9`G4CM+a-|1+OmBx+8C%IB%lg zNsvHQV4r96-Q&WL)VhfK*-pLjU6HlFzuf%Jafok&!N72|-iwURbHd5_$ksZ`IG{St z{PX7nBBV#2sbsK?)CEhI_x0)X^Kl=)(%G?whB6T`Z7R5=?JW9_}Z;}F7D>{n7RU< z(sDp2=sUXv0qm7LOFKKvQJ51cvO?_N0i>Zw;fK8Ep$FYK0sZzbf@vmqqtgQ};mr(8k5bG3F>UV4*^&UVmq|`u@x6n=4g2HzcK>2Kn_f z?wQvQsM?9MhT5wM_{=_`IU%hd>Qy{BN7^XFV~9NI$QHOQ3$?oKtJ|LA&C8{4v*K%i zpmgk>yumVLxYxlb2yJ|X8uP9P?X$OE_`!!fom-#luDdy^O2Qn}X{45Pn`2^J`P1nn zASti_Tiao~C)aPH9oBILdYrVrTQMww=atR@hgBK$P4=mQJK1|r16|iWMf*~FNXHGf zh1$hS4qJalh-k=A4_=Z5$Uf{Mpb=$J_+EJKe9Jr6#cl9D7adhFFHOvc9>bcnmyriQ z!n@pB;$m%hHm=KAYT8>lnFWqf(%qkZZT9Z94%ULoGpiPAJDIUo{{7LI_x6a$jsC~c za>Oy_ZWRUXgt>@t-0#&ICM@~#hbpbs7ob8d6^Pn~$^XI(bq~ru${B)?pOE6=` z3mX{3M#07N)tZuRaq!SfltyGzRa(72{iCRR&slE7)*H~aUis;MOsnnfFcr4(dT?`! zMAJnKGH!+|O7B_P1`;pbeE78MX2wQf&M|e`z|h%d7Pvy?G;~PoE8x_6BBV;UudcE~ zIp?k|GtCFUI_CSFMfiqrAqj!=(VP!Dxb&`jjA7dzumv2 zxlu!P=oBp4thd8C?55>SV=nflLq{ROs^^elCbuI7<+bZK^L1Vpj!MtjX)Si`I_+{U zNrj?6N=`TJha7do0e8|+9!G>vssIXAm?%$a#i)y>8Hb8pz*HZm5TC{&S1rW4eKVwN6XK+ zrmrK9LiljUJy!*R*Gi1Anq-kK#P!u0jpWNV)_N|8$E&zK0k=fgI$@?Qn?%N9@vOJjiMJ%crBR9 zsU7(Q!(|t&pDpG4f<>KHu|cPv8E(v$9&7qd2r1W!HR|;#v7#P_Wj|Hqg2icbl-7}j z5OMFwOIJ>CjF!{T?2<-G4L%8(#IxO3M|HDu9_PP!dgXc1FLE#&n(z#M2#DhmEDYR7)YKh9S7u!|`}Gv%e` zw>Fe^*mM%-fV^i#+~%@<)j$F8*S6SXX61vGx}|w)#zQi;p2`yR_b4k z%@^=-qzw8nhTO;@$)8skd?RMljbV{3#m{02V>j$rcs<~otgKTQjY|+iDh0tFl_*;REYq7mQx-;@pGNwl;kSc0z|Ng_I;$7C z!kZ1wtt7K|2#Yp6RF{g$_wzvQix~!Jh2RR9g0+;7zO%k^MRp~F!TVbPToK?;rBPiL zbjIw^TO9ijI+Zh#3*{bwbTFmJ1ubYT9nhWj*v`+MgiuSlx8kr%SpL2%6I5C zFLG6TzlVkR87U*+8&O2%`vMv{RgZt3^X3tJJHuen5JtsH4w?{^$YYR98tBK$6D4_pw~`2;!JZ`NDsUj=@%_`~`=E_w zPgKt{u8VJ#uc@13qHc$Wu>kpqQ#`0aIQ`=5m~r(l@{#yb$mK%|%**g<4gZvVo&W10 zLH8S}#Fdi{BG9TI3#>s*z1O(bs%_oJn zg!leqj=w2iz;vvFsd=aFkvX>+#3e)T9R-HhCBl-zh_JFk@ZiSS7xq;h7z^uH2CH{# z!rQ;72nMB3@RdBV`%Hr#t~Bz>DZHJfAwbsA$YC&QuP0Q@{g#jn z*0w3o$bo$cgu~tkp55%3rboLUq5O%zD3DCG zG*c9d2`yPt%!x-!6E?JY=tdyF(K?^skQo9BgRNaxXqvVf#hv@)*DtV4M165f@bmgF zCMBb`tX*}xjf@Z7u^t^EI4_MN7^V4=MDG!ud4$j9;>f(hG@KxxrDci4V?y2>AVTkc(^u-Sn`HOELmJ(5H?pj zUCQ0mtltQcc@8R>VLnoz>1z)#ZC}o?5{QP* z5}*WHUn6lMFfD+JLIZ#rp6+{ld+C6cYMeB=SVcZ1eKYbtaH~HidHaW1G8Kp#LPpB1 zBD{~F+VyR70|Q-b)E^o+lGX6cFD}It2vj}rfGf;d!MQorBmcuP&9UcJJD4T8HXO}a z<#<#|$E{>a2<;_&c`nntDQI2duQWeFuz7$ZO?CSze}crt3m_sB%KKf#(d2VFhadOP zrtwU@S#jxaLtj@<(RlF^qZno~7Hd=jWe$9p2he?sJJzIY8Lx$5bSL}4sbBLW3 zWxSZ3lZoxF)qtg$QZ2CvByeZ-yqKML`<(`2YAd96&nwqQm3ajSu*fhwWe?g*U;BPS z{PB7XE{Ls;^VTq4Xd)qajKq-2?eFP9=SL~;Q#+tmofuo$8x<%i z+Hs=*YI$6kE<{Sp8+Iuyfp~>qBCX`@bW2MM-O1r#lWi5&zoiT)>SY9_hbH-*zki2Y z*S}i@RK3oV&F&D?n6o=D=E}y#U0akWfjnmg*C;+TbqbkDe&uAi5_I_H1&B;G_)xb+ zfq5;4BLj_-ik}eZZtBfi_n})mue#Hy)N=i^#OS?Cm)FlRWCE0nwVd;^{2i}}DT-$T z|FJnD$xmODdYv{_uw*xg(qWTc?rz_QZLqdA%WUBKoivKuY|{sq8W)-1D8@kjS4IJ@ zxAI`vl!MC;x-?|63yK#hEBxZF^t#0ZVbRzrl(mK_yyN*y%$9GJW#mX?MiHBQ)@pKF z*g8YlfV$L`i*gtqme)LrG9sj2Bx&%nR{0r1lo@aFGUk{>E# z?4Vaix!w4nk(ZJ2RxHPfDyX&FH&j#v$p2`RediOCz&^X7&$Lj zy@oK1aleUn(~iG(oFxFKJlhE$j@CNprY6kS-YL`R{8+AwZfEWP=|>vP+WVVR1F7cv zsP=bsSkGVX6jgfvuv_wO`syBz{1EyI+mjoWZyi;FIq!A7KanahzQ*3#9#awgCe%Y! zLBeV$ESrk`&X$bZ^zmihZ&w$6=R%E1>&O}#hZjX3(Ib?Rx0_T?#M1r1eRxf)!Q$)Q z!cGBw$HVcLjqxYyzo6RU8V_IEr+B6PE>%}_Io|CKQkimW?NI~13Xq6x_BeQPRx6-U zt@Ufzy513T{DasCNQ#ZGP8TXli;0W3ZGXH?K!v7Els!k!ruG6FRLxg?mljP*WA%^y zEN1E-8s=e2QH92RMlIDOLcBtp!aHA2EQb|8Pa`VhhMi}s@79dQ4$-C*+@hFTR%Tkg zexGl2+G9R*-;)GwP58l4P+c~`J`#^NU42P=2^%v$wfYkYec8=CRa_QclNCjQi2{Zp zqImMiKRbmJE2DAEG*mQ3t=Qgmv967|P9@+Vk&X<$a-DX2Ca|_l^Kb< zs5K}e0>i8437tk-OqU9H{Ox)7lAQ_$@%|*LKDX)i`;U8UNR2WVzs6RhA6OtJb`qgU zPM7BHLV&l~NYG)W+wIRP8BPUnehz9s;9m8bJWld!`Nr&&M4^2(jJ zBr#pi_FFn<(latbmNV34AG$-zf5LLGJ%DMzt|8QjyL`b1)2N23boTusP^bY<(KWe& z0^r@rNjc%Ipg8s=&}A_u9CR}lbfM&DdZuA&WCUZ6mz58&vr{f#PM#&&Tk;?+xjmic{Q+aSoZ4N>OQNvqi8O!g7 zLKITI`hws-wEoh&fNQZl1@6!Jsv@3043dXCN@Y@ooMa@7q(JQBF-GUGLwS`PgyDxs z@YP&Sr#GoO=o@~W4G=!0>s7^Au$9Ky%DS_Lu&=w_22odP8@7B}MNYF12I&5BqA%Mu zGQj=rv{iU5OdQ@q)Ux>pc|LVq=m1(7E^z-KqPb0K{{M|P{c2Y?%?XXK?Nv!4MM z{T=?)mzD<&p0qK5C1CvJl`O>=_U`cF!$fUe-FX1;`x}=-fK;4IWB9^LG32oqhsS>u ztmk0k00i%t92_b@ITQK$xnov*0<$++>Lgv0{y&A0rB;AhYq<7z=L-^_OCH7r@LAuH zls=i<7s#v;#YdtYDHv3AvHPOI%F+6jnxG*2i%_-l(3zQNDR@RUdvMI&L zVg{H_BCkU~s8LEDtM^dv)=5Ip!6)|_IblA7@3&hI2{!+>opg^kLBDC`x2^Hs;3jJy zfsNcz5xOS+EqlM=&D;3TR2$f{LTc!F+rfg>)w6E06)%ERT!l4DqaiFDP{azi_dI`g)g1(>dY zj6uE@o4La$EhQ+s`kvA2TyGHSC*5<4KdZM)xnjzfu%LdZTfA?qj_sBC8|9fJ z!!OWg$ybI0LI}+4!fU6v=Lo1I$Ph@22J;~JO+eVo1*4Y{xt7z>(fke>sDs|}1 zzX{Bm&I@$dSpHVp}L?mPN;1yyIdXJ$oisE!0UNfAVNo zz5X_w+A#&go?&4*Bipr%u>ZLV+FYcuX~m(d2LCV*uo`K@iOf1t>yX9x;j@1JARLIO z5fPiXIx#S?N%Dakk0)YK`H=0>GT}8}N?D7rh)6IG?}AV2rqfX zX_!qzg&Y#)3k}?#2JFduL{0sq5&7&;8;LgkJ;ecp?Wf zE4|bh7j$+&IL?De2!3rAhNbtje>rFOz;WMs7xC;rO26ael<$JY>|y|Q>lIV3mXSmx3idO87Hx&$jqLyJG&9}o&#KAJ&Kki-Y9@y$-n#0+9HDe#x5V}mhGZP;s zTkUd~l^Dsbp=&hy**^{WA>c#I)Hg-FXu10%Iaukc{bRuV?`n;tice$3-6t7j}L!VWM@toz}PR{eRVPkCP_bcBM z-YuYn@bDa2Zf^RH`?L`p-Nav^fF5^;)z@mD?hq$a_3tbKts7i2s?GpW!UEp$;6E>x z8$io74^sBSG%QS0%M7rxu_*F)IV8@27`R`G)83qj%?Zwb2#g;5T263crZytXl7esU z@~)CGuGoCTQI~Udwwc z;Y?eQ!A86rqwniWw`6Ei<;6l)lIuw77*n8m%`>b{qC((>5IM=u3Xm_9S<7P7>NBt=D<KLF{zXeg@ zxNrHW2!~1P*~j;Hq+vV7?-XRd(96bP*wH6;6QOhaOPNc3Bc~f77^UvDJo4kK@bszO zb@L>|@X+n6c~FQBiTF5MV)S->Ax0iDc9;#nPm3B7!9q??PXjsTfbQR;CIdXc3@MpY z&I;SaTtFV%&|87}#>UGq0M$Xe3TADWH*P5cBdW#>=kFw3Fx)(m1$_u*-#q4OCG-61Coh5IFcjr*9U{Rj$C9W7wFHY2 z8(650)U*5Hl*hm)itPtCkRhDI3(HI&_Qi?&8ET*>AA`YMCm<6t$RKaS770PeI>VshXZ)8D#<|{F6;Jb6;1Zen zh&Hk?={@{uulQhj`rr;$$BUUYct^oR&L5pPM-KYcQQ1(>zuc%@;NW4a&h(mX1U>l4aEUOG|%#Es_wA(TPEa3^4MsLKkoS(NOkEP5k zyJ_eKrPwyQ(EgX>3dzGHwf!tp|6l3A=oGGJl3*w_z#;Yuy0w+Fn%B`(uIEBv^No*& zF?G-MB{w5cr&8hzap~S%eKy-%d|vR+`;UUjEK?stQ7nl!ugCMBYMYTuVGGzJvlo45 zh>x|imP52lF6X}=Kq0cR<1);zeC>Z{l?zh7(H&lR^UBjU>6sTOgN$5W>7Bz17P+2X zjdH`B_T9EORwb2;-A#rdvHq%`3U~G@+bktkU=f9^Jf!x#!2C~rR*QPgUb%{p3r&>l zSq8Q^iY#emI4QMV!}PuzzSZT{e>a5(9aks#kRo6JEunkwc%D+kXFi{2Ne&C2E@Yk> z!(O(MW;fCzA`MUue0Hfor#DzfNKas70Tx6le1( zK_L`Mu|sg9Y@r6xFUb7c$=a8{D-&*Qn2hgS zoC0v4wsD?l@l7D3X=XLJ;ebvk6p6Sw7N?cnRben%VUU%f7y|z8aH4SkdlZmmPtkFp z;RB7Iiky|gi2hWUbP4ewu&)Ki#~c|r<#8h8)xfgGAU7-d8R6dk9m6c?naE0nH!n>@ znY`P${AxICwY%#c?I>`hjdd4k)_Th2AbdyoT7JKI;eepmB)!J7=vOPn!rrTjTLM6n zI=>pcSZ$vs{CPlw%v3=Ka!Ew-FWjL&Ht8FFam)xKfQ;rlXa{zga=o+E(;w1~>uI34 zrD|eU@j?N#@BO!b;A6Px$UFoPYEtU_=+E7Oh`#zK-UYP!q@2cdxfyZwZ`QsClO)_y zQ+y285`CDT8zV0A6rP%Q>CUu0?H1dGd(^CqedusbIh0`lW~{$-?IBB}DUl<1WU(v0 zK~%x_C6ax!wNP(mF5R7tn=?CsEKD?R-sQ7^>y89Zk#Hc+W8LV~F%xWFbKm$Gl)e4^ zK|)kolXf_cE@kZfbfNt~Ko1zU@%r3uAjMS+=B>4&Kcr4CDMH_)IhgO=A@fUr#Yk4G z2HUnj!&wfG0><5gwJQJw1uqBPc7%4_^Lxy%iNfy=oDK9_=LDO>9E#8b-*3zt@E7q< zF9}o&Gq&UG7G<2->2Pvx{@Gofcm0nrrC_!|IfK~Qp<^~Uq5>u=BEU6R5yN-nZT!g% zO{%ULdbL}Y{}`QzQ~tkGy`9g$HSZhvpRyXe+T7w*ezYQ5EvZFGGE?8+2|Rx8{NG2X zN;#l^(JirfsoskS9@cE(z3fj8$XJmi5-lP(>y7(DkI-&+8C*5G;n|%ij7mDJ;B#4& zO1OsZ8tsS1PLYsh*F|&R51Kx);+yy!0FU9wj!n11&a<6ePYS5hy$G!Rk5Q)1#2=fI zFKGcTF#N_IS?J$Gdp^|~q@0Sucl_7AwC;6f5cX%NU|J4*KADr{jWt!y`vxIR*g)^! zXL>R)nNb=BOxYhV=SP18HXSC5c_3gU*1uH-XK+=qq$?=R}PZJyuGD8OO+Ll64*9FVi41AJDMzdp!{=Z={EpI8(Bt1rBUn96ir;<=Jl9wu|r@=JQ?J^<|dPo{k;>usKMXLQMjjZ(>=QDKij-^2|hzK@3c5JKJx&* z`QcKq=p<*BH)v(CXVb~0t1CSrQ-@RTF_uI*#IVU(h>RK&`>aT|#zM`3;`Ifoo43cq zlqXx)dEI+01p24;js{6ThvR4mLWzaJvF7@Y{(;=FX-l~EzJ-FzPZFgb3^`HU?@pe)GVJH6| zl5M-?^hBe~uSCPt(6IFZfb9kanm(WHcEXvU4Zf!h$~E!9@v6(ozpP`_D2w@vON6|* zP*Ug8ozLFO23asUu9Q(oy?$H@>xu7VQ`>17^pFcKEcOynYC7-|y3NZmiur9c7^1ZD zzP;?h!2L7zRPxNgNm=k6sZjaM5t8P^dLgM+jZUK4-K!DaOx&;A$=fbfT!PZVO0(`h z8smiJ10}3`-_m|&Z?r+YS`Cx-iz6Z;xWs;3Mhm3CVM5uX%)sYu;zvV>%^RkN(h;q{ z)l4GdG+BZ#pSG4SLrdB@dhX>r_aYOAcN(ud{D0c8hv7_%SezTq_39{-&>d(-Bt5s9cmu{XE+mOx|^Nt$=bE<&BjxE z*;F^gL4ypw^vUnzuN9sV96>4g*%7Z)jXrK`z+<|sC!4uXCiEsF`;Cy&tdg$Acxhy! zH}eqv7m!bia`bYz4WuA@`RBpE18W{~T!I9>T&mRmS*J^z`fxzUrNgW~UgI(40Mpf; zQuGrr+0kf=J!)WE`lz{J?O5)b-(UMYa79GAFW;`Vzg+Ub`(d=2dxylOA>$pwZ z6X^xZ5NvpVgF@G5)8k)Dv@-EZNW}j~+WZ0u_m_}l^?AQ645(_>&!mS#TTpz&W`u$N z*lPW+Up&X^3+VX36#n+=DX@W}GZQ;SJbyjQu7|@Ur~!65Hx$q+~~$zB5kR|G~!ld={>BPUr#2Q6@QcS zp{lP$QvG%o=`APWHa!)uxy=5lHF~($apqY2VT`VZ<#hA-Ds=VpVJBQ=e!oPS{2{Wkz?l++sd>j# zF3bKlP;~;ovS7jNqrmcACB#5ot;qm^81DuWX-1u}b|f#2B|qJ7vtVU!?x_ga{e)IJ^J>UFe5{V^zfkd5I6^7nm;IWKW8fM5&b0dH(% z_@7d5Ex(ws7EUitK3xDSdOzUL`2*i(O-j-WIU{>OR&HxdENM<=;o(t_*Nj1MA+#&T znSbafSgKP+kBRF0`urIn5f7CR2?*e<`CALQOT~ZPE#|i$Z=im#zHF#p%5h7$c|J|V zolYbeR<^QROl~f}Gtl4r`j4--m{F0*GB=@UO^1S@hX;y!DYc-jZpphE7Ut9In1LsZ z8t9{j`gj7x$^NI!Vzjpw=$IZJV;?K#C+zq|WyH7d$cC(l>lyZCGQIE3|9oK7$eo;+ zNDP=)6qT(617$Ig%)ev9jp`vP>6y3=3&uQVCQXLO;%mcB-Xh3^x$5`_?^`9Ct@$DE z4;iuE|2ZTd+OxYDA%kD4b4ifK9m+wnbWmY+NxV$IvATN|qG%o-i!V3WbW<-s;9Z zrt*VwB;2sKHT7BSo~N=DSz7vz;?>q+sCasi?W(U3Og}d}wI*oz+W=d$wy;3We~9e- zbJw{`pCi0__nEZ80WUN5UOQHHhBXT*&;?s?o5}K$0y1_${Hdoe^jR~D9ewl^h2z4Y z{-sp1va)rFItd9Lbhv2Wl(zAm!|@X{@F}wegb1Y+_HjeTyGqEC$;U78&hoDh2^f^U zmpmLbYj;K}c;BQeeW!Nykj<&;#vHhrM!0SKbF&|4=!6_W&{j_mo4~Ar)+z^9rK(fz z%=0Y)g%G?O7+J>G=u6g|9{25`^naA&?E$5=V(Mx;UM;`zze>b)|A2DBW)1eh`6C&6 zcY)sC=s?nK2+@9QFfp8NK8WD+D+Gm93=>V4<0@&0XF@>|9J6_j;7B^ zEzz;h0X*bxnF_rRffs}ab}5^ygb0fO5+o*r94KGno+ag(jR_Cz7@#!2(xA>yCi0Sf z9hmT~upzaY2csaHu5LP)FRn*op3$|RO45Bx?UxJ&rAkY_kT=!SP7kf@gxzkuvKP1| z#nM8av$|X3F{B)>0nV$~N1d0VQ^uZ2c$WblPI>Ng zBN|0AkSp@|q~jFGMmFgq~9GrK~0 zI2m|a-yvpEGs4g~?o%EZ;_C0kU9j=YoIm(-yT9+mL>m?YtVH}4_@)T4*9ImqStGzu zipD)h0zz@M8kjKK)inZ^J8dlZV5ioomkKtBDoY5>{F=&?x;!OVC!b@=e5Vg(q*@%i zSUGB^UF#YMUN0g-3KR&FUcr(L<0$?Oe|a-vJs@L_KjwBjJKewfY!7pZgL2Al*+0o| z9qTA8wfBe{{V=myx|&QVB&2B7Da3ZleR)hhx+cOqvx)2nxmk@y>hKfYGvA2WK0w>M|C|X${3%fuHGR zzs?3|XySMK^@1<}ee=Lki^vFVmz9KEj>xB0l54D?i71jd*g%X*RBHwvI}y9K=H>-w^QXgM^!S6KD3^w%Q=1)Qf=O@sC)(1 zM3m=fJxvnV&eza{Kr)k|m_M*^-vq9NE=aan&CJ2fn;);Gjh7>gM)=hKCVw2@zBW6~ zbcp8($*JSS!34n8sQHlI?TOJ$zo#-JU3kNJYN9Fc4acoShfb9~Q6L|_IXB<8zQ2E? zp0&tN5$EP2`~ZIJaqhNP#a59@)#^U^4h0M_E$#9>!p9$JfHkP4nx>jLHw6)p9Uk@c zhh9sVs(5kA&WPslRNrk&pF8*b7I!%qF;Z1_=O5hRb7TTUNWFb)ly=eo1Jso2gG@<* zY_)nq4z3OY%7EoEX&jbYHEK1Ja6-MeuY&6kpOv}L&~DGhJC8x_uZkR|dImD&itIVg zT8K4#N<2iXAA#DqsswZpKURAT+#Rwa+-gng+pcy&|5+D5tIumDN8$cCNmA3HW{9zq@+hj&^4kFsgOtA z;0s;JfRl}q*pJ*~P2T?voMW4vS!Mzy!^I&0;ck}{36P%~Q}Diy0v!}*qo%Q*0UsU4 zt|wMb-*4i!|^f(Jvm>d#k|Z`59iUvW16d`pikW{J(0l&=}a@7Zf5vhO9?px zxk-P1o57KIJ4nHlp{^Kv_TR(`pIi3wWnc^BPnBUj)P|az2l!u=kh$o@m8(E5lcn9? zF0n<8a!6Y7p-g+*&uAOy2_EJdd;mC=C@ZL_e{YXbC`@5o`&I{>6sHZMJZ5U^Nb5Hi zijZJd6A3L+?^rl2WX=K%I3W3|mur8*ac+ePP=V(qbPjs z>NvVv$p22MCUp?+Hd=K4QIlz-Vic(Dvt>kNS zg~iUTP2LaFzc&k4Ii1*2yZ`-*;-~CrFVwio9sIx?pl5IX@b6TRWJK~N{fS&~)!kB_ zAL3c1wdgX)CM&6Ed7hQ&xFX172Qkm63yUT={gl~}2EL7S(Du|jf!w z5dRcZ;_JMmIGKqXgy^t|tTb_LBxDNIu2`{jlO1>U5UeqF-mnYI_^^(km|0o9fBjs@ zHtD<0l?;VLZ!y^#?_az!6xM(#{7i0}_9mar@6>TP7eY^9=1ufmwhp1E6MK2!p!S=M zj*M41P+G5TfSgl?7M511E4*y_&ggns3(m#$G-LXR0&d>!C-ZA1eJKi6GrAaUw%5hi zsDQOmXc39Nec3YCQeoQlb((sD7P4-qLT%@AdAPEN`(7A;yO_;xSIYpl42nF&?%qKJ za3tkARq?@kZdGj)9p5$Hv{^elI}fuDIFtVi26DY`N*o#}P#jqPJ4UA7X7T?D)SffD z0WPv~UA9j*e(wY12fNmE_0_pB5JEnWKd93gGLTZ%;XmaFK=!dD$#h^N47Bf^-m=?j zdfN#vo_@Ox@2EW}2+rz@9UntZlshk~P?4=#YBkCX_C2!NrQY9s(`(MG z$||_ZeXDuPlM5P00j7#*>L;nRadZ^=Mh`l>O*o=FJh;4X`Es3sVJhJ>Oj#75XSDY^ z9;*G9xOt{!T4S~iRfZFCbv~w1ibxhb>**#o#}Cujs3r?<_*g!Dbs+bk7Grd$?L04r z{pmPuCCQe6(e7N3UQMoS6j;r>>ztrm1qxF63|v@%56}h27AZ*~@7~NL$e7#u2oMKP4s&#rXoT*=Sb+Wfz5$ZK5(fqkSve!0O|Ein6hG-LJbIOQgjfYK7vDqCp3w=s6%r&q%7tG^ z+|vc!zynEwhTy6HecZ{&sbAZBqj+3Uwz#JBSIg(@jcSfSJfC}(+J?waMN9FkggEd; z4o*RLNA@vbtj=g&TG-wT+H56~FTa=0Vk_jSUh53cE=_j4Hdy!lTX%kC`_Y*5KnWOL zY?20@F`^}njC#;rsXq-YOb00ndyFZPI#w+-7|^~SMHjkA*H_;F#wx#7uWa0*<|%?i z_W-q^*aS?Ct*Lof2QSrPt zlyww0h^1bMaz4xZM_q>uxZSo19$CpK@wy3I5#Jl(;EtbC2!=tPw_wp?ob!EajCkS7 zmmSy3w{hySWX2a)0PDROr;)8%TJYj}sz`XC>ew!HX)vicZ;Y)nmIN)v62a3cAw@T# z_aS0HA>-oG~t*u`+7~W-HWSUzD;n>RJ@_R40x5WU7!~2 zz0lbMI}4=*=I%pxByDf){o%k`$%8Swg>e&@PdsYnD1fcRqos^< z(P6h#s^uvw@vxXoQyJ0kml};8)`&#!_b2lAA-(9{_tF?-%($4^KR*AO(g@mo21-5h zW_}~!w*Jmk+PS*L(d==W_Rdf2wmrdFpQnt?yTLLvOP6&uVVe3y#%gBb3m@WF$G<7h z;~jRyMd}bC@-Pm;OngwA|8;8PIP)N2_bnUe+xZh7!@XB@MR3s$xiY9Ndmpfj;l*3a zMuTJyOd$mUXu#{}4s5L~4wV1YLBDi<2PS50uM>7}Gwd9$WsD0I<{}os2Ele|V@1R( zOKI9RVRb*&nfa>!8T)`PdZx$t#0>PjZG{Wo>VrOSd_@7&M0BY{?7wb02on6#M7YUQ zd+iP|POLeI7~8oCI*u|2fvF3pH+zv(f;XyLq@q^1VuZV3nXDk0YpW^k^@SY1oY zXa9ByuJVM~SRmbWpA4uKq@YF)I2U%y+rZ#tWlC^25bdEJ0PM7m)q10Op^wLy zHW@=*FlKCRH=7hxPvIOhIN@;u)RcjC7JOCkA|I^(dMHt!F)5w?S-GFdu93z!=MB3c zr$kvaErjH&d;I9lAbX0_9ev8qp|+!>$dju4YyNA86Y@{4Qs@3%HddY_XLnbdOR|yY zRhgb5*3!ncwS@VB1FnwT6gbFVTH3^Lqg|smQ9%S#;>+M=C6IykNr6|1zat^(rlhdb zshLzs{$TNk%wC0ED2$8jtfBRKM{?5zK zx3MwxgofD_JrZ@oXz7iRnyyMCn*PiEV1FysAs32|IERVc*e)GA&h+-foVw9wjlElZ8b`eFym=|AQ&Yf=*W_K zn6+_VK~(!{P$3)ms5Z@8keXP-u|i#Ey`kXurEn`Vi)x>C8d1RfKKEjUph_Zr1|wtX z^mID%u4Udy$N6gbqTc&%1VF~^!#hn6Pf3yE<0HQ|+MWOL2ne9VuLz%^UMe{{`C4pP zI_)`jrVqa)#{l_`1@_m+a!0sB?=3+cQ|i!5ymPHGwIKG<_ktR_ID@}2PS*+~xVhuM zM{0Z(>JBG#c&C{4Qf{xwc>Y6K zw_aN-q=u0h&**H0r2J*suXHzV_fZsRC=QF|v+c3ti91@U6;c48NvW`6~n*KEL zyi|Kg)r1(*P?craKu+>kMSSidR0T1UL>#zMd;RUBT*Y*p&d=fWcbi#`H7Fq*vMXm| zz;9q~X^93}egPDbFQLBp)K*n(19h=Lkobe4KdZ9CttK=WfOy_N09*n+aa!uo0seq~ zvb1zvi+e4}TPHfC4?p=>Kyng^ZGec|2_Td@GGd=-B;zZ1;Y_?0^p61agfvoJPb&Io zbvedQX7pcLVu=O6tEGa?V~ukROnSSk9VXoTx#1?E8(;ph&5$_$sPqiqkT%~ zG-n=i?j{is_}S3`uI8`F%YYKaa`IFHVVmOd^VU@Hz_h zU~>4AeCQJxhzF>h3T3#Lck4>i28b!qt;e|dRS?K*1T8mcoGc}L zJ1QJR5f{i$y@}hAg;H1n`Q8JCslww*^psU&gcNcCQf$D z_p4&6m?`9rd$L787(Wcex;ib&D&vSq@KfkaLC2F+$iclVE8%p>6!Br=5=lwFRv#Bq4 zM9N(}uFbz-wLs+tk&|~>6`F%*|M*$#U%2jm`{8loSnQ3)GyD#rXQ20|KkN1x6k_@6 zTb=xi%c57~{FnxMCMNwbSWenl6GH{UT^ImmYFF{I=DO4tn^etCI`Ahcm2jjjB)3!y zAWeYWPE&`gj*y`H>yxG`4{Wc=u8k|1cO)|{2jEZ_f|*T;Pn6GQ%1TR<)Lg!6vk6bh z-eHoHxtpVpa_v+6*QUCkV|rT8ALDedb+@rF4)SK%AYf40cOp_;D<8_`ACo$ax}!5W zqlD`mQrmbL%=~o{s9Y024)?$xxyaChF6Gg2yh;tgk=PSBBeS(Z@^YjXZudO>B_fnQU{#2cSzACEiE+ z|Cjui3uv5{Gh@cHL%AR{%ui$|No)B_3W>{w1FqPq97+13I=S0S? zmYKo-GwNg@S7_f9QlaM>5lIVq)_FM?j3Y_?#H#hq#={bg(vfnfzC!>o+D<#txK5T@ zTJj^IbeI>v$~IbNPwbk!Dj)LNje|bP_gTh!Upd_`Iw;nNn)HXz+3o70E6SH>%GK!s z$>pib_<}(E;G`YjgdN}Z&a26Q-<`FW5yQ8mf%q;@Yi5sz`H$4!nU6f*+x}`*Zl)-C z&gkGS5<@K_MkQ)s*8+5=3|-ck^W8euyUuvRo?4!V6#5|8BCgbo)M1` zk4&+B@rV4(!7^)wy4vAn%DRQ@`Rj_95AW;>6XN47tgJ{H4DhnEp95J9dwJ#LwD}>V zT&|svj4+SmR|8X1440#0F(VODZ{)pI>UBt4oPIJBSWx7a#SG5HSGgvB23-`7k>k-( z3V#}09&5~6y|fh@bQDj*Pcvl*SW6n9LFqcKmprX);;bMQ0J&~msr2JBd}>UtDaXn} zL9Hk>9|_A>j5eIE%@G-pEm7vDuc_bVB2)AfIO<%%vj4+1khdDSyY_?dy=EEjN<=2XF9Hft_aF<+DNy{h{DMZ<5%$>5_-)Ub`mt1qcDO3TG}ZRzRhC3C4R z`kGf_5dlF&l$3is9S5m1dtP;vWqRoPUq03@eWTUYw2dvCw0p$#*KWPSJ#T2ZXksI5 zIZ96{02IRQhUIl9f*BU(e&S7!X(T=pT$0#$Dws_zBOn^~zjc1RZ^JJaJaEK-zQwHG z=-CwDeTq3N3Ag^z?>?yXq?r+`|<0iV;6348paz2u^M9k5b_$!xame21wPwV9BwhCDqMbYYxR`BV#h2|2iA2y(X?^Qf4 zzlcbD_)~GcITXD!e;sp(WZu6JL1B^vO9*cs+wg{rH{zc8tUhtxUzPlNRH+&2$KX8^1!TYEyr`MT$z##doYiPXc-9?8? zj^3WMYE(UjW2K}H7(JkC$L2+Yf$CVylE}oTJkJ_X42R6f>@tEY8cU)QI2<&e>f@5lr29YIfT4 z0JPJLqv&N0lIh&rl>;NP3ckkHqcQ-17l(#{Zw5?HJKp_%rqsuqLoHXYcZ9XGMwLEp zI)%*E;MjjBKSUM3^vNc2%nswkC3kp;cytKGas$`3uGK4t2)Hke~_^ir=J?gpteyB>B`}f@lb3#^+ zlGS3s*d_BR@Ab&y&nB;o&b!>et{j+U>{sI_L`(WN`h&~^kkcm-l~!|}Lxm&c5^7>pZt*c)nQvt zD&N3B#Roi&Pi@YRrA+a)5s`GvM)0ENduQDvD5T6sqnk~1I*SG& z2%*aGcaNpt^=dRD&CW>#R6BQ@= zhiUjn0nch{<}0;{^H+$S*{s{CK5)0U=n1?=C_iEd*x1EfsCUtiWR?_{i^vhqYnwhvdOAfizF%IG|`{467$WRYD%{@IyqzMa5YWI53e+B+d zn8qdhx9-j0cIC96{MssOz`q?Iu0GhXlwy8Zy6t@`J@FM}bj@wGF4kcjxpr)Wj&asG z!6iR{MyOfWvGZODUC=HqFe=;;Y@y-c$y>BSLit?OQ*5ZSZSK(MuE?#geTU~E)E@rT z<#&5t!0xO!M)K3HKYzY!k-p!#3-uQe{i4F$ZVBu{vTvC*pWzTS zDMA7RH|Jyu6OU>940FD#O3upuJmTQYwX?FU5 zYjvW*lD7>!iNw zi`S%lp&{_to(qyP6DeMpP{a5@aI3#GF+nINC$~N3wzATs7&d(8EK=zW=_(e{h9`KN z(+k}%;x0r<(q%lo?q_D6Am7H`Bt+z>T>sJ_(5fwQY|xV~GQem;Hz4}XHJ%=Jj)yEP z*UR-LcGjXJpc3KOw(0IYsh#=+9uGRm?6u9Xx;$8p^fbWLKDd-sC2^gp26h!SD|+Yd zf(ke#Ty{iJFElIc4!*y+&w5w3QLyU3?*^cSB3n5&YiyzU;*iVM-G-Yl%H-JmZk%&s zx`}+`rM&ack74oC=vGbja26I8#v6h9MOCU?o6Z=2b6uuDo9Dcwm14=TS#dnu$VoQA zbz3dt9x4!L{!8M`8Ngoej!Tblk1uYPPvB)SPFy^;;j-LVFKx~(_zs(K^4Cuyx1#v? zR6`x9S1dOUwygx^9-rz4^LJ-_N+pYIU}`wM`)hfG0lGgAvFR+EvIk5H$#)4?!xt=UC7RSemqNzz=?;1_V1gl#Ni>M1v15oKo|cBe18>{9bwKX@Q3XP2A|edo-p zxVe#(l!Q;o&@j$u3AEe_Zy~_w_Jk456Td54iQw7J9sfvbLE>B7sNZqtqfi;2d;fhZ zT$T@VkFWpl|29xI|E~9x zzDS;=?|LzHwT(Gio)_EIm;Vi!N+Koqv{ai$_)St6C+pFc=`Hbzfw|WbgO9@$LAqn{ zw4!k74;8Y&n)`}DF>Z5o){5Hd9|cBl4aeU)SlLpbLXFhkvJ5Brexa9dFnB$M){a5s zsN!#Q*;t{CJv|KpI@+bu)C^18#8<(+aN8NR*@SZMt}fVW!1utM%XR?@RsE|abr4BR z3fVtbEcV#DV`fc2ShDTBm*mRJrz2h=ghU<2fnTtv{hd8q%ebLZRyAOECOJ7L?fklZ z7NZk~Z-6p4_ReyB8)pqgzh;q|U?1nY&m0Cu#t(6mu6Yt*?Rih0NZCt){$~^AE7o z3TXjem5|4Kz}g*7%!EScZ}H5`3GsaIZr3uUW`^5V|d z<_AlL#~6@6$H`&zIcSZF8GnlL-_ZDAh%_{5sGPpQfYttIiwD#0UmY5AwsZq5>iA2w zHKzPtiGG5ECqE+*@TAAIz4-0I-3ev>{XwWypqHP%thj@A%uC5w^75uI0t7w4LP?%E zIzT7joDr>prEG#F$)c+2C;jsP9&8H!$ck?Yij+A`1j;VoruJdto&|3*3n$y3W`bam zcIylvmTR-#^pUEcg?Zv`OYl8R3T_)#*xV6~csi`eh_f9@Y&5B{+?=AYqeP|iF-+NJ zrNl16Q)v3ct0#DQPT%r4+EAlzgg^I*T={DHUA|I4+Ci+rK)%Pv{5a4nQ+b$3HD?&z zPXXg4wwXR%h0sP9u*8h=9}sjX9&``GrMw}WVr z3b=J{EO;XOTp!Dul+!JJg@RCXMD?P^i#|hHDQ^|2Io{Rb2WXGRySdPDsh3S%69k{< zb4euq^zmg1F_#>^3N7i)A9$*icb$N8*{IgN&%@w@!v#rtshf*xt$1gL=1WL9(C?yi87 z89HZi%D$n2^j?r1i^@mJf0kUqf4{ zvSaeE+(tFydO4lEUm3S)q4E=R8D|roup>#dE+DqJiA0EE`PFp5Uz)4Z&JUy z9F^v@qTWtTO{s4Dpq?@RZ__yJGX%H|1T46{a|>%kEI!#dXomCjSzz^9yZ}g<0KH30 zM|YmVkc*;+8sf$=)Kim_gVwW1h04Edth1)}-+ET~G-<3A4N-;B*lo$nw@gSST?5jv z&~igN#oNLY_01_fxbwLiHHaY#jfR+pE5EJVtLeT%ZoP%FRh|~&*`>j9=j)+2C0var zqe+`oU*oqyKXZhR{FtKPmub@KGdvm4H$aurx(y5CBv@qROUxX2)iWuMH2IR$if z(%pSOF4~nNV?2z=QQE#l*m@G2+O&t(2CZXhv%k!RKrq)N=obe)=z^XLol!0?b1!F$ zY7^>PrkS=n#RX%Rr%IT?=M6{cOd3M6B)MDL+o;{Z;qNp z8VP0JtErrx@1em*%yMyJy zO}$Vtvl-JdLDI~vgCer4!!0sX{2}e~bQ2B@$7{}4mhLLxUoXk~c#pSt-_RwFm6)?c zR&t>f*+TH2*K}Mf-L;QIzJ{v{R_cYWr|aVnj~r~?nu-M`{y&<|DlDq63*$p~C?HCQ zfYM5LDjfpS4bnZp&>fo1;_$BWL-N)hKos5PpDOBl%UIFAl(oiBOG9@}CV948T!VRedpAX(F*9 zcpEJlc)b?6LNdLTlw^tY9LX<2UB0XD&z649 zIIpzc=q5LIxo7a~hq@oMUFm#Q92k}FM%hW$7DNpiqpWW7%sm|EJFVItAT;`Z*8urT zP?iwklON)m=s=n@SfHo!t4yo3)D#lQKol3Cv}Ooj>D(Tlm(-J8nsBk2r8~Jp3$u#} zSb99<&+ro;ovBS%g#J>*-(G2cc#+{U5yd0FbycbUQ|O|_yRqF;$G<+!ap~#7_g!^h zMgb0`2s!@)#!WKE_K%S-{V-=v z@HrVYzkJ%x0ucQgG&*%IxA+cMc(vk=90iPGkH)&fO*uhz(uZ@+lcXOr&7xl)Dks(6 zhAieGrrPYvBf#R1uN=G_{Ojn_Lufx<_h+P3x*~K= z%V{>qJ8_S1#u)_m#OT4VXfOW7X{Sxwb=#JUw0_&IEx(4M%+t0xou0Pf5$Qy3B$SpI zNFj^@(SgwSS5MI}koPxwj>W>7QMA1e{q6VLi_V|mho>Dv?c>y6`}p5+6Da+Qxf$o|Fsk)x{QG z64z8LoRl?ZS7AyXr4ydiupQuuSyFr!{q6L?fj;E`aqF89{qIFz3;C;~o}9jM;zmy7 z(X8t4;BfeB4qe;sV~+Dmt3Q(|NlTm8ciM)5Y>zE{%_aPn>n;J4yqGWFCtI+mp|b z6(-@*{{pof=p}DYLIA{7P%}1$Q|kjv@G+lcygVD;`oT2Fx-l+3@aRRUCw|Mc&6=FR zN^rHmMd5*%)1L+Z7t*U$c}Y2AI+lC153(qeBtI^Djs*N@cb*QKgH~H?H)R$+2Km3W z7(H|~qX3M7XgTiR#B;tt|VAG9fzsaF1t zTP!pW;Q$&UkI$D0!{5Chtb0cfE}_7Oz_uxRS|2U}ttJ=^tGjE_VrS5*gR>!P+TVj>sToC- zMEUU@_m&zkzQ}4hiuYAMQ0}b9V4joM$)`3NDL9b^J^R#FijQb}N0kh8MZy2zvQY$E zjFaK?%*ge)gN>4UWp}zfiUmGE;8|E?V2r%Q4GH>l1knoNmUvn}x28``AoO^aI1oO; zQjd!sWR({s()u71eI(MZk@y6y_@nPOq;U~PSmm5oirJp3i7I>kJ>oWU<&Ivfkab3! zU9yP=gVvjwn*?M$cY(Sv-F!?ez{@+7gFSZw5-NI=%`#a>H^yNy0imX)?Y*eWIue)o z4>CpKS@~asaBNSR1biFN5vFj-%xpy?cZ_@SAE`F8AziODHHQE*NbmtoH1FNI({P66cBrPg01wr5BcrmXy80kyA%Snl-tTb0GuwT@^wNlt5m2W~E~|4R#`JaIf7yc^=WVOJG7_b)6OZn?NiKPzu# zR5r>%Y+*Gx5$8-htTj+NcLz7scA$L+OJU$AJ|)vMqM}6-=)pGMXx_1Dc{QN0K}u`A z4Z={{nvkv;9t$fu!h9cE`RHa#1!WAnXyvec0!Bt@y+yA?Ae!C3;p)tU`?p{B1V0=w z^r8bD>7Eh49KeG+y)6)l3B(R|zbiT}<9ZZdY;Zh=(zLLRl}#_u9^B1KxBO1Jp~5Y; z-xCeUqijrCU(*0T5)J+d&%C8S4vLjX0#CuH%(R5zINShoO2yEs$gi2xzSCM`_V((_x zI(pzc%P&yvw?+1b>ua|M22W!rR}zV*kiM`L|HPkRJ`xjq4mx}8KF}D&FW)4^_Vomi zO94|HO5h!7x*!M8riLUxMm)hLnE3}_y(9MI2Th>-z*YV<`K465ES>QSOkuk~V;&D2 zul91=`mewh3|B34^?{8fCb|r*+=`@e`9zFruGYksVPcr3JASy4E!HGz?E~W>XHD*BlWVk8ss2|8&yF&p{TfaP zMbb!Z%g*J&^)(7+&y8e@A?LH8gOz1Tqmh0bYH<4nQGDHO>9pOW1bhO@HU>c~d9&9~ zQ18FjaF6h<%te?~Fq4&&Umy>bA2=apKa1ATyB-f;Uz%4JuM3h4nThLjCT3C&g$LQ- z9WGUqI6;Js2CQt8@vB5&TYmweowr<>k z$FGiMke6Hgt%EmPtkss{no)~3yr=NWm1uw8tF!A`lS=`YNgdNI962+u)8c`$EH}vu zslo4bD_q+!M=x_R@v~%Wh2mN_xdGe@S$&TW`y{4|5#%k85KVu7e?aYvuPhFb?p{qF zjcBstdaT`}Zfuamp9NH@H`boo&b0(Xt(d~0SJ^$8h48MfO(j?XgnbOqr|7hvbbPma zx=PJ)Vg!=dsYE0zbCy@sU`&(jZJ%kjw5QVcC8Z2KO&3|9;T6%?by8o3iR^8Z@`zB|^x}$eCPx@p> zwWu>zYdU}mf9lBRVp%40gfE?X3ZtioFj`ebr94{cST|<{h?fsk&ECjS%`JmOf{!jx z_uc*sLtbKGTq?tl4K-%rN8|6#NNFv=Q23-R98MGCOf`fOtWo`%rRSBP`NtGI`YQho zZQT@zDboqDAG_FVWKH_R&p?<9W(pd0&97+AIG%v`Z|zQoGEB$Cq$B$GbquFVU|&Lc zd9xaO7mmL%l&Ic$m4~=!m-#(Y$UI}@a6sHP3f`r;PDwowjN<3V{=RUzWzZ=6BQ^)< zt&sKSS)sCeZ-QllZJzM*^M(j-kG~;y1@H4LmsceE2C8qYZ0TBfiO^F7h9rFZF}zk@ z1@^BFx5Z+Fm$<{*ItpX!xzwF`fmgXT+#iNaW0l%n>6>k2pHb^=Jrs>oaV;UmyWlV|z78}(K-C-9 z`p-?+$Y3HF4HicR{6L;e$(-3^>g}S+9SP!>XzYI_GmF%Yi_HaA!()-(@G9#2r%aS>3Lkf6{ksEcI5i$o z=5^Hoim!14#Q;qu_br8h_c+*K(E8?wb9Fx@7r=JXE4~yElA<-Y##H`H*dxpChAC3+`jDE!qZ?DX{pFTu& zF%kMP$nSU)9qGfIAjO=(R3UVtBC3a`e47h{m;bi{ZhCP$NSgg=yYOivcuvK`0t~W3 z+x_3ZLK)L@e9hd}t+fA^H{HXI$DBo>7>PvIx-_jXHhqMxgyWc`H|ob!SZsd!VbD&F zi!r9Wv+^}Evive~FqE(g)@g{1QkGob+TXpuwz+L%bgZU8)S1Q@i+g!&+vE(uO zumz(L)b!?1i&^*nNi&czf&)LlT!PgpawE*SrDl&oLcMg=G8BS&0XA*r63v4r2 z#QWp=+HxvN`vnsYIj!03wg;G>H=3yiudvZ1E%$Gmu7MHssE?>}By>YcHS5odxYMfZ@H z3f^ApWa?u}(?u-C?e%pRF6czYs57mzOrykGa*47Sd3pJ)5v7`oNt}%AaF>Jh%=hU__7pM2FET+Sx7MUUfu1WlsKqhi=lVbDO13awHj2L+G)VUO0w(4zWvRVJPf`(yS>ZI^Q)7x_x^xU+DJlLQl2T?B%;>4$F1(nuy=C zJtpD;jUW)a@!yxJ$`n*#69Dnahx4cD@zleXyM?El+fPv-%Lq7MWEBx)Q(MZAwXW$~ zh3tBuQjzN^2q)h?^7P$8z+EW^u=7{~xBOvn4UMoxkUY))+5KK!F9)158QK`Nws@-A z(3D=4u)1EM)uo!-E|B2*aM>LkK=%$fLCZ8+4#G1rzqzUh9#;3dZnafNIRZOQu-Qel zhc&yAdU52l;z)RqGbb!*rYY2e7Im)LA1mv&TXXJY2|V}r3m(7YLUd%{EjLZTrWvn6 zIdj&gLQb{%5>Uy&2fTUj{O{5jao65NO`H9uM?IA*UD>Kx{un~pFz%smP+3SRrCB;8RV#T<1&HgD`?s zS?s7PLxgka@j!P-+ID}58=SO#T?0fBNq}jfRF(`jm`fmA0dwEN0t=c6Q4v1T8hLFk{W-_eFnts!e#9*d5)$vb<1DOc2msfXFaRhqiQ zO-R%V%;Tmid)KM`QG&J0qTn#dTYr%ed!80it?kDT(9ez_pV0wV5!i0W4yFNG@*qwSc<9J4y z++oze^g|=}L1cF2D@)+jYjXo&hqxdp35^wce910h7e1kJGfSKihGo=~C-NHi$KT4~ zFptKIzAv@+42B*QlTG&)$*YgFE6!4?16yD<+NEH2AE$9cK$s1_gm_-s($K?2CY{#`)&~;5Ek@E zaW+PF_Ht*YOYO1``Cz<*ROrg38((JMV}%DzgUD+TsPjPv9MVjTYJ+{a(3}wTIp8Au z>3*ll_3{#n0DRCB>nwvE_L~GFAEuo-2WiY8vr-fZw?~$n_Yy@LV51OkX9qBO3jlH) z-{WTTVQn4_TNepxF|{wa@rNn5b8{%8hY*Rkp^}I<$)r>Mxm}#zVEew;W==gr%|+7K z`5$ZKw=|>vEjjuvmhuQ2bDB)zvNtF)v2e5A2?SiGd!3DE%b9S~A^N(6&SOEbf>-i? ze75?D9cVpYRs4$JD0VmEDi#>w;^3^^|B@O$p&q!Kb*JYg4N{ZvbRk*4y}eZy%D@9Y zepGMTTVvN_8+wT^+b%;yfQcN3U%?m8qZxzUn{rg30O+nNGmH7=s3}L&<{tB1T+{4* zDi)wn`9garU|Vec-geVXC;{X-)57iKVYYedGF;#0cAu@Z`WE&28i6$A#KLoX4EXCe zUX}Nw&-x4;+6l(>~&E1}}1U|lY(m#*6`9~F$c*Qg&B1-`&fG~PY!uO(uX2Fdm znYKF3K6x~Jc~>exRo~m|f{Y6Q5-r|Z4<1Mp3gDkK73(Vr5ZATT;~*YJa%oIXam{i$ zlSiojo<*)JD49*VVfKQx_Z%=g@#NwM##AgE3Q{Th8H^N1DYtuR14Uci9(1huj8)?+ z7|e$b@4!oe=WGJ2QF6491zeP`*3Sz3Mb4Py))E8nVXS!(m^R!oX8xk3j_SB)_Jhfs zYL*&rZ?Y0gaC_FT;<5|&c?(@{+Kj)YKaE0^n~6SrrKW5cp08w#6U9wc7Dg2^wfgU2 zF}%^+nkiWj`|P&I`}P0}=hA`SB35E%?GkrC=40r!(qspg$Bkk6Ol)i+6zjhe&gOiZ z1EW!d@@u3|SpiFzZ4}L+fI{&g$*>oaKeMig?ZfuOUO?k^N3=y(OyU6ovhtyK6lGaG z=XApiwntAVZ0-cm_@8PR$US|q^J7>HUdRm&54O}!5L zpgfX3<{1VM$S>;dC|mu+XtIZMU-z`MNbEORoZJPTVJ-b!#O7{8@tqMe*tzYqey6k; zWLN(!F3a_Wr}KgkSkziQ^Om>Odr#-|W_lJRy*ht6nlouLI-df}z9=3-?<&X=Uex(v_6!4U|8I$kU;0##*kiN-*K0a^zT&4t zfY%wK2W~NzYH2g!yoJCTZ_1i9YA47(oqNIxUZ1{cvPHt2mEleytF20gNSG7d9x`FH zz+6GvpOBjzb?)@9sN!Xb$vtYLp{oT0U=>k`6aB6v;SnDU#jI(D^cxR7QbUvoWDJ^e8PJxyk*fM@w#C54%58{J7WSz18DAT^4x})bA0I@pwv0Vf7oFef6x-ua=LF1Ivo!pn>OV)zh`5!K z1VSN29_LPeM%+$K{bFe`&GI%Z@UETz8l5K>)atrX_?fEIRlU&%n5v|KD-$B18QfB0 zKj6d&w)w82?U^k8BFSVD`1))%mehdquR$vw8uea}HaUZos}@w=eGgJ_xX?dCY`S94 zlPP2%W?iSOS;h3WTy{58HgrxhGq%hiO1~iju6LTtGb3lcp{bDJRAaiv+9_Xv3e@Iv z|M=BZ@jUa;BuxjCIGT`IzPi`YAF{blmpL7?w(_};S7Et8tK!z^XN1q6FdC9n6Qz_& z-B?UoXI)spgBky zojE(4F6M)QVO|@1_QWyskyc^pb>A!NOZ4q+xG-u07u8bJJ%A=7m#z(mE@ATLSxDd0 zomwOYW0)35v-D7lPBD!c1uE}GNdwqFugSsIvacz}bJZKN0&qsj>?|i*``&zOmXZU# z^_dLc?AKF!@87YJX)5SK;_Z{iNoKC^R7K!>Z+F7@{PoW1eqhyHQ(!+LknI*~>HUn% zJhycvdL2~KlFDeiE-;0EhHQA36zjNA6~XwVWZtQ%*eYMXToy}o^h_?B+t^^UY5y_x zyl5Ny%O-z)RVI3VSbKd6ha_C@QYPGA&Az5pVY?JdY#Ah3x)ZCogR|Zl;ZN=G-WhRA zSXnIAXTKiO+;Vs0ZbLfZKkv`r+i}lwTUHEx2EDOn)iF1~_PYVkuB~CwM3fM@8~ujC zJp|*~>0FkgxVp@d^iGt325>$^0&&m*uw=ij!L}u3ws> zf`ffHlOaPTH31rZsBVQYg1gmRPNJo=8;edQ+iQNd zZcOf9l-WL($^HDLwR|vB*=q!W+nT9$fZ4Rbbm0{zG0h&0SKsQr?(P!e0TA^@4&sJ0 zmGm~k8qecdbM|nuRia!6_h|Hg+aesf9FzM`is8*<>Y=-*ux|Fhq*G%oOIla5ZL zge*uLh9n2Y2F~MLPtLZa2|U;B{PCzCziegkFZR>SIO%QjulfIuovb^)a3K&rK0Yys zMikfqo1$EuLiCx!xbN~7tB7d!eN2$XGMNY+vjcu^7;ly|w!83JJmO9+=)WM7-GAS) zr;Km}ur;>(#=YnkO}FtbrE}Z)!(2CHAAUx)!&YuyLNoqR3m8}A(g+j+H?P!{1vRA6 zuAuM{U(V^_SK?-enGA*d19V{9lQ^Rag~EDahZ;pjr&L1@Nur_}*z!7JY%k9!UQu^{ zlB0FRdw~MOgm#N55Mhh91W*I1A)bVn@)iu6+wh!#FI>5Zl6=cv;t;wNj43h14#+yQ zq4skm?sl^w4P@oc0-umjD*40rFD>U3d&1TpFOD^4M=6qs+sP{*QE8x0^o>n2m#cSc zG$3qrRj+v*uge1y8CGM1-X?>=eI=Dw;Uo1yL1H#cb|#^#zrmbc5i9}zW`y$n`kfBq z>dAv4QcLZpXwSfsS#iq_4bOvx#k>yGr86ruky6yebG6nGOM6Mo3j#|14BRHkOPOS> zXc<%wf91Ew=Cf;f8?ga~E3s}9jzOwL8}p(OGH`)Hr&)Q->L0O%WGXE7l_j&sMH;(Y zS5NvKhHU>O{^34L#ol>EOHMCr#`0o+$Z7W)3kA}06oP?Q<=2giX52%4u8O{ojsW6k zc%5KJ{7vxe1}RCDO58fEec@K1X^+)|de%->0F{AboqN^l@+p-?5^f7E13$Byn=fp(YeG;*BN-OceAZrl#gwNrG}gq?(VW;!$kYz;P+wY4u}kE zi22e#8L@;laDfkwhyV3YZC7<7RLap9N`V><(^vmtVWX0FeaVXp=@h6fm?2+l;d3ov zKDp`)qru*K`w^%s;Z6Lro|lhD@LZbAH_58j83=dUp&OC2k6#_#$F%j{>fF|cH*2TU zdJ`sR`affxPDArBdiyL2F24~ghP6+PdT#TjhpqF=V6xfx?@soxw_g=dYSjfkiw9hm zJ$*NMJdKqwL1XeBzVh8>g;U{7XzmozJbe2$w7 z@ej4Tm)fFzj%DCr_Km0c5XX)``=PL%3ZyEyCX3l^nS&@ZDG}oq2|{=h?GShfzpI#4 z&t_mDv)c-V_P0r!KHOgZS6(59B{IZH}0~&PI0F!A?D9~Rc>XXMCvjAY1N zuSG2$u&UKYymum;h7md?4fm7=wRe zB^#fejcjcd$GAatYi6I=)V^OQ zSM%;2w#cnG1g`QHp2|jQYhOPBLqg{_tR=o>522>PbbE!L1ya!DskT|lh5Ng@yOeaG z%vr%}+0$`|Ue)YM=%L~gWK>NTX%PgX+Rf@B3QEpCbNhSh=o~R0N?o|?N<-<-<~n&k zSWf-Zn!1sk3H$s5Tau}lC3@#~xt*hAH4bCfCjAG-&(GD1Hg>gc=qfrk*q&})k(^LXGJK%nwxdJU6@n8uk9?CU3thAz!E|e~tV;(o83m!etWTVBAr?v=T|8rqAarQKDbv@Jyo_ zzp!ZWk5dNM6iX`}PX1Gk9 zF3`>6Br#qO)kbbH{UQl!rs8RItzHS+E%}OLm7vu#(nw0&bT03okj5yG#e6Rz|GMnZ3BD~yRzYHdscgM>OEjoi< ziu<7qJk&_(@qz9C-1y}k zY>5*|PXJ4O?LjA*H}2T4U!xB6XIYKewR7P6?n(>AZo|K0FbVWu#R(GQJtq>Ng8W&U zO{+WB1rr|R&^o!>08<8XW>j!%fQkO#4oSpq5!c6V2NFsN3xD8C-VNrOl7NsyfdKbc zXlM`H^Q62i@Vw6wF6YAn8+%281xqwbmO>&NHAYWBOUrO>o&=+=n(s|kdX)&@R zj=aY|IQez+mD-0ne5jZq^Wx2_&WE$ zVoy8p)?CY;5AE_sH7Re<^Y?_Xn0nZ*m z%!ZlDr2cYa{7SSq(0R6Hx2EdHLbuvbNr*dcYE3Pm&>5gJ~^?U+OV z?aWX`3p>m|w>;B3r$Uz$PnY9Nm&tp}vO!2lXxcyU1x%wuYg_}0q^(Cy4f%Qh*{4xH z*;hloQK@(J{$sA{!&t)5@5fPs{bs{|r!a_ma#7NP*DfR~^ma-se8?YdVkZMk2wMGz zMe8#SM1!3>i8C6=LTk!5DNNnmIvi>R0*en$e&0%gfbCCsC&wUazVVVxMOk23>jQno z1Fre7tpx-2@6^G|PSz|GmLg_`&&7Yb{y1@_e+X=*4VQi<4NxBRjm(S@2b~=lc<+Rv z?e1hZlrJ=>{VzW0R+*wSIKe6SGV&-^8fXs${`4N-pB|?r*`=oZnec)#B}my3Kfc6@+FDv zcF(m~e;@~wxVj_7ZyWo_@!l)j1bSP1l1w?-tPJ=u@y|p4X^7he1WOBOZ%#8 zY?nKNJchx9y)RdX#gHET1%6xyu0_aF!fR}=+;7&HV@_(dJe}5MVLxEXn15XCp2Ari z8nb?031<=l;YtkPoMI6gOlz9#+O0y}_CvDoOkk%_N}4!{=uGKcm*bi*gIQ=GO_{@` z=1KgDB8_0XPx+v*&3PZxlT$GLMF?bpn7EdAwkm#Y&$^5@M~n4iyX~;8`M`R-VsN)! zJKBBFLicRM}eMR-47hUCqT;Uqk(ZJtTm8h>c zc96C&1#w4)!!N}GGWon=bQ7uFn=WB^UCsEC z_5QjSY5Mf|z?|z?U-DV2ZM=8`oDIXY&h&VZ#A#rK!jVzO=n+i(;sD!Hq+OQ?^-r@o z0cbVppiS%;F?src#U1vHbih;Dm6KadKMH6WnACdmjR>AAV`EQNkw`Bu9>1U?u5(8( zTq`=lz#ghKe)6Angsj(m=lm=pf?0FYOPEEHDgh!iX(bH=CTJg9buC@^e=v`R@KuD5 z7=DV%l)r%9M>2F7HNu1Oo=!#Gp9kHX{Qg9$I5JmD+-G&Z%Z0Q!4)))6L<4oA$rKCh z11Af%21-ph)$Q$F5K{;C?9~6Y0HUA06zEpI&85AV>@mDDmsWtjMdcsFa2y@QfBSWB zO*?zS(@;t!RQHzrrN~mCCSH71xoOEfqxHfh@>!Uzl=90d+QlXu0HvhDcCYNF02VeD`B; zD}I#R+*EaP0DzsnWjFLnvF&5mufyi@o$t?rWWs)0>?h~wmr;~7k$8R$Tlz$@aZ#H| znt!AxHmwr%V|Q?nGp=?Um_bxN*6IK?hVE=h)!8qMCezOeex(8wP5b+0RUQZ0Z_T2J zrPXv%-;B|>m+>w|rFs*(T%Q#P9?*_3aO=1-Nb-Bf?SE)jSyu4U z_7Cgt{5z#1Eu1MuZz7qiE(`33GH5coyinpqyKZ2vONW6n(Ea`eevIkA6I6Txe6y-R z;w@=C{v;q$K6rH{gxPWW0#(muxadwSv8HHx99y?dC9IDpTI=|jViw5*X&d~kay#F% z@(>dd{8a?U<97M)9b7fK_PFwB&ziyn1gPb>CXtxC1`Q6c+&=)brodTQ82k)X*tYoK z6bxt0jbhxeJ!aB{bK9!s{D2sU@zCx*Kh{~w7d7dWH1%0{`}ZB3?b8QJ>{I)d7{bX3 zxG)C0K?5nEB4{{xCAj{TOmOR$&JgkA;Z%~`p=|SBY#8L_z>4adspj411JwVHMLM!- zE8xvn&4K$GgWD6Syv7e{5}hY~Ki;Y{`=k3aMCDCXFWamRuvK>9akbiXKI8YRwf67p zmGwX?U_=K`KBMO}@_n`Jc`HH^>eI6Dm4b>P1rOUYq86Ci5AlqKVPc}Muz!5)sAX5t zRnYBB^4pQbUV02&bUnQx|0q?F#RoI$R|V-dIJ_0VRipiU8GC6$G@hbAZOMGcZexfp z$)fW~US49;MbeyG!hy8A^?8UEZnz)eyu*udLz>iIhnam=HN`V!%;NmU4ea?LpjY)j z<#x=N)M{R%Z>oB2FFu=g;2ZX3LAmtH%8pU>JK42u`)oL67ChroT-xiVLkNZM5(GXB=DmRwwu51MCKL}Km( zEr41|Tk%f@b5`V+U*?@67sm-Oedr=x-hUCDGV*N|JUan5vnv)bL_}a#+l-s(R-0oa zaT=9wGmZ_t=DD0GP&&m5Jc)d_Hmc(2ZHYGHcl%t+o(#=`F^YuPP9ak1)bP3Wa~LLb zF|8q2g31Q+>4YeL_)C=Kmv0mwMAh_ArYJoOU2n*0B2mVxgn!Fq)nAM-f#G!V+x^o1 z=1(Yf`<{{iWN^+8&AjQTUxUv16yIYxbf!_2{_bbnY*F{A3E52V<`zJ0I>Kt)_X|O2ku6~MoO{rZ~aR1<2mufM|xZI{+jVUcka*SrYqM0hm?!o zPy1b`C`T&7(U{fGV#jEIl$FV6&U7HQKq>Fdqp2x-xPbneVz>|K@b|p89~sr*nH%>BXH9i0I3fdD>h@C~9P<9 z5rls{bi_P}S`(;_XlSWuy6jD!^eu;-G)vV>d>`=O`_m*fbh!aHY4reZnI9k1!TKc# z;qXZ4-q;d5$z;#fZLpG!Kh=AMNKQx!Kr?%+K>o$E&hU;nOV)~Deoa=Ws`da6JKsXT zN%~eS@%J*aX?1DzY{m(FY5al+#BNZH|8&ju6ee9lH;5V&O88w2FQMo|ak56lGcY)Q zCnlYLt@HSnZee=Ym=ye3|9z2j-lR+jqih+x16Z-?kHcLbip;VGLNA+FL^;o<_$cE-!=Yk7${N)xr}tlTEM1@0jXQZB zEjT{!1^N5(zhiy#ZKVyC3NS;P@BPEpb{=^WUjAoUc@Ogli>O6I_w zEP7+9=bFJRp2y3f052y;Bb6cH!@YVkm@z0XRv1&Em?O@qeJi^eKhchf^;0Bk3(nF5 z_v}RT;b)x83a=S#?CBmpv#+^p^nVcqm74Yn^^#JigeR!702gx6^G~w_LFx22f=R9A z=c-PAoj-aKwXPJOe%2?imLCVoF{rP!`EnH+9Hnxw@}0ZHnlRy<3;f-?yuRO&sJzFZ z+tu63*M4!&t%XZ!AtzBbaE{gZ2+9^i`Wa{~Aw08Q0_eLha_qelf%g_~l5jB>D860@ zpxT-ZtB6ndTreO22~}9_@}-pWQ7VwhEJYS7R2IqZRiXUTl_V1`Y=5{Mq$wzHMD6tKGAGD|l{uQNsNyxuj0zBDXhT3(%Cu@FT*A z=juKwZY#9^@MjY=Aj7p7XP2(c*Ukz^_{;g z*nnu{&tg0AkUuXcw;17hq%hy?=>fr1*)+weL>fQme_}rOq&vXrh;wKKfY_mc8ix=d z#n4`C^6S%iH2E1C6nnXe)Zr~+2#9g=5$<1n{k#|wgE~9=;FRdHBs*(;`)h^pVJ&DbBRJxbTVr7JuP6* zg`_|4eJV+JuZ^UBkI99to@aq@pJ|?8`v7NO^rm{bwt9(Hw9x10`$~+D zRM9o+m8rP|-h0&-Z&GeF8e)rJneGsX7LuP&2g%6T={2~x%)quAG_W?_Vew1xs+`NI zlZo6Uq%>*DV^;X)D2&>97Ut-VZ7$FiZqM0au<~@3C6n1|+xn{)kYS%OHSfunR7Q_? z<1zm9eHjteaZjoEo+!+j8TKdj&GMR7n6M^=!2Zq5@dMU~&>hdu*|(^UbUvfbRqJ0F zPx@;mqRgxNB>%7(+^nF^D{h}&*oOAn|^FwD*)PV*LBC=VAp zpN+qb@mO!OFSJf(!SH~6`b@gu^pdyr#owvp&`@DVQ1#%hVo#v?*8^wOqm)*qg;NW=uctz@mym!yY4y| zERGilJsPni(3KIyr8p9B&KZOJ;#Ol!P@qiNahvZe#Q%G#uY+L#bU+4dLGN^MWFEY6 zJnB_j7|{>xifY%2GClUF>BmqS2a}rr89iDR?8aih`)i6Gc$TJ9E1mznjc#;GYcyi{ zYMtNEqx-Wed7Ir=LHGgh5TWJYk}O1Qo9S@(^>-TS%(fUUiv36qlaSW6VCf>haQ>br8iy5BGqOn#gZkGyB~a(x5#jIZ0d9UlYRS zThFdHt;NHoo6*IFKkkm8O-7lXV~RYIN*|+HAK{c?^*NSEZ_Og$zCKvs39*vNp44(H z<1{HA(iDD@Rnn7iqf?pi*G9;uQp&0H80K*`%>89d0dKTM#B#r!in#pTfazxY>E&a)-v&d|&l>Qw)ZT+(bE%|6Fj7w8ZO)UQB*q~+ZC9hp z;f~9b!J;Z?5BG;Wqw9kve`7szC*OIzc=75v@r5jhIn6g>@;}YREb7RAe#}f^l2(F| zIVouZLo3&X0_&6lKb$<#*&&0tG5ve-*0*|LP$HBiFjDOLf@O3&gC1YtvpgN;;ICsj zs`}^I!bk@o`g)hsGj|y-zrHPQN!Awq1ImDW-$9>xYMh$Z(K~vp8}}Oglbg956@09@ zUbNK z>ytbFm;eC%x?L6))DE z7kw{lw4E%Jk{q|)n<(HafNM)qO>N1r76>E?{ZeoIofrN#d8%Bmk$P*%^~~uf6hn0Q zkGO(S#7EPLX`=ka$QCQ`pW-=_i-maTqAiftf17$7iV5mKGpmaMSgi&#Q_Uki>k zZMxwo?e7@Hre(b;%C~RmSMDotWF1cD(Dk=SbxIaFXeBzGAc^a>H-6d~hrABlm{Oy? zf7^Ny&UJd?F$%h=m%;edza)ROe{;`AzRrOo?GNRelEbBvSRizC6JSIq}PVA(9>!Y2CR~nTBg>L4PjBF!@^27{I21H-1Jz zo9}@74j94y%mRvoRsa&$9Z=y3sVFb~yGHM~`Lv|bDi^WEZr=LCNS*HfpKBV_zGzFq z=PKWW4nKg^+Uk5P-oa@WQ_MqQR1VVjB0m8UULdjW0G+4`N8`10_^OQ{0*{b{|;;^x1&q( z5P-U@aRXxcN|wF@K#ndDk+Wn8N0DlK@izxFmythJ)c0bsmrIKzwyn97Ca}&Yvk=11 z$`(zQYzJRo(xD-GQZllER7RBs*mwcEX)mRp$NT4J7?^b*7yUnqbAouTH+&;Wlz)ej z2?lWC&+XrpQd|n=R8T?+3J6EaN8CZ`cR=t}!c$F`mm|HlJ)Zl1X_;kO?i*^jMO zEgMRIg1+Uyx9K{Ka+CccKcAFfDs|N!?D9BQ*6}hcFyOTeco&%-ZgtR)h^W#8g!Sn~ z>@-8N09cE{{k;fmMH&}#u;JUEPPQ8WsOS@h8)w!i>}4B0j=VL*jw($4`#K(*?}Sbl zsO774wbOES>9MT6xI@#c+hma-6i9L!v2ay1QrQ@IXa@?gUsg=2c0n%}? zKCjCa(*3HssReXY; zC|d3Wld)ClehW3eVB5Z#&;B|)NJ`0h@|YK0z92s`G-CX!?Bo6P+1~oP^&*|m3{=@X zHxfz_LeU!(0tb`vXrOBnJZ|8|!JOJV>pX~8 z*?mQncXO3SH%nZ=*Vt5a0G$oO-A$ri2kn}5nbWJBE-#BD)(4}WfOI)`*tTBDO&-^n z8B#&0-WS*BEX$dF|kg9|H=8XM-H@jtGQ+tlC&{Wdt*AX? z-Sn~Y?9bxr`z(LEh{WibuIYg*_}Bo7WFV2+MF4Zvbp!CNIrzvG*OUr}(I_*sDDC*Wb( z4>%NQ=3Unz)mR^S+WVqMxkL}dq)lNh|ITVd5b@C8A3DC)T(e$L`S|X61yhYosrF0T z`-`9%JCsBCu(sW{It^9XPr*g*9SNA6J+mJVMX-#8N4yJt!i3izu!qHwBp&YGGD#;D z6%-cd%CC%xZ<5U#_(HWokun0wG9ob+DTtJ2)yWi>P4(cIxiH$BcM~7+cbFl=3pBBF z$>6*!dZ6umY@wk!Bm`y&3GWpd+|G9inp-&=15bB7m`n?H+5W_)9hK?^0S ziqTF#eD+A6U^EI`VHCO=E8SlrxSg-TW$1R2z$Ke3&*_S)i4y&uO5-{wOtMRI_Y%0d z1@i>7y5ppVP)l`u;`yz8aHwThrepV2=QCXu;eoCQOu$|nxCk|%a9W6wC3dv zMWQ(xXs3CciV?{!TxS;sp7PH58Fl^#MA>HPSO3Pg*54&-{G)P`rxF%w8gZr#H{aSC zm8N#OCa{~{Eah|<>~&ad{w z42J}3>Cu}%?vCy;?eXQx*zavSt+718UP>jC5eZu8G+ej!Sg;|VbpEPP5Vcl!7A5?7 z^RU+3=BSRXX{iT_{R#TzN>1iFA7ObC_44^n^dyr6!CFvQ zvCoKeuQRtdl@vUBM-8W3C1(c1Vg9Rg3B;5|j0m+WsWuf4kv^S$qyTuJ6ivlCp@n&A z)LR0wo-*~Ej%t62 z{z5Af7!udPis8{O&>r)My4Xvwf(GUd+xQ2|o^VwY%tw2TmnHd=l8TtC<4Bn|nQFPx zNqruHYi|;om20-J>AgDrg&Jy9D1ZoN%n<~4>VCwZfeYzQtyEbJ-IU%CRH$P%u_oBOB}ZGm;KINhb4vy& zGoR+2B~1HaCt0{z{#QTxD7K&X@BP5b;w*vbgS3dpnO-Pd@5`c#bjr&*J?|>nn3epx zn|Idr#@g8@QT!@#A_N!TwcLL{4Z4jkqq_xFkhAy813PaaT)VFUAr?bX1s^!fGC$7A z8YNJ%bzssRWIayY&#Rdh2>w?iBQEe2`YGE1n;f3mxPxhV^o$uj=r8@tJwL`0_{gBu z20Ys3-Jai>Rr4T=XCZ}sG3{?1p99LC!;-fyLccYm7r=B#ORGA|4B z-`jJ;$LA%lB!UCmLz^>9>UK4cX0C2ErKtXz^hP)uX=Zn(Ei}K~<~wB*Yzr7|MA?+P ziEB+efoF#k(pF1V4%g4`gg#{T)L1fSU}&`-x4S(1-gd3^fm`Kn1mRa_KYy1KWaU*S*j$(*Kksa~huAygrZil>WqC1ec& zn&=Y3nuzEhM6hg#(#yIvR?+`D0~hi(h~FNf{4`S$L+MLyUO9Kzut)#gEN{#a#BCx5tunnPFlg&@bJq?5(h zaT7z$S}cj;gge<3sWUf`3h+jr&h7weDq}n{o&_szA{cRX8q>@7mc7AGZ}GEwG4Zkf zw6R8D`fcQ{lhX3zNgpQojH$3EN@!q z;k|tRw2NvbKG_k@Ku7g)=5qdemr&AeT!aGbWGT>}H~cIIw_eoG7Hq0%H!66^_TBx` ze+R)-z4{au$0%4+V$ZUb3wAKcx7p6%5P*j#JS+^JD4y}_RKdm|`dUSo=_SH(uc=%V zIpn&Kg;@k4IrtPl@W??>fx*cKB{0UTFAZZk<1bX2b;RhS_*v3l_Pgo3K8pBE_UK=! zxjYp@3uW*$t}kAuqlap_+tZykF`d~c%C%hN*vMWs!4)JZ2m} z4`;w#0L3B*V{*;!(Uf^iPy zwdO-21!F7x4ULi?ioFQ-p`e9fPTMX}L7v&LFlb1Ye$Qgn>3>=PQc6mg_nLx4A+NEa z$h~pbt=U#@Pj+_pSGPHHhk*aOoHF2~URC6G=tCKc@R zx~hf|T8&u%Z+s#v%e#68DtGDV$~~KJ6^-ghTbB8H{ki*1w$gHLhX_)D#GSKYzj(@@ z2g8arS}jl-R?I{+J>v6I@<&D~|AimGujexciTZ@6g5nYOrPf6fRNk&dJjB8z zGR&C2O3!5686;n0R+~k5rHr#;X)LILy4CDVeJ7f2T+0E#(@mM`c5xi99-nW#(dRLp z(XIM1z4A_GT>W^KguVU=fyygVM4!|C-*f{8{ zI8MtN55Q->AZNo_fMDlRwOo75>gR;;hOhMFhe$`#vIV>SYrk}5WR26rAyaiaEErcE zAWpR*Jc%rz_S-i*P4L@|z^5je-q2s@GB2X0UFcLl-_@RXwjPzUNk#uu*%1HbByy8? zj?%lY#znh85Fk)EdP4mQN2~)>WFlO}NDfXktc$*uaN`tkT2~#!|GGl{efFKMNcEg~ zX20Eb&5?{LnQ8k;=V$4l{p_eQTq45ohaMrji~{!Kbj6ox@{-O$t&CoFkerDi0MGaF z#7pSR_+lWvU8xb#KtPj4_^vUvo!u$`mfMw1@`}GQh z{AdVXzR!Gv4H4=##K02e$wB06*-lxw5Io?jL#$6Eg!By*>jU<0v@Fq3UqqSt}{ZzQhw z_uq8UnX8hsFi`Tg4%PMdlCuTx!dVAIX0TwA$!6nH}05OD%etdx%>MZX{BuBmhV``ggxuu0~rJK zyCrc6K)XP2(!&q?T5rEjDXQ|-{usW@;%d<7Ru>KX+Q%XLv>6ktAA8CxJk`9R_f^8k zZz@CRak*6Om4ti@>yXdb$&lQYupN>3FVSH!n%mKt&+bIi5(AEh1RwLl7)u?QZ)OE| zfL69*nG?OLZy@bfYG)z}Bi)Xx>*pt;kvBvyQzP5#jiPDoE;g`UR#(e=V}e^#Y_A3z z46Ixh@Wud_oldJ`5&j7;Tn6~VeyQ8l1&bmr&BssRdH~j(BR_0m0o>eijg4+#d%e~p z|0-QMm>8yOgJ)-66}H(MT(%@sRTFaax4)7)!;CrKigG@!!6CTcROiIQ5CLQT{9kyQ4 zYWzefM4rTEfv;Tv6n+~ts^qd=>N)4f`YQOOw`7zEyLLtf^Y~bilq^MZQj_XV(POo$ zjIq5^P&SNx)}!KIPsBXQn%k&!VjoZsrB{8=-!37Rv;A{z+O)0;&a2*2G7BRk=g zbE*DfCk+4ib!43hw75Y1-3H;Mcz>U7fIuA0mrmu$%&vcnWH{e}a}UgPB$D z7EUp=a^vszham!WEBbMb-4>S5<^YXWTT?E~_NF6g>VR|rZaAD>3lXy)FeC>4hl-hz zOfsic6XAkfo_H&5LMj+jxcjJnD@LXfFPETOc3eLNYKTn|cqR6Cr6<=5_i5w`I~@%i zHGxU+$Ws7Q&w$*D3K%BqyCKSf+c&&stbFhp58wcF8wvyMxYY#KkSM$g4SRPB1nS4_ zt$TCl$0d$QyTw`9D1(E94|bCHZT3e}Gb?U#RI-*7-J-`a-Bn*gJb$|^ynC&105v5g zgf2(aO56E{`f})(wG=*E3E)V=6{yqIsvPHXa@y|ygh|=q9 zqi5Gy=<$i*_pImOpQB#x?gVLRI@x)7{lmiyux{FaYZVuVo{*fJ+ZebORX2g36G?v3 zh$$+kVdBa8r#Mu^=A$6+OBdOT-#Sk2F+7t1g1_pTMAu;`-UlRUU=gZq+>EoKWEY|_ zjF<*{9O5*K9t@)^P7|OBm&BBbTrM1sXPvJd9P~cy^oA@Yzf@!kND#Cy;IvuMokoDV zOxyr~tw83EEIb0t2~2P+Q87;9I9le0s+2V}ph%_72P>S<4r_TZ7efb49<@UT2a|+r zaMQRe=>4>b7t(v!!GP=kq7f3Kyod+?kR^jb3y06y5h3L?xAUOIvNG)ffo<0E`n9f;;ewd_u zOPEF|bhc4x4(koKa=VndJUQfmx{k``_)XhUMkxcZYUS!)^oz4cl3mY>*EL0HtXrMu z?tGZAt^<4fO%_l+5U0|su`G(F2ROVune(PSUT@ofQYsK(&kU-7Q9t#g4K|v4 zk(*SKEzg9y#^iAf=KS+r+WJ8@w~x&FOmlEkYaNjNv|Vkq+yn`B%kh)AWV|NSSa>M}gK z{^5NF^?*A&-@_amhKBHdM2}BO#y%agnYkK4j|)PF%a(cGke@;!=s2Zd{c*Ih<0^o6X$SK643FplPF za*fG{e`R30h`nl^2r|qF;DBHag;bHLHT~3m@qu-T?Hr;dDhQwsc~zXi%jN717u=GQ zSgJ|ht!Mi~c{q5#1#XOY(upYxWLVd_l9bhPfwAceKNmvdvd=%Qoo`^SqyxvV6rljmd&*Ty7=Lf z1Yg0_+cl1Prd(f|`p)k=&I?GCSJRE}e4hV#i+OHEz_f++uaNpq<->4&?Fn6=YEdDr zV|ApAnT0!LWzUoNe~YI|w-Tss=1h=MW(gMvS+LoIy7*F68P#o}j6nn+Uyvr}rSIr6 zI^S>30t!Kj8dbS9

    $oLQ(DSYDsU58TI&JjRZ$A;ZI@AO3`O9*QsWpMZ4gF%ds} z+^r7tlii4Gs#nP|M3<%DYQs*$0?Qud>^mX&+bdk>DD9Zi105s>HCa|!<)t4bHIv&! zLx5f8I=OID&0!0k72a!ScGv5U0x*rhm>B$$@OLILMp_kUHg7aDocp`Id9 z>dWTdVPA`1ht+U*0!;gm{r?ET8hV#`t=2vc3#r0iIuDf(C#T+KHgiYUv~_*9`XF{Q zHidDbp$JR}6Ud3OD8F`;XfE|=4qt{9>0_Bv#q3cC`I-D~^fa~hQsi=w$V#|bEiCfr zFpiPQ_=-mGwc1_v6n1cq3fyovps!jB)x~!!M|l!U$-&xp9_QyE5UBbbRP9oyS5u8; z)Fxp;@p`|=MUwhR%8O_O?0fM#igh`1+%Bp7V+Zu$iBd}}jlVwiF^R!7c??qv@6ZQ+ znI+o#4qQBl@fvbN8@~_LZF0!wr9M2tOk72?0w#TqSqBdW4ML`X;l3;2rH@?jSYQAK5Cqt_`hC5&FN z{L>0Em4SmWmw)ni9)B+fEhKRx=Clu3-MBJ6D9r5sd7^4m|x-dmj>9 ztloJH=}0FDQh%&l{{n{mLS1o3=m$ zB!0)i@s40qz>(z2i{f5$bDk)N2VbjWPiJ_BOlx609jV)pBicaDVBpSVo!-Md2kwfg4JHdD-DG# zg2NM8dr5q$+xH8kLyE1SCFA?11=FNoF)tqq9K47Q6VMU2tefIsZc!t2zu{EW@(;RU z^HRh3ij+w?Ib>Yw6{1?Vr&kWW_mUR)Ka>y&TLj3JsO-||;w*->!ma-dd)iH!YQT6^Ige0eyz4$lLF{QKmJW&{9`d>#K)xTortL_}lrF=UW@7ahGT=z2j zs~*#9FVK|=3%IsWEaUg!7w%uW;!2M|uUVjrlFes?@u*uw|r!f=Bg zh+a`@ytAP$y@k@Qu6Fb%ybR^PKiz(Km`&5!kAq&n$`D;$-6Yx+M(L;vf38`aYKT-4 z6~Y1aHbUzHGeq+vKxPte+w0Ns7L~j^14f~F-&cg?@gRN@!>-wu?j`X~ykC0UExnpG zO?p#V6nLvJ_cT*0vT4)lXFRZCgrkRO4WTISy^g;F@twloZ5b9%3yTm^1*u*5Rt_bj zw1`LdX#IG)iz#=zRxFHBkMq#mKqY~wZYl1SXfmtxJ!%>N8o-0qN3}z*xM10bVz;?} zpda{}g$ralHiz$>7#Q*m3&lw5k8EnE7Wn9QWHN@gx;8qMuNXwoQC6)08mXjH{yKww zV&|;Iuh8U;NR7AO%m|j-x6dv;1)|7-JDc?6lDPkhju5ak0w>ZgyCwalcFdZ+?BS2uMCYB?{2@isW^64Df@YQ*@ zrQCc;)0tkolPhD*tQiLI{}?5@tl4(G+p7~YY0N+u_I@Cy^P6U!gY)~HkRs}v;b-EISb5bvdJM*u^BtLi$sVR+DyP8Xle9D`U zH^vbG+|s!bD$M1s@{UWu5j`Q7aIw?s;k@>~;yh$mry$|zZ4MJ$Q=*oB%ce6BVs)g} z{&!uasP;;Js6GLzYO`N)>O6dKWNL^#sUeI^{c`+{jyjXE%W?l}g*?41$YUPKV`mg9 zPU+!+>bh!IsWKk;ZclLD8StU8(Cc{;6Im5lAsZPyh%q-K;VGeb@8Uuug$^K4^1oZzT#;Dx`D}LaG>Z4%x@B zjYH~9$Cet>e41_04bK`yIIP^cy$CV=c!)EZV^nHP)^~En6f!OHD}s1os39^vE!8nkNX{$?2BjdZCLCQC72@if5X=ljb)JAD zi+i2cZr{_8WL7PmMy0&ck+Mm_r?6;~5n}$DjUl4O2N3Sk$Hx5&t~e6AW8P^BUd}zwwofu! z!R@(DI0I@E-Yfs++{_3mJRx#>QJ*UO4nBp7d}g4f%urtdv-8BPQ&&nNN zmLN|nt1E>|rwcJ@B7bBYQ|x{_A{WDB8h?Gy$ZqrTrP!$RbGwi_%rs?8V05J1?HhwS z084sG?ijd4G;!cI0uWa2RYHOEa#KJn_X_7vGb%Y zW@>l2&4*2YSi@Hh`0!zu(;=;&*xma2{a}*Lu2B$6BE;S!}P^C3UJX6!_5pgx(H8qWP2-{=U z?~XB<8%jAMB|>DsA!%GTr8H+*lI!qb)LwgKvgXEDRy~@fM698h_9YRUFSoxN z7s*FY!AyPCl!gZ4A6B4(c$G(c$`EJL$4#L?rJfW%7%EOGmtan`H$scvYgb{JHV&Kn@yi&WKn9ivyA09*Q+qMx5743qJqjOu)!eXS_~0 zI9_+VUs%U*6}yZy{gtMEug4~e0%>kSVa95>_E_3Q-Rhx|e3%pWy%2uWMV~ATx@x-I z!F{QDP+%2D7RS5CuQDoB8aG1Je?qLx_a^VH*AGQx4-GiThWGbIwX~Rg2B)3T;woZP z&UZR>;HaFP4Xq>8{cp4!p&ckdh=Fxa=_0J3{>3#$am_G8_xnRnrzMXSkVU_<(ilrO#PvSt= zWRAGlvslK#!kJO~og*=rBGJFdk}$fn+8|=U3_gYRuA`%)i`25On6CVvjy)Xxtq1yz z>MbC#Q|?*6F4*8MHz4G7@gg)RqK>JJEx-Mci;kv%KFN}~kQ1y&Ss`0eX8!|pHfT3D zC`x$<7YN;w#T8FjSs}Yha?GyTV@R5FQrqsI7rU~sP4!H5ZmrSn3qhvrAGdkt#E>%^ zE7tclIPH$8QOHJqlQ;Z41J^>9*iEhK$WlDWk}7^NNfH{dcPhA9-BhYMQRZoB$G8}P z;=0%uLX5lqMw7`F`p`If(a%U?yxVUipiA66?uGleL8_+cb<<e%7 zwGuWEPY+P;CCwwioVim!z-3vH;8)oTA!nk_22;m0HLu|1 zcLTh!a^=Fvs5(&PS=ZcdqHj)(&~-JGhAcs0AZhL6!TIf4g+*r7N{x2ks2iOqjRHWx z9QbH_&pQGu_r7+)m$+A^!qB%h-SG7CE}+LA7L12k5YhY8h7bt`XzT+@Y-t+|Dby9! z2XJm2urE0@WEHgcv&w&eD)hHDVU7QG$PEVz1yStz-;leZG3g;hD9J*#l_^Co?(cr2 zPPMl7n+s!=%5Mv+VrK>-&`h1A;-e1nrN60%#e+J>?xM-rOuz}XZ)&GsykTu)aH-HB z3~)4!fEkI9%U3OIt3xV(6KAKf8hW15quITG0U)-j!0P$s1!yy?yKdhyc*l)?n&Ibk~JD5c1Fu6VF*qb@H?O@yx`W z8ue=1y+J>nBV8%L5olOt@m59UltR`(CYi%LcRGqq4NWpcUbrQ#GM_62aPW$to@=qWiqA%!?43las?}Mg*pvQH%1_>&Qih2AlTVHx+L>3VgR(kq-0!5&MBL zSQb!{nl-uCD%nmAlUG>38f6roASaC>oUlY*6|b8ChGBVRaceylvUh0l!e5#sf^=Kv zfq^+&1DluEErZ~9Zx8i_KiStakh^-8vGh(wbT)<1F%34<*>}wk+a+N;b~}y;0(nZa zJSY*8$+XHK?bpg?dx-F$7%K-b&mvt4-hD&x-3q!pv9Z9q9`*Soko>5 zOLHlYMvKyo{}OPauYj*YHU69BbSQ8|nP1^Qo-TKbt(xft6S<$Zxw{BBeF^=y9J~|R zxKkVX?#IkjcxQf_J23ZN*xJS>6CV3!#fqd`ff0UIUV0({Ebv7eRe%Iy_hVuTA1AuZ z};0e9z7U9H_g>;buOB2aHU zNFLD@EH{~A>-#qIa$4EKkfnq6#qvOx$4Ai34bIsMNfmKiDQ`yf`oVV>T|>a{`>(VJ zigB@209SSR!{V`b*S5AcF%=rhG|e+yk9~gT`a9rPp-YahLSq5uNnQs$8I$2{0l|M( zUQ!C-L!~c z-nJ+HJ2F9^YH|3=y|ip5tk}_I#1+CL>SdewxrNj1wtdq(9Yp zHSi7P=7RN1dAV6r(IOm@betGo*XJi)>z!U}1T}H zdvH{SH$m*^RDACFDr__InfqkJbpal>4@1+v6=aRYsW)1|&+@UB=4$}TXmV81^Q(zr zeRO)Um?2u2-!SSL23ZlHGNaqrf!5kO&hS0ZEEgWyJr)Pqi1r-&G`$v`K{}b^>t1rz zviJOwB|)7WG?>)?WzTHhtPvwyQeWwC1D!so=FUZ_+x%TucvlcsNSokvRED6rFqOpY zqN+EGiSH_=+fT!3ewsLvvPOZ4r$iDF%xX z8MjPXm~&MMV7+TJy6Ob9qS>|<16BXh6sEl3!SO37H0F8o;!vvRLl&w}@%f0-b!!74 zgbTK!HZuhQ*hO?3grvw`{C!tuQpTiPPMqLHBZ#XQ6BoFS1Y%8y^hRdu%hi*eVZwWv z&7rz@2l(;>12&F9W>}ZmJp}r0-D4(by;SN5>!0aJ1x;)9tpO^LNtbc_{-*_K({uQC z`GPN+g${h8FsNNQpxo-d>T_L;kt9t2d3L5trPpcs02(T3AdcLTOVlX7ezK9EUVGoM zF@a-=WtWMNXMk|+AbE$Z>fJ@>jBdH1w!40R>T#l2&eGL_coel#7G)GLu43XSGDdVr zuv^_<;0~$sh1Qr_og19Yo8r8vOEbEluHK6Cg#46coY02}bFXpM|5fEvaI!kULNErU zXpS#9(wR|6FV&My9D}gFYUU99|*p(%Z~62$3neGAU)=$H5af5 zNgxIlHzU3z8+@iU2!98PKk{buN;)_=m_K@dK%R&)UY7ssm z|5Q>1ZLhR2nA-oC7V$<=9Flbihx`tw$rxe_q-KY9J+$W{LK*Ohx7;YHh=7%!ZMXJP zXcO%yp^QgspUlTiiE@s3w<5;}3Cz8{R}EbUR61&}QXQ-mxHEA{Gz)WcBebX<0D>72 z#X0BQTh9`$Q&rG%izM8|ugolh^EP3(wl4d&TCOd{)M$(M)Y3)=d3pd06xL5a+}-s4|3+u5UH z3bO0fzsV0Pw`-d=(aMP{w0kpa4+KNK-jCr5-S^m6mQPNkP<(zup;0^+kUCQk*?f8A89c(#DL_H93LQEmZzM*wFA4fg7Q5zAiqO5Ijm4ei!{%N*x5I zqzQYyAC*+Ucn1uHq0A718xP*DYlAg(T6F1T>-4V&^|7IbY6d$p|N}=@$cv}yDe737YR)i+u8?hn&X7A-?*2v`XD=I4fAVX=X zOJ;r{@Z~*UbjHdHeRU`PoLZv)d)5}*(>@aAUyla~LJ`qxV%?F2S%g zvmT7Qet1Z9u@S9~0Dy|u2SWWbtu~3|pYk6x-=L;%Ey7aMvZ(*m76}oNT!p#tMldIsl7#%NO3hZOkNw}t!nD40aDn%mnMX5jkzeF`cNk*&*=mIlq) zjXC-12KTkfp!eti} zpd48!$10`uvWapPi_i{62K0ds{E`q+59dyri~b1!52W68OMKu=V;CPBq8Tqf2 zx4+!3xt%WcMn^sP!6YeKzVm4Xk@{Uu3{LHRvr_tYEaMbK@gs1>m+q@%+uOcJYt<1C zU@#wD2?sgqVN+965$1#|XYDG?F3N4YA07*3@3RB$JszTS%sa1$++kWXiM9Mj{nXs- zV+1opHMKQMjaZtcr@+v>qY`ylPF=!YWF`SJsp#SnpWWOa@;(Wc3<-7cns-2lTb?-w zkEW)PO@$V2UA(fb=`t05!om8b)9>A>0=Yw&HTU#7zYLG6Y_z+~2R-sL#~o3-%|QVWN+2_TEmi;$gb6#tC`0q@cGLx)rU*pNHxe3)X$k0bRQ^vJXKL7H&KWJa3BC2%t;W?yy%tg*iS|n^%g)JZGy~;@KmPrT zm6>JG(9nRFXNM3=MuLc?hPs7mPD9>^1`{d_SebWia6+IWhex<(LX(OzJyK!PvRz#0c{u>%-y z!2aWcr=%H!C#Cxs`+3iu#O!7YHdID|j;BcX+&NkR5i&s+P^xKgGFK<@OGURw01?K? zi?eQ`CHah}zay_@W@Saz;mrOA7s{ZVLehaO(?$A)M>Ni~mwLp^<-Ejy0J1?uii6o~ zNa*ikT|Lbcr4T4fTP4f6xm`~FuW7Gn#`%g2C+kR48hp%0jFb5u*V*0Eof65gx@LJCki>Wy;rl{9GZGMElvSBbjaH4G{de zhsql2CyM5Q@wd@j-K^@I9NPn5y=L0WsP~2{yrXd<^Llg?u3f*60E)KOcS~VAT!olIwSJ_-6uU{WTRA9NGLdp~$`-Z5CzggWB_9O3%Jhv-ztR zq-3H>N0f&dwp}0r#JUhWx7-})LFs>7EMiK2tfHcFhajX%^pOIBaEQ{a%wI?Ib47E; zVEsig{c_?ecbK4zUbD z^zc~t&P(l8#DI01nfLHQR&X{&O4m%gu!~HFax}Y8(yYhj-5*n?KNlS+Em&dGp`nii z5a^Hh4xZ-DNnwWRB?ee<`o4QA6ME>-i$Ejxg~zo@anzzA(mYy=r~;Yn-&eoUmg^)R zlPR83@(bH5WU@^o_L8>3<^aqWdL~~^eLKGOg^~@GYInkS?@@;eQ*q%c?}u6Xbmw`) zfgT1I@1J8No_Hf3Zf`JH!F zK25MScI7PM{1ath9s~_&Ta%_#{BKY%Zb+#OX}&tJTDh!Mcj~&h#kj`ZufWpI4t>fR z(O!%N%Nt+9^21{wTnKQm9hS4b7qlT*M@GzUh|)YLPw5wYo3t%?e~K_fQhzVz`~>^w z4|`ZNFiwOmwDiO%1YiI#!kqk&a@Ih5oXb~r&@mC=@Jx)*PF~Y?As7NCc>BR+l<3oa z>%@XW`|fsi-QSE8Yg0eQ4^}!u#9ha2aVW+l-1+RTnitk#=+Kk*6Pe5PZ3wqW@YoLf zyDyqoywE?hbMC-EprC^n#1h#%tnNAdBD~qsVs&{n9{^}#455bX#1!M{$qWyKb-I=o zsmGM1G0g4ZcM>^obhfyB$y!6^n^zGc$MkAyPso{3OZ+J(^w=eFdS_D4wIJxnW8RFb z3;%iQF`xVLCm1B-S>T}M3M+9?3c13?$E$qpkQBOfntT-ho$y1|BG)tanD-%OB4VYU zA+RvPwy!e3Eyso`1VnF18-->)IcO3Y#iR!fGi;&p33>P8%c4=$=jC9Ba8W1CfB;%)2orr~bkz(lPt_R5pIdKKfn572o+I zH!shSaB@#*V1IwV(~NW1z5H4#=&0dGWUPF)qgP%2lHAs4eOftSNwB)iH+ybfoW1^z zX$?!MIw3*UZ*M;j_1O_#wgWmXEr?=Wd=u3d>LnDkNURk$9JHj+-?*mBdVhaGLqy_p zI5`CQ2sF(ijG^*A{wDIL++wCcd<(&~TZ@-ve0}||GNk0+f(h}N)pAc-qB6uHEfY5h}(td&+ToFX)if>R*Zu=-cKQ>F3D!Nv7npc)_Dogl24MVgehX z#GDS(|7{ZYu}8Ez*hL_Bo6=C*#~t1D#aZN&GLHrUJd{rjre|c2{{j(0)z4g1MLFD$ zfBm*c`aLv4FhFWFRslB4UqPVs()H%e2A7nk9v~3OT}tYvy8us?R!V)9#Z4Mlkc+cD z%~t;l*ZIMO5zzN9h-BA}IgiHtT-RSHC4=j8;djf^jqttmE}uQrwyh+SzGNZ%8s_)j z%jQB?T8eZvi?t0XhkE3F@TD9pzq+`-!9HIQ_U6NC8=a}i);+6NzPbU3sA`qNqmJ@$ zqtQ%)^yYFq0@o0b#XXohu@0?h4|>lX?X2Tyy)S~SzWAP`yB{%tS}tT3cWC`9e4a2t zyT?WvSjB&Vm8#{1xo1Vsg-x%u$E!IX^%t_)iuZs##g>?3HuJy$i7YNUS%g!Y2b{Ba%Cm)Z@Rc@ zO33yv7ObCZjvDve_qd${l{N}&rl8672qiOSgC0_N4DR(+_m1yyEc;<)tQP(*Y%8B8 z(rEpfu<>yaVPzq+fAZ=N{_lW~3s`nPN=z#A(YD-h*tzb;O6XjJo%*sBW5chX)esW( zOL_kL9Jl;NPv2{3{&c`nu+r8LsGB))!HVAjf5zZ*!h-2n8g$a4Buo!%ReI!*12)rN zb#0s9_j(R7^oaUo-mReK)tQn z*|{s6tzcc0YiFNQfI$*i+B~_Y+bSFqV_qT=#=uI=Yv9KvM2&mMgn2GK?iHFfTsiON z^SM;;$!m)QL)8~l&&AH(9ya1FBjY2AeUn`A?n-CALm0-@Iy#i_P=DD72vibZz`V*1 zfHTz=^p>Mc_6L_XgUh#GCnhG^N@K%^0oCqbLoc6`* zWw(w?Qo;A&1tI)Pg6ysxr3DM|dcE}6%;9(zKyZuCg@pKpSZy##a2}?^n{(UgupONG zMU&oH)%rgs`An`HLa4%0lx{X6iNjXiql+goXPfTP5pqVX@L3xpe?_Tq9oKW z0Ve2_s$BDlkfxS=Inhw;UoZRRm8KxU6y;aSTL5pQwLQ=RtB#wo1G~-=+?n$E++z@I z^Dut!8IzPru%MncC&G$y(jkwv#n0^*p@SYx#RXP5K2)0X!K4rsmG~{KV*Y4YE%8Dx zMGu4pK|uPR*J&*U)00qRp}af;;~j|&MQ?m zU|Y8CgMIKX-lHk&p&CliK5nd!ty#e*fN9YCDy6QaQcc{UZc0dSf}YGvP1eQmnQ50= za`I`$*0Hj?+_$&-w{Co&^~V=`hU@sv7?Qq!@@0b_J)q9>SGN?L5;(S|(5k`lXaq{Z zbyq|fH0xc;m$Ggyms6IA*gHsjAKMEx)F(H z$@gccvR?a^PVL5sjrPBT{vN9Qef4ec!%ym%`4OZ3ieX~5wBfTyRUfb>9o}IF6QHe~ zO)mpN?sxe6DY5X_c+!%(KZOEy95R3_8~%pd#U0|uxTrsRC)5D~3NVcvcnXt;W2V!N}sazOy)9vBwuW1y|`V)ehv6 z`RX<>2+;@&kZs(^SetkX6%pcT@n$Wxq2EGD2^9Q+Ey{u5rD=*_ads}Ni#A7L&wl@-|wz_*P6fcXP@_+v(K}iuowvq?v3dVxU#acLdC~FZ+m*g zb{nPl8P{u2*jKnqB!Z*Nh-3K?r8sy%6}qdbt6HlfZktIF3J)%qZ)e(XZ37;7b!_cu$P6h+q0LWp#Bd?5qvYFO{;QAUgni3(I+OZGlMCyXB$}l0~ zi*s{v-}}s-g0OpTKl8cL!RW4KLvB3?J&ERb-?xp!u^lkpD%$=)4m7eqJs!3~oh=J|zq14oh6Nl?fkO|1bhXUmuui01 z``0fcmmKJdLVEm+gf`9gla^xK*2g1-NAU}fOH$ZF9iJUVReGK56{kY^S=&3Aey*gP z(wjZ+=9aw#_nJ(!KhrjqrRjNBon|$TOc9o#?@Wqy?1#W|Vmu~3BW{Hei!X>?OV`!XmkXV}&G@Z> zXVLF0AA7X|P}d(WeQ3Houz#{x)-qN6c*a>2a@?}wc1T$lgg2BT-*msuY91hv#cH07N?3C49lhHP|l2)Xipl? zD9U>MOsLuagI@vTEqD;cZk?;N@@{Tj7j={ho(Z*JNw1UHQEpFH6+2yfl zY6k-28?um=usE0)-p&2hC0hQB$}JaNF)8=7p=cT#EnS}>_jy=&E=-9uvqZyuo zdus*#hZenroxR=o7IzSh`M&!L%1yx4_=^#|YQXgRrmFGJsmHW<&t3QNR<={^pSqz> z9vbk_Qs(Jam$f+VDb}GihXB-AY!uDJ4af&cW@u};C+fLuwel3eo*UKAK}Q4f1?D&v zi=yeDT}lI^H51uM3!$MmJ(!s10{IoJ$1F`M$D4ukUXBhL8$}Y~ zCCj*SdF#dF;av2|`+pC;QL4$xgY5eJ@O7V$<#FG=q__C{lefvDIku$$ZDG()%w!{ghT*iRx* zQO3s>T}BKUc-!4k=cxhTqvxb7f9uw9lXs@d-%Zg2^)MQun59x zwom*t4lWzp!31YpzWi+NHF!wDVG8_D(?`6lzK_~ zap||wzr0OK+l$~#cC1?YZx_nZ^~e%{0g>EMse@rjOvCQ}_9C_p;MQbl`jM=9hWI+k#eb7_7dl>&3BWKr<8k#Sk!SwXUTN5TSw*}`-=oZ}KRV?wcC(op;J%{_V;*jO&I&9BpOtil7?ryZ}%xc~ewx598 zsLp?ntKno0nV4t1@sXatZjshHlG5}1>Ug6!I8%r@Plz8S*-%Y;F}Rm-R{_i7@NKf(oys3cxAz0%; zf^b^g_>dw=;?`a()%ztv8{d0rbo_cMyf?dZ2A`Xodvl)eiEDD>stMFo#XK}W2#|;- zr#_*;Quyr%n%VKI>tUVWH#1EnLaiEPGPx)tZ`m{VX}i%6KTuc;x2Z{x^xsnzMrY)k z1J0`~5dP`id#Ycv`ybQ9zAjFM`p^w`fGCJ;$amA)CLhtqjZoKwNt8EjT!n+k=ACXtEjs3?W`3tloB zG(a-qP8M29|RWBU_MNLXSa`#p8~}BU<7j zm#Rsti%}`S*5rBFKDQ6#DAc|1;V;aG4_b(oYk9NnG~C-8YqRzL!Y;9D-%)w~obnB- z8($>8Ky!k@A~{6q?@zQ$vk+ZF=86m+?yXUJoE@-mxD`2M4u_liIU)k>CXNtXDPxmR zB(zLVi_q)OrKAH=SqXSUHcDQ|R`r=)*SOq|pst2I1zm4q%P>jUs*4KUGV1zQhHb;% zmCf~k&A(uM&>J(0yP~JY#ocW&<)(K1OxlPa@9XJ^ zJONNkPPCE*LyNrgd6_fUi)ilgzL8MBesQ8|ZcD>R3NfQz+O(_pG@+o|=bwBytJd_( z1@%AX6c5bq@9VXS(trh{%^7-6n$A_vzrn>%ThBYGL1ppd-{j5mJg43NeNpkn!ZLS= zgI>GPc37!C*kOX3fA#T^LTHmjYPx7Q&skY_$*dHV~puuaa+=M%`?g(x`%+0H4*W z$QyxCSuBe#gfXt?S3XRqL~~64T96bTjP7dPhmW`O-lO_L*#tKy)n@&z-S-H#hsx0Q zwa+Ny-U>R}ts=ok)zG5>Q`H;%c>J`1u9dtC{bp{@4_`U(JnyDJz$gF)htrRFetU0+ zJDJ7*mqz8&bbrHdlM~2+o}AgD5L;ZsnbNEsKNOC&>SBneNShnBgzCo4TkATWZOAzM zV=uUXA9C0d?rDhSUfzKz@c&$Z973>9Y~R0PI)qXB14h!him}lJ`l(vc1kdldeJsRx z(IFx{$X?IS-nXEc?a40;MGnf)O-{4AX>n@=!Da$Am$6FYl>}<>HX3l|N8a4{Eu}^7 z!;7M7fy&J{7QNl@^y~OppNxt`>kDOhXZ@xG)cO!7pS0E3%@>+C^9NK%1{=lA)be8E z&dfNps_iqw^2GcVaNJ3pVeZeN@6XktxY=VH;l@*izPYRJb+X@ky8kwHXe=UJ9H)9s z$*4Eul`YCt|12(F-fcBqtH$}(Q;4gkwmR{as}9x_0zA~wdP3UyzW zm^g)hJQaoCvqsvm4ueN-}q}i9_k4;uu zA$n`1uT3s)Ve--w+M~&(J3ew^*r}}DgF)VP{{Z&D<#D^EhmVYoCTfCB&z5Rgx1fqlWfJ`rM#>er9=nPX94;VxbQE(K+X%XJk zL_5;Dg9c8fHlJwR>bWt%{?%tA0tdtbhDUYOh_u1`^TiJzJ`99DcM=LNo^1+;cVDf= z$Mf|V5`XPmefj7RK|}kGj!rduyMj$>zHb%nr}aJ7mB08T&#qzx^uLpTTZHe)s6Urk z|nA#i*$~Y?r zy*2=)7ELzp)Tydz2O;H6^JPFS3ac>S1=*UzUui~Yc2{C?TXNjzZoUVM&|2BqJ#oLy z7p^&kD$-}bP*F8UIGx&rTHAIUSAFAlf;3j7z${&uVkpc( zD!ga z=s=)*eHZ8Cp|D=Zhv63en$KhUlyirw>OQajxcnq(u(!EoW>55fQLCw@VL~Xs7X2kB zns-985jeHbTOyAD&q%-b!3eF2)wO+q+@x8iGdsq9j3SaVRo8KI?$~F|c(+7L03xhc z2EH~yzWa~z-RyA%xR7FYh18*6f(@fSsWzmDi~Po}Odmrmq_MQ3E~h|_UbbmS#^cZD z9~qW3(*=49GX~SVsQ;Cur7^(ZlwO9$_IgsBjA#gr>!b;<3EF4m85=lJ$5!Y`?BpOu zOi%EqCC2ZvSP+x7*QLo7STMkl|9#u#`QrCZyvekG8ZXWDDv)MGlYDKPXsbR?LB z=IpIkE-2K6Cn&$F3CztR`INnN+-!@62MOr%)S&Se4kr!gVKQG``Bjyq9DooRX&Xit8rNaIP?EmKFfhgXF&lT~vZNN2`xl$0pt1{}4w9rxV* zqJ{knF^)@+WkMXeJ}$Vv%cSHVaos`j8J!*#3D%jty@BT^&zPSvZr-$cwhi*ey_lSy z{{E+&WkOpk{FI(WCqlXNJ9~YX^Ra>$(PUcj)$pnPnBfMxrJq=jji%Yq3kXz#Diad< zHULv(wD;LY^PIDFrI3jC`r!0G4Gn{)W4^oE78@BvV7Jaff_v7Qs@r}qu?FpWguI2t zigUTj`$+C8@hug_hhHqo2QO8(HD-yusZDBNynQIIF~A0-)$@+AFJ$ilu!)LG7aJ+2 zdGWK#r8PpoD$2i`VYj?I;IK;{6`55*&6QXGgBGEH%6R#%YL6~BL@`02d-^&dQ0j8rlC+z}S5+N78VRR4HszTjzbU#xoXF00H% zgh=283uA+24+&J1+{N92cxR`tmpSU)j2Y@hf7re=Vc{EX|`$QSr`=! z7SitQ-ktp4igrCcr;QdzQCC;r-BWeQF4V8WoJe$24+kTCF()&Sod#ER^X^1zkBKBS z6E}Ds=GD|N6p(erQqFpK8}WY=rRsT6rivB6{nR~2tdFl#4t!OwQdjamAy-+d9t0!AzFpTbB0k)kLa>cxROEvk9UWUUn7^R_2Y^X=$6S;!iqn0j zK!ZWc*@km@UG>E;-{p~_b$ej}0f8{(V&)q2J*Oh~s112NkZVhJXduN4QSAPSe&ivn zGdWr!nYp(ur`OF_(uI7TXk{PiGi+^pzta@up9@U2ScAHF9BQY%r zO>(q;QN^`iuG=y5c-4>I`(O#RWOu#%)P&jUG5P5_xedM^fRxU+)>WXyrlWJn-uB5y zN&=1wtj{R;eG)gS-QBc|TTxxq4&QB4F3!jvhmTvzh>P!~l?ZEq>g>YKuKihd0x?B#P>?;{Po=H9V?^cA%xeC*?qLiMt6itgHutVn8 zcl%(9LHtyO>~Z7&;dXfeX1^1|{omY+5+Rj2y)8WZ9SS5R850S((Aj&Jx_9fq4C`oV zUILkit&Ou^_4`^vb|1L`!j>@lVmCH!DbFlp(;ukZ0I3ZUGMK`A76RRVD zfr03(=aSxZRaUhnE|FF)YDZ*8zaLRXJ2xI&Ry~iU7xw40#pqIUbWu>W0&eH{MMO#@ zv9W$xIjk6z+y!KsIC`t3_HK6JpDf2&t{-~W_;o@`92^fhYW^m=7n+h``gc289+ep> zQzWH*Pe$915J%ykJ~$S{f{4fb)MPxI>^wP7AO2|`b%Z{7S-dbGis3p9hb^>5hX6k5 z+1W&aM#juz0PWyRigA#sb~5A;WMFa|cLJ5~Udg-W<70Xk8a#l@7TBL)r1;ojy^Ipo zVT69ODc8+LIa!W|@T+|t#KEZ33T-UX9K907LsooNZ9861O7xD(I`t{koY7;Mrh0B6 zb?L&CTJhPMOmxq;^Oj*C6`}o z2i6M!jxR>*ZlhEnt*>75*Ger}89rD746v^SA27)ug8=zU!t-#D&%JzqF|0>tZJ7hHN8pk27Mb_RU--sv1MyzwqgL0Xkm zkjMJGXnntCH%uMe&17!Vszbx+?tXiYH891 zaL~m+ZZLY+?(_ytfzc3Zf_cxD(ij!fZGrH-`l2I+4)x0Sr%CwWhU=(CR-OoPI9;>L z^D*5T(##MCc!pcGZWE>d+&47LAHoEJGBtYp+S^e<)dOT*eRq7_7@`}2=dopJgyiQr z)pn0Cq0`-B1`SJ1g4JATZk3Xy$3LZ{T=<*BqsWZYo!tFf z_j$)}?@}P-QT9Vsp*INIg-C?8HGeDAOcFA>{7f01*hQOW5~BF(){6{e_4Z3FcxiZ8 zsheikIIlZX59e3czmD+klie%qe|cCQrp!Q7bJ^lgPY8|%f)tV4V(W+SYK-0gaubfw zFe2@t)X^O%FGUi7E9S~Si0dIy!7MQ=_NTHc;xdR+!@uW!xu~{}nx0@O1FL~w#HPg; zJ>iB2-F`yVQRebFL3v3^JVcA}SY#PFtLlrN#z&2OWZK_0~U%92Smd}3^@j`*+ zVKrv?1IEy)?Ww_OkuI#}?6UrodX(zay`RTxYR%3b)!cwFY};54PngbpXYZAtuXzWWZ_%a&S=(dB{^|5$7x_(NU5{y%Q|pS2>ddKWy6tR> z9hr?dR)nLa`A3|OF(i8goZ;=X$Hs-`WW|z3=IdgG#^1S#RIgevj^F};iMMqIYec^r z?4Q?h!o7`m>UUOK-8R(At2Doa-Po6-W4>Zz3!!U6vBdcOmGz<0F;sC=JEXGcBZ2+v zofmZ2s6ewVCmTo(G6<;2fj3zIM!Q!Jd(DY*4=H=p*@9xf#6*E89y()LV?jI3X5A|l zbxm9R9W88v+jco{*y{1sKTa(dUqFJ=@I|=_W4*_&O@qq%lzMMlEN$Vp%%syw_JAuo z|BNGbPuqFCnD?l4Ge*^p$IDM#V{}nL>Oa;^tLhRXgHMMkp(8mi!ZW2+&lyjLzH{gL z&VCkyWm?W-KvM?DFU^T zt_4W4jv^8KB>aqGgoplCGPPLY#mRJ-bds51i6c2{9?-F5v;`z>N2BD=C!ZSA1hn>` z5FC$@r@k;GYWJE8OL_otW}r49YU{m1l0fYQ#uW6Ug7nYmJAg4p1Sm^Q2DSLnc4O!S z1B!V*$NYFtJ3IAJG2#Ru-@n~!DYfhd86;-WFGO|VYC*werOsrC8gFa?=C(>xZ}Rh^ zTCO6=0#o@lO!vvqLS&sQd)b+4h{{gM#xX!?%8I<=%07#S;%IcsC$7k~8;7Of?}*Z6 z3NWc^L-rHLt)}}F|no;kXEeL*D_Q}!BONRJCG_$o_|4ZrM081JYEuMWPm?8*L7MUNi+zE(sKs^BKlYF>U7v#;|hLP$905{sQB z!t+_?vRg^*#<92>Me;EaGva0Lf&uSg+aSc+I@A`$M;xWkS(UGxGWz`^S&Z?NMcW-^ z47mrRM3obQ{|}goAYBS9&jGJhg>^U`@_u)>cux&M_3bm4h2%7+qkp`krgxpeeCb=) zkDW5R4fCR2Jqf$n77nKT^+6hDdq~N7kN4M|uK16=#0F<>9q6z3^`FFqaQ~|LN;257 z__4I_soHc3p|?C_kMtX9`bDdpRjnscA057kPZ)9VCVJaxH0_XeYH)M0)Hgy&(LFTZ zf#(IGqf(btWZLxRDL;3=2|9i=NO5`>-ij)pu<;ho0>^{7)?vVAg10!t;1=sq> z-%{YmFxVlY%Veb9U}u9IF0Am3sfk0xTj2$a1m&HB7~2w266b}F)ppYRjkX=p(n z9v)W^2!w$N1MDKN@u2kH3slt8)#YsV{N@XB3sE^SRuG@_FVM8PRgw&CXk1~>rwM&_ z9M9*O_bHrg#ZXP?o5(=qt8go$()$To(W6)T+xBds0tVWxC0?YGD9jc3#mLVD?U4-(j^27nDN|y zCz$-C`fxHxT)-t1i>{19kMfGGv$e_^-AYr=*1}r7Vl4~nWxXG0=A3TO%A6V!Ggt(X zY6IE16`4~Q=z(T{ryVzHn^3l`xr8&EfXl0;;nT??FisQa zlOlI*JK>3?Rve$lM)k z`R+|Ln4f%EYLuBho%9EiS#=}ZyG^>Xh~hKWTtg2q|88ACM|O=1DQJUkZbFTN9JO$im(-?9~Q|>QH;w~i+YKR4dGbh!GtXnS44+n0x<<-p29~@er?@# zEqzEup1yDfE6BOGs#!j$Me@@b5#qqL5Fje=E1EGeql}1=S|h@|bn{ok?Y7+>9-`&s zf|Sh5Qaj9kM-`c}w*Dh*4z~qaNE35Tz2F46_BY4FdwddW+9sa0>q4zGQX)Kr7$?Ta z=@NCm!Grtl47V*z%Gpt(``biRY`0Zt(%_TlSyQvWsSmd=QSGB;pJvT&nnWIK;_cx8 zRV_%_jlIt=32;q?9)<*ImhdNM@~bBrM#c)bWZz^d%EgmhUQV_4?JlR~2PctlF`Tfr&tDD}4LC8yQzY_ZJ#EKO* zw4Nf(XnX5o+W7R@uRu}Maq zGKFF)Y)m2w2qr5#jwlxR&pA==_xU2CGiTURumMyt$kBh?U-VnWq@OZ)TQFT;-6V2cg1| zDaNZd=xOd(t=HOZjizk+yDz2`;3j#LN@1pzHuD8wMu9V(^yALsN0RlExJ9d{WX8*$ ze&e;V|Gw0&6S_B+mQtj>mX^;(wZu;`x*oek_0Ry|Bdnt02!YBoDnOULEW$#M?i(k9 zq_!`fp?bcOSIdkxLM8Sb@nFTenXiHw%{|IQ^TMv(LI=%Tz}7(!!bwX-XGw(9jRhBf=e~K-JpOz} zk`L$fBqBTMFEn`P)OY$gzZxE~f6MwanIgm6lf$E9&*xLJS{Tya(*(Gk{JKYFAKfiZ6{%Yt z4O&+Y*KvXDB*o0fIF7gDG=ZLgC(!8lxW^8tEJr+2QrPw!B3>DJYqdfY!DXT*!@_G5 zL8Fv#a5AF3Li^zK7`L=$|U|1ig2c;Wlq9e>RhXB4&jUX_^aK42n)R$ zz&S){kA4b*6erxbi7c!)NmK;JUK4muhw0=8a8CPf8)qO{E>LQ);?t%w0|WV*uYEZwXHib<>MuiYyct&1Ki;n zFrTs{mW}h8U(Vii;d>`0)el1rz4{V^bQJ4oN+awYM4D#p3P9UBVGTC3$<)kifua&gd)*z) zs=sUH1iJn9EQNAYz|58U&z&VUAwuEZ6?2bydDWg%anVt4&lHtT-Mo;EJFJ;lU~)2? zRrO0LT8okXpst;^3cPZ8ud{w`+q+(OsAgS}j?KewgUliO!^e*w)81i_mes9O0-Psg z%DC!VM6+?tk1gXhP^~3qT!o`$Fyc5bd_u-ItL3tV)y?h;m1p&i2M0Ag{l`SVJG|D+ z_fFik3CQAG7#^!T`LD|HPrEOFIcD*EQ7oT9u6i~GI@y0-EPSJt2>XXzll==6`QWLF z07e;dSs?Hy4+V<0PC!6nfah~Fk+yAio#(ba=e}^`T0wwlYMOib-u>b(!cuWxJesh- zD}DaAOG`>=MKv&IQB-SoA%j8M6|EpIxs_8({U>u)$rJ2!;iKi9Q6_a@NjZZUPx-?V zV-N0W1AYH0So^#3Ia|lIyYWIG!Mf!O6y8TA2e8Fhc(I*vDy*juJ&{!eP~fzlUsBNn ziAo+OFbEOP=(N5ZU!FF^4J(YNcX07%OI%mM=Qli)6DB@%iNUX1}nCN~GFm zRi;zva0gIDhiv8vLBIo=be*g(rQpu=g@z?R6{%`B!GW^&OruA63>_Q;R!x&>aTYc) z_EU)C6zz=aje^14!ke-<&2vGWrJ-)0qrXv$PgDE#|0?M!=L2f zi=C3JuP%Cpj6SPLCa+#~OoS3M@0gaWd}+{@p#o9PEk+AIa2C3xhl86*FQj9A2gs}5 zmCrDE#F~q1ntlEdEk=>r9_kziXp4+_6rHD*303Pa%udegwFN01VwIKcQ3Y95x24#E zF5OBB>E(CGAZyW)(eFpyCx29K9MeVKS4Q3(KlYYwrxKfDm2=o_^2d*oh3e*1RoIVc zOZjjwMM=92c39$F1ejeov8B}r_a?QmY{Aq=@@3yC!5nVV=wl$edB*7iI3 z57(PM8O0B$TotB=nwc67Nj_cHh`DXt5@vpr{O^1|wR@y~{@l!7*OMjD+w(b$I%zY3JHNI!{xF`Gx<(DXS-cy>Zu;`$MdNjgc`P*my`39X9R`j}5c>Fwn}% zXI+5SnhH^5GH^Lw?{=E`>7}qHqnZB(z!I{~x7_S&IO>-{loOB<%Y;%98UQE0KV=!6 z2@?nKOCZgB>>`<&dwUI z2#Ul4;TE(+*o`p<1Gy%>xmCmQ1dz3NmG@#|aV{eKAxD5k2Ja(Wt%R&9-BoX4Yt?vs z-uSN`gXezsTRu3Q&$=Jm<56=6+d{X&cEyUoX*UYW3h_!(M$dt|O|x;IW#Yc3(yuRx)#z5K|>Uj6~t@ZA1Acm#3s&cc4!`$wI-LNXp8stp2_a zx0FhyYJp%a=~?7Js@t_R%rEKY2B~GBb3SACD_d$Q-0qhRr0iJJ%-(TtmyIn`}y1fPrHkd-m(D3~V zsliu$nzBqs@SkcCkecJ$Vlrwql8V+zTdxvMu8L%2WnF9T8Yo1C zgy^qjcAn|e%hTxJR9MLd*?uho;PCFQS}Y`B63|{NEHnhH27n!gXp1yrY1@J*qj)C- z#q%~dfuVG#0XBG%e_Gn7-?`9yx2-bNKX)k85lAB!gD#m2k!77P5Q$0OxZK18Y80VL7Xzk2SDAd(8RUBq{ku#?}9(!OpRS_0gw z&G5xzDyolccEJ7mv;Pb9f?HwW133=L@3*ubmDx2s=k(o2F(iF_)%>2GdQ^kUhq0Z8 z3B(?fGZA5+)|fM{;Hs#OrKay&QLS@lMZx!{qZUTlB-6R6`_yI5!*4!AsWl3+iv}eHS=3~ssNq%?!H%snAp^9uRTWgXG;n>pp4hNWD zEsy3y^F|h!L5aY@v2gl5PG%Wx%uR8!pYXcR&E5P!jWOrq`PBS@rv&|^vC&imRR&0! zUpBe-abj_^j9A8|Hy$)t9N&ebQ@429C>tW)Lf@gGwuxzZ7z(5AHJWXs;bfQMSWU>w zk>ca#-R7wa(y`_51$GKF6Uu--!u+JJ6^&|{ON;C@JoQ!`sd-NaVz%L|*=&y1|^Ez501gb`pgFIvQS zcD{S`(Hl{I3<__k`aW$)&ay{FX@x2MvVGo;xGv9u@PBK^mx3Cq)csIfnf)^upy;B}!G{9W-~kGm68dDf;30=n1PP zgb=701=J|X#wqj_^aF(;xRg7sRl>{CVS78+P)=)tgg(a*-PCZqlEdXoWLM@p13+}9 znX>=wQpN5wzO4u_vE zhTJ%=f)~vqHKYGA>veh{mFf8aeN{d3_ot5?Il_+6f2KY%xw5v+`RArE!0znp6(2A6 zW-gx9V~>`3v~`lCvPl1Jj+3F{0tph2>ZkH&j`qBM!$BdB}t6G-?#mohBeb*Xyx1@J{aj8Wkzu5D+$WjY7|S;|7V31n9{Ph=O$CW|176M z=Z=vib88RG(k0^c61_hxo681!PUbolsdIcxSpQM#SPm#E`Z_sdB>DhT;04#TS4V9P zYC8a+H_9H0N~x_Zp;!B-o)G$)7U7q_e|TIOE}_S>vSkn<(S!#KX+wrC2fY;8=)Rnw zkYevr_nD>nmY-VQjt+>O7v=xpXygXdFt_TUXN44feD@RCUC^?UP97EB(HTxxZQ&kO zyju^Td3#Qe&kr?e9XITo0=cq?l+#`3^|utBTt>)jsmSQgv0g-Ko4@a_Sj_5fkM}K#M)T90P*ZV z?b)7U|7d z?|ffw*DUe3nSyZdtv56H^&*=-_T(Yv@6J7l(DHRU(k-rZ3jYr?pxd4i1Bb~Hje=IB-O;Y+f;vN+)Bp@VeeZw?j9>9wDj zGT@)+D%K5D82x^v{O5HMt{w2dN!nNWD~|hUaAr90mg9wVuHkm8*U;OE)hRKj#|BM% z=ASprzM&U={Tukpm6nD^FlBwwtLej$JOzX5;ZKF#K$jZen$z`(43Udp4_f-oERtfQ? z6FW5J8yX>4V9uf=0JHn{J>P9>xGTNil;r{^B)d;`?BjZ|95x1DQqlIq&^J zEu&Ib0nAJ=Z3y0brIcImEfQ(TM(ajMa27;ktc+(J;lnezXg42FSP31Q!Nr_zcf)tN zhw!+Wpdgcyyt%V``F|6mqvR~T9o4p1gQci_{G$3JMe|3B7W~iLdPLYd=I*3V-{oQR zW=xHr*4NH4IkIe-Q1lq$5B6TaK)s8r5_sgVKW;3qlW>@6nS&%$#qiIy9G*|TeL*rB zj)`CIvGWcH-(vdueh${r(LsO`M`Y&v_`+-sq$x(f+jpQSonvd)W|nR% z@=03k<=T6hf~T26)J!oV1$rj!Lm2~*9kk97`!&f1HxyEM)KN=3An$a=j_lm`4Drh$Gi$j5j>*O9A>xonmVakPpE$Eq+R}uNK7Vn4m-eGd!{V#X3VRy7 z;ORnEV9ZolDpLAcaRCcs=8d}fQ}m+sFfJFwxBc1=VQTbeUw=QC!?Y>zs{Bj7%fsWm z(OFKL;CN3)6;b4xoqi1@AWcY)_skiJQ=oON{>miO6SXu zEuI#&aN~8k{m0|MaHVc)7l2K{Lj}SLLLt?sxeAQ200N zJm1W|r0l2C&ffE;bY^XngWm7f(E&@Dfhm9C#swII;VK=yK4R9c9 z%P=l3FE4@2rN20c0n5)k%i=yDz6>s9Q($SV&p~!`G~qn;8=z@Ezecz5BF*3L%K2yv zf5;f(qP=*Et*SUZjjZxDq9eU8f75d>tCl?xIfU6HT0ZXx{M^j6MxG0y4?V+NaUK?& z<&RfJ3r0g6KrQ)ww1qMz?_kI+?5le=Mj`A`F(%3{r>aoL;MSBOX69PHy>}eLDlU)g z!H;tRVqM~YZk!ely%Ve-10HgouxO{(fAK6wqe&sTU1W!Hm)g~h{DGMzG+C3jFK@$J|U4RxJrfHEPpNDt0JeHFM~eyoS3d& zkC|-##6hT05QK&@$#2(Nan&T%cjAO~K>5)})~6YM+CF%823-kbQoeqap`I*0d%@Jx zaLzxvK_N237SEV4Xl`mvF2iNRnKl6Ikr%oPR*TtOgExdb_a-GYC3%?TWpf-oOzAkp z5gj2Sl9s32!xnLqtV0^OyR@&JeSx?DcqVS0TlxOx6dXvKw4+4;iBcb$TlD44oR_w> zJO#_qDd<#0Ax=QY24kIE8uT|3*CP z3mdHb6pr#b3{)nW#3HGWhe$Ui!{QH^PAr;c6=vHSP;J42ZQLyrH~3FEwsTh*j_XE9o)$fSOuWd5Z~x4n+Hm3EsFw^ysr z_p)x<3LDajH+VPdMEG|UOe9*ulkuU2EQ}xJ*WaR1f`~^>Bc#+z=n}MOM^NA7P+!Dz z7F#^j(rV6-LsnK+6riueZ@(+W2UBOcMdk?pe*Srg66F*{qkNx#u808u*3@6Y$PmNd z4LKXYAWCABG!?Dq#`l}sLXOz23-W78!}aw6`5n<}Y}ol5G5iKpdBE=VPBtdC5TpKj zQmcsLC2cmI{Jc*e;k8JfO^6?9=#ekM{8+*IJ_-Dc9Yu7nUt?x9TRLZAdn4o$y;{PZ zeCUM$Y4mNIIE2pA@1T|Yisx|LGFa3GiF=Q;StYqGZt=Jvx;g1NEvUQ4D{Aj4vbQ1Z z_?({DF_Lzr>?}YuhEVE$Mf8bW)|F&ZOY)e2pxU^4Ez!5;VC~_yH#iFWcn$B5`F@?u zuf5GDW3Xkgb~DQpRN!;9<{JX{SehyM`kQc`wmqQqH7@}TD;8Eb$VZA&q!nuv%u=L@ z@=tJip?|gU_u_oKvjqN=XH#s{QBrNRUvr5E^X$z(@ZeAVGSn1wiOAwPokQoJsMhrl zB#W`do6V1bSzABd!8XA)p+I^V42>W$mX-)<%KLQl>kZ55x3C`DiS)b1<%4INF%oHT zD-e)rP4ml+5rOnKTM?)c0a1>)Z~wUoh=YY|m;N9EaqLvx+Yuqxdt`>VOc;`o$a#~;B=>8o+~xj1P?}(Ow4o`VQHs0<)}>D?1;M&%it_Tt1n0-r$j?!q0-xDc|KTrLJL7shNTY*&xHmyvMS4wuYo5#Nu?>nW zI1?XP9XXQrs7On>9iv~L%7)avIMp?|QTd>*4yG z-ira|egk%I_~Yj2BxOIG@h~3xW`^-~$Sy`7>^$?f`!AYmcU2XBJOv^DCn71`RZdP9 za=q5*58aX4HKe#m-4`N$STdBj=hNn_9~90pujRjKD#LBVPUaUQomkTpVMR{bkoFE< z_3Xj# zy9WpN?Y-^>DX8}#Z1&l`1mb^9#7KprXSmKJ1yLf{V7Ii&THH|LkNrj{2tajo_v3a! zE@$15zod<`kK19{R=OQ;QT}P8 zP=oK3b|wl4%Ngxx`?|{F9`ESxI3P`(rz+pPQ@spkOf80f6W8MwPK!>VNO8jYr>t=jHg|k6l>);j+RQjs$lvoBXm)oLc6Br z8T@Os-!unI5DweEgkfiwLm3}Xo$h!bk>5T5ia0YTR@E~(&m$>%7m%tqHDUfH0g{5J zKf7L~<#jDu(DAsbn(b5H7V>K1^u5%ciDf#AXC6t6P%mfu;Jo2A(fBW!hr|i6({*sb z2sjv+X^<9MUP#Caxw6|BM2I-Ou&hPlEh|^eJZqDfl()U_47q>4>V2+)9B5LJ$5Hre z!9yqJH1Voy>(EuV5N4}$W3Sy}*fVcE(b~a0(MqH2k9N&lmaUblF}vUuEto1mRf z)rk?SX_}U*!m_ax1F8UtU%{}MPcU`w&Ah7(ewo@{;~Ipw)YRYZk{&{UZacS~K+rrb zpZT+v9>2U*;bDDkEs9(%W1^j@n&6=ANc@X6Vyc5Z^UC{zi2;8j2!#FRc`7A9gc?fG z#HMt@RpX)ym&h#V5Ia)9t9|G~RunPG$>y2zV7ufzPW^3^yr z%6?cr{RF)ZX(f;W8~rGt{eAFh5$8))#9jScm90ipmDGGHwtOd;-J0Lb$Uo|oPkzEk zFQQ-e{7sb4?oX^wez#bOS`u6hJC2YGDIr-+W>X0BL0Z=egE)R}IauqA)Uns)D$_H$ z(r!S*OpE8pYGY0FAUgw1v_Bm)Jd!rA_|wQ4ll_CL%LO8huhwHb``>4!Bj@h?srTvh ze;8@b{JX!H4q+QyEc0uV)q+b_$ol6I*qAvRd|78Y^v-(L6ai zRx}}8+Mjn0p|@n8i?v5{@A`7=g`yx|C|_Xf+31DAhx4KDRQ7a*Q$xvpzCGd8ySSfD zh=-@OnU-Kqv#b)|ZyX=y=jRu&MdTAKt#o<;((0E_>yBE{PQUMLfi^LiZ z102|&-uJfJ0ZaT$%Fq_klbu;Ztvtc?Fh;ZNaV+LNv(|-P9ML|c(yZWBbZ2OX@2`7! z2R82`w>%mj_Fbzv9x&nwy+yBS#nM~#C6nP87vJIbxb~DUGvv4|OZ;B;lh>B-4mYoj zL|yV$f}uM?p;`zyKgfy)m(3nhSWcrN=t&%;f?hj05X1C%KgauYJVr9uli0Gu*xb$d z6QG;BwkL}I-z_a8B!mT{e>OFwzk5xm&P1Q^*66Pcr-%wAF9)Vn^bqLhX7v6GV4+8E zXD@q?e`<5ynU71sQd)DUx17)rd*w?ZR7jFpWB&A$MOxcv{k_G%iOtXIE+Jt+xe9Q= z2DerO;0CunQv&MY44>NbIXfMbmfYvdf==%#=K1h|>fO!_S@Oxz>F$FibO&yPS!A^otBu-TYqgyShhc-vXsXQyPoZ!%!x(N%1LC#3G;3t{-!iGM{MUd3`ub~)%#_dr&~ zQwxXiNuTZClgUaSExtEo9{6e5h7v`BCIozkt>IdzDrEB5ke~ne=a%%k} zkP(#FCjM4}DSo1(7QnL0fynLUSn%=U2?{hgGZ(RIKcDPlrHvQL9?wmqBUhGp6@Rov z>So6`n(R93h&1VYuxqsIZ^)G_ZEkFI_XDyk2^bV)JG#1_UngO!Zx-WU@_cSuo?Bg& z!b;b$RgGj_`XnxNIvh$2P}lL zO!MWaTP&25*$k2?;fnr}H!9^FFm$Aod*8T^P;w z!h0;Qi@YPCgFmVIX)etw&6Jh2$c<{wjTI3)Pu(haDH>gw^x z@80@>0OLs$bY%a0NRjkaZPV&Ep{bYG^-8gjM1B|--hPH^riz0*Cc>_9I1X-r2`;xK z957kY7&rN&dh#1wTXc_4C`36i9F5(QF7p3-VmB&-lf~;^a6kOv+v4K|pB+Yl)XVhgf@V zUS&DIUW;JZFE)^WBIhxRt#EGnn|PJdN;k}?e(YMUee!0rgnNGAw-9*cDd67aK*A~b zb2^0jc3ICj*lYEMUPvMT(}LE-TR~!IQIHRZ@BJO)?{x>t-jWN}$zP7!CY&j!A@-{i zf7^F#zHGhGe1xknfx=Q49{Jf>uJJEQX$=VZ;_l88 zeiG$7h94x7#P587^J$#}kCfh+(zhoZf`|G-7jMr)eBGIq1pS^EvQj>iR$7HN&vFgv_Gd;9`4ay3 zDJaYg6gcv?_O5o}?HZc%yUXXI#MMh4`evY1!S)1G!PDTMgD<$t?U>nbMx-8XE$&68{4?n6R~ zL(+K(bV^1>IraXqQvVH0qLPyA`s1si*i4t#D0lDKa(-7eG`RESo06h~jWWl8&MJQg zW8YlhNmnkXgYj`Wy!BhfPRXWDh0Yk^U?b;qnY<)RDRuiVqUU zi(h3MnRP27;m=m@v%7Yxnjg5;mPN5(qlO@`{yrrBYbr%4ek^dz@*z^XWYoa#EBE* zZ9bTQ@dEva)mxa-a2^CYLqScQL^wmsKjN)El4oaWp4Cb0;3NRs86&aSuQZ-*XLOM_ zbAnFhoZzL5K8{})w)4~CyCd0*{O)O*B?{jA`OEF7(l#+GX*6D*lyQt8SQ`Izm7;C5 zM|-z$*=Uew!Ro>SS(3>cm|l%>z`q|_YCepD$*jwwh(6!n%Eo~`UXx#m*c^>N`Q}24JluEcbY(i)N@ySoij6MmwEL~)?I7dc zDS191ZQ2AB*v&$RLkKod8mRcW`{QG2ibgr`O?7cO0Z`JQ3k3yHx88pjjjbNxVX=m$j@cJQ8W zO&I=&i28aSqWS6tcKi8kje=kX>{Mn;73uNz=J8w6i|Qw7y#jtINF4zngCG3VCK3sPkQX3I$?*VYJe@)haiEs(?e zKsl-f6;%xdUwE^XIO5~+ejY2(AO@-^-4-e*((I%g6rMco#TiB1ej?$kVq_fwSkqset2*hu9iPd$#|w`Jt5xHDIL`%#Z+uM@Nd^K(IBN z*qVe&H2BD4PC?=^8c`sM>&oL5v_{9zLtg~_r8S04ng_EDU1f&UD)RZq z4EL$p(4E^c?aH=EX(qcz(wmoGQy_~OdoMdkG8KSeeDZ8eY=az)roQ(p(^ zMbw7NJs4+8e*sSJ9HJ}?%wW=aSbfjErFjP8$=b= zbTK&lkI*EkvM`yck@Ye!dDIFZt~;&+*i}jKgxZkp%f3_8V$=jJ3KT^f$41&?;GNNK zn*_GsE|0Z5Z4)+r$(R?i*DcH=e4pM-A8yK-B=@SrtKrajx*K*GE1r=5Ejne^a~YhQn>%z_n4haw;(EIk zaO%5PiGRMt^5Bo1W9Ctem_%TX*j)YM zu*9&%<_ekGq~yX(AW`p68rcyLf5SXOaQ`V4y?MLa)#%sjy>46~_4n&-q_<+#s8H9W z_na@YziJ{+Brw=ukMcn-Q*P#S@`CNyAG(Wsm4tVv6=eoLK8-HPoBa&->O7-kC&S%- zjF9xKLd8M(;!f4R(|TRdRs&6>d~1z@@(skt;#k39r|fne8u%iY`w75sUGCeQWY2~~ z4Yo?*8+G^evM1+0l=>hfWi)SZI-PRrbVP#J;)PG8K>&*9p*IS`z=-P9$9UcN(o0TO z00fG4By{Za*~yDhV79eliw8GyGo-ORq}!b#EKdFMAHd~h)1zT_TXQFtf4;K-{E7GZ z85>c|0CQJ{Rp4VlK&h@B<&H($M}Fst?Sf{EJ(D-J&X^F>%%cq9U*F&R9AoNu zx6N^nvVA4aRGY-$xXW}YE^V=*Lz}O*bFggrV?;^#u!Y0bwYJa{5fXyT;h|V`V!g#t zQn}|VoJaxg;^dh zcKMIO$40IP%itRRe7T92aIf+0j$e@2Mu^^nx4>pC|o;ZWT(y-VFv=7ssS?`MXghFjYoJ89ljDrvHxbT zN0~8`N!GRnul|%2(4oSODbb!mta7FkS*)&qdV$Z@!e2AUU=>I@l^CSCs`HIIph6 zVULzCG^F)G)8grC1$~B~Yejy&;1tc*rtkJ6deN#Oo1BLW5Ska;=Srhpi##vn68{LM z^BFhIBWcUq+_Sj*RKt$UTuSoU$y9Fog__NtU$#9Ec38%X)6=&-6JPS4K)W}Q5qAXv zn2UX;FSQRHYmM5^^#eA68!>NDI=jCZz-gg?;Jt~IU3UKR1#OAm_nlmh&52wfMY!Eb z*l>Kxq5YY~6=%Q(GahN`NvAd~dS;xpQ~!LwXztU>i8XiG#KDPDmF~cN%XB$^x(Hte zVLX1%veTRS+)s?V$A|GY2cd~L_SgObC>wS9csV&a`PyTvw$<{cgITnTW*Y`dadRAPV4izuL z3s1EyG_JAbx*5fX(LrT}vv7H`_C$nAv)}=veDvz4bkKhKb>EC_jQw!^A?tHdVR3dE zz76v;%6bSbt0MHJ8SfL$?x2<{hI`KTLxQ$Hbwcc|Z*ElG9h%`Zb$ZZc{E`_G2uL^( zy&VyFo*9FhwyMQEJhOZCw;jcz=S+6m1?d|RRGD+ru?At2;!yJ3g_VtF~D=FEK zjU-}+Ae$_vG8$?WIQrMf6&ruKc*~mL#uxpYIa-C#?&BPGY~XZ(55`f_F!Y@SUEfow z>|fmN6aWu`hdn(&#>8Qg6Y|{TG1>uHfn)MHM0Mj52X*@v2>RcDJD@G9uUVQU7=PhZxveU3IQ*LR^qE>Cn!_?*4Hv ziA1icFj{L<$hlWp7e$pUJr#Y=e{Ja#`i{Nry+r&lLw-op>W#Sn(Tn8C*=Ei<-a99$ zE_@mhQ-6QFt{}T@jXY^*`qG1*sax2%|uhM;L0(-j->9 zs}b7x!_hlsD}v=%|5Endq`D|;P8xNvkDCZxDW85VQJMA&Gv4y5i7$epz*~pcsMTYy z&Xz*god@*};I<>Lj#us%f#aT#eSMEi9y7lM0^CLAqRoR3V^YANG&O@t!m$`fmsPFNFz>W?sCEVYZ+~27R6$5=E zQJ0|d3cOe0HzPp(ehzxEE%!}tom-XE<*4n6*w5=2JETQ)n_tAh|Eg_+L`132uvb|% zLreN~HHNd1;7*Q$8S;N^d6~UbWWbV@`WXFx2ld%K!`q4JKyHKj^xOBghN3?MJncT2 zBK?P`wYK^FXCeVN2Gd}{bCByH|D{jF(@KSY*m2M_!q~5HSLgsS7daf&csj_)s^QMS zd)jr?vxu_mTu~#Hlui$4CK&0nZqt1shKgm{-?wm3Tj8xA`an(ta&vahconrLK5kgJ zAAVVWTI9Eb|L&X4P*!5zm-5*2ug<4WVB_cK4^~`=Xhg8(dT&;b@O3?e&G7!3XvEt^ z;(zl-o0gtFFz&lDxUrHqBWnjqqvEzCe3Tc)5h0wqDqf0NMMLZs_>jN4@b{}lUzlOX zNFKU6A9(^(idvy2_uF1WIXbl8$4sfeH@vvTm@>4q-`SgXZvP;0og?gw_hx3IdFW0T zRV8bs-?nu{*MHl-})r zo?-U$CYv<$x(gvmvR#ip_Y?{G+Z8aewvml15~V5>BSrW+5VsT_(WQ?6d{!alW@yGs z3kHE6x;?Y&_dNbBEzYO0u&4;c6GRJuPhASKP2SXENlHq3Kh!~gm9PAko!T!p6%4v+ z^E~R^=u>hT7uy+PS4hYYqKW)f1=ZQQP}wve&AxlkX)X2$+Rm^xclkm&A@z6|Td+De z7o}YE(~*5(G19Fn^lVe~QaGRZuyv~ivR39+;c4!+es^&plC4iQNdd=a@uZU+)Q1 z!Hwv}V8ps$FD2=160;n1?a75Z$mVDYr9MTW0irMDr3QXoY7u#FU(aPl<_v`@L+l8# zFwjKai|(S@&D5l{P{?cdboW0X((Tr7x?!&ve|d$MFCqXJ*dW}`qKdyAeI@NRW>>F{ zo7JhdkrQVU#kS?L7?~!zpQ((pHgcsE+Qy74B58_Z^Fc#ddy05ku~2tWSYM{0 z^x*)T>_cFu+h+ri`2&k0wIH5@^3voff3Dy5r&pU_sQ`38FRqL*4(|i@Ha1uMcszm0 z@*pFw^UlvrjEjT;b4ASFrlTPai?LuszJ_Rq)S6>Zg4sF&XH#DkN298&2DT>`Se4O~u)hRU6U;U{OXHQ>w0P!{O%mZa19vDucn2_zD;VAP% z;&gau-fmJ9G--6g@4O7Fd6_&SP)26nN3efial|$*!b$wSiXNImlhLw>Fdn)dG^=j@ zyJ#PH(6$!;fg+n^ISS-p;-*;4W#ATol?!a!k zCIxZoI`DBorK(e{+OeAm?IKB#jM8gAPnrL1o4orS{g*{K-Tm6EeJD&TFwD54wds<${nxmAaB{KY@g~v1 zys)IAt*j-OK$&`z;#ltY!n>mB$jqfCo>$4(FV)-`2~$5^9^8ETCsd@FRD=4$STSYw zva6uh9_U=+7BuBt_$R`S!%5Uy(uf4bk9rkaQdM@5G|IF+>81Q{9A(*MmFsYFIhX6X zE%bhyMr6~y&lyvhu(5nIbGOD_=H=xH-(45@@S)uNBfn0ovA*vS+QOg_YZV@Jfm@n^V(C-cgH3iDQ(_ZPhR8d&*xP^ zaTm`wD3DkV4_go#66>3G8CnQg882kSUebSO+<7zPyPhg;FLqAyJeio6E0H>CYEIUH5!R6R z4bgZ*8>{MkUSFL*zgVlDLS$Czu@)N~MTG@PxnrV98f3U}VP*^^(+2v94AjWwp7>;b z+x!zv)@LaU0VGC}4ii?3NZY498Fq<;y@m`WmOJza4Q}!?7>RlYBVn0l7VmPb3g5GP z)y%q9nn*At+a3QjVD53F2eSLDWlB(cr%P9}J{3jZvlz#hwC~l2Lcdryt|KSI?sB(R zV&Pk8_Xm3uXOi;~Yl`h2qXt@BB$(h$;X^Ji@C9m?%}r@`)8%v2XDlAM|AX%?qX z(LBXZA(fr&otEn|xHO=6AW_oL#1Ik?bkbs>es}}p84=c{&g23DcEMi+_lQ&mo*y;TUu_Pt zG*HsgV1%QQA%k1&IwiUC(24S=<h0f+v^((LT-}k7-+P~( z7tNoYT2RtZ%`n8cw(o_Gd0$Ak>x|gjadmTiU1pH>ho?BN-F^Vw@Kr_mNUcSxvW97M z#(fct1FjyKbZy69;+%hzAgYBw_Vf`tK>zSbq8}}55STL1RZI`_hRDSw;g$tF-XSPK z!qGc>#6I-%_ePNQFE#iE+t7yL^c^VK@~VL&&<_uoI_ zh1PNQr05eiigt42c5(yB!;~;*c`nxSjIXE-uTs0d{pkPTjXQsF=Kjp-5?HoM=)b>V zy>^cs2%b~7ek)irTmG)3AsPy=b)*4~kmq7eTkl+4sB3X{^>mg zr7tUU1w;12NLK`x&Ns2I|Nghz{jR0>+F>R~qKs9jNJXL+eHddBSYR8U5y3Nfux-w0 zn2l?nI8~=}a%`;Jv?>dgQq%dSF27ozBR4xM0*2H(Ol2lof-t`m5EHL&@r#?Fs zkA7n*EPOfGn56fc66n{+0|Ej<>=9Q>X}CzHTf=1V=TpKHyFG28l`(3dmfM}O7{9rh zXFv`Nj+8YL6;3s-&_OlLbS!PF4pU$b(H|AAev}UZ+V=>pvO*1>GM6=X7UBCvtUN1& zI{Q-nS*kwJ+Cn5BP$W~2g2{Z+7il%`QtiC(Z=OC#hX#v4mo2_h3U@i+s!7{RZWE3| z&u6(@#v`)Mwu8KB)TEAB@Xd~Iy*^$H=zMR7EPQ+OVrHBH;w;hm{51%<>Vvwb)1VHg z<*Q_l`6gQu6)aiiq-=5+I3G1ws}f#tPv76#Kn3$*RG^4MTJ)@Z7=e}lqq5EpiDFod zud5T#u;W#Or+ou=c{7K^@U{+}l0F~2BhR4DtG|&d!jVyr96n97ie_QsO+LHraL}Kq zT+3Ve`cJi>(?)=EOE6L~GAX`fa`kUK`y6O!EV{|@jKC!JnR~t|ean2+qd{XX$FlCS z|9t+;JDX2&#yS&|sh>nubUv+tkkDn*=rQ__&(7mBwJ2E;UVvsuAWH0q-6mCq`@I`zVzE#z07+xTT_ZwNd0z zZl#}PW-AIDCTO=IZ5gt+8jTe9h>clx3*sU=!iFlT8)tj#-N{sa7L7iMRDsuF0Xx=tU|~;C z9jb+eauIc6zL{J{O&1}BiANo=I{m%ADpts3&d3?~rzD~IppF27iEWkj>p1qu4FzMR z+NW3qCH1C;`Z(S`E)bouy5cvLsx^c5IAP%?713DKTjpE2_-EG>ptQYcDQ4~PXYJ67 zG{4rwiXa3D@$qfJ9>@8)%0>Lnxl*2L^0336H*Kx0`*TKKM+fg>O3L?~bVG7Swm6mI zX){dNNkuqiki}sU7a~~Z+(z2wuU8LcS1#Dow0p_3&hnm5!hO}fL~zVB=BRHn_2iR& zd`7#dF&)TE$y}sO;-|>h{@xr|-6NrZg9+2DB-*>(;1x%w9iG(Q3$azh*FOGH?`NsC z@Gyt=NZ$!;-WBF_w&XwWXA{GTV0JnHGuP*&5DwUj05XZ<0(uOO;P?AW4D*qV*46T# zKeu_eC2CfRGHEMsnzOScz2h%ES=V4&Eb4!Dtm_&{^OP9DRa1{`n)F0^S~7iDP>jdYnJ%@m&lpAVUfcm-0Q%77Y1S|we@Ur8A*$4sbvhO>(C5HQmZ@;>yXYsDDt zDRN$XF+@%8lPF0L zQC=P%KMkthh$&JLc(9gnl{N@~Z;RswQ;>C#@@A*JL6IM<^Wx|vay2w44qv^}0GnL5 z&Y9hwZwX3DI;P}dgUPCQ=tS{QXmIwY=O-wls9l2*2Xn9GAv>PT8LDbjyVugSWNKsn z3;-0NcUn7%u@`;K!FVF-U@cl#6Xs7Y1w5)cs;ZzsO*f}rV&H`NwfXYD0in%lsht1Krp7UL9prCzz|{*nM4fK|*xkjJmhgNjUS88G zmG$EOaoD;!?NVRv+DY$~2`D-zK{^a|;<#_aC`yBGE^)Nj6zZ6fCzwito9iu`7zM2U zW-gPfU#H7!Ix(x`I(W|L)TjSz0isTp;)5W!6+BuE4d8BEd^6tt;O}?)>?z+2ea%0s zH#K`Prj0PCjTCBg3bULkJ+g#%bHHi?4ut=EJ1nM)-^G*DFtkqkNRI2QB(<0HCYTj-1Mb(%^3dhM>kd8NPX=g$rfd}OsD@kqTcIssoPbn@@ zDcSBe!G5Y`L30IW*h{?qSzmk-ps~i3a(`(YxW`4B%~C29+(*kr7zGJt|A)9<3*ZZU z-qp&_#grJt_cIq>&J3HjL0+h)TEZzLt>Yp05r&T)n&Bx%dz>-^&EZa0bjRO4TtukX%&24oj{0_9m?aj*dQoMWMMe zwZ`}nt>W|v@WY1jUiUUn^V9kK%0=d*I2w`70KJZcm8hZ5B+1xkeTKC5*QU|4+z#gc zC=;N2yj=hD_aFr9#P#2)nTMwbV~TRf`>plcsYy4QCu-P)eiuCyBf)HLT=Ja|GQx4G z*}}maFSV(E_n)Z)!9T6{(6!>$>Jmqk!cA>XGQb%9<+JXOPgK2c4JBhVtS`pzv))aF z`#L)_IJIoZ?~FHj5R4K7sD`1Xjm<8suC7kVjF2Bop5@O{Qv_h0BrBW-glx~}?zLvx zR2T4)FP?!oXMaLb_c7yXyVE7607~QvXF26XFVI9*SsdF-9V*L3Y+SPlZ zeqyCncSxC)N(P^4Fc;8Ijo9}_U&sZqpB2r78?0!T*au&~-^o?F{UMY`o%>9{AR1j0 zaGJLftLF;JW}r+RsEluG^K0B-y^0y2gsBvn|3dh^mSGF;=Gn8@_ldsaVEII@RbDsH zB8>hy;BeV}VgOM1gaeZhl}3Iq{#F~sh;;0I@ZRDwwpCX9nJW?wAy>MF=k){5UH?JO zw35E07KIj+R8&17VVI{tv}&&_E%&EZ?Fq$m1HA?s1GKd@1nqvC*O3zz;wS+WT9+g+ z-xRPc<77Ry14?1Dm zW>&k~fLpH1to4+{p%=(08)4%{Ka;1n{IG>hR3A~&WPrg zd$zBsu@C$*lk1{CTrfOqw2^v$?A=b!C42n>x3Hu5y}DkdzH8-PjP<%fr=E% zI669do_Kc6A`7$8WS3wIr()jqbB_VwZGJzRR#Kd|-nnd#3Jcl`VKRf^B1enz&%n|ILZe<`zOtH%U<8eIy~UQt#E2%~1L6 z27kfi1DH!{;Y2p|{5hfbd7*;&#P4KPv7*p9rBLKAp3PMqyi97 zm-ThomR#I9t*nJwd}Ekck+#!aZ!VXgdUZ*!5 zoWdmI@T)M}hT3uF2c-aO2Q5<0XYqKkHzYh7A|~5_%hT7da(yiuKEkQnVP}24yFW~; zOS~3sOIE$6-cm>k6#+M48=y@lXJ-+s`rPEZbrtT6c>CsOApq$I)bzP?%knvo+yvmJ z1FD8MmRj%G5iJPzl)0Fl&1M-#bXaqCEB2m(?=XMY_Uk$LR$3F}(9JqY_zY3RdSxE#9;_c@!>fA=FY>H@CcgNk|rQd zkT(ohxv_aNZxjuD1n6#8XbPWHI&iAf+*8)xG0=PY8@`JfdoLAdh|tG=zI;+QeGWmb zq_>y&{l`K*szJ2Gz-A3zW?f=`~t!~6cD?AnPKJ?;%HXla)s}T z5;uGfS8is6L&Om6gM$yBht!S@(80x!^AkR4$idN3A4f^{`4xwWD5{7xr`La6*~TRB zIS0~mwML2130N|45#kcoGcK@wSNF2OYY;`azW<&gV)K!RFc*{S$OCq=zr2Qw^Q6P6 zy@d681n?yG<0k)awz-|(n{-RrM>CxyW<7JlA1lr94u{u~3wvIpMyYfb9JHWckCp#p z^J^46bmHle&Hq-j$ciG;#gjWS-LZVxqK;CNj;g;N`$L?Q^0qSB$?L!izOC}d%Q72! z=YI;An?p~1E%1&!g{`+J?jO~CeSMRZi{e@>{=No-0Mu@3%B*ub?MSOaxH|c+?x}*p z4gg!=`T>Jqhk)_cr<`w7ww!wAB;G6vC%s>fv)GAhRA@!-z(i1x?FvIaB|ZJ1f*DFY z{M3XF(TbW@v1Sxi^=rrNJ{3SGHiwd4iXQ!*@m_6z)Bo@n))z{wUWpsDc&BytaB=Sf z*fr&Aa`!pmY~#y)MsrKj^+@N{|5#;=HbY>4{jl-W{%wF+xoD42J)-$`tl!!RPyiJi z?R`16C2z?%7%$${tujCy18=Vmz_ht2MH^d#6G?ds7`|}3mmH~2 zR4e(&n^x3?qvy(D2_Mb14so2uuT2;Zwe&d!8CkyC3}TsrnJ1$L65L#ha z*vTZNM5M_j{~X{{Ex#^@mV}6^3P$-W;zXCDGLsJw?{G?|V5+DuGyHau3_=`Usv&Km zhL&mLP&l?CT}%HayHB8v4i`f*yxie~vZNWK06hmBp4?+tDz2j>({F8-AbCR>c$dS# z)N^fIJUH=V*b)<2Rq)%^3x1xNNBBP`t?`FRkyipdxq)=-1Sitr63-JQ1}N@aR!k`q z=`TCSuozU&Y`LrTX!vqss{qaOVm7b zKOGkbb@!sCzGeb2^xxZng!ui*Uk|;-pSqmZiym0Rv2y@>67x7OE7k$DaFVzsa?Z4N1NHz zSglY)cs)8Cb!9~|8cH&4f~A`bIX*tV%UZo06j5&;odLTOTmm?5f~Tiv;8p~Mv3H3# zzj*(n#vIGp7s0OvRTy*N1XLKu;NalY?ChV5O#9N$Afs92&~V1K)usW_zlT6n?{ab0d@$NO< zHda@fa1EU>YcdjY@PA?i0&t?83Z@*%!Yjpi{9bpfrYrxmQ_;@Tf{D!|5#x{uTntlU zLRkGgKOR#pPgdUoT>d?2|Ai@W4E}*WdAh?%PbfNP?+sB3b$KCPJ~?^>W-mG>=OU3g zQ<7>aLAI`lB@gquX5*&`AoSZ9mLtA;JMI;H8kr}Xwe<%hPC@!04G%>5?E!kQYs^))=0h{OD8O?cweUaD8C zlbX(PZ;@tM6(%A55Bql967A7mHvcm!0V~klzSmR|0QM2VM{uII8+$HH(bK=(tk(K>VLUUtN!dRC*Wf$@4$_`agx#-lVnQKcB+N+XutN zP&sN3_I6HlB)Tk1r+CWjnuQwM>fM^TJ+p_cCmY+-)IZILlSq{<(mD&3`z^gsQI?|7{GcwLpFE9DdQ>S)MMzS}_8 z_dX`IT;XddFJz)uN1fHVidGkvts1q&qe3n1ywWOG=%8ki0r4>_ZJryG1%30iu7#uW zc5&?JTR9Gr4kyPQ-UlXKWG|sVuOtZVq5cBzUK8bZcqq{P`W=;AQq}y~%&EBis#Nf_ z@ICwrfnd&?P>NJa0VZ!N0x!ly#_q~p%$(HXHp4&Hn)cXOThHksh5IkdP%bNoHh4D| znJpXA43puYcjnd&spvR;lqK^R^UL^Jkln&}M&eW9&UMPIK=o5xZ2NI?00LDXaQ5v4A}%1k&k<9%~>~1>P9$ z9A(#6SNRPcBr1Qax)FJ89PA+~W&PSkG*D8e?|fgxF|UrH6jBdjuyUc!qQdXJJdV!J zMsgJHlMQrY++vRCOA{+|pEL%YRafXKDF~A`i!1}9e;IS8xX#6SZLT*-hImQpq`hOC zTv)0S*Zjy&Sk@=L&4Dz6%x$MUWbRvN;zrMqw>|>B>uo7`DfbHTMLf;`z!+g!DU$;e zJmTID8&H?tJ^RG52C{=+XlmX88}Qml>g-w4CrO+jln4`r?-%}3!afc**jd>YG2rs~-?@hgEV$6*l0ck4*Z+0C&p*yv1M@9#nWF;4~ zd5wj%i>0e?U*0o*D4~g!=LdmE7sYH+vQ#xq+P%NR`qgq%zcsjR4WAuUw;gZ7nQ~B} z#Jjitoot@xi)Hr*46Vl=E&#i&S1C>pFiQuWjjMoNPU^rf)uK$jxJo+*a4E@C zC9JmFP)?FQW@A40rKtZdQEGMzX_I4w@^&D$aaz9)TX4?FS_4B~$5V2tP6gg{(?EgK z`}Zr~Toad?&g>74yE7ZqBFP$l^{dN5LbA#{uRqseis%+BHcAB{UmQqB_3>yl#IPA~ zq@aJRA-+v}0x?x%seN_@J2LvGK+tF_?2Y2GtueeCR zm1=X=t3{yX5a~1K^U4?{^kkO_%do#Tu9^$W;{1TVi?XjS)sD)gW)fj&99tHn1HW{2 zEA{32t0&T1cH@BmX@#~HJ88ZrGH08RTLxm-dpa3S{dxz!8($H!44xG(%*9NQe+;>2 z==R~0VEFn4rN|sRuLCi2gHR8`j=AZ|d!}O)frr1v>WU_6(!Jl^UAC?0TYLZ}H+q^J zP1^qybb1~wQdGB}4@*0mofRL(b4?NBlYX8)$M5jC};VJ9iRO4-xXV(3&Q+Yy)CvQy1Uja zFEVy@?hf?c^Q5mt+C`##meXO${EDOrJ%*pU7)1))2R*x|Q@`ze z)J5_>_fRlME}2^N7!?+}lT+>}{%hylI5RQ_NVl4rnxehqobM){AHdG~5Vx(9&!1b% zAaH{Js8cB~05sN187aCgM+twwtAI*^J5%JbA(94Ic^EkG)~t#)qU<}AeVEdEl}S2I z{h`QQFRpq)v>phnv3{+mfr+G9GJiD^H7Pk6Hr`o{Gzvzvp;Vy+)M@my)!b9!z|lL? zzoN7vyIO#9=-6i7XM1i?z56nQZ?l|3arwO3gFicK2cm#U0>KQt^4apKy zh6SA2d3Z!cJ|03(FDFTOdXl``)?Vh9&-u103u%-_KiIr3y2m0+d6xH=TLS8;h3T~+ zYe7swPhG*s$ybG92mU%a?%eoXK(cP(m)9X}P-_ z>76O1LIQxF zg77QSobn`RHZZm#)Dbe3&5!)l#r6Ul(qHV@aEm~+h8a{v+BJStE{gSCK`w$>KRW#> z1N&ObfJi>7%~EMhOmm-%R;?lDzn+QATRxL_csz5SZ{gbFv|pwAnK>X@M7pk0OwRVL z<#9j3^kz5luY>)2k}<;avtpz}Z@dG(Kn}qpF&@XWIrQ07mx#_$E<}n_g8{`z3#W>w zCFS)a-xE!4*Yl_LbVJURc>NX5c>vqR+h$%i5uug{^)?(6|2ptPmxDZ}u(`RbjINy3 z{eMh-bx@T57cQZoq|(x&bV{?Nfk=aNcXuq^2nc)u0SW1l?uI26Sh`{9?(SM(iTnDy zb7$_%4u3JT`|f_?oaa1o)xq87d7uZJaFsvue+5z5PaU6{jPk_j&4lD?H4B%smaVGk zCT3I?lG+TgTBW8t2ztLutkBLby6;{UyUER~_QS%yX(W|e9(YSk8hKMo(Eh|TVf7wN z*twrYCO`^vaM@#ezCE1ka7r(tU#UB1i&2p7wqIgVVyoiRtM>^r;5jx44h_h4_lI*+ zivp6HF1uV7z}p9V_~p0}nWLe9%X{Egb#M!YB9-!yvY7*)4^(yPjXycbSw}B$>WaUu zRJ#hJCyeUK?(eB$g=Gr=ToJw2Db@DRp&aE`JNorq73dOrpU%`NXT1Z8X4oT3=GbRb ze%PN?x#}Hd$k12qsqN6s^l!&_Wl!%*a5Ev%VMgIk*-RKyJpXBMYb> z*b_6V3FdsJf465-^eN9pD48_yQ!6k%waZ_%7S-be_JUcOwXUzRHV6g1HVet65SLD_ z4B5h9%y2K9H>@G1pDfR|G1~8%)1*OVhpzyI&-|4a6|jy^Yq)3ghcawz29f-Re-8a7 z5!Id-+fRtQnWrfW^C}PdX3~%!cqsqq#>9KBkoT(nozKPnBzU>jMgGW1%51v;8hM%9 zH0eAyRnJ@cmF@RnnIZ>xf+6OY|BL`Bf^!p&%-fxO!p`dk^NH9wO&WY@(R7&(^4!J^ z-^|Xn)-b^qV%3h`^2iW6d+0uF7U~X_lX@B{x*k2vlVE$@D^wwde>)<=Bx0w#xHzwB z--X7KXRi@IsrQ;==#=&no= z-nHR$i5N|F{WE8->suLgvUttMTokELb^wxd>Fliv`N7Wb9{auFfLl#4@4OW$u;TRj zuWM1!nrDW~8cC^sGX}(n3gx!ZdW)r$?ju9ub~C&VElnFk{x2U06uQ)m_#yWM%Ai8C zzVW1v(#5qee-9|Fxg3^#GB1||4W^}^VPIfbpLmWoKY6*y&bD|fe*-|r>1lN#uS-iS zW8?Lh2cxw($Qy+hv8ia3_|kg37}hhz)8F<7D$XLDQ35w6=knjr+iMPuv>%e~jv8~& zgFgk>a)(LzRpGwNeW&SmF5@!flk+pi;NkUimroL#j%aIN9TOKRyQXnAzRwYH+((Lk z(oqa^prlOsGW_06DRZ-2dLI?NQK^3kh7Y~`-^v_e87g4Owy4qiY3D}qfD$B=7v!Zk zvz(kRHm+IH(;&pG4R(DX00bJY7+cQ$zW_b!c% zP0{i(DxNUsjWvNp(i|+sy_Kiw@`o824MlJ4XQ@@Ey0!y|V~>qQAYH1=;Lhxgs6aX9 z9Wt4XDt0>d9Vb8%$#tZ}>^6RFXLl6pIBpAy8szZ=I6rKTuC6#!)*GTDu=!SXi08#! z?C1`f*@gw~z%yOvetLm&9Yov)zx?otKCcAkEN?x4uj%WTOo4)5Ir!Kw)GwN=;AhGf z@?^~ez4+G~piRw5pO z?tN`D`X7)LW3^@*v!?p&xR+JQ6^zml5gY`h)ES`oQ$do!$&ohv)82Oa6Yh z-t57iqb*{a&GWG~qp*mD!XzNHj5$qz`?_4gRQTfC4)-^6__rn1hDyQ@ zM;0)J*~;}pi{3e*@G296hQD0%WR2>kZ*=!NYfu{W@qOaqA$RNGL7dM*+5Aaa+u)H( z3 VDe^(-!UO)3@nUxwX7y72z_W2DN-|L(f;Yv-m0f6~C0eEjQ&>=7*{HcV~I^upv>WqT&`pH6(*DnMDHo~07NSm+J@ZEf}{k~Z;M zdy(+DNiyCT{UnV)mhAKgX{t^V7`_Y3==+~$@>`gnJ|#_nc=xEI+VM(tUC^$@>L`$z zi@|>reo~&lDpy-2vf4Wy%l=G8MTOm^qU3-r;amQ3*dOLTWRrxhtwKufBBuCIg=S=C%86cT_1d9NE0UGUYCj znUVr>ySv=Gu;IJl4j^H9o=x{)T2K>f#ckXO#MkC3<6kG6S2(-}glVBhWE~!Xssjcb zNoFwf&r26XWGT@+oEcrLz4{-!i*xEMUJ!AyyH0PF$8|V~4LLwIs05#?v45xwpmMj5 zP%!p#Sj9HnjWwx@*2I%HKPx@(^f)|4QEiv{e_Q~>*^>CfbV|FAu@~v(e>%e!_+Tpe z-j|8tM^`j*q@1Eix_kpD{#>As(yun*^rc$Km)hHuL(i4smG`L;&adusbVh$<80c&E zJUwJSJ>wL2B7)?je=wVWb80D8_4d7$WJlUh311J77l+gYM|OLU-E<)KCkIDAKQZ1H z<+()Dul6@KgaL`}B7?Z6p2x%0%*xY+_|rwE4&mo%C0|Tely3!ae0C0w`v^N>ki^@b zpx6gf$$BNTx^X3hNV}7*Y0aDM`<_or{#BOGlr+@*yQ-j$Ka*FsKZ)j9&DNO^SWUId zlm+GQJR9wDkS=zuZI;p5aX{|rICc<|a=UbSHq`ozG_^eGK5G^%ewaHEk3#w*{9!hw ze!hF*dwSpUaPv$5tgA9j4qM+VsQi(`NZF6!NJ33V&n*8`uTy-8ATCR6rM{n90|jvy z3fTD{qNTbvX2Wwk72ZAf!z`iF>ElK`XqGn<%T)=*U+?bB`YNc?zVd zo|~ysr+F(6nT111^NA)q?FVhdi?$F!?`t`>p>WFHk9q5#TbGE+^bOcH_r@f!v9Z${ zDs{@9PxAc10qjeKhhlDpLxT49_IfPDk$-3~E13`KdW$#%IVfmJpMxJEoRII@WHJ=b z!PU~A8DQ6WcD$1hc|;FX`;+a&yMp!ap~E2{6e5hUDjQR@sITZ|B?OI&d+mbrVSa<@ zCtU~SkmNuPr=;%j{YCLb&clNvDyJ0Y$gju=yO5oFzQTECldb$q<^>twb#Uoj_B7`l!{c>6nWB$ z)@yQ>1nV2)AM>AE-M#1YRMZ|h*I12ru10L> zg;id|ujIeArQx{7M~ZAF^pX?z8jD=E{)73j`O0vFyjSd9JGZ>g$rBRqaShu)@-Bk8 zw3{PwXFee9FMYh-f}r31vzkh^og5{`+!f)Pf*K^9)mgDRD;0jw0aF-t_HsDzy-2le zu{#J|J3J0^KDgq?3ViX!b_F6Qw7mfMV(G|}`VIexM7rqL-Q>n)EytP}0W83O5z zy4?b0p*OYGJp-Y{lEIsy&w|k5Fc1n3KAwr!j%Q&i?yLfO`ToZ#)t1|If%RevKb&$Y z)@@D4cg1Sdbsjh&cQq^iT>O ztKx{?v1q!Sma%X(RN`ad5U+!V1nVPmlKD5o7Zhb20jmZ!nXZa~>$j;DOc`k1D%oCG zy3OI{!EPa!7+|WD;*To#QLf)p@bqLm#=vBIt_PAXU?q21{^(4Rz}5(#4z->RQ^mv!Oi3W?(ac*E6O-F zs>s!sZecJ&4FUi3;T5y;w@mM}@&2aWdS8j)53)*98h`>X%4fqC{2vRnSIq}N9*;rI zdYTSY)Z+B=Shv$PKG(4Yr&lYt3w(h>tk=)K-*X_P49l2gDmlEk>|*}JD7w$*{xWmk zVlm;T^w;wnak{4un+u6S!w=3*s{;1a zlkmwd>6qA;RN5`)HwB8BT596FCBXHMj)`|^tH`RlN!(jiRar@^Ct}V%$vnv?-wntu z0Cx3!Xu=*kP2Ay(jN_y;6E zPl*Y~rEEKKN>2X(|H_ts;qIe1uoVKE%U81TP`dZA+zgsYNmm@-eE-UV(r_aZ^yqAE zFSNiCs9>V%wX&Pf`GS(( zkRSmf-+hz~I3Rd&&PiwrQmJ_p>LnndLG=7x1x@dQ_`QN@wHD1-1X>y2wgmQitq3*F z5V2&S$=pqngGdC8$R*%E;`j<;ywll!Fp3_6FbJM+C6!Qr8y#eN4~f^wqp zn}~@O+MtnMk|f`yM!@k$zJL!)&GsX+oIaMz(6a3875lcs-_3DKlM zq;FK5;QP5@O@`@FZk+s2eq>WLY-F3t4w?bd;6HhYbZsUkggdH76~W<01+Z zNgCXEIPrf{yfUBbDXu_{g#*-Z1x_}$|9%f{9hlNSvt;GK@$e@WnhWANbcd={xB2dy zhH=8aVF#ESC{05Zmz>fJ1^D%5f@O3vXxOpmBA*-ZZ_dvnifTsbbMutF%wCWBKVg2` z!ofMFj6M{%*h#3NMd*U6(*yjjC)pnNfz!t1tsi98deROXXscxP#;V0!{Sx@=MI@6z zCqX*~)8Az0KDOEiwH1DSg4e3rxX@lduAj&%-$#MJQ25Li00e|_%gH8ahyLT#j*Xzp zHQPwDC4TL+_JwUG=*kZj2(o^?@(680+sDZ*6`SD?^bCp7NX6JPiH+p>n`^N=Z>hR1mV4)+}7 z3G`_Tz=~)Lm+D%OY2OYl9Qc>Af@Wg}P}T^7QgXGDDW#IBPq$Y! z$n;H(20K+X?4-5>tixG>mmVT5qAyftbj^QJ)@V}(dis`M?1{G)Qe-XEQ`HVh288Jy zlM85TVH_$19t-jpPsw0Ua0`I0RL5T2W2~m zChhf(56{Nvg`GCS?7xEI&q$fA6OwY6lKt)QVjicAcnA4w>lZ8{Mr&#ub3mAkYE_zD zd+-9`@L6@bA@3?F@*HAQ&!*X86@GoXNyO2@0=e*HYkfpXx}|L6VmMHOoxFF!^mJzz zoDpnQV3n6wiIv%#5clDK{Mxv}K4?AMy(ofc-nsSN&DeRHG+5_0@cpmTx9W#YKgQcU zFx7LjSG|vqm>!#))IIC{&&_*zd#*-&5Zc1cuQeV3yIl%C@~G&g!-yP7)jqn$1%rko z3>kXAz_>!*-QRL4)V}ujD<*08W)U#8SR*ok(})cTQO`ZUz`hwV@TbVPs&~_JaopZg zxw)qCr+T{d_aiLiUuaKzSg=VCZvqxsm1j5$5f%_CZPDCk*WKBog8xw0(?hg!*>@P%r>%~L zu3J)iFEO8`daBY=wy^x3{>3d*n`K9@%bIk|AjKF6Y!90Y3`KIbm$*O|B1uNlgm6dC zPPRvy zYWkK$6XhlSJit~A|6LLWk;F^=Mxxm(P~uLKpn#ZDQ_ZRxkp%ouzXqYk3PHP!R(}~8tfkt@90`}E zTF5Bhtm03VZ@JsI(PL-YfcbE8{~1aNNUIAgR4;LAZn4YfmGABd#xx>3J2;TCDruSz zS3en?e|7{!0jm#IXVlvX_tyWFey*74N6-GHs=Mp}&(PSoF=q$yUUST?=vFQ1^cL~&h{?AK8kdL?he7(amQ!1|&; zn1*Q&=6(vaG9y1?P8cZm+QJP@UMJrnMWyR8_9x^AC=vi6kQ^yL$3|&o(EYvni zDodGOo4b!2IokB3E=?4$wRF_nrTbZ*Yxg4LA*w#I*Si=p8Yw=_i_60U_qg4n0rLjw z&VYx8hH9@9EmL)7u2CN4{__hILXneC#{@1WP&GwiOjOjIgZILMy|(zlw4%H>hOZcZETW~Hpj=|!W;j`)j>^9qbqDNCoYEv6$zT(vC^O6e44~O{8XbChN(`<>7!DWxl*^o0GhTCUpGREMj)DRn+t-z|ZMAIx5Pj7tb#u zrF1!R!h6{TX|ar4Mm#Rf>(oEa#{s(=lg8(CEhHp_0(E}MWqzDp zJ(5a^i~D;3G;jde;v1c|YKUgbL7Ac-H1`Mij{BR^yy?q3eHdI87+lo?y^m%I8Zw$< z@V4hv^k_3w&5T(VIO1T=#bcXEwxP^p+j3_=Q|ajncm= zCoF_M969*!&-fiJmrO5LM~x?9+}TvLs(b7g6+}-TT&1H3_Aw}7n#iJo|FGvnDwVjfLTSzD|XvjZOe0T&~w`z-19M|%RvHYpL<9F1H(goNS;CWzyu1Wvy* z#RAkz#g&gq|NALFWgC{2mfiz1A)lX19DE`W-ub1HVirsyt>mtUHqpfsV|_?Q=j<#V z<*fTF_>Mg6xl&EBoz9WA4D8q!uEfW8n&x$?y`tsLyHYP_F`)#;RnJ2*i*BeiXIVTi zWa;E(G0x2R#Gfizw|G0EuFQc@)eehQl%@NH-x2T=i-*bmd1We|s+t|{??{>lv0sBQ zEB^7y+v69KYN%=-Wn_*1as`dYDsMVBDVdEt-FL4jpKzQwf?O}Xn+5Cb8al&O1cZkp zXU4`}4Qx4c4Lbq9AtB+0UI8q`(nJy3K`BvU^VT|~!!f-Z*vcDY+4#Qyj6W31V!#x+ z?6|Hdf+sB(ejWf;`2o(mg7SkEj6(S%+_aq}LBbdLIo(Izf;)M>m4Z~?@pWieD60I& zI_*G4RZZaGCm-KfLcYdd`cyK%-QoJAG5@1O>@9XT&mZBtkm5)Ya81Eke=L2{VmWnqJZP`vA-}f1vHVY2W#`WTz6{nriNP1lrD2n{?ZP+?&5PFNA-i2mIPr zL5hnfygs_g3QH&TO94BcLwAc0JAMdwK7ag$xYw;zvR*Q5PlXW`MFnXQWG7^$>FBuQ zV)UOw`bp1Kc`*wELhhFH74MsH5e|6!gZ)i7>3cNG>vO2C}&F{si}d! zLa+loijGl(-bX(7B1u^9#Mjg84a?*--P?1ll!`&q+v-t$do>5zn31qPUiLH*Pqe|o zTAQ6XSq{6JU1_PF(%9kjJm6|=t1#4OBI4q!qX;NHBk)yuznh?;e>LEX@HKw|{b|Ua z=a+ce7Jv%rSIiiEkmu>`BsF~7{#oybKiXB@zqlSQ`I@cnQ;jD&#ODo!z+|`#D{Hb& zn$%ozrxO(c_S%7N?d7gieHRqaL#NxWN+F3(zaB>|yvZ-X?&2(4KpUUws5_sOG;zuVQF78GU zHpkCojz)eI{XthB0dN0~wExyEB(s+vdw^_qiX?rny+?z`E$_{D*bT|`xPY>GEsVww zF)=YQ^CDT&vL>OnbPMms_w%L~8kk&+LymH?zdqAe$U4P9I(~XaJqYyDW}1yiBSMpf z9p=mi;?((;A$l-rmv%SqbVc6n?I zk>3m5zakazdU}ZgPeFknzY~Mdp7InI?V_I3>n*$mJu!vooTnEGFsZW;rwKaI)&Axv z0gjrE$w~X3{6}=5fVLk^`9*+F7xv%a)!DO`%0LhKFMt-$_cB);k#|+;z*AcWIMqGf z#5~=EMMg$uqHMCCxdE6pCz)=XgfAHI>=D+?iCZMJ$<5#URsd#roDKrjaJ()~;7*K` z{5^!l*1O&=W2|FFSi|VOqWi8qZzTGgQgULc9Us>M#x_bii4+OTo29DYU{JENy@AP( z`;+Qd-^FFS(%a9gexhLXz-m^D+=^ zGf%7)hJxW$CB#8B$X(UavgppW((KO3!xu{|9?c+g;?;Fn*(+eJAo zbMQUr-`d(@4P+{;$$Ig53A~hLe85VgD%ZWnc+z%ZFS2 z{XU-<25KhPulwG8F7ukN1Z%Je=9XH50iq292}s0g{|udbGlc3U@lK6X$s%!TEvvkf z2F2np&SrJf^hvT}viHY56wo63CsoQy2aO6P!)w3D z28i=@o4shEY{&ogF4L&+g18x~$P?oFzisrNop48=+vDRVJ9wI3PoUA;Boj09X*w8W zpx(BCr0VS3M6c5W;ezt`bv%xW(U34q|SmJ30d_ku}wGSP? zFur0cYpt^$b6ttgbz+|BuA>cGnnMF=EwYak=i|0NnE$V#3 zW_Ru8!zTasw)w-6W(YJ@KVfvoXjU^aG6ml>+w?TOKy z3!oxie2C?}F^MZrCSBNB#%n+4-J*jbXLn{_w%k-lT%&X`@`hdw&fQQrYfXSvmz{@uKArlM0X)yYE`;B-ZaI%I9E``G*%^dD(0wvSaK*VFki^yLX2Q1)TB#Cgra< zNo`$0qo8~*ZVCJ5G8(g;DUpt=s8GePtuFezjZDCYE&t%{L@y1xA&DFt)9wA{UVTZ1 zhew?|bg;a}>XhA+ym8Lf*vaWNHg;s;%<$OCllF8jsa_Xk`L*(~QCU88=|XpCl=B(f z4JmDddhu^1B_NNHhxM8w3<^h#2X^RsuH%vp@&#~lEKY10@wqL@{x(KkY126<)z~XL%U)@3d_1b+EU4Nv! zLF{agxWzehM!d#Q?SG~O{yb;=)n}cY6l({E4v_GsCeMFLSBsIfuenu^Wg6U5@eRz{ z=hZJlJ`thVE%Yod>Kb(F!d2zukMxO$5GN}Qjw`;IOVz@K;9M89UBK&ta|8g0|MZ($ z`*i1gV@cUHk%!-r?6a~;n#04Q!n|tsUhG|*lCa7+XHXAHbnmP|IMS0d*@d@1BwX*8puM~g;)5i7H2DYsoF95PR{dhW_!-2A~LG|tl%OREpoMCJ6&&`US z>lPAK(0!7D2xZ-~Wh*0vL028(*@xr54o% zc#37hfP`=N88@nN4!F>G*vLLmh&@gJkz zj1aN;s67?;GzRjhuUui`J~Y%WoIZ062P*got%;<6Obs~(`1$+yzWcTwqn~ZERA$8< zo9;57WvpX|+&^}CXWxc)tM{yl><-FnR-Z>Hq;9{~XsrsUEd?bek|?v0{8>@Igx2kU zUTJcngu{7WFZg}!DAChD%ATosHy56t@0P2?^uj_oObEs2G??b*a`f>qd$crN?V-Zu zUzIZU8ULaC{{CJHrH#NsXWkjO1TDlr>&>W;k&}~Xn^2&GXRdWCL5glf-s zPEvoYy*F25UZ8gP?PQlh;BEIAL z>)^QIpY(R^YwNZTEdl{gI^kKQ%MLZf|ef4mlaM zv6C~g-_4tW7=h~yU*xoX254}WaetP5X)`uu^_aWz3xyQ30FuYh{5<~W`;XgfBn?8? zE8L{4-KRA_Lj}X}--@mrtI9}$(!cVjzCPxx6stt&20*N)ldG``h%wb@{u&8eC1H3| zD!glpIBRzo_;IlVXMl!X6N}XSIVwKg`BhO$q|8?S%y;AP#JDw3jHd>ZkTAaNgV5T+ zQCyCmm~H#bxe`&9euasXQ|upxd4J#|uQ)FzhHI{V)jP2Ownk(}$6HhGKk|W~)tLFZBa9SzfdCGJHv^=ZvCRj!SQ^_9i){QX zK7$p5{zKgm&|GJt{)M=fVCAa42Io&sl=Iayr2^0X&Ov>G8%Je^uT4j?c?1JnSnBE# z*&+gHyTb0#Kzq+@S~FMgyXv$x#gWFQpEm)0*!lvT@dxGJus@3acMTjpLfkJDCWWwF z+r#c$02SyDGc6=)8v!Xa@)c=CWCNtMw>q_bFEOPV*t2{SC z7thoAq;09RL@Z$CWn8;!pr^1E$RmZ$MkdVv4|P7GQ)8(KSyI>E=lOK zzLsZBMkxNj76t}n#>nw|b^NpN@kzOagu-KE$2l-+&N!u=&erv9b!TAb=id!DNMP3N zhHd^&Z6V^18=Pq|E=1eyLc9Zd`M{Ku$il+HAw4tGf1Y=kQhYr{om{#1S^L`f{sYfl zx=#ZecJzj!qvNZT#Lll#eh8R1P<(}E(bGHf2E1*Gh9}k$}bt6-Ate`{Nn$Q}h3zcb1*oYac%>e+MR@ zxA!QR+$l464U^Jjy-q;)V7u`0@E!bQ78xJq$k=;HUX@TkwAYI4EtfrKn6dOU<$hyY zqxBd5bx{3Lzu~iNt9IE-iMO1TrM{bj_E~9k!>P@L0wUUawyy`f74+V-BX0!%`n>F7 zP2grpz|uH2UcN*y;Mb6_UltWzRC*&+!)O^19IY^p^|4Bwj&8hCsv+^~s+iU*-INTH zJQqlaf-5lp7gy&~|k^0mQ#X3;Y-u=Vey< z6f@r$jQ|g@^IOzeH}pDkEt&YT_J@|A^0p-jlj&>IRkPpmM`a7@<4i~aGoC4H;*|Uj zuK!3Dc><3Xvh&J|t3CHO=OTWohm3D_`MHVlW;V=zCq-qfzlNRN)_SCxy7WARgaXep zU`Df9oy6E=%3m7Az~~ORDln6URx!AA=h`K7tE@tf6CJD2ZO|{|7>*WQ;qndiT!@6) zu{XXu!Ye|&0s;sqWiKji{m_lN&r!AA}hvg}u_kyM%#$vYQ9KC9^Ne)rMB$2TW77IV|;Xs#atr>Lf#p+7tZ zzdoivPkI67XS;19&cgHP+j8#P!3>ZO1+50Rs`CK!*KD8uP>z5>95-~AsC-tM2Wr0$ zSv!5$s6prN_Rt<%9&Pz&=HK_sIx7hble-UTWRxCVvT1op>Pz+=;0jIV>cQUoOiBpN z*yX5~bnwapk1)M0?gIkse-k`!ymURLw?_iR`0L-HcJpyCDs1 zo?pcHUFI%$u}|=P5`V!o3&@{+vGo)T>48#I=pB+6X zoW`CTgi?;R%#or|x7m03vi6xy07STdfAjvMrMjL&5KcZ!vmN0XR)mo9#qP+)SW%y! z`asrNI<2a?Qz)TAW%8+~G^+_zl@ubC9nROrp7O?|F2Vc9lLq!UU(O`Y;T$hF~wfWgv1++&f zaKZDREHdQuQBm40hI> zZPLeHvQhfR^%T#ers@kWC|lwl|FVj6yLDbMIfFGR>f@$?j7T$j@l%|rR0(l4_c z(D|e_NcgdaM98+vecD%4TJ#aUGC=VQ$TO!gm~7{lBtT+pNIKFs4)H`NlNTAqLU@1w z%Uw|Ow%28jfDdGRKM&eE=UQ1?J2}76_EbkgQT7Tjt`UDkKCOxS?9a^fR38;Q+qJu# zs_?s7`IFBa0=bcHV~vgaxYZKQrO0= zF_Xy}dCV3_9cF+255>he2Z928pM#AntnMBTqrSc~ZLl<$rBckyq+GOR<-|EE^y%#N z@tKPZWJ^1^gJUBO=g{?Lyh0%-&O5A6=5SnoMkBa$8pAzm_G6Wq*2lS64t(oeODRg; zxoZ7ku-KDZz%lQA-#65d&TnJl3Nxtzs_T&oi(shVuL4*k{$>S*vK3EI>r+-nzbP=4 zUN-#2u7-ATrHXdRK{Qh^!h%zEdZzvZ;E1b%D-?xh9LG zqFJsaRUgn>{?^IFXH1Mw#`De?-U0C0_wZUo5)CC~*W{!s+J(Fl@NwvY zagJG=UN)Xb$5&3*x9N|8pxatDLg0o2LadE5UwFo8_}B>Jn3FJ-dS}$7J1o_#z$9X@ zFw^`WpJ(k;?-T8A{=xVVtcbP4MP`;10zL+9CS&fD zWYxQY-2J|5S$L@4vGFX|X38)FVC2E`t4hUAY!W*J4QLT$%inXYyr7pj`S`EOt^g+V zD=w5_3uGVhoB}H3ZVvp!|2|=~C1l~DG^L4Kj*K=#vlMIr*#z);fmi)e7MysiE77M> zJY&%SDRx;H=xU@WAt;Z+g@f*mIM$kyXv&q+$_n#Owe@)f)rBYGM)d~kVyK=iPhW$c z2ng^meZ*qc*3f`%sjn zEXmzS&kIiMIa?AQ9-dE-k1xT`t^n5+?$LL6UDPi67{-b}De5ILOvgDMAw$u}74afI zKk-c*9hH&=@J{WWjr~PjO}*RPn|WEo-?d51)kgv9L@(d6o!<^Pleq?n*k-NVb?$V9Kkyrnmnx1>KS%QAM1Y;AFXa(Hzej18vQRaU}{Z|Xw7Me5)Ccy91V<8Vb(QuzbL%@q{f&35w3wG@+XxY7SVP=Z?`Uc1Z@`|=1g@Pv zO}an+ZZ1&YOp+o2)Xjr>%5$dQHL_5*(TaU!AB#Ugb4djy#SZW<(04IW~0Sp|y(l-<#liD^>Gr_0t zsYvwKY&QLx-!L(XVH(bqO9R8}Ks5oNF}D_UT7Q3m)9w?4WUrnv!|wda;X~an!qyE% z=cf{??Y4OoLl@d~HiddMTmPEmi&jfugiykKMOjje zC8^xl;r!*X*iOu}A5o|%sr=&c;y$5cG z4amISstyed6sexGbzFwx(+50j^(W5QsXtU|j2Oi~kqrGuTVdyv2+Z*?EFicY4T(}b zL>vv6*L-}+I)I=qK3w%3WF-i&fL(EQZ*2~B+IEoZl0;Z4mYDjKEBL25k}0>@?Bv_9lE)kBA%l_{KE)4vc)e9_)W z-=b*0kFl)ezw5M#0Y6s{=A<5y3@d2;{gGf9n+cE|b9D2i}W}u$sacru&?tSQ)J+KwL&VzAHC=t=m5-ZH8l$|i!xB6=}#n$d7J18NdY({`2PzAZAhNNr#DK zj;;YK{^|eXjII_IIrhI%e9_AuqFUtHXQ#%}68WL?%%>bAhP=jV45K+IJ^bUhqMXY9@b+JfXlEqdkBSvV#bY{4}UF>w#Zn_N= zM2-vots6B+tN^@;1~WqW&r3VaeLIqDNbH}<#pPl7>+>S2T`)M_pHPUeXz-*)(*V^}G zDi}+*AskTsJ2x$MYai%f|I5Jwiir=ov&{_~`y~}#TWv@&Z{oPvLyG)oyQx{QF#M

    GONSV}dz+&C9f!y-3D$pcV;6v1L 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

    ?yogUfgxZczj0YIR$xi5yI_M&%eV-sU}r{CF? zI>7|((1)K)PW)7`?+?Fe6}+3Y0TnprXQ$5^-(+}>N@GndREb#s{#en9=9t{QNcsFH zXHhnB7sXMwR}$IXpq>KVZg<0`bM)oJ2(!l;oOjnwMF{gZ;={TdYhRYxpxBz9p@#&v z*z}HcYmO+>H(NbrDV&?JF1L$)UurjE_+96qI_kR0zPdNNfdl?Vfo8_7b)Z8YcWB-B zRp*0}T6m$0oqDeb5st~}F~7-WcjkPP8+T82$SG|TUT#j4xAV(2@eu*`{Wo=0Y>XCT z6?U3fHRcG-w&~zz$^&P=7L@D45tZKRWWR?J(Z76s00d}D@(nlC&EEJ!#EbN{B9B*eEGm{_dC=(C<+I{& zs^>Z&-Mz9;MO#_hQ$VygQ9%H4?<NB zN)R5_PNw!0l}mA!>yFy?iln0ZZE3ePgwC~CZ?VozmF$$aGVrE~G+nx!B>7H$Y^i>B zB1Ari1x20Bk1<~M^E?d{s4icu%<3whK_E2eu=~A@&hC4VM$&toUrmzF9kC(+9^t{$ zzjoFL?JqyHIEsX1#4>BGR=>8=(?{FUyQAm8(%Rw-ddcWJ6uHI5>O$1)Ub+hZ>Qs3g zk}Ti;L*o!}p)6Vz2vBv%?7KdEkBa5+am-8{mZc8ABS-NZ7H{NY&=eEq>IRo8AyReM zVF9cqWtdY#p@))mw{*BPit$M_^W3PkoH)JKbi05_>Gm_D*Bx*MZz_fSQRM$yZcx_ z0yot5m)mi~*5?y7_)X*^O+nju9D(I;9{NmtE08`4tDmCPk)#spZjfKdQI-L0uoWU2mnZ%XLy#WDPPf%y{zWY zPMpXkl~i2R`Z-HGfBWH%Wx=c35)Zz*Vk;M^03)p2-Tq{CO&3U7>|%hB@SV|RO*!(} z)xlME6fMUchITqQw@bv?8H{7ME*?EwK1r6oGt|H8Rqh-%pQ}woYTg#1e&z_yz&^2E z(lCuJ`}GHMXoiS_jQ`az%m9t|IUvf{MW$ljkfL;?yW+$!OHL z#y%NtU2*imhvO&XaP`?aPNJpfD!G)^WV!5@CG0JxAGV)*AHMDZ*b{6ikZ3>c7&SRy z*W#MQhWcSy6KYTKt8vma0sb|!#6`GIO%CCcEj)V`xw=^x_ZX7Zrijgy=%8xAc+hlZ!-W*o;tNykpJI@G)9cdrUNytV@q6MZ+DiZIQ8uHqGGE3;WAI-S0! zE)pI~4u!RHzwi8`hjBRVJ~cn*s$5TgB#w_YjP8aP^^J<=aO)cSsE%oP8(czV)Q=nfHJK z2RI$9hteJV8NCpx-bSv&!In8LVyH~itJ-OJY!{2SZ+$5~y8V}9lI9*@^D00CKUr3j zh|iTbJ?59=xu5uXfcW`+=lOlGs`eyARlBWX4eo<4AW;0x4s);~8qwA+)s|L_2q~oS zr@)HBEWb9JZe5Sdivz&rfz=c6efYS>lT|O7A5UaJsx$3wQ zpPT!$cFV^M=-UEpr*N0qrTu|m0K(MJV4LHCg0v-0RRjwv2)e`_i@$tCrq#pu{v1uhqT?9t z{UIA^Prf8Z!ay!qK=5oip&-7i&99jB$ZezR(4rO(g`&k3T>IS7;Ie@O{~f#RF*-H} zAE-KOXdM|E)7az0Eofub|MP2-+JcM%g^$dV0I>nhCMi&N(>#EUcfl>0zOD6p3jTqSi!11H1QhK#=XU%AoWZ=Nr-nlnN^C2#(h z8~T#QH~S?z@!6iGS+PAbat)-YX$&18E^qz&@(tkPaQcnk*U(rYMmTa zJ(n!RmF&TN2`juQrg+)zv~N&<&K@rG{5fdJmJ~kAntPfy356F_d!2viWqZr25^*S2 zmI=tXKHLW&Y|^}JyHUDok^TYz0qDrjNhz@V2n<&OuJ;6UrkCvLNU_~-ml8KDUMsG+sUsme=sRHCZD3=D#O)zqsh89)xg8!sEpe&c2DW#lpO-Te?h_iveF97 z_cB>}#yfnhh3hfx6^d(ry)P?c(lFJ=)uVVj2R+n=PWtL=&tp&jcc@=e*rdJ+ReLx> zufUXYbvyUv<^_CzJf;7uJmh*F9vP!eH)b%FeXH5w(VU(~0F&PcH>wSc#iQ6|T(S{w z51Fyz?*ofs^ai_*n?|$=E3YdU+gZ{IPy-@bCUAltfQ1O?+>)Z1JwI-c? z8S5r=S-B43n_T8peNdLc+eE5S#49VU&Pmeq03sIZ3jX zOD{zpa%jx8&D>`Ajbpvg^-P6St0jBMre1}~|Ds2& zpBZp?baW0LrtU+c2_!rCjG<&6KowgMi~_IkfVIM8$Wf54dNkudk9NCvYG-hwCjr2Y^ zjD~6Yk&N9CM~f6Ak0*||IlNLIuQp-QNve5>e9k^TodF9$EPmhE_%5LS6z&Rpo;s z78;qmAur6-!Yv;X)0T1K-sH5_*n;DT)U8I53H{CIJA5q^+v0ln*8i(KL)%q1YGXy^q%L}gA zKb%JaLdUNxs1LPP0iIS0#RYk4v}T&o7A(lFKBUDH8@WDL9kRMQ(Onw|^`*xV21V6m zQ`jd#O}hq&V+fl|!yyK@_Zf(X$w3f4o8cuB!${I{EqF_ENOa&u{@0730iA+>z+C2b z;|akN)=JIZQJRY0Q|d-H)k!Y#dUl=}#CRfo*(3nCUF)WKbhV=(x-mKIot3&%&lC5g zj9iQXn3`*4Z_G!sr|$|e@xIk!T6#SK6%E+ ze?=?1h1ZwD9rF+a7Zc^lyZf%t4kAeIJe>INX^$SKLT%mXI3BesY!xf6g2W5fvJdBi zY{`u&@T`q<*Jl6L4J3&Ln@6m${~CPomClK7WyM&)Y$U%AuFiIORZ>XYHEYL zH%SBzQIXh?)F$`BiEa-JPz~pI`p4E9Ap)=12e>6oQlaF9a8p1H?OZw2(Dd9gY6I6= zfH_Fr0V!-^=x}`4?4j;d!gsZq-sm9?K?1Ml3GHvOd=~SkAW~A2wl8B=a2M!&A%@1I zG@D^#V^cKICHk`ReN%i-8)XBs9LNKx4SAMzzEhkIiiv^*?0mYlb5(4}* z4eDz_?Ih7v&LQRBWwkMr>H$Th*>aqTZO{WE2Mu8hSK+9qkX0`WQX^4NT<&ad%Wsa| zD+Op}d?fC;PDN*BTyFKz`tNG)y1Hs5SZ%&RtEp@Y22ES+wPxb2KQz>t2>;kLqDMt+YP80+ z-HCfgYv}09zmkJzPCpvU>ml!dpBb??9sV?0%%6pn;ZuvZ?P!~)PJ(!2@NS?*!8FX- z{s_?J_xpcYjU&srUGHRSf-3mP%5Rj(RS-4mH*It#TI0Bstl8XQbPNiz(3ZHKkrmdF z^6KMOHou?{oSJg&5pCbtz1ql|=5fHXHEfyJ!O*gNCIqhR#c>KJaSJDtbI<<8GjLIP&u6igUe;P5 zD?B!@jhz*R{Q}i3);fUVGq{`%XS`R)i3Z{E`_ALMU`5l=6jPTY3@^e!q1lO=l3qGr z%L&u;D(5RVVh=iad9kG!nv$=A0pz+VDz1GS=n8t1yHGcP$i>EnrQlPOhki=(r~Rwx z6E2=fkNEE*;Mrl)1|eT^Tsp*S^R%N z0;xapAIPKX!WnO2S%Ba5s?@pd>cz2JQOq~p*yBuzdZ3HO9}nPuS6;WdL?apfUrRoBHxOYl5vq;xv{y_Q zv>ql3G!q_cH)bD!U_&uckRU_bJVD(eG{~el^kg{nl-T_==sz?pN=D>T$b2@I6NPZQ zqGe^G(Se+)tR?_9T&Qb^T?k0;GZM*g$dxDg%$Gn;#mFCIV@M%1>o@DhcwYy{kB|`H zM%_Oy2m}n%!&gnBKiPx#Z6%6YGBDF_n_bAB#%fd=5l#LP4lE~e9xqQP#(*AXF1rDS zd1hUH4RXf(4aN^bg!Bd~@1!tHB!c~Apc{AVg?3VqhydE8leNcl$Wfg^t~=x&TFNChRVjSdiIo+3c=xwQSg6*}wZhk@P-6R>Rcd@TD= zmOJRf_I(Zc>_^Qg7hi|ed2NU5@QLqQ_^vZz&o$U?Dzw>6hMP20D&Whww$S4oDFX0C zjQkB<=2cNqw8;zKD$%S%Of(MQu_LjSZj{E#z zK5h_2g*U>!tHT$D(?R#!Z}eks!LShd9pWixJp?sfnM>rY4`Tvc3nJmFg0Vrh0G5F_ zKu%5#bLFf$hhuQ;>GNiuziGOb?GYFo;zQW+cF11!tB2nsZ~6x~Z@kII4i;|QYLq}b zlBZGEeSlN}^1{(3++oAGX-GLjulpJS?ygU`IT2Lvs;YdbO`n>HufuGY=lu`VpmvjH z#f6YR6g-kVJg$xljvzk9Dt~SH7Vhq|WTb6OGFJI16`{Ty4;F-Qt2S1g(5qx42SPlSm_n;NRz;IR)lpTo^Hy0NAwGfr%rFg< zI5M1thGVzrxM8+)U-c)#Wl=E_6d>93%Vj!Up7=(`J8mce`rUsfaOaPkHvz?d;SFJyIf7uC5bhbDr>@Vu9LjQFE-UEzbHTiN38vWu+zy56t$pzkd#R!BMM z2RRc1o=9Y4Ztd1w^bIUJ&6`g|7%W7W9~kXCUQU4jjZp_w5p&=K1@F(ihVRl?RX{2ig#ajNC=~iwp#WhGn^01?#cYY77bg?DC4(OPBfRWYuP zP@6tVK!N}91{AA>GUq`}$jy98TDYUSsuHbh9bQu3+c`T@UQ`4V)lXU3>RWWs(jhl= z-#063MpX=?{Or&>{qV(r?z4*tfBWbQ&YH=ecPTUJb(%AeE}2wSUv|z4AMBp`Bno9; z=hspCSLf!;EwAQ$T@JY?8#J<1T%)8Hy?1#HcN6Xxw0E?#$nwDpYsOS!eM>fv1unw= z*F>p9WbsyI=j~I;s2S)GCknBPtw-wYEAsV&zO!7z&~aWLoFG1m@y2-n$h%ie zrIE!61PfS;K#blg>ql*7s@CF~9pTy=QxpV49<^ZS&t$~u^QdziYWW=O3}7nH|BGH& zTU)1ldwY+Tm2y?Zzy~6SqtwZ**FZ8MxSkKjBPuCywm)CGFn9Ji=Elw<(cye}{GI|* zL{xe3&IzAFgMLUXr)TgVkHF)|SIdj7tucX(alZjC=G8SUr{?a#yB`N;#Vu}i*?5ot zp9>Hu&f`+w7PnPL<{Gy~V-gv=^h1BluXD|9&U`D&>8=cdLra~!MN{~q|J&D_9Rp(W zvRF))C%iG-i48O1O#WMGsH!?ao5_~7hRN8wD(Zg6Ovsui>OT7@lgETN(E-? z(4jxFw3CDazC&(6)uQXkC0-8sCQOysjD-lBxh zms4M}j+{rgc6S!_v1(=z?@uqcw8O+m6{fZepQm>qXXz0SkEb0ayTn@%!q8!=3N`3R zgvdPWL(BtQHqIT=|KtM7-k1qz$a^wTUrOTH)XU48^Zy+xrPLy3SZ|Oc(;L%8d>j<~q$mwT?XT{0 z%iPv<+|VM`@)_a4C(6tAAkEnh$E@;&D`gtw>QP;`+yFqY(GqbnE>N!LgY<>l+bAmp%xKc3{m$ zy~|pvBZQ{wRnD1G`7cf5d#TlLuCE5_*mWhydX;gO77rIwst)z@>Mt(<_k%HoVF?Ze zBiO2)Os7tTzK_-H0u>w1%|!z~cxsByfN`ye^R}{8NGD@r0Oe03LU6$56U{^a^!8(Z zJUv+a;uhC^Yn9lcXx>xqKO7@NeXK#iv7NvH{GieKU&Uu-VK41xIU)>1oVaJ+o<5di zkY(>3f6ARzv#jwdDRsMzARHV)(@Z#zJNftG$rG@G6!~=UbSZyA2|>qt77>h zn@@i+|3ELNbZYivwc@;u7vV*zeXM$g`YD^`%-WGXnw)S6k+=QS2uVFR4+ zE`9v6P*M6KJR?-&m@z;0yCpk=Z|j72`l#lC>Gz@3;h9j^?SVfQny9Hswe1(H?cv+U9MUOEg$C~wwEPhn>J zhEri}9j+@JV32CXW68fpYut+38kRXFrMn^*Tc1|BwL@*8q(p9A87*=OQrc0(>+IrD z-pwsT)axXO88^6QdRx{L118&)ah z-EW_Y)S=f6dI!32IJH-Fsp(|=_4`}Gz9pr-C|}i44&=`My|EW#?x>uufPK!5rtUod z@YVe$if-hu1AB++!3l|#tiq!|{wjP@w+|~>dCK+U%B$oIqA0sEV-xNzhia^YL#Hmn zb3fV1A)4l7G=3YA@e%d(2B~_pvFPb0yn|N(V{2m%_RkP5y|FC zg-^HE;Tmqs!9qV8;)tUIJO#sbJQvy!-yQ;QDuwhE94DwkcP3DX=foS?rS;LDZ#%;) z2q)b-uRFJxJGhwV&hG!9WtfPeg>g77WS{^;#Ki`w@nUUV99ISTN>^G9LV(eH-TpZP zr*=3<2dVxD@8;D6i<$v$vAb~t}6glp9&Bc51N|fK5Y76kU2>t+pW-^k}1rap3f1iG4 ziqsK>kH?`?a5K-fO5OHxC#dQA$@q;yhd&2Eg>TWM8iQ}PN%(qOGa*5ZE_=d)DMgk( zMe%*Qf?#fJnGx5=i)`P>Zhy;&*Gddr-lF)Jd#L1#3Ob5h{BfO`k)i5N-!Cf8TMh?{ zs-GC>H#1*sRL!Haa+X3l7aa74)w^5j8ApZA{+%Em@fMvXTMnx|B77r`ewf>RSDjhJ zlb#5m4Z4kkuQ2C|2yhHh7NI5Zim+ zK5)Y=gQ&&i!Y{buKCr<)EJGJA-9)4 z;&GQ%bN-H{=Y*y=mWfkyqIKx*|IFVjn(ehWtWHuLO5MQ)h9<4Hy>NPZ_+NI^hZsBz zG_~=k8`6+C6}xKP`V4rU<5yEU+Y9-bdLV)}Qu!$f*f=%#*+`Gs4J9zpPOE*I}6tY5W^`~O@E1O z30U80zum<|*$3V9u`@j>m}*lEe;pa@6^CH%=u5qfqNB--9m7}d}~a_y+bAfp-ch|c<;r0WhlG4@hXN}*Wfa&xb&!pfq&ja zmnd1$#VlBmAc+758^S}3m5Ao1_K>T)ySr4br=H!bDLd4Okh)*qNjHg9IU*fXP?|@j z%=&Lx>R;;7cp8er zg1|x_&3Q?y@01aB`XavLA~yG#vIo1PM^-EUToKT;!}><3<6W8qrBnzt3PausSdg!9 zD89)8>qVOgv1byka04^>N81nrLSO!P7SqEIi$XrzvP;#t;S1*mZJDB~T3W8vLwuxdRxY>X0wV{B zQpzlkUKQaQIq?esNQjS#rsmgSvnL+W#X7_DuDlO>nO=a^Aa0?Z zBhi>z)8VnX<26t~b_ooyQA~Yri;spdT*SL=XTRNB8f#N6gN&f# z>Q+o&37L_zIn#oz>4CHj;hXWnR4LA3dn^TbcA7&qzhvtv>hOA5J5RJJh2 z7j}MJt&O&+spdz%W&Dz!JcC3Vz6AFjKkEV^WbopE1#Is)Wp)Y!D0IF0`D}p`)duHA z!T#`q3Pw-xm27fk#2!BB(;iaxY=JbPd&}{W_Vdr{64~t`+I$qa{<=aUG1l<~6`j3tswtwM!eonTH7Y9feqwy_9M>fr<(bjmbZFZ4Io^ z1&kK-N+T}nBMi9YtzOE?eApzUwwo0FoYpGpUANHPDz64C*O2}u=5}(}0ruO2h$}yj zh!+#h!~5*Pde?r@b~!oD9IwOs_Yk3(bK>yfN817rJ9E+u(VR9mb|r8{ay4MFgTy<8b1sUb!C{@U zccG!Wfv{<7Sh@eh$DneJ+CqwM9fLQCTGtduLf_fWKsQVPP-!rimi9(Fl!P*5s|TQ9 zh_7bKLBuV{n*f(O3Y+~LuqNtiFHJqr$G^N+?|N7zZG}tcgh+JUIU9dU;|@BmWg6uo z!G(9%dklbT(m$SZ!6MC9e`nQm$|lSF@UmENA>XyeK1~2j0T$rAFEv*5nMekuyPp>9 zz1lHUT;~wEe%99yHut?b3F;M}T-zfNrvvX@Wu6cBz`X7K=Yu>hGIQ@!87zq7jk*1V z!Ef~z6MZoS%yp&Jp-iFMaS`rl*-D^9nelF&oB*hp4@Uzjx^$EH*a2!svdb;{r|Rr)H)Sm_r_j%52NHC3$du@th7~YtZ1ZUnqZMy~eOk-ob9d!q< zI*yKV3vIkdtoCn`_Sz{DBFs?70<;A@%tTxks9nXp&PaDzJ+7hCNF;diHd|>Fl2HkS zxz5I^V!kQ=j&-vfckTu-2$rVlxzzJ@Sxh2VnhmASf=R$Q5|Y)khuIKrY-T57*TEKb zHyTRTnmXl8WU$BoBowRx4*~VQFzU*PaD$Gw2zUi=F*GdWb^9lEwp}JkONXq`1by#w zKRAfZIbE&P!)Mh5-8b)9dQD*)*czM3AuwF*iqWvL@1{+^4tdA06Qv_W&L#;haFnNk z4a1(TKiVUFSU=NoFY;sm^;#e{lDFgXt6RkEnPltLCk-LRc#j&ZIIW?d_+`|VW8r@7 zimkNjz!Q5<0SXF!-*Ae?UG5_(Are{jykM)meRC-~zV;+Z^PcU8tz1lF!Sy-f`|-6c(oDM0324BI^hyVy&u?$ip}^`Fw@0T2$DZ1JgTg z_oinkR*44hE6zX%0GzHnb|NY^#2aVM$jXMJieFAd7$4dBaexSi1Cc{He&b)|CcV!< zCtaAi)D~%sM{=-O>kW2N_}w^8@1Ichh<1DX@LyIqlX_0&kIiJk$oc61AN}kVEMV6B zx#9TlQ0SJiLESvD9dZl53$d=wpqe@TD=9yaRqXcZEivR7cQukL_!(B@N6b8Sg2zP& z!SRFt(?#9J_lIFWV?UO5aImvau`Q0NJAGtdV}kTP_mG8O9Rk6 zPy8h+QcD!%0BRYi`eoCaZQ~>Pq?oN_xz~wTYen7qWcilRoPPyjF z(d>Npp~?6i&5=PH?o;z@V1u2^Gt{Xn_>WB!T)Ko(9CK;guU3(PB#5^1= z%ZG_aUmPJ#3Ftm}p+v$H?cp|9xG99(0UXpD$K@QEoEK{AhwlR!7ABb$AZUCV@QcVK zUg(aS;|QU+np@bmvvS zHSyO3N-SFNv*CWq%GDmaTRzzq_gXU=%?Fua0<4ebx39KOp!m@p-fkOV87)j#pf_~1 zak@A^Rxp#mFH?tyR2Bs;;R=!&r_PBHS&sH<3h-1HvRN3G~xRbG{DNn`ZC-stVYKT!n zI;emH#KZcK*X5OPf0A_wqX9z?>tQ-P!B`N2P4p6(K z?&DwW{AfWoy_DZ&^}S7Ks2ZeQ?Uk9@Rl&x~X@nCxo+UVUe=k%EmMtU~Td@MR&!N7% zr)a0WXTdvcsB;@4@B*BJ>SjUaD|h*KdI7Yt_VcxBA_X2vWa9aBE&bHzz*^$n)xMQA z`NRT@$;waO@I3CTk2we(SebN4?y!UD!8;&uNqwc{4ACIHTd_M!nEkt5)iikYO6twk z-3aG?6|3H8#2>tIg~ByEl)D+X?2a3&lMN{tv`A)O+^DYtt&N3;KyQw_257!Fx&4Xf zNPk~5?@Sf#EEwBADK!Z0l-HKoHy{~nU%4J2 z`aEykW+vvxC_E}H*zAuMc5)HdHc4#ePAKG1Z*-cm;651%+lIXk>lgb;oRMX<>Y%7{ zH0Wd@Nee^k^Ahb)#-Z$5(a9f`q$I(YWB(yFmie@({p0FGe@TOC>5w3sNQO`mC zU-PHvw6Y8UQ)X#ITz6fNX&qGWw&ZCfEB5`n-+a~ed>KjMbL%qt?Z!j-rkFR40~4ZC zzJGAyAwrmcH8m*X*#v9<>&jkjDir4Dd<)gQ8f5P&su6X2c+2%hHtdnQ8`u0LP3l{5 zw=!Ih4s)&Mp3oH?d&{4H10Qt4-<1z6U&1zG!#2?V%PVl|caa~_9RD1s?`>8G%?kB8 zbtZKDB?VHv(kC`~0++bDG>`-9-=p}f{T@f9L}k^T=N8BZ@9H3Ct4>f}+mhCnc3`L0 zNO~SnAzk&nOur7r)KJ9dOsViSU=Azj2NS9t$8e#@*Q_3r?~seVBLq2k?`(v9FYA&C zeK~2Wg}HJ%)bX6MjeP_PKRwMRFsLBkw4B2FXe?9`^UE%9h z3mnWQJa|D^%@GOux8a(-5lv`F=f5T}TaRJpC3dyoV1Iv!Hc(TE(b1Oq z79AEBCUDL7OUT^sO))U8h$N7?#X1u;f`j8Ix36I-{v!CbA9u5A<4MjhK_Wq)0zMMv zl5DASlHvB9oj?HZq*NJo7v&&r5GjNYTL*Pg!%38P&zDKA;=!o8uw;p9iSDuvr+t$v zCaa+B1UENnB8)+_U5~6qogqA|XzVQGvaO}hecWs3qwNOq!roi=DpYu1oD%2gaiAz%!pB|H42)Qo8K44FxMEp7OWf zu@kP~Xxgu)aF70yMY@@p;s%-RymR~_>zAdt*d`DDk5a;omOg#=?I2<=`kpMd@p5uZ(Mk6?lgROCwy`E zw-*l;e(GM<>fl|*jWqDtJ*~sbvc+zIgL*|-SF-iawXQZnPE(u~xr`Cc|8Dr|P&F2H zDL{eNVnswDf7@6{UN`{KpXf{Dsus<9g)H_&!6dFjoOD97X>g1m32Hl~MwiT8+krwa zEA0BVYqopLMt>8m*SU-On)=c98XZ5DiUvM36DHZ!5*aR<9JS38ftLuO-wL>Yua<@d z*pM2DiNP6y)(rig)_<@MsjFC#6lB!I@w)DAr^QHhvSQe^A5Y~<$^+9ZG7N_RAFD2v)jX613x`S(N5 zAaHismSQOo@#mk0c`ER>;gxwMe#|Q>wcj1WQ}64OC{dxEE?AuWa)*NEWT?RO2tPh% z3-{K`9 zH-C>2#1BhHAugkfM+{)m1CBlwS0GwF0RG|(R+ji(cI>4@p`wB}%8v^ct7+~C z1St%}FldAbse*@O8j7x*a+Wa;x1T~Eou4>$S#e<3`9r4$=6g7>sQ+Q2IsccbeAd;D z6*;J@N}4yC!dK;(uQfD*no()V`t$9vCKQs7)|ygZz3MivGQL|DG1F}rv-MLs-tO}czY@`DnFrE{6yAFsfoX5AE= zd(Nb2R(+|?tObYaq}v-SS#1lXV?=>s!P{6fgmNmVH_|KA^42ND@Kqz`;ITgfz7=eP z(8@(UMHLH24@2%LrHQWFdMV2MKsO}-x8BE{OURaf9I7c!#l~}SEM$CJcDF{~oTc{U zAKDOp1nM^H|4M+fvsPNntdXW8v>{AN%8@xA=PtnKZ~e$+bD5`rp2PvyjcpNw&r7mr zGxdNlG^um$?pxB0uvjihr2C-JH&?&D;P$ljP)og3ZS>VXw-$kFank403Fe5S>qzVd z*-(LD94?1U-?f^0#EGzIDKT<};RTi?4H9Vh4*SnHWXQtQ3Dh&vtif)Mza7(ZkW>gA z5;SBJndH45v;2NP$F|R;9>IENSuhGa3@#fUiL0nCrsyj}81Zj{5?fp?;I0GlUR{n* zpE?z%GXAVfXK|_W*(q>PYU2c~gephLI4P<+9s$c!>vW*iH5&K9J8|I`D_+)nRhT1@ zZR{SCrPLKm5jzFr%ubFGT7i9P+EUj~vqK$L4n^HglQm;baAg>;_&}|46llBGVr-t#F2+;G5M{^VoK|6Bl} z@@oICvcD4fs@Aae6XDyTkAKA{QOk&F)SLyxS1l*PP9^Q@{@q;YW0w-4sHGQeGJzD; zs;uCI2{hM@$jS?RxGbTGCLi`Du#1|1UcW>`qZlI*L(>i+%uCQtlq6CF;B2&*w2Ug4 zHVD1?;q8U^9K7g3m)&n~Hps1;GRr!9`%Go#C9w^^pDtvN6PuR&0&5T_=!RIV099$T1?b{-?iRn zc?ixNA%K0c2kR>sy!v@8I2q;DJ=w0b#!0l5ba)dWO<3BW_exDgrJx z2Ve<-0(-DI>Nt$}n01Ds8%;}dJ_-%64eHPnWSdflmWN~ky$7Mo@ z%Tr~{MbjJZtQKLqX8cX{C;T(Dy6y~DxGb2CC>#%$13cR!mK2n>LQGB8MZMqjEO+X8 zUinE>I6o<8Fshmi1BK8C*U(3qwCr1o$04JL@I z4qTKfwxO%`-pnl8U)Zr-PIz*jFO$@(%gLA`@hFetPzkpuOpNA9WJjX)Lj{_Z{h7&s z>!2c8J}VSSib%#CW_%Jx9cY)y=iV!+WoikOiGFzXfUSG@P~AMkpsOu=>nAfLE}Din zoTS_q6xQ5i+9p@ukP(^cqVTYg(eW-H8Ie~kR^P4QDOdDD=r+l*GT2wzEb3QvOx_uK z>o2Fb*f)2r20-qumwi9A+rZ4C#ToLupkvuS6WQ6Ypq^Q7mGsB`uX2kha`>S=lJ$W; zkAyhqepNF~Yi#n*A=5TZ3nq8uK6i`49>>Ve4KLo^NA~cSnm4m3%JJh4JRK zh)un&)XU0Do9&Py zS5x0Se))m?8XK!)U1eySyYROxFy{WT_Fh^q3tD1}MpX@|vSP*#_~DbuVOu_8`Zo$| zfM&XtXSmK%N%zJG{hK!`S^W`Qm;nt^RWL-?oex-)#&LtRL3#px&lCb2k;C>u`6Um* z^ABpuDj46*p4S7PSjL(Y^R?1es}-CGs($Qkt@RY^^`W4%b4gB_2VcONa)5^THPULGxFuU3*5U9;_j;Q0%^T@mwBigTE)xvu zPB^btlPX(p;q9RSBPGSHk&(uhVFqhHCd@1(ai$`q*)f0Jno|ttVYF^*XP%=k2g+Swq9yL_PRZ62EJDz3enaAA4(^mBjoTV+nzswNyE)JeBpD zO3DGNyQHkR7PUNPxKSCd=KrQ>YbX{UT25oI{jJ?-7T{x`T&9x9gb8-Pgr9Q2?q5IM$1pb=$j} z4*jM>7#6cPLH(+0zqq^IViYm8pFmwtYAJ$V1eGwPSlWfDnvsp8ESSv4aL{ih}3 zdiG7WLUx?Fv(;{z*YneK7Pk05Xx{CkzK-MqW{B3WTddGBh1k{#_BDU6$!@Y#yG z8rh%hKln)$DYLPdnBWqXd^`s`MOWT;-pOvr0IB<};Jd%LXMD$>I~xCShYpvL?%dL> zXYaUx5}SHf34%31UU}4Dn=+y{o2un``^!4M zpCUdLnA!4MYy&lpHH4GT^A&Zk)D{C##8rAxz8nP*PQ> zQHzH$1XJGx$OyoMZ{Hw|N4^pI?;6P)4oF~h8E_{vrw&OA9_mp)xhgN&IhT>-{Iz8t z9eH0ISUM__&Q39PP$XK%?Xdc(B9_7Ah+B|n?{ajObH;jQpF$XWhzx#-eqr$q&5Zy> zPm)H~vN_+>i1%POz2yzx?h69SaAz`(AOP*NC?Z!?GZ7)5H**1Pw{lii%dI+8Dt&B0 zyk(al0&ww>Z2-2_7+*+KG$~l@HEiCl(4443$j3F} zX25#$$o)I@VK8%YiNnQvTuT;YIW1<5y10y3nE2y9F$GuKZ(7zai=y0;l|iLH^M_}F z2+RQwSXElG&m5%&t){ob-=2MrCSJJLyALK)#5=L;y6*zLXhb1L!8`tLNP)pL|JLR1 z`}26}`TI9F0cfJu;&m9_rHq&b>;NkZa?`97+!D-v)MB5SHCCB0(NrkO4K0R*N)(3p_+9vT&1=cCOLk?_YZK zG=Fj{_}Su=IO(vkg*{461`9j+5fYldKxxB40S|5;9*+%OP}q?Xm$vpP>C{a>sSoqy z3)lqdgbEYsSWXBploV--ZE@)Sd3*U35`1PhN!!mxJ+|?c14S9qSpAD0j1DfIyrC7E zL8f)hfA9S^3smNn>94AMIak0lLsoS9HK*WTm6Ijx5VOgcuGT+9!oIYqFjDz&*#Ka+ z)=p71*)824$f=P$Fx75_l0+%&uJ~WUkTf>O9Wfn%DAte}O}B(sVNBxa;p8=eInI&D{t0qbAChW z%W0%i$~yx6pX?Ds*k{A2Vo1)9axdI=PeJvsM90kuxJg>kykHa`=n^KkQ3!<5fZ>U~JvY`ea?S@&gwS&cUM>VCy^Vk#$13Zcf`dX<2 z)x zyE0>j#JBK^*ZQehLgA^Lx15S* z(Rz0qVeE#V+?-Tt>_cU52tQXPsctK~9j5@JlsxP+9OLReN+;zXd7j(K6jFHq!-|y| zRbYFnqqsUjr`4Dm$A)3WK4skU`tj-h#@_FUxrw;~FAWJ2#9u00XC8Ay^F$zdS9#QM zP~)cf`#r`=OT$BTA|MPhaZ~YsXu8U0f zYDkOH-QCUT0n#M{Mt8&e{QlSVeq>zxazA_SIOp8=i5Vrwf^?i`F8-uP4W05X7CjOF$z~ly|Bul$e5?c*nK#$ z{^}<6$thgNC_fIG`7FBB*OXE1`M8YeuD%U-oXV>10f^N6wO=bFIhTvH_X`Rqs&A6| z=ehK)wzslXe&HNLa--D^_lMoEnkv!@1F%t)E7MO^GwWW7;Ui7jDXqkEE@kdj+g|yJ z&7)H4bwknuH+_c-4#k-~b(Nx{t@E*LbQ_Yb~0uk|A)e z2I^kRXU$Z)r*<|}BfF=>fc~KBb!CyU0X6bq+V9+AhoNMpEe-928h$)x8I|2lg9hw- z%$ssinpr{S#}CeimcCdQ%h}-2RJo@|uEqMx%uWu+lRescL*ey~dlhTSOG`oTYG+iY zrr`U<$H!yA*@sk9p=Q{k#`zM+J)nZm!J4UXQxe&+P+U1pj2!53uW{q`mdsWLs@4m2 zF2BheFUxPWpKRW9;|GaV(VXvXfY+JB}lT#QSc}6^j98gZMw6?5V-Qqw`2Zd zgTEo;SP;>5>B>Et6~Y-#$A@9P=1H6OX*MHEf%M+`l%?N9)rcZ_C?d`yEQJJNwTAb5 zl13+u#wEWuKS%$iFoLSOb}dZ8@i^Ukb4gdh?O8#Am)wmxUhV{}AI6H)>>|P1T=0YU zPKmB@y7I-jD)iJ+?n?qPS-=oMYM*5JMj!83Kb&`wL1ICO(_vP@s>Jy(eBCGQao$Y$ zInx_g?@DW^lX3Oypk^c>AYhWWbcIVN+~#l>Kd$~3G@lsCHM}6H@=BIBa;in~xBf>| z;B`>CT2tO$!eg|P|Ba9D9l5zB0W692!a>lfk^W`T2h+5c@;^`E!5E(>dLvrnq3R9d z_NG>3c!u>s?-%%&aL>(Dt*G6z)j=0NW zTbjcMcqd%ZL2j(UaiXVjE4ZLyn-ck#)Q6r_SAeEnJjQ(RqrkHl?p;L|VLB@C<%_@I z{L+FqwPG9Ijt%#ABYZOf7Rp-6tG7CixxW_p(DKTIl%R&53J&pqO?yD>n5ZK2f5(`iy4r!N=?eM12 z}6cp%X@7utN^nyufldgr>;1IJO zmFL@Bby1`{rod4MXOsaXc@uc~>+R1ZpF5aH{)si1&$INwA+|VhU->h*NP?0*ueZ4F z?f$@sxzt!cO@=y_>i1a1J*kLbfBs`&cN9S_7tA8Mi;)B>_n?11VW)A0 zruE73VWRl43f}0r|G_G5R_-WTfJbAmoBasGcvAnCx>|Z{V_w?=nmof&#?WoAvN`Ck z8!$2(BQ2Z)3dkSYNe}QfLKeWny?@)hC@lPBMTlmR4~FDE;&71AG8WG*6G93_MMqDe zZv0PhuKO!=WK!G(o5;{yV3oA?C8?Vl_lRsGa`z?z)Ji)KCZdD?Z@ssdDTK;Vl_-rF zV#Pc;JI8CbB2gl?OHW!GB31`e+7pIdV!I3_d_=3wHPwBZ!t!``KF3|{M>&x8L_$x@ zNY6Y!;3fk6=All|2%=x-%C{UkY}u;Foc;mIOOBdAYAPOO6A^&|J%2LIuAM5Eed{|n zW>>ZQ&}>R<9{VwuHx9?Pvt1&23OJzTo!ghROzJ$`k-SY!lPW8jI6|A}AkfXh8KwXF zEh@1mSt&K=&QC2!hVK7d4 z=Zy@9jowhb>~VG-YjlCyOpsaZ0Z}Fuq@WCqUobLW`zZO&?5V(Go+FBDH|*p&z;jG`(P}i88>u;=u}CsM-e9e!-kaC$$2?G zqsW|QMj_-nmB-g(E_x94DQ5<^H0`ZPVlQwzRx6wX~_pf$H>V!ekj%Cd#^e?%)rA?KB zE|QoIlR$YXdO3dZvKdED`GFE|?)tzNQ=a$l-N^%LDu_2e1v=JVR(2ZrP44;~`a?!3 z>I9=H+HZ7#0Fy#4wr7MVbIWMVsA(CyUQfJX1~0QXfTy%RV1>Fl#+5e>ecB=!Wk8jb zlz6UG;6|8dC=aXt+oKO&1`(u~<0yJCbdM-z^aX96uZ_WOoVQ4P_H17$;umJNRU3VcWGJx~VnM|GcG6u*m=*MWQ?8? zx~#c5c$o_mnOsaRw?gyfdJ8I}Rz+{N>izjDL6|9Vl=|03+`=vet5a684se$4GxqUB z;9c3FyZ^cc7wy*Di?(3+s(`5^aLG7nvvSte0tf7Q#>#=_&wq06C;W?d zZGH2tMA!KuiJ{=qZx`;hFAFXjaJnG9eMox8P~17V%M7jrra=Wja1dn?g<^ZhG+@xR z9K{w-Bqc5?Rwe{JN6SA(l!3b`$l@*-{G!zKRi?bs1SLdFJSdsTk2ud8CyGA(trcVe zhJSbC)4^}vU|E=$$d*)F&P5{8ccJkjDs0sijN#vM5nS~oVArIsFcqIKRlAlwdifeQ zGFgBCqmhow`+k!2CL_=?Yonk+xb7B;P}VQ&;rC_6agMi?L^rtv@%`M-!rQ-*l0niF zK8L@Q6c~LntD;;QoG$#+^@a# zHi0W^d?f2q6h>~mcrgjFp>7aap0bwq3c zn~$gr`micOy^&60zRL8J&xKFaN~eabjP}oJ27TmYzn}eRUaon_x4Q4Q(B^W&ZErgI zRADQ~ZT$tah7DOW{zDu>rnYj}3Xnf%p^?d3lE$C%FEY1+d^Uypsw7YaItrZ3is$>y zFEc&TsK)k?r^_g}e}P`;Ei?EN^?{VY>(nLbp_+Mu(1yxP1|VtcHsv=wg?Cv3bj6mGnXm?V5pV7cS$2SVAKRuOH^ql`^eFOt}ncoF9TEk z^En`CD-xtU$c8K%W5L7aO>b`k{7I&SrVjb9+868xttpzY3D&#J{$6!Q_V-IZuhBV8 zf0P>0@nP$gBZT9XnYm;YV4%FzmgK^Xp?aK#N%x*GXT-(x;Mu50{E)rmg>O1ZO7sZD z(7@utk4E}EVqMYt19#$OW?8@OLU-ok33-4;dFpZ<(kJk(9_$+T{EFwb2CH;RYDYiW zR@}G0*m?}2fG5q(MYGB2lLS)q$>vO#{&h$3+fzY3lMK;%3ZMNO+Fm0HpL#mTsPzLj zuudyntfx(lP>8(#R}tTcO_UO}kd?TvWoF=!uzfs$FecI$d!)LMv%jGTHT@C$DUGae zZMK;cf6pKTTDI>zkOvFHT|wKG_Bt$c@*vY8YOESK&M%NNWx63~=g-@&9N4>}W8nqc zG$%A)kAfS%$%Kbw5TT;@o;w_{n9b{%8YwM|RC9WD7iUr+NJyg0L`%Eg{a#$PqAo9Q z{q+y>FvW6Vb~ZPq_uTb~$er>@@a2#j^OP4yTz4s(v7C5{D~7?f>6=W7BALEZ`)Y@f6$1aQuRT8$2@59nrdFX zpu&GDuOL>!@=iKsNeBn##QEmHIjnv4!Sf%}US{onqr%VqJ~ri-J%_RSwx*fq^!uq3cl-{3I%$x^@6vkW48FPA>lGtKLi`F_OTsZEBiPgfGb1~-uz*A0dJKdzlJ0>FX$61WQ>v#4kE_-koe z4Aw74rSt8?iEi(sF;w2Cf;U_{==&KK_BoGyMM1M8zJS zJ)~6GYMlLC_X&DNjVDJ!OyPn#s7l-k2B7#8!|z0&3?WLbq%)R5d?Z2))AeP%7Y9oc zMHntrX;U^x2~u>?v=e49>{{O+DpMUGW0Q>_LUTJXVEzIylI;$Rr(y+}ip6-NOyhLu zjck)FyXDeI*OtvRSv9p-@6n(WU>`%{Ce!r-mi!1kKIkggym8<=xyJ7gVLL(e8Q(bl zR=3d&3iQ&&P*GJey@;W5IUs2bX7fMRqW3w%FhN!0opV8wXRJK9UOqyZM3F>Ec*z+| z`a988GSMSPX8ZQO*IKMvGIyz}y7tDKvvX)s|4W_Jw2^~Y)ZZqw z>$J|4r|$8-{Tj)2tF!#(nvwgkR((r9G+CnHDrm;iH$L%1+apVOO=g254ue&_o$Lk& z!Y33jf(Y6*wG0*`=`$Yu%zcLr^eU~to7jJcvrgB&yUoxCP2(ln@qpkIJNzTK676Cn ze*F#S1L?qP{L$O%w^8Yge|S4~C3LQ+<@iw# zofJ>7SWG=wlACqr%J0h#mV$TMF1030j+JRw*5+8lo5tVMZC=;eEk8l@av4|X&ah#j z-HD>VYAN_-?I)NGQ*03LOMFR58TcjZcmE^$ks>oN3FUz0_87z4SqTyg>JcxkY2!Xbd6Zx%Kyo^E2p$_Zl_mNwho2%KK^k3BN-Md>YEq^BO< z%6nuV)byQv5!1!7qZFaSf#E#0SvNP%HaT2fX~nC5_Z`gB0Z8SR{fxLjF8Ot3nS)# z@lj;dZy!G}Zes*S4_mzCjiiQR2D)&D%={8k2)era$n@CubHFM+WZZ#ohM%wT)!SY5 zqvsjE&Ju6J-<(QhAL!i|@;RUgikwn$A+aBJ3ss#3?H$4t_r0h^e7Ei1V5ta8|7Mz7 z``$5lEWaze)D$w4Jwvc;N(2(uDb|Q^k@Fk)_JaA{wb4dIk%IN()$jCsMp*eGb%z~; zR+wn{Je*VO&-|<-Wav-w$;V2Ey9NhhY-2;ercQ=0QW#L6G50Lx^kiDJ-Kdy|l{e@g z5ey{yxt^fI1QZlFYO41L3$gzC0WzW9XeTpWSR zpbA_4^=N5t+oHEraiEo&*(+2}JiGle%ph+D=w77B@mCq_<{@R0K5Z9nw0~Oz9+AcG z2f3=k!Lwbi*B;jvQO|l-yp+yrnGgig^CT$VGnEz1h1KOaN|0#XA3_TABHe;l)OB)y z8H(2L?qPudsJ6d+{ZzZeFxcMv^Br{(W`eT+;3~ZlQed*jfh2_<=xr-hv$d!G$N;zIr( zbdTVBC z3bm^^ihmln1g4_7+w^LuCu19%kuZ_1Pk=go^z+{rqyU{n__e*_NC~kx3X8k=M4J1X zC-(eBq=F|Fnh}D_zqMr$p(}3m7|}uP9edu%&ZjYu%ClaO`-jG{1}n`}7})V~UVmu7 z2sieXPjH%$1(8UYHPJmf&ai8wcPB{NNFy9!DRH0u3+WX6{n?Lckin*3c7C9@r|nY7|EBUc`Ot;Y-A<-KPWSI^O@D#Q^ci?!7}211hw85BG$j zj};;qFO?REoi=0JY48^Hk`dw5eAO%Y9L7w9KoUS2PZmGd;+cG%c3W8azO;kzqA!L~-nQ_N zVr@jPRW`xQDPO0z@WV2cbE)LS?~&(?>|OhP*Qe^6h3uv3toQ8=r~k?CFiGQ4EMnO) zS*ALa#5j%Td#x|$n?~^6B!qG{TQ|V4!+ThI>x5j3pDE|qaqceO|C*lD3pbiOR8aAc zMz6&N*Or(r)f>QGExNMsYOA=2{Shh(!!SJdrS7CLtXkZ`FkTu)K|FdZ)fc-?XWW3H zNC=Jp7bqtERiI5b@t37<(jGXcNNJgE@7#e5>FF z!48wh2l~rlR}=;%dq6uBw7f47eH3A13}=Z9D4W<05i`5@+p<|>eGF*Dh?&Xpe>F?~ zitz;i$CJs3-E9(_z`Cn;-%fl}53M*8|Dl;9;3(|ZfV!VAuAR6iJb3g^DqoQ(Bj0pO znLJBTT8lH5jxud)>Ew=vy?OfLBw*(ov8KqhZJjx%#vP}Lymsh6&Z)S2-&E6!c;3~< zwp$66_bUC=3I?ALMBF~l>BEWsU8bc=7#;iP(xV(wlO7#j$pe|_5AlFxz}vgO?u)Xyx&b%art~%(sa;`_+uixRG zjc6&m{?3EIyJ}r-w?2r}2V-1-#Q32j_*jpNVzPbj`5BYas`fS82;j<1?+K^?IH#BT z@g`^Q?Ajbi41h0Z->kivoh6i#lDfQ>SqjW)BBq6ef8k8{h;Lx_lqm6+1CG!l12L*g zQbchf{^s>ulFh}j+N&1_UVEn~x2mgB3FqNHX-)F{He_<|dRhI{fzgD6D0#P!@IST! znPv}aGBSSB))O~9d=!6laT&En1&-38_ac)!uPUjJ>F)fkm;DX3QIF10*d>xE0nk}?hyMW; z<)iIWi7duwt@PwQL*RM*W}Z%xL0l>CNF$?VDIZY*W|c*iDmtmy2)$(jct+Z}eFZM& zeTf%=?EIR7Bo{V}CeL7LJOrrCJIR7TZSHMXC-h^xS<%d!EU>3V>winW;IEBdZ;`6s zjubJe3_yZW{6L!AiyAk{0_hN8!JRJ*p2RFAb9im~Y3W^sfIV~zSMY`d1qku=GF0j6 zmKz$j{!2hMo!L*9nzAW~#IBKS>g~ZkiV$h(jc>fEA>20=HVcAyl^yZJP7vx-6(4CA zTrlMzv*~NjL8zft#N5x9z#oz#am_S;Xjzn2PHi?0E4ScKb;Z8`3*rMA zl_hKx))}gnxXO|J84?$l{%#9o5`oc7NyGFi%ZQ@He(1c_FDOGbk4j;X)3t1QM5Ex- z{sF@ZMkYqSNU@*s`6)SYewSKwJlX`Z;u9k0fAK}P*}eo9Fd(p@LSUFoHvS3iFj$BO zuann1(4ho{F~nTC4=&EnSCV-B7~=2DG9WW4)55nO;O|77yRmaBkHqOYyhdTNQ$OGR zI&@)~U?X6nx0yVL>tH%I$USdepI9KfWL~L79TxH+-0^ z{5%ut^|12�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 diff --git a/.vaunt/badges/badge_03-03.png b/.vaunt/badges/badge_03-03.png deleted file mode 100644 index 13d327fcaa5df92a65a5980edd84e0d923ca4df0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 126985 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�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

    SRh_1Ls7SOVxOJRS!1fB*ion3>Oj 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 diff --git a/.vaunt/badges/badge_04-00.png b/.vaunt/badges/badge_04-00.png deleted file mode 100644 index 6e1e908ca00adcff653b34b0cebd78000ace4392..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 161435 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 z z_9OLpXu27`d-`6&%FM7AeSjOeHv?P?8&!xuZ3 zm$|9#6*uqXB=p%0w?YMIYoejIEk;aqBn<$6z(9+A&tLxM?wKcQ*^Wy8_842_LIJi- zq_?b~BX#8aTYNOhPn80uvl>Pd#c!t-;%8tmyLbMu2WNjZ%)Zdz3UbA+EW->{1G@0V z+VSgijF!q-9Gd>d=+;^9GY$^ok=0MKxK)7R%> zHpJJ{-d0s6p=7DUKI`_wk1fAJB|jFFZ&x2UkgHwF3zAjH4~Y4v7CQK>5=t%kqM;nC zlpRX454(V|U^H+zu<~ugQh3LG6oJ_0DQu$ZY+4Z5sVCS1yJ>=F%m zX=Gn!-7yaFWrqbyYMpKW=7k5?5dY(Zv3j)jF&^P_?4Hqn$*JlTq`CQv>*Lv8QTL*` zj8}@oElP)h47$D;_-{?Et*ynf+}wgi7_q?(6y0YK!&0AksIhp@ZmE@NDi$z>CCV)d zq^oJOS`s^v07XakPAHS|__k~n&;ApAI9Ltf&9PKeR5pu~U((digE)u#9u8n!T*zYC z!a%|9^VHN-)q9wp-7TQ<5c;cx>#2}5GC>jvs|6m5qN3%LfG|0tAt6(>`45>wS=X&( z-a?FsA(YNSCC1YYcKc01BgQ9K4*tjO>X4eL`q*#ixZE6?Iu?xe%s3}ES7)OW6skHF z78aVRRH{{bYin>8gSgf@nH8W+LWb%Q8A5Ab&JwXDUPn@icS=N*4$j-tv8JBN-3|ai zXU z>f&}w_UY<2(J|GrX#{>SeS8`I4 zAc8yP^yCSWAF;VE+Z_4Re7X8Sgc;rx0bYGk0rlw7qxWY<>NhvSx#0x!oR`2y$UAIh z;WVhSYFswiUENRPsoBb*E*3HNS598dcX4Y;L3k$NnXZ~K8BBhJIM6RJa7j?&Ioa^& z1c5Ju*-GDqlF89?JIw$tYV+>wroJ9M;E*=tVM+@{0{hM$aH(~h|KxlZOCA1>OVz%% z$=gnE}x4n-vum z%|3+*^x6wA9Ijs(qS9>Sr&F5WL(ZqDNj|_t3$~#18{9XB&vY<6jP;^_sQC2T=5&kLKNA&My1<`dR`holq>D{Tj~Y>`Hlc zM=r2T1%^^f4~sSH$a5d+!B#XEu2JA_oXQ6W`aZ2~i6tL{XI6l^;MvFLm)D_*_J+fO z7RoBh%GDsjWyi(cA+w7|$Tj^Jm_jjcjPbb5fAoVBr=iJy?$5nRR4j*B;_95YG5YP> zH(ZhXMq>d8enJ7aIx<>3<$Zu*n}m zz~MRI6Z*XZWIGhikFe&>F7JzZ+=OZgwkP`kaCHIGv z-9M#Vo$Uo(U9HUp%}w|%Ot|=YSh+b(Ie`~`K2`xvX zjDK`z0{t(8vY9}k5N8)_2YV=R1L()^8|Z%BVCvxf-`rsKmvp)rAdzEf^2eFL_ZEK~ z**vU<4PtKX0x`FPI#{^4n>a%xEFtzTb`s_erVvV5YiEdst*4W@wWYO-iLJVWtFswI z!_yJsA#3I0;wZ?@Zsx{j?dW30=HP6}ZVz#XnmL$5pzOcpp}*u^0C{#7XA^6Ch`EHV zrGvAziMa==z}@}b0JU{ z6K5AfDhpePy`_s45sSUKy@?&f{-I|JN;?yKYYRZc%*58x0%~Q#$-`^@(BlhA8~0Ml zWh3JjgpE&{dc-2G8$?Dl@2VRKj#=*6v)#2k%p6V3X4{MBB02Tx>WfkD(j&A0umf3x~kgU&?g)!y^9HrKKCh`C$XhAG*G`hFV+No4B|-Lp+F}5L=5U zzmzZX%fkM;^zvUu9F%M3>TK&l|L?N@l3@RJ?{Ay^y<^*@7K<-~vwV!xHw8}b#-2z7 z6&f&iynT!%dqQnKz})^vr;Ptor+*pL?{0A~D{Syao;2l+#xBKTXI94+kBZ*OT7>E| z5QdS(2ZH`)Iv@~(_-`}#!(utj{u^igYsG*mFkn5H!cd5G4h%oddkf%_2Gk|T+6C&O z;a~#+>^H~E&BRs*gAW{p!3Bncg#iHvOo)$|!sNrw(P5Bavx6{5fKvppFmN20V06Ss z#$oa>5IA^P7z7YFFbEO#x8x%%82D@`yc5^~76#@IsjypHBp5Kqzug2+8Qrz;wCY4p z#z)8R(MNJccrd#sbNArlGTs~JH#%OQs9~`|*Z09gBMQzuCLEHzN*oIJgqWOQPA(2k zP7bgDCm%PbE-W&029aq4e|KPZ z@?i$QrwM}!OxuhD75oShP7@vx2Ub&^g8+>8&_Kb#kOo4H6cFfGC>89@*f@m10uLA9 za5(?GK&jyj7&YKWa@>?^>Jr>w0bWXVc?rO)DK)I^AnGnAc8=EemXuNwU~&R>M>PnQ6li<^TJ%*V;aBfuk|3x4sxISDYB?T<;&|22s}yg@=jV-IEYBVdiz9RVGxmj9l*gL!AXMPl~~GEFX8U1*N+jBv`Tp?unvXN1l#fa zcA4I#b`EvFuZ2COTAaKAdDCavj|y&v#Ymvd3nZLO%s=f#>>9qZeIEo94Gw|{2V($J zBEy7%xrc{`gGCAeqdl~79@?;A5E%cVMf=b~1EU}!Gb6$vARxgZgDD@*Q^FI03BbsR zh?aq9Fn~Df-;IUhLE;HKAs9aZw*i0BPAQZf%IKEL?)vH_zbnRX|*%Gjp(G z|5Ka4cT|r1_kRAdoqyj=DG4?+XIpUKn?IKV0|Orz3=Rwc)BJe`3=>B9dn5-lsN+9I z0>Ai63O4N7pYt(!m< zl@m9>wK%%-&|OU$+uuWYIXL>`k-{dywmA3t8>^pM*Mtz=&SuoI6&xAQm5L%t;ZaPZ z!JKRJbRi;jS9sLG#1+@*!}pGin?IY&=}cotpIa2gcAJ0XkT+%~i0Vh_)XSgtmaXK) zd1sLRy|a({+uJG~YSz3X_rc^qNk0*FM>rFKozN;@3+cA8xcQqY_Q?eH=5ce&PQq3c zktUL!XF}`AAWP}Cr`B$uDmTeiOvyJ~eL8&aXxdd_C*O5t6oqEJnJP0_`4@TdP=ID?l_ZIs6{DOBK@=fRX$)sH|#%40V}A98O)B zvzlYr%E_VGWy$GjQBTD>r@ExUPB2Q6`jfkJjsdZmR?9f28+iQE)h~LP8QN7Bjw%XC zKf69Ku7*jytA-Ydptx!4!~m{PNU*rxx2gn!)7_Czz;qP#7M%w?)WoCsyR5g z0D#3QT;P0GBLR* zRB%w~pow-D+C{Lww^E-&rmzp8AFKA5145#x3Fo(`L^=rkONf|7C1)&Sw^T(A#C*W1?YxnEp`fO6qI%4$pcG9x#G=jP$y{_SW8Cy4=EeDp$z1%MK-=XfaQ?IL&E%&q zM2F!b?y6o78!EazR*mm|g(jpIMP1ZRhkS{P^%&0A=t-mbve`nxqUhNdmrr8kkKA@j z3}juGjNiX_1j7Kr2+`Q<+cfxY2!7lwn^`^VRzHMclY%zH^||*WEF2672EaE10N-@L zj~{U47oH)55dk23$cz33J^w8-{T;e?#+QSJoD9sL&9hmGtv4i>lVU3W6Ek7Let8-h z?Y}{!`=3|=V2lme`hOE)B>ub$3>(Jte}FI#9xBHTpqmR=>S4tc@WNn0Fn>00Hg_23 zpZ)w#$oW?%w*MOd|IbY97h?J9#J0uPI3yQKQ^WXKj7?BUE>;qG+AC$WYh3d|InE-JC37LFboKUClQ~_u z?c3%Ip8-b{pZ%gHSLFuX^J1(|2AlT`8j%O1QBH1(2&!$ z*Um9*pJjgZObL9i6;^^G(>>o2lf9mNeO-{@T+z|h-u}{Q@*7UTqmG)a-tcgmM&cD46u>AqiwSv@JuAEJNbuf8G2#*km+DuO->ZeTNgjFc0`b(^TY9guQeGoPl>Nge{F1u zpJUN5tJx;V7*?5_&Agi+Q7br#m(20m^bsaXbKoS-U2ERpvG!yW{8i8#=RADm0jSsD z%jLime-P@58!X-A0mMzRfHC}$9P^q#ab76qO>*LyrUo-bz*XB32J`CJbuqg%-qUp) z46$&a-$~J?@3vf>J1f8CX`uT#{|J4;d z2Q@q;&+8!-j))*)XM}tHHXgW-G6W)y^6V=TxTDqBg-MiVV7|Zi&d$LArUTP}fg6LS z4&Nns^M=66ydI?oS>Ks<;c8uFqK1`R&~KzdgJof? zSk%h{R&+7<_~}Og8@7?BOeB_p!(MgtYkPNNiZ ztUzR9hOk+d9z14NKy@WZ2ayX%J=lTNgWz}SL86B$G*!7`aCD5GsWCV;^mq7uU}3KR zOg)}}sU8vu6dd9|=#9E3K(y?j5BZ0Kv!lbW@&yMOnB+kS6$keZpmf4M^;v z9Mr!e5Ri-z{c%~v*}>e^%;hfuN;$6Iyo?jzrGI84oZMib`DZo~n8Se$#(WqB4h`AN z#G2I+=;UD&e+`U=BjsT40u-qzrJNz=z`M1HEtCTXjQwlwXefV-`-?sP?ga@AS>42* z@~Hz9@~0d!8j6&Otu;`Bv9~t)rxt*%{Fgz%;Nw|3JF-4Z!od+LZt_q-dEhR9xBS;+ z2Ie7|fdP^k7#Pt0FsRTsOe9g_YZW8&Gy6_coe5F`&iZ0|%(P~ey5rVGTP3sT;IAeX zVyeoIMX(q28eI!^@7Rm3u}p5vA7_B6%7e8`Ff8!fJPD@5>BgiEE_APF;v+*K6mKld zH>v%)jLMAdhY`rtG``8gI1e$v&a1=2==G0#Qllr5$nH@1>uulTDtLaUevW`tXorA% z+PMgp7jhJseSw%T&i&Xz#$=p3QRg_7VroF$>$}*Sp5f9Zh0cJ<^J@O_QqtyXt5ogG zs%34}n0s?_4vJ-43r5>LJ3V%rvrxvahz2IeD#}}}E;aKDi{x!{db_%4{IujV;nN=# zAAhJVq(NxgAHW;|0P|OXMk4-=oc=p?B?op6fZ>NCz#l~db{H76Kk*a}9vm3^AV3Kp z7zX}D`u>uFg#$yuPJc?m!h#`aW;zb8lt3Ai(jLfs9U;zk)-Dgl0v88LS15$i#mX8= z`3x{rd!X@9X0W!fHUp}1lt4KV;^;zY0{z=Prk;R2gwpo6xQV4R1OikQUD&_|5A&gb z*8*#R)v{HxpZ~=v9c`>x0iwzV^|Ui_b+P)za?MPP_)K`rxJ=xM&V_7cJ;`F8sI(iadWI)+{yqz*{Noso47=B#h>4r}R1zgtd&kcb-#gzL zHrw;zi{T+Y)s#htX2sHI9E3(SX#FbCQK^q zSe1@=i@AXkMQ4Qjy5JS3t>BDwmT5wxf}^y@@zJ+nwEf$@K9i}9tl)KQ&uV(W;GT!%E8>E4dz7BR?dGW9E-X}P z_;xsx-FTV04ButF0cTWHp&#GTPkfFk?PRyYCUP^~LZh@4Qp&K^T`NG}RO&@2#^on$ zy*WxAH(U?*- zN}f~q6Etg=+5KmhIy^6-Cp$(BF>_d-Y2$?2kUf~<@|SK@h|}Hcg&8b2uTJm7(FwjY zV9M?ZqZljt9DgYq3@7e72&oh~vOGwwYN#S+;iAvz_4({G649f*?=im>y0~`*+vz{N zAhM2o>7?#OH~B-K6#hIi!J5MrcjZ**GZ z(!W^^*!G|C^8XFg_|0zNaIpS}-oJROlmw+5=L1-9@N#f)3j75Y+#EoY|4*>^{|LkW zCo)@0!PeaTs7hbn_6{w$+!kg_)q^%KKs2)O&8v@YUJwB=BX0q6|do646P>3@!Brk)A(_=algtf()lnXO(la%tbvD+1q*wmzw=ShbwB_$ z<28=irp;#~Ntki}2nqu&$3lE;$j>FwC*ehkJr0uYP7E4$8=ako>Fxel-{Gc4m%D;B z?6@SxFGMany!bGlg=L!Gp-+7te9dHqI1^_mkM;aBVxO)}8bYS&azg>vVm zj!~{YkGr9fIfdtel2yI56CxqC#8~>qam!y?op`X5v@)iKzskZ$FbE$85-mA@fx|z*69y5C`v-WU zKU8slRoDUWL;`F7ftV`b=iq05od@7j3@q{|n83o|b3BX)1s>x))Rg`;q@6X?j2!?N z_J_R722B3EK&j zG!m3d`o zTI({VO}&Qa)Ko~?6e$E2ZHDkw`o<4&?c!&4^7+eJxYrrm5o>f?l9R}V<0ok_R7~Po z$-Ux{oc=+E0`)mglgs#$)I!b5EUTgRx{Z25hUta0VfWUl+O3b)LeoB<#g&F+tn-lt zpYviNwrY|aVXs5R7avyp#j#CONGjjFZGAP@<4$7L=GE+~dCi-zg2}u+)8~8Q20b@y zhRvU=*M!u|KE6J03+h#Q>Y-7ij^o3W=6Ms+{Usqemzhpd@zVv4LQq1J9|G?MIU?8MANbg}R9?<`DC@@{FF#GInw~b(B^x))UhR za>z~Z>Q>f9Obxh?I&`oO8%|ecyKOaCeh6%1@;nVa+bhk$z&g<(=-rNlt+Ic5{5=e0 zrZquH@r=90VKteCFoJzz+$0l~V8K-Fe75o7VXO{n(;tsw|MU7E4g5y~|IxsIH1Hn{ z{6_=-(ZGK+@E;BQM+5(V*T9($49ICJa_{Bobpm@zm?52n@Tc-R{)sg|Wv1|L>I`~f z+(xPbw2Q0ly6j|;%G=&{=hn$HFM9A!4)Vvt08u}8?|G^o<7JnAj>*s5E=bsrX#WJI zo7o-74^$*7i7SlJ<&^21lj@=@*LKyqRMJbRV=3qBS4bAegEpEeq)4e-Y$jf8!=`2z zs3g7cFj%c}2M8-2dfNBYbP$2UfMgT~q^qCeNgVC^RMw()DvXL26quf{$Bu56SdN@y zN!Cq>{9A8NhJ+&UXi8rZjvaEX*|i3r7Nz61i(RI=}~ckuV?rVf3ZmRD(d2AO&d&4UhDl zX3uw|UB2s=F}5d>q9r67sC>kfGWs+F{4{Ur81?vvwEIP9{pH+p5qBNm@`ch&B2xR1E# zj7!k;U3dw)9L7=ABqAb8(Im^d$e@ZqF3x-VlnHqGamuP#ehN}kpiS`Uwx~J<+52yI zC=+|JW!k)$t7|GNZ>X`eb@thmb~9xJedgw=U}R>kcnq@8VEeIFzyv%5nPW1T(3VD# ztn2S4Wi?V0#fy|j0S(u09-{gZD8q-YQGO21^Au z*QcZ$exik_uX}mVf6&tv5*Fq>k#&W*j$b8gV~mcBq^B;w2iC8_rmB`*`1S`RQC-B6 zTzC+Al$g4eO18SXYV(1KX*!Y3U`j*XK)ocp?M9D1Mi zH+}XSZJ-z(8!Mo@)lf?*%oA6pP0%s7u(0UG#B4tJ_~R%_#I9$0@B0W(DHAh0YqV5# zG6SkCYiKrkc)bmUq`}+alUq@^T{6zapC10)+ag%P<)*&G%ZBM!tYP>hKT@&@L7Fj+_Fr_78al863r@ZKbC-_iZ zzY#OXo)znz7@d(kHl^vVa8WR*{rD}GTU-6+%*e#X#b!=Uds1S=TZ#(3`m>a)t1I=Y zIdP`q8Jf4SA_-}_a{{+}*N9zmqN5t)j@ougvsbC9sl>3fHi@#x0VfN3Xj_+Wo`*Gr zqz`-CwvJ1x&>xFof9?qvyq=GagirDCa5sHC5{WA*N-ve6K^Q<0-XLn9`4o0!7yR>M z@!`(GNJmH9;m5=E5+>$WPn)hX_FiYj;ymZCPf<=Z?3pgRyWRJG7SFU6mzUQIsgGBF zXliPD_xiG6-&7?@>)Q1#{OK2BcjVJLftEK#@bfODTR&LP;B#|Tl2mvj$_9Lyyt8r{ zMie~T*kD~T-bD*t*JlKo%8+$tKbKzf_1K3ENRLxDdv8WxKu4Elq^5SIy+7%wh;pG} zPplA_`2(FbT)73h{(a>;{q_f&eLKB5w`fd9qqn&~;cl;s@3W4!%Y#6NNjyK1U(zMf;Mg2{8^Q*=F!4RYpkere^n z(OVqZO`)Zw;md{K!^HOqFt*jO$BdBMKzGAi7fr}2I}aa^LvcxQMW)jA>2O29mj^Sh zKJ26AKuWer=_PfTo@^cTiFrp$s%KJEGSR%XX5!y>L%}y3u5!Mpi?)>w&S%9q&6B^U zDbmwW=Nu7m?Dv0qhl5807U19j3kqN9x-ng!Rx^+LaK(4$4W1OwfFE{!+b~n?WT{|i z=#!Dr*ucf2CM&bHV#ri!;>vt|)>AFCttyErYCbA<;mZam`9@|Wfu))O#ha&@DU)!H zcM+r`k1l~nq`?E``>*LAZ3%j?k`HErT(320q?#vgmZdUa{ryEpW|wl2MIW6sJ3u6C^VQSsG= zi3hcP?Ph*GG)4V9#$_)IJq9oi-&L6xmAt_9eLUi7#BuHVg@~!$7pwIH)M;JptIFb; z>20*QLEzDo$>XSgT%$YWsE^bBtL$z!9JJyhFR(mR&bveeI3~peIgfsB9DKh&o-^3L zRc)8ZfBSMe4p-jll)sg=bdOzrA_bkjqqx8z9!&|q?hPBPaz1tO7C5N5-l!bQI5GU5wgq(e;P7W z=c!USa3aRTA;2%pe`CA(miFFfnzi=U?r1?x0pg?p_yc~m@a0hzg;lA|g^@OQMO`BY z%o0neN#7DuY4=2&d65yy&t>1uZMu|6sf$eVtuGxbG@ykqm&eKJsjwjP!cYA3-hJG| zlq9629p4YY5y)?mu@=N3jW`yiVr2CCDh!c}bGEW9AAJ>X z6$H=3#56EAg#s!nEtS;MOWR}#dG8&E=}P^GGD;*6z6i;8O=>pvHZ&q*ITS|ij+zd` z^$4Hqa2|&8OC8@d48%lQ?wQUA)hu@=nLnYp|a2K?G@E~e9?JM zN2{u{$ktf=+H`}oh?0xg$=1pp3_{jMrda?}|Ne7xqHUY) zJY+jNJ76W!zP=*FTrm$vdU_> z;;;wKnsx7uzszsD>A28&2C3TE+WN9_07eWCAM`(@rlT)J)9Fp_S2@(hmi zlnD5GOtzT;5>pA&z+BCj*dEE*62l~TS8|7i$=4DYW!NAT$ypI?Rl=>0pZS4j;Jku< zZdQ&5+a=T5x9y)GJwsNP8s+s5Q7H8Xs>ANJ5%EhBzvV` zXS(s|!9i6QSNHe#OEPFNuZ*)RF!Q)0E{)pYa;e`#!UH~2YVFLscj_+LadTHkicDO- zdNroCfQ=;3U_5eL068ZGG z^MSd!*x1wUxNh!Tj^Tys(^nfmw(CG6yB^K&YJjl%3Hxz&d8y1--2p*m)l{^cvkrNhLz2{mb+m)HW`ApOdBRX@}}b>0!J@HUYo#%F;5zYYM8LGr3=fZ8cvMb+K`O z*9bYzYEc8_QmT~a=6(USz%gr;4-7bbU-7kcDzZrm8E1jnI;5 zVk-6;N((0*e0`@UxwVBzzP`T6shPY}9D#YmqMB%H((nxV?Z~|D;dbzGhtqEjur^Y+ zWS^|G%B@-lIvoqOB9@NzEm*Yas@IK=y-d$cEVri9Z=EBMVtVzO9yY|_*+q8Wc`?$` zIZ<%2t6oPdUH=ehxct+n$0TD8;@;juW9}}-%V8MP@c|&lTe7!U2s!2VImXyn;a*s; z*4@pr6mL9`U0eDWa~5m6WaaKZAIJ8|;RrpWP3U2HSXplFyASjCdp-VhgDrbf=+)?o z@lz{>@`r&wMMk2@Hbgm2q-4T@(DlBY+H=^e>#J8oEOu=g#tn4pxuM8xEj`JN2`E3; z4t!>u?s*wee$I;)5taI6wB0;sd+{oGgtW*vW`1+jPn^{AR%o6t1zoF&^JAWHR$X9n zg!ofBtB>8Ht}T@9tS^FsL=ek8Z3GphT3zVeNrT|Uq%CbI zb~u(1wQ^tWdRt)7>1TpqVoy@ned^ri6Y|Z;_JZ5XyFaJ4mf-dl4*!d^TK^?^vW`^Z z*a#^qmO8PqS}~{(V__;xNj5%qA!RK_IYVAR9IM`5B*uWTE_KZ@RRnG>v*e4xNSzY0 z#f#xa60WrQP(LqQKYGlNcJiI)UzLxFtHj6`ywBVUs~lek8H@O)O8OlV-P?Vs=)V3i zJw09d(F{&dP_WYEtE`5WR>R=iV2{TmU%ieVshqPunS0{6qyx)uPl+Ej?!LHmF0pi8 zV>^{D`@PV4k``E9lBS`^*_Ho?@(*`64K+N>mNr7nKkcNP6u|y+nX==PRs8-f1nXXX zX`(zX32#51XV%z0TVq0m=6rw0vkH9-JL6NwJTJFrj2V*cw%(RHFCeajR2C|*nj>4* z#Ug^P?!P86F|HE%jJB4LW>N(!c?BE(n`eW6-2qI{;lv2vbg_5O`i1UiqcFbKi=R8- zT8g+&kDSQ1`Ha7Qi_}w>0J&Qk|sfPhkX-|Trzeg zwYB*^O_uUTb0sGXOPVZxw{V4onsos8C;dBzC^=WL@{5Y9=z^M-+%4J6*JzSJ1C>gt6>TM}(7)gJ*mJ*4sGJD}gA&r6EfXy&Rj7MbIrl%uP(|SDVjy3T-NPEZ!>Dd*ZRcLa#-i8x zPV<^`646B7iRMnEaC8ON(lH^QhGcO_8DN1$xVT0Evz-52TXX+hQBe`)OauP`1X5}} zDDNi#g8lX~`71m9&wh2WxlN&1^}^>SR*v$)N>5Ah;$X_(W@;&|Sa01Je&dD)EsLf2 zVF~r6)?34QOx0jWJ{b}>sZ^wv?znTJ_*9vF*1O+Qv%}OO(2HN7WW|ZuJMAYUF#B51 zxQ@3kkAgydX2#%qVfo@pTc<(Yu?Yb~!NP}i#dBS+?Ud{%?&CG=*C`QpuW-Cc7caZ5 zEq8Z!Cz`zp?C0GYgBu;<7(lM~LQL?d9$@2-q5$(OxMDxMb=6ax-Y+m#hO|8FnLrOF z#;p}pPklOxx2B>sNvv@SET#C=YC7H>Z=>L`uFJq=Qir{9uGVY+q`t!aQ`Apu?yUyG zju;0~EgksScNbsZu@rVz6;F_jXE{d^K4boLFH^U1P`*u&)s6XXxVQ9vUWgs*=xXg+ zLB-#|RvcCyH810^q^5>f)=0Mv5HknR_L1OVze-8XlaUeK z?ivWW=U?s=|5N~SL(URm?+v-M?UHSZX0zMGjJtJh)HSo@wzT(hjyo5RUZJ5&Y<1Yo zj)C+PAiGJ#bpdY$hJy!;Yh(;acP4Lo?pzQ>rAE$Ef|1o;mMN(ardtG7q-WKs$ndvG z^v8B`wL(uC#bWvE$}Tgab3Dd54!stloI#XJDtz~cIWO0PUO)uezbz)$P{59QlxpsH z7aXKd!mb9GxAL50Q-5@XNT_|h9oBir>A88xb>V4K0+$73j7mxmWIuuWyIH z;cf3nQZy2S{b{`kE&I}Cl$9|-Wv&V`_>$%(Y^)P`Z?&dJ*YwWfY=+soDjD;Q`SvLh z)QGRfLhQwvvvU-r-#mR;#pl9AjP%1v{N27g`@8VIiqi|m`5SwaMI?RZ@ocZwmp`YqgO6RG+TIWN_y~$ z*VeN7A77m}uP1^|D_ebhy?PQ^C#ozlYwYKUeKL_xJ@T6fN21dfzjh+Hg9paXPYb>k z%v;&nDJdNm(>$>GqmYO#BM9m*8TUr zs+%bA1`F`;%Ut8Rc|!$O#h;BvU(TL=6Ms4>EK>wOi>M%=&^zMfMmX1f))d8K2 zjo0}UbQ)B2Hvt>N zh>V7y^hP)b(lstIGPVeKdL&*k*cO$iX^jbv9PM^DJ#-SYd@sfVHza_Z7Z^*A-b)TM^QmZU{EDtQXl<Y1w^xuLFV0+RE>k2arIbca_f*y)0PkDt8%S|FGj^jVijCyPJZR$9Pj8(Vm|(V6aL zS>$$et-t}RA+rHH=)2WYCD^ix$!ROqfs>AHpEz~YE+D?J_&5mUgZ7=P6Lr<5fpn+9 z_N4K6JwB9u=VAuxLTfo&{bawv3yrGIF0+B}`O$saf;vG+n}gDi%c@-wZ{MHz4C`40 z=TGP_yA0s{np*3AkX?`CP;7as8~Y5Z8Xtllzc6`r1i*=mCM4g|SRt&zp^O3kbY=Sz zADxmfK5c7%`+j>Y5qGDUA247P&_X?*|BVrES-zcvZ-b-k`iJvO^az3=o}SAQvjmQ44j zekm^wxSZ@}APJ2v>?XQMDhPOvyrWTDTIT`dtDeLHi=vtA#YA%5utc<3#V znfZS%fv#uawhU|7<0}OE#rM4S|Fj>cr)_`J^DQ-O%XF8G{^z;HytuYI0pb->b;`_I zg!O#Q+dlo0cbscRV?znI+5x>=x_Sh8d^oCz3w^J4VOK#D+l&cZ`yvBhtVh+=72Td~m7Bz3xyiR(QTVj^TLm%p{q*TC60`Tyu}P7xp8HO{x)U;3 zH=;+MZLv{>m)F0sglhILo;$M_&!D}9 zy`@XA#JF`lPF>TSHyHn9acXNvpytLSx*4O6e=Tb$2gEKqIy#qLCtBAiLK#H0a!wK& z%E;(uWU?Ln-4^_=W}^AR&XwS>f7xOe94FQX|#E8kJRF6CR}SvRmavHt$a6Ni|XSH3>$eHqr$H%bhQ0}h-( z-1e0-y!)1^C+IJTwyKb*Se(NKIvE6?8TpW{v!{orcTYB~KV^JlNo~m`WX#RIDN~iE z!I6<#5c5fYGUokw{o6EV;$@p-@`!qh%A=Ad7nT|nc_b8ewYij;Su<#hot+!~n^FC; zR*lZ#@uM74_{Nkdr#_iBRQ#2~&+WnWo`_AG#mvsjM2Wu1$LDJ@tyO7lm`%&;-DO|y zLJ%s4WkX{W97P&YX)oh1n}pRtGjeBMH>x@HJuirlO!k9zq-|{j^G#|x#U07+bylRv zKupZcA3b|4d^U2z2aJCnijLe~gse<6+FKv6in0*&8F@5$dLCC)*VY!^ouDqk>JWf4?{oMOk1Dg); z*wf?*Bp1;j=hV8-li*)?U7pEogR(c`nD~D&&%^C zy6n=9*z6Vsp3+KjiUstJADLZMRI_vd-$sZ_gRe8*xm3YyT6?5Y+l$JAI0Ly^u9C{o z+nuY%X>{9f2bkVToN@o3BF z2XB?~S{i>h;r!m%V(~%3IWM06kiLFKlSN{25x=@OVH8y?9rhMlML3MM8xsLY6doWF zKHG>41AcL~VzKEyALTef$p-7o{7q zl3PojFFWpIqoJe2qI@UH;xqoa`SiN04AGhgs_bof%>Sr_Lower6*uK=2|mkHxs>TG z`XX$lT<2Oz&TcN5Ea#SwQ~TEC%YC_;B82jc@m((^NL z5JHnyOw#$GkK^OxLB{IMc|WKm&8f;Yim>A&E!GuuZI16?14=3MlPn(b!< zSik+WKy-*N1&gpLh-Y8ZRuen?suZf`$90j!)riq`Qvw)FU`q0|R!QqFNjZJx#UH(A6ofWoip^sx z2b42)Er4}vK3kZG^*(#iDwGu98V!p==P1^L7Ii#+$#J>n5^B7y>8!H6#B$cmljE&R zqKAwXEMW9QczCs!wWz45vWuywXK-c)R__aM!6BUZ$xHgXXUHo3qt7yb1-^bz!8Tc1;NC48&V(%4Cmj*Wg~~>@{*drd4(7 zmn&*rI4)ONFc2My?ys`ImJT^PbMx6T6MG#S8=I@*{t=;DrT@G+oKukVY7KahNbj~k zl_C3eUK~J3#J6x=hPPW~yCh;d2KC&j&8`f6KMjRd_Ug92hZEk6 zQP^{vt)_G+q}3R}5Pqtx(dFNq+7WJNMnJcfp~Y6bb8Qi2);;|y~rdpk3cT#Wo0N~kkeBnVfxXds%02E zHinM{13asJ@v)RF;M06u6v84$fUlSUyS~TtXr{e7rV%nSwnQ@S2YF=5vxbnKTI!*! zl;bNl!;X;?Zg_0A^wxkK7yPeZzXH`QNnW9txjDmY($5a5aqo}(p4%>+`8#QiL<>O&7KsXBL%0>@z{&cW1W!mc-F^oZEp}x=gTgY9q+A9BX^O zQhm(l0s~Z9oVodGb6d(WTu)DdAMcWY$RP06&Y&Pbp7bVIKIxY5lCVPIa-442@;~Bp zi~P@XV0-Sbqq=&h2)Ftz4hkeiipzC* z37;%Ty_o+vht9jtg5*kFp$a<^&wUS^Vr&HgNTw*Hzp87*%m+h?Di(D z8NDxN4C+xm_nGO4emii(7BMh8TL$Bkkj?gUT~fM%ygA}cuZ7c|KBkv9yRoA&2uRDm z)1p4_0Cot@oCph6sXormAr;MGq)BQ=SD@ zE$Q{qiD%r;JuYXEUs&plzCSn47%#5WYVn%<5!QnVH6|XuFgbH|Id@5U zV`ukxyx2fjC;@RwzbKTC!(;=_OD+D#P5@%klX8FeI2{l_s~#a2kImeaW#8>5nYINm zasUqR?lX@m8?4>u_Brh>I=rnmF^Ro_+2dVGYGqo#$DT?TUS{h9eTwC+` zOfV9;2Ph#S;iKPakjBa^b}0fQV?L|s+=KlLPi`vPPA9(H9)Ax&A4X`kGi7UbkA6Pk z&#Z)sg`0Zl_r9MV3FEjoxy)$lVFLSZi20PPwlwc(*ugP5{ivY#)~R;Nrq7)N(_tQw;8D|`bC%7<4|FH4Yg2PPZh$u(AP5S=(?F*DSHP4ZMr zl8E8>m<0`LskUAtT#(J$v~B}-5VIWcUT`A^L4v>Whl|+z0S@NoXc(e0Zl_2IPl-%O zO#CHsnSNk)IL53i)&^AytW7IE>zx9BdO^Mtn*AK%YDBqBs1Y<`S#sl6tWr_L(B*qR z7Y?YQP5(6kBQ^F`-+&5e%QF!^yR|}WbgV)OAbDin@fBi?t0KE3Sw_va5D~{q6Tj5H z#eCH8HyNp%#g=F~#R)F?l<<@28lS)IxY4LT)iq*}t8L^gvG3w4gV-F`b4Q0De`%>% zvtO37RGO94{>J0*DbVdlYOg1iX+W1yVhXghJ9Q?Etwq_lcZ=sml?9KkuI|9(X9OZu zr279T-`|Ijo{9WGo$k{nbcA6ZFAQZW}pTKzA%?-=b3w%SbgI# zBQi9Ul$0UjZcNedyJB++8%eri$-WN0ms^w)DG%JTT=?3MDt;lNQi%%}hq{LZ{w+ssp6RorC&*Xl5Cm07fNaT+1dH#Jp z}!Y}zA!veV(@lIFl^7ptW8=~G?S!tlti#`9)Y(p2ebhr^z>!u`< zt*NM$Pgi^{wrz!Cx7OQ6mPO%X(LP1=+D*s0*b-av7h;ni&AJFI$X+sy1L-ikU$Ou8 zju5-Oq35>UP5WxlC3nF`?dHhx*Bq_*lcI1W0k@_0}oM*+;l-x)jg!45q!Y+OPCaHfsLEp(Go4Qhi4cw zUZ`Vo%u%9^lRU>*YqnOHKR3}X2zOi`ry|zuo2@T5CBvjY5|Ph&k~(@b2ZT&2lo_zf z`0k0v^)-^?&IUHApbN6xYx2$&c)5`-#UDq|sK6Q(yNiXqgEGw1ChHRv2@yv@k9`Dq za*qX=8EC%<@NoQu1;1M*i&a@fnB2tNYNNBEp#ihPuvxH-vo?Yj;fgwO9i#Q&d*A7F ztCoSP=9erY(!NG^BB6c4jL!DJTCj+SnM8^@yjwv0VW<$R-nY;8mKL>m^TNqEC+5!r z-LkmWJ8~zxtta2UQ?ec=a87Lq=7BRx8^7(nJ5TJA(ob zKj*QGPU?A%Z0LQg;ZIov`w7h5w$Sd9N@s)dQFMQ2PKcLkH# z-00%aGE!kpHo4^ME4(->jz2|;KYhQw&5$$w30sWCUelgEvE05ejY80;a4NF)s*>q+mg{|y*7PP zttr`k``!)SmG1k7O=nX!gd6*qEk>OEuOM?OuWyMAIf{^Oal-{cwsTEHm|{0z03SiF zN7HoTB4YSdAq|w04i5WS`*Y3L$DLtmKdJ%$kA8NyGHs-Lx=41u@2`CQzi2wku&BDP zjSuC3q$1s@q=a-gA~B?NgLKExol1&ygVHI|-Q6&BOAnnx^PcB_UGIEjzA$H1m0K8@##i4hU^qI>ge%^5*H4#(G=jaI&O7_8HDF4L>FC0*;vQaKr%xl3IihOFlF zxcXisy;6`%UyYI~Y>u0ObAR=?ASf+q=BS!zQv$-EkzXUaVuP~U8ZD9S1%Y7mxY_m` zrPr~b|NGEuRFU0w0qtM1#MT$E%V;s;SDvWn8Xrtu8s)s^vi&h=NZ-nwhI`a-yOLkS zf8nj^&I?+uQJ$N7y(cgo?R$T{Q9EbQ9V((ftHI_&2!hJlyEo=iD%DC(HKP`3e)*!s zDFl|e>z>>7^gVN6aEP*h@Y-Nt=MZqd+4>$Y`WP4Mv*mL>n&-^&4#@wX?MwINkq)3Tf7dhL2 zbb03KBa{pF``uA^wl93@QwNz^)l`-R&ZTPG_iVjmPd#sNK+~d5nPENB5->xdNCr72 zHFhjp?;P%4XEk!=+JmSEwP;8DRaeaILAJ;pe>y~3fMG=!1iwScffl`JujsJ=}^AGrga;0xB>bj+2i zhb>KfROM7Wq{)xLEiSPpR&agf1Xb%u*!ck26)+#ZDNx4EVU~pQ^zqNeE%TrfjNFvH!Z+Y!gB+qa;&7PGl^zHk146;i)Y9aqdMR9y1yA`X6 zAiTW{XvPJ$Q8K7zLL5?BnI4l@V~UP&}s)6kayA0NMWbS)Vl zel7UHZeHQ% zbtIWhbJ!m$q)JgWexgyFUQ&zi7zxww4L#+Ivzvw?h>H=(BHlercHA`2mAe)Ww?15~ zCPQ!^N<5m)_W7nVj~pEUmoBPE{rOzsxGuVQ%swI$o!E{-;M|bSRS2KnWo|r2 zK~JG;IhiuIr{BWq^_o8wMfPtRAL?#cc&K)sswev#9aQ37i*toR9PxGPk_l^HVFf*n z3uHR%ZNNgI;?%4#XXMLdjr^#(C*bcRcxb%P9I| zbXPL?uA=U-YQ48J$J<;V89d}QoJHghM0sPw^}aUOm88r$?zmHn=9f2@%9}EW-Ua2b zQY#0chsU-=(`P>rwVV$zUn5)^b7CYwtwG9_Wko%Yh_%>ef4Kehs;)BOK7TeD4jjZj zFM3l;A?WsC^53NbD9hbU;$5~YmFIokbu^1Cm2IXOW&n2jj`yd5)|7HUmTBe(&<*mCihgqt*xcN-C@d@#Z3Bu$Sfw8U zkm>3_Dvus_*q)cK!B0Y2hGT#6Qcm)DolGvHDqwOMlzo$jbm$PK&j&K$5VdMnjqTlp zbZVa7=R1Nm^5t^2j9gl%|GR||`@8q`(M;*<`c$M6^2r*;yA}E#4abicZO`(FChSBE z28#qnDb1TSBap53t87dg4GTMcn=A6q#DV&+K)dtI3KkaB+gRUF0S1J|<+TJz^|g6H zVYIqf&mPMtKW;3d= zxtU*e1vqAAW_OFc#IW0|YBr&82fqulv2kE^Tx!K=;hB34NAA#fUyF`?T9!G_J+7j~ zfS(CL3CA?sPulLMe6E-QG_UfH&&k!vbEjmz|GFrlfQVsAtO@d3GMIgX;CtLpi9M#( zuc3#ZXuLKF#>p#;rl*Nt3|TImatT@eT5UAMNtn)TNP|n|+5AaIcdw`ZR#Q;q`jR+M zxwVEgGgI))amDwd2{HV>7kPbtEpty4fxPih=k}J+K^%`w2n8Se!>ELjmq4T~Pvr6? z*57IEE%SE(8~@)jef<=xQ3#l&wDc(s)j8#34E}zm9n#Afn%LIyekSu_4|VW-}Lcf%}0t+Fo_^o zDU0fXGZE+Wo#7J2@}&|#qtXg_4ETcP;qlcgU^L)=KPGtcF#Ri7Y5OOTGz1Bc{RW=a zN;11(Op0u_k?{%7mK0wKXY)SGL5cL4?>WvHlm)g&E)}4DvLZhGiW(%xfa!+Dbu3V+ zO0#Mi$ib~kr6&l?iV^%4+)204{Q4c{DROplu#$&g- z+ePz5lITe`sRU5se;<@ph>A7w@*-7>cQPW|Qwd=(>9CZ;K$7~^1BwU5)A1P=jgO4* zVcQ@nQ|+Df%Y$*|KZ3==gMXp@;wQuiAoh|Fqjui$pi$P)iAZY_;Nt%J!)hd_qJr|h zyj+EMk&MK8YO81m@6!gA;~BC{pZ5S~B=Z)eJrWEjARxF2Rq}hC?yz)d$cGCLG^af2 z-zvU1=GQXRRdVGKx;j6qi=yBZD^7+cT zYS9#e0%wk+wJ7}TyeZ=ask^%wHfuMibnNW>QMsKo3TB1uB0MpJgBaLS3GBF7MO?OG z>^fyHN`zTMQn^AyTf+pN%g3nT)6>(`s)QXEp?4h})Hpo>iV`_J$P@wJxN2A?GW!$* z1kHWmf!pHfHba%=<Gd9*8y^2t7bIPaPd z3RdrH8Zo5#5n8l3Vcv=P4YAK%;uB!6qT6O^aR?NfBNdC3l*7`X?V$jpCyXVXXXEXtXs}MzH1#C>wV)%DSsBREt57s;QlNf|UQHreL_{<$(<1V#r~s1|wVV zmfBjy5#pk5)|STKF7i__xUEg(5`nw^;Mpqqu6v?0Rs4%dESP`6Q90tDSUvkD;{A2Q zRjH&+i^wVH13G+KP5bkvn>IQumQpY*zF$cq;Dbk~d*yrck&4OzZ_0vQzKKvzxg9Ut zzjFl-#1p^y=D9xus;@~{4OV$MOA#ROV$Gq%2;4}01*8n`Y37OFZc`ADL+1l*Ml!oG zp}WQ1k8krc$Vo^V-T#9ybe7D1yxB_@Z)-cz#eF=aK=|J~cRqLugjCqZV(Xc@G+=s6 zlX6pOO7Y-DPfxhQ)xM5TVj^>d8XBoBf*!%2r@nmn{Tb{gyU&6i#Z%e9{&Iw{Xw0_V zYsT8=a2D4%(b8aDt>uA(>c5U=OiZSPk^?TlVVe4wkjF6~p;~?WF+m4K;R<+MTU1cQ zyA{Lba-#Zd|1XL*Oam30BqZnKVlz$>Kt8d-==&fsuI~s@uQUxj(Sn16sht*1()c4{#eFR{5>W6}1CNq?!U=`f z&e~e76XH4bOMIqT1$(wQ&RQA)Te~SJGtazU#X-CWqD~tfk>{t9-BPb*aBKb zvC*+MIac@`ExCTDiJI(OJ;#c#I!GMF>KAKgO5WQ4EL^zvyZK36#J{dcJRG92LsEb| zCgjjYR81T)!VM6KnzlOGI!E+P|?ohg;M+m5O*b0v$ZroW4f>W-4!LW;nYmQH9}Py zJLFyDx*r*or^2r?;j&cq8E{LP(`4`!=H$^b_o?^8SNBp+*6U-ZdWqLG11DeF!zl3DgC8A(MZY2 zCfiKVn3#r$SYSx&x=PP)Dg7VFh^eTWS#tnc>375XD?>?OQv6eO@uAMMd8W5dR*IOI z_@;cN*}agg`GYdh>Q)B0Hl^Q0Y-24}Vwu4S22fsU4Sb9CTGgolZ3~eD+K=YRTpg70 zQ-&b)_^E=Wy*E6S6-~~a_B;_;M#f`l{ODTEek>x@*BjEC^oaM2M~6`YvAlPyeN~(N zAGx@`(y8#qVcusU>HPX#^w#3v`yW zwC3*|ktBys+<_Af6$N+OL8$m+szugEMCJJVusU$(gdXKZaXk77Bt+z@v7iPmCwzK+ zbI0Ai%_aWZ=bWad7k1_416*7=HD#_U626XJ=&_G8&*8gS_nlCbD;Y{p)N~#@37VoM zyMWEd6elM9fS1&vckcnR6K!DaqIt-S&u7R9lHgIr@yS+f-L5Nnfd4_DQm`?6`Mm z2fKgL-F^B~@#}`2>X*tPl}O0j{+NINZZW;4xCsWALk{TdHv$#wxshy6k+8uYo4OW1 zKs$QB?QEzxy1xaEJ$^(Th%)|OxLwU-O((cf^L5Qt)DU>YV&ErUfy(~Z3l_qodJTT- z0VHYDo8r!1dVU$=54E}sBf|L*>V=02BFG;d|DLo~(ELMNixo){n_&#l>z4*Y#nLyZ zyf0NU1U#9pHD_Fn z@^Mo0d2M{hu540wk^1E!lTlkowz?jqh7yie41bBmTkm zIr-c!Q?mFz=v{6N(;2*Iz}DLwOrf{vfDFAL{}%8~Pgm-XveRN43Y*fot?G`*qjV6S zZA8p&arGzDk{;C{hD@mtO;P*URfzg$&#FG2=LwWES7GoAkZ}#0d!r4YWKRwLnMpVN}$QKuPFK zIEpM8?7wtd`FhpRtmtIE4JB6S9Gw{6_Mbd`H2Wce2gC=3!-zyr192Ztq#dXe#en!p zvJ#D0{OG>$z!skNT_iW-ayb}|2}}*%$iwycU3}kZGbJym#$>@%Pjb;X;km7&7G79v zW2cvL@V9R4k%vt;Mrq}GQktNZG8w-F?CovP8Rs5rWNXWXT7#CCo<`OPPK`EoE+(RK~1egIh_#l@&1mx$b6CHMZ4rpJ`w<6^-d`~#m{5iX(EQKq?R zO$q!_vC)ClfQlH42K5CP95)QqA4)wV$9`w2?;0X}FDg`WRjexjxf0~qQ7=#JJGIE{sqHEmZFG zrSUUrLG+nKQy>mqzupy=c3Q94Pg0w7+D{!qDwdKGlZ=P!SZ-Xef-!weG!6Wy4SREW z4f|8o3P12sXsw`@am$Wf?8s^&jBACTsM_mA46{l|)^}Xqe?Ygx%d|k6n2Y!Td+YGC z{>Qsnkw-K%6v^~0=3(ZehT)+hTk&j$*9_m2KmoU_R|sP1_ls;0b8nqJ+1ruS3ec}) zWN4VJs&wPonbYTDb|J11pq{NdbBcSq0t=Sbn8)AGV+l33BFhQe|-#iIJUx__Gf+nUPS>WNra zQpa1n#VA1k6Bh^+cmXK93fF+b3mj3Kia7$jpsJNGWFu826H_rnZ%lkHNT;v!s5=9) zMLs&_xidC5x~+H1EmLwJ^00VxH~wP;IpCnOzNTh9zW#w+gH@v3=f|hB?l=^W+m2yk zGO}>i?oK30VMRTFkMILiY4qpTps%KDmaBf>2)%rG_ zO_j-D8h zNgX3Lq}yENOza@ofOEmb{CtCD&MLPDj^Wea%5pY?BL9DzR5H5W-bHCdW{Q4U0zV{t zD}EyT5_%rqR{C#Oi(VD`tNm~7dUpigt|8G+V{kQ-E4@QA0tH0PR*cXwB9F-&C%dSV zGl11B`w9y7r=oP!csuR3)V()AkkA-;9?(X|D-)L)$`yZr)ZTJMLZa z0!SKneC>(5dGwgo%w5WKiFn9se7tQpkV_hc&0O1{@HxGml*ZeTLRrk&YZmgTwTY;z zvX(d7W@cJVH81k>^BI_#0Y*P@vMjUjm-u0Dn!hHiSscil^2EFlp|;ygw(QwwiviNN z7#Bl#g5=uYv#YgN1d9ev#u-ONMM=o*M~|Y-u)ND34HO=HzzGo>=WQ3X!7OY`{9Rj1 z5FHJPM23s$=^ADzS29#~R6fBg`HIH7(j`3MAjiAQeORGLWS$rsZ8F&oKZ*;(c7A~s zo_stnr8WF@gzFt~`n(;Z#-=H~jl^#BmyAAKHM~!T^c>QruKOC|tlSVe33(Szzx|}x zU-}<(Z%~?%orAnikGhpMGV9l7cGMIR63bCBjwal&+J4)F#xTAGS^f;Yqb>V!C@2Ud zw@y3d+s@Vw{H~sN>n0^wn&E8i!2bW${j&oo zZaae8S=X|==8T3MwPXQqBN>+N>~ME7ZS)l?99BRo8n@3)!nE$>#L!^6xIQ_E3d3Oi|% z6cdYgrm-Rsy;xVc{x_2IRi-lk_@yskZ%??V66#CwP zgY2;=7@#2e0t&qsRP*ocO5z?=*}Qy(74^f!+k1yM zQJCL?DZVKi7)0!Bj}CB|SMbBujzq%#x7k7AHIKF*#VJ4{PZy%uU?_p<5C5#y8wSyQ z78a3speF+`bw z9x&bk-MtO8-MSr=?arhnyQh}g@_{2AN@fdK2;(uDI`>1dq0cRGaUZd80kZ~2JYa^v znm-z_90Pg7-mY6M_~CTHze0%<7~Cwdjbncj(>vB|D|};YT6F zGVYN@BnjLp<(}net(xi)XC5mdFfed!vDQZOB@{SedY`j}XWf>A>mNt_nP<&K*l|l5 zWw)*1#*@T`YW0)wvf?EXS1ZkHZ)RE>4)<+6#tB&YC#5l7Lmiz6Z-J9Olz*+5UZ0Y6 zvsCX-yV_d!-~yNd^z2!O^5ox+dTbtcPDfAr5}170Z}2Vh=+#tLkIn6e)n1=2%2?Xk zN?n|9Yt7bRVZX2KeA?4_Zc*(setcJuOmnVUkFm~Py6jDK~=)MoVDM__sjRtw96 z7S0tSw#y%fYBEOVh+oTzT?^F~#x|L2)XL#iHNfQNKaf#UQZglV&{%|EJ0t*+u9b4T za(n#t3tM^Dx!JIazCMM}W+?^~A(2yn4ae7_$F{V%GI#W5uH{k9qbX9vwQWvz(44!Fg`saxt{BHZ6k?Yv|SNlVpCI= zCayu37GDlEgejHQ%y+G&P>AG4qOwYCqUsgM^#{>_bO~mz=%&|f9(9nV8!==RQR=

    3MPexEdft^i`QHtgsB8@@uh6Ihd7Mm~yc~-@7*It-2+;+YXCMq%FvF z`qFzr2|R!7!pJl+*PeV@#%mJw(=I|zwCZ;}JyNm9*r+awb)Os8lG^>tTir8-(-8{x zUy2SwUmJT^qN4-{1I7Myd-N}Y?G|M2Afm7xULM?w=Fu$nHAx_ufo_uoU^_F13SUHh z*7P`T+#PYpA2JE{GENa>))C5w$noePjcDVEq2a_Z~;+ z_2WoT_T=^tKhnOn%v)9i-);4;g$0?jCcOOLqdZf8$30$hYF#wrozhA94y4VnV9{dR zb-d_JBtGS0(TxG1IAi^3(ht(1FF3oR_1`i6mchh5Uu=O;e{MKI@6-8Z7=CJoFXX9A zAOAs-vP0h}V^Ekr<-({a8)Pl|(;#Gy&P24;KnNXqEMudF+hcsMFU;#}hY)AHq~V%0 z&?P6040T{tVsGzOvSK#(bJuByUf`YQwB>!p08$EYCDFqN_}OVTpC#9_>qKg zl|UB|*u|aY6?wd>qCtztS&ZOG%f$*1ui)WPoXb1YU8SsjO9NfCqE0>T3qUWz@Lrtu zg$v)b$IpU_D5@{oc=)u=9rYqtzGyreDAI1S}z;1gv`WD7fl$U(8STA?UqP9u2h)bY>Gaa0uBSlDiW>A za%7^}Eg$<;7yJ7A$6588Tn~WxNO;6*2lfYE&WVHZODKimObsm%IUkgDR987I#a^Q^ zycjFEU!%r;s$!yQz@;y|k3MTNfVc3wyb`mTDw4UjBa)n1ETsNcX7Rt25z` zW)l}_!)yyAU-)3(d{pl_))>dwXFUr;D9eP7_!`f6tC<&v0jy`<$i6FBZrJ2UqxFd6 z10O?P?>my239i9i!9{IJ%~b>yRBHo0bt7O;yxnofUH9B^*Vh{O)YIQ*k*fxRgC^!- z-)55t6B0f&!j-8qC_Aa1C#g2dyTdCni!fi=^KNA)Crt71^Lv(*l)z)42eT^)%I#Kx zZO?nmV1(^n%kPP^#;ymmTSD`5E~moc`^m$$g5#1d{?QCnwB0`i6&rSP9ZW#yCwJm6`U3$)e5;|%CS6BB=xms0@eQcVh=_}%rtC-6ZuD}Asp@=o(4 zhj-mq_!h~0``>sCSfo&-!T!NR5RA+JXI9WKlg7b2STiK~wv)tx=yI~3Rllb-o%0yd zjDv^Mn*3wXRi~pc=9VTxxuJDUCkwUU*l!57(?PwahsUkyo9p`a=+r~3dGcc}t5*s& zLLaLNP(bf93>Cf5C=Ibrx9~jUd89&ilFVJp)&c~{P8cj{H4U0bdO_n!I59?Z8xEwW zoXUhx61_Qx>9f(dD}j8@bgq_>3Q}I=;{2MrDlzxwqD_BD8$b$P=??#PZ3H=+sfuJ) z^SpL0txiY^lo7dO?Zv=`r+0V|JhII-&(eXJy7su|UaytO48sVyYw{}7YkUoKRw@Kw z*?t=&KKsLl1_{b1%Z;2l4Y*eljCN10xHvd|b^rz5uH|~lo3rdH<`191eL8qtT77OO z5D?K!p&GEtZp3SujNqw7@#C)dfvj{b+K)&C7E~nsO>4q-yilD^m|Enw2|LteVP@`b zZ`$0gOl^Ol5QwgP*mH1%UouLqZoNfSU{oL9MMuTYLF0WT^-j6Vh2Q5wP_n;6Bmyt) zKc(IBc^1M*t%eYk6ScogI>=I_A0i-`UPixiGu2urEy9Yb^qw$X+^h2ATn9g4|&~mX4nB7eim1b*eqpx>V}{JSj?wS zp8&%X+|+aoB+8Vvm0h4EKDeB_3JeT}5}7N%7d+X|ee^ktH0%f&)O7!i*di5s#HV^j zb#o14w97T8Jdpg>vWEZ;Qfq!|_p6A)|FTJT@Z|aF#PHyw9`|i?>)PG2jJwDseQ3-$ z^migv=^Rb|pgi4QBu8ZAsUTe)Yz38|{T1e05=1dTJ~u79>|v}#{-po$u^Jy31PcAV z?Vb<0N`8nUr1f_@c6zvSZx4G46#1jAhl;kko!zUI`bHg@@)Na~0OjBL z^ch>hlm_I_CS-|(Bmsf2*cLW0v#r?-M|2&unc9YvL&E zpdwmER2tjd;W<%%n}2MWI~MxOO5)K^JhB|qKlBJ-wK*T-#jUJJ{!ULXzHz95rnof; zqs!0Ou0fH=ar|A>&dWruB%?$-5nQ`kTh)IhVMCMXb8R z`LMS#F-9H?u7Z*4y~w$&=WVt8ng0K7Fl?6_khsl7y+CeAgeRR6B5rFlGc!~|u6q;d zHnU}(&3o$()QwhLmzqlCO$SMJ*rH_>MRE#C>C7Y9No;SE(~&~XY~(SdNs+PE-$62` zN6HAt*p*I;n}HpL1TNN?QlJvtQwkN0$K_=H2mss}RKVNT(q&e|hc zo)yh<@T=d^Pk(D$gZG;y=(0!Kz#wKcop*Cp{Y09jgrx`xYzg9Nh!#btjT_}Cp1$nS zDyqIdju>M2Q>@Fj&SwdcT=9)HvRg_UH4a+6VehDbL$%FxK ziT*fz{Oo!?x3_}% zVKBQA_Fki7tCI)H7qiQ;mBsOu#rVcYi_n{+#B51^IksujwC0EU_}Goo=Lcw1ECf}D zcO9)AO{a1CuXeM9P|<+GpQi}H*T`nu+y8m~_*n0D&#SsK52+A#2vP18L=9QKM&7X5 znF{7!Z}XNGV2|PUDr~ed6hPhmMixEEnY={JeIZ&pd0z?P*R-J{`s986a*SBQ>yf5t z|F|4nRwPD-fZXgDnjVpmP*&}ZNUJ&6TlF@<6Zf*(0s!gug>a)^V>X$#+HT!8L84_* zrKFV=W5HkTqt|EUpI<$%V*X~5RjaHph^VWpGkVzh_|Mt~p7?&-W6y$8%;DKnS9{F= z#c}VyUOWpc&((4N5^^$ApUteUeI&N-mOab>PHDGx`8Te@< z98gMg;!1Tp2#7}UT}F42FG#jdkz1{T%s|BhGv-9BM0%b%IPR*PI?4Zn-dCaDJZHBe zV(NbjoV2#vm?K)1L5Jdb?MES4mDym@Wc32$9V$AF*y|#iFEK;=j~OfGvyY~UsS6fVvH@bRjeSLA7QKfS zZDvP=+ONDzI!eahT0@h3H$ zvooYFtRfdE&lk?}gGYS2T(B zw@!IaXdBddJt(~m`8`A>h6iH6`^DJu^@&r)uZ4Vkic1ek+6ja!PH%kobqiQW-GpNR zyIgCV17Z>ib4$m8JOb(zY@*`bw~Jp-qcD3lDCTm1w|293b!`%v$GuGqw!86y)s{+^ zm8ubev#&PaCIqLj@3W3+{`V8Q z+yUI_r>o!3ohW3KIehBMhtzs~u-FprXt~)E>C)mgyIg`^SXaNH^B`$OsyEtI6RDn7 zroBjbr_g)_erHHXT~B~7Y*-)u93Ae>-!tMnIugp&tHxD2dy9%nn^3M4m~v~I>Ku9} zeE3L-6Ns{Rd|aT+z|O}GJS(WCo2KMPA`(hUY`rFNot-pd99(?gMDzRkw0fwR)Z4YE zFMkyF!K9`-?UbDRDcn!P>Yzed{$U4e*E|55wC|b*^lHuBp@6yMz*i2~9Pdv#Ix8Ey zN2OdpqQ!@|`IRND*tqyx{oo1auR8Id9u+_$n`90TA8EAZmLQ<%5v+OLEBSp zrDl`}%)t1{8~A|WUEj%xvi6I>K3sWr9*#F_nw18RCD%Uw>L_Ff%Uy2 z+6dBdvhF_PrKwN>K?)gJqwyla>LDp?=A+2A{FXx zUqAhx@NDW*;&0$9-f53q)c6=O9^42DBC~#*VpmX z)bNR)f5ZoR@x&VgLWH=pwij@EQUBZXZJ$#Vs-i`g`49MZD#}!(#CO$^Y;8B{y3SYX zn0vYiQE2ba>rgW5sYWZMv*Mszy2eb&(BE+KwZg;1Aa;h~E@-x&w))<=ug|y|4oMpk zUt{RczM_Q8h+>%za`Uh7Gmnh5rc__)K9kqrf?#kLW85bWsa=npzIKVoLxNYm5y_ACo4>J)L;XOQ5Z#dDR7jEn-D zi*5VSro~sB^mfM6WoY9j!ZTNL+N_q$pZ0B@-(c7X#^?B*!6Q8p&1>Agv3zm$Vt9oH ztjQMu8K_yVQwvw$e}}L}yS&@%ZtY)!>;6m>R3sR29}E`Ko{x5tV_sT5Oe?;By_O`F zm{jb&F~OCmUd~iNS<}w2tR8SCp6?@T%xz@|E(+czSR5=oqe@Fa33(y{38p|yo>PYFHSJO35XAxgQCD!i)c5|h9FYN0}&hH$u*&kDF zGslWUA=Cq?HW|oC`UUm=T<}9qGnk45=?SywQK6b&UZr&+zpu?pa&OtB@Y(97Dkyg& zw3^zIS_~5CaOZjcA!y$o4~Rfq9EaPKd0*%;e|lx2pcpORBqAf}D@>6|@j6X#EunRS@DUMBk;^9>OXodNPo}(9$Jo1%IT5WXvgeQurM z2M6E#H+xK+{(Vd?`>cs}7WYk`lUAoYotc$>;b(qsZWa(~jS4+k zZwvZrK?^lqU2nzUCPP+EKE9r3uGJeSN|lLlo%ak#xWvmCrh^R@H+K)9=?M zfnGgi2C*(aK0fyVH>Q#0II(NwJ%e<2mznP8bah+lEwg>ChIS$Tsj>2gI17hYZC{UI zL@Tke@?Ti=qW;~>b?o%ysn~bl&raX+K(F+}8)QGeRg3N4^zqnE1-mG_U5d8uUqr=5 zF+6`6hDpNR=`(coEw8+dc)3$o30d_9ux(bmgeED?mijVOjLCSHy84qaOa=%n!+-XL zXw?hMRUeA%=@t)DV5N{P)x*_&lLXp%7k@7RR=0f3?nnO?EZnP2`*C6@g!^D>k}o?f zs5`uVDPqCd6xv>l&U`dc@9@5>M5Xz9@^E>t{rBrf{c4NpnaSc#A-AENr)rC1qyFoo zWv5*Vp{s-Prh7c;O1flhBghi#E2m@y)0nU@ucQwKBY+QrcAF3XXtmCmtg<_v!ggT- zX2H@dQbefWVd}c5iTQN1eG<|UtnLG`DuG}^o5mTIW7_{A{cGh!M`QgG(Ae?g$x6O@z%X* znj7ni$^Nhc0r_GIx4=(Hzy9G9(f<6DTuY6e(o`J2Mf{0`P(gKGXA4j`wCpz>c$gke zDf^x&s}jfW3f0&N;E`3Zl(SH9Eq&5r$1Ob=_3W&=tIr<<1m^hRX9Aiz_QzK)_t$3+ zfhe{se?trFPrkZ7Q$KYU8<|9n6n(-i325?A86mS(TpoxG^Dh$c7@wDD-Zg9t;cdSi zZ8<7;NPh)8@!LUayBJ^F=uAJ3eYqm%EK=_O(XLPobyrsW9r@6!o`Zj|nc2yOnO4CBQpzr<2^SA{33`AskAO8y38ONPMic+eq^@ zwcRp%T)}uBb;dXt;7JDN`%c9U9sd9l@(DcBjfQBL!7bhb@!Z~h4!t^kNt|k>c*EkoDIm_iPv&Z*RrY{#td;M0&u z$-uT8%TtXh6QUoLg~;t}eC>`08~ch7c5#dBf42LKo9^KGCqiWUfhsM4NkRXJa2l-6 z=<16CN4+3)FLJOp(ir~0+J4AE$YL-uB^^0VqKr#^ua7oW8F)9cWNTpv9%abb&dEh>8{PXbctubJyJ*6YmPk>{9EIqBIB`yiF6UZrAD3! z$2JSN5L;>%9-njj@~BVr`Qu1SUgio`vs(Y&kPU4bS3wy?P0(cp%~b{c_kL5Ky$^p< zvx^>+!EGI#!C)3O+;eT4f(o=qDZt`n2)i9BY}4b6IqOI8hX;Nw2g=6Td2t%NDIQ)W z+r9Xk=O$nnEONYY%A+Qf-(DGOk-g9h$Xq?V?x&;dkHr-=L?rKgi-9wd(JHVv@m}73 zS!85?DB0>^H|E<2+Q`iIVWYaA@Bg6od|4>cYg#W#?y94%8rC090FOJ!vRY0wcDr7l z;KBYx%V=q7nd9O{lw95#g{fJQ2k7Y4vEjvEr)DGBP5rQ8!ER^olTWkUTl*jWB+4ZA z7awgPlmqW>_HM?2rLl$S=U599$hVsl_xYh@`@oO44lv#l=G5xD>S6op3qUC<&WaDQf8wQs+K|jQO zkqe>^1$gcHxiW2+v8Cy8Pcg%Gm(Au1k>`l)kos0Ub}EyEdpb&WxMrooLV-2+m`#=( z?JtV8U$UlOzoklQdo89azUSc@G>VE?g;nvyI2jil(~V)X^B&3E8lJ^dJ-a zxyh-iu37r5^*}IXjusOK7yIX`FJE&UegI->xlr0COAHd{z4|#?*ZHJY5fy?56i5)d zuZkb@=T{zw@?{z{3H8Ne$yIy3+;}~%ZsRl zK3m1xIWhfOCI7qW8h6({%@6aY$B9KgmelNapT&WDpbMCaxZGoaeUj>3C?*cP!|r2h z!y+nL@YvZ@c9I@m3~h7x@Qo zon*D%y$n99)UA(ctls_OH2n$3-CZdiZNGbdp3kpwWNYi)BMM3s7A_|TR~HQSW_zRS zlAjZuuBro{{XBxID2!P`iV*Y)TJp5h#0nH1Bk8=cHftU%!(+N~9En~tflaaF-*`L! zkEUyij-(CKv7L!++vdcY*tYFVY}=aHM#r{|iESqnZ~wbz@B8#cReg9Ls#+!e_o!8A zhYh}t3@W6+5YLT9+hvrnFt#vC;esnvt@m9UZ^JgSrIh zbVFz6WDPviy=Akbf<`wlRlC~gpHAj=oelyx{aJkfY;-Su03SgnDJ3*M9_J?N zy3IYo2cBq>9-lmZ-Q7z|%XfQiUxF7ykZg^1TA(Xn2N|4tE&51)oF}1~0LTZpmTn^6 zl}jRQqTO|i{39%`&m;>@ftqzsjuFjBS}G7Xk5Ylf&^XJ;gQa1sOY73Y+B`W%NuW?6 zS%I$b0w!u04BbSAcm&-kDUuvGPKxt~T@0~{Ag)7+1qp%pKE0!PZXI24e}6pGbT|PA zFrc4w;qQ{1j}9J8f*iCP*?n4GTS_XOdi`EMw42x8IX9dg@ST80nyt#bi^v8iN~#B7 z2pAC27~0(>PCh{QM9+J^O`op-mY20#QGy#C`C3csPA9Jq;lPuO9XSKz8l0v%R_m>o zX>l*kuX;4V%Yzr-ki5w}^)pw634p`MzojxEL~JwfmIO`~#3^|^0-P;Z;G(SM-ZPxt zcb@@!Bl98r9-U0ny)Og41IP!-Lj|N*qQdHRu8d+9Gx%fB_Uw(r(zz&_uRYCd?}VML z)zK92&H6ZtR%u0cm2~C%QrVq8y!J8`kKzs1PQj6AmV@ z5oUs^Dwa25D;q;RjQ|4A^6>sH{PQA@KlzAwD=rr`ZO)JVCy9PXD(#iD1;0f*J?0<+ z$WW$XbB?hYa_xZ2J4vBTnlgDv7mKEE9@cX|t}$Gw<ms{Vhd3)-ML@jiCxds@>rt8 ze))F|P7;z5r#Ba6ZEf)t=Kiz$2xG zp+?tzUAwmXSo{3^TwkpKiTOO9O>2T|ne{3~*sn6DOp|^g#g3cd|Hkv{n=i)3E4hF- z3=RG9&7J4xTVxI9hs;ru5LthN8-qIimN$4R{7bEknQ`ya7k;mA$aMOy)6PiEfj}&z z<8V`CzR{O6*IE(`fV(BSC@32*cutKxqhE1dm1Cg1pvg0|p?%J=YlZOO)RV`KO3=-H zOZo$*(~(tv{=_pq^xBNz@uJgxuwp|d&kY)b?siuceFe_)rN|IZ;%DoURcNdaWoqZf zja4`oQ?s7<{)Pw9&SZ_p_J~IBn;PNA$X1L12gqXAvV|o}VMgKogGzo;$Cea&Twg`> z!PMlO_b+I@s^dksZQEm}97!=Tfiu@IasI#qZWzSlIL9C5@X(`y1o5_`@}1;KuxPLk zSX5~dsPV&2CM;N+2?=ILI-V>^sh+hm%q69+U9KeJl~F`jRO4$)Ibd_(0y$ryqI+)mJg2DCtFn( z=h&<+7TnGb3VqyB++(@O;(pmmB!IM&E;qps(4@TQV`PjwP#Q@<^b03l#rzPT6=n)Y zA}BraMAo~?we~Zu=IpxlJ_m8xuvlDM8A=;%6>p6m3&(;z|I-m!vhfQ1?VqNi;Iy=r zId!WOlhR)qJPMS_>DOCLFDJRVx#0hOH*5cWH?n-`wqvD@j9re*L>5V-lx-IXj)KIu z0<)F#B5c6S)^f?N^%6fG{?Nk?P>+nnb}5Th8y5r62%YVlKjMQYhLFXrQ#Po<{;(k z{=z@1_wskzuI;bHU4MVFL4*#8$Wz_AxqG%)ObEtqGo|$GG>gp&ed9X)nJOGtseV}> ztR$PTNZ$zQ47W@|XG_DWL)eI^lsrAA7&lVw0r3Ijf{J#O*TYGp_mj2oErjFa8jG(Y z>za_TpWlD0o!x!DaR3;%?`8Y@5cNKkzirDK zFB+4fxHuD_T5_~>k|3e@;9RV)8Y+1$Tf$kNdLFW1S;(Qap0gn8>guLMpN>O>V^Z%Q zu-zjF+>~g3M5BK9J0b@5QT1I`DfM3PxE8Zrtsp%#}+AJ|e?6m-^HA$&|2eZ98c%$QO&QzmxCsB9)eg zIFd8kA9_nrjo_T#P~~g9aO{V0sPe7kZz6-yMAKvgKa`qY=hG z98E)2Usu9k04!W;IvPI6%pN0wc_mjl;E$uv_Mdwj!&qE>@X#&+2I+)lnzUg78;gBc z8Y#kvAlpMZo7^slk3CDmhw00*CqB$Ib8rxHdUiq%XGt0mQ(SlKZTw#83&ia~v720r zP9khrF5A)958{S`xtY+rc;*{|f)V8t0w52}KI!V+wr_BvD?w9^v(J}%Jw7)_D?0Wi z^@VT=@S>a>G9*f%=alMvU`WLKNPj3K?DYj=5o1kVw2~s(OS$DCR6`o_MbH7e7dkkounv}$MJ&l4*5$vgqWmO|1RH{tO0Z=io@J8V5=8xdDU^9E-f2p949Y zez&avo^buP#6(nJGWy_M9wF}ed3i-mVMAeLZ7rkQ4Me|}glwJ7)Iql0K#-E19|NER z_n0APa>z6}E+AVo49bJHqwW6qdmeoj=R}@E{>{h; zRKOzA`Rt`{7%;bxnEj=WzWn6DtLNqO=I(6Pccj$2g*IX$@24vZT*A2dvF&E-l}(j; z&D$Z3{-QPm3S-Z|&)faJ4^)3>U@#77@N+7hEJZBpN-crWI_4Ay9lQHe z!U=CH(R2^+^k~4*J}7tOqRABU2PLZM-J_Tp8sGGHM2_cwgNZxX@2G8|+ipA|JWo5+ z6kmnEcA;dh8(AotaTKY2a=i57VCJ$iT=G)RCm;`I83l1wBry4WLj)>#c1oI!sIkja z1xTbFwA?X_SQ+RU{$0CLO1YW=$r-ZTnWTtL?Pcq=3Umw_?V~EyzBo##bC_h@RcKvA zMyZI=1J~)ySYj9Go_EcWfD>B-Yo{ukm;lRAeGC5)C{%&jN-;pM~qKl=UllPPXpF9 zy=GK=Lci2oJq&KV(t7HK{z#Fb_}zYEF4%MG*Sz34;g^RnMK?H68lI7vQf0mUXVklJ zRz#NW3V`ffAURHXz@^jEg~9CM;SaxVzW{CFzrKs|a!2r8 zuWdV1x3@5Hj%xrD=vckjM_Z!)2Yz6+Uj$WhYXJ;(AvG%IR2i4FSFuztpHzcVacON_ zmTp|mmu!j3kgl7bdw&%ND^$6_PFo`JnQBzrdTz5@D;q~<*^4JK_$RoWyuwB~8ZoP4 zAXe8r%D=$ZL3|?j;^d^jZBYB}S4=|hTawzYd${d4J_m|inOwGl?L_;Qhg}$G#qx=G zOtx5+LZxqb65w`2aokQqEc98>^Zj}P#My*T&pgdU{0_vB8}5VPHJdHx*_GO6!c^07 zVWcRNgbwhPyYtx;oZ@dbp9jsF(sj=zOTU)1^GGj7Ta}(&MSfJ7ueRFhaLBVjJP}Ik zHT_-doo3Mvy?j6anG$$TfMfpA??K~-i+ldMSVBZD{oyJvz5Fb8ZM-;`&FnNK3Nwir zJD4EeSmqj#${{PAGvKL^nu*uX$uN^sznDFQp1LWYn6iuQ(ql0H;-_f8EBk#R`}ZYv zGsD{)dxF*T9p+mRWE)OiOc>9)R%vt?Qo$l=q=jHgdr3l87T%4crMO9J-(J_ol6=64 zVX!IAzSjKGJML$DO!dqoWpm{gtHaMNa7j8)bo68dB*X^)9T#AzWdsoBt9RHDL?YxJ zYJ8Y6adnM>Ch|=XP`oks^cNx<4d?FohDrY(;Z?5qF|L{v9FF9C=*T7M9q+VmmJW)d zNIqt|;BIfXtdOcjOS4VpQcq;UuB z6aB~)HK+r;v)OhL#8D*I9ZSor^Bda|oaq$DBh;x;-Ymt(D?zPFKLe*enUP#Mdv+`p z9-E9vk?&PhfR2dYg#N~K_ETnGf4y?9;+%;yNEJ8K;wnllQ`lQ5d~-k6;44ME7pT%F zlg7=(gpBYZC@7mRN_Z#qzTVt`M?h@io~315gfF*~zj3KU*(r6K$-DbXjSs<{=al~O@e z-u@kgJ^&xaZL}qt;;5na_l7N(3&CzQZt@{t8Pwush_hf zd52(dpqq!8o$Cv284M_FN4UQ_{yG-Z`;P#Svht3FtVdO*vN)o(n#^;T3$EYMW}hOXGZsRv{*d@ZQVCRfJ(fWC zEWmKEb0$SlT{gWt2Y7GDH{N#r1ir9&UM-1Z;*1#d=LcosZe2!~+g(s#T65L*uXoJK zs#=Jrau*6yHlT18iSVDAjmZtB6oW&oRt&7=*AMks7QOzx}KgdxtrgzpaJmzJdu>UR6#mZP)|68 zob^Et1(Sk@i$3;GdUsEDK4G29T5r^4hqYg++n4i@tNg{MqLQ_gC4qjCadEU!CmcdT zQbNUq8Pl<1uQIe%+^M@OdB=s6O~VaQTb9JV;i12#97<;1g$8?D^gJ3u)-S@+L&3{(f%CH?g*! zU=#&Qb(Jat!7wa`=v67SQ{qxjlB19=YXrg}&Y1`mu2HJIKUou1e-nUB^hh=+HABY8 zIpaQ@$VS$yAuJO-J%I_!c-r6SLqS7j;O7*V0x-{HugXs?HyuOc!O=*zV5q~EZz!!4 z5=xL4))DBKw8!6fJ_UjIlbLhwr#DxIpIUzoQ>oJ@Jk8Yd|EMzVrA~TM5(Z1N2_O?C?i)!;9Qq)=J zz{hVxN^tf6T7Z(*+ST^-+U}I9oaHhr&dN3-&))q)Xri1_b#}QeR8TzUX773Cr@L|3 zyh(f$HCwCV*>teuQgcGEqm^Gp5szU`y>C~Xa0BpR#(LQz08lVBF_AU4__T2 zh9Lg1Nl#Z&;vRDVw>>h#Xy^e9Gp5*4lc9ZBT@BD?y!Z+%{U&KizRp4%Uc<~hab_MK zX%7!B;NWTY&E(G7UV-;51-fn!@&`E&?U9r*<;8d6*KVGxBO2pfM)ZNTg~Vt{1t2pN z{+Nv;^<-?`-W%!p6yUh@%F=&*;_=WiSw~D555z&*kK1aE)NR<3Rgxc(pMy~jS$P z$tlRQa`H;_DAk`kaUJh_2_8Aas+4M?fV9KNm3>h zQNWR@q{y1d#7WYo!ub*o;G#Y}mIz8yEk-!>FYtcNzGtWEJjwKZaqX)9Zh#GUf{OE7$X?yxao(jKR@g z`PY)lH?s9Cem{s}%uR4g{N+BTeoC1jrK+jnFE^C@&FiPLs1;G$gy1u(;&cHL1cZ@$kRr|iXByG5njUkSjv-K+-Jx3$Doi|3%% z%epH3_dv~t+$z9RpX~qo_2P91eNosZe)!}(JdVMZswgYEKHAh|Gj7_bt+J%GzMBLSDLW{Nv^ExU@j3OpgcP9EYV4g+=?gLyN8>AtAd_V8qhhlr#UQnMu>5rpr|E2pRyw-o}6F0K_?SN=_gUHlPv*i`z z2QpiEqPt z{?WZ(`ZNAOlRo*TXqTKf+x7b3xYgd>lb&7S{~o@x_q=(-Z6ep*)Ra66%Z<8-B*rn5nbnU%quOvZF6=BFnV7e7`-B zJlBX+237E-Du|F|cl?@siFx{^q9Fz^qI(X1XP&S1qz}70Ku8wB`X(6mIxN<98`}F1 zY)i-=^Ip|rdvDW@wIlRfP8KHT)r$3GS!HKK7$`SvU@E-Y!rjG(9#sRI!~o!533}+9k*rjiZwfir}&CB3uO3YjR3-C#k`1J;(oO zU>#26KWZR7ibVSg869}Qn%|y}JbWc%*W4*yx*4b+ zD)*j84f^T_?YWDsdjLjaR)*#}a&Ys2qMZFS=rexG;rVm!5{B*##b8LI5|5f;-hU>W zuUs*-wuW6KHW(AHxci=`r@D@h@)kxHpfNjpET2t7fK+)9nIdbepdQ!(u0SinUr4)B zvOojW?pRrtYm~M$vPR>m6I#~wIW6-A&fA7&bO1lMqBL*HEA0Sx508Ud{&sB zR7Ho2-<8KnOPml$U4Jy(*%BhwT_#VO_tURD8tOBa{vMx*UjMpu2O_=tPNj??hH_1fh}nXYZ~LJo%_dZlDA6v)*72JfUS4c&QbA4Me8` zi!o>RCTx**xjEyeCs0WGFuLB0Zc2a=jT(x5vko1RU%{g-Dmi!|m^x~#&Fn3Xcf(a` zm^@_v{QCR)KssNp%^ymq&&$LR6eEOV@l#Be1NI?WA8&6{lC^%arlSO}61m>yb*#aN zwOn$X0u|CgmF)N-YX@^ILbCTnXhN4I3+VR6S7gaJTZ zw4C&{W>-N5{{rqbJ`OZ`qW-cH>K@8*j19(D8I_ys$PsU#k#{y0v(ii>+D#zfF(7PKt4T8D zNbn1d$3q7(G-}1#gSNNzlg7!%O_eKzYNn~#MOZ<|o3se<=%uEc6|DEpW%GS|0>D#b zqK;B01$)Za^^AzQK52BOkdKr!;rmdEyRD^>oXqTrhoFW&|a`nbiulN~&jDWwQn^k^hJ=s3A( zz|AWVHDlptjX9x7HUXB1KAg-ny$oA2`F@t?Umvo`c4FS`A^Tlo$0Oes_@5NYeaBWR-g$~}w z^B(#=zSD{ZV?0oXP=_!tFZQixTK(lqh?DBVwz-=zN^I|DI0kSRXZmRqE44^TsA}CQ zSuHjXDS%%-=5zLMQ&;R~oxcW{U$b?|n8_9ko?SE${^^Kc^Iv zrm06O`?7fqy=tE^K#Y?6G@(di^fW1WfL5haC0Zrgavn_OOuY%o(pzLq_Jpbi%>i>w zfF3?}m^?8({$ndjC}ayv1iU!ELgxJKX|{S!I#_s81b!tB(y@6^%M=vFJ~g{|iNyG=CvDzK9$)o|w6oRi%YlPOsvCD*$22 zl|x(o1)o=kiI9wb5QBhJ_0OM)`2`})q1lU)U)~wl5f)*pDh5XH!I7y1MwUMh+Y-(s?JBOke*3Aj5b^cnbz>H*4^=#riDb1F8 zo5p>s5j!l_u%EoRbGgJr*0#1WK=61>Rtn~CaaD2^_rD&+LJK(mn-qCDGK2s;px1ts z{T7D9ewg1ZA$I0c0hZN{1E@q@oLdu?XOxr+j!8)Z9&sOD51CvZaTr6Cg9e6#N`?TN z7e*vP{-LF%6k}Hj^u2J}0${k4IUn{4cCL;UD`6N;dCG2fNLM9nQQp9pB;XP_?*EXb z=n{==yn)_8hM)0PP%^A|gH!$7n}6rpsx!?0R!5_I09PF`MQAYkSe`L6xg<44IjH^M z$RMv)VC=F)K)FYST}4?1AQ5PPvbMIS7shq7{TusBM`N=3SUoE{TY5-tgr{&}`p@!w zknqE9yL!AJEAN2tHwf9_AVPc$GwUDFx~R7;RYcVywFlfZa46>*vMiJhLL3+#5hd+* zWlI?vRJ0>sHQEaZs-p-*T+xCOz2m%Ws$DFTpYA9HrVEWvo*sVYgx9A)a0~+C0dK8eZ6c^t$kqX^m*JYPl8VOY z==W(6y>5Mg2H28~jrEUMEi9 zRGr%1FYnr(H|uvsIX)SvsjmBvBFXsQ_S3^QGq})zCaAfRl&6Ex$S+&kgS?MZ>Wuga z*z2<`ae(Rqg%aWg=Zvi=kj-KxCKiZiEyQ-NQAppQnZbl?D6|@21B9gK0u`lk=Sb(^#y4AdWMx~~2dOoD@PwQW;ow}z|AQ!}p z#)~JJ)`i62!QitA33DS>RT2X*B_9mHeU6XL?)`T-07-`=nKH3f#Y@s5UnJozm<^D}fd|Vsq2HI>Kr%NX_oT0f zQIxn2Qj-IfcrZX7WE8s+)SUk1TNIrvN}-1m3#27YiX@EJ>dZ`qW8d~)(71}EQdEIx8V27h|jBbdDvSt zq#J5SzN2+Po=nNVzbAr{K*y4r5^^)!;_S=hmnuEx1@LqbqQgI&!7XbaeHOfH;*eGE zHe`lg<9}s0%cauPKH-F%5~b$r0JQ~ODUD-t!arEU97?5=2#8&VxFSD+mK#}H$C@&@ zZ4Bh;Tg`t3{p{}6R?~fTjEW$Oe{OCt$c5oauGRrur}T9t*=5fz$JLk%A(y!jBoz6+ zN*Wx^^uF^rv%X1a?lTBKrx;GDZ12OXrqV(3Z_HND{ z7DfgUsvH<7FBt?GibN7UhD%~NP~=M-kN?sPL3OKuMJh#O!^@@MWfh(UiP+rII=`}F zo!JIZE&)7Tbtg+@;o@3a+e^R{VkMgCN_q`T?`Q}r_6Wlq6_CfS@=TzjOPVpca;)L? zqJ|Xs7YKRM7t;h*9;;~PI^FVzdzDIeTBneD7wJPw1+@ec!yqU9gSuS4$8u>Yg{R6R zCVYr2i`j_^H+a6A)CZ|ICr8T;oegU~%cd<>Bt^AYzdwq2K(uM)Le=1Q_3&^x1lTLL zSRK#g%ZjO(6bLRuzZ-&MxC)X`j=G&`fsVUI)#_q>etrTWh5!fEI;CfRAhX53!lk5P zFgrE|1GIHIqQi7Gj@Dg&VE8;=&C~vSq&ug!AXKAi_@uKd0y8YBPD~5kP!cSR=Q_r{ zy9aVxKEoWBe*wwRgqn5vh13v|J+r&iSZ4F*2oEs|H!N#OvnQ`dO#b7Ng7=9DWH~w8 z7LY6OB#!&`9c5)Nn^#v?7NNm^wGuUtzsd-8?>ZisK6lETZ7DKt9y-@|JV2P;9i&mb z&HFaX;bUENm9Cdow{P}bY(q(b;Szv*gk_jNm@vuiQ0-x-KC-GDbaO^opTv47n48t_(Ks~<*T`FRF$K{+!X8$-uS@9xLi0ld!^xM+-zKb% zy3kz5nmbT#k=jM1U<~5_a3rZgsvbcdn^)irN4FGr2{Qk9x(01q#5vjSa-Ve|jH^my zo5rjmv6ISp^10sdhNz%hT>k+Kp|LaqfHJTw<%*D#DmfeI7kuKpD4_F8k~LEtEL3@1 zLJ_80hS>z45cjx&its-v;L@QrSeWgxRG0I(Ma+v&h+mXpK977v0en+Nqh8eMC$K=p zTQF8_^i=iFtkaYG_JrAg{OI0ZpU|Is1k_iQEIbyKoq_F(bAd{R?(S|^clU*jjmoyj z1Wxlekes>C$>YWoU>n}aC;`xP&Zf6Xw>$$UoE{{3;o|m0#aD|q1>ZPS`c>nZX92pt zh_f3q2T})LOuRfX-(+M7rpShh7Zs+jr#_ThB_yD30PuP3IqbHnE0b-`o2jV3dM|2g z{5=?kB4x!<7+Zpw=$H5h2cw|J@e52){Y8NLl*GP6H68o@sB*y`f2hak|)g)1^JuytW3wL7Bkd_{gR}CSA@${9&HR~Rh4CEZxnrC{o(K2*!H`iU^ zT%B7x$47d&JS}e_82lFp`Y}A;>oS+_nCZPJnLq>f7$m#944V+A;ino*XzFWTW4KOe z!OSw@%t@T8)@1PsSux{T1x{B0u^B0`c!6_z&ukV4(E92%ewG8bNtm|z+Gg;@3~?AF zqa-=D+v!Lf$JWXb4hfHWOC^8P;Gzk;VH|c<0HW<^3=Oc(_iw(U{Mu3cz$nQz8Cj$T z6Fqi;SRw$Gh92P;Plk6_UxcJTmq71je^PiDn!9pDFj@DAm~%F-CC<=oQZ*&|t@+9;Pl0qJh}x96n6Z`9rQ ztjTkJe^t2q563F!K93-u$8`)p3tLc!iKJT+(2g;yD32OH3X}~x4QCcM4LH*`GiA!P zUT$^1L_R-13s4bEOs>teBl?|P{`_`sG^q@HEzj9KZ7|tLySliKroCSGu9HRKrtRq( zD6QR}5UBB9b?V3)8d9WTez}4tGL3(*w6ZzU190VSN6y)$^N+3CzgbLyV?C8aI#!<> z#4dBx!GZEtwiI1$_4F$(wcDi2qJ|6u)l&WScp0^FJbYQMnYLV?6 z6Um!T+Q~8Ff2}GFj-67|Ru46t;Hm^UvAehu-W47Mk5N$-9&Vl~=fX?zM8tsOaDh0o z2}0+#a9%_(dpeZLILOR^l)=0FiS?{-`3l=!xN z@QKE~WYYp%Zv`S9<@Qke|EF^QLCBfyF@HO zwoG*zl4Qmh=Nf6-<#AKQ5Oki_%WV;2tM$IG)SJ~x1w3A|i1Zq5cE3?w29)iv8%XR72)ftp6uu#vq=f+G4--yfibt^aaBo|z^~L#I&?BQG zr#^@E=Yx<`$CdRGxlXf`&I?A)D#o#(X5hu^lG5`1rc9O^_m=dQLER$+uRD zK5Lmq5nF^G0*5b!7Ku%y{X}T}^O=2GbPfvp*x}}r*2JV}BXW6&7~O~nlnr_5D$X40 z7-*q6zO^9ewK%yA1$&H)t7-L1`1Q3R#F{0Y#k&QAYIJJkA2c56L`j4f@EI!X2^%QY5z&$HHaSd862#1wd`dy7%7PI% z@wI|&G1Kugr}r6bgKq=q&rbW)P6fcQJvd6xAbO4fl0a-9rB7o;n%b$aa-?Z8GqB5Q zYXenj3q#Wurhq0CVCYemD48fcKIrU?SKPJ1r34|&x0V zQgGs|bzGwvksl^1s7RYjnmjHQ^Hcr*wEzh~&&UWm`Mx#iS?Z+s2Phuqn*<*E>TVy% zsE2D6&(w&f(^)7x`;rQ6#bX6b^$w({q?W2>ifV7=>~@}h-Uc97R^7n3scRkQOL1mt zRtJ#tgtwwXi%B*c;FnBm7EL%5DYEr(8=3i*NG93-xL`SKPeS`1H^D`MzaJ^Sb-mR| z#mCD_D0s%KU+O*rq9>!3FK^+WCS7XrNSzHk_3|&=v*#v30pviw$|)`lc_i=JN88PI zlFfT!T%H?us>Ey;txzc2k<-LN<9{<60Q6q{R(XiaUtec8w|~DrF$+ri!q%vjkSms1 z+;R!P994GkvT(^! zqpM7o|EQOzxCSP*f-%VwO-NbOEE{)DRcqE8nSJ zyQY_EvfYBDH}DgDdV1on#RF||{AdLw!D&QOMA{_!om3GUyvBc)TH~DEktruAG-2qKp_R+<3|GmZ8uSpN_8KmU zGtUAOv!?zTS+FBh_ZA^dx@4B(bf&mrq$rc$SW(5OTeW~`DE1BVu0UK+*pRr=s%}Q) z23cVm<;h=rKEoHMKtp$_$df3js-)eZxj&`?9l=z)ch99SVqyZ$VyE*mS;=34Li@o0 z1Mk8d-?46=gwF$3N=fNu{LYEVs3~qIZ^w-F{P#PjKtH>-UwYWnd9(GDtzcB?scRA9 zJUBR*UcYOt$763;j6;b_x*7y6a_C&N=XMsL%Q%Z;X@M|DwBB-LfaSrU%dz;C*@tg9 zcqf@MtrXrvjboCt+C2Bz9pRGgP+4lltieTjzQxEs$mREMVR76_b;=Id!b)`3vG*u1 zTJCqTrs(ClIEZ_Rz+DAR3F3wd>L$ruc(82XqQaK1eMfRW4jgFn$4d#n=;>M==&p`| z&An_$+aL64sd&pR3&~kr%w1h8OkfFa#CXBQc=%NhC5o8$6Jd;fs13w1oeDOxbwa)j0G$`yA*VwiMzYPdNED^-rb<;@k;dPQErvT*mEFi%5* zG=c{yE^@Fnpi*q<@nN@v@yu0QW7p-<7gLs^I3(i&s+S=qX%r-xIC;9>bjuktw=F@H z)(li0Muaz=0#!DF=|_NJe}(?~#6K6rq_^)6)x6QXwf|z2^}(N%bXsru^M1SY`T6-h z%a9%TWeRVh1_67aotD)!zuy&EDSLtaWsBZurko^uydG{#(gAN-E#o zp7i?53C^O-OalG4yN)R8VRPdKKV+4dI)+|~8I}y!TCj{CBoK)X+bPQv8RbN5hruDp87Pbb%T9efX8EN(CB zCvSTn`m75svx1#XY)wsU519@(hsdM^H5t1#x_M}ypzVKjDy9QHne ztOc(eWg-A$1b9$f0ZJ3NE{~&pafCz;*z4R9s4)bGK6{w@3^6z%?-Qv z#bsNyAfBpd}u#fWHoCe$~k|fTo|vls-}?{Q(FftPPm{of-tI> zM~IV34WW;jvpM3Z;W@8!-M2~4OPdKv;J9CI#68S>8Ypokk9%{y%L~0M1$FqIoVns6 zR11sDRR8I#mjCf1Qhau{m~H1vMd{2RP1yfx>^Yw?LqI6OK>#hoLW_`3`-Sv|cff)z za8kEl=ETd?5_q0qo}H_C`zA-yma&MBk7g?E8i`uPP3+P^XaddTwGn#UYI+6A$Zt+J zOucZcZtRxe0R_aW_|{@B>OsI8A6oRjpUrlti_~XvUsuL7pf@HQH*a7o{{!#P{qZ62 zvT($2_iCQ}gb0mHw@Oc+Y`1`pG=s*y9kI{IG5-b}Nydx|jFk#b84uL^UQkBY_Xh`3 zcR$Jr8kYLOhYi!f`ojqs8XOM2J?PXB2tsm{>D#6*JwJ%pA(XHwhVb#P0JhqT>vXr)Kwb}Tr@9hPwN;6*V^hq|J1(BMD^DklSd~D#VM$#%A zB`>jI{~Uv(qs<$)K}%cehRamda_0_NNJ1lQrp(u{bsy#dVc9s?EN3&ET+#TYtQ_>_ z^;C(qGgiQ;bpvz-GT4@TUsr&-(R3uXwY9VwO=oe)^!B@?*WFC-UnUTopPp7%R@L~} zE}fTg$6hBpM4_8h-+w?(ZsWSzkuyUFFk}iiI>&*TOXx9cSXZhXrRTy4tM`=CK>jkE zNs-RBM4pudjI=M=a&-?ZFE8!4-k;4|e-E(j2vd@66`qIA{sA#KeRUAzc?@WZ=>l;a zHcLMMYqVTobqNyX^d-so27UScK_vWA)QJBH5FG3!r&|w`;$4p)8|I8o z0&%$xx*OvNM`rfODb~)9(DW-1cSq|O?9=wwuK{fAMnBikve&`0;-VNL;z|i zSRuZ9Ni>w08xAU}hF1~~71}95(17wY5txI&lv+6`vZ#Q03gI=ly+ld>@N|PM(zgI)sIM4te0T+NwrS^AuaS0A zQm(~RzsYwA7P8FAQS3lRa`IK)(uu@R2j^l}!9pqe>%EC6RYYyC*tR&QU%Bn2aj3DwE1W&)=QFH4~F=n^Ar1oE@`zjuHgno_jq#4Z; z05gQkd(=vKyRQR!de3&5&>F-80e>wGw`ZZ|w>O|F1aDUVOK|q~NB1xvmO<_(xo^MrW zy*YB|0CR}9&0vM(_S%Bw{#H65a=h8f2j94dI)XmXAqSyW?#j0ESb)_)rEG^e>SH?WjQ{uLGt_ne$v;6vI``Oe!;+CfnEXQn@g$0}WO6=?r7!N_Q1{F3 z&O34@M2Y&x#rfIW47Hk~m$x41C!m|DMzg_iJ@)IND3AxlR`z-|aVf)bhZZ^_%7Sq} zSLMrzhOK$sO%Oz;lo7h!`AVijUz29I(d@)%o82>bbKrR&DAZT!g>6Dm;##wWTN;L? z)HElZ<&mB3CotoZ=gE*w;|nI55<+f1?l!aqt;dF5MCl4(Odf3J$MYrm1yy^SN+GfZ zs;RQF>7+bn$3_h>m8(aQCq_mkwl|tthId-lsqLT2T=w20^X^X)VAMM5ibkA|fnY5? z8va5A4aB-kWy4HPN?q#t194%-d|Z zgM9sg!`~KZF~8IXh4&g{Dgh;gmepsPHhM8njO3_fF)~m!aoeSVgf_VT!#lZq4Ddey zPeHK0IS*H#F=6Gd*zo#Tavne!T*rk49^^=uFMQ%l3eV!>$|HgxK)fV@+PYfUA)9YN ziQ&E(aznt!FA-i40U%^qc;wMX{uk6mnp-&=H{R%jjwt|ji&&lwv{{<``@|DZh;o9< z(A!g}X9ppuuBmzFuHC!NDN^;cq}LVDXOva`(BCU#0rQiz4QD#f08E;u=|STN?{Cs> zoXgBz#eN5%Jj6+bI7l#;gOoCX<yBEGE5R@el7n6^hdHu(Jmb(j=gZZaF547bpB`g)u@bAtn!qp5yXWGUFXEFaxaQ27w7Lhel!)5B}`e za9$glW-ynDgZk0khoPC-UZB>~$>1o!09ZkBdNJ0>>wiWVEP2UcBfQ^CbO@C(b^5zW3xLKwSs@!HA%~ zb=x)^Z#Z7Gd}(5=Z_{%>9EtpUaD%2Ny>5X1;{I2bU$Ahwu-4~KKNc_tfCF7e0q_B* zC}}`xqN|mKf>YR3%E0+aCcvHB1#^J6%z;Y1Zepb(-8HMPo|0$xr?0;BJ@ohYL(<}& zh-pFgw}1w9(Z*;bj89$mkug)_CP1@*bH(nXpm@09Y25qi&jBqtZ|rXqlx+Y_S>SLQ z*puS2?mXk(_oSR1M9b7A6%Ob?Eb@_ib6^LCfgIIrd@~vBPfL253yHF4$FS_i3$c3j zDn!Cz0L05GHvwD7i6twSgF4?~=tWJkdF5Ty0~{Vo-&n-tBgzHKe5>j@(K2QYm<-Z+ zip)DOFo=hK@gTY%Z=MjCzwNHK<82?kZ31@^I0uGsc-JAtt>JCt0gJq{bP>dec_1B( z>0mOR^VED|m027Zta<}9HDxWt8Q@eg;Cm0AC*T`7uE)UOI9c@cbz^9Fh*RNm5E5fJ z3m|94(js-u+`J3R4k2WR6d*8B5)u6%L0uch@y%k*teJ>Jc_hJfDg!59ZN)n~Y z2@NFmF5(k}>@XgE{IUN9b&=ll-uD)Q>I6VtD(UHQGBT(?@x+sA4twr16aj-ky?R#l zhV46doEzMrsZXyPpx0DXeUBgM7de)6g0>*ppH%V9<+?zH-*#8*@;S?$dfDm#sLNUH z03WQbNvTsK{yAeHOv}_4FIt2vtf_Y()58YP(cW&H5yQmCtCPPxah4_f9SrZ^a62kc z6399q39O0ub}%+S?GH8n0r!07^FX_!_ZL!L?x)lpaorV^dW_4km4jiajSfM)NibIA zEr3%wuv0lL6ECy9?0wm5gi}~9WnA+;Zeix-^RQ;)m6%ae1L;Up>Ouf|(KqF?6kgY< zCL>p|$c^rol%Xt7!j#sE*JF<_zI<-;<=1dhBilptZ`lsLVDPdIY}tqI-=Cf^n1An! z-@05Zq1VPndXRT=dQ&PXbNS@NCl%mM1h|Jj5QIX)AHG=B^+?m8ZgO83qo|%)jkdOS zw6?Zze;9;^Y31eEFk>=E?dy;o!ejpn>HvUMOD@FPYu8Q+)XjH1R#0zfXu$D?1`nuv z%LxW`i&!WxFZ)_>W2Qd6E@o?tvC5jtYNa4BRxk&EmpgVKl}@Qa20+=MQ%d>77ZKE4 zPMWKM&10BrB_}Gk+{6+a0&k3Sc^nFb@sW%F0#P#cVNnw#hO3udfv)HPPPeqE$!igC zb1up9GgyC?5lWH}8&_X*4K~Ct9~I2U!e(b9-1kVsQ@H1|_W-RT&a(t@VtfF-@__-p z4nMB4f%+&nP0I>7tTJB%w-IJUE7YYK52TWGh4LKVB#;Q<8-ro0gQ`^8uu8)KA;>ok z0rO&5wRSb?>gtR}L5WWws7KXY@zD!CGuXotq;*s@EgNR)r;hdw&8C-FWPqO8O`J7P zbXi9CNlt>iN3!t`ys{4{CNnRF@Z$X2?s_}^^NZh7r*B%f35|ozII{g<;k{&}V*=Kd zL$5o4s=AtB#UTIs$pB^6Wfo^r(z;_j?*`C7NIdVe5X?<^ySA9uxlD108V~AyQVgfl z0OO%+<$KV>+5~r^UZ$l?!z|dgrRre5dnqVvqF7P@fGsa?LFbWHl-5+BysQj~k_7Tj z4z5cGKkHsSRLO8CT-`Qe=eSW`YGh{dCz%2 zsC(b0k;TU`GxJGMFPI*LptrXNmtJ-m2#Dg&6xIjr%R&$@u~>X*YB=@Hl9G~Xw@ZIr z0DbF`9X~m1=A0G4_`tluJ&lHzlWJF}fLZ{!+L20tmlKOI!FJaREtO6&KvV=ZKbXt1 zFTLavtV~QFmn1=AxN_FTu+E9&ctZnR*HsEODz3Q#b$CLiE?c$?ADVYt0hlw44CeB> z*EviOMbBY=OaD%M>Tf>D72vcEo`;%I9^oWvmDwE7a}1~o0W(90%`Sm6l-IM{Fwr3v z1HuF>NqIdv<_%X$z(G7=fmDZi?DB-gHRaO|+@37zR?ou)7hS+@Mb#|ydv^0IE%KxX z)J+KYfUPXgLoG^w?gmw=z?gVg=DG}jd*l^)wa`xez?OZ$_7N1|MgVjU=KoP}>Be=N z&^UMsM|K=4URK~S0qf48&mBOu0qTlEGZ$S=(t?a_7A(ugvExUuaN#1%5YeXJh@c*~ zW3b~P?B26Sy%(c#@F)FV%zWbjb>WXdx`eH+sfKs^=C2RhflbT{r!9>C+DA zjIqip;T3K?V9r4C;^}S3X0z($$}p)aM5>_LDWlq?g>eer5ejjfjV>L}Fr`pu#yE#K z=TeHAnreJ-@jIrj14c+IB8##1{Ht&*-GttrUO-Gr?$E-R)Z%#7tXcTj>e~?ocXUul znKR?qOPNz~mV=YFId?tB{MVk`F?{ATpFyfI$r~zwRXcz&X1j9pN`OJiK|SdL6*e$4 zjBsfLti%HAceMGM+!RsjKkXvP#+c0!58E%4eGKF z%*P>Ko};`CsnjsKJG;<*stdh`I?&hDg@NHD2K$o8(i|vbh(=`pcppr@PY-_k!CW;_ zyet2E@;!{+bm@1HN~J&Om$&$sWcmsQsJ8#jscx}h4 z=pPsmRgVnnnxY;jsEg=*@?E#Kw&2PuuT=9j2-Jhz#m3^X<=J%R+tW>@PdlJ*JGSd5 z^XukaAi-uViGgB!{xI6w+YHK_i9jr_`pqeE4)SubWt7{RGvl|M&)lP&_8tdW4rQQ> zmwWwH*Q4I5oAQ1rmJ%d}_4RAeUzO`^5)dcCv^BEW-K)Dc_ z*Mtx*jc_WYUznfCatPthVtO4eFPG;-#Oo+VE)w!u7^u8x4pv^e3ejkx2Pcz+3n1Xc zIlbT$BclX$80<8Y4Nk=ZlN=a8XLASIkG7&`PdiRO*MOeA9T+~)hy1BD^35sGeh2PA z9`5N3@(n}i+1Y{K_HKk{#}SLgj5eB-KYxRVUfN%r&F+67U*cf??a}VUo7Zka<4`k> zNKhXWpz}W_rEYqZBj!pio+h16;pE;%^uN@Bd{YXvGYdNCf)2TGIA)QSl8i^oed);N2 zaoELO^2tFdLnsu2ZCT2TrMa#*HZ-8?U>h%|B!u$XO3Ys{AMr#Cv1m+(VD)|YZbF*K z@c=ItA=tKaJC-h4@`iR3TRVRao`3#%iBMS1c>RrKRXC|9n$keGAHS_E1ackYiDeZ%?rqyN3QM+s| zn$Da;YB*)c(fA<0YR%QySb7D3Alq?GnNz{KWxjLzKG7cn+9j~Npy zr;1H#TE04y#V#rJGmgGy5gZ0&CeF0%Ai4=80Sp%Cj!)EdEMPzXm4yo$F9?8dA*MrpM(D0XV4oT!pypvUN*j{i-UPOh{z~RzC0Yv$L`DG z#L!X;OjRbY`c?Gh!x3uBRADe*=pR6;W?UI?z(iE)UfzzHr z>O>N~$IhU?xfcV&N#tk_A=^U8aK%~BP4ayb&ns2=OkE1|9&-agT^Ffz3L)D?cTi$i#cJSGN^5dzqjg+oV=VAVyd-msxpXIIyu@$?C_wzisY#B3b={?^9~>VXrGx4X5a z1#7Qes~=2)Izd4>W=h24%d_e1v{LEQ3h1vK+WL3%=hUwi!%&)z@CC+-a%? z%BT0q%;iEM^O>@4qRzns>hd!@oJQNp7PK8ajnmIHVDNA+axE#i$vj`|JiY^r7dQf- zOHR8*320*$XYxImb#|Q^uK;l9#eE#iJ#8N$8F_B~*gNq3B4Dl-!T>JWo7die6NAlO znfj=J&i_bIudc0vUdnhKZ7pp`KGzA$L2xSed;vg@90TjgBiAyF{>C2kxAb5zl|-KA z5RFH9SY4oy&F<^SBKmlI;Ro|v2V+QOQgB=cv3OhoO~KGJhAks}eX%db!X^hN{q zh3789PL6H$c4@l`Zc{XEIp4coAx}su(x(;BW3kwy@n|dpz}Llv4{SPQc(rvWGMNl#jl0r@RA|038GOZ+H!8p2wzDCtGo9+Xlz4CP3#0tS5(FcM#QeRqE22jx*?grd_x$9<^B` zpD(DN13c}^Bik~J-s4^9Khuj0@(4x42!}#mmb~121l45@2Y6-b^2O%!d1SH~#G)}Z z{({=b*F#IvWdHym07*naRCVqzo)aBFG!lVBdC;XuB!VU9EydXj&xREWK?^GMxV3Bo zLTosKGf4zkXcj#5`~n9F*L88C=>#sk;G#Dqs8`0yF_;;`vE#=)uf${S8}QPKf;uU@ zvoLXu_scK4oG*K---AJ2_BkU!Boba-Szh_oQLC6>nl?b+)3ERF=FgtD$vjsK)J-ry z<~F18bQ70-yPOgyi~}k^3zjU$98xnXg)Q%s--c&Q`{~=y{22Ft|L0=Hh*@J> z8fZfVM8qgpw&Pt6Fzk8(SbY<%{ANSX;yy=i zrUtur)fP*Gdd~)1m2YQ|%jIyUy#r0VPM~A^DWpyhfepJJ_PMxWN&#Kw$u$h2SG3U0EB>c=g{jWQBzlqT;4_d6OFK(Q66Bz zfbKmeAV7v9-;u_^$sY8b=|h${2t|d)I^>Wep8LI433~leplQ@WT^GaY6hfh}a8?Aq zv6U;DpqS0|O|DI`XatUk*={zUd72~cVL&t*1|b$4*MU@$xJXs)Zg2O#Y>l{~zgF)S^b3tH-L-D4Q zO#`!L&3bK=DkhYs4bX?O!}nK~RaE%T`$66BD)E(;-AJW|R2*^u>X-wu*RGsO_pSn@ zHA`Jk;o_TsC4lfVJhh;~1%xZfd&A`=mQo0`72TP=LRT zeQtrXH=uFw z6prpZ9NdmTK<9s0kAvQ9KeDMb=*i6J?Vln*H;*N_=Q`3DXzD?K{{V6}MLZtU0IW85 zJQXU<1=r7Q)`vkr5Rby zLf*-1Ha{UoC|3Eggsh#Qqq7s?a0qkHn)ikS^|&2FhGuc_;30KyLBsqn)c4CHYaa#F zE#V)ar?(fEU4FSSExe!}WUEduFJ<}a6RXb zxuT?- z{|M?lh@Ea~uuDHnGOufZIPVAMVZ9d~6VE1KU*;%2^S7Ttz9(mBtV>`fg)DIbu;v_) zqF$<6vd1OBhoDzG7u8E5l$#&Q0OdBYEY3~dECK8_AuPJ&97H1WoiL=+X@nyY zghMjAi=eRN%!h2hyv&Sje9`Xd>BWg%$I-sC8Tpo+BV&!!EMz!{|HR zgA`38QWAr0*($5w-+=5Z|5C2c1DR|F`MiVDM1r3YpfNZ&gr~mqJDl!nMg4+$ghF9` zH>HS1V}kf72I@R7z}Ky4EDB4o-wj@X_pt>V-V(rm^3*9TIC}xg%F5qxpkBXdK3;j{ z6%40_z1!8XfV$CFzRoBZjwVR=_4Z=P;>D<{t}X!eVvc73ARdd)Y(91B$(b`}wieAa z!89$dU-NGMUq;L0cOC%%C%aAw_pDr#hPj%`Rv|1+FLB@tDsznm+?7gm9MrWPI^!Dv zrYU}xQe3=xHOfgzL0ew$R1D0u*19w}V+CMNPzd0`p5a_|+=D)R_V525!(Ax>+E!t} z6&S~a00Rz}flKgL`4Hf9opD}gPQ2$R(E(I!XqG*I($Z2+rH2XPi_5WW)e1x-QG`Na zShfwz;_cxGf5R9+(&N8v+Eb1pb9@lZ&mG6Uo6d}{^M zUH7#`{M#ub`2xBGDa&o$$~ouKWvuk05InPFK>!82Z=@^}O;Zl&l+w!O3(viL#5{76 z7z=9;O`^T69j>IHDUaqvRftndxoVXYiGjhTF68Lq+Uyk6)sfUFHEh)(SZu_P9-e zei!U?UI$mPn0I0FM^a0bXO|NZx zK%Fs)WHPBHs3#x?(TfQG=2ZRuSNGt=b4QWwnC_6HuTR=MDwum&>^zyku75dji-P($ zzwmGPvk$y=Tx}y`_Z#&mNrVw(n}^Y{tr<=G8ZeMdLN3Gp#3ac0uE{tMxm*@)oo&bp zr!b}E<+>irv?@?2jBGkBK%MwNoq-a68yNCV4kaa}2t}g&l-NKs5fed*5M;L#9>Wzs z_{k3e&^H{YufO6t%$hk%zbm6JgFxM@nXYnrlK^$oGoqQcZQG8%-X4BU={9(|VxHne zIWuc#UfCeUG11jv)y`)?^k8y@o5m}ycoUY!&Ysfef1vX*oL{`(FFgAek4vH@aS+}2y{{-G4$z&~jh>~z*EWzAeK89Irz$F0ricP0(KuGgSi))Mgw#CTXKMc7PO7) zHsVCG3CDIG@wUlqn{kdXXl1z3c28E3JpOY*b&b%5qUX$Zg0tg?+6T}#m_$isi3+qL zQ=#)3uctZ!z;#^=4G$p^FF{Enj@cKTjf$!Y%&3|nHdfNjtyts@*+;( z_|`{CDdMph9LMpA2rR{o(MocB&^b8=y#u{CXUP&UgY7MA`+u4J9xaby$Mzk%PtAAe zTT>wGGM_o<*z)#`|Gwc=3Kw2*VE}bZjK8vaeP3H!TXo$OJDQntK#xYEKZ!@9k)YXH zEW}|7S!{3IEh3)@(=D!?fXcfjv_h8F_OiYGu>Nhv|Im( z?7z=$!2|a{fTtQ>fW5Q~OGEQU%s&<|SBh-RD<7BNfq6Y_cDaKkaN%N0`%ZlIYhQ(% zaruOmKy287dnolB13QuubC&}#vB7`amiJzp==DiPR`$Y5@M3oaL)9UtVD2vyf2C4 ztV9hH0654G4G$s_FF|P{j`E6fWiq8f$cuKa;~*A`!*TQ8F$^C7iR4m>l9Cc+vpK`J zJ14CHET*ieet|Sc=qMzkQz<}_bDOp zv(85Xb#oI^4AlGj`f%lyS1JcT@a2;I;jbke4lk%Iub5I3Hc}AaU=rz-gIn*qbopw- ziL`tL#lai^Ug+D7#uF!0fE6adoDrhJn{p*N4%pPyK*n4KN+?_-PP)>H7aIa9*+2s2 zDHyI@yB0TBTr*|Q4gh!l@)PLq>*MVL!PyHI;Da~(1iRrk)dp^h={`}Aj=eRGwDIj2AGhWlQ03Z#JiTJ zXv#G#xGPwT0aTo$P}KjMu3Llo_4UZ*a_W=MJK{SJ*Kv{0=ixXGT-Sx;x!he$ z3`QyPP9CQYp1{DVUcm=sic_FOl=36b8+qh;;>#n;A!0)luZZLP>sI3G_uPOBW-Y^; zDlSxuN>i#8AO5Qkq4DuUfNR!ilu^jV4Nk_|vH7ld;74Eno)3QiGll3xo+9ZRsz9h!_(po{Y^wi$PJel4~H# z;rT4Q_S#nL*}V(dY!;h0Z$^E6J?~kA)4=0bSZZe=uL%$Luwf~%RmY6i^T$`7#dp8^ z-GX^$iFT?N=<73ow_2od5c~CSWE(bZ+JsG;HU)0ly{2p4qt?@{?_YJ{${!b0G{H2b zfZo{N)HHwgTpxN7O(hpezdZN|QmGUe6;4l-COU;nT_v|-GP0W7B)BGIRcZ zoY;O0`Qf|<pWqaTwq(A)FxuTWu0dKxd5M0x!P!A_fPC)Vr@JE5n_4 z-l^I>RiOUiyFZGqt}f3Y^M|q>5!8tv;*Cqp=tGgJtEzGDz4z#$?|UEKdh}7UfAH{< zg^QLIscPJ5%2@6%?R#bUipA%B)_;B^${YZ;r4OLBwM{sDVIH$G*Q3lvh0+@UFcn=* zvfcqGr!q3MDwB(r{4Ex*HEY&jY5eRdd2RscVFUQy!#@(vAPRS5C!0>;rN-AVG}FO~ z(#5>p0bmXoN^g*|??Nz_RD3bY+=ZscI9m$%(I0<~haY~Jn^Ra^fN4o~9RN$3^AG}J zS#Wm@f;DEi`_&QxREB|BQINBuu@k74D1?J~u*}?_ zOy;_*f`AB7H4%F(ek4bSnOBY#2QDnZH1==tHm==(6Uk;A-*v>(PV<{E!Z%Q30CY1A z^z`FL-~ACf(T6v!z7)}LR9%aNBRG3jJvLr*J?{L#op{Hc??&zFc}NWoqwQ2{aG3#s zuD(Y(N7D|HXZk@(!iXhwJ7fk4nQBA8)as4l;UR=V5lE?H0p%w_k#JylT^C{7E--0( z<>gnf@8Rv}?&`*1ei+o@t3k*PArg%UuXQ4j6XBGvR7;TWj)1fGyZd@^&XT1NGwF3_ zzqhru;+a1_gB?3}>d129Vm6mUd081|&6+i(GWB?Q0y}o>P;KC5WWKi%2)4v{4Mjkm z6q==_(`i&yRbk%TxuQ?OMVA3}nEe@xM`s>6a^zQYX3yyk%s9?8Wq>}I9{f>FW%W7c zxzWHJ0Jb&nMrt^v;*kSTCS}YBfhz6D0T^<2rde^)Tn$`C&Ns}arY8W#?an{6VrpgQ zKRx;&8X6na?;udmW^*`tBW@je&Vl%1;HLZ~oZ3@Z%A{ zTr0sb)gH6>LNy+Jrv=ONOeWP&8Q{Q$trjeAgEw5e9w!G+Yf$%tqXk%bf+Cfh%?M0; zx9q|%?!O4@cxf|0E@0Z4=pE~(bayYu>1)Cy4Wpa zxN8tuAH*)@Yt;egz0D__6A%u&7x&|%r{+RIn9*GFu0fHwUdK`m$yFo0#O4taM zMv#cd5sSwWi^WlrC_y+J=FA?UGz>5h%T{fWlq~_!(b<9edGk?OQI6LW)CZG;c=_d* z@$$)y%A!`Cvh&38X0l^msh+({L!Hcp75?^DfqhJ;(QHWjOHR zX4;v90WM_#)4^0EwXRJZICUmNpi;)T{W+5w@?tkk9bA3oRZ~ixAEV9q<>SAG>$oUz z%}AgXSU><`p?_ci+js3iqtl8dXDvjGL;#QiFgHEJ$?qUAryl02mwE?)E)3wlFWrZZ zj!r{)h6qZX|CXT62tjUF60AuC1G0z!bc>ssMF^~t5JEQJ5QJk91pp%4+4e#27-+bp+xNGx= zv7mG=!d6&Cu~Twrn3&D*k9+7g|4|KZPZsQozBU9%36aIn)S1|SlO;N1Ep zc;~y`iOuhOCt{1raD4YsWKtP#J>vy*@Zp(HX3^i@kFuI_#l=#IGMEp-*Bbud!>M5o z>cTk^fd%HNNDgxXmr+=Rz_x8{-?jsNJ3IJ27N2jGvuB{9q7t!a9Fa%_p>PO^cpP@f zh9i7ys4WKZ)&T$^JA}hW58;9fE)?Dtrx(<7xh!_?-iv3SeHLfVbQQG659*n07K{P& z=FL^lFcqL4D~V&*&Rr->!Jw|dykK22+H11neW2dk+l$LCy9|j$0^TcLQ1^#(wJhtb z%Cd^D1T=KqX-WY7)kE7qI)C=uo8|AZfH?rX)Uq7|$$mpd&Z%yfdBL2Ds72CsD^=7w z0TnEF$%>~!mc`lbM9H=oWr#$>_~^>pC;hx;`oY%w(b5vk_Vez{A!iK$ptG|R&mVXR ziKR0zKQvp3(EPv+6au`L8rSA%=6U)3onL<+uWWf$fw?W%Kx(222Qq{JxuGoBD{?0d z&Tg*>^E?g%23@d}i%@kGA=~B?C~ASG9IXUrx{b965CW{2jYv3x4}9o@SaZc1Fi;R! z69V?PKr4kBext%hLToZWcQhFqg@KrNlGda`?07;dtbf@(KW4 zf9(dGOrAo+?qjlI_04R6xW#11@a7-k{PDd<@q_RG086i0fyHwc7G%|%5Pnn=FTv$2 zF2$W6`2a53crlJ0J%aA`?t=D>70~4|%Tn}r_9I@MKv;T!qb6l8Hk@MJlD7{FH?WaN z)I*g6Wte@mU*-NA09YjY6H)mzTp1adC(p4j~?m!*Lz% zi$j)d&ToUT00X+ZyKv4q=L(M8^nm*DqsQ_4-#?Di&COgVy!a(`j6A!3Bl+M7uqdyZ9RlhvUbN z9&MRjH+y$LL&ue-#IekbvWkz&>{MqM>= zl+zhe2G@TR+S$y|>=h1YF1&E%R6MRqM`<(m?b##rzqrDQr3SAYewLb8Iv5%M9gD}Y zBEDEHs6jIGVsdf@6ZrMAY@U1d^e#O9=;LZaO4hpR6WW3$SnW30?qSdKk=lr+w&gfX zGh{lrrfoPBLO2}aPGfAs<>yS8r-dMVv|Dg84*vS%AIBY+-iB(c0`YhP(O3krSRAoP z6tP&0v+>0z5{V!hiy;z;s82W?0wDxPcOFJIIdOMnBx+&vr~e$MpE-v6HvAoI%SN8L zaD*Q{2QC~?xQu_ef+FwTeS^nv^G%zu=SQ!NnRPy%G&-0AK^2b%=E?LRlIfwqYY~J3 zB2(#sRmnDmLADbKwO7xCzD`piDBQhthc8#y`iWzxwwWD)J0LY0dJ>@!N+U z#{Dn+2IpROUhxgY7!z|S+V(dK1-5_{O=V^b4YN`uc8 zx2;8GMWw!%a6j)vnASPWMMFKrY0Oeeq3<^r`q||*|$B1#(o z?BBm1>9k&-%xCmE6k_Tx0gxz7d@!Jq<4%*Fa+K1_#q$;}2gVNO0B~ry0l6HHj-vvv zc-Za+8&J4$b%pmh0s-c70P+)%?0Q)yT&)QojYe_f{I!#PTu*vr`(pqk<)ztg1)XZf z&z6IW0oPo04Q8NR4Mtb^wlC%=##Eeh1c37ZEKGqp1J`!%W=VYGn_mZ|RLREWrh^cI zkYyHW0JD4nSm3m99L(p%5&~;uODh>neS*Tb6bn1A_X6XQOu3 zEX+hDYEd;|P~Z3JZlsewvz@Ufo8YXA&PKv$y6Cq((MV0~v z4(f6o`qNkL`3g3^KN!@V1OuIl5D5(U#aDieH(mTD>}=RGu3Il$cs_pp;Dh+t^S{E< zNdh}_7}^drBbD`TC|ThW&*vj!aHxaUwl)RoG_W7}y?xz!Y(%M(5!Rmxl1dz@nH~bTV9OK&cN{V z-~0k+I=VO~+_qo~8MbBFu!JKRTeLfu%Yz;Ana+eIpNkl7UBy706#;c9m%Uq-26CGS zO?Hd3^=Btkze+_+)}|B8uV23bCl5B_cM>& zB_Y^FL7gGRii7&s?)fq{zW=7e3j}au3{D9H3l&}-Z|d#r!Job9Mttr5Z;t!k3l=QL zuYU7u{N&kRqH^|(2?ING7}^h+pl&YG`sJGIp#=53BM2B`!dQ?11*kiFwkX#iY?#<6 zz*Xhv9LMX>#Ix>*psfO^c^MQ>JoN-jQ{Jfp^>8SHRV#(E>jXeOm&;)Hu3g5nP9D@t zqb0cbl8gB|>H~GH#8({DiSM@`)J-a0g8K8%Kkuu@ETs_CH9kL%m4r& z07*naRNZ*;i6=M(ZgJaiPK^uhxuq#}+ak#A>MsNumlaayV8DzpU=yz71|Dyk2v?_` zSm+^wnz|Y+S+ocMkQyAuSN{9!uwacF)Q{{tg44%OPv9*9%hq3np(on#*2=ZW3J}jR z4&(~V;i|rseMmvk?+oJZ|MO}5_B}rV@}pK&JTdSHWUnKb52gok{rcl+!=zw-GnW5fGz3TzOw0jGq)jk8I!zQKTR{`J@J=38#YU}pRq zyz>_>$J4JohxdNq02{)Srf`p<<~#( zgSsh~pD|;`I|~XNXPOkCA3k+#&8(`KGsl`=E(Rytn*=4!!J06lD03-_Qt`}PssPe8 zSnq%kWto&Y6HYK(&V=T>Q-TEx&qlpfH38MXBz>VhzhqH5#Z_4AeAS>Ry>TP*PSh@5r$umlYH`jx;Gicd7H~G3PZFf#&9B5qL#D8Wl2e zF+g4En_W8#p{{1V6GoK>IORk}e5fll-o+rJ%*BNlUO1V@EJ%-R|GnoG@rh;Z#2Djp z74g3P%j4$j->N7<&O!@jr_1ZwOpSQ7k{tuoDYz2XPk#RZT3cFSTQ+PdJGVK2^YJ6N z34|b%&T&8O{2@SM=16B?-8n^V!v;uY1h9ef$}-Ms7v&JjIFN^=pY<@7FIxuNwuLT) z9<;q(J^13ke+B>g+JB-OeItT;Q&SWE_~?@u?}|%GZ9Mh+E%?&%Pa=yvvdmGGdCp|B zn@Vt^|6DNiJ41NiNBy!DEk@v}evYC`wVs+@@*|NJMo{mXYw zXeDG0!|7wE)H~rWba|5Nv}DW5^Qm+Soo6}~kTV&Ym{H81zd)7k_U5o{>o$bKrmRBf z2uUSiqP=kD9Y=89jO@hbTI)o3b2PXwj4?d<^dF`L)a&Qfqpo)Lgh74x?%kN`C~X^W zxWW5k%vyb*u3ugdM~V41YzE)NxUg;eRuA0!K^?@fRx$3QjD5VIf#XP%Gh4IC_hZr6 zsC+AP^6yC>!RhAHhN&929|z^TPAbCkQ9)&c2&Xa-j$}kPNH?&u3^1xT0Q?+(p=G6I zc<-{!6MsfuI!2rEt0x~+yDN(TN_`!Ytu1_V8KB2^ZWhkJUExLu&@DLowfh`t}NH~OZ&pii`XheAVBY?5d;cR{jt!-_1VcUy% z<>*#)_Mbs_Zx1>;I?&PCfddB)VE_JoczPy zblq>p^A+*_W;%)?0364`S#!@qZEc-z*h+W1#B)xTY1!7Cin56ZY?<&L`RN_ct*t%Ge<#nu+~oss;S791q^{T{3JRTX05q6Wc}}{06$>cE_Nw zK=AGV_zrTJoS2kEX`vG$%<3!-x;C-Ud$Jqo^Vw%w0I7{~Gc=jy|r^J(C$T7LGq_|M0Gin^t9#$ESd#~_A=Q!rn; z@}*(+j{yW{y1S9dq=gx-p7WPpaXCU~#Z`-wCwsAT$99}(Jb~`+E^ybe{Hly^z$sA% zFv>UAwv2!zw=YByM~o=ALnsu&LytYeTRFv)`s_KgQClk&`{4Z+&ju8y)L(t=HBsi& zQR;7b%Pj$K&wM>zIAlIb-Qz{BK>Xo%H%YLVci*M>>x2UpQ7;WbwgfC&z8nk4S^U`wz+9T6aYr#; zkmu}RFk*l?^RVcjKll=k9y`K8+v4C2vB|K65*#;Mvye_@zzz=c)|pY!gjpJy7X_&f z3q?3UD*MR52w)7UR0cggT_E7DSVMLQvuf*5Q&poBe>4@XC#`f($r$5Ggz&QY0U(pf zp#4P?MbkR=T*n z9GG4(Uwhqk;{tP;GN}yS{HEfd9w8ybP|Q;s!yro+WxxN^KYS6_-7z|-GaGO!C|8=B zL~1_Vgg@JO6WaSa1FsVh z*3kyX&~*U;B9RcTxph6lOG-rbbqk4-l8*&8W(;Y=FTF-IQ-eA8nxn+DmW5dPk(9nJ|@Oqfo7-AV@S@6y)5i7xW zANV2WoO{-|>UFa&x;wkLNX&Rv4mHHEQqrLAQi}GDHcmk^EfR=CqF8^+4Osb(D=_n% zI+RzIBbJCGQIbG78U?WloO~XHFivqZlX&1-?>u;mAzomBx!e;Gikc9DEn8plfZ$Yt zdR<)|YU>PT1h6Dn@+Dw)S+B%ajTt#jXzCnlI`ZCVG!_)i9e||F3tv!UV(j3H8+Kx9?|k$6;T+)6pP+@XfU5iDH*8$sm0vPApe7X`@oClTDXBqxKw zG~t7gwKK*rFff2K-A0g&(Nc)uv){P~tHQI9W;vthDjR%3Fd?N@ZImj zK*Izb#^eB!F3w^HCI{w)5=NZ{(?huSx^ z7B5+h>RC0IQB~=I6ym9iiT?~v-cgFHYO_oL={JLKASe&U<2ZQonWv@&)Gu1O5*`Dv zae#VDYYV!%&P*w&Z``oKGgZCX=Y?Y~KwJ*yeIocLziB@B!V51LIsktu^+nR(f7`UQ2;Ui9}52$?wp5l&+`MXh(4)a5L7DLa=7J;w%1 zu+}xZUb=~8MyORVhM6_BSY>;HzfCGV+5951*=#|8dw=pSz?J|&;Mz;BQ7UbI>RN$0 zGi_Lz0&&xwtE4O?Ro{mso_^|SL2&b$ZOcN)vV{_y1zX7Woty)@ci3xRZXOf;AvIxy z6H#zCwZha5wg^x`6sQx+#)1Wl1Up_QCfMonomk$L2NKlPVk1EPOmi^1v{<_8j`jF_ z?T3+;lsU^ID=74wP=wXUU!(oimeDH;NF*)fA$z;;r=E4N&hN7{Ktb zS6_rNsyIF>6c44y=5pM6!~jlFoG0a+9A6uSl9<#<;slZ2@Dsv0XN@NskxHkh9Mo%T zYsDsHVxYcf&mOfoko__lP@g+*9_s7sH48l89Tl|GH$MDs-_1OVm=b4OT3gZE+iOtn zg`iH1dL*cqOpxt9AwZuqYtGd{=YwTw{83JHpHvDU0Johal$&9wm*om&Hp6`@W3J&5 z&Q)NqIkZ~NE;4~JidCzo)^GdH?K`yAxJM~Yf8?P>AY|4A7O}Bx*>cRcWGG0jt4{r3 zZUDH;_1Ary0R9)yeSQDWe~#hQumD{fmSFu`geXww0B@oDKnE}q014`xL@k7B;|SZf zx>s@|Kq0)%@lWlnnMfpJkb~5MK@l*3Ks&ba^Q8IQ)1aOl7(oBfz?k1jVs07!aN92g zWu8Np<&~M5GEr07?XLJsg^O2;uWtDo8Xh|`dPV-k0Fq)L`RN7oVp!JN+m36lyap!@ zO&yral*{CB_uKBmLt7pTyv{*A7I=+;p`WFS%GB@u>_1}d?bnYPq-m5PH)G-obGcL& zo3DKfI{OMaJ|WmBA#vp4qK^$KfHYHm?Oc5N`}dA(mCOxhkseM%J*2ri zK5`5&cZz_yJnss14%2%XKhHt^WKT18Y}=_6;UFmTzPp|Sxj3jNNX)~o)VDJ9(;=bU zS(rZm*?Y0}jU{g&Ug~3qF_1;(eR%z)+^pTq%Yyq6i_+{x5fL9$(j0-h2Pn z+WSm8nkCz^Jjp{G+nH=2KuE|?a)C0WKoSTSXc@}bF%X7ADbSYQzP-Jr7n+s=<=!$6 zA%rBPOaVfYLIyI~@oZVLBukbhYt|X|-s^e)SmQotANd?v>HB_I{>VByds=(1wbyq& zxqYh5tUI+0#w@F%jFWX zxtz7T3&P}?Dg5N_AK}4o{uGCvIDpaN5ll`@Vq)Snit|?Tj@$R$Mj)I#HHxXJsTGI% z)~#F7+}ylus6X+<6Y`rCg8H64d#WZw@z69@fb6(T+syS$v_djB@K)(u zNkFOCg_X>;SG>Cz3&~@5U2wsQI>YVVyU%=PvG!tB6Sc~hWarME*vi+%rE#dW&y|B< z63j!@^byF!ObakaRUhG7x7~(N2yjSA`sDBk2EO9+*b-;54FN&Vmjs z$R3$vVC_EGsx;X84A|Bz{GKeDdYaMF(}u3T)#zT;jrR6-bhNdjrKJ^~=XlDiWHmnb z(7SG(xnHTuv$k*>uBP>Tc1?gyGUD-1_!U0*(5>5x^IyX0jMvo++F8f#Jir<~dg@3Gf*%1l)4NAL5P&zMr@` z1s}~Umk4!n7N~#pLm$VLZ>k^a01&n+75p;F(7{2x@4YuCZfoUvFfarZVv=SP_j&7^ z-;UPRZFOI7VQLO#+SP>3TboyjHu%?vAml-108eIb&#TZGATyEDZyFP1l-h+`rET za{xGY`Zxe62RI-Su$@K6kE?fI$5vBJ?QR|A7=(elyP%7-G08`=ZQIsHZ>wfGDuyw9 z;sm6loBVNA?m9_8rKC>E$zjj#-A1}*>UkLtcB4?QwyVqE6gyUeU#?;O^uQtP-@6YC zBpu&~A$oXLCWc8Waep;av=cljk~HO-Z1Ne8!}oposWfy#E6xDU8CI`eja()NY2nil zw@?RQ+StrQ$$Gz&V{0WMoSB%azfoE}eC-YYZeU(?V6Ii|QbJcShfX3RpXLAfhmWCr zxFETP;bmStCe=X=_al)TJkOE?Cg@q3N`6+pe|oJYom&J z+d5DO?8`VYS-*6C(+A&(EGHA9=E6L1VUEgN?Gf%C`vs2w;Bej7QnyeS%y0aIo1QV4 zU%gD2vlPSji??IvMLUqM5rccS%DwN#KgO5u`Fi4J4vtpVR8vwvLvuBu{^uY1C|>x+ z7c~TE@}&x%k~7mTS^l55{U!QO4pe>L#Ik0kxkW0WfO6G7=WW`CO&4#e`&tWA^Dug< z7&Q=kACsUyF?rf-6|nHqfYJ~vmWufG!w<(`-o9%Up7)~5@$BbaimltXp}ngE%;PEy zROW{FeP5m@2!RH=+_2{o+P+SS9r_yQc+_}@aUSm){c<`VD>vMv5DJRxO~~73dqa91r7`x#Ia-j zR%4*N(6>Ez2iCmle0W!Pz`L>o{QM@c_LR*0mQqa}0az5kbO@R*LyU(A#)~KwO7J*G z7=$Pn%P1@qQCL_+p(r83l}CHpPoZaR56sI(1SV`8t@={l1F7TGetLhcekZlx;=%$7 zL7lM5aeVTk528fnn3~;4=EkF4JHiPA^N0k#{^8F64TQMY4fFThgfIT>zcz4UbNXit z=12j3&)$MeYZgc`?7V2_vZ4N$Z~JrH{IOdSH+$e{s{wTaB-Cp>^bddNqqyQt4MIHy zl)EBO&A{0jMF1c9!}lj{YG(GiOo_ReM6Am@KJh1YkC%!N7$tA^I466&Q= z8B?><2C^VHAQNVsiJ}N|d#x&W!?oM-?B_oh*=*Ka)bl)ezK1Xj0Vc;7pL<}${@`FRvd1q5LT zB7(;~V>|EeT7{HaFv3i<6x0D`9g7sKIrkiOyd#+qGyQ+M0d@PHS6m7(CZ%&y$zv)K z$b>p)y94rw1a2GpKIV?q??n$lhNhhb<~O|iCVb%;kj(cFAI8qukA1v~AzU1=T+K@=h^hX5EDmmc(_64SU* zDO!;F<-@;>L2@Oa-qf7OhK=zoe2qZ;z@bCNcWNb|{`?m_KQTjGCFCnh^)Y0vjL!d+ z(}cZy_r>nkg}PkpqdKH5-;#f2&59(}tEg;oUMNaFIJme^hOyHwXRJl%f?{m1&@acc(P+~#Qq zR60WPaPmMMtA%j}wkD0HY?BIc^T4^f4|6|Ky_C!3(ALo=uVDa8qCWrtAOJ~3K~x3- zr$0o13w4ik=%5U%j<5&@2mucfdIb2u z_6yEmHq`I={GE8;$CIU8k9p`|`NWml1PBvi7C{a5`v>0tVO;*ks~eNlIZ*5jk@6ag zYx~sAe^d1x2aBb+oufjcsoQ>FTL38;ez6H}A+J%gjQBnhQ* z(e{nj9o;aJwj`2)lFoxBCkUj*5*X;~x@f=%BFxOr;@I(HD-QJ?J9k#KalKGKbm$O> zVa1@nVcmLkc6Xw(=uonxlC%bTIyYPsG# zuE?Kn7G9B3xmLGFc8&9xGn{;;Kb(A^G3h*%Kwqld@SfM<^Pl|Z`p;QsIX9RSyldN# zZpk6=BLrTEvKJ!c0s#w9_5^r};ryNFqpQ7RS@pZ;3wPp{8c^qqqn$M;LY+XEpcw>| ztbYICEg!}U-f(rpP!Bs~dfIx+^!OAW+W$z^_xXyXIkQw9>h}B#pNCXFISp=Q35sPz zkxHJW-}gG8uHjTJmM}9vYXla={?~$sEKRwln95fOf^kJs`$QznIt#?eBmpAx;{qOd z?8(Qil)pky?^&}(P9~QD^|{#@j0}&gDAafFcJj?54(H0ZUuuehm~E9;?_HTCK-<;# z?%Rh#VG%CW-3dY>)EPtniR0I!&Qdqfo0^*55dWq&)HSS*&J5a4rPSxfGaV|X+<;oA zd$q}DNX4lewR+{OQmKdpNmczN7oOX?=Pq#f?%!+d)7E<(F|c#S;lZ~mcgSsy$}HpQT76aoATpRkvN5`LT1% zQ}wEQ*=!Dd4LHY@iX}sddZ2E`Hnq$2%#77)8n82C?$TxKz%YF7OZzU!fPyrHK=3(7 z5QgAdW5zj9ac#FQr%s>7^vukPLw)D2U2@lDK>gss19IG7A*f$=*=6<_Fs82WJQH1o z*jn#6G$uI6YSzsaLVbuuUxm&_}!=f$U6Mz3Pbb=*w;J1aY{Qy0 ztI^fniM$C})2p?qjB~z^j*bp9p>msD5KMb8^BsY!T=r&H1AWAvX>p{Oe!+Q{CsQx9lH2j4LjA0m{Y3 z7m1-Xz+T*ee7*&t7a;TqWv`5YM+)i@0zX8VN5-Zeae+-+`><-cQ2*jxxar2%V!l{y zZ{}c9Qcr+75#h9$LAeIh-*?N0aM^#qvLUEX_%mqfsz3L{Qx80m_`SPaEJ0wAs@vk~ zH~)6s*C{NjiCG;`cYRFcK5~qlnwd85kyM$>v14`5YOt()zR_qAqhn)$@;}m2q((Fc zz&#HTgi^U|BUscJ6!UL^h2qa2xX)a7rJ%lL%N9FvXb|cHg9A$VTN$XYU%w8W-CY%q zadD{2Z4?*Z6TIJJ&}VXGNq6BF#u)bQ+b6H!Xj2lQ?!>9Lwzkxr_Ovdb9~?aNg4UMS z8gGlOj#d}zGBPx*mi;7zLMe#UgEW%5PzoR6K73^}H!oHWfpW%$DDWG^40B? z!2S7|M^P@9!I-D)cN?Ys`6t>Y^eBa~o%_(~!E~Yc;Vw zQeb@I6pkG^Z0%yq+VOQ7){$Qvf!IG^BNm+joB&@Q2LSneGko6z2=KXwbT*B&pEBxq z4fXD>F4I{x)b*qbuu!)H_;&j!}MaEYVcJa`cfTIDvyP!1qfr=;Hr8oBA)UYQO$Huf@N9;xqM~tAS!*UaGU6Zb<_zSFc8ArWNTxu8J4% zGD43Kcp(BWLfMZ{W+6gf!d*i>WFh*t^kG%!@}R!|SNrg~>u#(G^-i7)bpe5KF@tgq z_5025{UA19x~=YdL{S9vq>-TMPc8y@`uKsWuhT3Q8(N3mG6lBE)e1QD{kOcXJmy!|1Z8XJ?hN2F560uTb6`{p|3QV}9j-u7xX zu2-$J@3h=LI6Q<&l@x5Hpq@(k%Z7TnRK~!-;EFA5P5f<1FYx1YCUa^3?4vT=k1~tiRuQu|vn8 zE2&tmr3Ow)4R7r0vQhQKBAywJl)OzgX$(o5mVRC~bS;98IhRUf8KQUp{SP1#0zS9d z+N7=9F$vV>5CB;}-Hg8HA)C#CDM{aB9z5ezXC3aEvQ5b6^ObW}Wh${y*ON5>VC2M} zEB^@nf+=mjJO>dLqWVBj@?cJBVD)7i(4J|7Cpglf55FwiG2mqc3fyHDpzKQrISqB~C>O908#iyn zs?P3Z)qm*VAYT7Fuf=?!8tM!ToxC+!{SJXsVyY(8KlZ7=soP!+08?TXUT?0xoeB8q zefL&$aUDu;-5z67WzNyo9OGGKOoPL6&09|yUtwPs80?eq)tpo?M ze`{&b3V3pADpmCMnAXvkJ8I)eqf%5eth#KqN3F?5@0R-3OAqyOsiod2M!-Zu~=GBsIT9! z0nPd5`2E%i^?|_wl+@&RC7|BBt`}WhT`{O@0h`owsRdi(Tcx(}*gjGNQjxyLW{s#!x3rSn8D%I~QTOMq9TLk&69(?dYgyphXO$`82YM~S>sY@q0DhRMPAFMMa^R;)R z#IZRGDl0~3d&Q0b*$u3`b| zKfhBf%p13vr&}}Fb>S{#SsLlcgC{urki!ps1$7^(z?Xx!QoC!Ym%I>VFOs0=0+AOY zU?CzNVq@PXY~Ikfta}c3rIx0D`6 z5z4u!DxGGna_Eu$b?sM5$Q+li(_U|Z4pc#%tX6O-sOvPab2Bp%T4dG5M8L)^eK`O6 z-QexXnRetWNGKLdD3!}bD_Smx3VL!MA#_}h5}MTb9Ry|UKe%7Qcm<)pVS|lHZxrhN z$B#SNL(d)R7hQaj{N8bPvvsIYgX^lWc)i@bFl6c~1vKFtV;$pQpsquX-Me*raeI6F zMW~~k73e3%hJHJp$vAJ6g}MuKT^N8lv53*pQ6sTQo4KCx>E7cwff)OZwX2h`Uf-lt z?Lw`e4nQ3*L)JEJ+EmZIno;fdO-u^5Mi=$vkX#&`=+D?bv0s6)xC~!}nvl4V#rH#LzQmWAJK{!_@$b6tX+vC{GLj!ZO zwz+D-$V`|>4NZjM|2S6Pbt(%3Uh}RS@y~zpziVvU!W^=gUs`|}o*?Aw;@=bDCn3}Kqyp?6s?)p95 z;|n%90!xMZJqhY2#WjFHL|9y0FbTKZcdvVOH=cjfRk+|4&&HZ<>(IMl9XdKXkZsDr zPx~l`0m7*4oLNfg^7Phm+5D*SO+@nhhaZ1fUu?yozG?I3SW7hm^})g8^6g$BsGq<6 z{G=uTkd#QKdPlCJoD3H@;@Vo-?((Us4#i@PA=lPc$EhrG?s-8#I-A9Bb=RM}eJPkv z(HsT`224J76YI^anw^2$?HndkTXVh{8=88|`AGFHeT~puMMFF?;MX4U0c;*QQnU9% zhYw+4zF?$g27q}Uz-=CO&KZI*ggCf>*xO(_oz>;AoR7A)c5u$rGN|$)bH+@rc6mQ} zc&>+$vyz(baArQ{PIQP=cDR_?%WMN|7){-!nPWqC6#@jxtKES)MJ5|uNNU1F*1KIm zp!>?+`md!6177vc8*uAK|FPEQWtY1i`2j9prZ+o-Y&Q=Q;GW>%k@_5R3GyffFZ7TS zo{`k0O+8Rhm!WKdAEC^pZ9U{74)v~fY+k=Ss1F}Ff$Oil4#&p^6SsHp7UYoD$}Xeh zh)AHAAPryphF8>m?bIaIUFT=L__=lMSEAtTJDsJ(faESrv;@>Ez1}(Fn4O=Kx;s6# zLZ-$h5Wom6ZOz!&w*futdeGL{fm~A#U@BXse(y+vO^`sTSTx|XQos5e+A&v3_s0hM zb;VW$>K*Ov=8slVNTVlyLl6&i~c>Zo}(; z>$S`CW{1?o6beNg+;<2R5_rVm2@V!A_>l)M^58`b>Cl58S*UB9y0)2zeuRKYsB7E0 zhI*L^ggioPR~!1)ZCn=A%L^s^-iu$42&7r>T+sq zOlCN%NareyXS#F{({^<&`9VqJ`Vnb0yH@!UF{6Ih=iOeX{ah%BCc|8Mln)FHTAniv zY`p-AwxKgMvx?yX%%~BvL35w*Fl2v1#UgB0SP@VVg64a{Z!&+ zjdC*W=}c6xwB-KP`)>!vnQ!i=vZ zWbO{R5SEtYg)_d|I_YSkQn_Td15np;Q7+GY_}F0-i-i@1`ucV2%oAx8>H`A<^4YEs z)Gu)&rF4R=m^sa~k&Ho#OWpA{)1^|v*Si=yx~s}`?$X>mvjSB;cJw8IerWK>3o@BZ z+DK&yLsli!XT<_0CMT5x9AZ+qfwc@OS1<>x4c&GC5`3}NT8fpBAOd!*+kUot zbR_dA5$2@S?L&iu#=(s%h+D#IY1n=R1;Ea(4y^V%9f-T$^H!y92P=2&bEzVhx1>xB zBsCg8|M}0M5yH6#?n%`t=N9Z9XBa#_06G&Sv}T+f=`GF3W^>@mTiy+MI5=wcp56b+8vmy*MEEWg@9k* z^}O~p{^pjyO59cnHLCc$6!N}yjxbLG>f&MnhxZ=_g#=G9coByuJftFSpq>gj{Lq6J zGNhxFa+D)wQx`F)msub~+E^qV7u zQqWF?%9w?7F=p@*t8hYFYG>fW&AY0;PD)Gb*Q*|=QNps-!~s|m>e|#MH!|a3>J~u) z3yX_tNOYkNm2^f9P^GX8&$DJTGYQoiGA4hEFfvjq2@O5SF;=aRNg!~>@#Nm8;&47k zsOR%}w6}LG3+e+W29+gnWuU%Ut<+iR>_(89$5=HuM=S+wl4R~`Hvz|Kj&O4HBo>QB z^9+-q&doLDdHg!;=t}~9c5&`?`sDGMb8V>iPY%k3RRAL)MX{tYvJ*u@&sHhc@OlEE z(#FBUTYFtH(+E9lR%45|boj{9YIc2R0*9vh%?o5~)sTK<*7Ms+vPNp=GSzDY8>XhO z;o8hysE5wJ8gjbR$vVjwYXAQI@HvOitu}x$4}h+Vlx)V2jM+Bvq*`7&z$smv4O{#zGUFn61}uChqjH-DsR zeRG*E*Hy9WIM?{UJuN%Ho9oLs5-tY#%#S~pxQ)zj+fw@fv%&lwD-3g83WXw$9XbXP z2zbh-ZlE4=c#(%x=pn5_+ESs9R3No4F4P02p&lYi35YZYr36^s2g`d%w`D+$Eo^4W z>W!=4^ z03ZqKq?2z!j!R1|60*3sh$s@uLtSO!q{u)-Kp+qyf~X8~$5&X{TkArjP{=U0NH`96 z!n{ku`M3Yje)GPs6x25>wR@vbFPF<0IeBu$px)KhiS-*cB!HML8PZm1AD8>t3KPh} zTx)qDrF4^Ar~>MYb5jQw>hr~gCF9YTe0w_DI<5d*$ueGLRQwe|NV|rrASp0w$=rfj z=5Nw4Fl>u695#KYJ0war2+WE}%tb(fytoERL$f*J_SVld{1V}5=Pk3IG{e)Z6=5FK2o zXbz{HI0J}*Z_J{psY$J*X4AWxq%@Enw>j4wn|$fk)!F;p)t}&KOXQ`jZJE>z-%UQl z$Vo&)K&oEbb_mQxGd3HXGEoR+JGV}7)zUesr_uYOzWS~O;MR|S8i&V{Jmc*-|Nj7U zT?&N)jvqNL)$bLKa(*cPPDdWnfedMrlDd5MA|-&V2d^cCRBHyA?mRM`S@>-}{PrwZ zvxh}i#=%2}8VWPiW&Mtg_~LC}K~n-eLxf7*uAKb9kztK4axRO%z`z^uU3<+fH&uNX zP!t=;b>RtZaNxeZbze&efzpDK#%e%auU8?z*J^h4U4rx{NT5(C7_FX86zztcQA8+( zfr*5X$2r+I&Ff7FN&!4B*G|{q6Y3q4rcpUApP8A$sWBVDv=UJ7UAGP{w)8Ww&!aZf zPYeypYpoE}w{6=B<@IGGb923fkT!;DKZSTEI5i1E8Oav5i6A zv$2Ue+6xGniOa(eJq+%7N`kgf*P&*6AK8ofdqz?I@fpy32wDhbe7wh`1DsAzsDz7k z>(_xnC8A*f*V~z#J#r2-WwR3UBCh7s*`4&nLq;Fy7dhTPSgec07m<+g99Jk5F>q8tJ>oG(xm4sy z>0BkB$&inhbRHeqcI2B|;5Vm$EJKtbgkFRak7Qa{FT`wN4hMg|A0lYnw!D7lM*N@K zzMLot2g)T>d+dAQ@R^sGCidvi@x=T9y08fF=NeGed%z7>RWE~@B%K353e}U0;#_?h z4pTfO)!&6OM5tBiaj4t1iqzoExdn}*ey^%Sxd_H!mU-2Xwm*a@3{@znn-jwJ+)}xS zpd5fRAmz(tlykYf5u!-h<@LmY1mW?gpOOGn=Q>xY=kqz_^LbzyP(L|(Qkg1N2I||k z%5=j5P#O|PQm?pnk_Wt9J&mNs*G&^!p~^pYtl!+FfjX-&Vpl-DDc`iDjkzY!!!Yb? zZqB#L(^n2%aj08p0aKHc^5H3m44v|ok<8}~Xo-{zxOHdIdEezec0aR^-k^S8(!DdW z?zJ4?T$o2{*pDD^s5pRfxojSXxl^jVZ}+Yx^!xhy90{CEJhZI`RK9jAnL`LL;!0zo z`yjzpzYh!!!l(ckmw@I>Edl`S+H(O|&KdlK{9!FV*xC$OX9`G5^*8THqp2w`GtH?9 z3IoC8%w(Tqj6tUxAR;hPVfS{P1qq5n9qK+Dd!JQX+4GolE14&gNu$mjAQ*h$uv**P zg?Z&ajqkYH9ROa`bs5rYGiSMqE&CpM3ZMM;-zRQk6~B|p*Y5kye;LemDHcl@Ja)o( zzx%?Iw)K$17d~>S3|gC7(bm+8CNF~wrI8M0h@oDrrNjf7D%KO2UYy18hmHc}#w)Xa z*Czb?ZC_1x z0#Gq2peOGO`k6CRn4OzlF{p3dChh1hheL|(iK*0M%cephDdr$2 z9|dC!>wDLkYiO7o5E4_19tZ_*GVR0&fY1w`kQtDO2v0uw6rw1!vF9rOU3;_>fbQ-t zw7+D7UF+Ow7UpyKJsGrJ(uLIa9M+uID;Hq_10$PVPTwDA9GO%GzMr;gIC)b5v}2;9 zN>{&i=ds5y^S^e6)7u&BKqbFq@I4<*UVXW@NA?Y4I+`=uk0j~b3_a>GYn%)9*99ND zx`Fitfq(kTPvee9@2Rm>&$gdl|b4v?ynH~m=4eqxS6G<)>UUE4*=K)H z^IHBK18*b(kOQ}T;Dc3Pmk}CC*DXmvKXRhK{s}}z57GibIYd}?RO=K!3FA!p3AqwH z%<*z3M+HoTVp-)fP||c1+RPSOqq$IAM4?c?6OTWJU)^>;_W$@vj1P{YsFIrysl z5Qb$e6c(jT9m1&HwLX&sp5yn_a_P_XQ!ZspFiPYIF@}y`W3q=Dw;r*P~{)i=)_c z4i9Pjx%;Ez&Y8`Z?rdXBCX;DTx5gxXeQtL~E3a*{K3QoTQq4~020%pEw{M@(0BBEk zk87tmrdB~?m_IWM*6M@h{fd?(*`WyN=;*+P_3P1;&pYM=>mQ)a4CzeTk+>a6JF-?> zH|4(R6?$SO2p;FA%{A`aNtkX+SBh`WR1f-zWg2*5{NXCeTu1m<%jH((uAT_qy!B1U zZ*Q*edg`F}|M4w2c=AZyhe$R1|2Ht#rBo_oWbh0N1?kTCDC^RrP(6bPk{*Rjn+)df@*0+t;xw5rmP_&3j=0r4lZ= zD%*-rm2v8fF@#}=APk_L;-o|_U?Ycs{d@Q0v9COUg-0hLrsIvOoxLIvVQy{?)6+8u zLTP$1>?MFAk_o{``UD&~b_6E$cm<%|wQ3c-RBBmJA00iZSh6xu-@0`x^cc$2SgVT- z9VH8ON1P|eMy}h+Ez+k*)r|xFNBg1U)TIw|HPmAoW5y6cybv`?O`xytT=ksziQ`bW zP7St9o}P?J-fnJop`_55!xfQA@u~)R-6(GSx>_q;+Gd4;!lu5>v1>O1b18Ak&r>vq z>FH_63~+Alc6Gzd#%EWCw5{#!g|?Y%i8M0TCX=Ls0H-r6>@YG8Cm`GD83E(t<6ux> zWw7wmbzqF6u&{t|@0>h&hJ&}Ir2SmjX9>oT&o?9O`^cr!XliP*4sc-RUOnz3<)>kK zB3Ug10B~W!ZB%;(+zk3{(d!1AuA#slOFm=r3drwTTC24zwaU|X{n9wX39@nKahSt= zvM{%3zvi#s2ujsY+u4~}yy7+2;pFt#S@&J8nw>F*mX`XTLp`NbDq&<`1PBS7xRKUn zT)GFYZ0Zv1GEO}edYGS|NARP`Wx;&Iu1)yrcfO9M1eiyNFh>RGybT;&N#%UWaJYZ_ z#HSObVHPr^W*UQex+#N?f2=wrQ9z(T)i>-jFSb6qF2BD0KkK|A153%M6kWnFK&eo1 zEiL_+!?&lvl^r2kHqw`6m;d0R%F1%Z5?yS!H8L8-=;+b$;|zzlAs;p$;cDR)?n<&|B~J-ku(r zI7Wd>K!AhEYY|C1xmrwtfg9Djb~-a5VGaZzdGry8NW@^v)eCC01;j8oG^|>X*^F>L zKxF|j8X%ktK_WuFMQ7yFiD+DPyX>T?v@c&8_xY2Z8440AF_oP&x)Tu@CvPVJjKM7I z0CHYSIW;xM0zgwfSGOH~>_0~^TpBYfK)w8IvScp*b0u_u@RC(m;QaUPsqccS%udhZ zP4D?V%oc0s{{H%Xx8t3!Tpr9{|N1vzbaWV(JnvbJ9ekEjS}bAc&+XUs5l1TWP@XP=zCR7tct%NiW(E5rdn8>`mlOwCN;^oeARL3JTyd@bQ?^BPcEEEp#!#^WKY zrqqBs5$vd~_9>N0(&3KTiFXtV2tnXJ2TR*w-dmkT>&{M`ckvGNZRwNFXbOY?AR?KR zMr#=fdUZ$wAQTKE6w4(XIxLqlT`8z{cRQht4M4pd1UNHwX2qbsb<36t$y$zEuJ^lq z{7n7r3N*5~NucaDE%iGp_hartEfr8_`Uy}B>dh_9n^2=90zC+VzD#UE7JFMsk~sj3 zgySfe10z+tHgm07mw(GpHK>FIZt@uo5i%01YHS4?E%B{cvj!c?ex3|-+lgwyT-&A$@L+1_k@*HmTiulM42-trpE7OJ8CjbGf3cU`wUnBQ{C2k^Pi{WAdIhd;Up zo1VR`v6Gyolom@EIXnak1$^RQDpjnfa=*)%bq}TKBIfTMTOQ0W*o3ct_gjgubYZS- z=1Y0B>oRg`1Yf%Ov(?X(mIw2lmtBCHUUXyC_hkwb)6H@)G@)AE{)6@P?ua$9~}o{K&ss%W%d(xirdoKiVI%*99-~*=VH&BUx??t z;xe4SV<(!LnyMcylQw)2$`Lf8$gH73kw6s5cUHa1ICS)|1@a0&y?fPa#1~qY(2=xEl`>R*!in_&0l+|T&a?;H7grJzD?lztvtIh$mZ8<(u(+~t4unR2_!sP$8 z-t1H%nMY=OEtt!FBTSs0a3pkY)$7i}D|#7Ku4Y$^0o~oJj7r@-FR6)@AnREwv|}8U z%1leLW)j29WM=%-xK)djomhC>Gf-bxTtGBbkoJ5nox3fm(!{RX+yl-TqOgoG2#oYC zL++FYz?T`~tg=AEklWBYx7{7@ck}WIl9Laz15D-Qj4Oznj;~X~5<^#8SIvG^Sq5%9 zg2Ccwg^FF*$G+_3{OC`5TW7i*FTVAy4XNG%3H9sVc6|)$-?;w{yz9EREeqz~{Ps8T zv5$SkeAnbP;pad33D)eXZ>{ZmOSw?S*wK>^K?F`r#i`5Re#B9lDPsH=L(7DDAHMnB zZ=*Sz0CNb;Q&GM<74haiyhNKh01TfR#s^;ehl$`!pW$E)hQnv_S$zKA|4-t!IZ9sY zwVCB&&P%#{|9^g`?(4F=XT=Kh{>xHYEEwpxr6$z%z~Y=Ewh~*Q?B2qrkv0x(YWyh_ z7p3DJ^m|Blat;kal4C_g*1t!+w}N#32dRBMbo7XX_6k8g*OWthTWeiVPp8t@uzmwB zea@wL*~?#s9Xoc|3H%B`ee2dOvFFcXS>Y<$%BgOZ_dA!@C3UW(Ny5pKC*!Mkx)XpJ zP=D&szLz7RBmzB?&OYC$6;y4Pf;j-3nV2xrIRNuHatC-)2@lNEwBPG%7}YyuKM@4y z;md73Jv|OYqnMQJeqT$?PU`o`Xaa@8qD>UTWZo*14waGP2&a?G$eGicHEX0A9eN^R zz3R!VmY_1Jna}cNAf{wXvK@$lVPIeYB!se)%WHF32ui3k3=R(32k$03@a)WyrGd`Q zPB|HYoLn(3y_q@Z@RaI3ok~0K)ol(yM1VFE0AS7w2;s~@or!=^!@Gl$x_>isB^SF4 zBn0wp`T7^sSYUYI2j4+V)lL@gamBl>VCCHYWvgC@3qEyaLtgIyu=n97aosy^z+7Pt z-@N~Jy!&^S2lFp|^UHYIOJ5rQ9)!+RJMO#pK6LJ0)7VMRQp$xg#*dGK=`^uQN-xe9 zaN<9YEz6sI!>&Gj>#Q(`g}G6+*H*I+j}POP8~zZ%e6>wGHOm@?IT-MFU;9TiCwSb? zQxRdpticCIdxEi_AUn0+U5cPp&XR$74&%JUQr2KLdb<+BB4?(i_lD*1qnn^gmSrr@$pkD3ia+) zt5luhQ1??Q^sZZvJ$v@xw_o~FTz}&Yxbmv2aQ^w*(b3VNgedEne6CPmyLN3%>Xz+B zHh+hyn{Bfy?{_DoTs)nutD0vxIdW2to6cD70zL`q*<2>kj-EK2^{nc77K80rXM;Ha z44*tHoi$(^3j}y7JD83`XGUFX9pzw-aWawVPGTTwAMExG(rMxBHgjg2r}RGNI0#Hk zOhD&oH(BDCR1VqzDM8l0?9#4xI{>v`cUPBGuS2bx=2TlJVv#Uo_WqP~DU&)equ|pc zhLI&1W->N0XiKL!gY&EOT6#$&@? z?0e^H0KlK_`D1K)dvY#=rOHzeK90*@c@5tE>bEZo=AZxi7xC(sU1zf1#kK=jlkUQO z_x=KHm#l8MZcCM*7+`YnG$;gok}yB|@L?pZSbEm7VOJl%{k_`~ZRP?33sh9bl}ea< z@ebjX6Q@RS^Q+&3V7^*a;LkF6#X2W_PPzV1Z^AXtzOw535D^MUR!Ow;WE0R=Kl1sy z+uQe3@R(=E1<2dhtELfv;-c0L)P_0q7#yCc5jd zWXD)pOCrd$vf3do5^7;BB@{){0Z#~lC-y!G23j$wOFKFtmGaTs+lz~L@5Z$+elcG2 znpfe9E3Ux#=kGv!d%HZ3GtTOTqE-s(+A+=*1zbBgfS6-qmG`^SlFDt&Xc}BcIi^gI z$8_i#W3jfa1$E9iIyyR@gM^X@^!B#4jZoF8TkW>bsE#&?;t`tlg3tmeIm@|O}lFLc-R<&g}JQrgd?3RsB`^ey}(`Xcg`5{O?hOq zIdzT5n#qV@)_zs@pcAl|mq##bOmj8b0+^gUW8&XA7(C{inS`fOwa(4WAsSKxk?*|d zo=QHWzFMRRfLqA+GM9T*x=8iv&02Y_Ifw*LLRKp5B_0xm9~BFLLPI>XF%3Kj?@AW@l%d6~|;anzIZ_P4D;4P6Zz= zZOVsbIyn=L&D?Zyw*$h0UwQLSOiZA#u&4xTSs#GGXDKuLV+5Qyp;xVn&*tRCRHw;E z4T4Vo4oWL)J?{y^bILaw@<=7*Nm9A79e*dHIN2aGSCpiFs2T+qWb1YRDWB7-! zdy_;gujeoaLCsHb0w^xgb>1x&B4}?*q z)^8v+9!u3Z2qs}yQK{Yabz;Bu_$VSHb>iFrM5HCV_mfY;@c1uT%$Z z>g%hmW+!cXcb6x%Hg(-u1rg?G0kgBS3fA$sb9Y%$*ZZ9-&~|ooLaWNPYT14kR<b(!f^eKvM|j*+8E-LA(+#!R+2CU*v3l|e3-Q{SnuHYu9J z4NQB2%<&TNmECBEr4@&k7OF3$@XHNNR5^0{<%H2|)F;jzE| z5vGG#=uWPMmpIsyKF7=XO`GwSFZ~&^%Yixv#95%u7{mYg(m&w$f9H2`hUT$=B8n&@ zK!AWE1PN+)9pbevvl>7A>5ogAw}ljEaiO@&6v#$A25{jTpO+M_FB?mEGFI!Ys< zoH#XvKe_JhD+=>;QwE>?#=j*_I?5C##+(B{Cu;#qsOjhb?OzZs)NhyYno_aQGR7SZ z9pX?g7lYU~4Xk)}GAk_TDRn*d@Hu$VONVphYv z!cp$bnKSW*tblsV_q=n70q7_bl*>1MhP7y>9vwDB@B;@#6Yb(OXw`LV(jW# zFinuep+nkW8%iImzw22eorS6vTG9KW8s>Jf6q)!X0^#)3X}D=sb;1^%RHmk*9GBVG zWWVR}dr(Wl%KLLW9ZV>goeA5HN+fXV)VN7nqo#$*LsDtT!4U)jqC<{XZl wPx?e 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 z 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 FV1l|q(gpwk diff --git a/.vaunt/badges/badge_04-02.png b/.vaunt/badges/badge_04-02.png deleted file mode 100644 index 5f00f0979da6d3c7bb3f39261fc9c4d693fa6242..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 170297 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%0A&J!jTw4;RwQ! zC_>>dLgA3@6GR}$=B55a%L#0&$f8&wVF@>XK0u?IQUj-Ue z%03!2Xp}+kz{D|JckR{K_w)CBY1)NKewYJp1?PkLcya>c$w}9BAp~@fxw|BhHb$7( z<)Lppgu6a;i4)ueP-7HcGp80J$;l+{+I$DT^3c~X=`>x1Ths5?9^FWH3ew#r43MrN zt#o&HH_{*oqf03fq@-JptF_4Ec zG+K-eDrxs6aIWPBp(K@Ag5sad=7`cqVy~7~wFWO=IJ)hDCr)E3r%PUE3*EqG6}wIs zCL-k7ids$4_C*`laMyxVtA0wfcu1=kg(C8wncJ9?JS!R?2?57yOGV-M+^O|9Wp3)N zw_Oo6C8`azOr@)FqL)a;kt4xoc0rH&d$P8_8wx9(3sLv)E&_a_6#fwByD(Lu$q?-5vK2 z&OT4cZ5>Ux4;fE*dhP5IM+gKY{i=}#z5Zir}Me%or1ohe@@Y1 zB21f~qHt`aEQg9W$#HZ5e+&7y0VODYsY#K|3Ox~y-;LXvD4>!RG%`QeCB!~uTwuEz z*yTM&U!oH!tb&9?Y#=$O<317cLXv*!rM-bSG}%VkCdjwg@T=orIQeu+oMpYIwa@Z` zuFOi^12|9Zfb{O4Jl5uTwD22N9&{dwqtU3B!E)fpPFDM-&AWU^x=M6%d_qE1k)-=? zuukel#CkjQhgr2MisAsOE-XCV=O7A)U}>nPCs6u3|W4|LMEPjuEWSaD1^MrU}M zAQ^GEaY#lp>0P#f$3vHh8;Zy6{0L=x5i|Xp_&|IU=??;ZTmQIcgWIXUsO0-qce!*} zkwhNg_$8rV#NSdf22%yB`6qJ2=dt5Rs!Ho?Dsi(mvlQDA_bw-Yr~8afdaK0i29AsG zUxuIFdO$?GIvu~JW3YD1h&X}G3caC;bN5qaQ&m?j?uT$Visc25%d$Ht_d(!yuPa+J zSio{c(xo@RY7OHI9Qbgvn{wHb4P?~E89*7CBkk*CxWyWJOTWf;|G zWr6h+1oX)Fn{rk4khad}zb-wng5Xc zhxtKM0dckcj#z9zR6>VVsPdIfEwwqTmCHDf1a>R0f*j0+SM^#)eOu3b)~XWd3Q?f} z;)ngs(><6b(?x{F?0y@%N1+dE^|}dTkom&jk|4OU-B6+XtMTRNjq5AP3*oQ9L1-XL zXQ3#E@JpsMFLLaQRjjnl+!ibomHliBLyKO*tcarl0)t$pFN!jX)T0E@n1U7R{+o4O zJ5-C?L!*6*CzdAe+i7Ytv1$%EFT!7Bu>u=q?08h= z5$TeaHvh7nUuAlz7sC^V6?Nrxj@6968u8vlzvWU#yXfoKBkU0%MQYZ3%bz@a4k(`* z6UmW?;C(Ntt`NbQxv8Y*B!T+Ty6q5#E^io~#amsko{2*))k=)>v4J%$5@vGuebW+N zdhm7;7H+&`DH;KvK${CP+MZCo(Q{9z)OyWVdp?+Eh*zT9f$`m|q+6JU3}cxRWg!Vv zPiwehJ%XyX_N}I`XR^J2eIu#D%=}_H&T0~`wt|=)8Wdk_-bsQ?frAPxK^DzQJaO&U znDQ?We}V>qCeWIAbjctS{!|qerMwRDa5)~n!lc1V2#Vamle^*aU%$c?f@Eybbd=?B z6GA_u!c?-=R&MsBPc9$$hhnUHV>!saR|tD@S%r5HAWYw+i`bm)NQ(HOGm~CX&v9^6 zI*yYfOCtVaU61k>m;%YZZ?H!VA&$&f7vXWymg^x{jaKu)2Tp4ia6#FyIrh^(3l5E2 z_w!1ALdvKl=Jds})|!b(xA3ZLt+`Cqs+rk24@p9-@>i_-xTM_&jFyKM;G8&{dCzee;6SywzA%1Lp#O2S(cghmn^>+S@0+^!8nbsMQ+6iyJFv3)GM{ z^u8eQDjfm(K3auKOB;&07DXp|QhmmvBc~eeOe`X5iCaNMfTNz*42}B&$ zl$5tNFV0!;5x&)^{3#*fDr-nQz@yGNQzA0gO@dQBv+G!2%dseIFn~QHD24kz79tRN z;gX|BI7*mm8)!)-7k;w*>k$?KO57}j96P!XKPncmJb7SEME5KfZMa$}vFoSF1Jo&zusFfzT9 zKl?3_ZO08iRC7Flu!k}SeEz%NF(nT^Ir>JQbJnC-^k&MuFO7*K9m7XRv_#Y8SH9-Q z65{kk<94EcR3G0%u*Ytq)3gKOJ0R0rB7egHHKc!Q$BU=)ptyW`me02x!$aomb2-bh zQG*=4u+Dm@x@9r-{&0lsd02Hm!lYNi)lFp?B!n9y#ta6d{-hCZLyIggSlyPl)K;R( zgkam9QfWRr`B*FkJuTt*7g;G!^~c z@Teu@ZHTns%wp<~2P{w9W0d>g5x#?3*uP~?I#oxI>%=D^>aJqR6oRrKRTgeXM5iI4 zRzgQ*Od*Z#0S!l*cI$>mLl;hkO2XW=(0ZzJ;N}6 z#G_pM?LwctTTp5RzKM=(1r5vTP4Fc@0S3x*JXyROZBYOeppS8ww)W$MQ^)q9EB{VyT6)ZReF zjCb8_;)g9xrY%Y9?7IqY_iZ>%q%B*FC(}Ds3EO@;OKPGIneHvA&FhmaP9L$lAZEHz znrz9y91R2wK{y;W1GC3$p>`y$G+Ph>>{MrptnS6Q{bSniO$HOhi9b^OKGFO%G}Mhl zR95_W%|$nMCr)Z$plfCpUrX(C&h_^#q(`s(iO*K`ZJj$Yp=(gF)^7!7xJ4a^k#oa) z{oL){E1qRV{$+u_{g?4|<)v1ebZ}VVe)}z1@a>!2=4Y5OK7RuJW=X%1t*S5}B|_;l zRm0iI=3`Y*UqneRe!sa8vEn;t@H>2{OUD3OFzP{!V}&y?^7Su)AmvH%%!7$k{$QZMeU#t!4f&Mb+zTlJnJf z!1Vi;pb>OA?sZaQrXbylANF!vcf#tjzs>sP!{1|iu$~L0d4s0ZarPVZ*In-n)g1Vin~qd$}+*W6z+|5?dN z7)<|p+~?`#6q{AxZ2(0ljy8%YvVPB27UYO5xtY518kwXFazS=h>*9WTUEn{na+ZEi zoNMOoG*#wy*)OcS!1E@tr1wM)+8U}YzvCQh*`^>U_(Jxx!dvwI@I_XT*#nwtMx$6lnYnF)tSt1(>#n z*-N4}hxp4X&E-P)>?e!tI#A;rfrLeO`I=q5r~WT(*l{>LzCD&_!6pq^UhAfzNFq~4 zgu816z~1`?I0v~6&7%vW0A9+Xp}va?`l6 z0K_M-c!d+E@Q%Oh<1anm;av66rW((T03BuBmS zL?k|g_skyyv6(c(MTxBN@~@LhsGcK7MTL zqmyVA==;+&fg3HE3zW)5ELid7E7W)W+&HPSa$X}^H)Yy(;2OB`%!bE7~|6@SFP1JR+L>i>um7YgeEJAgtz4g zXVmQ;?NkhD)?=xxpjcGSkhBKw1-XM+w2*u1SNS5(a>~DYz>U1F6M6gikWj|P7S~Kh ztN*N;6vt24{*S}w1TuniNZmnqA+5x{8u(kmdrG!f|S&ct1u z&HS^5!AAEh8+26=@fN{_SAHatnCGMht8W(%3DQu``U0=qd3!9imdGt`nnc?3rG7u= z)elxJX06o_^F~!Vxu7jwn2BUtsdv|q&>LlCw`qU(YCSE*x6hJo1jtDM)Nr$Ya(6q6 zl6Ux4QV?$V9oVUq%P=Ui(kX!78`nCS={w&7H>xiio=MKdP@X5nem~Xs{yrf7ihk=; zT<~gL2UN6e&3i2l+_QHQj(PlA{^grEg57!_;M?cThu*@2suEq0&*6!^$C+qd7u&x^ z%DTX2>2GUz@W|=U4d9=JMSos#S`%vcC*c7_>FLP4;nu+RIg@W4EOaKDnBpnwC}L9q z+Ej75Rqwx)R!wO+41tL4XX#~a5!hQZf}os#K{Ibuj@3@ix3>f+i@%S8q)}*UpI3jW zeWhiG0mPKBszE1A|MJ8}%hv(zlpSV5{n{Lwo~pI6qlz;278U*Jdi&1P-c#(oNX$n< zPhDXLfyJy*h`}_@h?Q)VPS_q_N)d;Ul_n;Wng^-0z)L9UpZJ^MTr(+NsE^u<*VhGS z4GMaTUW*sZ=tQR{Uv)t?A}I4LjexTIo=-M(`z}=U(*EMc{h8u;+jY z&%^$~?Hl-leg|Eg&U9@+4yTe~$vYg&4ZC{BHHMR`8IifZ)1M{UIB=cyuf#;4sr@4? zWY6I$75!g6PB?$hEn1GtBNh%ym$FS9}^|B+NwpdV&&(&5CG*Mp|p5I^S`>ZU*3N{fqj$fsDCD} z3@1g3u*2mZBO|I~K+e=k-=c%B?Ek599!&OFrfG?|y2bXNAe?6b`<2BiU#5w$5&VzR>3PJ^~ZTNqrF#zz5ec=a??5=+!?o`V9JaMg>&P-Bi;oy#jjnoKE}i>ni)>58}t zmGuJ(F?abQxpHlGDdxK>f1P#PvUJzsg|Kt7P!}b}Iiv-)%DMqy&58A46qBaBf-tQ^ z$klqGpOs)0g7ePbwW!$NyaUqUfn!CuF=la}twrn@(^hbNuln}cYsscFZ?+NE(#odj zPre`OMldWRO&798z6Uxhop8NnCIG!Z2!$UAFwz$EOM5+yDOjJ4Q*S!E|34StH1}=z z7Z(KeN2dj?$-m`lE5+^}0j-S1z2$lgeW%>G=8xvZCEeeGlx#ESV5Hr1ylpw4L?bYxO7 z$@>CsRBy&^8Z%fLes0ME#CfTeh2OL;=2M?bgoNF~dtk?)^Rc&eh=AwBbZc$2+ME6% zOZR-H1xbPJ9L*sEV8;I@HSFj#6+SHB%4$ArAA;5AP$9CB;(3lem zl(_L4J8~!uK^okwBKqUT`qcgT7=G0}{E8e@Ezku!lt1rTnJH2&rw*hhTD@Z=H{dge z0$7m&q&BMPVYRj>(IrnOULWZM93muP!qLa3pQK=AoBR(R+pP@`H76ehvu`F6g_En4 zw8>$#U1@-ZqIZB6g4nH1y}tdZ1kVHuEqc(0D9uz% z(bt7Qlz{4XeZlc}+wnXxiD;%lY$go@{5c$>41kNZ)PAoQvE9{O_i85plBQ@gRw|v+ zKs0GBE2e${RoYfB55Ii&-OUjs>9LIX{`SM+^`1+@iMAd)0DWxz*$}wJiWiiXwCnZo zRPHJFjztRv>xVI)FQuH9NrGtUqwgpDYwy9~_SKgp@5PJAdVFBNF#7Qs;f(?H2 zkvraA+n_p|Jwtc)gKT1g+@o75h7$6=#7SjubC0^usk^9 z6K?$9_IMKUm5PiS1Pd>8`f4$t!7(YM*D){(0#x76>j$3(g<3H!G! z0%9cRIeshu5TLrckuV$$+!}ha>6dxYUs&)vFTQ?gMfLg6&raEsp1TZcjtoS^3up*V z%uQvvB|}_Nr{&`n{LAaBwR=gK{j!>g42X7l{lx+pxVp*$Tb?n7ZOE@YM&aQ`chZ!N z!kv|F=G)}@2>QYf)keHgOEm+SJGswD-hgnkPjU;Fy|R$N?LRlr`$ zhaE)^D=*m}-phwsyP^Wb7+`P~7Ath&%nS3ms?iWT>%#Uc?oXh)%R3^Ny$}D>&+w2> z3ibJx{H6oPPgeMCkVw;PkdcpuJecvw(UhH-WXC`-y8B;uc9Gi%un_Yokqlw0e0KJ) z);reF)NIsgC%f`XA3qJkhXRI?7xZS#N}FT2q$D{1kQ?lun4mjYap?JKXr!DN9nCNh zjc4`aUIjZxx{9EUa%<2%od8y$&GdhFSlebjeaD!aMGqQrB8?*a71TiqI#m4GZ1^n9 zqwM07P49&DhjXm60y&>$&X}8Fr9l}~a!THsA3+lcOM8LzlKu*Bi{6{F>-pq9FEd_w z1&qWXXXKDCz!wO3+(&CaMBAlA_oK073q-#B@k6ioEMQ$hL#MzdDCJd39)d(9m9>CL06p(U)EPoudznk%(Ve4G)Fk9`U0_~8&ih1!^r~Bh@mCI+>y^*O_P(S zOwvUsXdp&pb(X~xAB5imA%uMMUXULuava&ysbHz{37Yiny9BC?+Q_XWcK zeoyZi32(6Lao0X1k_`P^)#QUyTloUMXECJY@6g|qNF4XI>n`Y0tJ5IBN>b7=BKKDB zcp;gTQ~5l)($^$ls!|UKQbM3PO06NF@`v}W6Q_+n4%&QX+BU$`)b@EIXIQ>!aUB~Kw&g%!-VaGcwB#o^ zC5*j_#4+)%a94(FbJ?XYNo3L(b`Wpx{;K5+EHN3`p)PulV2r>f8x-vm=-U;Ox!lkJ zxRqYl{~<>dxn<8O6ja$H9F|OB_!NR}bQrxC0Z*~~YXJ@W&eSAaFH5yiF#Xb#A2TDu zKy79g&`RwXaHSyz0b+gOIn7Dy^kd9^tq_TDZ@MFCJ@tv~>15y4sx{%L00P{mKQQ7{ zDQp77>Y!vRe9Fi8vvpTdOXGi@*VkZSmZ-H`ry@fmw#JL;nYRuH%i0D@!f~vNv8ga^;V$H%@M1|~Ik5H^E}!G$ z_>JECtsjs(?FTJN z8KCdcU}JmnxAT!7QCXY&Eph*9fatTxHX+!Fwzw7BSyUyOOquE|S(8YJSe0p!fl-Vl zN3{{BI1GhiwHOa*eT7sd{n^t$f*x8O&|(D+3z1_st~j=2#m#0QpjtBXH>hm+BlqMV z@zh>t$O!c9&9!aL>Xqg(?n%Wbi<|0;z#5F{l$2ypamYvvh_WM_b188AK>RZQR6_S? z%^|ry;38|)0`NkG(fMY?O>VTP9}$z@mnd|+Ga82F)mX~)u;E4-g=pnfQAmnz)mZ3K z^e5xM;Ftz)AtCvzY*C`=XRr?Z)HIen^_a-0Sq58mPQ2Ld-$7br5Dd29nnEcru#cw!`mINI<*Y5lD868J9 z=z%h`-05Q}8okNKRCJ+1bRK1aLVM_n#WkVXaKijsRR%>IqGx$Pkg1-G;g$;&1*65w+IB^d3!V% zy6(~S6b=Lnr^Y!UNiu46iLQu8SjHnlPc7&tScx=}mT~fZ{m4!IrU`l{_I`@!?Qw$; zt|3W}o4Ta=(KkhH5o*l*KW_6-Y-qJ2`dDdg-|w~57Yb$dtkpIBvy@Gz!BAFVpIKWm z_O9l)XeRWZTrfck00cjSp?9C6gNLK%1br~Yy9$U}3)YnY;wn$R6sY}0iQtcGyx-wx zv&s`D-qoaI%T)}7<9;?aHU=l0y-~$f$WG}+y}d}O`A8U90oOdC&)xkFpS{1JRWu{i zB|my5;DYJkW4YPpN)se)5I(yjzDpqmGm;D zvar(Z9&GV;cQ=}poZ=nujr&?MuyKirzXG@m zzH^Krl!>5=3{B64ttDf!GA0aA_C#{JY(mJ(Qa)lFgO4zBBpF$ZFTM%VJ-qMX(PMLA zA2%UbqMkW_$iXdl_L10Cu4%4O#$6*{Si4AZbxQis6n*>1$@5SM3{o;kb&xf}(k8of zCIZM5DJfc1ZcK4&mmSr&r`Qu110!<{0>gEBk5^rnlnDlmb4_ZdC^fJKKefi~cb?Wlu zjc_d&QCe)+P~mH_Vqr?)&E;ZEQlT56wR-2?{b~^=JPMwD*zGjbCg;#6)jZ74+%kxZ zH{hUOmkx+*|}MH5?wML z6pB#OW&U&rFq3@cV9SE%F|m;(T4zpgw2ys_WxcBKapSX?=c&^AFS*DxlLkY?*%*AN z`>(5ujVK!p6P*`=60(ch1W=jqH%P4gG90tDm|@FFS?pMXvQnnr)eXiW`NqO`{5TN`?opnQRImQ4lY z`K3Q7*{YZbQsOF%yiKZK2iW3TfkYj-XkGW&J+*)44( z#>!m6ZTT>FtS}Eg@{s-a`E3p+^23>q;%W-b+ua|yhC?uS9&a64o5iEUd?}QH&9E-0 zJ^vEBOJk0fpRgTxQLOt{UI$Nki;_16lofoTL*AfzIJ{Avt z$T!sJF*D<5bq;lXiwAIapcy;AyDOQAG6;TE{-nLjX(2*A)n<&|Zs|4T?Ba@3Xyjk%0K+7>ZA= zE|2WPbGfQ5GY@(MXlB+s8--@g9>DqTwsxxa5_suhD3*6QMy1a1Nb$4O=Ho4>S071+ z-S_8KbKQJ+9ltT2f<#D^^9XVK1Smz%O$Dm5%h~_tT>a+MFycqUNNK63cE;?tW44c( zn>^5u!Nnz@$-g7K6Kl&7@%zTxxe_?dd)=UiaptEqSjh3Kn>9KRhT{`HiDO(!D*oVA ztq8mT^@o#g{ETUMr|#E+TIky%HYhaNiXiMv)tOu?lgBfjuW3(XZ>tz@iajFyl-a0s zn~Z5rsSi}57TdZJ#ym^;ui82%^CU;aXGVsxrqPh@$MFx$bVbl6LbJIj@1y*k_?%+H z$n_&+zs51}e_YV^Eurh*_)8^p3v(%y2gXy*o|sa{d|gr;whfd@EsfZXnYGp1rl0a* zm-m=&tA5DA)5RG?>TNhndpGYjcs`wxBofpe&=ONL;yFLdp7>N#^^+6-t-VN#!m3MQ zu&P2h=FqMUbyCi5wQ%0X1A) zKl4&DUd3N<>^pO%hFFYoi;%yZukYu-R*u0{U55OhPa!1(Os( z!|`6xUD&cCdGWxB@&0`BdMr%tB#f?a&@voFsAkYgmZfmm?{jS`NCIK+*Cnn{P4J{( zaxR_FiBB-GJK6uU8h?yjpySh-qqJ=3gB#R4PD((r_7&Vt+YdJ>>-W3QIxk5Qw~!$X zS7r%mktv;lGXW36I8~CXYo{kjSD49xNAEdj2&jMn2@tES>jBq4xxYO^QgLVaLiJ?_KVjbjHaZdy1^+e(*Cj4is$fjM%gr9E|b^Q(?#o%#zA!) z)on$NHtuK-QreWj&1P60uAKVGcggXUS&MsAYpjvFMX`<^R^*SEu9a!s#g(9QK-3T< zgVeCOn9s*lu<}^W1(rOP8@9PDXod5(M@Pa{wf47BGNH)lFwRfLO-CHn@!A5WS?)J)P-+LkZe-Qz&E1E@ z)DV43Ap&3a$SBSQn-cX(0U_DMvP`cOEp6taF&coa$3&6HL`O)8?gKvF*^QC}aR6U- zI>qAiZgCVD%mgk0YmPr&!H?JTh5A&pvlq>d7jIcNPGa~x?43k}%4mp-2OpFwtSx(dJumw_ZjFg%u3%l54yji|^BumIbB9Q8a?^S|#zF{3YK^X;>KOl{tXzUbsT3w66@ z2`}3|6Z^zcS&!LJdh-REyQtt0m#iDtToAI#!`OwcV4cxw=8NLKKVJ4kRZX)ZsR-js zdr8J`3MAm8*kB2g^PPxsyz`pb$NhIkI&E&<9SFMnEm|V4iDId2o3kNo zgb$_lDcJ7>UZnKfWcp8i`_q$;(j-)(ryv{V zN{HM+zRJra(SoTHgG*au1;bN0wlL@KPx?LnChb!ZG{)kB^{xyqs38_Wibk!KP-aU@ zkt>U(p&75N*V3ENzlBN?ZrY+0lSOgAk?P+oh+|{qZG}v1$@cFmxoSVT*@XugvSFba zmHPK|y^Zv7D(&?=RqwftQ|xKpfrf{kNoivtHH_*p-W|D<9i^ko7Oy*_wqcDgiTaII z))W+>Zv1MbnE9U3h(>OCgyE-F;T>?6sWr+H6vY=6{?kt>E!S+%j(F?GQ2A?ly|#Q` zQ!Dp#*&+c4rGgqFmRaoQpYL@%{$ltja5_4Z6@8g3{vF7t_0o_bLBE*{>}0j(eJ=p4 zv2&UNv!yLjB?=5YEoXj1I|vMtv7(UU-Wva?+}S91CHd1wOi72XQMy^xa_lY-57*Ds z^I~r@rED|jD}G}@_2x%0t00)(AM$4pX+&V{j%iO#?L-^5I%}~BPd9QshLpS!zi&wR zIE3>}aGCq?mbz8_ZH%>J^JH#`gpkMg0gbZjll(!6@5Z9loOe z8$XiQ(ieLD7cb^tOO|6tfv=X4lR4_5A5B{}C*(rE95*G*;fj=;vO1XWd5rIg@bclL z=Tf0016Ze7-7$8EiV8d1h5lCoS<}yzrPcKuBR}KLzIsmazzvL=GP$KfIYeXjuG#Z6 z^VD26P_Bw}IzjZb>h%0xSo!YH{vK_k9>R{E>G`*Ls_HveP!vPb_i0}sq|oR1 zc>fz97GPvs>tbbn2D|YXiRD9xk@a`SW87#Dn0Qb^(fVyCLgJr{jEssH+xb0=zs0X! zlMK>6f2Mx6ow}=LbY|lrhdc zxxL2FX8LnZUFuOu*bO=l4@f(q?uncriI>dP_lcS z?h%CBW)ZBRi{c5QZIZ}NwY*9+x77#7p_8L$dpAo9qHgf07aoQSM!sgbNx}AW#7FuW z2-ba0WQL%_h4q|Pf_4ra5B(B?Q}yc?qebIMSXG%+JNkX(A40J!#=OU?*%V*MvMiXs z@)Nx4+VSHzq-(ANSdfotU$2r{OGty$Q0uj5m-{tIr9WsgGrcAF{G2t=j7-Td`%9F9 z!9^f@>WHYW2)%1;rAi;LY)H=G6P)eER-dUf5OvCkDxRE0`IvRc!WS{>i+j31%|(FxeQw7oS<)jO=j1l=uVi zuV6P`BD-P)6FSpx88v!dT28?ZN6<%uT(<9jB$eDG8#Q88#R}+D={b5FwPf?=FAckT z-GylSeB!}*Ml8t8h=(d_K>ow)d!pHQp>b3oVmA&h<9LG0zwu&LZ0D#cUu1Xl*;L-h1)?)uW{QvR*-Z`T2WLZImWe zh${q(wfcUoKen^#1%@UbaT(!we2Z80qR~hd#znf@qrh*|Qf)BN3+C1DW0rixTe#E6 zapw^s{=JFYvo^H;xLgTds5;K38@4D4l1r?*YiNauf~}H7*|QNxf9~mvBiG!wpvPxi z-wpqEoq{C|<}x(x@IBFjrMYD$>Aq`e@v2slyokF!=pdlLCP%$UTVUJn{D6wADhkTM zaZr;82*XQ+{<7=)lHa*nHFZgugL79X5j^Ox%m7&w=6el!r4ZE}eqIP>JU(8rJuSIA zt@*?*AR_?M@)|6}eI~XDhuK4Th(g=R@zMIVN^G#1D zu%>hU1|j6H2!!gXpH9)*=Nsw9u%X7jP*c!zVUO1{JY3PrS^Pnq97_*sbGb8><|jj} zthjfaGYIgjYE)U)m<6Fydj;mR)S5*~&Y^t`{ow@ew+Qk!ziTJ=xHZcX)@fBvs4lA0Pa&AnpMF=rce~xF&0o#CCmmD|)g`ySsf|E5p zh%A8Zk?z)ub{IyV1}J9+VsKv&g^e1YPT_NEWxNhEx5Sb7GC&PTjB>;_7G*Y=O_XNM zXeDD^T)qL(NW;mm5gGxgA5iiGB%_J$bMbX6mHeicoC?>|4(KB zm72u%xng_@*oqYVhE?LIFS?l)@th%1GN)=&n!|N zV%m&6ii=v+LB`=mH&0CpC6gh+Rkob8n09wIUfQL zX}nw>6fkalFk8`&vEuso@-GdgDe)*_jcfRdQNomYS!*YE*>X22)iq~-ufEyu!dEc+ zU!v|rH|6-q1W&cGlYRL$s($JeUruuyGWpkk8sAe2Hv9^wyz&Uw2Q3~S$ZB}hZ1;AE7#vB+cp|_27Qw2|6fhY(wG(Xc4hr=Ns+Oj+KG=00BeB? zzm$hY-b5z;cdfVnhhbfYYfB^eS_gP(y_KG=Fnk#1|_7=Z^h7Ay!<9gHM*_gp4L z1rW*L#~DB}jb4fU5!HIpz5PmTq>0CXmye9^{lrVh74Mk<6PkH}5AczU5b$cC3c8j+ zE_w3nq#E0w3$kw}kM-v=rtAqQi;UA&?~BK6nbk;WF*zOYYAdM~f9q=v&75%D-UZTH z&{R+7w~bQaS#ZF+ey2ARssPJ5TcDBP&!!MoRr1}pz$eQ$mqq-%3IRO@`wYq-{A}*z zTo2z>wcHh&V1f2hBH*`=u&4srJIhG;LknJN5aR|}y3@rx6t{7Vc($Ti64sVgRSc6C z-oTCxL`9i)e9SD}Z)bw2!+|AF$l9uN;;S~5_P*vTreZhsjZZl|Y{LEe3+K7Ztv(=Q z35Ohvt@{_0>D1{;FnkY;!4>blFks7#+7w%=!|kqdCeH%WE?a?3p}1pokRuM(JD2PK zx%nq3oGwM&E38dwi^A}hJRpf%p1WU%tEQ~9Dn+LWZ+3vN9^(q*J^3)Y|gFsjoEKJdn5ZuJ>M3Szhcj2pu~i`rRJAH1^2Gp-98)?P4_LRdtjLN1n96pl*)p zE5Cr|FY4%k_N9aNhn?da1}%D~ulyvUes>ZV2)56RMTbnZU0w1o$?y>=s8{Hn9alfQ7yMI%^x;!mg+#whXl<;TKD1(v77KT|>rQmsBwX#C0ebXgaEmno6^ipk@%q;xB!w`$2l=W1hZI ztv{m~oVyY#xuxsSQ@LVquP!qQzlsO{s`ZU_iD_--I#Vky!3Mx$gXW z(bp~inNr0ql@DLVHmT!2ayapl57?p7@cnFgFPb*A$#Tgp0Z$hz{#pk>(hk!llj9sj z$RRWqXd#tKO=+(xBklBW)u;TX?XfU1%LocKVl!;r zRB99Wul;GAdQ*E-T3xi9mp4u5Q=hjSoW2z-h(;FyE)v-7i@KG(0K@Ipu2BD@7L3)? z*-W2Z!yTrIJ+e_I2@u_s3SmR{qmPFWgZbBlpoyzIKhbt~gAbWtWik^?dxO|UEAtnI z^YLH32k2}_D8lJNZht{IBEd`$5g2{jz=)Tv$>2eq+^9bzaquH$$M6+wv}e*T4VBfZP~+<3ymyh;EXQ5Oi+QH+Okq+O=4d?t2$6_5F!C^zY! zM0qB5K}CPdZO57ls->?tE`N(AlWvNAZ!mNC#UE0@3P3>K#2mvUG6?*%&*pKzs8MW( z!G`@&K^dgp-(zu8YvYB9OO~5xwh|fMT`?ShRsIH>RnwtaxznIOk8^5McpA-5o%3ff zu0ElPk^%2;kx%{lLUFHz;sP!i2P-`2eh7z1dENiv02XpybT~X+Hp;pJk{`f^I#Mjo zNYDg%#uSG{_&HduOxD3XCddpoHaNnAy*)0V6OwB~ZrlRa+%K@uWB=+0a?S62d20rT z-|75qek7)LC%{aQ%Cxl^yB_n`5epIXh_d|4)!=9Ew1CyrH?4Vv`^$1FVizi!iaHp~ z4{g4{qv*Px26hWgC#9hPvbKdVSw)Y%oJKM zlPM9(;?eABnmv9?i7&5)HZeLIoNBoyeI$dOYQ#`-1m6qxhil;U&0vJD9 zIoiTTIUHKF;OA9(Umx{|X zOY>lLMy5@H)`@w@N0ECjS&ZAKuob&|I1xN$%GCNu6uI4`xgioX(K&j!Lmh< z8I+k(>MvaU3^d7p?~DKpVcpjOH8dtMb32#C*ykM*sf(46ZmpEi1#h78@! z3jfXxShk)#h$YI-H6r__$3VSc?RY?|_y#+hw2Y6fq;cq8M`d>_pHKa z=>aC)JD$aaRXuGcFd}rmzz>WPQUqFkWDwx}j!Q-+ z)R@Dww1NNikMR9zOI2d4N?&rmR6xLmzyGhPFdlML=Kr%QS%5Ftp=q-pvn{k<-kO zBOoVC`s&K#n@o(3xe*=Aqwitp@8RJf^{!NwkhV&Ev*5uo5CACNN2~ao!&j^5Zf5Bc zAF(|=bf35WoFP?up+UPAFIPA)=KF0HP@`cENfE z3*W|@VlzrNCX>({rn0@Jl5ULG1Q>U|)ntkmQ>QhFd<~_?YO8db5h2*q#2hIgEX{^A z)Hf_PB$`;rK>)8wDtZPEYB;4B4;C{zO|{@)R7}1}*hNT{5u8`6E-3j|xU~bA1a&9B z;7v-TxHLS`HbA}+z=b`;x_Ud7T>W(iNSjjpn6lJpDdAKOgtXnSCS_DGC0JA%!^ymQ z0D&I?a1<;fbaVxt#Vfpfn(8NERfi@(_%tPWNFu0dHaxh(7Y;~2l_bc%=f~>szEnF|aM4)~McmWY zsaBQ8yLX6OkCK;wZPOwqKp?u6Fe1k5Uj$S-Qh>WaTk$~Engt!~xaW%ddTBZwA9Otd z7!z)q1jSoZa15#AV|B$7XqgFG*6*TX{U1$N!4_rLb%*YfZUK=LhVCw<5tMG}X6Wva zR1k&+k#6a3h8ViL2kGwm=6SE{`v>=Z_Sx&~v(DOk+4;#cxq*G#ZkoTnq=(;)(gvJj zDiOd|tg_jDXDQtdIX+#)yzaIY)(L{EmYPr-4Lxejy(3sF_bnOm`!;wRJL?bQG6`;f zL#rJiISR+GE}m;Hu0&RAuU~G%vPR2(eI@v`^DWH2T1c6Q9u4D%@?Vwep+#g!t^Y#g zI6`LJXj-kms$dWT-H+~f878rV^yn59{HLn8tJg0Y&8t2 zKG{A8EC=~I94z1wq|$YwaI!$0PHhYE1S))SWo$>oV+X<0pktTG?&a-^ev!>sB#-_O zLr-aakYcwg;rgxaUeLw*RP5;pfQNqkwC#pJa%)G@|DZ07TkTr9y-M4wRgLQ4T#K?H zgGa_lq`0KkvF3!%Dk3`WJ2R@_^vG`1;59La2;~fU zcr)g$Z?z0k82rZIpYa$+(?rqex#Krr|30$bMpHx}+wsM>XmNTIKi8l#SBsnS!w*MM z5}vw4dAQCD$6I+G5k!Z@p01u;{ye>`qrLDZ-HIcJ^hd`HL1$kFOSCH0eg5SEcRLdH zfzp`7V$j2B&Jz}go@;;%uyZ@Xb7RE#C1hpph=2P$l6K$z@X232(L8DmR zYehp9C5vtfp^^(c4x#pZCa6#$0rx6IkboJPf$O5E0zC!z3r+3}l@iC?Y=VR`xF6$U zt}s3|@NPC3zofbwr!S@YI54s}=>7cp*m1p=UL~Rg^1aV=>h8@pIQpfRt#EdPBm zgwO?=ErIpu=O#f_fAsFCZ5c6OaVYp9zV&1fpbYKe2rBfyrZ`*-T1m_Q8*dQ0q-v$7a-lfJ(P?FvmlBDgt zQ^l%va(i(fnFgNv6iT7WK5zS?P~Y{gHlfSz;uF8V-m{ser+RmzksL1$k1^B^?#Cd0UogNL%+ z23^096A&VWu76N3boprE_z4#&%M9MfCjz1Ud~tlSNF*39&r1@<#Y@ouvKeE&+Wy#O z8fzjdM5xVsYe%#9GSpkDZ%3EJrU|^M0BM~*@a&EDqIyiW^~7AhO6Ai@T`x~tB$yiO z=d^utpmCl>tLkb~J2kp=4{v+Al5pw5h;csut0sVaxg6jrl0w}oE8os@g9Oh0H(*Tb zjY#c#yFh58F8}nkZ8axJb4i}tyWGnPI~>*Y1=9NZjhg3nlR*h&6n~A~6MoG!wjHMy$Uzh1OyRTC>-ko<$>^0ci;pfmeZMpiA!MXAkME<<|y zIv#%Ou=={@!r==Q9ewLu(9&K22}}G*iYnmgT=1oir+U3x!345;BkjAVRRTn`M@M>S zS4N!KJFRAG#ITm;4eFhlDH!-LHp%DyJGWe9IJ$1G?V03p7ukgh!CiV{Wsb%u3P2#~ zY0kx0m5&N1U|#3MZ+gk_v^xt}1~JNUku`?Mtdz5!Rrwi%SVUCOVPO&mq0jmhQ)3zW zdXjZqeqz?x_1&526z2Hgt(S<020h;S;?Z3S{So$V28mb3kP~Oj(VKKp+{<78;a(%RE{mQB!ptb!qJgo+Q|_ESjWOEp)E0mQ zi524UlGBP5T6TU@0L*uO{ z{R5La%Tv-KC#yo7UqlE8PvQxE={DV<7(Q;@>n^K1!t`a&_vCN-BHSPFW5voQ(6dai zt75%{Ks(2aPLUs61PA4#EZ7EV=gTj5;}nu|sc&X|yN7idKRI{KYS}s|1H9oGu%Gd(o}!1RjVdj+0W z29WpchZ`zf|8ui@%{UZ@%-l4SefB_r+FH6SE;bhyR#g=^&TPLXT2`LEI+s^?d}vob z+nT58`QJv1%Wlkt3{8b&1p^ zF)Wfb3TcK(YDEx0?=rHEx{(sZ1#Q$he<>}jG@@AONxb_nuRPa$Q{6@Nx-vr)d0J;C zq8+>m-yb$QcKuQk7b^j(@iMs_o(4J|yCqxq3-3_@3KRM9l~kP`@72_Y=4j#_0}9?8 zd>rw7dxlS<$atAWM*$7DJ`Uqkfwwm?lhvYp3Bi1m;aUj2=v%-mg`S!f@Q>dX3~&_H z-D970oSLtSoPv*+-^G`_s!995j4fv@@hhveFNt1%RA`oLJ#=PRA53gcw*46O5^DIZ z+;i2XyH{E=f$1~a91;ldZ?$f$T)kTQR?LuR9!sl>16x2Q2@f&!vvP)b#;U%v*d;5_ zDslGqkr}(KXrS;A*+)U!Q>A9nG}OEA`PykeX4j<>GZ=Jt2b>+jN~u|q2*TgF(&ZvZ)Hf)6Fla=3k2vN~_uvoWJV|0Y zFaMsc^(PDi*LYb{NB&X&!wRRWkb|8xi@ms>t`ejR(VM8^GaRYf?{+%EkuIR8=shuP z2=?y8$5qH9z1iQ|INWDY{qZ+z)}Q_syBKrFhoWaQC9W)TUCCd0bq_!^y&%gJoOYM?sbi~_>+#x-e-JLP zRzFRv&tf&w7|^4Z9o3wt-jyX1`fegC#FvmI*tO)T&G6anu?>nNr}>vrhk3bI zsH^cccBwR6?hGW1#z%31o?n=+xn`VT3X+DiSlthC?UQ59Q&6NU<$W{Bd2xCizV}Yj zUi9hBgr=(HXs|6$+w$zL70K7t_NLoo34kj$^^#}Z!VT@hH64}5Awq|Q{(bWD8gH{#ZqI;U1Scr^fWPp>_eaV?J2^sn6Tz)08}bS|K*I~ zh?fl;g!xwGa*l~X?#RkJjWvCv*i3rRql@x`X=dNMOlD-@s9)I)$5RN`ib_L(BB z&@o^>6#DP2ry*&j%!Y87zN&6=v%q|LZ%o%&PV9anaycS!%^hdXR zNH&|ba~e8yP*TqkH;-Q_3SFFC+T9R!w{a=zDT>ZIedA7z*7K_3-RZR0#GzHhEhR%V zv#JB0HN_E|6&=t1oASpgULr0IxAu4m>06gDQKwjLNe`k(O`LWzkl;rpHFgvQs2dX6 z4A$TGB_lt;>uw<_Zme^^*s;~O4sQ>eyjAe0)#tAaKMgM`(*U#mZf{SK+nUbWlnf3* z`(q{v!Uj(xHelQ4@|Zj-qe8D8T6hsJJ3AX`5`-BODHtF%F-T4U_fB_v3zTnQ+n?$g z#KmuAk6tsT-=iF8zx=DcJ1R*v50walXOL-07O93TxrG;Veu(QwB~t0S=4B2`#-gqG z$5ZLUo_}xS`B}7C$*9PAzpj*i`7eV`bOQwRG#hjfh`jZ7U>~Vr?Bg0AjpkcvQmJSW zF0q3(?Xh9&PusUHcj7VSt!ab?cP|+qdngES;YGwf=Ubk{N+B#mIlS8K(n~4~5Zz~< z8x0Kb{-WchUm|ROPgSis1(xu4h z{2Qa9KKLE(D0j1)AWW|i9~$nwTf_oAz@IR8EN7!9PD!S9^on>u?FA|T=KgZHxaS;6~PbkpzG*Yy+7vglcHgL$M6 zr@nt2>#kjYVu)aaQJE@@*(#o<8;(JOJ4M<}i>Kd*R913)TchY&{x$mVI+E*O(T_r* z9UB6aPU(FrB**wffs41wSoZ{-4z95HRej|@DdpT$%YpA{*k^!tINwI9-q(Ord^-A5 zgZuxr0CkssG)rG})ntpc4K*Y4*-IlVzND+(r{?37lpge?sI*T&Ao->oVLfpWnK;RX z9S+eIhfg{t@fDm3y(>X{$|_=J%7#xciR4RE6d%jcH{??FaMuG9+ykUVaj#v)KQKKN zO(z?NDoWVFa$&(E*%9S8F;SX3xw-I^oZuHa?42IXS-m%wjH<^6z!Wcw{o;iD0tsE9 z03whV{SwUp6$E%o-1TW5Ew@Hn-etV%RkOfwe$liUZYx%ECZI$a;gd~rb``3&m0ngg z5aCKIZ%v}BCmEljo=dECm&}*o1Lcb6EU1-Ih#h@#R;JU`!-^|XaK^QM!zOn%a< z5c2n#T|dvTv&#YD0N7pbEW~qr$4Qsk^7%=-Sl$iqh8)aiJ>L zTej=+gW#eqUn|Qg=(D*M!|x_@T7=BZW|g5{(C|aS^4=~HjLL1ei?+%c5&>5uO0inb zXklGTU%58H!7oXnE)Dg3|6il@5EPeLuhx%4lS}`u2Ih6Y^R=NS3p#H`>No(z#AbY@ zzajF2k&2TqW=(NX4iC%^5F@riERzKfG~L{kak^JX5XNY}e~HW48)#}a47ENBjXExA zVBv1}F{v~Xy`)1c7%T*_`y&gJq>J7TXE5KF_ZT>6gRt>=zM-4u8O)Mp--S(Qv4a(| zG})jz{!U^vQ7m9A7jC#cwpnYbeX|`>z~fBC*U>hDu0Z!&w(7IS5sDC>4xO%amBZ@& zeZIS!UE_hdi`-0KBYAiSGv4jrhJjWVMNQABkv&(Q;_;8F{kNyB)FtgQJlX(2_Nghm z$Q%%QYFM*Unx+Xr0Xj_mxMzqEXsxINg;T+8lBJW`rOa3C&4Heq+YKTCLH#i)dbg?S z(Lq8n$X1j@I_s@8#uBes?z&Ncw;6Gp$EFq*B_$e#g)%l=|ITq$knsMHS_I7ZyO8^> z2F;GUP_?a8#fx~gl6hoHpgDXPjXK}wxi`~=v86>ZjLE1S$^=y&4yzeUPYg2ur9#WqQUz+F;RzYN2h-qygbd(c>HK z^1TKSt!p5#tjEC5x)0n!uAxdKg%8Umnzn?NupnlxSOyCfN80;f_qmkgR}_{sdb*8V zQ3N;pkwu5xn*?&QTHIVjsiFd8^gD0!m|W%$ZT`ey!&=o`s@IP!?bi{40HZFsh;PXg zMo2k+M4{DPy@msgTWM|~y+G0}?1yWeEv-Tl9l) zGlav&a)p~_si(WGs{AV6D0)Tc%-CM8HgA$IIWdNNVFD7qrDu@Lv|OfORBwOzH@uGa zrw05Pv2_{YR2y{Ii1tck!+Q~Ei~$eR1?{CJsdJqnm;T`9Q-VKLemg^+KVk5F z;MzG7yIvi%r4t#?dxT<-!@w<(gbh0HxEO>L|NM@%`N8LB4K@Oc@V^hd@TgT(l)LH+ zLoKpng0D$JDDDJdwTfJQxUoqy!sL z06{5qSgyFd0_uJ5AY_0*%(60}L;wVOlrItim@SA|CH=mqy1agZ>~N>gB3u*TpXlU=j0Y6p*Qqb2PP+yG+NJ>c|LgS{d3Oa zO+9^v^7ck1{!9$dQRYJ^VJT*` zj$Nrlsh>12PyK#hEpHTBm~HErMFcJ*{b^=mmt%^{5LQ)QxVsnXdlZ`@h!5)5)yt9! z_dDLVG%r08C2RjzZ6y->gc{hH0}OOrm0!tW{u17d|1(IYCtY#o%&VMmNPaBz4xt+XWZ?4tz6lJvad<2Qgk#2quL+ zW%eb$b@`LnHzd|6J5E!Z$OfYfyT8#n@4{q*B7CR+KnY|*g&zO>u;V;dLJKJr zn2WsWcO?wEr|pR8#l_+b#{}~Dc4LAH)6k?at2cu#RmCWg>}>V-3@}l)7;vMioXpe% zt@?1UnZZc5`=1d?a%I!jz3KB*vQIDNz;~`tDp(jkG;=P_TT`!^4=s6kcjCHlOC|ZQ z&~cB*n!914|C`+>VvufYz4xdbcZyU!(m3eyNxc#2pX(5kGEio@)7WhXQ7 z5!E~TST!tE5U}xZd*60`L{4T&nZhiDxA*noSY}8jKz84#)x#xEs0}ysXdsP+3t{0a zM68xOqU81KtHtTVFz>FX%I5~ecGO~~Bo#d)CUj7TSk6c|bnAfZroPz;{{x1JEn%&s z)8O4dO7i}$GjwjhC}%}P>rW-Q?EIj|R}yfQGLdaaGrko#RkZQ?`vfHmBap z{HmFNDM8n1nw;*JK;a6y;?!ZrE1a9)j^y6P@fUhjMVVq}IMmS$&nToloE6jBc%-It z(W*JoyYMExcl-JEofv88AsR)*{V>|s-=hbkxELTVqe|$}7nAJq&7`7ii^zLq-b>@B z%~l=11)I5N;)6VsXvDo9DG{579#J?7CKY8yug&TojH&r0chxXo5h3fdtHbp|bOo;c zLBB=CdY))LLhq(8MFp3d8n;`VsnBYD3+dB7n%HWieJ9@N_Y@cb`K@^fFn%F}xi-@$ zS?))xB1&c2kymb;R0nb?}b1Xtt8aT#x*ydAOh11pjBxMKf;pBG5hr}lXNRSl{; zIcJKDGiU`g^Edv<5p#0s^N>&2nLFxrJ#s+eYI8wQId68RKBdc=Y7C_%ap>**Nt{g2YN~D&a{$l5X zW*_O}zy6dh1b3(Ta`svWdd2#PrZqm^G`)8JvW_{k7w^&m&Jat9!*QSB>*%Fwv)H!$ZGL+3y;|p^!<{5gXAOu7H1#EH4{0 z4d;D7>$akmHt37kZcDZsoWFz0{rPx)n=Rs$&_F`ca~nsuQ6eDl+sT>iUOG4-trg#a zi&71Zr-IPJ(X+XbgFPn0=h1?ufw9=rjf<98lZVvMp_XQ0efUj}W^%WctgKKzVspLu zH?O|GoNWQ=xbE{Vu@l~RUif{zvUI=_F46rL5l!wHIH z=)wTkNON+50qNo!kBGR$3Bx8a#2Yz&=qB$!+GYWS4>e5ii2ud-gGL zMnsr5Vo`@=(2?lfT|aFnB@W1oS-wZqBGOwtvR3Vd%x8VYeo^1>BY9L2BrqOjW}W6n zizy>;(L}Z6dk#mV0(iY1iJkN-#5dbY_B#=7?WIS049l^@zpWqfwH7A8EUeK;&SXVq zA|>V&#WtQ?SglA~(%ZIm3_7x-b^6Qd3dweJ#a04VeH&QM-!fA$vz5Sahv~dA&)Vl1 zD$Q{RADIG63_14ky%Lc=Y!~J#b=F@nLW=AyQ=`c*03f^8Hi+x=N;NDQjvt9t48NJo{ zWwJGZ4NNqr@S&gJBP?6rzumCA&flX3lR@*Rl7Z{h7;NbjLEfzitCfqSvy0-5M_vl!PO@y(riKD&dK3B{J`l zNJEX)==loCgI5S5L7iCLT%df+KYxjD0!YgD(3WdCYcroh%SDPjLSgl^neFyrcKHgCgcO8x@l}-}XxkEH}Hm zXKAZ+)IjQW{KlCmLt6H{2X|eW+eE*QB#5B37a&v?JQkld?@Q73?5G-Ck)S#sh4gYY zx#ynPjW4_Vir!6x{vg;;EdGclcs{N`J2P9kJp7%WXl)4qGwl^QUzNO?)dkn1qjaad32pIHs2h+d4%QYFjXTDX zZr9>a!f(Z;yv*ivde2;7?P%ApYsJyu{5alEqq%LZ3QT}Y76-U>V`B>nzEo*(e5w^g z^6uJ9*)#Pr8C*Mgrj76s{juX-fGJ#_mZ6T8T&wS_NEy5~ka1XY>$Ivx2t^3G*dA!8 zOgj2X*WG?Gw#|s|m#EZF&s-1zo5zQGM*_^C-Scee)YIG`0rln{3XE=1LB6;GHj^Yb#6q})pi*`ZVs(zf_ zr#uDPI^ix2Tu@$I)M3j-sv&nc`Ij$N9GesiD9(Kdi zM(;BHzwksCnT#B$xbGF&IPy5YUY?#GI<3Vpa6U1k+h8A@#+Ker2&3Sjr>)k@md5NB z#`OO*NGxbAL-O@Av3mEWJT5nxJ|$|qX&bM1D{v956`B(>mtxtBk5w>ZO*{PSFBcK> zb3AXc(_-B(+RkH1f7@|onKJ$*+hYk7?+?oClSOqUHBMZpcn->|2vT{8Sh~*k()End zHU-R!A8ICMmYS{Vk?q^3Y9^&f?mqw;BTP8BA^hp8F3E^0)C90AJ=3uUQcR&;<}G15 zQ1Z15IBm#-v*X$b5-C(5uGs(C8fuUt&`56&uLRaKxje+HsKKk4PzSX5C4UN%lNuiQ zld`WDdd@>3N>NQ*PUk65jSq0?LECE7j+ZTBiSoTJ4Ew{|NcxMqFnSBF2@G_{`$5l% zfF3QSv#o=l-XG$ejJ%OhN3KN@<%Sw>ns5~=;hk(9r}>-47H5%=V(7$f3?C(%g_YsVb=#fs16L{{?IPKO^5$tcPBF-N0L z=Fp*X{lhr+eqIAdG(1MFH(d*G#;!Jk830PBjR1!fiVoTFbQU!Yt$GB){O3_GT}!^j zVOux?3|lI<=N+^cwxzR`5!dccAmrTFEjYf`9@)fsx_aw~g(<5)Bcs=g`8Fee1!h|cf zP{HSFiv^vd#;_1ZxS}Gq_eQu*3a&(AND!wI;*0BEnSq8A8YO?b)Xi)-BC_`~{|SGi zrQL|?JqF%xaIIcg{Cit%5oFvZGn9{CTSpVT-1lRIvX1r=}ABu9NKqO z?jEYaY;Ut4F2Ut$YNa+EPdjaAON64;#}m?m~_=F4F*7a;l%> z)i?(|&`P|3$-ice_Lzhf)F2rv1_~HJ9ZLGGn@fVLm0XX+ae|jNs2PD;dP5T+ekk=f zlvnVvgZKhCcw@r4X|-DUbci!c$hbd91@Ii7~cOlC0^LKnJz{%H9HokYSGlli7G&{`)Lq;bR{(5FC%}e4EpDkYbXNh zWl{=zZ;HS{q_?dPPe=1pksxUJ2e(mBQTI;esc2Lv$DOmeI;X&9dyVy_Z$Bjy%;lF7 ziIPRz&52&y-IBf+EIjpms#KubLWc9Nx$dI(%(A&6%WwhrnqE6=Br0-a8)Z3ww;86iGNB-=<6kWTjx8D#2J?#hPqGg$Yc>-NDd zg=vSMik4d6wbols;I$ub3k6;|?ej>M+Z{+ELrWg?qskM}asKAlB6XuXKRki-aA3*Z zRDj_E`rkb*Unw=66zhw9YwobB*X!YPjlP@Fl?@9`1mpjtQR!t=7O{e`>}H^Fn*3Ut zowQX`h|RH!>wPRq>#Vln`C7+YnihyYPCZJsF~vKs{hsZ&0qmYhk~L%OuM@ zeM6TG;K1f-xjy_-xJB$jEK^Xp0xb}nu|5_1eF ziij{uD5QyDLiDZ=TEcV|fve&_CdA99lr%ZM&-#^L?1vzTO&nD72G|%ks*#!PiVrdm zj#LiR$rZ~@!UJji;Fnvw1pX)HbQ+O-p~Us@chlmh%6X(=G@bG(WfWQ0WEcv>y72 z-rO-*tJUk?qM5290vkUScJZ#^R8`>|`v#iQ@Jqq%cEZB=8sR}<%C1JvpbYj_ zK5G^wn-x2uw`V-!Cp4F~Z&71QoSkU1W?#8#<7>|o$Gi4SXXUi1NVd0^$w-q)K?Fxx zRKJ?ym>=+;-X`{wAV2uIQO-~+)adgEhV{MMwF_=;+|5~9aOpCrloC_S=X=5JHb|?v zj_nmFDkR58BkMx~YA^e14KuP;!`T7RZ1m72Z9FY_^A$RkleiW@eUNnb2$_5w6(;!L zOIeTp6?xFN3ur7^THB7Jf(!q|C?@#W0~2w3*ufO}Z zyfXe&Z7N$z%|`D|tl~ZXlEIYZFv{AuGg&%4zw=_CGXPLf#j0%&+lHJ9IljHo#=trO za6TcU_1UpnsEgoSe<$N1@z6mJR+_4`JLuwSP5UOOrI(ZieGTn8pAY1|ZVJD`%>FEi zAGTD-?0;jHo@R(gBf}DY2&nZbw4q$op71;M&dw`2yyn#ack&BH{mKfDFzFZ}rtP~_ zSmERYA%Hd~$4th)zAIDjuoNsg}e+oHV}CN0?&Pjsxo-Fnw7T35?1w z?GkNzpz5M%e;2I}x#hXXRuz0{LN(3q31{nw9ak1XLY733v#}KzJ)RLJs=0vg`>rC1 z88{Z*y`OQ|*Cw>d#_7p)GN(BxS79buaN9QP2>P7%CG$|QFa@`mUk0gVfyvKfMxkDW zp_d`EaT#~U%CWH>!`Pad{P&sO2-rtmbAGxYmzlU}?yH4I^Z|C$fbRxCvPS3V&zT(_ zxC`qGQ6jNXhtVew@Sz@DCUYS5SEOt5EwuTTt-i|uaqZ3Am)F4>kb(nYFp9LEKp?)% zQtMhRRu&|{m$){M`)@Z}qo<@C0EC|C7EE3tnF*joQ_wgIo`b!w1^xa~`B9+{BatNG zQ^@_HjEv6WEE&|Z!=5hN*iQmp?Q*5dL?mR8B11JcX^x4t1bb!|gq%K?ELPv7Mx18^ zK8ml*Q_n2YAOcXoCTynEazb=WFL91=T;q44hq&VZ@jkLFl>I!!bMAOwS{Wo+a19b0Yng!{h1Ipqd=GQ1=i1+?lbXJ zxu?I9?-Rv*w07FTo(hDH3|h>x+G+e`)83gXHX|xvKyc$luu1r0q#tu(p(Q3E9-z9| z6enIaYw6=e1Y>KtxbAJ6hK!|h_F*ZM%LbDOL9qs>=rNgHG+Xr;+7NRR(leHRtW|$j zzxpNbyz9P~ccw-02U$?2G`Lt{&CdycUHI@bHtBoLJ7@x_A4-vE!2Tod_5YS!O;jBI zFo6R42v$H4OBy#DI#)UZa;o$}U$zf`MINJ~8vW2UAhf8!dG0&q*?qQJ55ndcm~pY> z3eoVB2A#&N>-vW{yMx0YeR`vh?TQjH$GGW>HeQr;?A1h@a|)68UfGd;9OL7r5I)8& zR?eUGOTMs2<`l0!!4oQ`!is(KgM0>adEsTmnWUljHu9c)I!N^iCChE=zr2muOB5&O zTR-Kx6@2=CEr4T^P5LY@J!E$G2NnYEmD_sDVzJ!a6-m$s*WaY*Wyr&(G#tFm#yy!# zLh#?p^@e4`F(@3C_SiCTa_;-(F*M!2LS101NkORV-V}WJH7YlyGVsuwuoGcJ%<-8R z*TtUc@w*g2%tB1NZJ`0(W$jy+-!QUChZo~K^zt*$xDt~fF6bW+ZYox&^ycv@Rl)iC zf2%DY-;{{Cf&GXh<$s+n<#%`$!^It~{yMZ~++9K#{2<8fnR@T__dOUZ=ulYLgsoUv zJd_cV6Leiw!RM*omDUBmcY3`bq@vyjC~WGR;=aSj%K^MK9NY*qPkYPQrAd(otuAdB5@h;+nHqz1&Ij;O733!~%}69^%NNH9y6H4j?`E&GPc)`ru+Q)ejMEn4#(6K`sBRE~J?~CR*~jo$l$egw&)7sP#HT zaFG=L8Zn*SWIvTB{$D5#qC53WRS~>?%V3E>9hyIpatm%Yp@T^=1_h`8IB?TIZN7jZ z<$LJhWp;GFZ|MI#&X;!8Hm7D^zk9Zix|V*!=&4;55KdMUpzXw^ZQa*^J{+MPjFF&p z3onH=MuKe3t97H`QXu)!hIeHCj?O0NX>N0Zg+fCSBm!};A0KMnmh|~f#R_R=X55Q4)#DTr&A0!mnu^<)f-fINu}6^wC-jS; z3zI&{_#fW=Nfh<`P8d!v-G$haCWI||R>2SE*;syS-XppLAf17B*Sn938ncsZ2v*)q z_O>iZ^ts?C#8e0JsjB2}K6hWn;wo1c-@{3FUzO2J(oUtf84V?)E4^9Q5_M>b{>2J$ zK9f}pFQvpVCu|&3Z%>3>;r2nBqJ%8YRZ33w7Fut;zG8&SH<%`%QDUf=mlnCOu915d z6@VFaxVPz{mQ=@-Bc>ctkReX$xx&5o?f@bl_cFC3^<0GI)Cb9KGn>k-G;ze+JJ2+? zd#4PJF%S94@y+?E24enfcN+f2O);+bNg%Mfo)s!ap$bl0G)E_h+q-NskH_*9wjIHL zD&cyoDmjc?CLSQc5qMd)pcr}2%a`EEdL936#76Az0ak(lsykxaHsiT`&dm`@5CI10 zyfNiV-Z7S!SGH3f8epN#wZahpcQWr=<8Kr#loJ!7-=nr&4IE_D(V}=8V;~RQA4rX6A{IAf+LoFhU&R=l>aE@{iL_46aiKU+ zYbGl5Gc5LrS5k)3XbnX7&-RjVGopNSHb+Ij9<(^^J}ODbpCr=N!#iMB ziEx?gl?~y&X4aX{OXJL$13+5^p?K}ILKq+za_ZhTEJ8sf$DE@GU8B^yj_nU#vb^*0 z9tSt{=m$4Kac8Y1eyab)%BS!L2Y5ut)r^Epi^o?j#Ipmoq6eKTx4T6Z#c%65+wg#| zEb$enpu+=KWS6EO#?E~|R0s{oUNEQL0{z7e735vP-CbJyb!$n$Nje>-o>J&xOnHEj zzHC?4N!odaZn>&1G2<_N<}(!5;{1`46qdsNFd#%PcI~Ojjga&CNU$CUBod?pm3y72 zR?hIxokJ~}0k)U9xP@F!d=0tYy}*L8g!Sb819PC6N+}-Xdkt5m4iD8-d`csrj`-RvN}CEyBcc419Ltbm%6PZw{|!L z(r}m1MwmE?Cz|y)oz;kAn(2kORC?Q=0(_&dZHbnev2N(!Z@G9o9qCh-b?$V0<&-zH z-lc*je8uqsd731Dg^R*A=imP+Vfu+t?&mDW3oTGZ5aQRyf^t63v(-E`v_j(u zBksqY?PUeEF$d2YTJZ7vOq}|r?y=+3(4kfXL9$I$AHz3xr%!vY%Q~YG73HC!5k8@C z3DrFs*I|U1gMU)#7GcQz@Tay#fj?_DA2`3j6?L>m>`U|2?gpqiUhMCK+fR=?>i7im z4Jtn-#vBrTXIxxBZ$dGDA$9e}U3EY^IF}6x)mC95G~aH4jU`K22VxD{X)gV-th70J zsQWfkm^QM_w#y;;Zqqw!lR*D_e=pk=c(#m!up<+%Z9}p#S2=>qw}6LUAY095Q+HUsU4x=)sC}69GP}4_D$&Y zxV&&q&5393eF%Urm#XPXN!#SU!ZV!`1xmR|j^NmS>p|7H(1C3G1xz@fz79X_^Am(o z4=KX$sYIZ=^=!zTIUbzij{~0SFmbBiGD2K`kkkSL7%dIw;XPf~KXq0Giq|wgGeElF2`dn0xZExCQcF!7gaCs zVZl3~h#k?k9qhnl9o#^&P?E8DtUiyGM*I~3=EcU!$j>|n@?wHIRJ1V9uQ4y`>@NHW zFT42y=E)G^6J1OkKXG1d+1yW@YE$Kl^pY<%^Y&-Bn@`VJEQL%2kimXK{qHmUt7vF? z#Nv9MrrOUELQfUqNr2L|Q~6nGi!rY8PM_kn)00Ab1ktj|pW!Pzlp5>~yEFMP^`&HE zu(_5izm+AV&FCGSKs(%UUGa45C1 zPfQAI{u}rzq$+Wxb$DV6Z*l2*8qAL$Xql%BYR0;|G|L@2w^3w8=FIXVb@bX^ezFO> zAyUOYOb9#?hqg5wD9(O8$LMC|3~qc_tc3{M@%3aXb*OJadIS~f6(m`k+DgThN&os^jqsW3o`;#Pk*_&nhICj}HLf$?@=qe!1n1 z$%lI~8mg35-R^%~<`&G)2w*Kp1`9%QdunP)V5RRAop#>=Ou0rV zFg>3KF7tew{3Mf=s&R3%MJ`cLU@T&+M3(cCoorc4Q=s|IW$(pPfe7sOyiN`G13z?JSkw^UTp;20IT6TAHd_9hQ{#fJI zTbxcuj?gPo#?X4MzH5cf50ec?AIaUtkeFDr!9Cb?)~w`Pk3J6Zh+8CT1dgO5mO5!; zsb^4^$mqkHV*8wb>^7Q9RL^Ao4aC?g{%+QNK>=SjA&mNDz0?h(4qJSY_-%{0^;zo+ z|IWZ+br_C>B*HqxZHVukjZ(9Xq>j*FC)NI=z*KWs9~TY94Sw2mV+e4T7S(#97GXU$ zRsa`TkEUUBYe`Ny#wx0}GN>b;z7mPmRUEasHizl#&|X_H>s&cKZ8`lBEKtU7wT*&q ztp8*n#vS5oNu*I(6UuDyJt2!@4T}@m^kgrQkmk6q&jc4PD+>6NMxEEh=@XQ;r{)*87_b(5aB-CTBJ-{GMn|{|ZKurwRFGzY}B3j|_5A?t9of62DUY#0P$y zySj2kZc@v+nUp&%Yp#qbX4#-4q)6s_4-WJg1wz*;sJq2@E^xa2AXpM_O~sF_z=WAO z3b=COVk+GR-~|S;rS1cm6GNHv<1Yck!%R5QPc4E4_~?-Hii9n-6O{A+dIzw4{SlaIjEPMRdZm{rWqK z*A2Yqj;}CN1!RjMNoEnJ>RNdkq*_A#U}Aa4b2%=D(rl zM9x=J%Wc(EdA4?$l+{yw1A zr!-@g9XLO15P82E*VVQRiT^(UM?tv07wn0D9QYt|w18nhBQ^6Z3flBEO*5ySTyQ1m z(JnIfx6zmIi>tl{tZfA5Wh|Z5jnY<}0i9@?*H3s#Uhj7NJ zC!?=4IR3#k%Fh>m4QD)g)%yC-3NuM`4}*G z+cb3z$fBp9jtEy&$Q(~07|u-Y+5+k70Ff9Bl`)vS(A1?#M=KDUqnr?5cRmA*N|jmE zI|OyZT!*!Sy08w|v~C2hsaqJTb_is~$AP&mJvH=itR+(_v);7JtDq+Zlzbpt=3!q6 z_#AX%yimH7%li1a1?F0|2hy3wU_Qmij-O&M&(Z>h{VYal4r5ebEVt5obU3nTDYL^50&l;30(1LV;aEP6#YZ#_ z^TTE~p*58R0p*=HA2E1nr4+jjI1NGlkt2VB%U}Ik-T4_$etE-xq37yd8iM)@u{ioh zRqS+;MiAyf2U;l+kC?695^cSv&6zOQoP7asN9An?>a2Lx__+c#BZ;gOntH|PWAhPX>(pxj3~O$%!cE}nB03RzMT;{`V9_v`K|=GNgM}svRE()N40DmD zaDX#R==#IuoB0pqS>4n44sbwqm{UrT8BKF<^H9;se5@PuWI^jeFCEPprLDC^rma65 zLCC8Y&OT;du2gVm`)K2u`2hmv896;I%R{>6DT@MELRro;uUJ8@%J1(ZFXPu&d;_$B zG4rYAGM3Joinf+!xs8C`H+$Gwf-Wcs^$bmY(X?6UY7putFIzgPP``EWFXOW3zT7a> zm!5nQ#w<|3@bj19?prM|ua_q3#D-u_5DoKmZVX2sdPw6ipOrv!D#=Wupc3kYL%p2< zyAL)7_4^OM9T&g))w=UFp4@u<&oJ$(#-RRmg&NE3I!=u+7ot64qK(k?1MzMOtLw;E z2Hb3@ThdZxHO2MSEwaM)2UpsD-e1zp5(dOFhluIHl>nDcMB*D#^$OR<_7eK-w&+z4>u0U%cM zySO1Am9ht_6nf*nrFn-a?Obv;2zOV10ATzUkPp_67=PDa*tZKg47Aqi&OX)04xics zFYNz-g!zaLbCi(hF|kXO!`w18&D6^&o*j7^zq{fapzG@g%+zujOJ+_*Yjeuj&YnkB z+yd&9QbSW0W9o-ao7ouDUmnD=6Hk~_^ZPe;{|v5v{>H|j{>)2Q_OVk8s9*5;%W(It ze+nH-qMS0u69W8f`G1WA^Kjk?NaWh<>D(BW9rR(my}JHY(^AyKqFD*Frkdo{gHRWm zdYc36GDP6kS+v9_xbM)P;ewaHQg{BwlkZ;lL-bs=bKOwSB^+daFkPN=$g7HLo@hH zO`3T?EJvAUcGbr)MZlYAf9r4)CmEW$21FawC5%N+2t-x(L|`s{i|t(77E}$vSG%X+ zHKHTH=?|Qub*OVd94)`9V57h*08WSsG7}zW35yNpHYt_Mc&ejL@91tHJDj%%{;@yP z%!gM*xoGm{^~vV-=;OYhb{C9sKW=B=qF_z(?S80v&W-K7x2ork zt{`m#PzM6z-6F7#Hqs!brb$gbFg4BPzEOnl*ERJ>sMi2<(ZL7=n-k^Z2M!J%p}~&* zVQQg3SX1{^L^*N34s``v-$;YN0jLk6Et%R7%*Aiv02g6?H|{HN4fO!n()Nw}j>?nG z&K}h}HfE%7?cA6hQN@%N1#@vJVMWN4%JpgIQ+@1kz7BJynUB&evQ&Arv-s>B=G4VR^T)1iLQw3+BE*J+al zgZeSY9EHB(49m}3B+*Y zXTFW;SJtPgXA>^cT1aWBnG3TpA;{&~eqH$jROg>k3fFNEb6q48aWtozkV+A}to3WNA0~*C zO({5zn4ca~oe=HXrD74j_RxXSuqVE}wl90EwtN^5kR^?9e$7UZ5Y^iXY3JIvI^NXC zZO(GRrE3WR2FDv;(`BlU9nRSu|M-^&k)Z_)bIm+WbI8&n^0bH|Dr_BTlu?Gy7YGqU z61+nqZ<+o0`{*mU^E0=wG4ncQUa^8j(|gd|oRn!2!kjLHx28Xn0_q<105~Ajm$0Ee zMQ2L_2lvdv6I(Z9#H}x1>DPyGJ z;qc2GC+dZ+M>x#SIQXQxPjoO(cP0xnzH2 zm#% z1oFb36P12b6C27AA#YVwIDS2mEKggXn#QcEynPYp%4>;;a_TOwfX28&M}-ppr?m$Yx+&fq^N-3)5a!~$H&$b~w5dLJICppa<0B6t6EL&qgaaJPs8A0jl#Ti2 ztfR`@<%YCl3{!LH8&840Mf zCY7zn?XcbzgZlJYc%pX`M&0^+4AQR;3}MGc(aJ7ZQZJ?|X1TB;WxL@F`-1 zqAMQ54w(wxO#yx#PofU>pD(zv?t37FfKURLIEYhMYIvPT;JzN*R23u}fT~k^E zw2Ynk`NE-CYK&%u7(yvUb8|DAQb~A2zHEy`d+YhWY`@~M7`i&zjPwlUO#@O#*EG5O zv>p-_fCfcvxi_s$^nL1Ygw7FD$wDzWG|fSTPz`$Fi@$ZK>%f;|<d}6|NP&i=T{xP_SlNg#1M+-@!leD0Pq#|bmR1@)RhrHV@)j%ml zEEa>~I;d1CsCb^%E>Q_{%1zzA@1rT1K-bhRrIFTPeph*@@i=x+;BT`m7+R~PBY0sS zLRME%12o}%CWDmafXZ#UrmkBD2!y7u(h+8M!Ve%u8oaYmVapKj=wK?$bBh+>MFnHEvLp^GITb7~chhAe*$0VSg zi|;5vj|cOam1OV~y9_v3bNd@u{P$(p>JOVR=VRtYDqya=z=fx$>0Pz`I`+b{Z(j{( ze*I`4NDw@{bu&hDB~ap`Oj&a+^aZJB1d`UDN%?A0D$lS%{h%4M8iV@lLpb>GL(p3s z;9DA`srKv4?T*I_n_og_kA2nSs3iXX!CY(^PcuIR>l%SMso=2L38b2u6tJrZ;iekT z^T1Y`;SO>{dB2a9N_eL=2ER^4fD($2J$+?eCU>p*=caZCakywg94V4SJ84Fm=5WRL zFTBJ=GL^)YwoL36FC9<})Xcfdt9bA{25+A#ko%qqb4n>Z&%^9_vqR~ri%|1B zQ~>{5p-!y(f{LX)j+kw|Fw=wQNd^bgFB-H+5VPaOh9j!nj>wUg4?T~@7`kZO1eA3v z4W%9g*O=Dh%cFwP*@T%rxX_AdKnaKzI+c3>hJdfbNaTnYAQk$ZX2Kzk)%;!!b|ImW ze<%}5FfGEI_JZRR#yoIsm!p|(?PLGkIYk^#%tu%Zhv^SNE%z6tnNP7qeu|U<2kZaq zEu80HfUke}8>qlTp0Yr$%mI!~M)RZw4zR|Ped|w@-i6$+V*#A+T!TMfeKY9V`Wn=M z1i?eSn{fE_S!i!g0Mz4JjnAJG80Pm-2a^?wR!3|hL>CkuSjUR`6df%I95izlp4_|% zqfUJj_S3Hq;lM)=#50dSgW1XHb)6f8xybd-E%Wi@YtP`2JrBfC|2PhK1Z-gvJ%Ktd z-zdzZE;lA&{$8D#VK6^*b`w&mB$!gb>R0Jlft*kks#Dal&l_(C1U{h{DSLRmJq4fE zS3r%xTnHh6LkV0sASA|TTQH}%VVc23H(!K}-+P@OTw9u5Bj-H<71$u zHq#y%bg=Ok@8EOZ^|*e&e?tUGNCN1 znz6?BeR-Z3{u2t9J|yVz-=6QIQt{Bz)`Dy%s}+j+8IQ*i897U4OlaypFwRn;Z@=~y zYi^ zizsmudxdI&V<^?8r)k%<{1UQX#{!)Gz3V{c)=M5>Fz(=y-pv@xmH22VGp33s&7%tH zG6$9plOO9K0Jbs^?8V19pN2>Ty$K#lX%qZ=JvdJ^4u`OTNn*4}PS zg0?tz)wPDp|Lng1Y7pjj87-%A;2{S$q?yO5kNxMgp()kOYlPJjvcThQLLJhf>*DZ-Jw|e#3lIoUSF;2y#Ghtd&kL9oO#^8>M*l2voo8tyV5EPfkegv zM9x`c3grVAex7>jDc)o8Ip;djU=ke(!c6Uxw1iLmFP9q@%nQVq_uM2f| z^{ATJY|DmiS&dn}@8~~`rBGS2mWrR2Bi3*G74gk7F98*{jOwv9S+vRHq zEKW9IMj;xY$dHchx4wfLp1l-hT1CZyx#dh%vtbL@Rd#@@_2@2d*$d}gdkL`6jtrtf zQ^U&b4C*$~U8r+MIg9c&?8DEQ`y5c}YMC0P?$WChg*;x^G6=g!qHDYWM&9Vhksm%D zI~rW2P4#FK;R66!J&lJRet>C3LMFReL&&-(b$5Ex{Wni5%txwu9QE0g@Xp4KF&f0y zI2bEdU=ba*1M)DaTRxZrK&9&W{}2Gf6nLdQ9Si0sul_u4+UxrfkHG8XH4x7c4hB+4 zph(O3=#?MG=AT4|d8TY(*K9U?&%&6sKgbLPT$o#eL)>_=gi6(N`U+8VXWuK83iC-& z9A8)61*Y6oNp7ME~ZKQkUK04P?0j@A|cKt4b2p0m)mx;iii z0K+hF`cMXDL?>S|q@(vYoAJx%u7btG#?auZ=Drryt@pr|y>P+R-vH)Ehx(AI;V}W~ zRSJmS@BEIesSxmU3eN(i0~jAKVCBXgn1BITfHq;rg8J6SH{yu1kHbKvb`TXc%!#m- zeXrP6?6%vkcy!ex4C(~1v+-b_ZcgKlm3QO3!_Nw7flBJb{OHe|gtZU621tJ_NG9nRN;x@EIyT;d-17%`Vo3cT8ph81z90M#f?T={AIe2?!%DhKeZ#X55h z#DTevBr#D!1?OCOKHj~{b_7p)e&FA!dGi={HgizPhM3zVuB zvYCtvd5cn1ZJ;fegH^RKQJ8SIiG4nCoL0<);BZ?<1Fz*MSFMzN5N{mn%3VzX>SAVD zQy0h7J@^A&@ELAacVme-i?@iYw5b~6pPI&7r)nFU!K-QRKnQ^hbGNtx>Vz^gyQd`v zp$>Qu5jA!GSAwS_?h@&OX&(5$*3`X=K|TPeTLRbt&z!}NIcb{AA9-2zJiRTG#;IGAv7p{}>t@{Y%r)Lps2(+K>hG;uk0U>P zJO(Qx%I)fIgh+o0cwihRd+xah{`A*Bg0|?fV4h4RvGTdcv0}gDoRmfntd3^xz?|1e z32hka#PXV9L&K}v!=Y|drU8lOcYZy&hMp$`FL$O?6)V!vtyv)UBHEeOKguc>=5hWj!^DaD!*fEzU0TC%L) z0Kg}C7`l#fv4Y8oNoikvn1l7}%7?4=0fj()bYzf48kIhl`#lWmP3iC{jcTX|{isyt zcW!3)G<9*>nW(vYe_e+}XMcQIRX(OJExjrZ)7G>gd2OSbF%EE`Q_WqfM+I|ln{z-y z$Ubf|S3#ZU2{^>TyU74?=~b@|p0@41ZO*nSLOs7d^teKW0Et8rpqO^3+qSo84IAqb zA29wl&B|y5n41A~jh&-0#}P%>_^ddpqcY@o_A4mb3CXI>*&AjUEKc6bqWJJ z0&Qzl4s6*QpSvtG-4xgUMX}X)Gf-Mbvn0iOQ#Zrrp|f}7wYbs=z>|Dcro6I0Cg<@^LqEHYaOcsZa2vR-9S(7o6-;lb+*ml zNm2>w03;Z(dq5sj7iB6?r_}}{qWQ(W!KM%DZ8O@O!6-Hb1dv~bM6XkTU8G!sV0jmi z)PdoVF;^=OfEx&=H2`xii<+Bp%2qQT)NkF4-#m4#*ABN$ad6J$z}CHS;dS4MrKt}a zI#z9G^VGSc92`eEKh*s&=TaD-!2O%YFs_0*mnlGfSQXQ+AkNEytPDouY zqhq5u<@_`8#@la3ZUck)<5)U-=g4KlWTcwM5uZ5$>l85OQVZ%Tn7ieCP`4-nh$fle z*)%J5zRJ}q@|uPhXU2fJPI2%9AH`30za&yQQLAHj9dSdv8qiUNg_Ev08yhcuDHhC^ z+2u$u2jGUj2ISQ;#qnkeinf%2eY=<<(K|4NDrMF|uBBU+<$1SfHH+-*n>CK7QUZ>6B!0 z2Y_@!N6K_!6H{PxtPt3pG>iej(6xqP&eIn*XL0gYBNo(m+_o9FKXI*BU$iQea!~6& z`1JMv1uUSEp*~_5czoM-j0%o&ey9W9n7VjM^5YZu>$_uW&D<|GpiRbu`r4JR4E;F-aS7>s8dRP-tGR6<$AfZ z5A#RjUhWL7(*SkirD{Y5wWz7PP}hir1P**J20emx5uj_9KU8!$)QQIWCfl})fYUve z3uFDEN6QPkFlPtd+Rma>`Jv9zI4nF(o#){qkEwfUJclf!3!b>Za-H{TvUiZ86S2u!#skLCv|1NCK;^b{6%!sqInE8D(ZhPXIDQV_@ zIk;tSTz2!#XgaJpmZrXXTdxx8Hg#sJ6Xr?HB|koa2O5Pr7YFL8h;iQm;LS&0#)@-K zN5N988zAmN0rM4~I6WTBQwgkmc2%gEJ^JRZJ3qRWJqDbXL@oVQg(O|*GF_)i-4L^W4bv{+!ZySc`J-ZC*;rol?D96p}Dove717$GR+)}QI-RCIB$J<2>Kaol*_v}v- zHS_X#z8`3?Yb0(|II(i?k1bA1pt6?eEs-Z=5yyN5nDd`pQ`bOHDwgp7Ce$TQ&1r&q zDxGFu1+d!AxRB?O%hLT(;{47Q;!A>GqH5;;dKNZkv0|$c9qJ>@{C?XL*F-B=M`oC< z_~HLtkETPL>klpYWW><1dTTFwM+z>~ZDCB^qMrGk!@NKuz}%4|_umHt+lJBA6Ez|n z@XFs_z^Uh*g$Y|dJY)-NAOOHJHQv4qB6j# zS8q1gjDRSiUO)H@rIeY~eQgeY-U@qJ-qRy3fg10K`?;((psd>ra>qgYT9 zCOi81eBG%*eIg%yon^rDP82E?niCJ|=}gXzqij3l==|JSj+$s12H5rXj!_&71AyUC zHts5}r_O~xxZ>R8C@=@uby(1x#ft4Qp?=F|+_L)WXa(y?N1_!!`oRtHq251)EdwL4 zgpS{KhK6hag^39~@LoKaA9UEkxc{*y006K3^A&W=ioSH}3lBYmGtWB*CA%!8+rEyE z!TdD59s}lPDuKT}xe`ly)G+rJ(P>yg{X0B!p;3xG^%8bfz#MS; zKUy2+qKMj_3(V}U>$>E7B02Lqd5uI!kee7#r(naB zR@JYC*VfdTUx1$(@u5C6FzmfJ`80LDpb7`Rti1;v<={HSIsLlE^ZJiG2z5_0=i4cu z>mvXMx{*-Qjs!Y?c?bT8Z+=ak0na4E`=!3|s=H6VGLnDy;yKhc&9!($g*i{3pKiuUaiM)@z6rHzlJ=f@{w!~Bp#mgCU}A9jCd^)#M;={dA@ zw@0q)=?DLgb3S$+s*Yca?Yp-|^P@O%3NU}pEk&1^|`G@xH)8Q5*is#0qB4p5^`$$9}n{ z?rwzBVM@SZe?^n9EpC9%ERX;9pss1cILtIby=&Gyrj1t|XAU8(qN}M(P-b;(EmZN= z5F3BVX40S(u9rLj_a#9T!_ZO7%U%4-#UFnk02XALapDv-^_x~*8LeO)nUQG46_@@3 zO$Wz=`V)g=7#JM~b#G)l2YqJ-T!%za&n%FG_dMR&Ta58`6DZa#f&UKTJNZfxo8XI}13J(42k`|x@w zrI^v>ckJ>vNRbxOcBo%bBuP>tms#bCyuc^g!JYZkCNZy9I$CaFpZbcPCAA z=fM$o2c6xs{U?T%4P8HiqFiJQ*8pHLKiDfZS~{_6s5hn9IIu0jg1BaM_a<|`^Bmr^ z315v=?fnh_g9Cj|UGbq_oE#VOHZH`JgA+^#)G4K~oUn@29}t1E-|ekA*DM3D^SoBD zqqJt5F8|j7*HS8(SP$hxN+t5LcPOm#Z{Nz zh^9lLL%pKwcxw9~3MC6;6D2&dWh55N4?B22{N<6SLboqY&BY@xJcevnOXRwrT>S+0 z-|qm7j26MA3g{vR`6^`mS zz*j5F^y+sW!@^6VYw8pl66=9PT{mB$j7hQEZO7m%yZmd!y{UQ0xIf3f{Cj#Gfl#_-{ zy-={4Z&Euq&6~;KlGa44-N8+c4fFy|H)y8Yw!1ce0nVNTp-us2I`*mFL4bQFhHIU+ zFs2U3@DRP<`L=SoG-XX)8Fx6QOb66kJ6gdV;QZRT>x)3VxzeVgW4Cq|+Z_OQ42^&g zpjwqZ-TCf$9ipcvZ&@6ev%kQCbOy)w888*&_O*nJ>gc~^6K+^}MWk}|q{D2*)tCP= z7SzWK124Yci&gIrA|C_h2OoL>9)55YfZBc69?d)B!I%Dq=1z4)uUfKY%N87Tz`=NL z>-#wV!qf2j+BYKCk?Y9ej}QJi6y{ZGE5{6Lz4+!Q3pnh^!?Eej4bUrmnpxv8zw+^$ zB$%sS244T}CK1v+0-UF*izao^{LT_J#{tf3 zjbC$@+R(ttj)_d$cEITZo4e+1r4Y^Rs)HAxPAQt2(rgg~2xfPv0qzv>rBNvzkj?CV zO`S!7;;o9WsRw`6mqaocLU1Zjr5!>Xa$xvoPKAv6W3mrF(U+;gs}SN$un zd7tJSAL{bo-_f8hn!^F_g-SISU2>EY&FwxjyEvsy6P)1)(U8k|em9N4900OibGHJX zPV>litpgy+Me;yi= zu!m+UP|vmH)6fO#Y5?e*`jjt}+C1c@Pq2AiN*a?|1X#Lgd& zR3CrMspXTi{L&Ngc1)Nr)JoWEcDMtasOXRy9{gN0r&Kl*OMW^I$a#9XTxJ@%4ZJ=G zBsDE6psP`JD^b z!Zmn-`n@rAR+qH&Di!zZ-LMv=0W0d%pdL?5GcoN@H=Vf30S`@!-K15^LUTIhK8Tv* zt?tcfWZx%>MR(Wk?j-`VXmKLUx!8yYb1nIWQt5LW&1VHe|3$DI#t-4}m&;XWj~)AchuFsF%HT9{gL z9WA)~zI(892+S*}!U}17eVCV(+X-cwx+^}Ie{c1*IIJVOvm4++Jgm1+f36C&Y&Ne656~Gg9j90+1!MtfC>?CDF021;%B;i9~) zgh=h=+uXO+@jj4jkNT9<=rj3+6dx41tdP#zK*e~7efM!3S~?o9UGoyuDqXmww`d@sD7IVJ<(flq=AyGB zl=hxK{!fMVDZyMXVNr_#(+Cd#ggL-buLAdnALd*P-H^0#@h`xp!179~!iC{8Y%IqL zX!;^g+MogDH``KUSV`^*gW}uP(K!nj{OjidLQu$$B0oBa{OAbAM)Syz?}UdrJ=QZ|{SqX|OB{n@6kI zF#)tU0Sj^(+FNo+n9O@sdV?40qm&|H8tmo4XC@Q>l0bSeuPEZeFbmRY9Nj;TRh<^9 zHOKUP=gfin74&~_@k!rnyd1nxnmTkC&|pG`2?Gfjm~D1q^>vTo=>Iqdg(rtWs#Ayh z0Y@B!RrfHMi_63E_VDXlufO7QO#6Yj^B;f2xqGfaWz5$jYCv^vOqkDT!Cm*>g`HO7>71>-X$UINM;(rMt*wMQMrP3sJ^!B2wN3FQ28zAq{gSscgv> zr=YH;?mEf|PLhYCSCT!P4o0`d7WHJy|*ChmgnQ`viZGKEGzGUsOI--c@kj~`a*}GW7%|=-@AJj z001;yb1eXxCVnSKCzBwAz_KhnyRC|KLqM@A*F*?`Rjs;Sm+V*^Gnz9+#f=sxSX9Kn zd{Z2lbD5t`H3 zKT?Ld_?N$`0l_|~p1itdC8}e-v2h)!&eK4XG0f~UT5#vRcVY2NwPs$X%mvOb%+fJE zFn8;u1PRN;Ubh^FL)tma#sA~WpRaxlM}Bs{ST#*t@*W=9@Ib@)-C-T)o@4(+O?`?m zH;P!?>RI9pp|7b0bFU6BZBoH++`=kJVV2ONeu^Xn}(DEL*}BqfA)9X{{g;#;uWBxRy;+R-*M0Hv3RChGcVB!sv$5pLSX(@ zOqc`gC3wNy`6zs8Eq<}?4on^6vi$k#mDuCU(Z|${s*Y_dp2hte?yH&4gSdCU>0s-b zbEs3$DZzYB!h<;gB+OtCt6DJUqKVc$g`=El7!tf~#rXNei;m7Ua7~y~E~XPe7!MaUb0G>GA#85B zkVXi>jP5!Cc>oFKPJ$a`#oaQQA9>F^NWW&ThI%TUlFZ4X!*$W5ZdB+SH~BqowbAVm_`Q60twU;P;9mZ`)1(1VxZkAL}x1997pq~_PneP^U@ zyLpnIwLD_wPeB^Aajb&0GUuK)t%z+gsM*uze1R1#=K! z-n_YJN;bi)=y>as597MEziGJm!vjy^uz!3UbHBEa``PJ=gK^GlU%@}~YutQK{_jf6 z|Hj_Yp>Ao|e)6;U)7n3UHQ&AGm?cPOKqor;O*Gh`IN;KgV#9oPqKL&g*}R_c`OGu| zb3U|2#C*Q&x~>J_>xX(_f;rc62RKT-?{FaB)#Albpbq{0^_r#*GZCET8!EA&UVlLs zmT!8XUa5H85c_BV64XV_JZwrED?XgnXDS4N+?153uKCUHB7d!z zFy}Hiox)K&NMxvMc^$pK*nl5C_+2;6HEt5FCFwAT4imZy^Cp-`kp%jy!#MHFD=_}_ z$dqBe-w_Akk$WE(U@mIs&N0KUn@<7e3v|$?=rA|aChocKk61i&fpU8Z6*nflC>jV% zn4vH~?vUeR!@QES@!rHXSk8XUijFtVe*jmny}9Noy5gOiG5eUs`0#Eg|%#w^m}_#e0KBJaxLQVcY3X;VvK4Jrld; zK%5Qha9<4rI&5m=kSk7(JUjCQzv9ZbZ&DUL?A9}J#Q~RK z{Pn@QyXpPyTAZ=>i8%YUuK@sF`p%=6d(mFep>Ao|cE;av`-XdY^Wjc|bU<$K7f7PR zfB_3O4!iQSSh3kT%y(%Go_o{K-LdXCF!%N$?a&>*3&5Q6*zG{MQiV+w+PR=tSpag) z>7bdNdQ*!jrD)D&6%A=XVnMx5p=pA8xm`pmkMKY4#{0JXgaU_%W=A{l4#be?(1A8DXiy2kD z1zO|>&oKNEDfwygVAvJ&+5tC#tY;)KzC-?T?;|{L)B3(UVle z90*#_;=tV7mnVF2CUH1a9#6M1K2h|#exG*E%CJvMb0+X&z}w6n<(hLs(4_z0L!I@* zW5WZ^n7KD&id8K;z;UfxbWW7O&11I{b}+n7u|8EC_gXLq0HP<>%Pj_w>74g;jUwK` zQp^24vxh~CvuzozlzN)F=P==v62@?x!(zXwPgA#LO?`BD4E`$`2kLb6ef1H#m8dVO zW|%_W>4AD%N4H~c4?-Qz-vzU0x#hea z6&_TcO*LlD-{k#i^}chlDaG7O8b=J!cu@b@27LSeOB`*<88hcFCv41o(kkJki&h~2 z_o1o7{Ky0F#BU#g?w;Mc^*%cI3~oF2svyjFnhMPC2{p4%(lV+FnDZF{ zDp|XAJx)C0gxD~zW~l^oE=8+^cPF>F&$m(4@$5PG;(y<|9sqFaL!U(d?=}PrHYjg> zY9+q3=0^a4=fCqX=3KOAWT+dKhIh|cgjP4og zhBPW4DAXJ2AcFn>_;_A0uM5+l1(E`3shvg=DO^5 zb7!;J&34VR?`h^7&xxiKs4Y9sQQ?m8pFbYX)tl-dR0p4?4nb3=6!{U}(M%2MR;5_u z7}Ylhg~lQ+`RZ3mRH%2)?sDfUYP#m#IGP4c*U^&8VwUjI`|=K8`_L#RCz(G$s)omT4She`fQ$Ze5lo^Z z2@mFJl0?xe;mC`Q#pn|QA0W&H?VS2G^2T6(_U@;^9v2qTnIg>Z{L?+yse6HP`y?$p zfn#LRp&=0h^EF#H;H0BYiVyQEB@_vw?{ zKXwfs9$+ipJ^k&6F#GF!L^i)0mWGXIK8l+*{2mmPy*Ls!Yobi6IN|!UvHsE*Vrk~H znrg$`5T>q92h6>F3sEA8H~i*l)+}n=Xg<$?>^wtN1hw;7*(O&3@IU+f)0}QXu2o?& zjtTWu_x}}dzN~nG`ag#HL}AjY!h^cYZ8so{*C=UBUC_(}n!Q3(*G)k~Zvf^L8cfsN z?Cx9KXj6o{fxDWyS5@A&IYY3u775OyCQ>g95=h7(+P zs-Y(WsZ)hIr4(%)?d%OtV^$BM5e9bWuV&~tcGqr*7W4ihP%M|F;}{t$crE8nD$c{p zcbjzL8wX(SJ7f{&T*AuKgE^Nu=`;=>w4-~!7c^}D**g5kU%mvB7)X;O(j!7I^Fi)HK{k?aG!<@Om z1=0>S{3x&{g6sxYyVrap6TxvlkDN#$s1(w$~o_81J(87w7h=7P?KbgBsxlSM#S+(kZL z)ZHX%<^)2=&r9+f2^5+Ga{~6JGf^y|Tq-hea|&NOyc=Flb)YUpl$$7wK@~;Yd5HzD znU$6Em}UZ%iX7yI*Y6kc0SrwiY~JDeH`lX>OKyI7$Mbr+apaBxJiE<%@VICoD3;0? z%@@!!t1Ix32?HT$N+!Z#&eQDRh_Ixo$ACHiIyaNSVMF71vQ3K?QLdn2%k^*LLh^as zfBKy$S|uED$x$dgH3DKq2csza9lab++`?d9h2?wE(+6%wW^2Tqp+fnz8l21Icd7{*mfe>>j-Q<@~3$N2MJ+RSUl;vDQe-t z8n2bvej2^aoWTyCS22m;1G}cb&6yHhFycER_j?`xl3~g}y&G%6;haZlT4|F+4%=O4 z?LVha%y$6OWF5I?ekSa7!lW~Er2{lR1Ws{x@B3PAsT`&NM#_G!Q-*L(VWMkTF=Z}; zn==BGz0T_At!HW{mszoS8Rtajon-=O8V!LQE;_8bI+N$G*1JbbLZ*-(NeY`na6gFE zXv?}VD%G`T+dX53$5z7H*#lKT>{~ABj%}P4K%O~7(`KHD|A!xG*e)OpLIS;a%IUS1TcbaRq6O5CkYdVoFO~43fqifY!g(@VuUA!ubh~2~q+R~y^zWQ=Yy;)Dy<=;9olw~a3 zgWuljaDE7I?!!NPHvddfK&0~e(gYE1no{5^z6sfK0~=e#&a9xV_C%PCeJ58zBDT}AdAxY2nb?ackbQ_b?xs|Qm9%7= z_g9gGF3X+z{__fF#{BDTVjws4V^5d@Uo4)ohQAk~Fbt&$fkAYDxGMH0+M&XO&+csF zi>_+|wAm9>Hu1>?Jp%gDyd5k#$h;i}moz{9k2lw5_^?_(ei4ed3r5{uzju96!C14( zl-~|peCMmu=hL6E2amojXJNb2=|IH_3}o~kD8Dp|Wk0Lm*)GJxUQ$*P(R>%hh-t;y zEs0=r zMd-F&T$0<#{^vT%p6fW|xOAbZP;G3Y)gDX@a?xRl=&C5Iu^jfl3#%T*0?+O;umU+@ zOC}hEF=ywMI9_H9G%joIIxMBl4lHnYWaE7Tb+t5EOmD2(;#%a0M`q}Je090OEwn2c zS-m!BEyskoh3w(~%Rnh@eH!o}=^p6i<5`3+{J0ecwzfK3>EUvNiCSlucO4v8_i9IU zb#OY6&OA7+2~@X7r4%1I9@lq>SU38%9lrN_in(Df`&9A6-T~KOyl+oV{YyPf(pL~% zBUFpdaGy^qX#U2%LIQ}n-l@>JWDF13Hk-mf5<9lLLZ(f1ad?)>dsL44O)_d7E2ZEw z_W2xc^pi&%?^Qs%Hk)y8kLZV}bb6e$s+!pN>@IyKqTNFDfrrx%o9E}H=d1k;tNElF zoFtf)oZD4<4J_rH%hz5~RB-D(BKoqzWh|Yls9&+l*;mdf0O3fdAiVFEL#R)wtmw>18K`)$9iuF?3XgAe?x}m z!(y;^(b2R;J?tYAiEk(sM%?5yWtrOpv9w=fJ`+SV6!ufo(O{xoeajgaFm~$-c~|hq z;S}yq#pg@8W4(-@;g7Y(B-x<#&xQ(7!gNRzkyYm;av2Cddjxm@y<$v7>fm#l6+`@AhZ+gB36 zKwF=J^7@JFfV*1%M5@w3pd4W1^FCv&M4mYGtvYFsBiDateQQEz9sOuh4Q*vncyaHU z^KLCzvBVrkUtlEWznQ*rC0ajnDyN5`=*ukKm-v?evdDr4+r}pDf(0CvzCN?JhNmhX zbGZ$!2Jtx#%hkxeBN(@L#)lm}@^f2}j%b07$^N4Ble0^2}4rq%zl@|2iL(WVf zCP4%n0SagF;gCHHggrJ}Wx&D#+mUFDFV@e2Tu62t6XIEBZzQ5{uV7LMUGQnX@wiZ< zU?>IKxt8QEvPdjXIQ)-yat-KEf@CrHvRH*>-tT30m(I0;PcHv{0q~w>cWt3fP|4z{F}D-A;xeG1Ng>W9uQHp6B+E)NV1niHx&4&d!J3$DzA82e%O zD!$9h!{Y^l7wT(ry17(VUzZRgn|8hq?-$)?D%xb^>AQ7KsV$rUXe(%K>vto1rxoxx z59ik$p4)k0Imhsd_er>2a7R_*-`)U;0K!VWNt?Oql_t&8oVQ}f`7b7drD6;4H_Nwb ze0IEZxfC)4{N7xZ6+A4y>sb^gpE?ch%_M>nQ498HNyZ1>sgddnyk533ID-SHRe17r9@&ZaP6SUmyZ_f+pyzi&s+XVj=ME&~-sDc@$#g4 zaY(DCEk@aU^I}Ym3d1JC2$G*{xGCOxuhR@-)BGAurUW zJ-5gdbNGUB@rR~NXwnUcE~r}@@*jr9atuT^?<4qJ19vlXOFYUdv7d;XKs;t4YI=^& zOBa^wv{qGKTI$h~REPrVBcOB1gd!)m-~$1tN)_&Ns7N=sR4tPE{eLx4!Mb|9nPMAx zbo3-(9R**F&lUQ@_iPfqZw5f%zxtRwI_4{vP}}{X=ar7_IAl7m*#)JvN*UgmFfTNi zYvN91YO(}=dh9*djtVJD)HuDfJs2pUH-Ab1-sUc#Y6P2^W@m9C=AiLy(|(t+uvWm*DVLrvnb5_SVZk2 zo%uUO8W|J?q?22mi5irOR9A%}Onq|KOQ`CY)p(-u6UAx%*<20(1=TZsa?}^`!^OH4 z%mIW=1aAf8KTD&leeCes_if0|=bx*udYXRb$3z(u_XLJGx8U?NM59#tF;$vHQ4zaP znE!#T^Bsy+$huK;n4qMTz(D4tO`7rtJQ;IF6<>C1DNn8Dm*UAAdf zeQ;Fkn8nQ9LaOUG}OMus^Di~%X&%=*)r#GG2d^>uX)aQ`z# zBEfU$?EN{Gw7)vT_Pfe8q~IVZJ51za@gscwPCt4DWuT|n^jGSL2RN#cQ1NK7yr1vc zi&U~qFY9A3K6bdl64#^K8v=Vpbhm_()G*`hePrnFLd%S2!DPtO!w2k+fvco-jn2O{ zl8RF#Bnr_1zJW|ys#UN}{0drjByej18_;jI0sdI+FYDTi3uMcHgS~qephM6XUc@Kx ztA&mW%1wKQvlIgig9b1Lh(tNB7Smg};3!d^Y=rYOR43lp{I2gmil{)lc|OrV1BoLm z3)DDqfZ$=PI$XdKFaW@gdxsaT6L;`mM82@~GPBsU-~X$E`Rw`D&pK0^XrmqqZ+ztp zR_tQWX%`u&K)Lbspmg*|d=2yPMi4+L4uR9SI)S7td<{WITi-A$a+t{tU<&$b`7Q`C z;)H@y!J-&VbwPu)0O>axmaHN`01*wB_wCOqPxb26keA)Z0b-w3??}FKYGm-&r*jny z)Fj=M)^gHU>_Lg~%jDzWTjqsHP5G!V$kUs@XQ~7}IZ)CxRh17|lCi~O)Y(K)zihYo zc>o!*-ALh3pk}X+wrnT4HJcI&Ole%|%aISFLN}e-`$Jz}VV@PK3)Z|C%7s{j@ML{T zUe4NxMrW-HF6Hgqap6;;n)4u~3#I<&TZ6caa@&(MaY-{^2({K$qACN0X&Z7-+4{#0 zle?v}?=N@ADMkJ6x6UBtpD=X2y6zLL`3&8RyqEbwh$0l3Ga2zY0sTEz;j9O@qZ7is zs!~~&iLrW6dE>TRY5T`{(~#38eQ)?d(agbfuv}?jP!@HCawt!6E0q z>E&u@(oTw8`4m&65}aG@btEqiVVk3tr!2v#gY82R-DrWKG!RVUE7mLK;&L1~oo{?h zD+lPva~m6+!jq#>kB5Gp6+KvIh2{0a(BBmVkSs8z;f4{V%UVR2eXyVx)$}Q0bw=XK z_SyIr=iT0KY^zm1<1y>1!{L;M8_ z12`6wJQHENl`AE|J)lP%S?b@2L~FZ_y{FAeV5Z8|pq1?G!LSWY zmIUzlUFWG@n}unqG&7SqJplp~8>Zf{{+HXL-<)H)?^Yn%9)5%`86i&&-$uuth?r<4 zw}yRc-Df-uH&{8mTa)&6ysG^9>23fiR2&dJogenn@9i~mL_?;NToQks+F*=)@CR)n z3a&I;Yqd|YPIC!1I?eZa9kK`S-|fne=gyyTbQ+e0l7zsqV zw2T&kIkE}5E-bF+C3n8*UKR?g{^C1cq_C2Kjir$aWyE~$VN;Xv>~22WOZz<-4+UE6 zRKEYvKww>N%qDT9j+yq$XEr2MD^!T_6I@#nY#oFF#XWO?6yJ$9Or6d3ksycsA>%km zmB;$$R=~5!K83)j3!w5h>b;p0_i71H8Hw)`%Y$7c%j4f}Rqi}tS{Sl|e~txX{yyRq z*7BIV3-@e`b1aKfE{oG@Iv256CAKm5%{P=t8b3IK208UFR4#YopX4qjdHyz^DeGbh zWB3;KqWCeT?Z!)ySoDjlr#Y-7V-f5K#B8Vp=RIxwFSmjEX;OOEDlniFZjb!LUe%&M zHATYc!!^`~ek992zfWv3oOw^v!6 zaPJoo$~?O^zai_eR3dqPSj_w6sY-?UU5y|4nB|Gjn^-P-P*&_})kb`i=4z@%Kj7yBdD<_v~Mybih3*Npv3+Ok(n8e8Qoh+zu-^wj+C~`E=$s!K7>j*~Q zMJtYJu)r+uMTU;&v>Qg0faPA(KhfOlOM*y2K{2(H6>-d{i!oikV&t~=NM9mxlKDs{ReQ2J-CRAi7{JA z*}!&V*<0x8o`BmR&Tfr4J%05#4Y8@M8S$X?+mDv=Zq=@=J`Xxt7(_*}jeXpXqX%wG zpU*yMZ=RFoOswmsF(H-&gR#WHT)h4Iq zN-5@_U70;D8}(gVeV>u0DREYL8NVx47#FrI!A^E;u0k|1=NVtY8-@2_>^ z&THUu$E#eZ2#q9@+Mz1KVrW-k)n^=c=_}v*s(A1B+3%#(-0z*O)A^OFqb-nnvC}@( z=yoHzOOc^?o9VBv0SqGUPg6)t>9qck;dtl7*)z!qlU);<$_ZnbPl4}{^MoZ9YYt?! za%|8YA+B-dN`v_vl^yNA^b5Hu9742Cy)l;}H028=St4AVsOLNkFg#{=88V^5I8*5$ zZX^sPI5bZQ?QtM=)j;%hR`I}*fn8_9B+u$^o|XaPKxk`QqsC1Rmg6s7K{L!BbD9c7 zA0VNd=(Ho_)AGQYx7Y}F!ep2#&MfB}a2Vt|22+9$e*Fx>jC$yt2bp4mH#+Lag_-i= zh8(@5;NU)-E7t{Hs^)&3j9oRQHfI1MfG8A2q!Ca=KH-e5V|Tt-b?~2~p>kb3OU}ON z9km;46D$32t>ivv5Jd5UTkQzKJ-_WCYHS@VGIh>JlwBbY7anW{OlQ%Uel%mR!UkNe z?bDJ_?cLjT%9&hjzB7jrwDS-LRhWeGMGxg(J~wEQc1N#419Nv$a6izxsad=}m_A*N z_p1;rqWU`DfzDy-ZNh~x90Q2XMb7~e?9yLX^4Z?Zs%ewGrdc+ASlgG{E2j$fRy_jTu~whElMn$T6&dIM>lfQ(dN6A`@gO)-ZWWv}afym@OtQ zzkuzq10$#=UE-W}>^%27HJr4Fb4G55SyOG7 zW1HBO`zl))2%uSfu6_(-RR~RO)rIw!ZS@42YAP^`o+wMQD;sjbsLS9#rk(CrEmYIJ z;jDL#dLZFD)bAAb2~xH;L5B%JPfEa8Yr-%enjz0 zZuAh4&ZFw8t>&#@)UwJ8OC@|U=h9}}fu1BPch1r)++3g2YA0DPKY zJxsW{wcjXP{!XRsom+^EbdmDm2!bh111u{}M1@J(@n+9SF1-wzM+9#?3we(Y&CmWp zJGu@|N(bx04)aZqB)G*0Q~X3z+KY$w?jW~8pSI*eQ=D4zN7R1zx$z1ju;8XU19(=$ z3Cz$Ms)P*6`9x0%Hd;RD)mBT!1;{rt!;$*iz?lhM9IR?m$JJ(aq_8#mV87ap;#%-? z9UG@Dlhxfn$I>(mFy(xug(=APm?<=sc>rXZ{BgX7ELc@|Sk_v^t6`fdienrEVp0Gm_4U8FSf*{d7@T9q(L{5RWG5NZ;G0p=6277s_t8 z|9bfb9afkfDt3}Drc}l&D>$o$&)WfH4CT9NPnv` zXpC#lI8@?7cqq^_EV;(oNY(;vpj?N^Ed$63-!X1t?t;(t%Wky625HGj8kY?k^ z-X+OjtP-Dp(y;>nm!k5!otiKm$~=*c79hw9I@g>#&%UAd%nKNRXaMM9Tk>*g<~VDL zi^M|>{<-B&_-oJ`Kr@fyzk=)a(ad}stIbwI1rw+-M2UX*P2~OIZ5_qm-`cZ-QqI7Y z%bPJ%s-Kx^19*r>kBB))Na&V@s!q{;x9neiN8e;jtGeLn2B~njw)}2IG_HDhyCZaK zvSe3Orzr9#zs%>PfDRpH40C;7r3Z6GAF6Zr;J#$|mu~=fTWF#AaT7ktF)TeMR)R>NnDh5KZv}#_Nhl|;N^4_Cy z(UF)R$US*UwyM|5zwR3v8VYR4b-Yg#;Uc-GlkTeu;@~;u6AB#>amMjjc~(1OaWOTm zD&2Tzdi8YW?6V<2RH?_LaO6SdIYPn`!k*6m{_% z|K(O%ZBt@g6%eatA{NQ!o1v6Fw6xawEvR1<2_FRt(;d3js!Sd)XrC@;K23zD+sYfg zn|T(2`EP44veAVms2cDI!CGZeWTd{4(ML#8$SxoznDU{xMrri-dL zYbEqytbbbQDFM*PFas1uwwHgoKFWM{lD&tJ6$~ZKYuHooJA%p5R{CPEa{o!fM7wvN z<0YbwL_?UhvJ5q5&$sbaoTVh%|2fYcImUleuI~E7?6A3bc^B`X0~3}jBTRQ(3hUa8 z@%(Poo)~MH(nfL}aNLgQi*x%>Z6OI^&vcA1cnknX(fI0AN;W+{*drsY0S1otD6FJ{ z?8klhLGs!?g+-|Cp9g~c`82gre@v8~fpcDF#`I4G8kPHxOq7W;lq3lV&rAH*@HO!qN&(J|Qu@o3C^=EK`MUVkw7m`fi= zCNFd_GKu(yw8s|3{qoB72o2_EH;{CF zF05A(d$%sX$}_GyafpfnfNNx<$gl~Vt-(En0Y;}Y)3lf1)J4@vr2rzxm-($X)+_+TwY@}oh6naF#j+IDASWFpi6 zwX;{3Sv&VbA_4A8N@?NR}nairXU} zdjE3R2v`$()G2Z`BG&llbP6*OsMvfY(}+;t)G3m1nvp5xJ=Fk4XaUQ^oEh1Pan30U znKP8H7l{U`tki+gRzK`C-1rc3S0Rnu00?krWDHbApE%`L6}|_{O}9FFylN+6ltd7a zu;LQbv7(qD7jJzjs@vK1iW7IQ7PkP!>Ak&e1ge5r<`Z zDEAlDk`I(~S@OzF=Z@kN0|E(dU+>MhHEwMu@$i6hit!oJ7F#vwrz*#?((yfT%vav-vtx!K)Js!lR})5gk!FZ2-Zgsl{#^F)a**m zx5kkl3 zyj<6D9d}j3&lP$mFw@6H+X*_+WOSsWTzd4@?+MKy(V(k+tK)nU3h)%ztGKNTed^ff zX9NredOx%F7Cm&0h6YC<;`u)DxqHQOgc7L}oKMkceLIubVWrcT-}7au92uXFwwmFlu>U%2{7mm1ec`l(qB0B(k@1D3<-Z&6H?P(2bBVgG`Voy}b{K(I+RVJiM*XS&Wru-C_CubmgRb zr<2yaTv)QpaQD-4TLsMNQyd@@Uh>tpPv|ugS4@F)pnCWIcMTnq z7eOsUU4x86dg^buFstaj>P2*FZ2~aF|G40xVRn+sjgk3^XaThSV{l2&G~S=e5r{i4 z#)zk*H2*$~xHw7oRc)t7=xs9@)@oem`v8&V%;|D?$QFqf)X$XmmMos{*35qDmxZz^ zS=htw$79n@WO{Oa6v7}A=R+$Yz8azK+tYlso}&-QP&eX>#g^e+jBo4`W2kt~_?0K? zR~;`kp1;)R+K?1>PP{$WF3g2v81*deg>IOm`O zF0F-G)9(%Ej60L$U5IQL{a)sn$*T`BZYzBK!`rafAVv3iBQ&b#oVrefsxlet4)IUc zT9rMI9&j%xI{**-Ecj%f{oVKWwJqn&jE6|db}U!260ian;N)}$X6388bN|a;r+*-w zXD!0*riLr^6K89K+E(Vvs56sP<(+6|n_GRR>z_^y&h$9iOM1Sco>b5GfsX(IoxWcBU`=P4ilOC26`<-Med_(V;3 zLn2KMwg#ax_V0}6aTU7N#0ozWHCuyxP(5R7MOS(excyY{!0nOlo#nTfu1{jy1AsbT z*K!Q#RKw7w1~A#e7`8@FK{Avz@2_&>oq0PMw;cMKWHKDqVp!+|7lxg;E>WrY?SB8$ zD=b(in+?T0orpUke~lV3xcLBZcEPWd&;N4tm^&WW!;SL;c^j$arT)d?OwTtO`6zAm zvf>AR`}a37OYWl~0Z4AXFF9vHb?(M~IlPjqgH06ANhY^?Y~X5h7zS?Io0WwjKq4LJ zGnIPcoA3L;*s|lUflW}>Hb$7Z6fBcDS=HBr)%4;YISddXK^yIXrY8u%mynU(9r4$D z3pL=4E|jfXONvaFS66$@Ic=D7Ka^YwHPkbz|5zOgIuD*}R&@VcAD^WF?pbGr*?PJK zldP*!O>b?nUdE?WP*TeWds!P6CiM!UYI*mKh>%K(RbWE8Eeh>|lc9J>VY7YOqU%OQ zqVQJt9u5+fZV(#zrDm=#%%SUq?KYUyHRp*bP9)hTSiq5kUk9m2gmfLi zO07{ty>BL8pRGuKhCevhd^_T8aTY>Zd{Dt%L^Zn{uecMY8BG~enGZH-^ul-T-&Z(l zH{_S_n+n2SYRL5JeRh8tHIVaYV}x-k(VCC13_B=EL`OkO(e-qBj+>vUVZ?YCMOL|p z)^1ryz^2U_zNZZl(=aTF@H>BB(g5q?Y~J3zTl#W=GGo(%*6cN`6Hp)B4F2_d`2K-U zs!vEbY~EUvD>e{A3ufGzEjUAk0}vt?pIf8quf+b4ef_=qi}0YersHjHRP1oewdv*u zF_=Ww3KBh@#u4*z8RinyxS!ica&gr1%FT4jQxzYQ8f8($SJ*8(TzJ_KA_7y9=$?(| zL-U6F^q$~HOr5^uZ!`ty0nR5FGH9roeL@a(&^wM7JI}vYwi5+gA(R2B4K@gQPPlV; zMPBc0_no(>5aMd+#tiH}%faNjTNa9eX$Qi5YF30-!u8KLVJlQUQ*r{Z;kT^5H}S9g z;g}j6Kj%Po?{KoSA{6*uHKJsL)VwO4h(eRbd0RO3yV2BZP3ty^U;n{JO(2;1mk&Km z60SZ*tau!^qf$(&ecj>5v!}hEOAyyo6Yz8W0fMg=F7dI)+VaJM!MQZq(q-vptkiX? ziEhskKS2f)2pvTe<>dRO&gu@{tkp}-l!x9SRRzO4ghBYY+m_H@#%oV7Z zSTGro6jAY2pLL!+&p*Vyk^rOrYGuJnuj#~q|H)n31U%#$J#rjf=jEn)t4Nv6?Tq?B|K`ws;Z zL(vcHe}Gju@0#qjliceDjq$^sIcU&42ihfa*-_PWTMpVYu}G)Gs+kki)mrTQ(q60x z2tV7X+w!w~_^Y4R7K8lsp%vriuK%X3*H!lA;r!+>Jn;;ouad*|Yl$uKeCL9{;Uhv3 z3UIBieWu{+D0j=olavV%lTPEwiRv+Y3?!c6Wb%fCT}n3>^M&SX3vsnkLs zfqrfJM-e<;F}bjcU!(5Iv#ZVnKH5#;VvV}wOK$~7os0?jJKMYNNjEiZNjwcb27Hw0 zYSZuh#Mo!Ptf`(VV7Sx;UaVx*MqlfM(>3QMElXe$hYT8@Zd1U{l7dv`4{NdL@~XB* zY{=#+*jK#|9NN`an*?r%!3ta5-cXZEG~`+lr@bqeYisl5oC)c@5)^y8V9LE#J~RAh z>z3>}eLV2fT#stnSS^J=+?=`r6Y4S|>i1-{v(5t&+*$nTb@)7qt#V?w9&{; zn0AfFhPD%% zZn(FY;t+F`+-0+*ZsRRs%wXv|7ckPEZ+~JEd`Y@`)L!!0@Anj2^3Z6A2yx^sZ&W&~PnZ?7S8 zUp>(X*(SvZ25b};iIV57<*Mpe8I!41TGBSkci=E#ZW4g_@38GGzlzzSPsc2 zM)@*$ak3PsIwEGQEpt|9#gP zDWp2_pEWI6>cXKl`qJHVsa!%m3fI7i%iEj?D6o&KLmq!w)K=C6NW~)0TyB;SszN{9 z6yM`#KPx1x8Hk(4!#uid5v+$c-Mh`c+I;MvAHetZ8fUcoNoE-HsxLXkZtV11K!bnV z+4=JHbkKANf-dv>FE&66uNf4E246U$E$(h53v(q~b?JcxqMcUH z7SUG?BGO+_jL@QgIAB4=$4GhMt-vh!6-J9;55Lqn9%Gix`&*5zt<-aT%fr<-VT(d6 z9e7u0&vznJh|)++)yMRQkzP%dwl3v<@Vb+XZzmGMC{+)=llxJGSuH?rZ+e%GiHE~7>>yGtd}q(GItsL<)AJEWgmG7w z{{6a39^J5fql#A$`gbxSYZ7D2@BJ2ZaY3=4?iN7scH0+n)E?3oj+;Lac2nOePU2jf z*Eg44Zkk>diw{+@C(JSN7}_)iv*CscmzS$eul5x7tPo-ImFhNYP44in2mlcK!ktWG zuQ0ky0|XcKYE9kPYbCmpWYZM!-+7PQUX)2!>1}BUmRdh8=k<5Dp?I@=@bqzmGar%J zsx%6&(atyQ%pmK{KgcSs@@g&fzp;3!Jqs_p09TCL!4t+=s`;|$F&nD!M;BRr zIu#oI1QARIC z-VAAre~^BpJVNQAs*Lv^eD==lPw6=heK5ZM1x<#Yy*}*)IM6Tkjk{h%lbg3pT@N@e`C^? zK`OX<(Y#V;tSmxMZ-qE5+qeBR@b!ky_*$K2H-jc5na1o52GjMXYVeyT3)`4Mg_JzS zh>zqAZJ*y;HW^Kw%NlHaeF?|djI*l@P0Ns1dvIl!NX&y5m z$!D8u`IZrwsT9~0rSPn=bvgm-mepq5WU&~^Ndk81c8S#m$h3`=0?SQ|UUyP~*uQXa* za-i~d+pF);%B89fQATbrZ}>e^%GjU4MS0p(Jau4&b^-K3P95vnHTKCm#$ZLs>$o{OyG*DW2mqmRkhzJRF7-%rK^lYSvz@@fQ{NPTs*2Y->24*m28To zVq2Coat-*gnyh6_U?7L4rK6#mwc4> zZkO|*vXzpp4AC)~;vaR3eC!%oku5y160#OUSPZQw;hU9y$sp9fJ@=QjVH=g?h2*P5?0FI}^dtRB0fkZNVd zgb4%3u&^WlkB4E(uj^fD{L*Hne0io7n6^*3Nkfx9fXl8Yj`b_!Kt@$NqwJYmftrPj zL>xQC^z#dd`Dpe{U7qh2&Cq;pS$$iapN-$uEi1?cEs)O}W&t5p=~vMb>)3fA1;h+1 z&ejy~34F|s6xLB5%>%d*y*pWR-fq%c+dfZ(`O55mXGp#&y@qD*z_UP154*M3xr(UM z%3P+jXS+?~mWy0TMLc~5oI>6{IAVFr-i;X;GsCdCciiS>y551sB1VP-8$2v_9Kyh? z)ZUvafs^WLOH!0ixt*8Q)rG8JMKo!-g-?w8m0v)8GGXXpIm(FD8xib=jF~MHSAFc);U<7rP_`y>r zP!7tF}|8an{>cD*Rk21Vj~;U zA|kH#@oLG_^lkqbNR0}(f#W`m4A9fal7byv#K)u$F#;~JACGJ=a|3I>OL3A<`W9jU zj38Dd-Kcs-DKW-1k$)6YFhjdH{!zSdw@s>PB1ThS{4X6kNf(+jALc?EGyP{*UTbcz z(?6zXuX7?T5=`(-eW~-pq2il~qKlQIFJ*&6EPdx8asVD7j1S<)h9TVer&a#Ydq~wY zgApA=ic`=|y(azbokWaz%(F}sS9Z3!n)q`N=kU31N!|xY->Ikr$}1n(kme%*N;YTC z?qPsWYu~?~m0vX;?d|qXv*6pM%=;xYk$%TJ`WcaYT(a^E_zc}C_=0Upn)g!*J2IfF zSi4GxIb#au65srQu+U-vFg&KfFcp9AOpZzLHp#EHw zXnUuL_cI+$<^6LSdW2Ck`4W#P0TD*hQ{vAvDI#$aVF;bn#UkHgkW*Y1#znEUxq-(vyC1Y{*8t3Zf6bZcP z=}*`>ny#%-iAvBx05PMOy{xbJgNvRJSM21%w^1|-Qo06@j-7?_l1&437c^F)b{%xD z|6SrMjMym*P)u~kNU+6O{x0Q(J*EI@L zxRHV1s4>8|My7ABCeM3!jW1bss#Io66f43VA;eGE0Ck<3fc6{>y(ne5O1W6P55tQ= zPcl?yDMZP-o^<9oT>PnJT2=Q_9O9v{YOEPeJ$Vo_wb2G^3~GMIdG2@$WYL*Q$4KRE zImDFrjG`aa>OukItJ)lRDB{KQlZ>_JN5%v!T{jkvW9bX^`Ub**E|M=mUtr<4>7PP&_g<|gVU#_ef>^%0dGDNtx}C@gmHwf#O|tJ=)7r(h z&--_D_%&)pvG(Mr*2U$h7U-+dAZnRzBj=49(tAB}a`xvELa@sDH1{#Q z$TUSHm1kAP{W5yt{=TgMhZlK=AsX-bLlJj=gLxr+lsLJoyi;Rz=egkM8@2EZ5MiuE zBnRM;z&L(aC=84UDhNNyqY1{9e6rn&)Cw#96lPzThe)UhzyZ0GZfGw$^Y+BaAf=;` zYZl=Xkf-L1$t+1P)yyu-4D}lSu4@7`2)N32y#Ih4zZ@9U@6ulL$>?WpM19T>xqdcx za={b{DOrK_SI>3IfR>*eqIt@mKgUXB^8)oB22gIAEX+Ff#uF|VKvjr!M z1}kGB-lb(_J>&B)mMcr&Z8^Mj@hhwMOK-K)AcR-|Hj@wJ+_S%<0}8YHq|be~ZWe;N zFFi#NDK8Mt%!r@A&eAxJ%?`QA|IHw|xEos|CepZzS(zV-e8e_;AO7SEz#&_HU#P6&sbW^4e>DF{?Z)-8;{%ZPF<%Y3OnLJ*sa_Dg9ikQb4Y8MD!J*{9YPC5+k)62S*U;!+>S*tZfAg z@n>&y90A$L!ECU>f7j#E^9OHTZd^$f=G3)Pf#9YSL*+(QSNvLR2yS40(a!c_@zIXJ z9t0*;W_P@ysOs&0m;&}feS*h@86GSleD&=y1?t~%BkL-5G12(rb=(Ekz!n{!HD>k- z`Wef9R-U9O%X^8cb!#W!PNKp=T&PUg47z^$KSZuERQG?6hSw^tVx5qyEl({%bCaz{ zljbA$$lY(GQE=w%?Mkj@E=@(RSjkfR;50AWO?3nj9$fl&`gNmh808Gb=k3{pWUS^$ zFyKv8y&n5F`Pwq&9K5Yg1V#TdQGPHjDTFMgP_GrWo+6X?5Fva9F4q_K-~H&C9DxB6 z{&aSr#!4B2vaWWA=%}me)(cj`v6leJyP}cH?xUMb(@t})fqU62M|kkNws-ZT>NhsE zLC$rbg?{hqoS7jJ9OCos%dLvH;g*ncjP)5#urq^N9uT4|ec7B)59=WSl$J$0PYZd)m) z{oUU2oy0hO(|sh<|1oTrFOLkrLeT-~#$5HKw?v({XuGuBbWx}M(~z^l9dO4R@Ew=y zDr$qwQLF;$MJIs^oV}Q)R^WJ@>*+iy2b<%}(M{2gm{hi7$BWtejNYgdwO4ID|CEdD z{O0~97);d75v%1oWL{5!GGax*Pm4hm-wio%WAZ!Zz3o#~c$(J@3X>ZG=VH{y^X7Uz1wwiBJnsIg4!;1#yN?^1AZM6Y zlaTK#m(agYS81qEVJl}U4lS5}$WW_Ly$4E+>os;C>|T3mH8_dl(=ZHd%b6x-RJ1uV zx!4E-T?{S@P>CT_CVgy1eTyqKV;)H!pLy_oAx^NJ^l$8lSe6#(yLbhqpH}bRaUZYV z0=w~Sfxm#rAruf-Md9R8_ywMx<+$Tl|s~?E(M>7-+@VjPE0mE7v2Q=%r+}ExQAEz-op9)a`z$| z#WvWld@O>CWf&BYMm1J%$6@DzJ7_s~uNjVuM5ZysD?GeD5CjSS{@FoB)G11$v8S|~ zZydynzp$}oN|T&*)#{3zG;flJM@6%&7f~VEl3bQ!sX` z-;J(mu<{D=X5EWNzlm+KU?u9S&iY7akrc#vHn_PAA|e6R-NX)!6#+hkUYW3gRHCmm z=f&m*oRdCokf+IrS8nJ@Y>5xf)49>&Y<*v{#&7Q|lvn`<+~7&Ha4?4EZ?#T9dvq&5 zvrNp)Xw;|G^|7&6xc(O?9Ejoj$>K2SfTwQpY++z_rYk#d>3i}-y!geWs|~gP6r7xc zEkqw=euw$A**U;`H1ZU>*Lm}iXxqz8`wDbjxISs#s*7iS5oNEF@(`J>ANmJn}MrDvI7_@)yZ%8Zv^|#+j9SQ*a>3aG*@3I5ULPO zW|X_im=uewSp0X5PRmw6JHP2cx(KBi{wh4+)j9S*lOcnA;a^8bT)@dLK~)6lr_ z_xh>sw6d|O$^U*XoYJ?Vt#o|i~u1hd2*aS zuWxUl16{ZnyLcvMncy=U5`kT)#J?LZ{`n^-HQp^G`fy}BQ&ZL9KOId#-B5T`L)#Jm zN5-TR4$*ycf)kL>JAP*H4$YfM<^O29s-QNzZcTAYf#NQuxVyU)FYfLIiUxOwLU9Vg zt++#RhvLEAJwb{F*OTv`IWxJ=#oGH_d&wg#JmJ2d<=W&ZR%FV7Uih3r&<@IWcHViv z$4DXrPQ+Q?f$D_N6;3Xraf^C}3ThF#+}sJbr?7;}!?f!7s7fcIc(g7nYl?=wk8754 z&0$7{?Z6*CiFlvIe3@>< z9W)%p=12^#{Oog!=kWP_A>~%vm~6`@eC6IiPZ#@J+UIOKymVW?a76XM%Mi*)HgS{p z$i9snwTD7}azpS$Iiz2j5a7V=HLYgf-7>2?ZW}D80HmRbO)rt@6CZ=OOh6R zvg2N(dNU`x<1i&%!C@?+E-Ijs-F`<}O;BeBz@gnwEQNW)R)>-3xDc#}KK$>DALXgQ z3B+0AlukIL?lf0~bsuwo653u-agD)N?ChGCk^MKc6&B@(jqqYYHuAVHANvt+L=#>! zYF}Rkb2Ib5{7!}Sd~@u5ymVH4;S1$N8L5Jpw&w^XC1;qpC#9|6M>x2Hd zqS%J*lAt$5<7gDtp8Mo+_=&S-5c=^_;17CI2^iX6IzVG`abdpaqPtQMdOqcdc05J$ zo_mn1T`N(lj^A*n+%0)b$;rkU0}MZU{4MwNfv5qEKFrcd0L$;$NROob2-()*kPcKN z6OC*BbS*~bHIc)G4+`e8Z)=ubWC6XqjsL06)k%fI4vRk;euK5$fmF+Tn0pM+`p+;G zL9B1DF*mo2Vqs?U_UZ$9&m*s)R6LwG_q+4AW7h1eirD*|mL6%(=I#XqgQ&;9%Yky- zcl*pOjU{c>sc~jbEeWtjv#YBD=PqMyLsjx4=$&H3_qt(61Ur($qM`xQa-C6hk56Ib zv9lYo`a(qiKAK5yP-yZGV;@V4Ru!%9VTqb&#B9hudq{RQb|m!SOE2PaIWN+7$T??i z6(ymzNhMLP-|z&j>Z3Eus!wbE`rd7(VyP)o;xkxWz6P0I+EAbSR-CLo-CpG?3=X3{BBuYAY1CPsNp^map^48puMQR+Qf5=(t|=Q2c-u3KXzFLTru;Q)C?Lf8{+;rpMU>iP$#ZEs%nOZjvndLH4Kt8wv+BRgKHQ} zU^bq|f7I@pE8xeuHkISfF5TAlG3&}YQi{H2n*w!vK*c#Iqu%et?uz_cFUPllfHj@` zZs$AC1e=;x^LSFwCo?C9|N8pE*~Lwya@l)XHA*nt%B85O-R*j2VB-=+z}S?B9VD_! z%2>bvaDgv&mWq3vX6LJ;$t6u)GX(*kl(#Iy$-) zz-pZ2xpd!lwBS@Crwy{R*ZG*ifPJ?0hU%BM!Ryr*94gs<$m`Jr57lVvuc`k53pwS! zhLj)P7=Eq7hR+g4t>-50FgNbt4;BciaDqLFZH~{bQVA^DKD9yteG}(x|5zTrZ#vlM zcK*p= zrjjh1yWptyRfj6Bb;b##o4R;6C!fO_Ve;s=CaJCtuV8D3G~6FwT>J_IllF|jUOmiu zK{#JUEJP7v+eODu(~UIohyR|5fIL+fE4~W-$`{oX#%CdjolV1ZBI~!Z)5ME7_%v|_ zXNh$NNl^_<%CxPGH(Cy2i+!_M$X=U3InH}~=6!y6?SNmRm(89;R;!(__cVs~RSKT4 zR!bQ7dH*nfy=7*zBL>HQMk-O77!ctE?ljUHsV_{5#=E@7Hn-7=HK3GUYCC&YjeuqC z45`)z)n<4=FuC8Y`h38ufVYH6Qhr692SM{hzxT|w8>M|heTnes>>q=PbgBu)@3FH< z!ByW)RE$yk8u|h;MIXziA>?12o&)DZ-1h%9<&ZU)7d=?MD{zYRZHl?E1A7|s+ak77 z0oOMFd7EQ?H2jA_XX&);-CCBK2lGiK_9^Dgw~ggrvtM{#}%93iEx{kBN9T6`hYttG0Q_v_71jOx;IFM7l{y5KV5>l@YMa7~7(p8{W!x z!#mALg_t8Xa;q`vPV-FoniFC@9Ef$9sSl-F0|AoP_(*%}H+U268#t*@BD|2j;l>KLFmZDGXDL z9t~4Y92bYp<91*(;VFIXB_51y-7xepmj8qp79h${<8FWZvcMCkEF{ZQxUdNz{_fkt z`W`kCyZQd|yc@`AgCX{o%Pj5O!>~Gd5_o+ksB%6nG~f8%=w)RJDnqU!N^9ZHbd-63 z159l6CczTjp32O11gX*h0aS@K2DOu;~_BY0jG>RenaE5=rNn<$zzAK%I?!(R3y_)=)g_ zXv{pjswF-i*P-~Ej4xdlvnxT~*%s#*e5_GuZ||X;y^1_ayvF?NhfL95<9GJ|Zkq3e zaj3E5LN?i;{{j+q@FKLhB&pAM(<5C|Nx7^J>)nHo#8odgoxA9-Z*{A>fCuU11Qqq) z7M^ppcK~^9nZxHDqAmd%e-A%4sqrUb6ucIX*Y0GufLdM|+Iis_7LJKC5#a z&R4FQOgzGt4}>xQh%!FR4{cD%WsVAPk${^oc7Lgn5={ox?TkoQMDPT+?*LL8Td>eQo9O{d=io1>ku(W1VfGb?V)3>foMdwOPwbRm zY33#~9wy7&%A*&d>!&MDVJ5gHz?R{HrQA?aQ}fJRFUNVqBSH zNA%>cl@-Cb1A7Y#cCX0Vu-*M1nOR-ek1jxQ&L1>Pe0r_ z8AINd0g>SDGoWUWNgDPEXC(}p)$YL=1}UfXx?1$c z1;Losq%lG9kgZ$@4{ zCnr2UbqKH7DV5eSp8gP}Ld-0I_0I(lTz$N5sVCY<#t|24gzeiqJzWv1PMDNdM^WOh zqp=7#l{Mgc_WTTe#Uw{=vp3BB+=r29`0*DI`#Uqv>bm zCi(-)M~oF5n4yoW(g~k3E@XxD@3a0N3*hZ0?S?5Q==bEShLu_Rx{kh+>w|=6isEuS0%fBqV$V#emmpLUFmKq5gU}6v2?4zUW)j4 zeo9RcwK&|KNYN~?EP$_(&6aE%}*7EFt8K>^o0q3HU zfi8b&$YZJajUYwGU3~8i8g>z@nr4(jMkV@9*4q<3i+)Sh(c`jPA8pV;4=Wys9oELc z#i%ik2{a(3glTP;&L|&;E+M~iA zZbhGn7)SnB*|qbO<{(Ynpk`L+yu-O9S_o%e2-fr*UKPtNDepW|Y0A9ths{^OSuLU* zcaa`{=O?F}TUD50gDP}o6=fa_fFXAa?@j)Haj&t%CK7381R|uOw{5r8e6lu?$YUeQ z<9x%R!U#{);;vti+CY9qqj#)g1vy80DCm`Cwbkcfxa{4+E_OS3@X;aM*U*n%nmN6$ ztd!JF{=-IoA!+(O%_kz3vYw-$2N`*lm+5PRnvM?QGF^kn zNA0&~Vv4T2$^T+qtb$mqpQ=1c=GzPO70TUDqijaLS?Yw|_@AHyP%cqFJ9j+itUph@ z+1Z(Db9x-=$S_?Lp!D<#iqdCb)Il%p5BWeI#t@iVt5t&nu#|bvy{su3106c^gV7U| z>LBU#1H+BxHxKF|KZo{()Fz+P4NX@!@~_~8PoGK{vORX|S&Vt_{!G~H_w+yqdV#0r z#YvuLX*LDjUQ3IxjPycI_Kpn|42K}ioEa%7!6^QeQR3w`+8NyK|FYwS=ixz;{-c9! z-g@wnRp2pP^J41G8)G5aIgQ zc?;i;lU%{_fg)W0r(4J}@1AI61(TJAf(7go%+_Q2HA9^V+3^}!@=Qfg3-7<`dyP~} z*TDJl?T@X-SL7BdIYEx<_tKe)Z{J;LntZ95LZ8^4O~vX3jkYtmJ4}bt&mJ&OPdcO= zDSc{qRYXgBOT~Qf6E^+)wjbLHO#DFZB7;+b?&wO3QBjW$Y=NR%ui|h3m4)as6}pfX zn&kKk%Bh!d=EcqdrwHXlbgwd9ByCi!0*x8w?A9G`y5Y=547s21(qrx_q&NiNl)1+5 z6uEpsh~M`3MldP`RrLM&Xx!VM73klWq-2w~kSn9K$r|TO`Z?04x}lWT7rB+-xSG7i z%w-DQwOP5pIdxxlh_`eG5uL8Hnin`7;+N13u?GG@hTU^79*-6qHhXinaH>XkXq+E zE=Sn1T9M!?(bC8FwZHpAQZt`?LU)sM8AD93YLa>Xz!ikBHxeG)0n zpb25qsTQ%fx6EqKd=Lt3yZV{HF3^Ak$nmxU-g2uc&gd|A>YlTa5s(F%n*inp$h<~4 zRR)au%+Q|5O>t~}WyVW`^7L@(D1qkvW2 z_@xqTbZyk8!Cgv@=Bj;A9dt*s`(xES=V7F2XzekRE|CAK~5Fm`T% z)wT6)7MgoUW-yNYl-O8Ao;UaBgSLsP*ustHUE7xW`~HOjkS{F3(~I9SQgq+l_TI$h zi+zS7W^m75;pprupLPTP~fW4>iZZl;}{Q{px0)5zaWg77+yDKNT7cfhjicc{ajQ{qYQu6xsW zxkeo`*(l8lfv}LfP-ghRQ3st+ug20O%xs;#7obc+h3}sJ{@+qVn|AO9>g!S{)gI)>IjyFNL zR9aF~4d~P3K)m^7^1IzjATOVzNn?zXgDNe~^PXVTPNBHdzM`-n7Lu*fYxkSQN&66f z6ba+rO7`|(QgP_)fCxcc($A$_T_Sx~uwPjW3Dqe0s*(D#hVN}^7f_=Wfj)^D0OmEOE^~R{~2Q&qwMURZR#c+=F@)#fG z0S;j9L_@%oScCNdDGJ5feC{@evz-ZUu2T1NH5m7_^?;kQ%gW?wDeQ56zjftn8|Yti z$tDx%G$0j@yQ8q;TN1+uin(h+t+4|~sc0V%7KimFEGgxT8hCct4^Zd8VKhPKi}7Sq z6!^%jeT$mmZ+xNikkH2fug!D8#gJg%a;?ySgfJ4?w(p-a349dtYh#T_8Zg+$%RB&xMh2jKswk$BJ~EW^=*;sxJ4x>JbmMb2c;vYfg1mU(fil?bJ7uof)IASUPG&Hd zhLjP0=c%)4*LKM*WzhK(G_%C>cJ(W!nA_{aQrLg9#byJbFqJboxS5XPclq5lM)0B) zy*BE5ZcB8o+a@Xr)4&neCEec^DtKw~^!gzI83_4K@{_(dCsn2sk^wb7$FOX`$2n0l zduk&p=RwIWOfBp&8FUOq}3b`ztmt)7!&P@lc$F6{*_i&vcx zP|HJC`sGGEz>yuyJ^9PU?$$G)IQ5V1th?2$3{TwVq~~ruQAI_ez9h*y*z3ubnxd$( z3qz&+hKM}6tSZ}XqFP4_FSq-iZPItp?%B@&tenqO@ZaA0{Rph{`gZ1eGXfPlmXB5I zx!M!aLpi=A$j|*z`f#8c)ORJVbJcxPyG@$+nl5OM4U>ut@u5zlO2Pc9JSR_G&afon z^I1Fq;&sv4Gl^@u0Al`LBzx^_^Nv z=kA)YpMH;LM3c5aSyWExChBp}^Udi(#3UO!x`**n`M)|)`$nbR`JwMorso~)BxD!}2m*ewG_k)g86Tfc(u>3lJPtp^PE)RPs9L%~X*-C(13>UsU1r*`3^ z^V5bH-lewT(Xf1)@O;sf64qaC$@I%6m6bewV=Ie19yH40+w<1g|$vmjG=|!rUikv&5p0-vX!p&aFRG zin|_=hOy#EIy-#MzyhU=(wsUvs+_kx|MXbzx%sr&_&nhaD<#KY?=B8g$h!S$O`pK* z({bP?x8PLHLCK@SVYC`zpm@CpmgS&XV>|2ZRdg`EV+@j2P?^n%>QPQbnp>Bf%Sb>-4xh%n#X}8TSquyHQ_GE6Ir4sdArOm*rOr)8~FsrxRQ-NVoc*IRr_rT_YSnmmogCT_kSgOFhQJFJn7q>3?oa%28)s--#GQnx%p zeugJBM%LO>tRz3CR~EleQvmp|rRszV8*EA>)!6yX^I1@x=+s ztpM)x_7hx&qanKc5p-5500}viJEApV=;6gA(?JW5UX+nR)z(T-t6Kmbkw@ zPBd-xUFlQjKPwx|B*YJaDU?$uZZaB_$5JE&4KON*oRi3}?wT6Gg3V)*8(+1zz1p{L zOtpCC2u6sONzEX8Z zrMR$<2nPDj$7md+9zFW;rQ7nQd!5P3`H^O5g~GN{xm}b)QixN*a2l7e8PVxqOLa&$ zOM)F)=0x)c54Zpw$PaXm6?v(qD_S)mOka3O0D;`mSFLM>U&vwyO5_`m9JA=Tw>Y_tM8=wqveXO zJ-jSzBLT51A(evRCvL#a3)lm{%L%}Q7V4#9tgu`v0-*CR%#H+*6HDP-FXL zl;3Q|c06F@S`}N}2U}njh9u_DZ2?m9$l5$#ZH<2+Aw9+n#P@V7|2~Wo$}LxHQWL-Y z1C^)62~p#>lE7`0P{94-5ldjBk z1d=7x8t(AWk3%q?@wknPM{v1s*UoNa`ody?{IkAmePeGc(%eiyl1w>c;$WrTYZ(E+ zNIR%8>Yl1pO620x6V`(u7m$=+&Xl2*Jn4!1FXxhhRMCg4I3IOcB^v2=ZSs}>tC-bi z$cFnTRnT{|_3MhT&0)VdA`&tu9CI|N2F>MFbM@QCWH7;(l(b;6yt| z7P}u!)PerT(a3M&!&6VPQ+q4SGHLvOG%hBW49{9Q8MUfeSvjDOeX3ytXda z4*XZS^x^~EyJgzEjczY96lebDtk3>yl!t=eRCQ#IhA=i->lLLqD8LI@T9le+xBr^C z?CTcSiFRLpXnctIfzXAxqj%b)wHSx9vvX-rt@9biJ0Wc`@3#e!#}q$725nNyXUOLk zXnVq&sPu-k|31)*yFH-w@?Jt-A<x@?~4tF4&sSGkqk?T3##aGB2AuP6Sd9HrHaN{umZUib!H zQZBjlCB?oIa8N-R&UH7dLQcUg(i*cy0h_40qk{{@K#mjZo~;-#jU>EwKWSxcbno1l z#+1H2JLpHwt<7rF$fzh`-?${SPvesU)#BDMtj%`1R6ronK}CW;$Rz9&2KzS4_M%Z5 z^35Ih`pTy4lZ?pN0p*)Oz4yBHW7Ce)xyBl~t6W=S(Aq}o@vTXt&G5A3w4*Hcm?{_a zc|(h3S;5YmMDM8`G5z3G-=Tt_$#5yP=k%ep?ZnHg-Vs7ErPn4bo!QtGuFRz1>=lJ{ zV&C=}IhBYbi#kMK+ICm30>h@Ra@)av1Rh?A?j&4KeDak$$@{Ugo@b=D$RFN|K;W=9 zpR{H?8rnqGY_3EIRn)L!S_(V@!v8SgO%v%Z`H4qb)LmCKWj`lDeU`@fU1fa9D~c}P z*Z7>R83C^37?J+w*0N}G3dy<{{|xq(?+p%ja(U6MJ@~CTDckq2Y6Z9HpF)8UKB7*m z=82)KEH2oyf?QN(*>ygA4x1y$vKqJZev^_n7?Z4mMbTj zp>anTa`7vrrciuUTI<_42IX|yhmGZc=V9IMafG)(VOa;?Ldvo;D)b) zrG?(Jo2KQrREE(vpLrCHmw!x59>!ZEC^nC;HN6Gvx?C#^FLjA+Iv1B8gm3nEc9c>C z0lNngu5U3GSZkXaRA_e|Y;#@UM-k&PlulaI5EY|20c$M<*dQ2n?_qp%dAURM!Y5fi z^=my`pVfN9Hpye5Y%Co;^q0y)24T~rt{H!~wwagbtxG?eoZ-p$i6x|F1enGraFrtU;{>T;{pKSDG8yVb#rgW%mG`oq~-9*0Tp?tlZE%}GtQ z(ZkwQMsD+2`{}g$P}aFTAzlRYW)SV&`b}2v4as|T?0Oz|(%b%ApytA6#2OBPQ9_I9 zj1WjzSeTfE?0aimfxIu9(dZrj%g^(iS6bh~oOM1odcv3Myk(ckOO{iUvB66A{mI(5 z)sP3NANF_xG@=7ZvBHLt53e(>6zhTqXe0A<^*d1u&6`d05Z2eHyKef+67VBkmkH z9I?YTWSVr?K6!uG9m&zc3s?~4RVhaS+zI#v01;?VFe^;!k&T$ZFz=u({UyPDsjPL! zQJ5Tpi&6D8Ow3$w)wEh+2@jA(TKh(wl^4*r@GdbIvrh`RRS8!%8@N|5cTvIr(xn~8 z^w(u!Ykkn~rw-_xTqz;AbtPZ^)3lfP&_7V>xbNj|##U@Gy!gY^n+2riMR@}BNW~1J z;@b*Luc;W)S;t3poIx%Q5&2(t?5JY|r~Zhep;YVj_f@7_5=9RGagKHJP8a+XhV+jz z$BZtka%DK6Vj{k63S{Hs-42Sz>67^L-EFu@b>b0D9e+;c&p&i`4Pp&Wp$hQb7do#y z*WLEM^tY`Wn4qms{HU>{Yr{{$;U?uX8z%L^RgKIiRHXz$?SU6z@kh2mx4pN_+b6oL z$g?x2G&bYVnyh*x7<71XpAC>t$e^8^cC^tIclOVLs87auVLunohwu8muP_&{wS)jL zomt4x^Pf57yGKBx{suN$qcy;&Q}~_SUAfF3)JUF+KpLI>q2$y_yg!BSBJ$_3S}EIk z_S$N{B|v|u8hxSu)qG68iMI*5dH}8uq%JA0e17uchB?pEgEpWbR|hbcH|3NFpostm zlHG78*QTE}MgX4p`p7I;?1;!_r6Lp-ApD$2b9Q%F2(~pMd!B-UZnKvwNTx_Yp_#Y;~2bslCi8$m(fg+-OGlq>TN!JFMTh!e(56nW1q1{1Hmk?(<68X5n3hb@Q9yH zy!LFGThpfh_@l!TobDT2OamkStV#&e4>SEasz#x-({Y!chY2*V6&EQtmy`!xbfp9C za(dnyv4;zObrKivzoA$VUX`T`AQXRC0^>TO(jXW!>Qw28-3@U?vYCq5vdX3jwmL>~ z>y$u{peshXQKlT`n(_E=#qUboBB099Ep;nyB|8wy#=mBX}By4 z%^9vxnCfbCo5?i+w#k+Lqzl^wqLo`^55~4TI90Bsf4kVdk0YwdVhah0=bJoJat+m? zd7%y!l{biNSGym+GnzE^dTrS8Y@R&3al0FXU1kcW2b)-q1VVvt`47wgP&DxL%{^?= z0J>lF*R~=mm{lgtJeh2|pfC+9YDrJ1U3Q3&-LGa?_Bd4hK})bG`S;)kUac97U1`TMzN+sOfgrx)4b;hi2{O(i8kJ9 zimOfukId)|7saF*v+k09cpLYm*KIszeh2wr5;L8)< z0@`>y&ETB{E%Kc|FZ(?lsqp(v(aOB_M?S26#ZV!_!-*Bi;aSW67ca34qQ3wFfa|>O zI)Cs5%oSq#CjX?QTe`gzth1M{!ugpM!2^VLzj4sGIOArFGW-WYcDeBq za#}DBNcAUF1=&pOt(bN@`*g`cWOBKXAYW)3ncMshhVpK800hA8f0$wlcHrNdI{srd zxXO!e5Gau1w|6cjHhh05W~ihKSAFMa>+1KWh=YGw;#j&YZW+xdnS^Z_ZvS8Y!X>v-+0;n$w3 z*h&o*%KKvt5*b;f0@=-=&X)=6&Vhh%$$p}t*l!$9uLCBko2Gb?@N}QhEA43W!`scQZmxNd-}46}fav{E>I{+Eiq)6?J^7 z8p{LEF*5t?IyMAE*usi!Da$04u5Q)*TQgO$slL3&uk6NLHY16FB${a6JDNuTgS>Aq z!O6mHOXsWT%Q{Iu%4>6)@m2l!{Yr~djcB@H@L6P={*U)G!VE=SG!hAn_={e60!|Er z$u-KnZEC$@9Q+{kL7cm;x+vqhG>@?$1^5bEGv7?g6-xS@_hIXKIRB=Ov_9Y-Znz$T ztfq@43kpBe?lUJ=a=);)7G6Z+V(tCZ%{>wwMuI=pt$9Ljamp=F3o#YBCcHA_uiq(? zjvm@Y*LanJ3%HAiaDM2r2ChA!LRyYN@~{_NR$ZZZO}^#|DH-h@Akmj*=2r33-~O*_ zE~D>|e1&q@{;f4aTiuoQ(fQUp)$YVQZ!_KLCUFx)B~JqSH^I6v6@a9~;MW?}?kNPoR2xsQA_j=F z*29P~Db~H`n*%Z@50aE0G}xD@Z`37F zV1^m7GHNPoF?t@p+A1rUFM%?mle&h};8NUMH**NrT9NV8i}2wC>t2%I`KR=$y)AZ@ zc??ETEX71b$$<08F0#OD3c%FJELaFPZ&RB-!}@MoQI99?(5@6)FFr__F)f~?J_A)R z4OAZ9GR5ix-#LnasO5KY7tCJnAwFf2ncRwx1YSsv^fKX zJ5oFcXPkLkI+#5?yaGJFYUddA*fDEbN-L`tkK!xp?CnQ36;RCbwEu#)Hg++`>I5Ih z{`lhHIFw9-l*W{4VSmh}z2O2n+2r&amNN4KRfUcx%kWqjz%eaU@PBUkc@wM#(XNBm zv5z+BFUkvmVq}0GoIk#nE4SIJO&1$Xv;{Vl(pFfx1o|b($QO(1+R*HVJbsYik7}a1 z74Zr#4+*SkyG$#Qc$-M*OgQ&HGmJYgemC94v7{B@!XU$fL-#8hH%XFE2#Jx;St6Y_ z+Cj*0Rne%OYix0ord;nY|IRGq35&VYq=opP<^Zkx%z71tUf^Vf!1p7S!itL8=Ue}e z3dx7D<60PD!1wj?;qn49JUHNe_sxgy&WlA^RuDe1Q`fhYM$Hu?gqP)=uxIdAV2VW! zuN!^i#Q~+*q%ZCGqOtH4Lmv0L_K%@`DROXNL~w(x^2QA4;E^L?Fy(J^_k49KfjK6T zB7^6HzdfW5PNJph+FNgP_qe2FbOmM53_y$MuviV=iK4iTu){xo<%F(Cb`_pj4a=?g z>1FE$ZdF^{ysp+?%ifi}#Ob0_8H<<;wATG#1sL?s}U_Y@U7WD-;(xepS-P zL&-$dT56-DNh&JTu7u(;`k3~*j<&`AHQ?(euRm+ce!|CS?t+wc)s7-hV zc;`+WRy_(|UM9%MStw6)Wj)kSFmDLg{vc;D1w{dp34xmU*9`~{dmfVRpc_+L`geUi z2<_o!DxH62D>Z2LI17_FKB++CG>2u9I^W?la@k6xbHGk8OL)v^xv0UcLi{Kom(uz$yGG(){BWTb|mb zUeagF+X_VCv_YTYj;(Nl_YY?Pw&2{U;)gh_pis?RYoD9_o;kz7-k6@0>+dbC&f zU@<;7n8gi8DF=%EQif8KdD?j^3H51rLksobzkOq9bGaAINawD zokL8B+65<_wED^tGsp%nfU6La>C8bcqHOCnlB~=^ zl2Jd|MLVYjxb5iD*_fmU=Aof+Cx3*OP5U8B9WSgt;2W(1NDG~eb0M)TB`989lAqIB zEi_+jmetD(Hfaj4BGU2*saYbvb5iGF`e)BRjSa2kh#tjp#hN#K*Zwd!KTnSm@3Ils z@)-QODgNr%{S+bWuzNpS0Z@^uE2ticU34#EQk-bKp(tg@Kaq`*sq$EDL=cjaOL2cp zMqU$gXEP$$>FlN%Pj;o=ajDj3^~P!p_R;1S@O4X+LwTQ?Rn=ANrI5BAYVylEr$iNv z9dwFWtN&~BsWI*Qu@E-;*n#4&djAC!XY3Kx6f;PJ0Oj*^NA!>dD}ozekoc=@(A3MY zfhJWRIh)&E!ubI$q_(K5(zY+ygk_(Ik~muz$ZRsP4y`F&75-7xv95czD3c#GKI4tkOt5{l0_m=D83)vXnURO4I=6{lO9wWk7c*&inbIs!z=-WQB; zE!Z!>2U@~qPJ1Od0@v;qKOB4JR#YTMf6+^dt}FixYR9_{kCBnq4rkG1JJESYHuwau z!nM4pv-@oQDOp`}PTgvyTsOGYLQ?cMuR?5Q=&D*Ckq8LJCHpt;8awvL z=C5(|eAD)FL|ng{3?yh^fqgT{k9gW$%CcpLQWfaVqh-{jv>F9mh4D0iYiD_o8$5P#^+w|POx-CiHJ%s(M& z8{4*`O8bP_*Gn`R?aGu`c+!PFpzCsPZIbQ{Q2G+ic&~fq0g$fQpZ9t$22HcC_@}r> zWUyaPYlaUQF&m$D(N&qZR^S6Jw8T+4dol%YBiVF_M*U0unvLx2A&sGeTH^;%_}Wjy z`m#bQ8T_iQl0M+1JmWe`+2IroW0c6|v4i%2o4_x54;?)gTOk9vb&_RS5K_m(UHryR z4*pYp$a`SJ+Jj?KCxFB*d+tlUFDs^wos45Q-ShJ>4y;saC=^ojGL=~g`YD)HV>ZF8 z$B^JQXc1BybZIKM928nVdPGt+zn)$!Rco|35wqz8NJa}~U%#Pxs`~WipsUcizq|3L z7^fTZDZK4Bt0{xV(Hcj=m0*|9-``bt!5RVwRzz&$o|s%Lf=lC}vWj+3$9ou6`W zGBaWMCFtT7UZhVF+6m5fF`a8tSe{+l5wU&B;e}wdrlD?dtkFFAH&t-!ecV6c35mP? zoJ_mCK)UB8{>(-#HsMb<)zVnjz@}sRSVdjs|cZL?nmT~2H{3Q2v zQ?en_t4`V)I?bPFo=vL-3 zSA6je+L(>H1|twKJniZR@dYhv-AwP1@)|xz^1i*lVY`4%vitq_gG(`Jr%yv97>m31p&+(o*9WxK^?U z8@`ZkLl*`{er5d-mdbRUOsWGID;J=40`Zc~pzF58*Pu(W`BBl`O zyKM@Xl(UX4DW?i|w##z96dX6jI_q@@d`M$&%EU=?I9L0Wsiq0W?ORPDcbs6Orz3sMPilR3=KJI zw(uKy;jtO6eUW1#CStBVWmq-ncoEjEaiMm2{FayWiz2{A*Li*(R1`N1n)G#vxh@x_THr_K1ViZ4DioG_A&pfaJDFs~P;vYJ z1It(V9r94;rNNey>9q#@JVNfr$3VL3VFWlr(YS(c&%G~!zIUR1HlUcT$A4b6Fpc0J zqjt%z5x*SxL4xxU9K&H4eq7nmDJ-9-uQ8rs@g+66}CLVKz3gfz_ye`~us zFjA<;85aK%m;)cZjk*1B%h1h*29ju6x*SoV6280;(*L45SSWKP7)d*5J8qAB9l7n~ zVj@+?>EYBXlEr=@^TsiifLHGQ=pH9wqUyIfgS4jW`B@3)j*?{WUMBYd4P&KYX!$&P zY2K;CHj(w0V3Ol@a}%}*?eYdGFE3ON$_brA^8J*4@Hy!Djx5uyXK4=Uap~<}b(KMj zxz0g0#&qM6LcJ?C=Fj@%}GYXkd)v`u`RKKezVDK^SOB`1qn$=q6FksgeS)G z>9^3SX#gBLY$B(nXctc=sAG9n9mjvCCLVZ=2r>09STSs7zkeU(tF}~4UaqVZCOEag zC;XIt5#3I?28-Z%?dM>{_<9tYzD^?AkinZq@R#Ygwz7PF(h>W!vs#-sgAk>;41J z>-qYFH!Qy$>|82tQ#LI;2C)J>f=njbImd;*P_d_S0sRqgX#3?p=21%Y#6kJC(br+C zFZ>ra$nG5)#RjZxL9VY$OW>#Zj6*g?Ui1}UCifBcHHVcs`S>Ji^eWm`t<-!u(f%Iv z;f{jaT3j{x;Vrg*Dbh{y5>dVXp`@bDxN~^s2uh7#D70guRKD?!YFM2#01}eT(8=aN z=ID^ZA(a*4%UkMj2kScnQor~Ptg%z5vPt#gN45i}T54iSM+vfD0Px+uXLfc$gPd=nCYPb1eR1 zysKIIJz6mIb#>0_dG2XV&|%zw4*)8}r0xEQ$v;Nd=m(rk}A0LaR z#+pWeuoqqUVf`Cw(uvP!M{RujRc|$X(gT>qXgA%T{~~GK%86z|m#gjVktyGwEPFD1 zSA^6)gg)MfS^1bYZ2kbm6cNKE*LXBhS08>`9`{S%+l+y&t;{<5g0H-<^cc!qR$F6M zc96HXlYfrPihI9oFRcZy94g__~yq!|YKs7*3vFH^oRsGCXyF2wp{ zl!`ShR$`JIfGW;!W@3J){~qev%Eg>8k0X_yA21BYJ$?cw&@A4O;z`q)4sq-AG~VrU zM#VM#Y@n@hMpoFxmMy8kWqNfBy}($jrRsGesM^i(Y$wv5-a||H+hzLjtozW6gbALD zo__bZhjBl%{`|LHFm>3fWXRymm;m6Nb}-LTx;xrdOFq|sG}$~FE`$-uP{K!2C2ixu z(rId$gl@NbIIjGR&GNihkitx0$0a~G8hlj!?KG%^Jv>7s(V@Y||0U5fJOQ5y7o*6I z5?5PVUCXlngpw+(p=oJu22UG(XR|gqJOupCQOJeghjP4o61muQmbCOX^P`Az#U08n zs&omrKvR`rZ~w6%VGdzwRhD>s`A0>rMM+rY>F?fr;NP04;XFLj1zP3z9ueH*Sv~uh zqP779&g|V4vTp{+lwl3>@VTJ1r-W)jWCiM>JhmBX+VIotzW~e2bqLnGp>ca$oGl0n-b{-1?_F+q(te#^nipiZ`;Vq%FO{X>iM zxreg;flBj1II{E|UJ++I$tv`?cA+P0?RIGz(Slk0?P2xqvU%N`kn$6CzUSu+#lTl` zpC_FOZ|~D}pT?2X9~~$!Z266h;nyPZk$Ogv)`-+mbzcYR-VZJ{tJE35>$NKV2IBf zc@jTMv0iHNH-_;?X|cB;VD<%P`(79Xbo+a1OPhKB>QS5c;%)R_Z75!5!PEXH&f%Uo znomdr($9dm*!jzUX{P6GgRO{}}R+1HyuQrkR~NwJ5std@&t=Dp(f+w;pQiE9Nb z^)GCrT&sq)Az$tHMv%XMDEt*+q01KGff0jzZONrCJQX;(!oKRH;LollQie)tdw#NY zAMF1_MJWh}o6zAkKX-Uft(fbWZ%L?rd_3K!h}Nl|g_4;mMFBv1dw$_=y#Dfklgn;e z7critTX+5duT`PVgtuJrW!+x{+9puNl`;XuR{C{SS;kp&0BN5gg*i-;m{OUW6)&g) zOi?heX(Xo^CDZe>61BX_Yd%Wc6h~L{@Q;; z*fw_~ASJYBYvK^+S#IzNx6qi^>FCln%&1_cL>C6ZHl~}R^Hhhe{kbRe zDO)lBZEFqbekkpAu(gXD_A#&XR?_4$V##=I4^XJR#(i+~nfj6|*I1M@$HnW=1=Txh zE5-B1u#_Mhok3=(ZBk2EaDM} zMC{xkjy}pNe^GPSnbk(arZPenvNfIxPnt) zvHopWA>b}vbU{PF{;g?GuSA25Q_u}?ab}apUL|P9X3VZKMN#hKxc*aR>(mhUDYD*{ z7|i+-8J~Udqq4Sc{I>*D=ynlcThb6qYcr9q1oojcPi8(|N=3F_Bq^$$Mj1k@$`!H8 z42FE79Ikh13(Dy=$&6h4i%A1sz3aoNz%^M8C#;u`O0xI7`3k^wHpA1ek#Vb)WVK4B z#R}~x$y|1?s8IN1sX|=u-|5TipwBmc5nZTOqcw&Ro`ZC&2Udr7e(RIUjxa(t!=NTC zQL*4>>-4R)2*^{&!wW!gJQ z!e>#P99v`QdI);}fIz-Tbc@{SHh;cI+VTPS%c`%pEPcD>@p~Y3BO)f-_l3lNvp3KD z&5-zG@VhK^90Z;p{VwMNoWd@buPg{{=Su}zaxvoZSckc3+Qzd_ArltU1iQL=zV}Z`&3b%j!K0dTH zT|S!nMs`VL+9_^Y6qP9BnU-|5Q^_*^&iDH`;0{5=);Pg0^F1ZY$_5B0QuoRw`^ ztP~W*<_2axEezlT(G&6C*;5eZ?Hv1-B+%$BBMO0guW#I@R@Y?8HO!cDZtPAakw;RP z4johdlLf6h_%LOOMFLSw{HF{8UW{F?+A9MTr;Y3mLI+hZA_E@~2BNL~v!fz9>&QAE z7RBgt0jb8aeGRF+Ou~W$2pjQOZz97m)LBZS2c7(j1*e<8noc7gu&W2_4~PZ3JN+T6 zr=BRs_D5@JqqFp<#hR30Um>rPsX_nDeM$SHUTTZ$TbhGY!&5#bXm$Bh54*Cmv84Ha zIKl5Kp@Gfb!E&t%Ez;&jHsp4v$UA*qChdXJQpTUmK$TlE^T^Ae+kZWaqM)Q4Aj2#5 z;lO^3;1xPiF|@9{rZe@>Cje|(Lc3a zxQsf1i`JTnmj6N{YvX=_@yGfdsP(bM&kZ{QY%MSD6)h;OVtsY4ew5E|>Gx!-%}%$4 zY~sA2VZ^f#&tOsr_cY}gM$v0@h53AZ>6~>CaGAHp5DpA-ZQZI`?4Q2p3ju#f7~juO zvVr{`(QBI-T{tv>gqc4S-AK23O7o7DoKhJ`1_U@f21li17j=T#s%?t_C+v?f@}DKN zvJAV?TnOgoR?tY!Xph&>Hub|NGZ&V0KlH6VrK6_vAAh~?QHWjleCiOwNhgW;yW^I* zO^qWQ@Gq>TT0VD}hQIcjb~AHaB)cnsc1msm%r6wTQHtcGTNscp+hb;_Pp8WuNY)R8 zK)K{>oW|wJQ%Y1B+q-$stILZ`zOp$mAk^!>IP?$6U9WIBv|_(i2@cjDvOMbppiN-n z8>46Gq%xfmCDph`@s3Fj)ke>Ps`hmK7#ht98}c8X)%W)&)Q}DqlzjMKihj&ABNQ4m zQiyF>T;B{akJdPE+)4N^VAa`Hl{QRLBj^EK8Ym5g+E{63 zlFL16yoPs`&~wcl{YH$<>4fRNsy^p4wi}gmaORY#u>{j#{nOIYcBd~Qf&;Lnmp=Tt zFZ03KG+6KLKKD|FaWvn|kZH)N=$(rRq09Or*%am>?^qEc;wggI@ka?GoU0WQh&zQa zUd`v`@DvZcy|lT{3VdWrwo;YdM+nJbBU`KYxG;lViYe~ETshNW`CUNu=s(E zy=nW?R&VoR|5k9{QJ`svKiz7&ys@b4Z9kjR zd)7K46BEYjTrg+Q9njiJc5%MQB{1V>q-U0BaCZC)=fOjXs&7!5aN)X(#)4@qDeEgz zr&-JDlpJMZFQ9*nBhGt1@k@E!E?nA_Pk}= z!}H&XFx<-}68UCrC*Yu7d&7mBX!sPKL~er@rb_Af5vhmU2bq zucYk}OnDOqTiccEFY`F+K@}<(V}6dRp*fD4BK-yQa?kcZM!e~AHjF#ak|y%^l%oOb z%P`4@Xest7O`l1nQ^!{~S-yD~;{e?V^hlI&t+3xC+q~0D)*fN(@x;|83nYCls@w;^ z2Qql8k8wxwxWcIpje?`x;#{XzQk#r`=ymdIY8t|^C)*ci19EF*WFC5eh$&?4bQo?>*%cspjfn~tm_i*K7a!v=eed2d?kFlrx0`N z#Cb|p)s+f-vSPkJ#q4M{3jh@t07dzd(t&JH3@j*UCe=YaX4aSEM%uM)Rudj6fH(6< zbkb+%A&s`Q03J>FEd~j^brh4sH!yGOlf|p6*N|BzLkuZmBV_qJrz6l)~#hKUb z*ltB2i(1{uayaRSOnm;)xyGgu^$BP`hJ7&?RDK(l;HxtEJF?~sTquHRo_|1|x8UM& z{iktMSg_gSBzx)zpl}GNx_78jh|?@ro!6osN77f#%3p?|3QB(ySl9e+5=z9(R)^BD@NhmsZH<|b!H`l{ek*Axxr;~})A=O)*E78OMApSq02-UMbQ z0TRy-OtXW>!k+d97x=37U&ET{-;wrq{r3I>0JEeyYW5#2^7(nf-t`@td4!r}3`tHQ zRTcrwfxd$?u&-y^fg@3xQY>^cy0v-(WE9W8wL8PZ!Dh%Zh^k)*5$mZ8#dXzZK2%hE z64zzzM$I>3(toON^E{s!6_)Bq7`^Hbd`1%sywab(cB&=1qxmuj+93F33TyuUPk$lH z`Qc}6?N{iOMfN*PR)hbA*HD=@6)Oq=E{7m z^2sK zSAb7=$0ym#Mgx$Uv)+gWe@e>?Pgc#VHgLJWt9h?zaFs2BznfY$KAlyajZjcn6Q4A1cL-^&u~N;-#8B1;$#e^bGVoH~W^#A>vjWE42NzoQ){wc%Bz zLerd1rA1l&%KQDR95s0ic6@&VZAL|nW;s|7H}#b3Q;G9NoT`C8pDO8{-`5!BUQjRC zecS=AY5Mc~Pw*(+hVKH7Uq3n%Zi>|exA>d5j*|bBNnSbet)Q1^@X-sd&iUG3VzuJ+ zmu{|BPlgE#^u>A9UsWU$?fS+eBbf#s!Ds9KojTrx>9R#l1)#_c6cRn`zssub5i-v3 zGV$QK7?(<3)OmJ<=yq-DPX18~C3N>Oi>=}2CRFUF%DaDJznCf5?tB!*Nq#y_tKEa| zdg@HQ64Olf<>Qua)zZ^SSFBfZg*N6(9|1DWm%V<&%3;uvq<4biy6c&58N?*so_c&q za7U6IQ|UfbixG6Xi-8-Hg_18b-5-WqMn-r^@ZTLp)PRoeu|`trTMJ^U48(PXKcoq( zrR6{?3bEgZPq~8-A0(y7v?Xm^VXEd;L1W9N99msg^Xuj-l(s3PG>#&Tu--**slc>0SPMoa-g3HV50+`5 z%59$nczUP@r?W?*Qt4V2FK%Dqq52(;vh0DEgI&WFHx4#(R%bz?BAmnfqEEbW7_qbM z1f{6g{H9>=Vfup+T!+?JGNhP*Z0~e*p4z>s1>y~}C)3D97~QlqH!C>p5p0x+6aZUby*ul z(c)o(y+NN#;4#~hAb0@`g`<(5ku*jQBZIWk`nF~y*C(fmAnuM5psbd;Rt1X9Dj+B~ zG*9txG>5>viA%BCBYdnRF0a9}q>p4sQ=C{uZ8OPkf4Ms&e}pV=!WSgcEOK_WL3*pw zZCNIc*Izx@T2A0ZZ-&{qc=%N6?A7>=LWe8$m$=MgL*K*F!rxL*P?gBLH8xMJPVM;} zG&w*HmFB*oFbyXO?Ad$WeI`%|-B<}_DUwf0&IL*euHGfw`hfF`c5fMP<+3;H+~yej(F8OxZC6ge_N+s1rtJF@z4Gbc z^yngE%4r?W+Tc|_66TInrOj&ghM1ebJ7U(q%GfMn81IvZeS&{-h(a=k%=lMnvP7DN zpCOoQmxz4lD`vZkM=N*S$%(;~uj@9Qk^|i3P^I1Rw3^Kqisx|w#o7!lCM&MPVd+S3 z9(-AYsVx=zU>EWa8Jn+Zjnylzh`gL#^)!Q%9j+&fvTqLFl0IY$lfQO3Zwi8O{Ep6F zgZ=6@;4dWO%Vnv})^0l2|E$nYK++#K{e2nIQ1?EymJ~2CMOWlAFjWv=DMdr$3LF@2 z>k2a))*3%06{=?wf6N)!}m8n~X!+ zU%W}dtF*&I*fhKc&Wit1mGYUm*8LxGu@Gw3*JR~1b7BR;%=G3^6&2IQ&mvhyhdhcb z_4Sol*F-k=KPP$PyrEqBuoFC?dNE!5 zP1U5-t}K#WIwbwQ6Q!CZ)Hf+8xcz|?%}g{B{glaHWVOn;?nlBPdZj+T*d*+ra_#&| z?!?~xOo#0Eii^zERY$$qecJ;MJ>S8O*8;3KK(O^nXX6y_$?zp-nQgDQwk6nBSf3kF zC0~;>&Emk9+&8n<4;o1*nNB9*u+nDkInsABIB6Os=@wK@t*R_*1#$v&mteRToWV^x zYLP!K#y<=M`nMr=qoUuO#d)kf6<}h=ea^rvQ&s-K>2}3XUy*N5iQ8}Ba;6lGsxLmT zrrn=`yZ_u6q{0xVRwP&O?(yCX2>1xdj<$1rP14eM~w|6|j2txN}=>~lK=t`!6vjIBP zm2g4cBu>~CNVT4;a@gXV8VJ2SxsWJFbyaFE$uavLi7RO^q_0X56DHqpQ4)AC=4Vt6HUKBt88xveKdLg7c}a4CV`t=c^;-rS>yvSG*GIY`Zud1yIdVXqq-S zQ_EtWSgb51I@Jx#K>Mj=Z$%+zF>I3Byo0~axVvy#=!cntK}>22sta;F5%}+uA=U|a z!^G^K^qq|LciAE(#y%Wl5mvwiB~g&#IsL zH>4ijdNH`E4J*dj<@VT?pRUQ!00rmlKW$B=$?3(33M&yu{f-}Nx9^;=Qoh4gs27wO z3jIJ4)6C)gCalom-_>$Qi}jtESk)C8H??dQ`p@>Xg>4LsSy|FgO_U@@yXEHorw&}3 z7F((NyP`HNH&Lyi@}kSYYvTeE-kWL3*|6wz?V_STWGAo zL}BvB@+KUUmtcYsG9}-^U(Q?&jsY1%Zvwo zUVM9?e&4@U=y22qSsow>c*$`V1XY#Wl+Y8AkaO_5^M(~Nh)#p;0sz8d|I`wmw3NCf za=%2ZBm=BHE+z9$yzu98Eh8Yy?7Zz>728_xydpy!EG0wsDV~~0y)ki@O8>e(S57&~ zm0=zg=k){dMRZ8UgAS`G6?`JZ09dEE1SlkX{Q4Sic^8_ihU(DP)FXUP33 z**&=scGwlbq+Dl2XUw3<`K5>3k626CVXhu2j$}?5b?IJV^jyZJ=h~hCBit)LFuI1} zx*r$FlK{4s7L|-4m5MMvE$%-x-i9LE1Ho{=sVT0UDv|Z-m%GiN`{{b0PvGkSfFpyu54^dt%)W>3hCT;R(s{1x%qx%??oh!`0-#8+4Lp; zoKuw7X_XyRSkQGQee4Z!>FOOGd=?5M_F)rJZUv?!y|O~a@oAjfC1wd`&nC2dHMIfp z046yyFFS5%R_ntNcWgQQ$ug8C?`a=mXoF91lxE@zTkErZ3M>Hn%{6YaMeiIT`1JEY z1lT@f-6^@v6U{hWZ4CYz`Ej!0*R-Y%dCaz72|3^-g!bmY-~3Q}{*rzvnNopaRm-(g z4wm`ni0`2nyo-{O8|T5Jye&pf@vAUvS>EJdY5lixrlll#*M|^Q?z=sL758x?vyI5s zQ=HX^uI8C~o71{^Vr~vDXJ-QDzgmLZUR@1oo3X_p+~XU2VeKV6^=#vzljr3mltD}% zKxurqqLn5*#oP1Mc+b0YR= zX#5I0`j>#F^d%>O%Ai-kl)<#2K=X;Q1^rFQ;%LtfTGV=MXu6&2OYysgjcvxIb62pY z^>7zh0JIxNI%OYMH2p-@NG`r^ZJxp5AF`TvD$&zQ`7y%*C3J)Stt_-<@H_Q(uYg6t3;`N8Rw3g@VmD+r@#?spSLj*C|q{O=mUYW0l5zRafm!jwVCQWhc zUXZM)fh67pW90m_Xz8jyP5-3kD`m~G1pAE1-my6K0Qb# zRv*u&&s&M5cTDQA4^@N^6tm1C1N; zg_deu`AfEHt4XQZKfLPEhkr96k~zuaN>dWWCw}i&({8x@#$#djnEciQQLQV7H+kDK zuAyU96yZvRIh|-k}P-@MK3jaYI;#c*EjlBD@2dS+`bzuQK0vA zM7Lg3ll1y7raZ>K+D|m4UOHvE-!xFV2d1xFERBp{e#LzzAP^aUf$6+Puau z@5;CGmD4i9{`_ET+{G6)uX$kl<*UbE$58Xm9Ejg3^ZG~9sCxH(1ZzRiiJ#0Y55R{7 zp#M3?J*_SmshBhzXk0jSW8+s|#PlvsbKfwi^$7R5*B(JfOA0`}wt#D5fMv}?A;8!I?{fII_X`}Ep%OAkZ{c1E)OtP|>=Yi%5 zLk6ZH*OGtU`hwu0I{h|+swbVS5iA59s! zxN_*QFx1Nr_I|a52{2BatbF#zoSsC_>v9irEmtbgvNjj&jrwaASK>ZMIq7K07qGBQ zb#a!(zBxDF`NMY11iP6d&MZWO4X+h??D=h{uRFW6gRl4^`0j<6d9Ef0`iCT{Mwb!a zRS|9v=8~5nhi?p)TEy!ouhoT65=a7-zFbeiU7iDMG%soPFGg3JFb@B5E^GO7O3&XtbbDa@jmzo)z$SK2Rg?MGX+Q?Me z7Bw>9;k7(kyIYY}ON$ShZ(>iqrua1G8Tgg`p~ueobndgqHQoK{dRwTiu)w|@KekkD z(r9KfNh;i!=4vHnW5u`NtlsSBosIS8>XoaR!U;L~OKZCT0!cMSJc%C8Mj?x%XoYgE zLZf<;jG(=<9ju|uVut`vMf;H=%(YSe&Tj;mXJX;b8~27T3?{4%5-k~`c?k%2VfN0K zOS8Fv%=rhDNV$FsYigR!mW&kID4-Yz5G;XbS=}-UpxAlJk_@*ja(@rwq56-lC7nd0 ziZlkcSj5zI*`LT&(q&0`=vw#rF@gNN5BR2;>~-<%m$4EP z4kz}yCUPR;H`WZzdO258K4b6rirU--RTk&gd|b&~2{&V5OqaDl`7_QxrDh$}YQjjS z_2*)-G}F*k2O#U!S)Aq!^rcfVy}u{90;^&EC?|;a7QIc3S7QN-?1IRSV0;?iV^8#b z($?k-lPFJ!jQA+ZpAX2-yY0}3-9LKX--=*z>ii)d6jZSf;mT4iHqm?15`HH?yYllF zcLqmVOn(u8-_!c<`rJ~oPyW>{v>zA0Y~ZaX&?JO%d%lt0O6Dh+Lu<-XSJhTzEhE}p zrzz!kl}pXL@05RjkZ^F!d6&yq~lQ7WTacl?1bgDD^21xy=eoO+SK6F zl7ZuKo1oSYGSW#qCaD`uWz{44=x#wGUH6Mw{I`8?#>mabrUXY3o>gPvkCPiHuaA(o zf2EA=AM)cqOq>8TEk*)V9is7fkatJc7Qd*ON0P$9WP6B=b2#mk)xYZ>5Acp>FC6gY=L(A;C9QbD z8R2XT!|b{uta98hQmcNmTzYO|Lah28Tq3ELn!!M1IdVVHX=tasS2Wyerb*J=aZTHP zP{I6tz^K+a2L0Nc60$1RGCwnd-s`8k_u;@Pvu}C*nrWiVt64t|0S?UZgBAg#uao&? zmj??NLe=5G`)DKlKNi46-mUg^wH{UD4)ClN_0qTA)lfiB-(DG!N|kIb zOFX&ke@)SI9905Rb=IfN&S1}(V{YJ-Z9srunkQ?U zyOXVBw*9PDCCDmAe$?>zvzdp*YGugBw#^9Ht1vA!EHIVQv_@?o9=AN=6Xp;8hagWDixS8rln_+Hq7V* zS26us5}f)onG^|TmBkbp%z1n8e|?$~`9WaxyZNe|r=?dvDwewTaGe~#8G;ZooTV_y zTcc~8IQD~!V0(>Q-sat!-?+20*CKD#;%_`#IDJTK_&Xmyk@5JhKz3PG^bCjNaDqt? z{B=x|^9Fiz*T^Mjmzp?#+DA6d^yWK05AtcaG4u{$Cgy@QBKTYc*9n-Hz|PC!n>5ou z$N3_;7&A@Xuw_pLNN*Qu6x%!9lk5d&Kc|H4@s5x~hod+vW}~IVDbdi(KB)eZqgfIT zH(gR|COMKl>q-N1v!8>xtD~;kDJAxzJu{q=A5JF8=L0@_exg{FK*iTcx6}M&Ld$ z6Vnez@w6SU#(*D);$He=Pn}r}Vl#~kw2?YWS2qljL(t65*w>~OWANY4%a8iD{Kgs-|_s;go~!#s}xGM)yAB(&S$|n z=M@uzZbg)XK@9Ren>*1lOTpvNYa=)jQjE*E=8n|HtU1W10g-ueel-8#zeeiXRE91x zNyk;4&ggr;kT6yg4eAcLSrJ50ce3FGyAw;v?_cY~JPe`M6K{!a`!o@Vs#o!E7g4lG zH}hQ&H>pq}<~{6CpJF3(AN!S%mJ9LKuN%(Dpej-9sOh=2@WKk-yUv*c=h2}_`GCs? zB(LY;eeaEjA|k3~a$!NJmpC~q?pcJ#L=?>(xzPZx;OKVPF2`9M?QLW?(r(8Dw1 zLlQ2-3UP>%>Q%#AXWnaaC}9NZK7i_-7(e!2B{7xYu@+R+m&<3@Pp=I`(fAd|-HdM* zQ1c_pcQ+eeu>0b55D`0iO}9Ctp?e=dl&KNG-HP1t}mw>=Xs?L=J`!zbcmXYo35?)ADeihcKDBy*+`(G zT-!IcTQ-UF_NH^hv#m$W?B3&milx)@P>;t+h6PaEf^5jWFEVe8mpbY{B%yL^9!Yep zr9bj_J<v7DoCuX%XCMixegf}r}GJp_E37~%e)6?oB)E;2Mk%e^CL>q zxObH`B`Op6WxkMou4z({mUtWBxArk^xjBRfsNoxH#8l^ZPFeTOGsc}-tqkcaQ}61X zj(z4_j3M3xCTFm^I51f|7)GdY-j_iEUgx4`PlxObsm!@g85H@ZFNIL=OLW~2Q3iCk z2#DYs-87mpi_=lFUD_GB7!IV*K*kGhuv45_91=iv3-XT_yQZ&PPKife&PkGOSM#iS zIO+*oOA~t|$_==E0FH+uduxzx$E62$B3AEK`EPc8kKiMM$FaHL{hJL)@ zl)oKCbDAS!YcOQ!&g<^VC%I~vc>7QknQPU zn}@T5Fy4-w>}D(YVax2*v=j5i=-F!)L#vcZa)$Bs+qudc7_`3*63YIY!2t&k9m0o1y>9TeENxWUHN&nnnCs1Za1xec$1qe-@*^5Fn@0YR z=k4U$RQQSC5IalRJe}nX>e(;oie~)7_<4l*G|yJ>se1Sa8jVxO1;1SHlk!Mn4!)4e zyE~R(=d|&(c>bJ-Oz^RZS0^x-8By~k|t+Iv=eVc!E`8m z*oS?ZF$nEG=lBi+>@~G)+@EIcLDdK=k+aAQ#@PI`2rM-8+^sy(hqoaDRN$xqO3m#L zWG>Bf73^p;qy2ELMoSf?k81plXG>A85oKcP7(#KIxi~%Isg_G^K7h89gt~ni_yzl@ z@z9r@(f)f=oO58tF|0}jrdw&iKH&iy!!gXNX0FfSzmFoO=_R|+NY<3-6aOP3j1!SD zEkV?c&`UqqmmadL*4w?xNy)tr)8;S$@~9%^Dk-eBiXm*iqs7B}$?=Qxfq=e_&NmE| z5Y!P=AdXRe+X{A=^N>B$k=D+zQ!=h6!8ToGaVmS7|L@0R?Nb~*mh90^WF}@uj2Dm! zOacqDaUk6fr}pP?`l)v3C&fjT1k&n$R!_7u4%5x-b_E>6O>BYQB(M|Hi|CR9gr$p( zI>8tv)3~Z3yt{VkXQVJ9Ss6Q%P$aLta{r$rR;B{`I0rzvc-h2*m3gk}I>n|Sm@VvU zT5(P&2h#O(-v#>q5lu@z1I5dMEI}I@D%GfNwLsH;IlU}6sV*(+JXQ;5AmR^Y*n{!? zcZNhcy2VbAkgC`#4W0uI>ToM@7W2Vp>&HimRsH zbsVu$bE_3$SfQT;Qh{`*mH$(tLog}(V-gEaR9}K+hJCSRV}^%?%NuXmA;U&w?S+}% zyN`@!MKf!gcJ}5!G|J^ZVK?%4G*rF*+ZJFKZakio9rvGArl0)sII*ly31IC>478ViYwjj>`Er zNcS*~?jVny|A(WvMN|Slld@$(gHBgG5o0Gs{G(FDh)=)w?L17~I4ernkY}v)=}2P> z%ZX_n_S&*i`IUoXzKP9{VKwQTsTQrZN{SBlEhGp?V1Dn%{tqGDURCy)iq-x=)Q-bZ z-07u>xLJPzQJZk+51+V`w*f>bSLxf4oLH;hscUd6oR1;b-%;m|2+ zWetC=CbvDJ=mF}jo}cWfDwWs?hX;RvTXlu_vGukajEGfAW2Zrw{s~aA%K^#(R-P%V51gn?Z1avc2(v-rH#E&b3=wVJ3<@{%sEf6~o zZ%;Q*kk>h^!mdJt2CuRJ@-?*CWh+(J2m&4_sZ#zHKunuJW!`1{H`3ElEk`ki%656PzHFTQvl^fcKxzYff`Ytqfdq& zjd%G-++c@l;9=8gOc>?lHzL z9HC+yndCnmwOT2!=9xIST9ZW%ERJ_XV5l+f5)l$+aHeDc+j^JF8N6#h(RT0GllWb1 zfC|>QR)=(cZl7zcde_du8N2$SRC94D6YqAySrQ?Gv?Y z13MEbJMgLg&U?;LPfvrrnpXJ_LI-dhy>vWTV%$TKT$n6-KJ_W zYu8U}qM>Jh6cIuEl9_MyfB<`AP5d~P?VR!`AplYgqIqas<6UN>Hn7HlI(kyG-Sg>$RhI0Vmd9U?Z5Z+#p==}-&a`NaL z#yHD`19>`}D-~QKe*o1sKXb=76Z8txvW(?`t;1desc0k{ljd zqbT~^6X*CY2{^j}&Ktzz831dc+P=|% z``d)hZ-0xU&Nm3mO%V4-=+CT>9RaqTE2STCu2*_u4=cD^Z_S>25+0;?{%^NqZRgE* zQ3&E8g6(6+buln77!i{rO&c5&P?yd zeA89m0{mOQma>zq`~ z*R;`;7jAzu5x%N>IUpfDs9`gFcdgR^J6c~ukiHzAVbPUNwD!_r!fg`sPu!E&yZ1?j zRLG<1XKbX{fJstxnpKwfQ5fNJKtAd0$}?OXxety7PSMcrlU)RBu;9jXuS&_k@BKKo zyvMdYnHwU1Jz^m5BvvbPPv)V_S+Ho2M)j`cKl&fMjXr_ikA{2m7@~is;tZ2CyX^c8 z&37iGD}+TIy|}|VDPMl=jmv%9^F1inLzY=Lp)pj{Gd6M5%)3b;i|XSD3_z^x*T_#% zVv3TzU5}I%eZ&CIieeS$9@#(UZK%UJBm`ZZ=$yeQ|XEC~CTZ?|TB9i2@zQo_dzgh2PkDx{~wH9KR-h zP456~6_nd)(bO<8dAmkL@?pRsM;m@$iV=WWPT;-76;vBd@Cj{vPJ5{Ue%6 zyFX#utrBI*grmR=>_^xy?Q0cv-K=C<^C(Zdkl9JyP?aOBWqyI-R;PV!in z-~eXQo-aqH;+y~9XM?qQzYef7pUt6mWZ-iS>`_cQ7Ga{Mz+MY*LCe{WGAAM zy^@u^xm;WJzV=qu#YNX%ec$~akKg5eCJRSUG#*sa=LQ(E6yf@#{Q3um?0<2QuA zPQIJ;FbtUA5SP|s7+W=wBH3`HWNwLPOFlzqN|=+4LtJxJM--3q7IV*oHaK*>2NBMiF6)QOt?Uxlii2a;^9F7Qh>$wbU@LyZ8CSXn zdWaS^`9K+=-)!37?d6k%qF&Lw;MVC%7`BNYwjBk_yz{IZVfXQ=&BhVQot7lVGx2ax z9laF{-5TQV`O{wR>v&cSd8%N-PIS>lT~C0N2H7&+V$79XiuH`?S??gEND|8#bE;tej|@T9M#aVD^q|cQIzc}! zRlk@=j-cPF^Q7h&)rX!sHQ293%d8c#Ttt$_Yvt4FuGUG1+U2*8jwM8^xAU*IP*xZL9qs1?SeRp95GNOBbGq;JgkZw@s;~dEO9WAbh8G; zq!1oUDf`KCUP^_Rp|M5y_V&F`MZ{~-_dab4cdU|E`5wP2Jca-x&x%5DN1O`VVe05gk>=8K^D3=*;Q|e_iKmTmN(-hS&9O< zk2n7j952K{l6EQ?EV*L4tv)OlTeXCbL-t=X0`o|_VK5(_a9XS<a8ZeJCPLkkzI*R0eB|2t=e(rZ-_LanD^+I0Kc#{z=N&-Wst)tYe z#Z|46^KW%ZTCwF5{o8ENn5J8ji6n|i+Wc~o-2lE3^8$_9KZyp{^I5iR@Eyci7so%BNocA7)mQfDl7=;c>PebXA$?Y-D?QI|J4_1tN53RD`D&867jm0N)J-2sMp@Z3@ZnEp{kj_AE6Y3C zIN!rZnDv7I@zHI(^VjxI5|2&OfO#o<%eUa$H zG8xE7@rao1m<^^w?P)W6d-N7Ba2;GSPVEU)FU&wU z$^j~`Lo!k8j&GfqvnQGvn~yHMB7GGSiSF-Di?>pYPfYoZ_Tthq6})~QECtBjC`VXz zgnY@gs(47%(YP}_2^9#F$F|rI0_Kl|?qr2mZO`^jy#`SmPA}L;ab78NZDE-+p<#Sk23f_LM5S{6pde0- zT;qs0L8G%wIA_-G$VlzfUZgnOuk^jfJqmV6t+86E@ktrO+TUT+1Cy&-bH!{TC%QH5 zP~U*xw(+a;*YypqM^V8R|u#jy^ECRiOVOf>A@31ltVq*3~bkZ+Y%Z@V+sc zzHTM=^gO{3Y0rVQI-lH4QIQ1Wrsg=UEm5?JO!-v$!*wJ&P?{H2lqs3MhG z>LR`R`8!JLc!t}qwZ`H@bixC`OqG*7`_E<gR*} zcPt2S%O~l&nnXx68(Ws2%Y|h9Hx4p{?{kx;19?kpOFQEFr9h#jfa~L8LPY1zE^So8 zJF|@(8Wm{KtHY^Pz6Nn5VJ-tefy9g`w7}anLPaCLnuTjIJY-e3>lXmuY%q?D;?8ZX zASDwY9WuzGEo>frf=*`#$;Aj9*vR*9O57clkG||T+M0fH@AlJschqG#2%KQb3{wIg zt*U&#wfJIeXM!ee7%AbIo3l4As3HykDOslSw$Na`fe`o*QIHGVf5v4w&wzCVsHd^<5OseYJQoptSX-$1W^h&$^%X66f z-%i?J=v?)Rm!|WN3MVuO2WI3kR`W*2=G`Gl=F0Z=G<=^KfLO>p1@_gd8*!269X@M4 z7B)_GVfs)j(E7_~$WAGI_S2bus6NE(U`@XDLWFgN;QI7WPjn9n)YJfSe`A#1sargN=B#Yju=qy$-|-;MJZgFAC=980H|jAV7k z*LSogo}dl%^LbmuUOZRH)~d+7@I;tBpL2Me@gUK;tvSOAaM`4#sU_K8 z)X&vfPRmz?gK@B1SS2wfnJev;vbR0Ut9~KFL3JSk76z+1-X|)z9@0gtS*6~OvTCam zhB3q&41~y4DmzgIuPa#0tHDorzG}Bd1C!m$xcCWPoKJWVEL5t!L2rAO8C1{W(X~4M z>k6Lpbz=^X(TELi!NJdsyvhD2LY&FRyD*$n$Pe!q^Myw>wJ*kV30r0t*_o3)hRcp>%^&wGk*R+IU|1)_aG%|wOw5) z?2;>hF~ROj6Zn=~vzf7~i9-HRoOwZwtc_8}qW{QK`vF-~p|b1>$;gg1o57LcCa!Yo z(FfM=pW1iXJCYj(kgE6vvL#Per8Dg>!0h1@Q^I0r{>MT8UkgAhfAS&}?tI|uG~kh6 zdOggKh7qtF47GmE@4Yq6s5eT^8`b?e>d9U4L2|lh->M{IJnUaQFRq|8Nr_mJ{wr;l znp~Ah;s58$LmT6}nT8@JJJtM2llh`YaKQbVa1N*-sFkPNVBkI~@6)cONlr@I2oxNX zz6vO3t-TtDEI&bC?bh$lNJ|~4U@AVvuV}6xeuUDph5)F{li)AD6?sSB{>zD4jy8GN zFChX%IT!KPh|S^Fh{Ai5{f3WCt$VbH8&#|AM--HBqh^JVlN~>#8_Gm5i7_K*6BB}? z$Bh~Ef6|CO=YM7@G7Kwtb`WUU^-7rD|ttZ*}}8 zNSa|QIH*>hVCf09C$^|wL{m3O4IQC|rePbK>HAmyPQJHD`=)A#n5j@;RprD}SQA$UfA0fInie=&l}VS+RKywD`Xf=-f}c zh1kE@($sn<2WfBNu3z*8%SUIBA(mWnb=BQ%ZY6EnLPZjFjf{W(dDBjmPL6<>-@gMY z`AYsE#-z%t6S8Ue9&UUKQ**GJ(ff`{5`5$n-bpW+Mmj{bka=Y<4@y!+=a zk4EPo%YZKY^~xEi%aoe00gLJvyEoA?VU@|6O#E|x@Y5Fk#*p#3hCnJ*%V>J8P;#_9 zd${?ypO*CYZ(WMxI_n|wE4uY;ZF0BWUS5TpnIv6z)dMsn<0~hopoJAm_MO1NIhzJ_ zXhckl`zww^T7tjfe!%5fvAYV@tIp z>2@bF_pjc2mjr=#6QrvhzX!sf25gVC2E$#*Ti6S$3xktwC30}hTImD8$>?~vVpc=c zaouFN3%W;*EsiwU-Al`n98HFfW6*B(80d|JXZ4K;qPiZ!)lEygkcHHtG+%fySLkf^Y=7Wf7dL|{A$VKY4QjS%`p7P z3Z3e4$T5D9YwW(!p$8csk!RW%Ga?*Af0RjEAudu+PNHP~doO|e+EXW`#_tp9#htBV zSnGAuWqt&hxhl<;4s&aDqljpUGD@IhA9QfEj3fbjsvhiRyU^KZo-+lb#6Pu?6~<6g zZ~j(1U5Eo(#V0gi_&2OI5z}-SUb9>;I~3qPFWspO@Ak#~cr3QR+xVJZX~=iAQ3J)cg(~Ab z?4OR2ZF_qYKI$V8%=Sb9yzgQy`fcIkE#-_ei)E<=n>Pg8-TRP_zI%{T<92I{GYJl` z?{i{tUXF^VmxEJ3vvKOO-lfzSw4M^-T+8QBr0l}!D7xXgjF#_qtbJiQ5f->)BO^|Q z(XJ~=t#V>ixiXLclqoZ0#ncTadur)g9ZVCIySyHuHUMynxoYF9cav2RDpH4EY$3jn z5W>=_9nv=t)62tv$WwqD}q4?_HL?Y}XxY*@P10WYX4 zrDu;KlLA8NYIrk25pmjP=z1uY=BLh1*$&ynPUfMrC9ke2kEt{Uren<=F~vqgW#7z8 z+dZbsHm$Ukop6@Pk)8DS)Ln>Ko0&K#i3X2X>WhIZE&gszW^t1nZMwD0Fn{OGNHdv` z>f-XI7Fa&Bqk9&AhPD2T-zeSBm)RMq(Z3V9s;a9zRsk!rE;Z>5)M^a7BhZUKB7hV3NbBIt5B$+1i<^6y_ z(sMg0AVJs5_iRuH`PvpKP-lpVg4I*o_Bafkp%v6 zIZ&PnJbl%0y6k674D-i)m8rt3i&Jwyhi8AV&aj9~s*;4%u`#5^7)sC${d!WrY` zn=GjO;5XA{^Q|NUz|YwM?$tcRyjUM<`XKw2X{gPt@cS+TtzcP2sdtxyx9X$^fAul0 zHF56_3weL=N*r{M5@pLd5E;E*H`Hg_ntxJ2gFeD&-2Vd)K6{kE>WnRtC&Ou)9=x>| z^m;ZFL_( zVte{^7o&JVrfh8L0|hudt)to1)Af>R`7PoWe$IGx+fMK=evy3&^%8(DYI0{+-a+2W zWve48UY*1&&A$)igW{SxkP)LJit_$67S{tkZZ5V{L-Xty`%Yz=R_}Kxg+glb2svO3 zuAZT?nU!`k+1<=~f}_pxhV!~K_W@3Cz*&3sC;$mT!?NM4-UV`!B2U;s*~vY7*Gzxj zBbNkq(0XW8Ek6<3pcIHg1;2D3n!PhkW(6K(?PU`8{%A!UIeQEC%b`=@jt)=dCIQdb z$FfPz!Q-nx&iAR0obzEfI8A@tRhx79ebp(Rpv)db(*x&VwhJkz=A#7(pNlk|T+>nn zHR2)Fk|Ks_*Jk=&A^TM{sIb^_I4REq_u#jEwE%t0Dzbhdirv+h`vlh%tBG({MVdj# zWOOogG{ay|(VqVW=QXz|!Ta>~UzOwbUK^Q+WH(fO7&m4W8D`ig*(gz-vvpwGL|?WC zAgo*>I(p-FNm$X8iba&kCZ!kan(7wkqceLS({V!$Q;Ao?`g~M0ui?dEK zHicxzMH8Wk9k*K!rGsKaBR_hEp(glee6!Q35c^MOHtL_wI98xTBi~W zgN~w$a(-JxScVgj3V@y$*6-*Qh!Ify%2lUXi!Q$c3k!<~^cWpHL;4xtkpAMhLDXqJ+7=ng{@&J3@C)`rr4=|&X^|aWy`H* z28%b*FTh-!cn5PUWyYIugnj#JBUli8zK$)gJ0&QAE%~Yy%|1OxVV~^^&ye>PWiA!v z=v6C09s$Xin|N8xZfW9l37QYZlaI`OPMUnMY0C`RqQesVTv)W0eXiL3P#!w$(t|fb zLq9CFo%Nyypx(IH)9G_Ha@D=9ExP;OI+h+IE+1Yj1#3vwS?9D^WzS1BC$0g^Q=TTK zB}SA{tQTK^%d5Y(PaPsPF#P&YlQg`1QfqohZNSj6oJI{7YekK4xG5ZGE5Z2$M(%e6 zSUQP`dl_y{F1^Bn@CLajnXGY3WQy;RCO|wSatkwG9%yxs;hMA4MJ}eaansqeRjY&o z8wUD^|BhoUy2ehmtC&AR{a}UcVXaeK*ed4occ@KE|6RHqm$Tbv&I3>wBFs&@W|cbt zcKe-^XlS1z1IzN`5Wtf@qK(^SDU1YQ9}pP3az5`oqR7^yCOj8g9Zz~+EKpi%iD(Q4 z_k)fb!H(UqHgb|vU<4}pMv)fHA^XWGmwAB$Exfo6 zb=3MTrA4P~q+!b7IT4a^C$0aRkN*7LrBI`I)Rc!)B`8~Rj-TN$5?XjXw&T*1=>tb zJgk{nD7a|x*A_RfXQfx1G~(x&w7BrhC#}n2S0;>V4&7~~?D@EG^I%cut&ZKouhGY@ z=zh|=XnW0W8^BHb@?OYDqy*St1r1I+YuD5Q4{lc~OEGT<#}aPfS`JDQR%xr*)5!65 z!f{uzr}fL_&7bGm7V31u)a8&t(b5)d@CJk##+t54+GuB`g>8%L=2@X_s426FhtEEP&S$Rv#n-r}N^tVhRy;0oQ> z+o#_M<@+U`&t+@@mMsS*&l@<_Ry7~c9{nkm*8`r_6t?U;bU3wrB-P>j6@5}9_;fpdW4EkZCEipE*gLu`i+e5$8kp$ypwZhXE#?mm3r5)AIDi~dG}@{6t&%+ zmN>HciENp^prfNwnOwNu>9haqIXZTz@Sv;z@>99bYWLIBB=0<3w&Vt7yV|jg*-_Ow zTfg-juU=1_A;Jv(%OUhXt0u@68yxcaDmG#Ua$*+>XOd(CB4E@dqRi+=BrG2Ee6$-l z_?=Dvm}%;zh<;ITtybElwA23VwuQIJ69jI}1vtv;w07i%8m%}t3!AFXbfof|*G@(R z;?w5m!%3tUkF#@KTTnp?%-6OZHIIV9SK8eQuT$Tj`aPiXU6ByO4<5N+T}x+nRWcNO zS5x*cln^stEWj~}s8QJ=1Tf+LtJ&IA->6z8jQXWgV7T_UD5CYZIvKI=H#2j25ic9O zwy(!GRm#U;c7AnvZY`s3R{UrF+0;p|?niq{4JCrUS3USX{-FF2lB2E6659^UxX$mxkj-A1JiDEj8wX8k0_3~AlOvdgdjF;n>U9F}p6K zQ#4!Bi}YU~Jh~NdEo9L?ODTbqrN_qMOO|vNtNH4L6y~oG#)v#-q3~tah3{(7Yxj#_ zH03RUIvG>xlRcm)mhpnTv;0flC^zxESW+&hE24N_d(F+l*8~d-sMSoWAU`hb5g|Rc zN;`Q%A)Rcv434i3zYyrZ+f`hD`-jRe;MTX%tN_PhmTcS8%hPB#(hEd8)AJuLN^U!G zr4%)B#!sZpQaux|PmPV~ZkzxYt5;Z<0AVOK#GjRzELQH`tH3D9*WV4_p_;Wy1Q1zr zOe8byh8Au0Sy%T(#h98U@57|Yu`Q=xh!G)*92no=UZ`{%d!9AvmG^xbH@uGhPQw`$ zz3Rn%cQx@*i7NgfHrZzH!DW#q3*JwVC=kMLaoUb&clbe#Q&~cr>Y}{*3?Fkoh2J## z&NEo@z`EOs9k)1IJ?G{VCpK?jy)RRaF)cr8dl9D6a3R#OyK%oWy(0}U{DUrMRzN`v zkO#W>=>lR!rv=H(Fh+~JCQ>qk(|SJ!`oTXqI`i9STXd#oWDKzuSL+<}chcToJ4u;q zmfoUm)zcL?Ft6PVheN*0A^(^KoU-ezb@{`(lsri=-62lt0%_59X_2bRL>G@AWS_3`$Kz>Vesp4`YoxmUIRQ{`KD<7zm&~B+CL@gDH z0xSm&kKQR9*NGQw+MUv@D#Gu)IrTkK7*y1#3#olG!T5O4zB8fXfphu`uEMlicpe?I zgTWWJ(rMg~K&&=TEAzWD(BRJcT1>)|i_IKE|0dhKkU-9@8FsP2Hvv4?=M8;#zFRpg z7l^7Z@twXGo_zo@6lsosSrPIdC!OY5MO*U&W%_0g0UDt79oHu0<+}nLQOl1J)1!^hGNOa> zuKRiPSSN}2ALG3v1$z{3&1Qbuh3a&JjqoK#S@59p?{1hB4SZJ5FnqT9Jn(3*ah}$r zC;0Dz-;X@Hv!iz8YsQp(1>6HJmh}+kf8)?cdV1SGadmgTJ zbG***b>Lz3jnD2jt86?-m&_YdgoZCS4pbnKe@G1|@je@AIx7b`-oW^9MkLlH@LbUr zKk@U4t`|E8<2$uh`E5lGm4o1R3s|NsiIAd~TE2vLx&|%4Skx*32YGz+=i#<*X;U-! zOp)C`KUC>tu-6WK3}oIsW>_8gPI(r!R63_;!8~~Wlax%qVPuT?iyAz*9x$9o zBkpbWf?X7fSzd5TZu&*0l0$w$rk;RWRpwcWggD$xHh@dgm3HlN(UF5rv}8Y&pFVrozg0z+ zW7)TS%HOs|ls!Zire5J#p%!BqxueIt`)Oqq{i~?j-;%PKxGjC|RT#bqhEuG55$vmw z*)_U#ucL{ZP{qAw@_ze*L+#Pl@s1IoeH-Jr1I`&3LW@Qws4d{?bdDJi;S=P zlhZ4<#L%3zfLn6;k_>C?T>?`gc9Of8NK-^R3Jlx&83V@C<69S%&c{uSGd)$MX>R8(pZF9bUX0R zzcjNkD0m{$;$qM!XhV;8{KLD@6u~P|Z7`qP&l-~j1Pur`fT@cHAyk4V^EA(H^elQ- zL)9w`ihQ7_AqGZ!+J6eoTvIdiq5R_z*~ZszJdFY(qW(HIeM_%LiWt&DR<9@OXirVg z7wgaBrK@`~t6@Dn-wH&P$C_ZwQ&fXBKYu78MBh4BkVbHz_E|SxqPL>p6o@Rda$dEo z9A8z@(8<}?1jEQUsR0HI@C-e{;_~$UdsKL+%)5{r-M1%uuG|JmwaUr!b!NrFBS_IP z>HN#STFKGcWKlEJmuiYlZtngruuFV?yFWG!>I%gm(z%nA9;sMg5@9n8~}F+iE%(0Umkks?Z+lj zsn3&YWtswLNHfPgAfkTW<*6(!Dc$mr2N=DXBy zknm{VdxF`b!tZdAC?Yte(@YvUq9;V!?N4da;am*(=c?+y+kFhz;}sxuecrg(o+;;; zJSz7?J+ZoYO#$I^NU0<&QYyfI6jc3kOEz%No6L)ft3?SBD)O~s`g4Ac*ER41W2ktj z{0SSQN><~lCZCjeS5;S$y|BgT-0lyXH>+`hN&5r)*X(aHsDd)im{xw1zNg)&A)uqc zNfcZr(b9ah{^ynlijn7x6(H=)#Orm-zXY}vpGuRHzrecH)rorwc^Nqx1Ivj1!0{B@8FS92t( z5zu^Gacxrm-drlQ(K^W&>s0^PeMg_G;T`p`DCad-&9`(w-46jQnww!VS1S(LkGn;bQh@uaFVuFp{PFgNCm1ew5Vw5qzxhZr z|0S|Ve#~^wQ0H~GH>B8V`xC}HcELk0wi0%X_wqu@CTjuL^^h}H6=~7?bC)*FYk(HP zM{HrY$Pl71Vitj_7NDl}B}JsRyiD$vkF@A<6l)HHZ^AeS#sPa>Q1dKPZsi0CpZukW zn9Zy>e7}nHSl!Jkz;UOD#s(&>_9))nlml0qX))AjIaL(6kR26C@Jv*lt5F?e&M)K1 z`YRJQUz*9ar-wc!Pxxv}&2^2#Px%`W01X*%W3h=R_va%k`_NHwNIDHFw`J_tjs=G) zN3to=tiRt$8x88mA=B8`cs$;myD2&!A0esL=0eaFb{pFjygM!L5t(@li4`oow1`N| zW92~ZP&c2f4R9^I&f*X2hAmLYiuw8N-j0v7X!6B21L_xYK75HU;ccf_V`tu#q;+^8 zw#hsHWEUG>P*XasCw=eWk0S*+(fZlXTh5+Npp7M@o{^@dfiLz7?$J*_uxm>qK<;8ULcS*Y&@ z#aZJ6JJ~<)U8@R)3kV2w@`ljJV5)}=3^?ifO=9i zlUgg>%Kakp^lhjj0>^q7zp;@rz>XrffkT;3r3^7PXz`?eAaBD0JCtkHSC_RpV%&D-Z=e@m3hYJrk+N9P}+9N;5$WZxD)L(T=y z2l1=x^;b_CPnyUPgzgX7z?h6ce+Y@6G{IL`-0Ifq^h4y8Vzc)eqXL)v60h{AS#p7> z7JX9iGetNSiH8bE(R}WTy4>C-*`pg-sv)H6ggDn|Z zIABv#F_WTzr>gzIgl~bssTotnF-$9@5&Zv3cz3%>J0b+k&Ij9=LK`O?Ov@4tTIoh; zZhDTHv-AFYPGq+8e(R_y^7Qn-!4aEp8_rz^ZX~qWE=W`DGJr~avK$H}k_V(#65B0! zK~VFylx=I7>m}XvfYW=nuua0vB8Cxa!~H8Jw?H z-XFV5e}Kdi?%oq9{t8_u>u3FRx|8<{MfgfQ(vyQ6jypeB2(;j;gT`^#j%<*L%RGv^ zY1d88^_JtC$XgCE4DuY!?_6N5G#6t6C+>111FwJ9)?fgcM1390o_|HMe5CICRxWhJE*JRfu!%WTFX1BfFFS_KDl>#Xws+kF5xV89czAyxn zl4r`IAIf#dTIk04n1ioNfHE;Bc%~#cuhd`1%y>z^a_l|FMt-JTR@`1~nGvZ08}GhJ zK)zuz{y1+WIN}U_DG_FN;&H7ye07lXk804EBr(YqP4hrY@lnS{`$FBGacRvJauHmH z$O9B%t&JRhI7EkbvpR^5(khW#2cK_G zyI-KK8$4GPw7J0H4z(1lZNUw})W?J9vHdU;UG2(aL6Sn+<}#~}*}RW=)dj;uNtC)1 z*L_S}b>h&tP`Rw6Q%oY4B@2ou9lrOK^)Hh7FL{v3QJiaF6~bP^g#SNivE?X7(`!dyx7O@JKMsvu7D#w zEu!pE2#{@B^v5#B4{|B;yKZ$z-}5Q-pO5me^0IoKCf%Q&CZYZPXP=s-Hu<+oat~xE z3tI{#(2{)h1_`m%x{(TkXsymz9>j;%0TaQ+e1@fRrzz~I+Hn7FS;UJ7R_XClJ9D5_cI)5eJiUZVEp{tzjPIuh+1kuy_NU(p zxKddH6SJ2X2GK-k{tnJAH)xB=6uv_J0bqzfPy`RuH_?G6jY;s;5}8aYH93iLB8-0sTry$8$THAlDmlZd#@=h%Qk~ zoL~jmQW~4M7V>g+EoeKfdEG=&UrW=G@}Kxy{|;@Eo- zHOXr#>D07y7j4wFWFITa|TW+uj6(MJ}>{vY6Y-(b1qwVZ`-nz-}IyEs^<5dIDU-qE1q~!P1#>kC< zRN`5zk!178y(qz)CD8?nB?;!?yFP-Z>|2_dzI2!-Hv1Q^=!r-$Nc`dC=u(k5EgNY1 z7FJ55RJXXrP>iYN%U0GIIKpacY}rQ?$CcfNg%CBb-yXlHUbh zs3a@0V5Ow{O%a^IVia`5$7L$NltvUl*bx7bVlpbP+&xmbSTPo5*F0G=JuEHQ&Hei8 zaW|%|fh(m9G4#)DqQ(b{yia>_S9Sh-Ge*Y8`{?aVora()$qSO2^Ydk8DD5sKbIy|c z94APihgcw6`^+W6ve1H3{8Z~;I>exOHr;hfNKEQS?MNP3k7QeI89M+W%%)Qnk8w8@ z_J3_3C7{5!Y4#~t4PI&G1k2GUMeD1ett}e*C1`_DWDjl1<>fc4pO(jL&b>&(Go#T~ zG?cZr#qMS1=Ezxx+LmOl^ij|>$^~G$yzU|+VVrpy7++keaR&R;hXLXw&@6(1?-lEt zwPY&j9oZeh5mOh1-b`N*Ceh|1r=?mEKJHM9)ja+)XENk>+|+jy-TL?iUdxrl(cY{H zFbd^GGSO)~y#Sv{YNBG>wkL~@{Zqfdms0~(BYIH@=@od13sEGQn2L8aI?Mqc19UU9j7G|?z)U0X4RU7!(Vs%nh?Uo>X zPhMHU%|n(Xb-&*-7SBh5(N6wN5wp%|k|w3LIj=>soL`qtv)A@h7Pa>ksOH3TAaM?Yxcid4$xFxt&6hvT8LU`H1vk?v>I(;GyFLCBxiz$)lqa3(21m z1oJMFC0}cSYU54g*tuCh`}Je!qrYl`;P1??W8-sA{*mdN)4%=)2ari-HF?@Sac(kJ z7^^nXXx3HtiIi8Dk5OB00AplFd0b2lr<)PCoGtz2Z1T8GVDkOIriP41rLl0c>fnJt zKq+(Q>Ol(E2M2q5X9%EYjpw0>&;KJ^iK{)Y{&hUwZ+CY>`gUAi#GZj7?LdDBDB-PN z6dfNaC@h|?#P+55xVx;eVT3N>hx?$Jull7)F?bL}3!aj^s*-D*SzIP+PQedn)(ibC u5f-ny>Sh$#Ra;XBlsVPb{QJrXu7kc@^025ETyTPb@7YuBCuJ&@@BRm|a{zJx diff --git a/.vaunt/badges/badge_04-03.png b/.vaunt/badges/badge_04-03.png deleted file mode 100644 index 185b14db61888a3fe89751f86f8959a23868209a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 131450 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

  • fsdVZpy)US!_{kQq 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

    Ld+e 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 f9+@?{xB(uR0Hlrgh;2 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

    paX`%`}FD{osliyh0*q-mId1o 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�_fJLY)h#3Cz{Xr7w#l7FKEy8zG4a_ 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 z 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μ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 diff --git a/.vaunt/badges/badge_05-03.png b/.vaunt/badges/badge_05-03.png deleted file mode 100644 index 559ff5b4c70e5cf73585afac7274b9dfe292021c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 112041 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

    ;_Q22Uiax$9|7lmL>va{W| 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≶GOt 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

    ^47!~IoX2fz~-r2hwEf}+i#ImmmYhpIh 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ϛJ^uq_Vfr3ha>G6iXaI+B|XXyv54H zWRQo$e*WualA~@y)Ey{^y4j5(B{dbV;AFjfW#z&sO2UGjiV!4ReD3MdW-b?6`}U-w z&Q%>HL$O(v&@eKeKiGv6uClX|k*C=`e^!r*z$T3wB#l!-wWg6J4w1#xqomh_X_RLY zbR9QlusB?5zFY=_lyvve{u zQEqs>*zQ8c650C(B{igp#sT%H)9;o70J)608>n74Vi1Ns>6~*hOYrz=DMVAAVT<++ zE>`x)vB>N7((qtDjEV?NH6ptQdzLxPevJc`Efc?da?ja$tM?k{)|vd+Zy)|THK3x| zx;(w`M3ZqwB2@?D@6hFRZOAq9*C!HoJV7@nKO?$)jE`H&d(WfpWcSLx`xF;@ZXPo_l(j^(fVkwxi=ShPEC3d zI}#e#lYaITL&z-pjO5|$PDwEY4wHU1XA~6dC~wAF9sGVbqNYMnTi7$CC!7RH&J|9`1W%Lx*#x70y!L}vv@4LKw>I-Ynt9rYbh$=i+f+1SXAyCEG3WJX zxhQ6sSx7l2F5@wW{XgmPBp0FD}rqiTPmvgy0WDj&5u24BcRP39gdE31Cr^&Q|L;HCvn zPcH|C;(vBSbIdM4cfQB+m4YSm*TArjV>106`81YOZ@jI~ydOgVfo9l?7~}+i+lvaO z9*}dg!>oZrQ)e=`YrKv&^smpdX3FKy9X$M+H!qx;Za7A>Vk+`tVzjpM}ZCH97hUbN~4 z5Ym`yh|TF4X@Bgi#wm~bA1GN~y(0V*>}B%xesfUP5~V*apm1EBiG8OPQQG#9u;O_s zY@w4^%iFrscqX+TTHF0lwSzmQ6=|0u<_d*k$h|{ zKk#*53HxTq5K?vPkD`c!9(>-XkhAO$=mO6HN9v$q;l{ zZ=UO2p6}6*X9xvL`yQ`;qJKQ_WkB9+wHn_4j&j~%@Ldb*u$3+}w@vy^TKUUwmO-S5 z>GB0#N_3Xf*fH5+&YE}dhfZ~GQJFzV7>38+`SkjORj*H!6NfpQd1zLFLTAT{br;pG z_4nO&dCKC}4JAJKbBq|#Ba#ffbDQDIg)a9wCrihq>kMxI>4tI+Y2C`icE&xl0MMdm zf>Rq2n*e}ZCS!nwpGS~%@7)|`Gycj4(C+8dWevaQvwULAvwRsfA1%)tx#iqIg}fNK zVCS?uaCxpY?XIbO($m>v83k7_>-CdzsaYU4C+FVUSwvBd^J*KdaELRi?8I|euKW9U zOf$39>S_pRs{Ym_myxgkH%bFo$W4t68Y-;gZV|1s^;!(9LfiAxpMKc`4@A??{fwCt z;~%GN{^)sy8Gw zF!jW;uFr5#*vtx)Vj5~*G>_{9d&!oXdeOG@zC@l$M*fDZUV)LZlEql;)1P6zVPe^X=JCO9Jk1OSXwJB;Z`K1 z)MXm&d9=h0fz(?+ylo_}c#e(R9{tQFUJ%A9Bb+=>|dR2Bl%>Zs~5MySp1vQi%bi zQ|azb=}xI3hVFRh`Cixi!~O@(KIiPU*Shb|ty>rqB=}jlN_J9IEivMFxqf9$E=tbO zkfN&fQ~-;Z1CY4G0Nz)n3b@iS2w2iAiNg_(abn+B>G=FP?QsiRcK_F<59Bn^iPYY5 zruEUkz4dWc-sncn4rymy|E?PUT;8TRBkbblZYx?iy@H$S0iOk;ES2_j&P0&DJbx>N1*2M1!S+EYJP6c z5>Pc901uqu3`S7ekd^cv-rDm@j9)&%iwz4de<*;ndB;>9ZI>WXl~VkPvlBR65!0h@LNP@km=^9x6e-lHH%pz) z{D_T6h8q32N+G^_1>m-N_j96Yu1hfiA7nF)5c8v=VRa&8i_aO&C2EKlXB#^F!H4GN!wZhoC#;}+?i z`LNf`#|#ce|4)yr{BGx~+>`mGYF?z@_0#C*?6k%B1Vi6Aynn%tjy4v}|e~Yr5 zRO+^N_xE@HTLXU9+weu%XTX_xzo;#S!19v2fC)F2{g}%TsHak#L3Bz&xf2P1e?;tt zjGt3gCg58#F#|Dr2p^&_qf~AKg_E<5-N5IC-lnadC$R`@Q~lE{q-Y*K;v`WmL*Wcx zF=SrvY7LsjXte7$*&7lD-l_O z(k#se;z_<*iyi@h$g@X@HeG7ge_T9(vvxuS(#UGGp-gf7u#N2HxV6lHJP*Bid%eqd zR)%K;?(Ze(^JxEuG`?J*u0M>D-K|<$Z`p~qbT&z1H#s%D2w_I~D&)@zez-DJ`Zw{T zVj3?rsJ#QZ!Mt~3xrTx)@r2sWT8skfsCm%!+rh#?pI=6JO3>N16Hoh_`rSHKT+ z-P7il@@%=x-e<)UiSYft#9WmgS((|b*)~mbtIm2$)hkUf4}djQ(c7S&KnlkxqX9;d zLw0;)+!iXry0((~EG7r3QCI$s^Mn&Rky6uzsM-2(@Y2x5m!M0cjg`by4NPpWM*!d( z9OW9>$rB`|3=!qBcKmz$Pe19Q-g*4n!Sn4Vb$fFu|C_y*r(3VU_=_?OgHM+uVc*zw z9RrV*?R9I>mF#$l{FM|GFdwdusu^^1rAsg)R5iKy!gu8yU%aFnF}{Db+x>H(N)$_5 zP2@vP;T*z7#DfMsHY0#Op(3tcNZ{f~RoNsH{uODlHK8M#HD@0uf$w%G{8 z8gh}!czstkO7OIj2el+}@rg)J*GBfV3WXT`t;XFcQu=1(4E-Y)aB#AuTxYfNm+a4% z@u;TPP(gx>qYF5H9t9~1yC?m$xudBM8=!of*RdVI2?LjTGhd7-gXxF!$GU|$?HvX-s$OA5NGLJSJU69trT-*F^Nur6q%8l zFAH@4LCs-R#*yta8W?IMD(57s^By?0+Jp`3I9KjI zU%@-^-o3vEa>#7KFV~Te##wPM586#TI>536p_2P_ zL1LEIvSG?M!qPYTBlS2>-L>bXL~N%8p2}JkI*DHEKEUd>3yhq=hc8cCI6+9~k>j{noKAEamb^g)+tYUdPpRIFgwY5Cm`EqQ$L&n6F0l!1v zs)V)Bp8{hclfl_ah2Io2Q4knZH4V{6>qJ~s_wn}eONs&Ce%Vj_u;eV!5S>N%7u6#8 zGdrLNwZro|-9_=l8`iCATku7j+kS-ZsDI}JpVNgdUqv7f)@bk?FCm&6tz$^TiZkv~ zThc3>$%l=t-)5t>exx$YnWtQ#3rj@)tG6(%o82fY*iFIU^PlLb`u_IYEeNcP@qK!P z%iw$y8>QdDahvdIToIdJy(&`(DVd1i}- z{rkDSa(XJ>Q8P2Czp(l$J1cR0E_J_|x=IXZf{Ww+g8-c^+f_5F!fYI(BzAcyjweog z2Q2Uej@g35+o@ZBdJ+(H(yE1L8UsCv;SVWP;QD2-ztSB2RNZSTp+}@Cwu~tw?LH>F z#bJd5O)alu<0i7b;-X3Lrw}sqk=uTd$H;bD*@_zr77!)IalJT9ykh-JTXa|v_oo-n zyHur~pG(RBV&wfCf5H)QjQZ>y7Z)n&&B_U!{0v z$YNSvB^*Js3aviW+kk&9HWpVWt*{SAk7>X!_^GM9Tmkz24wgsB+^m{75YLZA<$u;W zWeJC+mz0!r#n9)V0d#Jw=MH%5PyGt}U{a1@~n*Aiet zsRrp(3oeVlemxqz>GiV`?kZfBNV9rHcs3y|x^1xT2R{so6rEZ)P?MT!ngN2*-Mk1r z9q^GsSYb5k6f(ZXL?z?d|xJYq$vzuk@IW{pe-x2rNqv7%dq`s1% zRsROyh;+~#=SJ2N`v-&EYZcwwZ>H7WuvH3qtN`o4;T2#1F;dC1o`u;$)Qv78J};N+ z8b81@oW62xHjBB8>0h^C*T*`%!}zDh#(!t%GU1Wfl!PJ+o8K7}0&fL!a-VBMw?QOa z_{nIOOeM@N2I07J;ys@~s3}E(wJ_%L%wPFkSWb)eO0ho#n8p<0K8EKr@OYH{3+oRd zl-VlcWKB_(gkhylGj7;RS!awE!9 zf5Hn`$G=kw+?Trl1LX_uOFA_}mG{}pRZms&<-jyMBcoUbi(v~sJiZ2!LX)kyld#dA zm}dC+*UAercbF~b)cnh8u`7Q&T{De{ys@p#U~VMD@eA}D!ss)z7nWwbFkzg0kxgjF z^Ft38s|xpIVJTUW%hbnfMW)_5+p1D)?2MC7T{CgS(KoCJocDgLcA$#DXzVFvvYU0D zuS21p79sB~m;FY>gv`w@6Q%7JAM$Ya!ohlBj&OPb!vGFH;(M!}_zVv7v|yi@h^lM! zMONr)0t9wcQsBz&HU_+cBd@cz%3JtLl_RaYw2yM|Asf?53c+ltnyGoFgG!9+nEz(o zR8HhPTUZldPCafoPj#Dj@DB!UTHZ2QTlp|sg0P6$;fY=I1=`s=QEI;N5N;)-ko!8r zOFT0Ud)YDY`5F~AXJ=8{Ce#P9g&GwbQArTR?1c$HeDySx0D3nBix_wjvI=vva+}7& zLBbI&ITdXz;HVZ+%(bW%OWmOlaBtWZrItYEz&H4lwLJ3ugxRE8T3RkOKGl;Kc(GKB zpTk$3PbnU-yR5mM!HqX;hIFFjE(qug=pJDjdCML{fb0Q-iG>RkrYL>=p4YJ!IV`JB zJd2Hph!iOY<_6is_8g9c7LkAcVY#^W2bf*Trq#JBmttYHKPUmjk`~emeK~*OprwbQ%TTF7@%C^!ldHn?y|S~mRtxao`Pey@r3io)Z# zG+p_KPb&e9+Fl$UB=8uYbpv(W4h`J$nx6L8PGvIq51a9fP?!;5c!)mz<9HkON#QfN{BWyc*rw1}|3F8|pg1J5G@y+fUA^uVv-9xO0 z0>2Gx&AmVghgoMsee6)412Dg9c9?)NVsZ%j0>SVkO-%HG`<-~^=D+Q@wzBc7e zRHx_VC|PHU4CSrMiQRCQ;Gsi*2Nu3Fhe~>VG(Kp zon56EG|L`#=C|+Bxm(6Kj1p<+C`=E|8T|(WxaGdEjWA>CM|$oz!nz@*Tg+&naC@I1 zJj#{>5qH8G(ntj*C2V+n(-FlHWLhes{m%znOR56<-t@uJ z{$rPpW9G#e3>+`=Yn}M|a*{VYP7l7W&0Ve!FKsn#7o2`?RT9fXwJJ)9&aqT&TW_^t z1hYq6Se!*{`!cNGqgBxQO`|9hEk{GGi$3x4GB3abj-n21kNUjWUg%E!wziNuETMPb z>9?4Zf+$3vE(-EoM7)-Cn|w|w;Q3Z+MyDc@jrJFJ&7-U018@PgVGLf9pjcntgEhGD z6%pReQDcU-gX_akw+bkz-o>%7h-6T56^VHFsV;)tD0i9?ZOG-oWCktzDbY)%mkYXI{)ATdmzKL%Qa*m zEX?Q|cBux|2zx)&$l;EUVJf8WQPEaC8X-AJVe^TfKBsE8{NM{O&8b;Bk$Aunmt&cj zZ@>%15#a5Pl_8m3i*e@JF@e>R%>gS!Kh+$m2w%@;!TR$lC!CGjO3qRVX_d)Gv(Aqv z^DFYP2vP~)36w9x0ZR7)^e>i1MUvoj2BFt>W2VtXTd1we zRy_N5&rfznfpPc%IGS_#RHD7G@?#wWra%`%%IFC1F*D{5 z2HtK-&LGR2?K`L6q&*4xmfWw0Bn@1>wJoyDJP(o&CJR-Da3j*!Jmu0b`+-OTPLx^E zV?+?Msj@lWECoh64Qj!xWWyS23zy@^=Ig&}7yoa?cgFIH<|<*@@3~=6gBY^A~#j z$9`VCZ`21j3ANXJ+0Tj`b!sM+QF)2SVFRi+R4j$_69u%}WZ+PVAi@z)=VJJ(B=4vh zdNfNeo$vKNc2vBLYv8ldb%k>!lji(N@peL^tmZDFJM-I^tgqdDbU&BGB}RZe*uEWU z!|Qv_x5_ZqyYAf$kY*AySCzPk4tIKE!uPEu!xA#R7Vw*r<|7@)h&R)Ms#LH(9CT0rnTZ+?0#5Ala0r!&Q{Yp-l`L198bSMGsJmFoB0FGOzx`u@zhd2>7T+8y zlUD=-q@H?2;^}eSXNa1V*|zCGC@x(G|am5=tcRieKyZfeojD55TW}=OXCK{XkFV4XvDaK zO{F6bkWQ*S*XQ#t4_}-&z2xxjqgS9PgZYAMwX}P+4;dYkUcfdv^x-(bu*a(Nb|B-w zwtPk}2u_8*Uh`UMaLD1;MiuDF3w#wL(*Op)-I30#C_5uLG3B!T$B>62_m$B~F<`ev zv!{eDL|+)Pj!D4IoIHUSj5~`>HUc?K%)NAR4^R|dOAY-JU0)H|dNaq<|J!uL)W4m@ z7)Qb6vko=EX+uFU8Qb>F;R^7tH;;3^!Kc(4|4zJ_;NKglOAfVs;nk+Rra$ZxSbt;b z5UBN`rqBp9Atxhzh`wPC(Ikk_q>%Wff~B>=w^toN@F9TtFNZU68B^I3aVN5yI9lKe zTnbg|#$VBd!fn+ZuVdp=iXPK{%JuQv&dNI$(Muwhp?eV_I5pm9BlD0*agxNSWVrp; zpOlXSUv7-Z{l=`{%<`ui^TMzWoBj0IqLLBdb=~a&@lwA6MLX7mT8t{;B7HYv z{%ThtBmgR?LT(rnet=0xVurTp$=*xgu>E4`R_Og_H}@NcgzXWOW4Vvgj(Kgv5*e9H zihv9_@{hrj4L^G zWt#fuOw|lAUXfgvRafi8H!MW6mi66j!uV-4ngFxttC$`ro=k-b*03z$#_JK@-F2j> zslySS1vwc<@QotI=uJ>?)VxrPmnUl!$^Pgp*74I{yrJl+ zz_q;mk#ILJWqd?9W`~LsN|4~a?~4JCwXB4@;$N@K@5ysTzu`dp#{!8K9`ETT^mMYC zt*V%-1ti_~xju)q4Eb@u4WPh6z``PN(%{lW!a6ET4>|Qfb>^_{>9sRnt1nh5AkfW! z%7U}`+m%NI+?q}OE7#2IAn{)K=eV!JU{kXymBy_TelMAc{;;8nbKpF16hDTTXnNK;x?kGQP_? zZou%dY^ncy^g>z7X@;1-_LVtMRsX}B9Rh%)i9LvLS`qiW6)pxULzoNhrWoggBpzvL zay4rpQG;HU8L)a3x9zPp5ovoA&t#Xtt=JY6IH#7oy9aQ%*3HQZ)q(%OZ--ys@&9HB zsyTLITbpB8NMeCFO@0I`Q4sebf0%WPkx)vLc>^dKwrcu`T-5*4QNOjJ)8a$268TX) zI2r+tC8%8<&p;n6T71dYv@vdo(#(B)@l}zu>OD3PCzw#7hcmZbd(xoAhy3-t^I} zdYGQ$7ewh-jE>Vz`*X{t;Bs=k5Rx*Cvr?TdAwY8=jQt$WNPi1@_ z^R32%eRE{l&&IjzzNa57PH4zuvs=dJV|QOGeL>OEN-<;?i@sBAR%Y8d_Uc4*PN7v* zzswS}GFdKuPTt2KOVZmMfP)Py1-p5@1T9BIC1T;M6*41qYFyQi>Nnc+v;9B_?}Tkc zWQ+hh_?fvlZ$Gd2N6R|r_rck)i=x~krAxmt!}MW@$m-002?Dd2*y$6J^m|4^nDC3> z2np;v%{pI8p6yz{Ewp^TGV*Et{I8VDQ_yUHR~Cil((A2avxC#pkF{efUKHGL{8;?M z=(;yxNi>A;T>Mh8cZi77=t_*!=L8$tQj8t!^3_ZjG?4tS$RY2+0`DU1n^#WTx%Y1e zGr5b$#@75`j_XOV%i+C=u~IjyJ^#tetYR=f8{~bF9R{5LILkZR%T@W7|GEbp;<6v! z#i0nB+-Va&B@b^cv^W?ZAH{mrcBRJS6@#);??!yM=DTh<-+@brX!$)d_g@^!$x_KxvFJ-F4Ts3?&*BuNpof@ZnF=Hm6USvb zj^qETpw<8vZ9dNKgyCw^$M1KZJ!9Jg^1az7xv!5i^a^P^vDK_4Z^u>^z2ULJzYxj2 zzH%pR$A|5gMGMDjc-7mr)sd;^E;mfHN5!IfIlO?(8s2eMt}|t z2lQ{zV1y}N+2Es}y#V5OCAv5wzWi=NuEEM^u*P)K#p+`%Vg{R`%8tRqBfx7n;OsD; zX~gkXouC!7ijJFHh5!+)A$>L4;D>UJ0C_}?ispP z&kXG_F=GE-vp1@%ric7Q_|efx3A*zYtPgAP6%B5&*(Co+y^}rm7gL(=;H{=skHY(H zy_LU^i6eHxIG--0tDGG8{RdnU+R~9r5!Wx#bV7a0I>EdX?&J3)9eO>F3N`(P;7LAE z>g1qmeLKLo=K@_FgX_eUd?WIBrUZi{UV-2MXo`a-b@kg>k6V=Mvec9E0XkT&)KwyebYWt z#nb7}1LLda_x!XXC3r7c)B%|58M&UzU-(Y0X2f%af!D2p?(~FybSAst=aKSirbjm6 zYYR&g5MXKE_l@|}(sT$s1_5|Zw-w0W6vbBPO=Mi&b+1%d_grykuC*`^NlIrK+?6rb z!OLijcM3C&Ax4`E79a{Kzb{Qe#lkt-D!O+eE{U@%i#D#(Mjem`8ybEFFyS%N{ED%2 zZISO&S!e|DWfq}R3Rel0#9gxLw}>L(tGJkgWx-cTI`@Sbd@;)EqAE>y@8aDSfU$*w ziANzj2VlcWef@;=x1D6TTuB5a`b7j8v-X0K2Ij&dFL&SHN}Y0HU)}6Hn6o`L0#W(g0WY-D=XG)E1l<7%B!}~YT#tHSGv-^g&y7XxUTA8Klk)>dWRE>36!Q@uv($mn#oxpa505pb=9c6F#Ubl~ z23}*9O;BE5^Xbma{8hoAKr&d{3l4q*7CQC*h|2{h;C@MpaYXnwYXA2mkr$@!H89)_ z0;sSjC$`vamaK47C%TAhH>6{%@XyFMcuf=fvjdgtH*lIYai|&kVnh_M%jb#Bw)rMK z3#>RYm~_Lr4q01u?h-t>P4jc8Ncj zwF!W*$$ubnW;B3yc`U}!cPI_N3X7(7ngY(&{V;B}b9|TK^!k^_I~g)`sCAa7fUj?u z=YC86f$ZvizSnyHHb(#EQUj{0{O`+@%tgo66EOOw9)1z|gDwo`j^>*Q+}BhP-^g~b zktz7H#i_a7tvYXeXInbVE zt6#oN%=j3%Hh9Rwt;6aLiJaYy@mr}PbiN|%kq2SR4Q1~aS66w^?t<5a7z96WCB!CW zk1I2k_^qjm$Rn&W-Hn6|Xuos)!ISLAJJ_vd^f?|hyW4T$PBFXtAn6nEj!RD!Cun%- z4hw|yPB%T6qE?LspY{SJCgh>;fBSWDIMxcoP= zsAi*&XaKybqdSOln?Kv-BwDY>mTJSgxz^G(Rv2Qt)Ws@zSgxneVI?J zmHsyYtNJPk%xDtMl-<6g&G3>)k5Z!^NgAk(E0CvH_$+R`4BOD?ZSSN{TG`+D{4oOw z?6$%uH8v5`$^Ag^I+i;Vwyy>e;ot?I^XgJTdu!0G^zF3BtK3kt4M~and zJ4Wqm!|3f*vfWMuN}^bU8T9m5P`li)v978uGyCPiM9fE=W*Vg}U&-Dk9OhqwCxX58 z2`0-CwouUK*#e0Mzu|L+&xV+Hnzt6`D87HUQT;@1xL~;q)1d23v*%}i2ZAz7GX}z7 z!{+BlFcbKi{rs|bS=Bp!S&aw(i9c6)$7gBa2-2OQrWVWX0|?mzaLPq31FI|xne)!8 z-l3vg6e0k^V^R=wB4cjQPihq7o)f48Cxh03VZw~za=P3vzS z4?A?SOCFD#=cN_zw|R7a+eqA7d^W}SwI0rWj2plGH* zURKPc*PF(sz^xu?8Rgx5gtmu4ZI^Q?qH-Vc4nc7=$JU*O8tviYRA#O1^v*lWC84Zi z3#_FE-?1ea2hT?y8p5Q!l0G3dL9t&*Z2mz-vF#7Z2OG%}lehm|hP68rk~Z{>JeFK2 z95@_4@kYp&iy^$nLqCaiFAB>4EDR#*)ZR9co(oLsH_KC7M%JumAZpWC4@wLORkQ4@ zV23uB2->@Rm+dR`^&#tyc6HsjxbLVB9*nnNZ}X|#6cA4A*)g&Necqd`?1CyT`X7X}UsP7%CNgjUsY^qI2=e6u$1#!j`PDySOhy8!sp}))TMo7Rm!sBAfe) z?{QU0+46Y|LP=^aQSd zbJ1M)?(_57Jpc9mMvk!-Jjs^O$S+{YJ(HA<$J}<|6Q47$RY4&%*EZ@@4>H{jQL=`HQsBEp% zmPH)@_TH^Fqkcdv>rY*E3NbDVeaB0`|BSIxw%Fvdqv!1vI{dx(swTt?iJ7b;eP`BZ zKVnGIxspaSg^bYb4L?=F&}d);m-tCm3o&vsySEeCZ1Jf_JVh~Ot$Fg!5aV8mFKgCA z{h&c8fkN5NtOp!If?d9_^Q}6N>{<9eT0L~#=b6g;X)sC3`oQD!X{)sI^Y7wULFBeP zgXC&~B1|AC+NneOP14}h@;oZsjm+;c%4K?C+$$OA#*UdSAOB{;U~g48$(7WL&26@Y zu&t+AA*=0+enw62`#PtEVf(??Mm~=hHoq+2u?ClYL$56=*b`E-LHmRgN)Fh|ix(tv zU~+YJ^FXC(B7UtbNUz+Ns%=d2JOL3nB?l}QD|hiG3LrpI7&$)m|H_o8tKMvxEwvu} zDk%DINTPgXV__yvzrza&^fQn;(ECuyd$Y*zeCOwBe`Wf5Jgqfl=n7jqNq}&`$J?lo z`}_J3A3w6=CLtmdn_m{x#5(8myAn zD^V(zBLYxKqTpo1{LUS1qLg_9f^(+I>y{3q5O=aDZ*>y2_f4ralcUr7|!wI;;&4;BI9FQdJNfZp) zq#!sL2@z<8OGw=_HGyhfO!g{hSXlAsCF$}~ha!?4)Ne-n2F2Sy>8U0? z(h*E&$TiZ7Dz7wfx{Un#0e*%uf!kNh0{$MolK*}>noNSo&YmDQo&15E3esVPK41p< zle{pTCncdaOLa6FDRQ)XN&FYa6|t8#5GxkoZIafbvf_m)YS03WamfpK$&3@RG`2Sjf+=N1f^zHS>Qz^Fe zOY85hkeAbZuk*sS+pcd?Iql6^rY?hOt=?=Zm$BqUhk>f#(bMM7 zGF!y{tx8w&xytv(PAcp^gHs5W{gU%XQ;VD6Vy4!0KW~@NmgCCZnXBhMMqJ zxbB7KgN-*N(%}fEl|9US>U~NSX!utz08S+o3T@dr4$&Mjv)0-mX8 zwbk>%Dg+RaWaxtm)jf$qIvu7bad$Odtm8j~H>gmo9*(^78NBi&ENI~ z4))NVB>1h5eJ}X=usF9nFN$){ZSSR#S`_(EaK)+f*|}d++t)*K;;hN0TPpdBfJ5hu z`2st0tJG7(BlWcY$71V?f_qxB%i&XU*4{w3>tJnKG?` zn=u>o3#d?S3O7y>5`@`KSO2TPjhrYLJl@%`p@*aVr#vZ8`Tdl1Kcr)?_M`XFN#{Ez zjyNw!7N}Uk$k7T(8PI3u0yk%V20;@szh~fk z8(1Q#pkyqq#g4?%x~jP!?FbWp3KA_C`C%LR-dpy1BZGL#8I3wVwD91NW2wrvTo)5U$ZEijyhtO%fmtZ7d5e$9i0aOSJztf(m{J$^fF_${^#ljIV`vLPDJ6E|l_(b9gA{`BG^f2X%}HaBLS+$o?GWs&T5RJ)6#MOEhLo6C z2NNPOZ(*IvUFo%?oUI<}E^t!l7WM$4CAp8Zu;w;X^>+#B-2Qgy`VFYzd@5#rPy3}) zLHOH6^i5w{Xqf|hm~i1ALSfbNn^tJZgrBVI27~4_pYCts7CM!lG8L`QmCu25oJ3nK z8|$%*+zr^{mz5Eh=jY#c@BRrB+)e6vi&&ksyDdF5X6t4W3Vk9B`GTG|H}P>1o2jFK zqed#Aqy=^=jlM`^=p$l^Wprz;t+N2Nz<;5wiC1Tjz#J#SwVt)H&h~*z?6EpcCHXJ@BCr+UqwsGQeT*qHh6LB&t@g!LVfiBz<(>I6 zYGL#jBU$|PMY~mqCahU4M*<;0hKEAeJy#K7&j%f6XjwKLI?0bs?~5IvM?QQqC%4$r(q(D{v15P%t^*_ZhwyDYfQ%PqiwWb?1 zN%U6#YWMQ%ySCL?6@)AL$R&C);nO)weWr2Nahsv}q_NVUMKFvsmt7-&SIUU-xV|FW zPPcK-$(t-^M?HC310Q9)TCzVwh75D}20kQ$9&bVwKOM1ih4X|(x~|y%@K>T(I?bUp zxM^4T4eNL`J^%Ir+Q-y>D^P5dJGxc4(H^cVctU)izi_+<~~4TZIUG1 z`R{fG5TZsU(QUEXEN|-Z+b&7uN_NS!Ebqkn6kdA^4pwy7ep%Wsyqie2UI6X63b`Ey zJ*(2oXQHTl-s7m<sWXVxMt|u+%p+5Pm*yY{5lGf}>ySv>Dk8T<3+T zMhgO0p`7e^FX!0U*ghvo@JL&2idjrmZO4ZZl?^;nX4QSYj4W=PSUcH+chn&*hQcMr z_w}$elxsZp7dpql3uS}*I5O#fW0ns=8-fK~e;-@&0sCs950gR9m?yQjoznMX^y#Yh zoR5pnz7S;ve588>@_->V;su^6mXg{{mPo!&pA)=t95cEZ9LUEk@pzZy5>#_E`j7w6 zP@whYLvU4Z2a9l37rG3Qu1|9uS6xS07vW6<@68Zk+hCVSPBK_n+c=5HI1s(oGwZ`O zV-}&2m+;F|@j{B78YFN^47e2>*1=-%HI0D_TNnRN4m-A5NXclr2AW>2EjHzI|02S} zZ~DnfrdP+uQ#B8=87l`O-+=!%<0jcUfpQFqSme*IzJ_BA$s=0kkyIp)G(vX(o>5{l z7IZ5v{sLmefdA`AtPNv>o?hNiET-}amFuh3H6z48POQBSW?Q9lE3apmXZ_3*KX$=RL{Xjtm%Ys6LduJ}uz9%cc6V zt?sq__$@5Qn+O8xFPi*BrcvS(8-Y!^H(fjQuwy-{4!CdjcrTY>J5^X#OlsOyX!Q&S`}^( z**3k`E8pTKLy6ww<=X8UQl`Dtzj)je(fzKj`hChk(&Ce#?F{EVK#!QPzXJ;5X|J#j zUp!_Ks!O&zC^bC^aqH^@^KSWn(-d*22ERvU=z{mF+~yC^gd&1|dr??R3m?KK`^7uT z$)n!C;pi0KSX)5bTaXDYJh2Hb`;V*_Z%$Sx^L90pq9P-I-Pj>{_)Hpg5Vf=UU~DcZ z&IG^EB@xbkkNK67{vg_Yj!8zwekUswSrtW08a!CHJjtj)YS@O>1k9JmH5Yq1clp9 zfy(^5`0uCXh>LC!;K|!7KmMkZ&MTmJyEa2Ra*Tv-rqD$2%OGJ%LUnX5kHh-`wcBl% z6C#Y8A5WX3a(fc?4K+Mk;qX8akS7a`_zy(rmd%6=AAyQ3Cp8&rOEt! z8=`sZ-$JJS5tT(D4r7`o<(N-~J*vw5`U`0kkRaJ~my=`Gpf^H6~@1x880^#NWz2jgCi3T$p zFYZa*B%Al~8vS`s@8ss>7tJ9?rc-RHI?~)iMQrKP)|yLMWk9$# zaKlw?JD=CTTkwNzRr0R)8LxXIwF?U$KVS3sAv&7*2uFhsxZLIyg*J=d zsF;%%2dP1&yA8qe30Jn)edBM>IX$8K@{N>nuf7=L{?MPD#cf|EMV{~-OAyACRwT_8 zxD|hPUWOj3NB0D2wYX+xiM~}R>2LE&+DA_#ke|C~tK>4XCAl{+2_I=X_tCX}kAN2O znXy_nYyiT^?qZh5bgEnDVDn{H4*rwj?r(7T5`cTy5=!2g6cX~%-}WhJ&(_h=h?&TO z0t@KzNj0+Ag+WWAOuDR1T@B&89by?Z&d|&3HM?}i_1*v{^$)7Utxp*K~a)gTRyKL!Fn zyED_XJu(K!t()dHj7QWj_E(Um^wMqfZf;kbp9lM_4d?3aVd3{LZN zyXt3M(i#R;A~>&k{MO%{I;Gi>q+0UF1j3Oe@?C99T)#NvMGxHmnaKw;86p?VWV-3_ zwz_TW*17_`hQlWzEE2{*d_%!cT$eP6w$&DM$k!1n3!OzFfzm}F^>M3bEo!8 zZehTXah8*Gs*?5B zDg~rxACy`2ce1k|w$vw+c|!AOkt7jpR-4bvPymTIP-Nst1wa_k9f856J!$!D-I%Bk z!UBmK#)oY}SV}P8Si+7|wT)ud*F}QWo2o`bf1f#2=pnX%QLYU>#reTnaoiH$5aKM) zV(Hqitj&b|ZySYRu1|#^q-&&3e`=6$%83&FAI5IY7JQ}3@uB@lv6xwInnr~u=oW0_ z&C}H>@b3z@=jy!+J(Va_V50rW-+!k~<7`2DqbDkE1Bi0gAK=+bbi2e_W8;6bMgRM3 zwYz-&-7Wu2oRlhp?m0GvGot2vX*i0!QNUv_#_9`iebJLtA>_I4> z+Bi}y1%TLh83yy2P#fn{vjLWrs%%gJmtSX>mNaK_9^g~!;0@6Sam`(6iNQ$`Eg{Oa zHM>+lXaG`x_rD-Y*50?}*5s!^J#s93V6p<{;p8X0;w~PgzDi<6_FuLFKO-%Fj7g5; zlfsIAk<(K>zO18nR-KkIFT=j2wNXwYzwBm^@HXHwyZ}5@$ zzq}x9{BnSEwfuu}yfH_T{X3~d_MO{m4-CgLxn)RpOU_}ZhXco9IQ`pRMCHcnL*y=3 ze`R)x`-^|7vO)hxwOGUkq?Gog@$Ra$>7G^?ce)%sBI*fB%t<|VC-`V(1Uhcnn<7<5Ef4& zgO*cC@htA3)BFxSevjuo64a0#cqhewuK!^Is29j*-d##>=7I&nMo3W!`tt(j5G6-_ z;)w3#JxYp`14KPQj981;H&&9U0v-tg$iQ6H6%mt|VTf38U}wSzOfQf4%d4!UU5{!KauQGUB(?A0gzevenq zg(9CPOT9cjw{u!y1M7aUlYlMzBudF4;N90V_TR@*SvDOsIvm^7nK+{M z7?=NZ>s=4A)Ny8vP@r&7K*G93pWD_*A$xT-;8P$YKOUSeRCqpWHUN2eFv4jd7F_=a zltF90S)|h`PuE4~>H$L34=T8)uHUO1QX7H(aOp53o#WS?%INnKR1#CiaYfPPa!kvj)<)3o3?l8FeB#qt82!oglul;a|bsQoA5 zJx8=vEvT1D#lW7qn7c$AblEka7*rFKI%5jziFg78Jy5F{0o1`JRN@$bLE-XvxrPTA z;NtgAtX{pkDo_W2AAS2~5CR-DZ+2DXYN6u~I~K40A~znXJg6YC4w6V0-!#wwH06g+A(NsY6Q=eX~{`rMlpV3 zJMy^#SY&u_(XH_3@{zdy*Vo>{;}5CsXGcq?&;Qn#))z(panpVH$<6myU9M6vHw_cE z!Mw7?EE|b<9JU=pcfJRG1L5Xyl&Tu;<-M>0cHydOEg*bY$RsSA?*&#QGsgL)#7 z+$h(f0eWmLA=p6%OtFfPfm48bI-N#$H(w-#??>}a@{Xw>%eC0$^DwutOfjymt`1OK z(^e1aT+`igXrN7|GvI`B>ZWO+RC4`u@o;Jf^+Y_Oh$aP<19g535Ew8CfddB)C}1*2 zDF9$uv6?~sj`Nv9)4}r&uc}_ZO2%$c(wKaY5y ziR6F{+pv&Af|;UO7GP795Dc$rSr!uU1iIS0(AD1MUmqME#P9$1Ckz$_17#>YY<1u- z+yl>60(HtccAnRvFbxxqD}bH?Ad34+w)bsv(K>H00@T4d4*bY(S`k74@ut_e8!x#oG=Hu1rG59rm-gEW<)lGlLD!t~ z{fd0J>%_pkITXwZn7N}xOjw2`Z3D6GBY-`ZFoidn*#3DmP|FnLHq~dP19}+c^Lga+ zd2HUi*}vA@+>GhdcZdLWRhq0z62d^8&zpQM50d~z-KTu15>B0sZ*c6&fqE*HS}WJ2 z)EqlSw^F8&Q6B(Tf0C|BCi71%T>x4h;=@D;qtCjNZ5Md+H3x zW%C5J&%z8r?>ip{o=@CQ@V?;ZEw`s`+qUnFfn`_6ChU6%o224q47O>riCs$Pocc%~ zV;J3W{>^y#(dVl!S1lc}-(d*d8|RNwKL;thr+&i^ZiLUDd*7x*TojEGif#!7r-)*) zh*GKK|H{YwS6-BM_jTjrHJ{+^_x}k>U08O|UG2XN>ihu|ka zeGqTF^(N-doeSS@J=BFu;MmLd@GpObIkV@Ww^ul(0i^etFr}b5htI+O`|l^cAq1J0 z9O4F=D}tSQPQkAZA7D)p&bied8`FvntWIzw2R7$vfr4-N^ zOLb2g&=+93ojMb@b4HNoA{zeay%6{q%r8vf^gVSketKW{F%9%Tl}fFUTUKUyLX5Wo zd@HE&t*%D+HR|ng3DEUax3N^ou{7S~>M(B8g(YB<@*$D50FX+6G6ngvD%fi)PW|(mAIt_S9w3awT-f z`8R=J>vHOI_Bjkc`R&iJe&c76TI|(u>Yr}>4FC1e&vD8(PWIar* zk8{w8Z3xaO$ip)Z>6@MFCx8PW_+*55hqQeFX;}d5N0Z3#LNTh{0 z*E9@FnKc#bjnBO+VK5#}>sGDBFYf)Xh}7C>Le~Twck=NOlD4s-tIr-Cm~+mYb9W{& zVS7=CqQ*)lHisFC1V*N0JfY-OxzjMvE1!4EmMs*um9It$9e zh~rbxVVUe)EhrJFlv8Jb?tNQ+|D!l{pAlB#Rx5zM-FDMfeE8u9a9yf^7P}ewhWRxE zxm-Pfl~5M}!bVO7XB~*3r3d%aWn$jqWDdSIP-lDo38^k!ydJbuXNq$sc<8OM1oe0< z4xmpP3w4abKt1dusf(x3NBiKo4ydFDAS=pM3+lI@e-i+LLr&Owd+Ogh=2Tq&lbcoG z25JWNpZ)6R*n6+NFlq8+0N&H^xk;d8I_NR_(Q6N2+kx@O6jcz}(!B+}`Cb&Ak}r0Y zsQ~`*cxBv_WFf9|)W_9 z0IAw+u#8-Or0R=GF6t@2TtHZunm7#tPI^3C&%i$4ylR>LhTUNoCMo>IR{zh-oyO`t9f6 zhz+Yh#mSePURAkD>4?1#!=o?#506E|MDn&+isr&S3o_SQ}6BR#jQX5 zA%6V8kHz-`1U$-3o4Orl&6?#+W)O2A0g~AiGOcQu)opi}ioWbH3Ml&C;D}T#WR!hm z`PKcus3}ZoIoe^?bdNh9d+O`y#c7A1f~AW;sJd(vnA^mL2_pcal~BnkNw}w$<>t3R zP?z&n2I_r%)y0LEiHY3BJg&A^z4ki~%EBnfefufWA~MQ;ek4v^l!*p)nehdHZMNCw zMY+#`jn&rHaf6?IwjrtCFmFT`zcbr)RkR^Hp9vFP%iOvuZs&s*EYAn3SS-M{W1|9f z)<1QT0t6BUUYY;^AOJ~3K~%Nd1;`r!956TAeEJBMuNBl2i8yS_La|ij8GSKiD5z`C zOnn&%VwR0~JdR;!7z9+gr_q4=FMse~_-xgBTztM*G1<0yh1s6` zg((JCrHMomZkLH!u)XIIV=5nwmn|l-mZXF==xg$D6O!I#rOBF)`?wPQ}dfoO&!4 zlg1|;)MbWy^5jW=lr>I)8NoEoPk1L)1vlvaebZ0Pv zi1eWk4h{zT#QIyEqMYm-KD-=J&iSAVXF5bHBlktVpRjugD$1pj5|=KO3%>h=?YWxF zT+JKJ0H>Zx)B$GL$Hn$)CQPVJQSRkOpT`g9FRZ#;CA7z_G_3iwiHf5Np@0Veg$hR}ePo?z!h)*k`Z3nZ=6qa`Nw` zt|^OLTZ3qT08@6@7K!#WdQh!6mY}~kkE_qVyvlMT)0g($6MOEr*O=Ga*VBvBW}l1? z#}Ld-VkltFiBchL9f?Ykd9o~im-o-5nj_E4wMQw?*H_z?NH&`dZBtb)3$`yyG39c_ zVljlNl8FS4RSe_U$NK>-4`co)rHIAk1(EcfQB^7{pT}ac)q0NtPnZznL*A$WZG9!8 zf;v--)9cZ>Q-E{uYCh#mE3e-m@uRMZJhg#(sZ{bs7{R(!Q0L%F{CL(;{jD9;Q;C$w z7SO&|iu?AxE}*w!v>U_ zWQIrqrBVsqQ0;8HQ+X`6)=Hr6+2~53ZX1>d;wq>!fVG&`yARfS$W@`~u4}{-!Xm1v zpe}ofGe-n<5YAPX2lW7mmjQK=haJ83#+x|)_~S8m?p(b2=9{4&1@&bl4 zq5_Kq=gjiUV6L{$&xv$Rt;5pH31v{%pA83f%d(e2qX3|{w~v2M2PQe1OcLTW(X`HOal}578C$iW zPJ*DGALz$*3xkud{K*WN%#^K2gJSY6seUZ8)_9<9!!!&9)Gd>NeHf^l5~#}{u7_VW zD*$!&-Z6Kv%sg&nQ0MFFu?F>?-d_CX@yBt*oFj0;2`AvKx84eM6Wcbf4ZD8vi`ZqC zFQT!r(HDp7->_jAXqnQ6WG=0IDpPmdj)6JdQWnU=iQw5sp29P~s$M&MBs%UJ$7A}A zGsd*e4;HsGBDIkQGlU=DzV+buI*E~O~BZduNmTX^V1DM2!k0F^axmGo#3 z4{NTkulD&QlTkVJa_xmnCe-snL5b!Nu?W$}RiCff2Uwm{C$Q~!$Rb0O3rm|aWy)e` z6ae&iJpNZ616`Kkmjm_s`uflpiKpxPz(KLRT%UZdi|d)lJ**Gaf_kY`RPu+{rLOn+ zxnVF(+_408%d(M(@o=gDHG<=#gF2+ov_wl7E)FaGvbf!-zt^hT_j5(LapPKR0`*0I z`6s@6)VX60>I>$b&rFwU0d)^hbWs2JlaF!7kA4)+hj<@%sZ_$C8Hlq6pbV%R;h=7s z7AzgqBYeMC0_y&`59*%dj}buK=g`Lp)ZhQ$eO!L&W%$aM55%RHU4{=n{2<`_y{;~W zuC9sLeYf2(b?Q`P>eBoTmc9x2ABdfZp=H}PScw>zh?ByKS(v%!j!1T7uz_+DCh0p< zo=(X3L4c2zEXDQbTp9X2M?=|M7T1k2cmDgQU&c3QpM-pG^$KD2Ese<5X9Ej%PEi`| zE?g8)KmkQ*K*ND~a5!vVn;;&G!7w~~kD5STy-=${TrQV`Wtowjci8zzpe~$o5v7ct zZ*-hGJ5D4L5t0K{{4P@}m3mX_d{7Rv{r20x_Qo4;N}XhlGEoDMAKjQ>E}2MT$XgW>uKXoQGQ>C$5EsnVD}g^)MYo87!XR?C_Hi4Ky9Yva*R}-X z#d{)75x$#N_>>Rep+&<`-aYkXB@qbQR~exEUb5x^?-$D2>kZI1Mp`!@~G5ry+Vm4;&y%UBq z4z{>kqM3y<$IF*2!}&)9l_AH1zI(;R$kyllWzJ~nx4(QG-#`13n#$&y8W2m!CSw95 z0QO#ykiGLFig2a=^ZoUxJ@x#cuDih62=1TjfeGN(D+6Cx^e~`yKv%`>;acVbRAnr>~$e=E4`UKanx}^>4J98WBV5~vCKAXdq9?7ACK^QoQoJxHLCBl!px34ldJcM+j z4z?XrLER#r2|d-uUG#U{xN!h#0rh1#bN`cZ$5Z!V>dft`DjP*79CR%H_|Bj4j}QJi zrl9`dgAXEAm%;%D9-y^Iv3i?sxH2~p(ytz~A4_vC{f<=Lz=i<)R|3%N%pD-b%0`UaIj_%aZKDUFA`LV zO*v3!=_;t}uChg6i9dISEi`4Eiq?KtEe#BV1az5#iw+gkCr_R{Y+05Pm<0%(iGaGg z)JK~(VMb6fO@KNNL&|NVxleat1|ZDDqCi>LTf7>RF$F@67!)M0lDAJM!<|Obx0$|0$0AFy_Iat1U zX&`MZ=(=0SP8sylvo6LHzk0l;vh^*Eh$Z5I>pF1hm{ULru0J=k#3+}q{GC*}b5Wsf zS+KSE=Ym-XH&4@nN(S}b8nzoaWipvEAg-VDHdSec4C<==IsANjeKMyWE)@vp)MbvH znX9q3)%v4By`iCDMc6om0=nzEeTBZQ)%p&s4c-9DI)1k$qRI`611 zu9x%6;*G(a zd@=g-dAN=Xm%8lNrEpzGa0wpQK)|E`+_aACd~m5D=f*h~PCVe2m08(2yE`jxp{Z*e zQrS9BH^93dv$5SS+oNStE7m)kL%_frnJ8vmx_-~)cWgB<|LzqRkBK5&Z%;4IJ^oDm zwMHj5%^j@)r$RExz$L#^r7$pu5yHibdIk%Fa9lCJ$P{j_RvoB&R{#*?^RkyB} z6-lq&m*9C2)MfFz>Z3yj3Z-YjNcD1#VaWVgfP$&FC`JpnEJ~{19bxi z8XKGZef4VT-tXUmo6ozprm{Mnb>yj-*12s^Ic}7Sa{Yq?xcZ8#u=0~nD(FQtAOBgd z2Ork0VSKk?FvU1etKCn$MQFWS1`q7w1$p5Lazs*^Grb@#7ORgK zL;$a8!Lm$PwvCu&drn)3cMEKhlT4~i3)NKedR zowL#3*NwvNa`eOb3-Q7u&(u(IWSTx}Ixf1Rwta4y)~;NGZyY+WW-xDTZ7B=poPtD<`?hjLabm9S~k=7_xIsi8smED(0u zRJm5J54zHx>pCbFOM!V&9@FSWLNJX{82+)uSj_hGhA9??ncU@a+0Yj#^v&3N@4a6X zK*c+tf~F4Yx|TEta~-7R8`J?-{tY9MMv>1m&FayDI*;W}hzjcE>mng(V*~1$blMLY zDJ|^aYEjhW`eTNvg^wiIk{8=6zWW&tYNpzz+?M=&GMP-xp#H)m&*Jp`P8ySa%-hbr z5$ROjRsr>EuDAv(SF9Y>j%bhBk0lK&@wwXz%QRt|mgiJP26a;dbsnir19ch5BSGCW zWg|u?s0;0P*$$me1Wfy#1f#SWBH9|)lqZD6TqoXwmqlLVVD2frd2;~q`~diie*+)} zLAoh}_8F6q9pB)uEBQM=W!ARX?XW#P<+mtjBEk89gq+=a{tbBXk!MHo6r(Ad%i?GM z^U$d4d4JKraO9U}`8@2Rl62?g|AF1I3^%?+yHO~uC=0_urGT#M%#4$@&go!0QJx(Mv%1QYJa@hQ&-+01WZAWh@8>HK)toK ztxTS1TE1i%PTTJ!EE}Z=w7sbf7ajkda3CK8P`}m#b(P9Pyq;Pj4pugA!qWI!6lg&M zbyEU$OXJkdkkG3mgSus!Fs(A6?zx8bmEyb}D|YHc26gs68y+|A2Y(?1!~=B$9*7%; zFOm=E)PcID4BBUOp?Oj(i0NCO1B9TlwF!I7*&E|$bYfj;BL=DDEDGMc>;LIQyno^y zzU};*@X{mCm3>~Lq3dtG0i6>&M^(q;zx;2Ubm(04)v!;@VwtzVtkMY-12&2h9Jtig z=7(r=HcEkkA``Xy;&=%l34pp}c`%pjV!!20+Pb@YDylDxve`@sUN+myLog&)m zBn;FUP-ZgeKs|as`C6E`R~75CcEz!{&K(ep7Sx$Nx@w26gSwv1>tbz=J*a2uGD0anbktt6allUdY&B57?uu)JpiY&ail{F&gyqejVLjP|cr50Dx+Q^nnE2iFLAw%A zH;4!Brd1x)J!dp*USptc_}sbdQH}_3=bX9+(y|>qF(5c~!sDqEpHnw26ZP$lXrDe2 z&68ST$72k9y>vSs!}PspVV6U8M=|SSlhe&YwR#k_v?LMf{k{FTT@%!;YMd z<4+l#KFFOn+>Y;^_1&7myuP`~8^h|!rA*YWa+UBxr>b>wRh>a+2o7}xnEM$3ZUk9Q z+^$n4px)gbP}r`B8X6jWiRM^=I*YKzx#%#va@D?EPM0}#ovT+Bkl8QaKNnzL9@GIB z_4W0uLJ|O!0d&i<-xMng^^=l8op+iLprN4=VfzT-9B%lrx(Dy)Q2Is)-$!?qe6@f& zrA#3xm^UbXSMP&!G;06G0@O3nSUK^`%n(td0L4$*wEOAf8|!8-x&1vvMr5MS3#Y-k*x&OiR6f8WKd_55(jnP`3%uO z-H^oZq`df@aq93z@X2fnEtAKgbEhe&Z*PPhx7j<+zZVc}v(r@Ud&~jIO=-gV(k2X2 zU5mIn>hJBxWncXcUVilXQPoq9rq7yzyB@r!=JLHgy*O*`>A35LJ8CMQ%%srR+TzDD zuZ6^Ri@0LJ41zV7qnRORm~rzF%PUHmo6?cQ?a>qjslma)5UujcsG*@AZMXKkk|0I5w(AY_8?`@9$Qe)`T=i* zrmD8A0SMs0MbRx`s5FfJ!XSo<1%PNTH3xO7mM13hw8nJ`QYCf4Nt9RQwx ziK*= z0E|HOpe{S%ABj^B2X%}&sMlxeHDFfnQM(+V;5~kX}KGgACavRP?saJu_$gMgE|wr3(;fHO)SwkbrPy5XId80^=ULsY(dAY zF0@bYLUvp|>_iMOh%y)0aSI(&JF)+92V&~p(=n7PVzbi&$2YI6ob=at<$E9Df-j%B zRlytp7T$UzX6!h#rm}Co`UVc);}E>R_+K@Z&owt7m8lz3Fef00!3Lqi4YUgvC6q9X zA{-55%K>}Fb0$*@sD~-a)hcdJrBX)zz$QC3)WdE2zReC_6T5A=ix9;T`UB6 zT98xco;nkuz64}YCjn4D^w2{iSBa6VR(*Z_iiU=U&0Dr?X%e6-oW_WihInZ#%R(lT z@iZ3Ms)pYH-_Ky>X=u8B9G0K8%Z|IdyV2P>0b=ll3)yPy)VcBqOOxA#@9I_EV;0V5 zm_0u056>%0AZoQ!Pb3mZ#F7{)42l=eyE(tleBiz6s5XXtEPUxZn3pg;FNp!PK&3Za zejdC}qA|;|(A?Yt0KTzM?!K4p0J!1;DYuP1e|RCooL|OrYwr@Vl-zSrG!_1?V6E?7BE&i5Toe9I=GW zfSa&)h``G)NzMo%NTuu0K6L^nO`ih92nO6?6rA2r`BJq+0KD?pOSt>nKO9v(mC%{< z&&IqO_s#EEcpH9n!|gS<-O$ z)s!MA?q|ot!^0>P3KADyJEzX~<3)L0QBEH!SzBJzHI|%ueI^G`?UM>F2|X$!##9ao zLPhccEQyLP#1}dST3TAs(o&mQ8vs1^z{5CYpSd-O;4eAuJ2-0Z!?!A@{{DOK z&o^IF#P8mIxnZDfY6lu8v>@G-K`a$#+&+lVd8)kiZ7wj|l0Cem;33+P> z-A*40v>3ek8gPA}w;%U>=eGY9FrRnw3Ao|58>=qY+tZ70%{_HgVBR#oWvhWX^*C}D zt|YNxDUtPrJgjV;ZXyOm1#~G#y#39aYqLEE`2KlVz2!yg!Fi2ca2!X|%L655ah}+|yGqqqlERU<)1EoNF`}jb}RGG>GdMp-uHO!2Q9fyNDA7uHu;6~*R zlgMlOv3jm90%UFX(SUlXRFWL!AT)27_WRZZ^@d!%pHCYNZA>60S(&Ju?p+G3I6X2A zwx=G_4)2rx;t|3$;M?0f^p-28WlNUg)TYdWYK9;h3{5E2=W zL*SrJJaN7+UgwH(o^A;t@LanJr8t1q(K@LO+wVC82b^>WW*)RNvJ)GyrPPPKGY}er zmJWQ}VF5iBw;`Vqv9tf8z*IWKPT>G8HB9Y7J7^QOR za$4A)x>{Bzf_R*X+rvOz^jQVB8!NlK^b<^KV_kJa9cf#%0Jrgy95TvqcjGxkh>HF`9{Z2dxI~=$ZTDEJ$fHjOB zCyzmQI7HcPboAVVPvV+mF2RcTK4KRt$EvDn`m7mv>UYmntpxYr-T#5Z_BaS@SFNe3 z-DI{7^)1XSEeJBzQB8a9G~}C(80btg9U`gps;Lpw+uFvXu`x_^UY_df>&v!R38;HV z{xu_lq)pSrh7B80C=6?>oT!^-dE|kM2K8Wk^r4|4baZq``9+&@UGh1#OSb?3 zAOJ~3K~!FRFc0ziZuqw4VM-O@=h32WLgW=&a6!V-!~4S1O~XWYUk`jZ4qG^ffVx4M zd65AElNvB7fe8Z!HN127XMn(z#s-(P^Qr?FL1pDD*@0oYYLj$o6zxviI}|0R7~1=8#Ht^Bi@ii z(I{cqEucglf00PEapULG+w4Cxe&!z$@uUd|Hm}`?+fQ4F-~Hk_6o<8UX)AzwHkZXO zAO97)CUsR@rnkEX=bn5PetOSOYHzo(9?7~?z?G{$KUG4bQJ^ErbBnI0Dc9&P+Jnu7 zGbZ9%c>Yu>iH3#-w6?Y)l}e&mELCK}*4a5h3P2UYoG5@CjaQ;9K|Y_Cl)VvBhG=EP zy@qk|a@~4)+qRKTr>X@k8dA7>7*0Rju;XE<+N}-%H?v)dwY9l%Bu|d zCRGJD_S@Ll=qbkON?PRtutZ(sV65(O%L;QnJ>AIV>NVxE>J{aRMaTD(Ei1-}KB!U( zHA)++Qw8YJE6Szo>X3}bF)$>&X@STK3O=@Cm26M~6Z#&wnonHyq!xa^38-zt_4bp( zG+E_)m!F$q7-()Dhg7N`8#itUl&ge3UA+!x&p8eA&iMw;y6ik;bKzn&nZ7V#Dt`9e zd-2WN&O^T6K843`dl&<~ zdi-szvN0OsY%YtZe)lY9R1tLLy?2-3)Zu=FOW!m2P9P z80zcg{qyKP>0=pGlw)ay!f+t|IU_ansjMg`(!{x-AmhWErIh;OcF`Y}$U=InWqJGU z?c-O3-lW{hNMe##UU}u7_uqg2JXw`qF2mv^i!=b(u;DZO^Plf1*W_chO;tf7sMH|N zqihG8ni?^A@?=TuBfv&KXMN_gG*v`Jga9dz17d%!2Wr&+b6rj#F8JNSilzF;dAHUxqr%t4F@ijCyHX`L)&jdMh9n=Bf$Rm$< z@atdy`nLiJ5|tIX13-WOz^0WeSAHvO|C)2j{w;XN@pv4ccu}lGdQe;*q@XxlNezfg zSiO$p{(tt~JWi6Mx)c9KUUhXJLf%lClB8FxUxRd@{q@Eao9dM)N4SWIW~pQz4PPv?Em)_*)D*?;c3%v>>#(qOqQFy|zFlOQmN4wINLU@(J5q6H`5 ziD0h!GjtQCVIr5wqF5-x^E@=|W_&^z0d-B&P#qYIjcw}jN6d#R!;|>Kbm6;VnkM@D z`!O;y60EgXt5sw&86}=X)#LGYsV4x-%PYc|mOM#_f^!rr;>OKUK9U<;XsTMMC7=%v4!PEy-ODy3-}=H_NmtJQ;siH%k@P~ZqU zEG#3r(EvL!ty~_2X&P$=bwb#FdRg6`2IAql=1heiKG1mGy90GX2&hM~Qd^13Vp89R z`AOjC~DDM5X=`{`I@TJJ`K5o8n+Ua($gUi{an0Ner08^sQnYmhEF}gO%nqH1HLgCiF~?IJV^rdI9@r98%XCeV5|B$ zJzl-0E{>^yWo41i7g|h6WKbU)8*5yD{q?Eq=Rlht0Sbk}ecZZ{7Z6&%hZPY4WpHrN zuP~L;g&mM|01La1rip@FbbWYwdKzIJ-TbhIT{Qgt~%#yJki5jGy>?91j7L(@WGr(a}IG~`+pvZDqO?1WHK4w zm?L^%jhdejf^n+RCCmJuUUE+ewgC7P{nL#=~!-n#t%+ z1<@`c;6x^4M)DJdL%H(Y=4^O)xUDmHTT18vaQyhOU9+>ZSIPzf@qt`aubZZcqemwJ z1$af*YW-N@I!QerrjM5GIF7G&Cqnw@gHb)GsHDyToFCr8>ciDBvN4#v{w^Bv#b=3f z*_}%2x~`*X+o(0_L9ps&4~!HEjSK?Z_>BaX?}TWff>nIM2!%(OZ9sHgjt~OF&|z5_ z*tRVh3d$r;(hS2up-_P9x?QW_0pNij-;Zy8>FXHZx5t;(AxY>=q9GXSui(lHo{9Sp zKZxl?-+4unq%PjCK~m@OGpDC<_jiBrq?Fi+@P8~kQ9>t}JwAnRf8y)-+tW3O&!?OhV9vCdN!JF6Ah;c$93VjE`#)!MIJFcNkW&~oV4{>%ridbs+VZRYZkDwvLcM#VcH}~T;}6t%Y0FxPmJ&H@Ar>P zO~Oz4no{86i!b`ZzJ2>zIyz_z&}+5Y($S+wUoCfR5~#CZ%d#*raWt?h7dT?qvLqYN zD`{pchP$qdN@Wm+VXhg}2|*xDa&Q&*5Q>Ix@_s~lve9c$&t-F%o|}>KkSVgpPMKp6 zDU3*WKIk(bib~~__(v~-ZJ*Ob9r<42F<@++@ECYy}`Iss7auj1Ove+_p&{KE|gb%5Cb-2I)qaNmFY6qaS8 zIx+;)GVw&FP67ScBS-M%zxpS9{Et3_1OM?519H{pyw0G0;l7LT_3z$>Z9BH7X0b58 zfZu!Nf5%_{* zX@r12zcddoO_cSE9w`q8!cFoxE&^LZMgdZR~DdwpjbCV_lJkE7p)a&&a zF9-5Ch{u;XWu7=b%Gz8VrBW#c^VD^J=}WJB)5yq3%WV~H0s8Rp@bO0MkAk8 zX-2ZNw!FN8<>jS-SCn9dCir12eH!S7`3tF~&eBjW4+x;z9jH_4`F?go5+!wZFM>D; z;`myXT-V-!x~}W6?Ivo$7B21DsRx&OFf_wI@hb%N zY&PeA5c0E8**|bHO#^*>eP}itaNW)i?BI0Zf&IAoAHIO0(IJfQ+k+^e0|Z$!gKMw2 z28T~i;LxcfkSZCy7Vmom>Hxvw+yd_V;ZJeLZU2tNxdoKU11OcdJH_j4lL};5ID&qt zFRkLzXlr!>es&bT73S?Uufwx=JTKaC%pWHFT+DWf3SlB z<1{!{g_X@D3L7J_4NUC+hRYRVZ5e%5`tLLi;T z0Z0Y9(Xl49qG?U2H>eIu#+3qMGm1%srlC;igRbjcAI<;(%|;X7 z``7Q_M|a+X%ddJmN&_Vc&5Zo(K(8;Y;@+?S5MTSi7x9TVe*{1Kw|lWTHJ|j_tM7xb-huk> z|H13<(NFwcFo>$?=)_Un@UrXi_aFS*HA&@xioHu)5rgP36ktw4VZ(uk=y?9``8d%Kf8~ta-YX zl~u^g$Z>27!;Iw8RB-MfEu#TA$TW3=`vY8%j}rl!oP zsj2H!m5)|}Qznzep+kog*33oz_*t^z1Ci4wgSz857#u9aG|e@GI;Gs&oz;(1TvGRf zbkUjBdVsoRnpml=qUrGUuW$`KiZA|rHiWk}KpkKby8$*Rd0@r^#BaOpIk0pyILea{ zf=nihW|KKJiLOPd%M06=$z+hv7f`FMrWnAqrV~exokxL!qx`rrGXOO|KShdjcU4sQX02C|z=<6?arD6xznmLoqw zWR~N?^WRf5k|9sN4>uxNcSRW#`)q7RK&8vH0*w4WE9)Chb|nsm0(y$o|Y!wvvi*CT97-FVSBJWj|Sej zc->i?P($H{mG230(Kdx;x9fanWpx>kO&$s-6^b;Rh(}-uXCRAh3{p$?d;-K?CKn!> zo-Og}nvPPg==&4bK!^^_c{_gPMZYEi zI%^%l{>cM)?T6lkVCs9>KwT9>#$mJ&egmj)adewpQa`D8tjzM8gyjErzUZ+qdDLzWfF3 z+qX~tHiA2fyKcV=ulsMW#pKb+^vqh2ZtCc-l%aQdjsd{lNsGkS%+tU;NSgxcmTsbu z$qUY9bTpg>7M2wj`;jch21f#KW+H=H{hl^~_s0>}#lpe@DwRPgjoLSSdy@s#q(LQ( zC#_4buGY|K)FW|f$(zTgOX_0(h;?LP*=z>oa(LE>*tR54FBJ0l=tn zbO5;JmRlY;bLPy20AfIv1nP$mAHn|p`ym5IIw;52snbDSOsne#F1ze9h+loTpsr~e zOw)wtd2n49j^hMvj;G&PP=9RlF|4ev_*fu}s*y1il)~@~;WcRm>hb-S9w_QwBN$*Q z1+r!a#T-+aGavXm&YU^p`yPJ!SQ)%1cE#tfZaO%`4oIH6FhGAf6Xb8i@Lz0{Av9Lx&Fi ziFo{+Z1F9Fy65}8zWw&w{Tx(AWl5kO1s*l1hrZ#%u=CH~?fd#&JE$9m0mpHC7q8Jt z$k_w+dZUH|M}83`r9%2(4CNCO5a^!x5~YE9IKvFpVgxSrP>aWm)bx1?a$%QKL6K` zYf$&QOX8`FR8binLUpu?%2*Ykz}EA&BUjAJU@CQRyl*D=PoTE6iq*vxOdgm(ZE*#Y zk4(t?vERohsK4j`e-B>whp+des08Q>^9%UM-+UN<`L1^>3h12De6hDn{9Uw&Je^fo zoK3W)8+UhicXto&1b25r2<~pdg1ft0AhLQwcoY2 zAFLpZG*+(D`CdUG1`5GHbJ!Y=<$BVCG^&t1$+k^Rl29udPm50yyn0D-H@ zc?yv3?TyQZuD@TL+qP4kWADW=-Jy>j02k&3;COTv(-GmaM>+BQ=bj#@t2j38g&qc@ zgK1k9>XYRB2ngtB>+On=hQ@g9@#n!lNtX`|XU$M2$>p>ho$PqWcn}NW5WkCLEI~?; z?ie$A^!d`C)m9dQPrbhi!^zWmZU8Ax2O<^qLI1cM-HexwC-ssH?zn~1GETg*CEXDjGO2?9d=>S; zNP6t^CjM6BkGFj(dd+dx`AAuaNKp`YF`qwZuz7pHBM`a0fK*8=UcjLtf2h1tFrgwh z9s??~?weBzBi*(XH!(CyirdCE-AHFDm@|=wu_dqjqLSQncwo%|RQ`?cr5YF(78dll zF$};0$A|db==U%S)YsKLmUl3CAWAHXde5Q5c(Xo^xg+i>&5O4%z7$7=`WUWVpXl^H zhg8@1oS6NTC+SX2HwkzOwr>%HiOQRYA6nJdl@A=Lz;Ik`qDlJvb4MPH{STfoolt&e zR#wPqM`I>#y(^pWM7Vog*>VXSrE@h^6saz{j>&aE@(Yc=Gtq4~)_l$Mae?*Zh;59Na+AP+`S$y->%# ztI3G#y(p6Nd$(8;>_hjO$8M|VMl7GNk z%n1|9&1$a_ha`01LLFpcGKBNjGx3D(Pd6J}fL@zqlnjlZjmgdMU!?0`? z0F*Bo(ar30qmP?*w(XOD(|vI7uOFr^W*8qXqi7Hy=eCOnm$i=`0^inzkDK5Qd{kiN zHsyS965NzA2mZS_b%&&1?zbZ!HbS#E0zSu{|5>{nLdtvbdwsv`!A)jJGV4rXI#B<| z-DQm}5MgS{~zZrc9|7MD4L-K;MRBka1Dx$y@Es@-;qWpA;&!WnrFy*SpB&u^w-K&MR_B&n)AM2 z#O&>@8~TGK>|JA_`Ue#?D0M_Qe;}YG8tOYY&S!jF|HS0`I2kP`Ab4h`1wS8t-7Lcp zj;FE3Z*WGvQWMyTO| z0N!YokuL}77)-&C+uoG<^I}?HVM1{Ux%1@i(Yi> z)_Luq%Jbdj$?pdtAAp*jqBWAZHxQ&Hx|eDO_a`F|^iDqwiZ?D;c~@Cv5ws-z(Xw3Q zjVBX}w;25kxYWO7m&U^ZJfU!|;GN@h`qm6t*o-xlF*=aFrOX1{BuO3 zruiLDo+Ucc%mu-il_^WLO>4)J(iBRSRE>;;Fx*NHLyGW@u=OxMG8g&eY#AzCS!AU_ z{ee*Tn|9-h;eezCfnpra)H3c@YZpSgLzUgzSL`xe>xQ-t(3;DS=>v#dP#UesNy#D2 zk`B(uDcyZwqwc`U3axIMBgHxkiI@-a$LYgHl+AenVb3Fh$H86NiM8J=3fTbO=6%9S zr~m6U%!$0PI(huN2!w?H=J3l^t#cp}U*MCq<7STt{Kr|jXsAf%h%e%vHf!ianc3d+ z&CKma&et^Pb$!o4=e0fc@2Llf^`9s+JA#3EgF@T@Rk?F}{HN4a1#r3g`-j(^^aU&y zYyh>a1#+K|?8ZJ;#H9G2!TF^H3i$^=u|T?lfcK}vK$F!V+=WFVEqZKGVi9A_byfNh z!R$)gvHfrKsR|l?z77ZS+qDw@9v--Lr>`18&-abB44AF!VyG@y692+uVC{+|oPc{+ z>TS_;7;a#mmxQP~j<5{x;OpaFqG@-$y=X;w7Z41-#K`;?HOPs9nABRvwOefvilV`U zy@TlEaC#$VI2=aUVjAc1zSFt?#rWlmBf-Y&BgnnvN?2apf9>Asab;9A!uO&ZPRGa} z2V`m%KuY%97YVrN_>94wy^+Ntx>Sdnq?HBS{4*`T_;6?xw!@U`Nce3BWT1Ypm|*cb z@_&7^(49k`*3|svujPxFfrYO5%ruTnf~nJ6uO&!EOsuI;cfLqbqeud@922;HqN3{7T;PMefu;W7~o@NRf_pM;e4)A z(vv$vYisL;=#CQeK!oYQS@5;2b0Ami6DhoN&n|A)Lk!ta^DMZm`kg zNv+A?&H$v3JRo0feMy4HUwX=YZ1Nazo-)nU2pVtKsY zF>Jl8xQb&6aCa5?kt;okiHW5Ty&wKY1l(?KuxQ9By(H(h>KbT^cxD!|GBP+Qi5JwB zoPycWqR@Zv;*c&GRB{Cw!bI9>?pUa@-z-$L{HbCy12!9=$ZXX-RRm`k3BMSBwxy%O6Pr1l7LlNV{DbCD$^OBKvvkL#uV>^uCt14vTd z=nPI{TlYV>K@5VSd1`RV*Hr?HC=u-eIf8GME(!BX&q!dFs9h=6=!M@Y~g?v zt?3?2zOEaY^`p?oL@KPuEjZC2;5*~eJ!<4eZLo-Xd4Vg)?t!pLu& zAwo^kj~*ICvAcH}MQjzAin`6HOP4Zp>&9O#H=A)qY{rj`WS z14cYjsq+SDM-T~dVDmTce*?a_Vw{{e!SRF)XoT+c+mJq|qd#IpH4D5_O$R(h!h9xq<<83saq@!OAU zd#+;Q;Nwg9pZ$GXE*h7=`2pTTHGw+rh}Wphe?sTuv2I(n&}ZZ6gvDH&qpkEs2$mw@ z=N4WQs??PP%{Q=XlVC_$2-~5^eHQ~JuV(=>c;ZPA#ew$99

    `Drs*=2jZv;rq-s* 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 YkKNm`AVXW6lL>tOHnA|SGQ9KPe{GleTmS$7 diff --git a/.vaunt/badges/badge_06-01.png b/.vaunt/badges/badge_06-01.png deleted file mode 100644 index 03696a1e1567a23fcad02e39eea1db70f56de38a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 169523 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℞C|7XIIO@CXj?nW>iyLA!|SL3h=9eTXUK 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 Lb(5rT`~3d^NASy~ diff --git a/.vaunt/badges/badge_06-03.png b/.vaunt/badges/badge_06-03.png deleted file mode 100644 index 1c366f4e0fdc79ab2fb099a33b197d5e3a963378..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 123277 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� 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 diff --git a/.vaunt/badges/badge_06-04.png b/.vaunt/badges/badge_06-04.png deleted file mode 100644 index 6f237981a0b540d4e6c8305fe1cfb302805b92d6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 167564 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

    SVy?xRM?l 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 diff --git a/.vaunt/config.yaml b/.vaunt/config.yaml deleted file mode 100644 index 675a034d96b20..0000000000000 --- a/.vaunt/config.yaml +++ /dev/null @@ -1,162 +0,0 @@ -version: 0.0.1 - -achievements: - - achievement: - name: Debugging Dynamo - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-00.png - description: Awarded for creating useful issues. - triggers: - - trigger: - actor: author - action: issue - condition: count(created_at >= "2023-12-26" & labels in {'Useful Issue'}) >= 1 - - - achievement: - name: Merging Master - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-00.png - description: Awarded for getting pull requests merged. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(merged = true & created_at >= "2023-12-26") >= 1 - - - achievement: - name: Merging Wizard - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-00.png - description: Awarded for getting priority pull requests merged. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(merged = true & labels in {'Priority'} & created_at >= "2023-12-26") >= 1 - - - achievement: - name: Ivy Inspectors - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-00.png - description: Awarded for reviewing pull requests. - triggers: - - trigger: - actor: reviewers - action: pull_request - condition: count(created_at >= "2023-12-26" & merged = true) >= 1 - - - achievement: - name: Debugging Dynamo Bronze - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-02.png - description: Awarded for creating 5 useful issues. - triggers: - - trigger: - actor: author - action: issue - condition: count(created_at >= "2023-12-26" & labels in {'Useful Issue'}) >= 5 - - - achievement: - name: Merging Master Bronze - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-02.png - description: Awarded for getting 5 pull requests merged. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(merged = true & created_at >= "2023-12-26") >= 5 - - - achievement: - name: Merging Wizard Bronze - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-02.png - description: Awarded for getting 5 priority pull requests merged. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(merged = true & labels in {'Priority'} & created_at >= "2023-12-26") >= 5 - - - achievement: - name: Ivy Inspectors Bronze - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-02.png - description: Awarded for reviewing 5 pull requests. - triggers: - - trigger: - actor: reviewers - action: pull_request - condition: count(created_at >= "2023-12-26" & merged = true) >= 5 - - - achievement: - name: Debugging Dynamo Silver - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-03.png - description: Awarded for creating 15 useful issues. - triggers: - - trigger: - actor: author - action: issue - condition: count(created_at >= "2023-12-26" & labels in {'Useful Issue'}) >= 15 - - - achievement: - name: Merging Master Silver - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-03.png - description: Awarded for getting 15 pull requests merged. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(merged = true & created_at >= "2023-12-26") >= 15 - - - achievement: - name: Merging Wizard Silver - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-03.png - description: Awarded for getting 15 priority pull requests merged. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(merged = true & labels in {'Priority'} & created_at >= "2023-12-26") >= 15 - - - achievement: - name: Ivy Inspectors Silver - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-03.png - description: Awarded for reviewing 15 pull requests. - triggers: - - trigger: - actor: reviewers - action: pull_request - condition: count(created_at >= "2023-12-26" & merged = true) >= 15 - - - achievement: - name: Debugging Dynamo Gold - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_01-04.png - description: Awarded for creating 30 useful issues. - triggers: - - trigger: - actor: author - action: issue - condition: count(created_at >= "2023-12-26" & labels in {'Useful Issue'}) >= 30 - - - achievement: - name: Merging Master Gold - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_04-04.png - description: Awarded for getting 30 pull requests merged. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(merged = true & created_at >= "2023-12-26") >= 30 - - - achievement: - name: Merging Wizard Gold - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_05-04.png - description: Awarded for getting 30 priority pull requests merged. - triggers: - - trigger: - actor: author - action: pull_request - condition: count(merged = true & labels in {'Priority'} & created_at >= "2023-12-26") >= 30 - - - achievement: - name: Ivy Inspectors Gold - icon: https://raw.githubusercontent.com/unifyai/ivy/main/.vaunt/badges/badge_06-04.png - description: Awarded for reviewing 30 pull requests. - triggers: - - trigger: - actor: reviewers - action: pull_request - condition: count(created_at >= "2023-12-26" & merged = true) >= 30 From ca490b411bdef084d59b816412d5177699c56a70 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 09:56:11 +0000 Subject: [PATCH 837/978] fix: ensure matrix is invertible and stable for test_lu_factor --- .../test_experimental/test_core/test_linalg.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py index c459255a13a53..987de27a606bb 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py @@ -5,6 +5,7 @@ import numpy as np import pytest import itertools +import sys # local import ivy_tests.test_ivy.helpers as helpers @@ -1389,6 +1390,9 @@ def test_kronecker(*, data, test_flags, backend_fw, fn_name, on_device): max_num_dims=2, min_dim_size=2, max_dim_size=5, + ).filter( + lambda x: np.linalg.cond(x[1][0]) < 1 / sys.float_info.epsilon + and np.linalg.det(np.asarray(x[1][0])) != 0 ), test_gradients=st.just(False), ) From 4838ad68380b9bb6a347affd589d76418e28235f Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Mon, 19 Feb 2024 10:27:09 +0000 Subject: [PATCH 838/978] fix: revert TensorShape conversion within reshape (#28330) --- ivy/functional/backends/tensorflow/manipulation.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/ivy/functional/backends/tensorflow/manipulation.py b/ivy/functional/backends/tensorflow/manipulation.py index fc62760080b08..5e35641ab3c26 100644 --- a/ivy/functional/backends/tensorflow/manipulation.py +++ b/ivy/functional/backends/tensorflow/manipulation.py @@ -124,8 +124,6 @@ def reshape( ] if order == "F": return _reshape_fortran_tf(x, shape) - if isinstance(shape, (int, list, tuple)): - shape = tf.TensorShape(shape) return tf.reshape(x, shape) From 0e03cd5abd60d05a4105bf15b60d71238e65f0f8 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 11:19:55 +0000 Subject: [PATCH 839/978] feat: implemented lu_solve for tf, torch and jax backends with the test the test requires use of lu factor to create the lu and perm matrices and the value test has to be done manually. --- .../jax/experimental/linear_algebra.py | 11 ++++++ .../numpy/experimental/linear_algebra.py | 11 ++++++ .../paddle/experimental/linear_algebra.py | 11 ++++++ .../tensorflow/experimental/linear_algebra.py | 11 ++++++ .../torch/experimental/linear_algebra.py | 11 ++++++ .../ivy/experimental/linear_algebra.py | 18 +++++++++ .../test_core/test_linalg.py | 37 +++++++++++++++++++ 7 files changed, 110 insertions(+) diff --git a/ivy/functional/backends/jax/experimental/linear_algebra.py b/ivy/functional/backends/jax/experimental/linear_algebra.py index ac6fe6354152b..d5b6aa3d31174 100644 --- a/ivy/functional/backends/jax/experimental/linear_algebra.py +++ b/ivy/functional/backends/jax/experimental/linear_algebra.py @@ -186,6 +186,17 @@ def lu_factor( return ret_tuple((ret_1 - jnp.eye(*ret_1.shape)) + ret[2], ret[0]) +def lu_solve( + lu: Tuple[JaxArray, JaxArray], + p: JaxArray, + b: JaxArray, + /, + *, + out: Optional[JaxArray] = None, +) -> JaxArray: + return jla.lu_solve((lu, p), b) + + def dot( a: JaxArray, b: JaxArray, diff --git a/ivy/functional/backends/numpy/experimental/linear_algebra.py b/ivy/functional/backends/numpy/experimental/linear_algebra.py index 98e87e7efafa3..2224dcad492e1 100644 --- a/ivy/functional/backends/numpy/experimental/linear_algebra.py +++ b/ivy/functional/backends/numpy/experimental/linear_algebra.py @@ -217,6 +217,17 @@ def lu_factor( raise IvyNotImplementedException() +def lu_solve( + lu: Tuple[np.ndarray], + p: np.ndarray, + b: np.ndarray, + /, + *, + out: Optional[np.ndarray] = None, +) -> np.ndarray: + raise IvyNotImplementedException() + + def dot( a: np.ndarray, b: np.ndarray, diff --git a/ivy/functional/backends/paddle/experimental/linear_algebra.py b/ivy/functional/backends/paddle/experimental/linear_algebra.py index eacf1acf4278b..df21c54ab3a69 100644 --- a/ivy/functional/backends/paddle/experimental/linear_algebra.py +++ b/ivy/functional/backends/paddle/experimental/linear_algebra.py @@ -131,6 +131,17 @@ def lu_factor( raise IvyNotImplementedException() +def lu_solve( + lu: paddle.Tensor, + p: paddle.Tensor, + b: paddle.Tensor, + /, + *, + out: Optional[paddle.Tensor] = None, +) -> paddle.Tensor: + raise IvyNotImplementedException() + + @with_supported_device_and_dtypes( { "2.6.0 and below": { diff --git a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py index c8c7436fd663a..10d2f1b2c1705 100644 --- a/ivy/functional/backends/tensorflow/experimental/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/experimental/linear_algebra.py @@ -243,6 +243,17 @@ def lu_factor( return ret_tuple(ret.lu, ret.p) +def lu_solve( + lu: Union[tf.Tensor, tf.Variable], + p: Union[tf.Tensor, tf.Variable], + b: Union[tf.Tensor, tf.Variable], + /, + *, + out: Optional[Union[tf.Tensor, tf.Variable]] = None, +) -> Union[tf.Tensor, tf.Variable]: + return tf.linalg.lu_solve(lu, p, b) + + @with_supported_dtypes( { "2.15.0 and below": ( diff --git a/ivy/functional/backends/torch/experimental/linear_algebra.py b/ivy/functional/backends/torch/experimental/linear_algebra.py index 971f6bc16e2d8..5c7dc1492571b 100644 --- a/ivy/functional/backends/torch/experimental/linear_algebra.py +++ b/ivy/functional/backends/torch/experimental/linear_algebra.py @@ -215,6 +215,17 @@ def lu_factor( return ret_tuple(ret.LU, ret.pivots) +def lu_solve( + lu: Tuple[torch.Tensor, torch.Tensor], + p: torch.Tensor, + b: torch.Tensor, + /, + *, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + return torch.linalg.lu_solve(lu, p, b, out=out) + + @with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) def dot( a: torch.Tensor, diff --git a/ivy/functional/ivy/experimental/linear_algebra.py b/ivy/functional/ivy/experimental/linear_algebra.py index 9bcf56eb56af7..d8a22701bbbd6 100644 --- a/ivy/functional/ivy/experimental/linear_algebra.py +++ b/ivy/functional/ivy/experimental/linear_algebra.py @@ -495,6 +495,24 @@ def lu_factor( return current_backend(A).lu_factor(A, pivot=pivot, out=out) +@handle_exceptions +@handle_backend_invalid +@handle_nestable +@handle_array_like_without_promotion +@handle_out_argument +@to_native_arrays_and_back +@handle_device +def lu_solve( + lu: Union[ivy.Array, ivy.NativeArray], + p: Union[ivy.Array, ivy.NativeArray], + b: Union[ivy.Array, ivy.NativeArray], + /, + *, + out: Optional[ivy.Array] = None, +) -> ivy.Array: + return current_backend(lu, p, b).lu_solve(lu, p, b, out=out) + + @handle_exceptions @handle_backend_invalid @handle_nestable diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py index 987de27a606bb..f282fe070867e 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py @@ -1417,6 +1417,43 @@ def test_lu_factor(dtype_x, test_flags, backend_fw, fn_name, on_device): assert np.allclose(L @ U, P @ x[0]) +@handle_test( + fn_tree="functional.ivy.experimental.lu_solve", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + shape=helpers.get_shape( + min_num_dims=2, max_num_dims=2, min_dim_size=2, max_dim_size=2 + ), + num_arrays=2, + shared_dtype=True, + ).filter( + lambda x: "float16" not in x[0] + and "bfloat16" not in x[0] + and np.linalg.cond(x[1][0]) < 1 / sys.float_info.epsilon + and np.linalg.det(np.asarray(x[1][0])) != 0 + ), + test_gradients=st.just(False), +) +def test_lu_solve(dtype_x, test_flags, backend_fw, fn_name, on_device): + dtype, arr = dtype_x + A, B = arr[0], arr[1] + ivy.set_backend(backend_fw) + lu_ = ivy.lu_factor(A) + lu, p = lu_.LU, lu_.p + X = helpers.test_function( + input_dtypes=dtype, + test_flags=test_flags, + on_device=on_device, + backend_to_test=backend_fw, + fn_name=fn_name, + lu=lu, + p=p, + b=B, + test_values=False, + ) + assert np.allclose(A @ X, B) + + @handle_test( fn_tree="functional.ivy.experimental.make_svd_non_negative", data=_make_svd_nn_data(), From 1ba9919d940dfc6716a46ed4ff0d0ff6f78ec77a Mon Sep 17 00:00:00 2001 From: Lee Bissessar <120032434+leebissessar5@users.noreply.github.com> Date: Mon, 19 Feb 2024 07:25:05 -0400 Subject: [PATCH 840/978] feat: implemented hardsilu (hardswish) activation function (#28300) --- .../array/experimental/activations.py | 25 ++++ .../container/experimental/activations.py | 114 ++++++++++++++++++ .../backends/jax/experimental/activations.py | 8 ++ .../numpy/experimental/activations.py | 12 ++ .../paddle/experimental/activations.py | 7 ++ .../tensorflow/experimental/activations.py | 10 ++ .../torch/experimental/activations.py | 8 ++ .../ivy/experimental/activations.py | 52 ++++++++ .../test_nn/test_activations.py | 22 ++++ 9 files changed, 258 insertions(+) diff --git a/ivy/data_classes/array/experimental/activations.py b/ivy/data_classes/array/experimental/activations.py index 79538a0a4e5b6..5798896266b90 100644 --- a/ivy/data_classes/array/experimental/activations.py +++ b/ivy/data_classes/array/experimental/activations.py @@ -554,3 +554,28 @@ def hardshrink( ivy.array([0., 0., 0.]) """ return ivy.hardshrink(self._data, lambd=lambd, out=out) + + def hardsilu(self, out: Optional[ivy.Array] = None) -> ivy.Array: + """ivy.Array instance method which acts as a wrapper for ivy.hardsilu. + + Parameters + ---------- + self + input array + out + optional output array, for writing the result to. It must have a shape + that the inputs broadcast to. + + Returns + ------- + an array containing the output of the hardsilu/hardswish function applied + to each element in ``x``. + + Examples + -------- + >>> x = ivy.array([1., 2., 3.]) + >>> y = x.hardsilu() + >>> print(y) + ivy.array([0.66666667, 1.66666667, 3.]) + """ + return ivy.hardsilu(self._data, out=out) diff --git a/ivy/data_classes/container/experimental/activations.py b/ivy/data_classes/container/experimental/activations.py index 98347733a7a72..f561d7f3a8ec8 100644 --- a/ivy/data_classes/container/experimental/activations.py +++ b/ivy/data_classes/container/experimental/activations.py @@ -1837,3 +1837,117 @@ def hardshrink( map_sequences=map_sequences, out=out, ) + + @staticmethod + def _static_hardsilu( + x: Union[ivy.Array, ivy.NativeArray, ivy.Container], + /, + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + out: Optional[ivy.Container] = None, + ) -> ivy.Container: + """ivy.Container static method which acts as a wrapper for + ivy.hardsilu. + + Parameters + ---------- + x + input container + key_chains + The keychains to apply or not apply the method to. Default is ``None``. + to_apply + If True, the method will be applied to key_chains, otherwise key_chains + will be skipped. Default is ``True``. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + out + optional output container, for writing the result to. It must have a shape + that the inputs broadcast to. + + Returns + ------- + a container containing the output of the hardsilu/hardswish function applied + to each element in ``x``. + + Examples + -------- + >>> x = ivy.Container(a=ivy.array([-0.5, -1, 0]), b=ivy.array([0.5, 1., 2])) + >>> y = ivy.Container._static_hardsilu(x) + >>> print(y) + { + a: ivy.array([-0.20833333, 0.33333333, 0.]), + b: ivy.array([0.29166667, 0.66666667, 1.66666667]) + } + """ + return ContainerBase.cont_multi_map_in_function( + "hardsilu", + x, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + out=out, + ) + + def hardsilu( + self, + /, + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + out: Optional[ivy.Container] = None, + ) -> ivy.Container: + """ivy.Container instance method which acts as a wrapper for + ivy.hardsilu. + + Parameters + ---------- + self + input container + key_chains + The keychains to apply or not apply the method to. Default is ``None``. + to_apply + If True, the method will be applied to key_chains, otherwise key_chains + will be skipped. Default is ``True``. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + out + optional output container, for writing the result to. It must have a shape + that the inputs broadcast to. + + Returns + ------- + a container containing the output of the hardsilu/hardswish function applied + to each element in the input container. + + Examples + -------- + >>> x = ivy.Container(a=ivy.array([-0.5, -1, 0]), b=ivy.array([0.5, 1., 2])) + >>> y = x.hardsilu() + >>> print(y) + { + a: ivy.array([-0.20833333, 0.33333333, 0.]), + b: ivy.array([0.29166667, 0.66666667, 1.66666667]) + } + """ + return self._static_hardsilu( + self, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + out=out, + ) diff --git a/ivy/functional/backends/jax/experimental/activations.py b/ivy/functional/backends/jax/experimental/activations.py index af914da4a4f88..f8a87fc7607f1 100644 --- a/ivy/functional/backends/jax/experimental/activations.py +++ b/ivy/functional/backends/jax/experimental/activations.py @@ -160,3 +160,11 @@ def hardshrink( if ivy.exists(out): return ivy.inplace_update(out, ret).astype(x.dtype) return ret + + +@with_unsupported_dtypes({"0.4.16 and below": ("float16", "bfloat16")}, backend_version) +def hardsilu(x: JaxArray, /, *, out: Optional[JaxArray] = None) -> JaxArray: + ret = jax.nn.hard_silu(x) + if ivy.exists(out): + return ivy.inplace_update(out, ret).astype(x.dtype) + return ret diff --git a/ivy/functional/backends/numpy/experimental/activations.py b/ivy/functional/backends/numpy/experimental/activations.py index 45d1a6b3c01d0..3acf91898788c 100644 --- a/ivy/functional/backends/numpy/experimental/activations.py +++ b/ivy/functional/backends/numpy/experimental/activations.py @@ -202,3 +202,15 @@ def hardshrink( hardshrink.support_native_out = True + + +@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +@_scalar_output_to_0d_array +def hardsilu(x: np.ndarray, /, *, out: Optional[np.ndarray] = None) -> np.ndarray: + ret = x * np.divide(relu6(x + 3), 6) + if ivy.exists(out): + return ivy.inplace_update(out, ret).astype(x.dtype) + return ivy.astype(ret, x.dtype) + + +hardsilu.support_native_out = True diff --git a/ivy/functional/backends/paddle/experimental/activations.py b/ivy/functional/backends/paddle/experimental/activations.py index 13e004e82652e..be09386ca5026 100644 --- a/ivy/functional/backends/paddle/experimental/activations.py +++ b/ivy/functional/backends/paddle/experimental/activations.py @@ -252,3 +252,10 @@ def hardshrink( F.hardshrink(x.img(), threshold=lambd), ) return F.hardshrink(x.cast("float32"), threshold=lambd).cast(x.dtype) + + +@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, backend_version) +def hardsilu( + x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None +) -> paddle.Tensor: + return F.hardswish(x) diff --git a/ivy/functional/backends/tensorflow/experimental/activations.py b/ivy/functional/backends/tensorflow/experimental/activations.py index 2c5140fa83975..259c82c3255ce 100644 --- a/ivy/functional/backends/tensorflow/experimental/activations.py +++ b/ivy/functional/backends/tensorflow/experimental/activations.py @@ -185,3 +185,13 @@ def hardshrink( if ivy.exists(out): return ivy.inplace_update(out, ret).astype(x.dtype) return ivy.astype(ret, x.dtype) + + +@with_unsupported_dtypes({"2.14.0 and below": ("complex",)}, backend_version) +def hardsilu( + x: Tensor, /, *, complex_mode="jax", out: Optional[Tensor] = None +) -> Tensor: + ret = tf.multiply(x, tf.nn.relu6(tf.math.add(x, 3)) / 6) + if ivy.exists(out): + return ivy.inplace_update(out, ret).astype(x.dtype) + return ivy.astype(ret, x.dtype) diff --git a/ivy/functional/backends/torch/experimental/activations.py b/ivy/functional/backends/torch/experimental/activations.py index e487d99bb5fa1..8af005a250047 100644 --- a/ivy/functional/backends/torch/experimental/activations.py +++ b/ivy/functional/backends/torch/experimental/activations.py @@ -162,3 +162,11 @@ def hardshrink( if ivy.exists(out): return ivy.inplace_update(out, ret).astype(x.dtype) return ivy.astype(ret, x.dtype) + + +@with_unsupported_dtypes({"2.0.1 and below": ("complex", "float16")}, backend_version) +def hardsilu(x: torch.Tensor, /, *, out: Optional[torch.Tensor] = None) -> torch.Tensor: + ret = torch.nn.functional.hardswish(x) + if ivy.exists(out): + return ivy.inplace_update(out, ret).astype(x.dtype) + return ivy.astype(ret, x.dtype) diff --git a/ivy/functional/ivy/experimental/activations.py b/ivy/functional/ivy/experimental/activations.py index f486b57c87960..a9d41129fd362 100644 --- a/ivy/functional/ivy/experimental/activations.py +++ b/ivy/functional/ivy/experimental/activations.py @@ -960,3 +960,55 @@ def hardshrink( [ 1.70000005, 4.19999981, -6.5999999 ]]) """ return current_backend(x).hardshrink(x, lambd=lambd, out=out) + + +@handle_exceptions +@handle_backend_invalid +@handle_nestable +@handle_array_like_without_promotion +@handle_out_argument +@to_native_arrays_and_back +@handle_device +def hardsilu( + x: Union[ivy.Array, ivy.NativeArray], /, *, out: Optional[ivy.Array] = None +) -> ivy.Array: + """Apply the hardsilu/hardswish function element-wise. + + Parameters + ---------- + x + input array + out + optional output array, for writing the result to. It must have a shape that the + inputs broadcast to. + + Returns + ------- + an array containing the output of the hardsilu/hardswish function applied + to each element in ``x``. + + Examples + -------- + With :class:`ivy.Array` input: + + >>> x = ivy.array([1., 2., 3.]) + >>> y = ivy.hardsilu(x) + >>> print(y) + ivy.array([0.66666667, 1.66666667, 3.]) + >>> x = ivy.array([-2.1241, 1.4897, 4.4090]) + >>> y = ivy.zeros(3) + >>> ivy.hardsilu(x, out=y) + >>> print(y) + ivy.array([-0.3101, 1.1147, 4.4090]) + + With :class:`ivy.Container` input: + + >>> x = ivy.Container(a=ivy.array([-0.5, -1, 0]), b=ivy.array([0.5, 1., 2])) + >>> y = ivy.hardsilu(x) + >>> print(y) + { + a: ivy.array([-0.20833333, 0.33333333, 0.]), + b: ivy.array([0.29166667, 0.66666667, 1.66666667]) + } + """ + return current_backend(x).hardsilu(x, out=out) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py index 75fbc12a2fdc2..a056aa7291462 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py @@ -98,6 +98,28 @@ def test_hardshrink( ) +# hardsilu +@handle_test( + fn_tree="functional.ivy.experimental.hardsilu", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + large_abs_safety_factor=8, + small_abs_safety_factor=8, + safety_factor_scale="log", + ), +) +def test_hardsilu(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): + dtype, x = dtype_and_x + helpers.test_function( + input_dtypes=dtype, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_name=fn_name, + on_device=on_device, + x=x[0], + ) + + # hardtanh @handle_test( fn_tree="functional.ivy.experimental.hardtanh", From 1d5255feb8114fe6f1dc12ae8fd58ae49b3902ad Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 12:44:41 +0000 Subject: [PATCH 841/978] fix: ensure separation between current fw and ground truth returns perform manual check on whether the X is correct manually using AX = B. Only done for fw. --- .../test_experimental/test_core/test_linalg.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py index f282fe070867e..07c00507e29e2 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py @@ -1406,11 +1406,13 @@ def test_lu_factor(dtype_x, test_flags, backend_fw, fn_name, on_device): fn_name=fn_name, x=x[0], test_values=False, - return_flat_np_arrays=True, ) # check decomp is correct manually by getting the values from test_function above # this is because the decomposition is not unique and test_values will not work - LU, p = ret.LU, ret.p + ret_f, ret_gt = ret + + # check that the decomposition is correct for current fw at least + LU, p = ret_f.LU, ret_f.p L = np.tril(LU, -1) + np.eye(LU.shape[0]) U = np.triu(LU) P = np.eye(LU.shape[0])[p] From f7f06d16390a59f83dc07934c5c68534a5bb43af Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 13:01:22 +0000 Subject: [PATCH 842/978] feat: add lu_factor_ex in torch frontend and the relevant tests --- ivy/functional/frontends/torch/linalg.py | 15 ++++++ .../test_frontends/test_torch/test_linalg.py | 54 ++++++++++++++++++- 2 files changed, 68 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index f53fc7744bf5b..40418d3b3f240 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -135,6 +135,21 @@ def lu_factor(A, *, pivot=True, out=None): return ivy.lu_factor(A, pivot=pivot, out=out) +@to_ivy_arrays_and_back +def lu_factor_ex(A, *, pivot=True, check_errors=False, out=None): + try: + LU = ivy.lu_factor(A, pivot=pivot, out=out) + info = ivy.zeros(A.shape[:-2], dtype=ivy.int32) + return LU, info + except RuntimeError as e: + if check_errors: + raise RuntimeError(e) from e + else: + matrix = A * math.nan + info = ivy.ones(A.shape[:-2], dtype=ivy.int32) + return matrix, info + + @to_ivy_arrays_and_back @with_supported_dtypes( {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 89ed457355945..66fb4a14c4c07 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -735,7 +735,43 @@ def test_torch_lu_factor( backend_fw, ): dtype, input = input_dtype_and_input - helpers.test_frontend_function( + ret = helpers.test_frontend_function( + input_dtypes=dtype, + backend_to_test=backend_fw, + test_flags=test_flags, + frontend=frontend, + fn_tree=fn_tree, + on_device=on_device, + rtol=1e-03, + atol=1e-02, + A=input[0], + test_values=False, + ) + ret_f, ret_gt = ret + LU, p = ret_f.LU, ret_f.p + L = np.tril(LU, -1) + np.eye(LU.shape[0]) + U = np.triu(LU) + P = np.eye(LU.shape[0])[p] + assert np.allclose(L @ U, P @ input[0]) + + +@handle_frontend_test( + fn_tree="torch.linalg.lu_factor_ex", + input_dtype_and_input=_get_dtype_and_matrix( + batch=True, square=True, invertible=True + ), +) +def test_torch_lu_factor_ex( + *, + input_dtype_and_input, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, +): + dtype, input = input_dtype_and_input + ret = helpers.test_frontend_function( input_dtypes=dtype, backend_to_test=backend_fw, test_flags=test_flags, @@ -745,7 +781,23 @@ def test_torch_lu_factor( rtol=1e-03, atol=1e-02, A=input[0], + check_errors=False, + test_values=False, ) + ret_f, ret_gt = ret + ret_f_matrix, ret_f_info = ret_f + if ret_f_info == 0: + ( + LU, + p, + ) = ( + ret_f_matrix.LU, + ret_f_matrix.p, + ) + L = np.tril(LU, -1) + np.eye(LU.shape[0]) + U = np.triu(LU) + P = np.eye(LU.shape[0])[p] + assert np.allclose(L @ U, P @ input[0]) @handle_frontend_test( From d83d5fad0057e38edcbbd60219b3cf7c992dbae6 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 13:09:13 +0000 Subject: [PATCH 843/978] feat: add torch.linalg.lu_solve to torch frontend and the relevant tests --- ivy/functional/frontends/torch/linalg.py | 4 +++ .../test_frontends/test_torch/test_linalg.py | 31 +++++++++++++++++++ .../test_core/test_linalg.py | 3 +- 3 files changed, 37 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index 40418d3b3f240..4df5186b46b1b 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -150,6 +150,10 @@ def lu_factor_ex(A, *, pivot=True, check_errors=False, out=None): return matrix, info +def lu_solve(LU, pivots, B, *, left=True, adjoint=False, out=None): + return ivy.lu_solve(LU, pivots, B, out=out) + + @to_ivy_arrays_and_back @with_supported_dtypes( {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 66fb4a14c4c07..d8ec53c3e8aed 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -270,6 +270,37 @@ def _vander_helper(draw): # ------------ # +@handle_frontend_test( + fn_tree="torch.linalg.lu_solve", + dtype_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + shape=helpers.get_shape( + min_num_dims=2, max_num_dims=2, min_dim_size=2, max_dim_size=2 + ), + num_arrays=2, + shared_dtype=True, + ).filter(lambda x: helpers.matrix_is_stable(x[1][0], cond_limit=10)), +) +def test_lu_solve(dtype_x, test_flags, backend_fw, fn_name, on_device): + dtype, arr = dtype_x + A, B = arr[0], arr[1] + ivy.set_backend(backend_fw) + lu_ = ivy.lu_factor(A) + lu, p = lu_.LU, lu_.p + X, X_gt = helpers.test_frontend_function( + input_dtypes=dtype, + test_flags=test_flags, + on_device=on_device, + backend_to_test=backend_fw, + fn_name=fn_name, + lu=lu, + p=p, + b=B, + test_values=False, + ) + assert np.allclose(A @ X, B) + + @handle_frontend_test( fn_tree="torch.linalg.cholesky", aliases=["torch.cholesky"], diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py index 07c00507e29e2..1e15bdc2ff1fb 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py @@ -1442,7 +1442,7 @@ def test_lu_solve(dtype_x, test_flags, backend_fw, fn_name, on_device): ivy.set_backend(backend_fw) lu_ = ivy.lu_factor(A) lu, p = lu_.LU, lu_.p - X = helpers.test_function( + X, X_gt = helpers.test_function( input_dtypes=dtype, test_flags=test_flags, on_device=on_device, @@ -1453,6 +1453,7 @@ def test_lu_solve(dtype_x, test_flags, backend_fw, fn_name, on_device): b=B, test_values=False, ) + assert np.allclose(A @ X, B) From 949d403e4cb22ac41003afa1f29517eb4da91223 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 13:13:44 +0000 Subject: [PATCH 844/978] fix: direct lu_solve to linalg.lu_solve in torch frontend adopting the parameters according as seen in https://pytorch.org/docs/stable/generated/torch.lu_solve.html and https://pytorch.org/docs/stable/generated/torch.linalg.lu_solve.html --- ivy/functional/frontends/torch/miscellaneous_ops.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py index 61624d2398762..1cf7aa6d03416 100644 --- a/ivy/functional/frontends/torch/miscellaneous_ops.py +++ b/ivy/functional/frontends/torch/miscellaneous_ops.py @@ -372,6 +372,11 @@ def logcumsumexp(input, dim, *, out=None): return ret +@to_ivy_arrays_and_back +def lu_solve(b, LU_data, LU_pivots, *, out=None): + return torch_frontend.linalg.lu_solve(LU_data, LU_pivots, b, out=out) + + @to_ivy_arrays_and_back def meshgrid(*tensors, indexing=None): if indexing is None: From dbd517d3a99b5057579f13f698a6483db2758e5c Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 15:17:49 +0000 Subject: [PATCH 845/978] feat: implement adaptive max pool 3d in ivy along with the test --- ivy/data_classes/array/experimental/layers.py | 9 ++ .../container/experimental/layers.py | 38 +++++++ .../backends/torch/experimental/layers.py | 7 ++ ivy/functional/ivy/experimental/layers.py | 101 ++++++++++++++++++ .../test_experimental/test_nn/test_layers.py | 36 +++++++ 5 files changed, 191 insertions(+) diff --git a/ivy/data_classes/array/experimental/layers.py b/ivy/data_classes/array/experimental/layers.py index 257b29e8d766e..daee018c7e382 100644 --- a/ivy/data_classes/array/experimental/layers.py +++ b/ivy/data_classes/array/experimental/layers.py @@ -877,6 +877,15 @@ def adaptive_max_pool2d( output_size, ) + def adaptive_max_pool3d( + self: ivy.Array, + output_size: Union[Sequence[int], int], + ) -> ivy.Array: + return ivy.adaptive_max_pool3d( + self._data, + output_size, + ) + def reduce_window( self: ivy.Array, init_value: Union[int, float], diff --git a/ivy/data_classes/container/experimental/layers.py b/ivy/data_classes/container/experimental/layers.py index ebbb6ed120669..cba584f2686e0 100644 --- a/ivy/data_classes/container/experimental/layers.py +++ b/ivy/data_classes/container/experimental/layers.py @@ -2014,6 +2014,44 @@ def adaptive_max_pool2d( map_sequences=map_sequences, ) + @staticmethod + def static_adaptive_max_pool3d( + input: Union[ivy.Array, ivy.NativeArray, ivy.Container], + output_size: Union[Sequence[int], int, ivy.Container], + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + return ContainerBase.cont_multi_map_in_function( + "adaptive_max_pool3d", + input, + output_size, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + + def adaptive_max_pool3d( + self: ivy.Container, + output_size: Union[int, ivy.Container], + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + return self.static_adaptive_max_pool3d( + self, + output_size, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + @staticmethod def static_ifftn( x: ivy.Container, diff --git a/ivy/functional/backends/torch/experimental/layers.py b/ivy/functional/backends/torch/experimental/layers.py index 150b0e41f2024..1c53639d23409 100644 --- a/ivy/functional/backends/torch/experimental/layers.py +++ b/ivy/functional/backends/torch/experimental/layers.py @@ -961,6 +961,13 @@ def adaptive_max_pool2d( return torch.nn.functional.adaptive_max_pool2d(input, output_size) +@with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) +def adaptive_max_pool3d( + input: torch.Tensor, output_size: Union[Sequence[int], int] +) -> torch.Tensor: + return torch.nn.functional.adaptive_max_pool3d(input, output_size) + + @with_unsupported_dtypes({"2.2 and below": ("bfloat16", "float16")}, backend_version) def adaptive_avg_pool1d(input, output_size): return torch.nn.functional.adaptive_avg_pool1d(input, output_size) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 38ba820389006..94be600e2907a 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -2195,6 +2195,107 @@ def adaptive_max_pool2d( } +@handle_nestable +@inputs_to_ivy_arrays +def adaptive_max_pool3d( + input: Union[ivy.Array, ivy.NativeArray], + output_size: Union[Sequence[int], int], +): + """Apply a 3D adaptive maximum pooling over an input signal composed of + several input planes. + + Parameters + ---------- + input + Input array. Must have shape (N, C, D_in, H_in, W_in) or (C, D_in, H_in, W_in) where N is + the batch dimension, C is the feature dimension, and D_in, H_in, and W_in are the 3 + spatial dimensions. + output_size + Spatial output size. + + Returns + ------- + The result of the pooling operation. Will have shape (N, C, D_out, H_out, W_out) or + (C, D_out, H_out, W_out), where D_out, H_out, W_out = `output_size` + """ + squeeze = False + if input.ndim == 4: + input = ivy.expand_dims(input, axis=0) + squeeze = True + elif input.ndim != 5: + raise ivy.utils.exceptions.IvyException( + f"Got {len(input.shape)}D input, but only 4D and 5D inputs are supported.", + ) + + if isinstance(output_size, int): + output_size = (output_size, output_size, output_size) + + if all(i_s % o_s == 0 for i_s, o_s in zip(input.shape[-3:], output_size)): + stride = tuple(i_s // o_s for i_s, o_s in zip(input.shape[-3:], output_size)) + kernel_size = stride + pooled_output = ivy.max_pool3d( + input, kernel_size, stride, "VALID", data_format="NCDHW" + ) + if squeeze: + return ivy.squeeze(pooled_output, axis=0) + return pooled_output + + idxd, length_d, range_max_d, adaptive_d = _compute_idx( + input.shape[-3], output_size[-3], input.device + ) + idxh, length_h, range_max_h, adaptive_h = _compute_idx( + input.shape[-2], output_size[-2], input.device + ) + idxw, length_w, range_max_w, adaptive_w = _compute_idx( + input.shape[-1], output_size[-1], input.device + ) + + # to numpy and back in order to bypass a slicing error in tensorflow + vals = ivy.array( + input.to_numpy()[..., _expand_to_dim(idxd, 5), _expand_to_dim(idxh, 4), idxw], + device=input.device, + ) + + if not (adaptive_d or adaptive_h or adaptive_w): + ret = ivy.max(vals, axis=(-4, -3, -1)) + ret = ivy.squeeze(ret, axis=0) if squeeze else ret + return ret + + vals, length_d = _mask( + vals, length_d, range_max_d, dim=-3, mask_value=float("-inf") + ) + vals, length_h = _mask( + vals, length_h, range_max_h, dim=-2, mask_value=float("-inf") + ) + vals, length_w = _mask( + vals, length_w, range_max_w, dim=-1, mask_value=float("-inf") + ) + + ret = None + for i, j, k in itertools.product( + range(vals.shape[-3]), range(vals.shape[-2]), range(vals.shape[-1]) + ): + if ret is None: + ret = vals[..., :, i, j, k] + else: + ret = ivy.maximum(ret, vals[..., :, i, j, k]) + pooled_output = ret.astype(vals.dtype) + + pooled_output = ivy.squeeze(pooled_output, axis=0) if squeeze else pooled_output + return pooled_output + + +adaptive_max_pool3d.mixed_backend_wrappers = { + "to_add": ( + "handle_backend_invalid", + "inputs_to_native_arrays", + "outputs_to_ivy_arrays", + "handle_device", + ), + "to_skip": ("inputs_to_ivy_arrays",), +} + + @handle_nestable @inputs_to_ivy_arrays def adaptive_avg_pool1d( diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py index a4dd5711d5c64..cbe9a2ace12ce 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_layers.py @@ -657,6 +657,42 @@ def test_adaptive_max_pool2d( ) +@handle_test( + fn_tree="functional.ivy.experimental.adaptive_max_pool3d", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + min_num_dims=4, + max_num_dims=5, + min_dim_size=1, + max_value=100, + min_value=-100, + ), + output_size=st.one_of( + st.tuples( + helpers.ints(min_value=1, max_value=5), + helpers.ints(min_value=1, max_value=5), + helpers.ints(min_value=1, max_value=5), + ), + helpers.ints(min_value=1, max_value=5), + ), + test_with_out=st.just(False), + ground_truth_backend="torch", +) +def test_adaptive_max_pool3d( + *, dtype_and_x, output_size, test_flags, backend_fw, fn_name, on_device +): + input_dtype, x = dtype_and_x + helpers.test_function( + input_dtypes=input_dtype, + test_flags=test_flags, + backend_to_test=backend_fw, + on_device=on_device, + fn_name=fn_name, + input=x[0], + output_size=output_size, + ) + + @handle_test( fn_tree="functional.ivy.experimental.avg_pool1d", x_k_s_p=helpers.arrays_for_pooling(min_dims=3, max_dims=3, min_side=1, max_side=4), From e2729421fe26ee7749c2987a8503844e3af4cc51 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 15:36:38 +0000 Subject: [PATCH 846/978] feat: add adaptive max pool 3d for torch frontend along with the test --- .../torch/nn/functional/pooling_functions.py | 18 ++++++++ .../test_functional/test_pooling_functions.py | 43 +++++++++++++++++++ 2 files changed, 61 insertions(+) diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 6cdfdc3ba299b..cdc334a740329 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -56,6 +56,24 @@ def adaptive_max_pool2d( return ivy.adaptive_max_pool2d(input, output_size) +@with_unsupported_dtypes( + { + "2.2 and below": ( + "bfloat16", + "float16", + ) + }, + "torch", +) +@to_ivy_arrays_and_back +def adaptive_max_pool3d( + input, + output_size, + return_indices=False, +): + return ivy.adaptive_max_pool3d(input, output_size) + + @with_unsupported_dtypes( {"2.2 and below": ("float16",)}, "torch", diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py index 7abe0b623de58..27091c4ca9bba 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py @@ -160,6 +160,49 @@ def test_torch_adaptive_max_pool2d( ) +@handle_frontend_test( + fn_tree="torch.nn.functional.adaptive_max_pool3d", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("float"), + min_num_dims=4, + max_num_dims=5, + min_dim_size=2, + max_value=100, + min_value=-100, + ), + output_size=st.one_of( + st.tuples( + helpers.ints(min_value=1, max_value=5), + helpers.ints(min_value=1, max_value=5), + helpers.ints(min_value=1, max_value=5), + ), + helpers.ints(min_value=1, max_value=5), + ), + test_with_out=st.just(False), +) +def test_torch_adaptive_max_pool3d( + *, + dtype_and_x, + output_size, + on_device, + frontend, + test_flags, + fn_tree, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + input=x[0], + output_size=output_size, + ) + + # avg_pool1d @handle_frontend_test( fn_tree="torch.nn.functional.avg_pool1d", From c07ced793f07746c8862729ff965b9a62c0b29a8 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Mon, 19 Feb 2024 15:49:06 +0000 Subject: [PATCH 847/978] fix: avoid shape mismatches in certain cases by axes for max and the value updating loop --- ivy/functional/ivy/experimental/layers.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index 94be600e2907a..a5e06f7ebaf04 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -2257,7 +2257,7 @@ def adaptive_max_pool3d( ) if not (adaptive_d or adaptive_h or adaptive_w): - ret = ivy.max(vals, axis=(-4, -3, -1)) + ret = ivy.max(vals, axis=(-3, -1)) ret = ivy.squeeze(ret, axis=0) if squeeze else ret return ret @@ -2273,14 +2273,13 @@ def adaptive_max_pool3d( ret = None for i, j, k in itertools.product( - range(vals.shape[-3]), range(vals.shape[-2]), range(vals.shape[-1]) + range(vals.shape[-4]), range(vals.shape[-2]), range(vals.shape[-1]) ): if ret is None: - ret = vals[..., :, i, j, k] + ret = vals[..., i, :, j, k] else: - ret = ivy.maximum(ret, vals[..., :, i, j, k]) + ret = ivy.maximum(ret, vals[..., i, :, j, k]) pooled_output = ret.astype(vals.dtype) - pooled_output = ivy.squeeze(pooled_output, axis=0) if squeeze else pooled_output return pooled_output From 0b2f195ad676d06b3193592d70b956d031a60963 Mon Sep 17 00:00:00 2001 From: Deeptendu Santra <55111154+Dsantra92@users.noreply.github.com> Date: Tue, 20 Feb 2024 11:53:36 +0530 Subject: [PATCH 848/978] Fix the name changes required for windows binaries support (#28150) Co-authored-by: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> --- available_configs.json | 6 +- binaries.json | 128 ++++++++++++++++++++--------------------- ivy/utils/binaries.py | 6 +- setup.py | 6 +- 4 files changed, 77 insertions(+), 69 deletions(-) diff --git a/available_configs.json b/available_configs.json index 21eb28357ddc5..a0697c63b5791 100644 --- a/available_configs.json +++ b/available_configs.json @@ -1,10 +1,14 @@ { "compiler": [ "cp38-cp38-manylinux_2_17_x86_64", + "cp38-cp38-win_amd64", "cp39-cp39-manylinux_2_17_x86_64", + "cp39-cp39-win_amd64", "cp310-cp310-manylinux_2_17_x86_64", - "cp311-cp311-manylinux_2_17_x86_64", + "cp310-cp310-win_amd64", "cp310-cp310-macosx_12_0_arm64", + "cp311-cp311-manylinux_2_17_x86_64", + "cp311-cp311-win_amd64", "cp311-cp311-macosx_12_0_arm64" ] } diff --git a/binaries.json b/binaries.json index 649ad6ff15915..85792e2c67ed0 100644 --- a/binaries.json +++ b/binaries.json @@ -1,72 +1,72 @@ { "ivy": { "compiler": [ - "_compiler.so", + "_compiler", { "utils": [ - "C.so", - "CC.so", - "CD.so", - "CI.so", - "CL.so", - "CM.so", - "CV.so", - "CX.so", - "D.so", - "DC.so", - "DD.so", - "DI.so", - "DL.so", - "DM.so", - "DV.so", - "DX.so", - "I.so", - "IC.so", - "ID.so", - "II.so", - "IIC.so", - "IID.so", - "III.so", - "IIL.so", - "IIM.so", - "IIV.so", - "IIX.so", - "IL.so", - "IM.so", - "IV.so", - "IX.so", - "L.so", - "LC.so", - "LD.so", - "LI.so", - "LL.so", - "LM.so", - "LV.so", - "LX.so", - "M.so", - "MC.so", - "MD.so", - "MI.so", - "ML.so", - "MM.so", - "MV.so", - "MX.so", - "V.so", - "VC.so", - "VD.so", - "VI.so", - "VL.so", - "VM.so", - "VV.so", - "VX.so", - "X.so", - "XC.so", - "XD.so", - "XI.so", - "XL.so", - "XM.so", - "XV.so", - "XX.so" + "C", + "CC", + "CD", + "CI", + "CL", + "CM", + "CV", + "CX", + "D", + "DC", + "DD", + "DI", + "DL", + "DM", + "DV", + "DX", + "I", + "IC", + "ID", + "II", + "IIC", + "IID", + "III", + "IIL", + "IIM", + "IIV", + "IIX", + "IL", + "IM", + "IV", + "IX", + "L", + "LC", + "LD", + "LI", + "LL", + "LM", + "LV", + "LX", + "M", + "MC", + "MD", + "MI", + "ML", + "MM", + "MV", + "MX", + "V", + "VC", + "VD", + "VI", + "VL", + "VM", + "VV", + "VX", + "X", + "XC", + "XD", + "XI", + "XL", + "XM", + "XV", + "XX" ] } ] diff --git a/ivy/utils/binaries.py b/ivy/utils/binaries.py index 8b22ed383a159..dc7175831457b 100644 --- a/ivy/utils/binaries.py +++ b/ivy/utils/binaries.py @@ -9,8 +9,9 @@ def _get_paths_from_binaries(binaries, root_dir=""): """Get all the paths from the binaries.json into a list.""" paths = [] + ext = "pyd" if os.name == "nt" else "so" if isinstance(binaries, str): - return [os.path.join(root_dir, binaries)] + return [os.path.join(root_dir, binaries + "." + ext)] elif isinstance(binaries, dict): for k, v in binaries.items(): paths += _get_paths_from_binaries(v, os.path.join(root_dir, k)) @@ -96,7 +97,8 @@ def cleanup_and_fetch_binaries(clean=True): continue folders = path.split(os.sep) _, file_path = os.sep.join(folders[:-1]), folders[-1] - file_name = f"{file_path[:-3]}_{tag}.so" + ext = "pyd" if os.name == "nt" else "so" + file_name = f"{file_path[:-(len(ext)+1)]}_{tag}.{ext}" search_path = f"{module}/{file_name}" try: response = request.urlopen( diff --git a/setup.py b/setup.py index 75571b84efc24..02b111d8c7865 100644 --- a/setup.py +++ b/setup.py @@ -27,8 +27,9 @@ def _get_paths_from_binaries(binaries, root_dir=""): """Get all the paths from the binaries.json into a list.""" paths = [] + ext = "pyd" if os.name == "nt" else "so" if isinstance(binaries, str): - return [os.path.join(root_dir, binaries)] + return [os.path.join(root_dir, binaries + "." + ext)] elif isinstance(binaries, dict): for k, v in binaries.items(): paths += _get_paths_from_binaries(v, os.path.join(root_dir, k)) @@ -72,7 +73,8 @@ def _strip(line): continue folders = path.split(os.sep) folder_path, file_path = os.sep.join(folders[:-1]), folders[-1] - file_name = f"{file_path[:-3]}_{tag}.so" + ext = "pyd" if os.name == "nt" else "so" + file_name = f"{file_path[:-(len(ext)+1)]}_{tag}.{ext}" search_path = f"{module}/{file_name}" try: response = request.urlopen( From b45d7e8df5bef615018246d55b7684dc341cba10 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 20 Feb 2024 06:57:19 +0000 Subject: [PATCH 849/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 20b1a83192f9a..88b907dcd9d64 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 20b1a83192f9ab77ed04b34f2f05f3967af4f86f +Subproject commit 88b907dcd9d648d986089479b17cbfd3601e9a04 From fd248dc32776411c22ae48c7f7a260cc8cd5069e Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 20 Feb 2024 13:32:11 +0530 Subject: [PATCH 850/978] Update compiler.py 33206f0 (#28338) Co-authored-by: ivy-branch --- binaries.json | 1 + ivy/compiler/compiler.py | 1 + 2 files changed, 2 insertions(+) diff --git a/binaries.json b/binaries.json index 85792e2c67ed0..86406c4fc4a82 100644 --- a/binaries.json +++ b/binaries.json @@ -34,6 +34,7 @@ "IL", "IM", "IV", + "IVI", "IX", "L", "LC", diff --git a/ivy/compiler/compiler.py b/ivy/compiler/compiler.py index 1404fd94969a2..4bd5ae74aeb45 100644 --- a/ivy/compiler/compiler.py +++ b/ivy/compiler/compiler.py @@ -194,6 +194,7 @@ def unify( modes_to_trace: str = "all", **transpile_kwargs ): + from ._compiler import unify as _unify return _unify( From 468b6653d7f019a243d8bff839833279f5aa53c7 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 20 Feb 2024 13:32:59 +0530 Subject: [PATCH 851/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index 87463cc45c8ac..e241cdc6c96ab 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.7.0" +__version__ = "0.0.8.0" From e4cf2c697d4f226de20c349196bed272576a7cf2 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 20 Feb 2024 13:34:00 +0530 Subject: [PATCH 852/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index e241cdc6c96ab..87463cc45c8ac 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.8.0" +__version__ = "0.0.7.0" From f58719e371c18abc39629c01462b2733a7eaf160 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 20 Feb 2024 08:15:26 +0000 Subject: [PATCH 853/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 88b907dcd9d64..a806ae33b769c 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 88b907dcd9d648d986089479b17cbfd3601e9a04 +Subproject commit a806ae33b769c3c53d28f573fcd0ac7dade338ed From 09da535533beb9db05864a9256a3458acfa0fb51 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 20 Feb 2024 08:54:54 +0000 Subject: [PATCH 854/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index a806ae33b769c..d5dd40c78269c 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit a806ae33b769c3c53d28f573fcd0ac7dade338ed +Subproject commit d5dd40c78269c17561f1a489e2186b97738d1cdf From fd55fd1b59d527b8a31e751b34c6d1f3e068748f Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 20 Feb 2024 14:55:59 +0530 Subject: [PATCH 855/978] fix: Fixed `tensorflow.math.is_strictly_increasing` for all backends (#28336) --- ivy/functional/frontends/tensorflow/math.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index 111b76bcda4f6..75bf0988040a8 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -536,9 +536,11 @@ def is_non_decreasing(x, name="is_non_decreasing"): def is_strictly_increasing(x, name="is_strictly_increasing"): if ivy.array(x).size < 2: return ivy.array(True) - if ivy.array(x).size == 2: - return ivy.array(x[0] < x[1]) - return ivy.all(ivy.less(x, ivy.roll(x, -1))) + x = ivy.flatten(x) + res = ivy.less(x, ivy.roll(x, -1)) + if res.size >= 2: + res[res.size - 1] = True # The last comparison must be set to true. + return ivy.all(res) @to_ivy_arrays_and_back From 4449f0d13ef1131c9d66da05f31f4e8f47c1057f Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 20 Feb 2024 14:56:44 +0530 Subject: [PATCH 856/978] fix: Fixed `paddle.take_along_axis` for all backends (#28321) --- ivy/functional/frontends/paddle/manipulation.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ivy/functional/frontends/paddle/manipulation.py b/ivy/functional/frontends/paddle/manipulation.py index 2cb0974b00a7f..dd7c7e79a28f9 100644 --- a/ivy/functional/frontends/paddle/manipulation.py +++ b/ivy/functional/frontends/paddle/manipulation.py @@ -198,6 +198,11 @@ def stack(x, axis=0, name=None): return ivy.stack(x, axis=axis) +@with_supported_dtypes( + {"2.6.0 and below": ("float32", "float64")}, + "paddle", +) +@to_ivy_arrays_and_back def take_along_axis(arr, indices, axis): return ivy.take_along_axis(arr, indices, axis) From 704c571c1b4adb4f329591efbf0617320e236cd1 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Tue, 20 Feb 2024 09:51:55 +0000 Subject: [PATCH 857/978] fix compositonal get_item removing to_numpy and scalar calls while keeping it general enough (#28077) Co-authored-by: ivy-branch Co-authored-by: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Fixed the issues with the compositional implementations of get_item and set_item as they relied on numpy, reverted back to the previous implementation with some fixes for handling new_axes, to_front, etc. --- ivy/functional/ivy/general.py | 265 ++++++++++++++++-- .../hypothesis_helpers/array_helpers.py | 9 +- 2 files changed, 251 insertions(+), 23 deletions(-) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index 416619538d4ca..dfc16539047ef 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -3,6 +3,7 @@ # global import gc import inspect +import itertools import math from functools import wraps from numbers import Number @@ -2800,11 +2801,17 @@ def get_item( query = ivy.nonzero(query, as_tuple=False) ret = ivy.gather_nd(x, query) else: - indices, target_shape = _parse_query(query, x.shape) - if indices is None: - return ivy.empty(target_shape, dtype=x.dtype) - ret = ivy.gather_nd(x, indices) - ret = ivy.reshape(ret, target_shape) + query, target_shape, vector_inds = _parse_query(query, x.shape) + if vector_inds is not None: + x = ivy.permute_dims( + x, + axes=[ + *vector_inds, + *[i for i in range(len(x.shape)) if i not in vector_inds], + ], + ) + ret = ivy.gather_nd(x, query) + ret = ivy.reshape(ret, target_shape) if target_shape != list(ret.shape) else ret return ret @@ -2880,7 +2887,7 @@ def set_item( target_shape = ivy.get_item(x, query).shape indices = ivy.nonzero(query, as_tuple=False) else: - indices, target_shape = _parse_query(query, x.shape) + indices, target_shape, _ = _parse_query(query, x.shape, scatter=True) if indices is None: return x val = _broadcast_to(val, target_shape).astype(x.dtype) @@ -2898,27 +2905,243 @@ def set_item( } -def _parse_query(query, x_shape): - query = query if isinstance(query, tuple) else (query,) - query_ = tuple(q.to_numpy() if ivy.is_array(q) else q for q in query) +def _parse_query(query, x_shape, scatter=False): + query = (query,) if not isinstance(query, tuple) else query - # array containing all of x's flat indices - x_ = ivy.arange(0, _numel(x_shape)).reshape(x_shape) + # sequence and integer queries are dealt with as array queries + query = [ivy.array(q) if isinstance(q, (tuple, list, int)) else q for q in query] - # use numpy's __getitem__ to get the queried indices - x_idxs = ivy.array(x_.to_numpy()[query_]) - target_shape = x_idxs.shape + # check if non-slice queries are in consecutive positions + # if so, they have to be moved to the front + # https://numpy.org/neps/nep-0021-advanced-indexing.html#mixed-indexing + non_slice_q_idxs = [i for i, q in enumerate(query) if ivy.is_array(q)] + to_front = ( + len(non_slice_q_idxs) > 1 + and any(ivy.diff(non_slice_q_idxs) != 1) + and non_slice_q_idxs[-1] < len(x_shape) + ) - if 0 in x_idxs.shape or 0 in x_shape: - return None, target_shape + # extract newaxis queries + new_axes = [i for i, q in enumerate(query) if q is None] + query = [q for q in query if q is not None] + query = [Ellipsis] if query == [] else query + + # parse ellipsis + ellipsis_inds = None + if any(q is Ellipsis for q in query): + query, ellipsis_inds = _parse_ellipsis(query, len(x_shape)) + + # broadcast array queries + array_inds = [i for i, v in enumerate(query) if ivy.is_array(v)] + if array_inds: + array_queries = ivy.broadcast_arrays( + *[v for i, v in enumerate(query) if i in array_inds] + ) + array_queries = [ + ( + ivy.where(arr < 0, arr + x_shape[i], arr).astype(ivy.int64) + if arr.size + else arr.astype(ivy.int64) + ) + for arr, i in zip(array_queries, array_inds) + ] + for idx, arr in zip(array_inds, array_queries): + query[idx] = arr + + # convert slices to range arrays + query = [ + _parse_slice(q, x_shape[i]).astype(ivy.int64) if isinstance(q, slice) else q + for i, q in enumerate(query) + ] - # convert the flat indices to multi-D indices - x_idxs = ivy.unravel_index(x_idxs, x_shape) + # fill in missing queries + if len(query) < len(x_shape): + query += [ivy.arange(0, s, 1).astype(ivy.int64) for s in x_shape[len(query) :]] - # stack the multi-D indices to bring them to gather_nd/scatter_nd format - x_idxs = ivy.stack(x_idxs, axis=-1).astype(ivy.int64) + # calculate target_shape, i.e. the shape the gathered/scattered values should have + if len(array_inds) and to_front: + target_shape = ( + [list(array_queries[0].shape)] + + [list(query[i].shape) for i in range(len(query)) if i not in array_inds] + + [[] for _ in range(len(array_inds) - 1)] + ) + elif len(array_inds): + target_shape = ( + [list(query[i].shape) for i in range(0, array_inds[0])] + + [list(array_queries[0].shape)] + + [[] for _ in range(len(array_inds) - 1)] + + [list(query[i].shape) for i in range(array_inds[-1] + 1, len(query))] + ) + else: + target_shape = [list(q.shape) for q in query] + if ellipsis_inds is not None: + target_shape = ( + target_shape[: ellipsis_inds[0]] + + [target_shape[ellipsis_inds[0] : ellipsis_inds[1]]] + + target_shape[ellipsis_inds[1] :] + ) + for i, ax in enumerate(new_axes): + if len(array_inds) and to_front: + ax -= sum(1 for x in array_inds if x < ax) - 1 + ax = ax + i + target_shape = [*target_shape[:ax], 1, *target_shape[ax:]] + target_shape = _deep_flatten(target_shape) + + # calculate the indices mesh (indices in gather_nd/scatter_nd format) + query = [ivy.expand_dims(q) if not len(q.shape) else q for q in query] + if len(array_inds): + array_queries = [ + ( + arr.reshape((-1,)) + if len(arr.shape) > 1 + else ivy.expand_dims(arr) if not len(arr.shape) else arr + ) + for arr in array_queries + ] + array_queries = ivy.stack(array_queries, axis=1) + if len(array_inds) == len(query): # advanced indexing + indices = array_queries.reshape((*target_shape, len(x_shape))) + elif len(array_inds) == 0: # basic indexing + indices = ivy.stack(ivy.meshgrid(*query, indexing="ij"), axis=-1).reshape( + (*target_shape, len(x_shape)) + ) + else: # mixed indexing + if to_front: + post_array_queries = ( + ivy.stack( + ivy.meshgrid( + *[v for i, v in enumerate(query) if i not in array_inds], + indexing="ij", + ), + axis=-1, + ).reshape((-1, len(query) - len(array_inds))) + if len(array_inds) < len(query) + else ivy.empty((1, 0)) + ) + indices = ivy.array( + [ + (*arr, *post) + for arr, post in itertools.product( + array_queries, post_array_queries + ) + ] + ).reshape((*target_shape, len(x_shape))) + else: + pre_array_queries = ( + ivy.stack( + ivy.meshgrid( + *[v for i, v in enumerate(query) if i < array_inds[0]], + indexing="ij", + ), + axis=-1, + ).reshape((-1, array_inds[0])) + if array_inds[0] > 0 + else ivy.empty((1, 0)) + ) + post_array_queries = ( + ivy.stack( + ivy.meshgrid( + *[v for i, v in enumerate(query) if i > array_inds[-1]], + indexing="ij", + ), + axis=-1, + ).reshape((-1, len(query) - 1 - array_inds[-1])) + if array_inds[-1] < len(query) - 1 + else ivy.empty((1, 0)) + ) + indices = ivy.array( + [ + (*pre, *arr, *post) + for pre, arr, post in itertools.product( + pre_array_queries, array_queries, post_array_queries + ) + ] + ).reshape((*target_shape, len(x_shape))) + + return ( + indices.astype(ivy.int64), + target_shape, + array_inds if len(array_inds) and to_front else None, + ) + + +def _parse_ellipsis(so, ndims): + pre = list() + for s in so: + if s is Ellipsis: + break + pre.append(s) + post = list() + for s in reversed(so): + if s is Ellipsis: + break + post.append(s) + ret = list( + pre + + [slice(None, None, None) for _ in range(ndims - len(pre) - len(post))] + + list(reversed(post)) + ) + return ret, (len(pre), ndims - len(post)) + + +def _parse_slice(idx, s): + step = 1 if idx.step is None else idx.step + if step > 0: + start = 0 if idx.start is None else idx.start + if start >= s: + stop = start + else: + if start <= -s: + start = 0 + elif start < 0: + start = start + s + stop = s if idx.stop is None else idx.stop + if stop > s: + stop = s + elif start <= -s: + stop = 0 + elif stop < 0: + stop = stop + s + else: + start = s - 1 if idx.start is None else idx.start + if start < -s: + stop = start + else: + if start >= s: + start = s - 1 + elif start < 0: + start = start + s + if idx.stop is None: + stop = -1 + else: + stop = idx.stop + if stop > s: + stop = s + elif stop < -s: + stop = -1 + elif stop == -s: + stop = 0 + elif stop < 0: + stop = stop + s + q_i = ivy.arange(start, stop, step).to_list() + q_i = [q for q in q_i if 0 <= q < s] + q_i = ( + ivy.array(q_i) + if len(q_i) or start == stop or idx.stop is not None + else ivy.arange(0, s, 1) + ) + return q_i + + +def _deep_flatten(iterable): + def _flatten_gen(iterable): + for item in iterable: + if isinstance(item, list): + yield from _flatten_gen(item) + else: + yield item - return x_idxs, target_shape + return list(_flatten_gen(iterable)) def _numel(shape): diff --git a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py index 81434c0b726c2..28330daec930d 100644 --- a/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py +++ b/ivy_tests/test_ivy/helpers/hypothesis_helpers/array_helpers.py @@ -1914,6 +1914,7 @@ def dtype_array_query( shape=shape, large_abs_safety_factor=2, small_abs_safety_factor=2, + safety_factor_scale="log", ) ) if allow_mask and draw(st.booleans()): @@ -1935,6 +1936,7 @@ def dtype_array_query( ) index_types = [v if shape[i] > 0 else "slice" for i, v in enumerate(index_types)] index = [] + empty_array = prod(shape) == 0 for s, index_type in zip(shape, index_types): if index_type == "int": new_index = draw(st.integers(min_value=-s + 1, max_value=s - 1)) @@ -1942,8 +1944,8 @@ def dtype_array_query( new_index = draw( st.lists( st.integers(min_value=-s + 1, max_value=s - 1), - min_size=1, - max_size=20, + min_size=1 if not empty_array else 0, + max_size=20 if not empty_array else 0, ) ) elif index_type == "array": @@ -1953,6 +1955,8 @@ def dtype_array_query( max_value=s - 1, dtype=["int64"], max_num_dims=4, + min_dim_size=1 if not empty_array else 0, + max_dim_size=10 if not empty_array else 0, ) ) new_index = new_index[0] @@ -2032,6 +2036,7 @@ def dtype_array_query_val( shape=val_shape, large_abs_safety_factor=2, small_abs_safety_factor=2, + safety_factor_scale="log", ) ) val_dtype = draw( From 503c29c5401ebd389484ba8f3528c51dd5fe97d1 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 20 Feb 2024 15:51:18 +0530 Subject: [PATCH 858/978] fix: Fixed `tf.math.argmin` for torch, jax, and paddle backends (#28342) --- ivy/functional/backends/torch/searching.py | 10 +++++++++- .../test_frontends/test_tensorflow/test_math.py | 2 +- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/torch/searching.py b/ivy/functional/backends/torch/searching.py index 57480f4913b59..acc362fa27776 100644 --- a/ivy/functional/backends/torch/searching.py +++ b/ivy/functional/backends/torch/searching.py @@ -41,7 +41,15 @@ def argmax( return ret -@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes( + { + "2.2 and below": ( + "complex", + "bool", + ) + }, + backend_version, +) def argmin( x: torch.Tensor, /, diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py index 9e9cc7aebe1af..fe19eb21d3037 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py @@ -286,7 +286,7 @@ def test_tensorflow_argmin( on_device, output_type, ): - input_dtype, x, axis = dtype_and_x + input_dtype, x, axis, *_ = dtype_and_x if isinstance(axis, tuple): axis = axis[0] helpers.test_frontend_function( From efbb9c9e6011e230f7d728da934253d54fa0037b Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Tue, 20 Feb 2024 15:54:36 +0530 Subject: [PATCH 859/978] fix: fixed the relu6 for complex dtype in paddle backend(#28326) --- ivy/functional/backends/paddle/experimental/activations.py | 5 ++++- .../test_experimental/test_nn/test_activations.py | 1 + 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/experimental/activations.py b/ivy/functional/backends/paddle/experimental/activations.py index be09386ca5026..ca193162facc0 100644 --- a/ivy/functional/backends/paddle/experimental/activations.py +++ b/ivy/functional/backends/paddle/experimental/activations.py @@ -62,7 +62,10 @@ def relu6( x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None ) -> paddle.Tensor: if paddle.is_complex(x): - return paddle.complex(F.relu6(x.real()), F.relu6(x.imag())) + if x.real > 0 and x.real <= 6: + return x.astype(x.dtype) + else: + return paddle_backend.zeros_like(x).astype(x.dtype) return F.relu6(x) diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py index a056aa7291462..d61e795307cb9 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_activations.py @@ -240,6 +240,7 @@ def test_prelu(*, dtype_and_x, slope, test_flags, backend_fw, fn_name, on_device large_abs_safety_factor=2, small_abs_safety_factor=2, safety_factor_scale="log", + min_value=1e-15, ), complex_mode=st.sampled_from(["jax", "split", "magnitude"]), ) From 8a45528b2ff44bacd43aff7280fd900a26b098ce Mon Sep 17 00:00:00 2001 From: Lyngkhoi <78148524+fleventy-5@users.noreply.github.com> Date: Tue, 20 Feb 2024 16:45:54 +0530 Subject: [PATCH 860/978] fix: specify supported types for ivy.relu for all backend (#28233) --- ivy/functional/backends/numpy/activations.py | 12 ++++++++++++ ivy/functional/backends/paddle/activations.py | 12 ++++++++++-- ivy/functional/backends/tensorflow/activations.py | 10 ++++++++++ ivy/functional/backends/torch/activations.py | 10 +++++++++- .../test_functional/test_nn/test_activations.py | 2 +- 5 files changed, 42 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/numpy/activations.py b/ivy/functional/backends/numpy/activations.py index 714056b4b34c0..7f396edb7da5d 100644 --- a/ivy/functional/backends/numpy/activations.py +++ b/ivy/functional/backends/numpy/activations.py @@ -8,8 +8,20 @@ # local import ivy from ivy.functional.backends.numpy.helpers import _scalar_output_to_0d_array +from ivy.func_wrapper import with_supported_dtypes +from . import backend_version +@with_supported_dtypes( + { + "1.26.3 and below": ( + "float", + "int", + "complex", + ) + }, + backend_version, +) @_scalar_output_to_0d_array def relu( x: np.ndarray, /, *, complex_mode="jax", out: Optional[np.ndarray] = None diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index a08580b4383d0..88975658f1fee 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/ivy/functional/backends/paddle/activations.py @@ -22,10 +22,18 @@ @with_supported_dtypes( - {"2.6.0 and below": ("float32", "float64", "complex")}, + { + "2.6.0 and below": ( + "float32", + "float64", + "complex64", + ) + }, backend_version, ) -def relu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor: +def relu( + x: paddle.Tensor, /, *, complex_mode="jax", 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) diff --git a/ivy/functional/backends/tensorflow/activations.py b/ivy/functional/backends/tensorflow/activations.py index 5b757031a48c5..2e60ebe41688e 100644 --- a/ivy/functional/backends/tensorflow/activations.py +++ b/ivy/functional/backends/tensorflow/activations.py @@ -40,6 +40,16 @@ def leaky_relu( return tf.nn.leaky_relu(x, alpha) +@with_supported_dtypes( + { + "2.15.0 and below": ( + "float", + "int", + "complex", + ) + }, + backend_version, +) def relu(x: Tensor, /, *, complex_mode="jax", out: Optional[Tensor] = None) -> Tensor: return tf.nn.relu(x) diff --git a/ivy/functional/backends/torch/activations.py b/ivy/functional/backends/torch/activations.py index 13cf0113beb56..2529147c6f976 100644 --- a/ivy/functional/backends/torch/activations.py +++ b/ivy/functional/backends/torch/activations.py @@ -18,7 +18,15 @@ import ivy.functional.backends.torch as torch_backend -@with_unsupported_dtypes({"2.2 and below": ("float16",)}, backend_version) +@with_unsupported_dtypes( + { + "2.1.2 and below": ( + "float16", + "bool", + ) + }, + backend_version, +) def relu( x: torch.Tensor, /, *, complex_mode="jax", out: Optional[torch.Tensor] = None ) -> torch.Tensor: diff --git a/ivy_tests/test_ivy/test_functional/test_nn/test_activations.py b/ivy_tests/test_ivy/test_functional/test_nn/test_activations.py index 66d6e7c42e63e..5b2aa8086cd9f 100644 --- a/ivy_tests/test_ivy/test_functional/test_nn/test_activations.py +++ b/ivy_tests/test_ivy/test_functional/test_nn/test_activations.py @@ -166,7 +166,7 @@ def test_mish(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.relu", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), large_abs_safety_factor=8, small_abs_safety_factor=8, safety_factor_scale="log", From 6862f057df95d25eceb43f6ba6ab604ce5a7be04 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 20 Feb 2024 18:27:21 +0530 Subject: [PATCH 861/978] Update compiler.py 04244f0 (#28351) Co-authored-by: ivy-branch From a08c603391236752d50f8a4d01bd3e6dd4dfaf9b Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 20 Feb 2024 18:28:01 +0530 Subject: [PATCH 862/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index 87463cc45c8ac..b41c3588272f2 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.7.0" +__version__ = "0.0.7.1" From 075e08ad6637dcb6645dc220032d6da146b597fa Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Tue, 20 Feb 2024 20:22:48 +0530 Subject: [PATCH 863/978] fix: fixed argmax for ivy functional api (#28329) fixed the test at paddle backend --- ivy_tests/test_ivy/test_functional/test_core/test_searching.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_searching.py b/ivy_tests/test_ivy/test_functional/test_core/test_searching.py index f7b5ab9a88c31..1edb5f5a6f60c 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_searching.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_searching.py @@ -66,6 +66,7 @@ def _dtype_x_limited_axis(draw, *, allow_none=False): keepdims=st.booleans(), dtype=helpers.get_dtypes("numeric", full=False, none=True), select_last_index=st.booleans(), + test_gradients=st.just(False), ) def test_argmax( *, From 295b2db8c4e41d35f761ba97d691ac7354792e96 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Tue, 20 Feb 2024 07:26:47 -0800 Subject: [PATCH 864/978] fix: specify supported types for expand_dims in paddle backend (#28309) --- ivy/functional/backends/paddle/manipulation.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index 71accc56dad03..d8a42449309e3 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -62,6 +62,20 @@ def concat( return ret +@with_supported_dtypes( + { + "2.6.0 and below": ( + "int32", + "int64", + "float64", + "complex128", + "float32", + "complex64", + "bool", + ) + }, + backend_version, +) def expand_dims( x: paddle.Tensor, /, From 1854ca18a093949c3e3d2280792e27eebfb475fd Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Tue, 20 Feb 2024 21:06:40 +0530 Subject: [PATCH 865/978] fix: resolve dtype issues for `tf.math.argmax` and `argmin` in jax, torch, paddle, and tensorflow backends (#28347) --- ivy/functional/backends/tensorflow/searching.py | 1 + ivy/functional/backends/torch/searching.py | 10 +++++++++- ivy/functional/frontends/tensorflow/math.py | 10 +++++++++- .../test_frontends/test_tensorflow/test_math.py | 6 ++---- 4 files changed, 21 insertions(+), 6 deletions(-) diff --git a/ivy/functional/backends/tensorflow/searching.py b/ivy/functional/backends/tensorflow/searching.py index 660576fe75bb2..0b1abe892c9e3 100644 --- a/ivy/functional/backends/tensorflow/searching.py +++ b/ivy/functional/backends/tensorflow/searching.py @@ -45,6 +45,7 @@ def argmax( return tf.cast(ret, dtype) if dtype is not None else ret +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) def argmin( x: Union[tf.Tensor, tf.Variable], /, diff --git a/ivy/functional/backends/torch/searching.py b/ivy/functional/backends/torch/searching.py index acc362fa27776..5194967076efa 100644 --- a/ivy/functional/backends/torch/searching.py +++ b/ivy/functional/backends/torch/searching.py @@ -13,7 +13,15 @@ # ------------------ # -@with_unsupported_dtypes({"2.2 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes( + { + "2.2 and below": ( + "complex", + "bool", + ) + }, + backend_version, +) def argmax( x: torch.Tensor, /, diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index 75bf0988040a8..0192acaef1e5c 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -193,15 +193,23 @@ def angle(input, name=None): return ivy.angle(input) +@with_unsupported_dtypes( + {"2.15.0 and below": ("complex",)}, + "tensorflow", +) @to_ivy_arrays_and_back def argmax(input, axis, output_type=None, name=None): output_type = to_ivy_dtype(output_type) - if output_type in ["uint16", "int16", "int32", "int64"]: + if output_type in ["int32", "int64"]: return ivy.astype(ivy.argmax(input, axis=axis), output_type) else: return ivy.astype(ivy.argmax(input, axis=axis), "int64") +@with_unsupported_dtypes( + {"2.15.0 and below": ("complex",)}, + "tensorflow", +) @to_ivy_arrays_and_back def argmin(input, axis=None, output_type="int64", name=None): output_type = to_ivy_dtype(output_type) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py index fe19eb21d3037..aec91a0c64eab 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py @@ -238,7 +238,7 @@ def test_tensorflow_angle( @handle_frontend_test( fn_tree="tensorflow.math.argmax", dtype_and_x=_statistical_dtype_values(function="argmax"), - output_type=st.sampled_from(["int16", "uint16", "int32", "int64"]), + output_type=st.sampled_from(["int32", "int64"]), test_with_out=st.just(False), ) def test_tensorflow_argmax( @@ -251,9 +251,7 @@ def test_tensorflow_argmax( on_device, output_type, ): - if backend_fw in ("torch", "paddle"): - assume(output_type != "uint16") - input_dtype, x, axis = dtype_and_x + input_dtype, x, axis, *_ = dtype_and_x if isinstance(axis, tuple): axis = axis[0] helpers.test_frontend_function( From 1520d76c6e52b99e30ac9b6c786e52ef299ef602 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Tue, 20 Feb 2024 23:29:04 +0530 Subject: [PATCH 866/978] fix: fixed the complex dtype support for ivy.maximum at paddle backend (#28353) fixed the paddle complex dtype support --- ivy/functional/backends/paddle/elementwise.py | 8 +++++++- .../test_functional/test_core/test_elementwise.py | 5 +++-- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 48763d3bdf157..0c0ddeb016fec 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -1122,7 +1122,13 @@ def maximum( ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) if paddle.is_complex(x1): - use_where = True + real_comparison = paddle.real(x1) > paddle.real(x2) + imag_comparison = paddle_backend.logical_and( + paddle.real(x1) == paddle.real(x2), paddle.imag(x1) > paddle.imag(x2) + ) + return paddle_backend.where( + paddle_backend.logical_or(real_comparison, imag_comparison), x1, x2 + ).astype(ret_dtype) if use_where: return paddle_backend.where( paddle_backend.greater_equal(x1, x2), x1, x2 diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 18dc1cc661344..5c35cf6ccfde6 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -69,7 +69,7 @@ def min_max_helper(draw): if use_where: dtype_and_x = draw( helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("numeric", full=False), num_arrays=2, small_abs_safety_factor=6, large_abs_safety_factor=6, @@ -79,7 +79,7 @@ def min_max_helper(draw): else: dtype_and_x = draw( helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("numeric", full=False), num_arrays=2, min_value=-1e5, max_value=1e5, @@ -1438,6 +1438,7 @@ def test_logical_xor(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device) fn_tree="functional.ivy.maximum", dtype_and_x_and_use_where=min_max_helper(), test_gradients=st.just(False), + ground_truth_backend="jax", ) def test_maximum( *, dtype_and_x_and_use_where, test_flags, backend_fw, fn_name, on_device From af48650107de891bd9a2505405242e26b336ca38 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Wed, 21 Feb 2024 00:53:22 +0000 Subject: [PATCH 867/978] fix: ensure all lstm weights are contiguous, so they will work on gpu (#28358) --- ivy/functional/backends/torch/layers.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index 7a04b2d7bf698..f1b7fecce5367 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -910,6 +910,11 @@ def lstm( if initial_states[1].dim() == 2: initial_states[1] = ivy.expand_dims(initial_states[1]) + # ensure all weights are contiguous, so they will work on gpu + for i, w in enumerate(all_weights): + if not w.is_contiguous(): + all_weights[i] = w.contiguous() + ret = torch.lstm( input, initial_states, From c7e98b388fc3d3e82f2350c627623c60139d5401 Mon Sep 17 00:00:00 2001 From: Felix Hirwa Nshuti Date: Wed, 21 Feb 2024 12:12:15 +0530 Subject: [PATCH 868/978] fix: fixing tests for `Shape` `__mul__` and `__rmul__` methods (#28337) --- ivy/__init__.py | 13 +++++- ivy_tests/test_ivy/test_misc/test_shape.py | 46 +++++++++------------- 2 files changed, 29 insertions(+), 30 deletions(-) diff --git a/ivy/__init__.py b/ivy/__init__.py index 00e5039fd4099..d40ab10bfb12d 100644 --- a/ivy/__init__.py +++ b/ivy/__init__.py @@ -287,11 +287,20 @@ def __radd__(self, other): return self def __mul__(self, other): - self._shape = self._shape * other + if ivy.current_backend_str() == "tensorflow": + shape_tup = builtins.tuple(self._shape) * other + self._shape = ivy.to_native_shape(shape_tup) + else: + self._shape = self._shape * other return self def __rmul__(self, other): - self._shape = other * self._shape + # handle tensorflow case as tf.TensorShape doesn't support multiplications + if ivy.current_backend_str() == "tensorflow": + shape_tup = other * builtins.tuple(self._shape) + self._shape = ivy.to_native_shape(shape_tup) + else: + self._shape = other * self._shape return self def __bool__(self): diff --git a/ivy_tests/test_ivy/test_misc/test_shape.py b/ivy_tests/test_ivy/test_misc/test_shape.py index c42f74180293f..72f60d5209cc9 100644 --- a/ivy_tests/test_ivy/test_misc/test_shape.py +++ b/ivy_tests/test_ivy/test_misc/test_shape.py @@ -424,18 +424,14 @@ def test_shape__mod__( @handle_method( + init_tree=CLASS_TREE, method_tree="Shape.__mul__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - num_arrays=2, - large_abs_safety_factor=2.5, - small_abs_safety_factor=2.5, - safety_factor_scale="log", - shared_dtype=True, - ), + shape=helpers.get_shape(), + other=st.integers(min_value=1, max_value=10), ) def test_shape__mul__( - dtype_and_x, + shape, + other, method_name, class_name, backend_fw, @@ -444,17 +440,16 @@ def test_shape__mul__( method_flags, on_device, ): - dtype, x = dtype_and_x helpers.test_method( on_device=on_device, ground_truth_backend=ground_truth_backend, backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, - init_all_as_kwargs_np={"data": x[0]}, - init_input_dtypes=dtype, - method_input_dtypes=dtype, - method_all_as_kwargs_np={"other": x[1]}, + init_all_as_kwargs_np={"shape_tup": shape}, + init_input_dtypes=DUMMY_DTYPE, + method_input_dtypes=DUMMY_DTYPE, + method_all_as_kwargs_np={"other": other}, class_name=class_name, method_name=method_name, ) @@ -569,18 +564,14 @@ def test_shape__rmod__( @handle_method( + init_tree=CLASS_TREE, method_tree="Shape.__rmul__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - num_arrays=2, - large_abs_safety_factor=2.5, - small_abs_safety_factor=2.5, - safety_factor_scale="log", - shared_dtype=True, - ), + shape=helpers.get_shape(), + other=st.integers(min_value=1, max_value=10), ) def test_shape__rmul__( - dtype_and_x, + shape, + other, method_name, class_name, ground_truth_backend, @@ -589,17 +580,16 @@ def test_shape__rmul__( method_flags, on_device, ): - dtype, x = dtype_and_x helpers.test_method( on_device=on_device, ground_truth_backend=ground_truth_backend, backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, - init_all_as_kwargs_np={"data": x[0]}, - init_input_dtypes=dtype, - method_input_dtypes=dtype, - method_all_as_kwargs_np={"other": x[1]}, + init_all_as_kwargs_np={"shape_tup": shape}, + init_input_dtypes=DUMMY_DTYPE, + method_input_dtypes=DUMMY_DTYPE, + method_all_as_kwargs_np={"other": other}, class_name=class_name, method_name=method_name, ) From 44d345362565e65305c0acba0bbc5f4147789157 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Wed, 21 Feb 2024 10:51:39 +0000 Subject: [PATCH 869/978] fix: improved fix for making lstm weights contiguous (#28368) --- ivy/functional/backends/torch/layers.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/ivy/functional/backends/torch/layers.py b/ivy/functional/backends/torch/layers.py index f1b7fecce5367..c470384987513 100644 --- a/ivy/functional/backends/torch/layers.py +++ b/ivy/functional/backends/torch/layers.py @@ -887,7 +887,7 @@ def lstm( if weights_transposed: # transpose the weights if they are in the wrong format all_weights = [ - torch.transpose(weight, 1, 0) if weight.dim() == 2 else weight + torch.transpose(weight, 1, 0).contiguous() if weight.dim() == 2 else weight for weight in all_weights ] else: @@ -910,11 +910,6 @@ def lstm( if initial_states[1].dim() == 2: initial_states[1] = ivy.expand_dims(initial_states[1]) - # ensure all weights are contiguous, so they will work on gpu - for i, w in enumerate(all_weights): - if not w.is_contiguous(): - all_weights[i] = w.contiguous() - ret = torch.lstm( input, initial_states, From 2eb432dccb53e8b197397df409311a74aa379eea Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Wed, 21 Feb 2024 13:28:24 +0000 Subject: [PATCH 870/978] feat(tensorflow-keras): Added depthwise_conv2d to tf.keras.backend frontend namespace along with the test. Also added tf.nn.swish as an alias for tf.nn.silu --- .../frontends/tensorflow/keras/backend.py | 45 ++++++ ivy/functional/frontends/tensorflow/nn.py | 3 + .../test_keras/test_backend.py | 135 ++++++++++++++++++ 3 files changed, 183 insertions(+) diff --git a/ivy/functional/frontends/tensorflow/keras/backend.py b/ivy/functional/frontends/tensorflow/keras/backend.py index d5d9e033e7053..6c29237ef6b5e 100644 --- a/ivy/functional/frontends/tensorflow/keras/backend.py +++ b/ivy/functional/frontends/tensorflow/keras/backend.py @@ -24,6 +24,51 @@ def bias_add(x, bias, data_format=None): return tf_frontend.nn.bias_add(x, bias) +@to_ivy_arrays_and_back +def depthwise_conv2d( + x, + depthwise_kernel, + strides=(1, 1), + padding="valid", + data_format=None, + dilation_rate=(1, 1), +): + data_format = "channels_last" if data_format is None else data_format + if data_format not in {"channels_first", "channels_last"}: + raise ValueError("Unknown data_format: " + str(data_format)) + + tf_data_format = "NHWC" + permuted_x = False + if data_format == "channels_first": + if ivy.dev(x) == "cpu": + x = tf_frontend.transpose(x, (0, 2, 3, 1)) # NCHW -> NHWC + permuted_x = True + else: + tf_data_format = "NCHW" + + padding = padding.upper() + if padding not in {"VALID", "SAME"}: + raise ValueError("Unknown padding: " + str(padding)) + + if tf_data_format == "NHWC": + strides = (1,) + strides + (1,) + else: + strides = (1, 1) + strides + + x = tf_frontend.nn.depthwise_conv2d( + x, + depthwise_kernel, + strides=strides, + padding=padding, + dilations=dilation_rate, + data_format=tf_data_format, + ) + + if permuted_x: + x = tf_frontend.transpose(x, (0, 3, 1, 2)) # NHWC -> NCHW + return x + + @to_ivy_arrays_and_back def dot(x, y): return ivy.dot(x, y) diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index 724c6d71d1a36..7cc55e31428bb 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -633,3 +633,6 @@ def weighted_moments(x, axes, frequency_weights, keepdims=False, name=None): weighted_mean = ivy.squeeze(weighted_mean, axis=axes) weighted_variance = ivy.squeeze(weighted_variance, axis=axes) return weighted_mean, weighted_variance + + +swish = silu diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py index 54d0e272d528e..21ba947042729 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_keras/test_backend.py @@ -22,6 +22,105 @@ import ivy.functional.frontends.tensorflow as tf_frontend +# --- Helpers --- # +# --------------- # + + +@st.composite +def _x_and_filters( + draw, + dtypes, + data_format, + padding=None, + stride_min=1, + stride_max=4, + dilation_min=1, + dilation_max=4, + type: str = "depthwise", +): + data_format = draw(data_format) + dtype = draw(dtypes) + dim = 2 if type in ["depthwise", "separable"] else 4 + if padding is None: + padding = (st.sampled_from(["same", "valid"]),) + padding = draw(padding) + dilations = draw( + st.one_of( + st.integers(dilation_min, dilation_max), + st.lists( + st.integers(dilation_min, dilation_max), min_size=dim, max_size=dim + ), + ) + ) + fdilations = [dilations] * dim if isinstance(dilations, int) else dilations + if type in ["depthwise", "separable"]: + # if any value in dilations is greater than 1, tensorflow implements + # depthwise_covn2d as an atrous depthwise convolution, in which case all values + # in strides must be equal to 1. + if any(x > 1 for x in fdilations): + stride = 1 + else: + stride = draw(st.integers(stride_min, stride_max)) + else: + stride = draw( + st.one_of( + st.integers(stride_min, stride_max), + st.lists( + st.integers(stride_min, stride_max), min_size=dim, max_size=dim + ), + ) + ) + if dim == 2: + min_x_height = 1 + min_x_width = 1 + filter_shape = draw( + st.tuples( + helpers.ints(min_value=3, max_value=5), + helpers.ints(min_value=3, max_value=5), + helpers.ints(min_value=1, max_value=3), + helpers.ints(min_value=1, max_value=3), + ) + ) + min_x_height = filter_shape[0] + (filter_shape[0] - 1) * (fdilations[0] - 1) + min_x_width = filter_shape[1] + (filter_shape[1] - 1) * (fdilations[1] - 1) + d_in = filter_shape[2] + if data_format == "channels_last": + x_shape = draw( + st.tuples( + helpers.ints(min_value=1, max_value=5), + helpers.ints(min_value=min_x_height, max_value=100), + helpers.ints(min_value=min_x_width, max_value=100), + helpers.ints(min_value=d_in, max_value=d_in), + ) + ) + else: + x_shape = draw( + st.tuples( + helpers.ints(min_value=1, max_value=5), + helpers.ints(min_value=d_in, max_value=d_in), + helpers.ints(min_value=min_x_height, max_value=100), + helpers.ints(min_value=min_x_width, max_value=100), + ) + ) + x = draw( + helpers.array_values(dtype=dtype[0], shape=x_shape, min_value=0, max_value=1) + ) + filters = draw( + helpers.array_values( + dtype=dtype[0], shape=filter_shape, min_value=0, max_value=1 + ) + ) + if type in ["depthwise", "separable"]: + stride = (stride, stride) + if isinstance(dilations, int): + dilations = (dilations,) * dim + return dtype, x, filters, dilations, data_format, stride, padding + + +# --- Main --- # +# ------------ # + + @handle_frontend_test( fn_tree="tensorflow.keras.backend.dot", data=_generate_dot_dtype_and_arrays(min_num_dims=2), @@ -70,6 +169,42 @@ def test_tensorflow_keras_backend_bias_add( ) +@handle_frontend_test( + fn_tree="tensorflow.keras.backend.depthwise_conv2d", + x_f_d_df=_x_and_filters( + dtypes=helpers.get_dtypes("float", full=False), + data_format=st.sampled_from(["channels_last"]), + padding=st.sampled_from(["valid", "same"]), + type="depthwise", + ), + test_with_out=st.just(False), +) +def test_tensorflow_keras_backend_depthwise_conv2d( + *, + x_f_d_df, + frontend, + test_flags, + fn_tree, + backend_fw, + on_device, +): + input_dtype, x, filters, dilation, data_format, stride, padding = x_f_d_df + helpers.test_frontend_function( + input_dtypes=input_dtype, + backend_to_test=backend_fw, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + x=x, + depthwise_kernel=filters, + strides=stride, + padding=padding, + data_format=data_format, + dilation_rate=dilation, + ) + + # mean @handle_frontend_test( fn_tree="tensorflow.keras.backend.mean", From a3605b0c8542524cfa92b5b3db31a40798efd4e3 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 21 Feb 2024 19:52:13 +0530 Subject: [PATCH 871/978] fix: fixed lint error in adaptive_max_pool3d in layer (#28367) fixed --- ivy/functional/ivy/experimental/layers.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/ivy/functional/ivy/experimental/layers.py b/ivy/functional/ivy/experimental/layers.py index a5e06f7ebaf04..0942677e34361 100644 --- a/ivy/functional/ivy/experimental/layers.py +++ b/ivy/functional/ivy/experimental/layers.py @@ -2207,16 +2207,16 @@ def adaptive_max_pool3d( Parameters ---------- input - Input array. Must have shape (N, C, D_in, H_in, W_in) or (C, D_in, H_in, W_in) where N is - the batch dimension, C is the feature dimension, and D_in, H_in, and W_in are the 3 - spatial dimensions. + Input array. Must have shape (N, C, D_in, H_in, W_in) or (C, D_in, H_in, W_in) + where N is the batch dimension, C is the feature dimension, and D_in, H_in, + and W_in are the 3 spatial dimensions. output_size Spatial output size. Returns ------- - The result of the pooling operation. Will have shape (N, C, D_out, H_out, W_out) or - (C, D_out, H_out, W_out), where D_out, H_out, W_out = `output_size` + The result of the pooling operation. Will have shape (N, C, D_out, H_out, W_out) + or (C, D_out, H_out, W_out), where D_out, H_out, W_out = `output_size` """ squeeze = False if input.ndim == 4: From d940a62c3532998575b36be52f0d757bfde5a5a1 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 21 Feb 2024 21:22:59 +0530 Subject: [PATCH 872/978] fix: fixed the docstring test for ivy.hardsilu (#28370) --- ivy/data_classes/container/experimental/activations.py | 8 ++++---- ivy/functional/ivy/experimental/activations.py | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/ivy/data_classes/container/experimental/activations.py b/ivy/data_classes/container/experimental/activations.py index f561d7f3a8ec8..02f174d8d9a49 100644 --- a/ivy/data_classes/container/experimental/activations.py +++ b/ivy/data_classes/container/experimental/activations.py @@ -1882,8 +1882,8 @@ def _static_hardsilu( >>> y = ivy.Container._static_hardsilu(x) >>> print(y) { - a: ivy.array([-0.20833333, 0.33333333, 0.]), - b: ivy.array([0.29166667, 0.66666667, 1.66666667]) + a: ivy.array([-0.20833333, -0.33333334, 0.]), + b: ivy.array([0.29166666, 0.66666669, 1.66666663]) } """ return ContainerBase.cont_multi_map_in_function( @@ -1939,8 +1939,8 @@ def hardsilu( >>> y = x.hardsilu() >>> print(y) { - a: ivy.array([-0.20833333, 0.33333333, 0.]), - b: ivy.array([0.29166667, 0.66666667, 1.66666667]) + a: ivy.array([-0.20833333, -0.33333334, 0.]), + b: ivy.array([0.29166666, 0.66666669, 1.66666663]) } """ return self._static_hardsilu( diff --git a/ivy/functional/ivy/experimental/activations.py b/ivy/functional/ivy/experimental/activations.py index a9d41129fd362..736fcf1c6e647 100644 --- a/ivy/functional/ivy/experimental/activations.py +++ b/ivy/functional/ivy/experimental/activations.py @@ -994,12 +994,12 @@ def hardsilu( >>> x = ivy.array([1., 2., 3.]) >>> y = ivy.hardsilu(x) >>> print(y) - ivy.array([0.66666667, 1.66666667, 3.]) + ivy.array([0.66666669, 1.66666663, 3. ]) >>> x = ivy.array([-2.1241, 1.4897, 4.4090]) >>> y = ivy.zeros(3) >>> ivy.hardsilu(x, out=y) >>> print(y) - ivy.array([-0.3101, 1.1147, 4.4090]) + ivy.array([-0.31008321, 1.1147176 , 4.40899992]) With :class:`ivy.Container` input: @@ -1007,8 +1007,8 @@ def hardsilu( >>> y = ivy.hardsilu(x) >>> print(y) { - a: ivy.array([-0.20833333, 0.33333333, 0.]), - b: ivy.array([0.29166667, 0.66666667, 1.66666667]) + a: ivy.array([-0.20833333, -0.33333334, 0.]), + b: ivy.array([0.29166666, 0.66666669, 1.66666663]) } """ return current_backend(x).hardsilu(x, out=out) From 9a58cb2b32475e7d81ff4cc12fd10144acbfe827 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 21 Feb 2024 21:32:00 +0530 Subject: [PATCH 873/978] fix: minimum for complex dtype (#28364) --- ivy/functional/backends/paddle/elementwise.py | 8 +++++++- .../test_functional/test_core/test_elementwise.py | 4 ++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 0c0ddeb016fec..f7ee481f872c7 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -1098,7 +1098,13 @@ def minimum( ) -> paddle.Tensor: x1, x2, ret_dtype = _elementwise_helper(x1, x2) if paddle.is_complex(x1): - use_where = True + real_comparison = paddle.real(x1) < paddle.real(x2) + imag_comparison = paddle_backend.logical_and( + paddle.real(x1) == paddle.real(x2), paddle.imag(x1) < paddle.imag(x2) + ) + return paddle_backend.where( + paddle_backend.logical_or(real_comparison, imag_comparison), x1, x2 + ).astype(ret_dtype) if use_where: return paddle_backend.where(paddle_backend.less_equal(x1, x2), x1, x2).astype( diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 5c35cf6ccfde6..5e2dc42aa3322 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -83,6 +83,8 @@ def min_max_helper(draw): num_arrays=2, min_value=-1e5, max_value=1e5, + small_abs_safety_factor=6, + large_abs_safety_factor=6, safety_factor_scale="log", ) ) @@ -1182,6 +1184,7 @@ def test_less(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2 ), test_gradients=st.just(False), + ground_truth_backend="jax", ) def test_less_equal(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): input_dtype, x = dtype_and_x @@ -1463,6 +1466,7 @@ def test_maximum( fn_tree="functional.ivy.minimum", dtype_and_x_and_use_where=min_max_helper(), test_gradients=st.just(False), + ground_truth_backend="jax", ) def test_minimum( *, dtype_and_x_and_use_where, test_flags, backend_fw, fn_name, on_device From 73fe907b73ca76d3f4b653b3b8b408693e03f81e Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Wed, 21 Feb 2024 09:49:41 -0800 Subject: [PATCH 874/978] fix: specify supported dtypes for permute_dims in paddle backend (#28310) --- ivy/functional/backends/paddle/manipulation.py | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index d8a42449309e3..44271c6400601 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -108,8 +108,19 @@ def flip( return paddle.flip(x, axis) -@with_unsupported_dtypes( - {"2.6.0 and below": ("uint8", "int8", "int16", "bfloat16")}, backend_version +@with_supported_dtypes( + { + "2.6.0 and below": ( + "int32", + "int64", + "float64", + "complex128", + "float32", + "complex64", + "bool", + ) + }, + backend_version, ) def permute_dims( x: paddle.Tensor, From ffb15c41fc961849c9f2c672159973e9aaafea36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kacper=20Ko=C5=BCdo=C5=84?= <102428159+Kacper-W-Kozdon@users.noreply.github.com> Date: Wed, 21 Feb 2024 19:32:26 +0100 Subject: [PATCH 875/978] fix: fix `test_torch_matrix_norm` in torch frontend with explicit dtype parameter handling (#28323) Co-authored-by: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> --- ivy/functional/backends/jax/linear_algebra.py | 3 +++ ivy/functional/backends/numpy/linear_algebra.py | 3 +++ .../backends/paddle/linear_algebra.py | 3 +++ .../backends/tensorflow/linear_algebra.py | 3 +++ ivy/functional/backends/torch/linear_algebra.py | 6 +++++- ivy/functional/frontends/torch/linalg.py | 6 ++---- ivy/functional/ivy/linear_algebra.py | 6 +++++- .../test_frontends/test_torch/test_linalg.py | 17 +++++++++++------ 8 files changed, 35 insertions(+), 12 deletions(-) diff --git a/ivy/functional/backends/jax/linear_algebra.py b/ivy/functional/backends/jax/linear_algebra.py index 8d6660109a08e..886d159961ef1 100644 --- a/ivy/functional/backends/jax/linear_algebra.py +++ b/ivy/functional/backends/jax/linear_algebra.py @@ -191,8 +191,11 @@ def matrix_norm( ord: Union[int, float, Literal[inf, -inf, "fro", "nuc"]] = "fro", axis: Tuple[int, int] = (-2, -1), keepdims: bool = False, + dtype: Optional[jnp.dtype] = None, out: Optional[JaxArray] = None, ) -> JaxArray: + if dtype is not None: + x = ivy.astype(x, dtype) if hasattr(axis, "__iter__"): if not isinstance(axis, tuple): axis = tuple(axis) diff --git a/ivy/functional/backends/numpy/linear_algebra.py b/ivy/functional/backends/numpy/linear_algebra.py index 1f0eb33a2506d..98b5096a7c33c 100644 --- a/ivy/functional/backends/numpy/linear_algebra.py +++ b/ivy/functional/backends/numpy/linear_algebra.py @@ -148,8 +148,11 @@ def matrix_norm( ord: Union[int, float, Literal[inf, -inf, "fro", "nuc"]] = "fro", axis: Tuple[int, int] = (-2, -1), keepdims: bool = False, + dtype: Optional[np.dtype] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: + if dtype is not None: + x = ivy.astype(x, dtype) if not isinstance(axis, tuple): axis = tuple(axis) return np.linalg.norm(x, ord=ord, axis=axis, keepdims=keepdims) diff --git a/ivy/functional/backends/paddle/linear_algebra.py b/ivy/functional/backends/paddle/linear_algebra.py index cdad53a1fbf81..ddf447a62e946 100644 --- a/ivy/functional/backends/paddle/linear_algebra.py +++ b/ivy/functional/backends/paddle/linear_algebra.py @@ -263,8 +263,11 @@ def matrix_norm( ord: Union[int, float, Literal[inf, -inf, "fro", "nuc"]] = "fro", axis: Tuple[int, int] = (-2, -1), keepdims: bool = False, + dtype: Optional[paddle.dtype] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: + if dtype is not None: + x = ivy.astype(x, dtype=dtype) axis_ = list(axis) # paddle.moveaxis doesn't support tuple axes if ord == "nuc": x = paddle.moveaxis(x, axis_, [-2, -1]) diff --git a/ivy/functional/backends/tensorflow/linear_algebra.py b/ivy/functional/backends/tensorflow/linear_algebra.py index f6b412c9cb190..fc31085e3ba6f 100644 --- a/ivy/functional/backends/tensorflow/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/linear_algebra.py @@ -288,8 +288,11 @@ def matrix_norm( ord: Union[int, float, Literal[inf, -inf, "fro", "nuc"]] = "fro", axis: Tuple[int, int] = (-2, -1), keepdims: bool = False, + dtype: Optional[tf.DType] = None, out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: + if dtype is not None: + x = ivy.astype(x, dtype) if ord == "nuc": x = tf.experimental.numpy.moveaxis(x, axis, (-2, -1)) ret = tf.reduce_sum( diff --git a/ivy/functional/backends/torch/linear_algebra.py b/ivy/functional/backends/torch/linear_algebra.py index 6db582134e52c..39a2d1919838e 100644 --- a/ivy/functional/backends/torch/linear_algebra.py +++ b/ivy/functional/backends/torch/linear_algebra.py @@ -201,9 +201,13 @@ def matrix_norm( ord: Union[int, float, Literal[inf, -inf, "fro", "nuc"]] = "fro", axis: Tuple[int, int] = (-2, -1), keepdims: bool = False, + dtype: Optional[torch.dtype] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: - return torch.linalg.matrix_norm(x, ord=ord, dim=axis, keepdim=keepdims, out=out) + ret = torch.linalg.matrix_norm( + x, ord=ord, dim=axis, keepdim=keepdims, dtype=dtype, out=out + ) + return ret matrix_norm.support_native_out = True diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index 4df5186b46b1b..c8b0260412b0b 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -173,10 +173,8 @@ def matrix_exp(A): {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) def matrix_norm(input, ord="fro", dim=(-2, -1), keepdim=False, *, dtype=None, out=None): - if "complex" in ivy.as_ivy_dtype(input.dtype): - input = ivy.abs(input) - if dtype: - input = ivy.astype(input, ivy.as_ivy_dtype(dtype)) + if dtype is not None: + input = ivy.astype(input, dtype) return ivy.matrix_norm(input, ord=ord, axis=dim, keepdims=keepdim, out=out) diff --git a/ivy/functional/ivy/linear_algebra.py b/ivy/functional/ivy/linear_algebra.py index b0f7b47bc4691..434c25997a68b 100644 --- a/ivy/functional/ivy/linear_algebra.py +++ b/ivy/functional/ivy/linear_algebra.py @@ -1144,6 +1144,7 @@ def matrix_norm( ord: Union[int, float, Literal[inf, -inf, "fro", "nuc"]] = "fro", axis: Tuple[int, int] = (-2, -1), keepdims: bool = False, + dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None, out: Optional[ivy.Array] = None, ) -> ivy.Array: """Compute the matrix p-norm. @@ -1198,6 +1199,9 @@ def matrix_norm( If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original x. Default is ``False``. + dtype + If specified, the input tensor is cast to dtype before performing the operation, + and the returned tensor's type will be dtype. Default: None out optional output array, for writing the result to. It must have a shape that the inputs broadcast to. @@ -1286,7 +1290,7 @@ def matrix_norm( } """ return current_backend(x).matrix_norm( - x, ord=ord, axis=axis, keepdims=keepdims, out=out + x, ord=ord, axis=axis, keepdims=keepdims, dtype=dtype, out=out ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index d8ec53c3e8aed..f3e37cdf4efed 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -899,32 +899,37 @@ def test_torch_matrix_exp( @handle_frontend_test( fn_tree="torch.linalg.matrix_norm", dtype_values_axis=helpers.dtype_values_axis( - available_dtypes=helpers.get_dtypes("valid"), + available_dtypes=helpers.get_dtypes("float_and_complex"), min_num_dims=2, min_axes_size=2, max_axes_size=2, - min_value=-1e04, - max_value=1e04, + max_value=10e4, + min_value=-10e4, + abs_smallest_val=10e-4, valid_axis=True, force_tuple_axis=True, ), ord=st.sampled_from(["fro", "nuc", np.inf, -np.inf, 1, -1, 2, -2]), keepdim=st.booleans(), - dtype=helpers.get_dtypes("valid", none=True, full=False), + dtypes=helpers.get_dtypes("float_and_complex", none=True, full=False), ) def test_torch_matrix_norm( *, dtype_values_axis, ord, keepdim, - dtype, frontend, + dtypes, test_flags, fn_tree, backend_fw, on_device, ): input_dtype, x, axis = dtype_values_axis + if dtypes[0] is not None and "complex128" in input_dtype[0]: + dtypes[0] = input_dtype[0] + if dtypes[0] is not None: + dtypes[0] = input_dtype[0][:-2] + max([input_dtype[0][-2:], dtypes[0][-2:]]) helpers.test_frontend_function( input_dtypes=input_dtype, @@ -939,7 +944,7 @@ def test_torch_matrix_norm( ord=ord, dim=axis, keepdim=keepdim, - dtype=dtype[0], + dtype=dtypes[0], ) From 36fd2484588d92f7d81548a6ecfefc65ac5024da Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 22 Feb 2024 02:59:17 +0530 Subject: [PATCH 876/978] fix: fixed the minimum at tf frontend (#28373) --- ivy/functional/frontends/tensorflow/math.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index 0192acaef1e5c..ab281931c99ee 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -626,6 +626,7 @@ def maximum(x, y, name=None): @to_ivy_arrays_and_back +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, "tensorflow") def minimum(x, y, name=None): return ivy.minimum(x, y) From bba6fa3fdb58d081ee28758f0a6d9f4fa33e8b0e Mon Sep 17 00:00:00 2001 From: Vaatsalya <96314403+vaatsalya123@users.noreply.github.com> Date: Thu, 22 Feb 2024 01:52:18 +0400 Subject: [PATCH 877/978] Update compiler.py eadf392 (#28376) Co-authored-by: ivy-branch From a243a6a80bc3749c581ba9b2cf2b2e3eb308c36b Mon Sep 17 00:00:00 2001 From: Vaatsalya <96314403+vaatsalya123@users.noreply.github.com> Date: Wed, 21 Feb 2024 16:54:43 -0500 Subject: [PATCH 878/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index b41c3588272f2..b982b20f2a8b3 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.7.1" +__version__ = "0.0.7.2" From 9085bd6a34cc0832c348a43da9f5327c46316b17 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 21 Feb 2024 22:36:12 +0000 Subject: [PATCH 879/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index d5dd40c78269c..104f88a7be642 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit d5dd40c78269c17561f1a489e2186b97738d1cdf +Subproject commit 104f88a7be64234ec58950deed8142bc7748d9da From 2a41cc977f40e92cc261cd20162e60a4073096e1 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Wed, 21 Feb 2024 23:53:35 +0000 Subject: [PATCH 880/978] fix: remove numpy use from tf backend split (#28377) --- ivy/functional/backends/tensorflow/manipulation.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/manipulation.py b/ivy/functional/backends/tensorflow/manipulation.py index 5e35641ab3c26..8635ca5ebb173 100644 --- a/ivy/functional/backends/tensorflow/manipulation.py +++ b/ivy/functional/backends/tensorflow/manipulation.py @@ -226,7 +226,6 @@ def split( num_or_size_splits = int(dim_size) if isinstance(num_or_size_splits, (tf.Tensor, tf.Variable)): num_or_size_splits = tf.cast(num_or_size_splits, tf.int32) - num_or_size_splits = num_or_size_splits.numpy().tolist() elif isinstance(num_or_size_splits, int) and with_remainder: num_chunks = x.shape[axis] / num_or_size_splits num_chunks_int = math.floor(num_chunks) From fb66d33274810fb420cc03d487c9ca73d799b152 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Thu, 22 Feb 2024 00:06:08 +0000 Subject: [PATCH 881/978] fix: remove numpy use from tf bincount backend (#28378) --- ivy/functional/backends/tensorflow/experimental/statistical.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/experimental/statistical.py b/ivy/functional/backends/tensorflow/experimental/statistical.py index 974b9886c3674..537dd72bcaf09 100644 --- a/ivy/functional/backends/tensorflow/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/experimental/statistical.py @@ -310,7 +310,7 @@ def bincount( out: Optional[Union[tf.Tensor, tf.Variable]] = None, ) -> Union[tf.Tensor, tf.Variable]: return tf.math.bincount( - x.numpy().tolist(), + x, weights=weights, minlength=minlength, dtype=x.dtype if weights is None else weights.dtype, From 459799c76d2f092978f06c5d6939f8f13e192ac2 Mon Sep 17 00:00:00 2001 From: Felix Hirwa Nshuti Date: Thu, 22 Feb 2024 13:02:28 +0530 Subject: [PATCH 882/978] fix: fixing the tests for the Shape `__ge__` method (#28384) --- ivy_tests/test_ivy/test_misc/test_shape.py | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/ivy_tests/test_ivy/test_misc/test_shape.py b/ivy_tests/test_ivy/test_misc/test_shape.py index 72f60d5209cc9..9ab019cb59275 100644 --- a/ivy_tests/test_ivy/test_misc/test_shape.py +++ b/ivy_tests/test_ivy/test_misc/test_shape.py @@ -113,15 +113,14 @@ def test_shape__eq__( @handle_method( + init_tree=CLASS_TREE, method_tree="Shape.__ge__", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), - num_arrays=2, - shared_dtype=True, - ), + shape_1=helpers.get_shape(), + shape_2=helpers.get_shape(), ) def test_shape__ge__( - dtype_and_x, + shape_1, + shape_2, method_name, class_name, ground_truth_backend, @@ -130,17 +129,16 @@ def test_shape__ge__( method_flags, on_device, ): - dtype, x = dtype_and_x helpers.test_method( on_device=on_device, ground_truth_backend=ground_truth_backend, backend_to_test=backend_fw, init_flags=init_flags, method_flags=method_flags, - init_all_as_kwargs_np={"shape": x[0]}, - init_input_dtypes=dtype, - method_input_dtypes=dtype, - method_all_as_kwargs_np={"other": x[1]}, + init_all_as_kwargs_np={"shape_tup": shape_1}, + init_input_dtypes=DUMMY_DTYPE, + method_input_dtypes=DUMMY_DTYPE, + method_all_as_kwargs_np={"other": shape_2}, class_name=class_name, method_name=method_name, ) From 5a4b8bdd373a8a0b639953d96d2831aa6827a01f Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Thu, 22 Feb 2024 15:08:51 +0530 Subject: [PATCH 883/978] feat: Updated autoflake version (#28386) --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 75efc76c1548d..7f554e7ec95f6 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -26,7 +26,7 @@ repos: ivy_tests/test_ivy/(?!.*(?:__init__\.py|conftest\.py|helpers/.*|test_frontends/config/.*$)).* ) - repo: https://github.com/PyCQA/autoflake - rev: v2.2.1 + rev: v2.3.0 hooks: - id: autoflake - repo: https://github.com/PyCQA/docformatter From 1bdf5c0dbde64a7fdc0a4e327b9fac259d6197aa Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Thu, 22 Feb 2024 16:38:58 +0000 Subject: [PATCH 884/978] feat: add tf ResourceVariable to frontend (#28393) --- ivy/functional/frontends/tensorflow/__init__.py | 1 + .../tensorflow/python/ops/resource_variable_ops.py | 6 ++++++ ivy/functional/frontends/tensorflow/variable.py | 6 +++--- 3 files changed, 10 insertions(+), 3 deletions(-) create mode 100644 ivy/functional/frontends/tensorflow/python/ops/resource_variable_ops.py diff --git a/ivy/functional/frontends/tensorflow/__init__.py b/ivy/functional/frontends/tensorflow/__init__.py index 9c1d731b8a586..50c96a4cecfe8 100644 --- a/ivy/functional/frontends/tensorflow/__init__.py +++ b/ivy/functional/frontends/tensorflow/__init__.py @@ -94,6 +94,7 @@ def check_tensorflow_casting(x1, x2): from .tensorarray import TensorArray from . import variable from .variable import Variable, IndexedSlices +from .python.ops.resource_variable_ops import ResourceVariable from . import keras from . import compat from . import image diff --git a/ivy/functional/frontends/tensorflow/python/ops/resource_variable_ops.py b/ivy/functional/frontends/tensorflow/python/ops/resource_variable_ops.py new file mode 100644 index 0000000000000..1ac276f9d2224 --- /dev/null +++ b/ivy/functional/frontends/tensorflow/python/ops/resource_variable_ops.py @@ -0,0 +1,6 @@ +# local +import ivy.functional.frontends.tensorflow as tf_frontend + + +class ResourceVariable(tf_frontend.Variable): + pass diff --git a/ivy/functional/frontends/tensorflow/variable.py b/ivy/functional/frontends/tensorflow/variable.py index e97034e4559f1..b580ba13d89e3 100644 --- a/ivy/functional/frontends/tensorflow/variable.py +++ b/ivy/functional/frontends/tensorflow/variable.py @@ -53,7 +53,7 @@ def shape(self): def assign(self, value, use_locking=None, name=None, read_value=True): ivy.utils.assertions.check_equal( - value.shape if hasattr(value, "ivy_array") else ivy.shape(value), + value.ivy_array.shape if hasattr(value, "ivy_array") else ivy.shape(value), self.shape, as_array=False, ) @@ -61,7 +61,7 @@ def assign(self, value, use_locking=None, name=None, read_value=True): def assign_add(self, delta, use_locking=None, name=None, read_value=True): ivy.utils.assertions.check_equal( - delta.shape if hasattr(delta, "ivy_array") else ivy.shape(delta), + delta.ivy_array.shape if hasattr(delta, "ivy_array") else ivy.shape(delta), self.shape, as_array=False, ) @@ -69,7 +69,7 @@ def assign_add(self, delta, use_locking=None, name=None, read_value=True): def assign_sub(self, delta, use_locking=None, name=None, read_value=True): ivy.utils.assertions.check_equal( - delta.shape if hasattr(delta, "ivy_array") else ivy.shape(delta), + delta.ivy_array.shape if hasattr(delta, "ivy_array") else ivy.shape(delta), self.shape, as_array=False, ) From 2571894f070f14c776bbae163965cd5a1efb8c24 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Sun, 25 Feb 2024 14:59:17 +0530 Subject: [PATCH 885/978] fix: fixed the hypothisis requirement error (#28412) Co-authored-by: NripeshN --- requirements/optional.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/optional.txt b/requirements/optional.txt index df07ce15dd0a8..7362789081551 100644 --- a/requirements/optional.txt +++ b/requirements/optional.txt @@ -1,7 +1,7 @@ h5py # unpinned pytest # unpinned networkx # unpinned -hypothesis # unpinned +hypothesis==6.98.10 # fixed version till this get solved: https://github.com/HypothesisWorks/hypothesis/issues/3896 pymongo # unpinned redis # unpinned matplotlib # unpinned From 4a141408d79aded10122863aecb2d42348f03f2f Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 25 Feb 2024 09:31:57 +0000 Subject: [PATCH 886/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e359c13c4280f..3845452e80378 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -14,7 +14,7 @@ Top Contributors - Badges * - samunder singh - `samthakur587 `_ - - Merging Master Gold, Merging Wizard, Ivy Inspector Bronze + - Merging Master Gold, Merging Wizard, Ivy Inspector Silver * - V\. Sai Suraj - `Sai-Suraj-27 `_ - Merging Master Gold, Ivy Inspector Bronze @@ -27,12 +27,12 @@ Core Contributors * - Name - Github ID - Badges - * - Sanjay Suthar + * - Muhammad ishaque + - `MuhammadNizamani `_ + - Merging Master Bronze, Merging Wizard, Ivy Inspector + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - Muhammad ishaque - - `MuhammadNizamani `_ - - Merging Master Bronze, Merging Wizard * - nitesh kesharwani - `NiteshK84 `_ - Ivy Inspector Bronze @@ -51,15 +51,24 @@ Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master, Merging Wizard + * - David Adlai Nettey + - `Adlai-1 `_ + - Merging Master, Ivy Inspector * - Garima Saroj - `AndroGari `_ - Merging Master, Ivy Inspector * - Jackson McClintock - `jacksondm33 `_ - Merging Master, Ivy Inspector + * - Lee Bissessar + - `leebissessar5 `_ + - Merging Master, Ivy Inspector * - Mostafa Gamal - `Mr-Array22 `_ - Merging Master, Ivy Inspector + * - Ogban Ugot + - `ogbanugot `_ + - Merging Master, Ivy Inspector * - Rahul Prem - `rp097 `_ - Merging Master, Ivy Inspector @@ -69,13 +78,13 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - David Adlai Nettey - - `Adlai-1 `_ + * - Aryan Pandey + - `Aryan8912 `_ - Merging Master * - Kacper Kożdoń - `Kacper-W-Kozdon `_ - Merging Master - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master * - Sheroz Khan From d4f46147ba9f44734430fb0afee079af8a432d6a Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 25 Feb 2024 09:33:25 +0000 Subject: [PATCH 887/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 3845452e80378..cdcd441ad7206 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,10 +27,10 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Bronze, Merging Wizard, Ivy Inspector - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze * - nitesh kesharwani @@ -78,13 +78,13 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Kacper Kożdoń - `Kacper-W-Kozdon `_ - Merging Master - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master * - Sheroz Khan From 26bf455d7482d9b0bcd288a68b6f7227928ce012 Mon Sep 17 00:00:00 2001 From: Muhammad Ishaque Nizamani <49721249+MuhammadNizamani@users.noreply.github.com> Date: Sun, 25 Feb 2024 02:08:22 -0800 Subject: [PATCH 888/978] Fix Ivy Failing Test: tensorflow - elementwise.pow (#28153) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- .../test_ivy/test_functional/test_core/test_elementwise.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 5e2dc42aa3322..7f24ba2d6e656 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1630,8 +1630,8 @@ def test_pow(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): backend_to_test=backend_fw, fn_name=fn_name, on_device=on_device, - rtol_=1e-2, - atol_=1e-2, + rtol_=1e-3, + atol_=1e-3, x1=x[0], x2=x[1], ) From 661030a06732e8534cd2e864e4c1cc4dc6f668fc Mon Sep 17 00:00:00 2001 From: Vismay Suramwar <83938053+Vismay-dev@users.noreply.github.com> Date: Sun, 25 Feb 2024 04:09:48 -0600 Subject: [PATCH 889/978] fix: Fixed `ivy.zero_pad` for paddle backend (#27994) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/manipulation.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index 44271c6400601..aa1a01315f952 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -436,6 +436,7 @@ def constant_pad( return paddle.nn.functional.pad(x=x, pad=paddings, value=value) +@with_unsupported_dtypes({"2.6.0 and below": ("float16",)}, backend_version) def zero_pad( x: paddle.Tensor, /, From 2e3d242d7b89da32a426b9e392413798568a580b Mon Sep 17 00:00:00 2001 From: Vismay Suramwar <83938053+Vismay-dev@users.noreply.github.com> Date: Sun, 25 Feb 2024 04:13:16 -0600 Subject: [PATCH 890/978] fix: Fix `ivy.permute_dims` for all backends (#28009) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- ivy/functional/backends/jax/manipulation.py | 3 +++ ivy/functional/backends/numpy/manipulation.py | 3 +++ ivy/functional/backends/paddle/manipulation.py | 17 +++++------------ ivy/functional/backends/torch/manipulation.py | 4 ++++ 4 files changed, 15 insertions(+), 12 deletions(-) diff --git a/ivy/functional/backends/jax/manipulation.py b/ivy/functional/backends/jax/manipulation.py index 360333e8a186c..ec3727de6ccd2 100644 --- a/ivy/functional/backends/jax/manipulation.py +++ b/ivy/functional/backends/jax/manipulation.py @@ -76,6 +76,9 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[JaxArray] = None, ) -> JaxArray: + if copy: + newarr = jnp.copy(x) + return jnp.transpose(newarr, axes) return jnp.transpose(x, axes) diff --git a/ivy/functional/backends/numpy/manipulation.py b/ivy/functional/backends/numpy/manipulation.py index 19023b3a23ab9..ee47d4c9b23e7 100644 --- a/ivy/functional/backends/numpy/manipulation.py +++ b/ivy/functional/backends/numpy/manipulation.py @@ -86,6 +86,9 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: + if copy: + newarr = np.copy(x) + return np.transpose(newarr, axes) return np.transpose(x, axes) diff --git a/ivy/functional/backends/paddle/manipulation.py b/ivy/functional/backends/paddle/manipulation.py index aa1a01315f952..c88903542619a 100644 --- a/ivy/functional/backends/paddle/manipulation.py +++ b/ivy/functional/backends/paddle/manipulation.py @@ -108,18 +108,8 @@ def flip( return paddle.flip(x, axis) -@with_supported_dtypes( - { - "2.6.0 and below": ( - "int32", - "int64", - "float64", - "complex128", - "float32", - "complex64", - "bool", - ) - }, +@with_unsupported_dtypes( + {"2.6.0 and below": ("uint8", "int8", "int16", "bfloat16", "float16")}, backend_version, ) def permute_dims( @@ -130,6 +120,9 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[paddle.Tensor] = None, ) -> paddle.Tensor: + if copy: + newarr = paddle.clone(x) + return paddle.transpose(newarr, axes) return paddle.transpose(x, axes) diff --git a/ivy/functional/backends/torch/manipulation.py b/ivy/functional/backends/torch/manipulation.py index 023fb00a7409c..0560c89f7e64f 100644 --- a/ivy/functional/backends/torch/manipulation.py +++ b/ivy/functional/backends/torch/manipulation.py @@ -78,6 +78,7 @@ def flip( return torch.flip(x, new_axis) +@with_unsupported_dtypes({"2.1.2 and below": ("bfloat16", "float16")}, backend_version) def permute_dims( x: torch.Tensor, /, @@ -86,6 +87,9 @@ def permute_dims( copy: Optional[bool] = None, out: Optional[torch.Tensor] = None, ) -> torch.Tensor: + if copy: + newarr = torch.clone(x).detach() + return torch.permute(newarr, axes) return torch.permute(x, axes) From f643c015eb7d513d0d812c02ff7bebacbbbb7df1 Mon Sep 17 00:00:00 2001 From: ksheroz <87086877+ksheroz@users.noreply.github.com> Date: Sun, 25 Feb 2024 15:15:59 +0500 Subject: [PATCH 891/978] fix: ivy elementwise not_equal for paddle backend (#28249) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- ivy/functional/backends/paddle/elementwise.py | 4 ++-- .../test_ivy/test_functional/test_core/test_elementwise.py | 4 +++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index f7ee481f872c7..4a6a647bc2179 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -615,8 +615,8 @@ def negative( return paddle.neg(x) -@with_supported_dtypes( - {"2.6.0 and below": ("float32", "float64", "int32", "int64")}, +@with_unsupported_device_and_dtypes( + {"2.6.0 and below": {"cpu": ("bfloat16", "complex128", "float64", "float32")}}, backend_version, ) def not_equal( diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 7f24ba2d6e656..3bbe5d364d932 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1577,7 +1577,7 @@ def test_negative(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.not_equal", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid", full=True), num_arrays=2 + available_dtypes=helpers.get_dtypes("valid", full=False), num_arrays=2 ), test_gradients=st.just(False), ) @@ -1592,6 +1592,8 @@ def test_not_equal(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): on_device=on_device, x1=x[0], x2=x[1], + atol_=1e-03, + rtol_=1e-03, ) From 93a7bc90d1e5840bd5a095bca5aad2e307dc75ac Mon Sep 17 00:00:00 2001 From: Suyash Gupta Date: Sun, 25 Feb 2024 15:51:42 +0530 Subject: [PATCH 892/978] fix: Fix Ivy Failing Test: numpy - manipulation.reshape (#28016) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- ivy/functional/backends/numpy/manipulation.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy/functional/backends/numpy/manipulation.py b/ivy/functional/backends/numpy/manipulation.py index ee47d4c9b23e7..55c72ec851974 100644 --- a/ivy/functional/backends/numpy/manipulation.py +++ b/ivy/functional/backends/numpy/manipulation.py @@ -108,6 +108,8 @@ def reshape( new_s if con else old_s for new_s, con, old_s in zip(shape, np.array(shape) != 0, x.shape) ] + if copy: + x = x.copy() return np.reshape(x, shape, order=order) From 13aff89c2c44896272de590e367a6d99259ccc54 Mon Sep 17 00:00:00 2001 From: Suyash Gupta Date: Sun, 25 Feb 2024 15:53:56 +0530 Subject: [PATCH 893/978] fix: Fix Ivy Failing Test: all backends - manipulation.squeeze (#28035) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- ivy/functional/backends/jax/manipulation.py | 6 +++++- ivy/functional/backends/numpy/manipulation.py | 2 ++ ivy/functional/backends/torch/manipulation.py | 13 +++---------- 3 files changed, 10 insertions(+), 11 deletions(-) diff --git a/ivy/functional/backends/jax/manipulation.py b/ivy/functional/backends/jax/manipulation.py index ec3727de6ccd2..a792afa21b6eb 100644 --- a/ivy/functional/backends/jax/manipulation.py +++ b/ivy/functional/backends/jax/manipulation.py @@ -1,7 +1,8 @@ # global import math from numbers import Number -from typing import Union, Tuple, Optional, List, Sequence, Iterable +from typing import Iterable, List, Optional, Sequence, Tuple, Union + import jax.numpy as jnp import numpy as np @@ -9,6 +10,7 @@ import ivy from ivy.func_wrapper import with_unsupported_dtypes from ivy.functional.backends.jax import JaxArray + from . import backend_version @@ -125,6 +127,8 @@ def squeeze( copy: Optional[bool] = None, out: Optional[JaxArray] = None, ) -> JaxArray: + if copy: + x = jnp.copy(x) if x.shape == (): if axis is None or axis == 0 or axis == -1: return x diff --git a/ivy/functional/backends/numpy/manipulation.py b/ivy/functional/backends/numpy/manipulation.py index 55c72ec851974..ee2084c7d3b8e 100644 --- a/ivy/functional/backends/numpy/manipulation.py +++ b/ivy/functional/backends/numpy/manipulation.py @@ -134,6 +134,8 @@ def squeeze( ) -> np.ndarray: if isinstance(axis, list): axis = tuple(axis) + if copy: + x = x.copy() if x.shape == (): if axis is None or axis == 0 or axis == -1: return x diff --git a/ivy/functional/backends/torch/manipulation.py b/ivy/functional/backends/torch/manipulation.py index 0560c89f7e64f..8c4bdbb9eda22 100644 --- a/ivy/functional/backends/torch/manipulation.py +++ b/ivy/functional/backends/torch/manipulation.py @@ -157,12 +157,10 @@ def squeeze( f"Expected size of axis to be 1 but was {x.shape[axis]}" ) return torch.squeeze(x, axis) + if copy: + x = x.clone() if axis is None: - if copy: - newarr = torch.clone(x) - return torch.squeeze(newarr) return torch.squeeze(x) - newarr = torch.clone(x) if isinstance(axis, tuple): axis = list(axis) normalise_axis = [ @@ -179,12 +177,7 @@ def squeeze( f" {shape}" ) else: - if copy: - newarr = torch.squeeze(newarr, i) - else: - x = torch.squeeze(x, i) - if copy: - return newarr + x = torch.squeeze(x, i) return x From ae4dddc26b1c1be16a3af3b303947424725cd158 Mon Sep 17 00:00:00 2001 From: Suyash Gupta Date: Sun, 25 Feb 2024 15:55:47 +0530 Subject: [PATCH 894/978] fix: Fix Ivy Failing Test: [jax,numpy,torch] - general.get_item (#28049) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- ivy/functional/backends/jax/general.py | 21 ++++++++++++--------- ivy/functional/backends/numpy/general.py | 19 ++++++++++++------- ivy/functional/backends/torch/general.py | 9 ++++++--- 3 files changed, 30 insertions(+), 19 deletions(-) diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index 7bed7585f613b..79817119b082e 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -1,25 +1,26 @@ """Collection of Jax general functions, wrapped to fit Ivy syntax and signature.""" -# global -import jax -import numpy as np -import jax.numpy as jnp +import importlib +import multiprocessing as _multiprocessing +from functools import reduce as _reduce from numbers import Number from operator import mul -from functools import reduce as _reduce -from typing import Optional, Union, Sequence, Callable, Tuple -import multiprocessing as _multiprocessing -import importlib +from typing import Callable, Optional, Sequence, Tuple, Union +# global +import jax +import jax.numpy as jnp +import numpy as np # local import ivy from ivy.func_wrapper import with_unsupported_dtypes +from ivy.functional.backends.jax import JaxArray, NativeArray from ivy.functional.backends.jax.device import _to_array, _to_device from ivy.functional.ivy.general import _broadcast_to -from ivy.functional.backends.jax import JaxArray, NativeArray from ivy.utils.exceptions import _check_inplace_update_support + from . import backend_version @@ -68,6 +69,8 @@ def get_item( *, copy: Optional[bool] = None, ) -> JaxArray: + if copy: + x = x.copy() if ivy.is_array(query) and ivy.is_bool_dtype(query): if not len(query.shape): if not query: diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index 7db6a0c320298..4fde7cbcd4f39 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -1,20 +1,23 @@ """Collection of Numpy general functions, wrapped to fit Ivy syntax and signature.""" -# global -from typing import Optional, Union, Sequence, Callable, Tuple -import numpy as np -from operator import mul -from functools import reduce as _reduce import multiprocessing as _multiprocessing +from functools import reduce as _reduce from numbers import Number +from operator import mul + +# global +from typing import Callable, Optional, Sequence, Tuple, Union + +import numpy as np # local import ivy -from ivy.functional.backends.numpy.helpers import _scalar_output_to_0d_array from ivy.func_wrapper import with_unsupported_dtypes -from . import backend_version +from ivy.functional.backends.numpy.helpers import _scalar_output_to_0d_array + from ...ivy.general import _broadcast_to +from . import backend_version def array_equal(x0: np.ndarray, x1: np.ndarray, /) -> bool: @@ -37,6 +40,8 @@ def get_item( *, copy: Optional[bool] = None, ) -> np.ndarray: + if copy: + x = x.copy() return x.__getitem__(query) diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index ea02caf0707f3..4781a195a0f9e 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -5,7 +5,7 @@ from functools import reduce as _reduce from numbers import Number from operator import mul -from typing import Optional, Union, Sequence, Callable, List, Tuple +from typing import Callable, List, Optional, Sequence, Tuple, Union try: import functorch @@ -16,9 +16,10 @@ # local import ivy -from ivy.func_wrapper import with_unsupported_dtypes, _update_torch_views -from . import backend_version, is_variable +from ivy.func_wrapper import _update_torch_views, with_unsupported_dtypes + from ...ivy.general import _broadcast_to +from . import backend_version, is_variable torch_scatter = None @@ -94,6 +95,8 @@ def get_item( *, copy: Optional[bool] = None, ) -> torch.Tensor: + if copy: + x = x.clone() return x.__getitem__(query) From 1157ec157e9daaf90af090fa6118ba7a489b231f Mon Sep 17 00:00:00 2001 From: srikar <80592970+shruzki@users.noreply.github.com> Date: Sun, 25 Feb 2024 16:00:49 +0530 Subject: [PATCH 895/978] Fix Frontend Failing Test: torch - linalg.torch.linalg.norm (#28106) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- ivy/functional/frontends/torch/linalg.py | 8 ++++++-- .../test_ivy/test_frontends/test_torch/test_linalg.py | 2 +- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index c8b0260412b0b..2dd1074416540 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -215,10 +215,14 @@ def norm(input, ord=None, dim=None, keepdim=False, *, dtype=None, out=None): elif dim is None and ord is None: input = ivy.flatten(input) ret = ivy.vector_norm(input, axis=0, keepdims=keepdim, ord=2) - if isinstance(dim, int): + elif isinstance(dim, int): ret = ivy.vector_norm(input, axis=dim, keepdims=keepdim, ord=ord) - elif isinstance(dim, tuple): + elif isinstance(dim, tuple) and len(dim) <= 2: ret = ivy.matrix_norm(input, axis=dim, keepdims=keepdim, ord=ord) + elif isinstance(dim, tuple) and len(dim) > 2: + raise RuntimeError( + f"linalg.norm: If dim is specified, it must be of length 1 or 2. Got {dim}" + ) return ret diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index f3e37cdf4efed..299edb7a9fd0e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -68,7 +68,7 @@ def _get_axis_and_p(draw): min_axes_size = 2 else: min_axes_size = 1 - max_axes_size = 5 + max_axes_size = 2 x_dtype, values, axis = draw( helpers.dtype_values_axis( available_dtypes=helpers.get_dtypes("valid"), From 9de0a01211979968c7182b1ebd9e21909f8f4633 Mon Sep 17 00:00:00 2001 From: Jackson McClintock Date: Sun, 25 Feb 2024 05:38:41 -0500 Subject: [PATCH 896/978] fix: Fix Frontend Failing Test: torch - tensor.torch.Tensor.__gt__ (#28219) (#28221) Co-authored-by: NripeshN --- .../test_frontends/test_torch/test_tensor.py | 38 ++++++++----------- 1 file changed, 16 insertions(+), 22 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 26e8c5ece6238..6b8f122486cd8 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -742,28 +742,22 @@ def test_torch___gt__( backend_fw, ): input_dtype, x = dtype_and_x - try: - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={ - "other": x[1], - }, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - except RuntimeError as e: - if "overflow" in e: - assume(False) - else: - raise + helpers.test_frontend_method( + init_input_dtypes=[input_dtype[0]], + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=[input_dtype[1]], + method_all_as_kwargs_np={ + "other": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) @handle_frontend_method( From 82ed332e0bc5b1e876fe014b731d4ef2974547c8 Mon Sep 17 00:00:00 2001 From: Lyngkhoi <78148524+fleventy-5@users.noreply.github.com> Date: Sun, 25 Feb 2024 16:15:54 +0530 Subject: [PATCH 897/978] fix ivy creation.asarray for torch and tensorflow backend (#28226) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- .../test_ivy/test_functional/test_core/test_creation.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_creation.py b/ivy_tests/test_ivy/test_functional/test_core/test_creation.py index e13e0836f24eb..94def0ea2f966 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_creation.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_creation.py @@ -21,7 +21,7 @@ def _asarray_helper(draw): x_dtype, x = draw( helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), + available_dtypes=helpers.get_dtypes("valid"), num_arrays=st.integers(min_value=1, max_value=10), min_num_dims=0, max_num_dims=5, @@ -44,13 +44,13 @@ def _asarray_helper(draw): draw(helpers.get_dtypes("numeric")), dtype=x_dtype[0] ) )[-1] - dtype = draw(st.sampled_from([dtype, None])) + dtype = draw(st.sampled_from([dtype])) x = draw( st.sampled_from( [ x, x_list, - sh, + # sh, # nested_values, ] ) @@ -185,7 +185,7 @@ def test_arange( x_dtype_x_and_dtype=_asarray_helper(), test_gradients=st.just(False), test_instance_method=st.just(False), - test_with_copy=st.just(True), + test_with_copy=st.just(False), ) def test_asarray( *, From ad7e5d3038c4a69e1087c96a65115a418f32c9d1 Mon Sep 17 00:00:00 2001 From: Lyngkhoi <78148524+fleventy-5@users.noreply.github.com> Date: Sun, 25 Feb 2024 16:16:35 +0530 Subject: [PATCH 898/978] fix Ivy Failing Test: paddle - activations.softmax (#28241) Co-authored-by: NripeshN --- ivy/functional/backends/paddle/activations.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/paddle/activations.py b/ivy/functional/backends/paddle/activations.py index 88975658f1fee..8ddaff5b70a09 100644 --- a/ivy/functional/backends/paddle/activations.py +++ b/ivy/functional/backends/paddle/activations.py @@ -16,6 +16,7 @@ from ivy.func_wrapper import ( with_unsupported_device_and_dtypes, with_supported_dtypes, + with_unsupported_dtypes, with_supported_device_and_dtypes, ) from . import backend_version @@ -95,8 +96,8 @@ def sigmoid( return F.sigmoid(x) -@with_unsupported_device_and_dtypes( - {"2.6.0 and below": {"cpu": ("bfloat16", "float16")}}, backend_version +@with_unsupported_dtypes( + {"2.6.0 and below": ("bfloat16", "float16", "complex128")}, backend_version ) def softmax( x: paddle.Tensor, From f51d0fc495502f0f622a0ff2a565dc99a376e416 Mon Sep 17 00:00:00 2001 From: Lyngkhoi <78148524+fleventy-5@users.noreply.github.com> Date: Sun, 25 Feb 2024 16:20:46 +0530 Subject: [PATCH 899/978] fix Ivy Failing Test: paddle - elementwise.equal (#28243) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- ivy/functional/backends/paddle/elementwise.py | 4 ++-- .../test_ivy/test_functional/test_core/test_elementwise.py | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 4a6a647bc2179..cec3a3703d480 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -121,8 +121,8 @@ def isinf( return paddle.zeros(shape=x.shape, dtype=bool) -@with_unsupported_dtypes( - {"2.6.0 and below": ("bfloat16",)}, +@with_unsupported_device_and_dtypes( + {"2.6.0 and below": {"cpu": ("bfloat16", "complex128", "float64", "float32")}}, backend_version, ) def equal( diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 3bbe5d364d932..e842285adf61b 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -708,6 +708,8 @@ def test_equal(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): on_device=on_device, x1=x[0], x2=x[1], + atol_=1e-03, + rtol_=1e-03, ) From 4c5b2468a96025116b39f27b59e7dfdfd7b4b8d9 Mon Sep 17 00:00:00 2001 From: Rahul Prem <117741770+rp097@users.noreply.github.com> Date: Sun, 25 Feb 2024 21:54:08 +1100 Subject: [PATCH 900/978] Fixed Ivy Frontend Test: numpy - linalg.scipy.linalg.norm (#28244) Co-authored-by: NripeshN --- ivy/functional/backends/torch/linear_algebra.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/torch/linear_algebra.py b/ivy/functional/backends/torch/linear_algebra.py index 39a2d1919838e..ca80da523971a 100644 --- a/ivy/functional/backends/torch/linear_algebra.py +++ b/ivy/functional/backends/torch/linear_algebra.py @@ -193,7 +193,7 @@ def matmul( matmul.support_native_out = True -@with_supported_dtypes({"2.2 and below": ("float", "complex")}, backend_version) +@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, backend_version) def matrix_norm( x: torch.Tensor, /, From 24f515377871edab86cb8d0b66c40021692f7eaa Mon Sep 17 00:00:00 2001 From: Lyngkhoi <78148524+fleventy-5@users.noreply.github.com> Date: Sun, 25 Feb 2024 16:27:01 +0530 Subject: [PATCH 901/978] fix creation_ops.torch.full for paddle frontend (#28267) Co-authored-by: NripeshN <86844847+NripeshN@users.noreply.github.com> --- ivy/functional/backends/paddle/creation.py | 11 +++++++++++ ivy/functional/backends/torch/creation.py | 9 +++++++-- ivy/functional/frontends/torch/creation_ops.py | 1 + .../test_frontends/test_torch/test_creation_ops.py | 4 ++-- 4 files changed, 21 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/paddle/creation.py b/ivy/functional/backends/paddle/creation.py index e3b802febecae..65d826733c439 100644 --- a/ivy/functional/backends/paddle/creation.py +++ b/ivy/functional/backends/paddle/creation.py @@ -215,6 +215,17 @@ def from_dlpack(x, /, *, out: Optional[paddle.Tensor] = None): return paddle.utils.dlpack.from_dlpack(capsule) +@with_unsupported_device_and_dtypes( + { + "2.6.0 and below": { + "cpu": ( + "complex", + "bool", + ) + } + }, + backend_version, +) def full( shape: Union[ivy.NativeShape, Sequence[int]], fill_value: Union[int, float, bool], diff --git a/ivy/functional/backends/torch/creation.py b/ivy/functional/backends/torch/creation.py index ab6351d5054f7..082aefa280f56 100644 --- a/ivy/functional/backends/torch/creation.py +++ b/ivy/functional/backends/torch/creation.py @@ -236,6 +236,7 @@ def from_dlpack(x, /, *, out: Optional[torch.Tensor] = None): return torch.from_dlpack(x) +@with_unsupported_dtypes({"2.2.0 and below": ("bfloat16",)}, backend_version) def full( shape: Union[ivy.NativeShape, Sequence[int]], fill_value: Union[int, float, bool], @@ -247,9 +248,13 @@ def full( dtype = ivy.default_dtype(dtype=dtype, item=fill_value, as_native=True) if isinstance(shape, int): shape = (shape,) + + shape = tuple(int(dim) for dim in shape) + fill_value = torch.tensor(fill_value, dtype=dtype) + return torch.full( - shape, - fill_value, + size=shape, + fill_value=fill_value, dtype=dtype, device=device, out=out, diff --git a/ivy/functional/frontends/torch/creation_ops.py b/ivy/functional/frontends/torch/creation_ops.py index 920756f7e814b..f30eb6f324541 100644 --- a/ivy/functional/frontends/torch/creation_ops.py +++ b/ivy/functional/frontends/torch/creation_ops.py @@ -178,6 +178,7 @@ def frombuffer( return ivy.frombuffer(buffer, dtype=dtype, count=count, offset=offset) +@with_unsupported_dtypes({"2.2.0 and below": ("bfloat16",)}, "torch") @to_ivy_arrays_and_back def full( size, diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_creation_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_creation_ops.py index 136390818d19e..989a783e225d6 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_creation_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_creation_ops.py @@ -81,7 +81,7 @@ def _as_tensor_helper(draw): @st.composite def _fill_value(draw): with_array = draw(st.sampled_from([True, False])) - dtype = draw(st.shared(helpers.get_dtypes("numeric", full=False), key="dtype"))[0] + dtype = draw(st.shared(helpers.get_dtypes("valid", full=False), key="dtype"))[0] with BackendHandler.update_backend(test_globals.CURRENT_BACKEND) as ivy_backend: if ivy_backend.is_uint_dtype(dtype): ret = draw(helpers.ints(min_value=0, max_value=5)) @@ -512,7 +512,7 @@ def test_torch_frombuffer( max_dim_size=10, ), fill_value=_fill_value(), - dtype=st.shared(helpers.get_dtypes("numeric", full=False), key="dtype"), + dtype=st.shared(helpers.get_dtypes("valid", full=False), key="dtype"), ) def test_torch_full( *, From c7279953c25e4228a6baa4b7a5765643e1a7cd9f Mon Sep 17 00:00:00 2001 From: BilgehanMehmet <29982854+BilgehanMehmet@users.noreply.github.com> Date: Sun, 25 Feb 2024 14:00:30 +0300 Subject: [PATCH 902/978] Fixed failing tests for torch - linalg.vector_norm (#28273) Co-authored-by: NripeshN --- ivy/functional/backends/tensorflow/linear_algebra.py | 1 + ivy/functional/backends/torch/linear_algebra.py | 10 +++++++++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/tensorflow/linear_algebra.py b/ivy/functional/backends/tensorflow/linear_algebra.py index fc31085e3ba6f..230d91a7be0f3 100644 --- a/ivy/functional/backends/tensorflow/linear_algebra.py +++ b/ivy/functional/backends/tensorflow/linear_algebra.py @@ -629,6 +629,7 @@ def vecdot( "float16", "bfloat16", "integer", + "complex64", ) }, backend_version, diff --git a/ivy/functional/backends/torch/linear_algebra.py b/ivy/functional/backends/torch/linear_algebra.py index ca80da523971a..a22ed63c897b1 100644 --- a/ivy/functional/backends/torch/linear_algebra.py +++ b/ivy/functional/backends/torch/linear_algebra.py @@ -493,7 +493,15 @@ def vecdot( vecdot.support_native_out = True -@with_unsupported_dtypes({"2.2 and below": ("integer",)}, backend_version) +@with_unsupported_dtypes( + { + "2.2 and below": ( + "integer", + "complex64", + ) + }, + backend_version, +) def vector_norm( x: torch.Tensor, /, From 5fcf74b3140458b3f212357592f1e2460d047d98 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 25 Feb 2024 11:17:18 +0000 Subject: [PATCH 903/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 41 +++++++++++++++++++++---------- 1 file changed, 28 insertions(+), 13 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index cdcd441ad7206..80f3e986f7a3e 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -18,6 +18,18 @@ Top Contributors * - V\. Sai Suraj - `Sai-Suraj-27 `_ - Merging Master Gold, Ivy Inspector Bronze +Rising Contributors +------------------- +.. list-table:: + :widths: 50 50 50 + :header-rows: 1 + + * - Name + - Github ID + - Badges + * - Muhammad ishaque + - `MuhammadNizamani `_ + - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors ----------------- .. list-table:: @@ -27,12 +39,15 @@ Core Contributors * - Name - Github ID - Badges - * - Muhammad ishaque - - `MuhammadNizamani `_ - - Merging Master Bronze, Merging Wizard, Ivy Inspector - * - Sanjay Suthar + * - Suyash Gupta + - `sgalpha01 `_ + - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze + * - R E Zera Marveen Lyngkhoi + - `fleventy-5 `_ + - Merging Master Bronze * - nitesh kesharwani - `NiteshK84 `_ - Ivy Inspector Bronze @@ -48,18 +63,15 @@ Contributors * - Name - Github ID - Badges - * - Suyash Gupta - - `sgalpha01 `_ - - Debugging Dynamo, Merging Master, Merging Wizard + * - Jackson McClintock + - `jacksondm33 `_ + - Merging Master, Merging Wizard, Ivy Inspector * - David Adlai Nettey - `Adlai-1 `_ - Merging Master, Ivy Inspector * - Garima Saroj - `AndroGari `_ - Merging Master, Ivy Inspector - * - Jackson McClintock - - `jacksondm33 `_ - - Merging Master, Ivy Inspector * - Lee Bissessar - `leebissessar5 `_ - Merging Master, Ivy Inspector @@ -75,17 +87,20 @@ Contributors * - Rohit Kumar Salla - `rohitsalla `_ - Merging Master, Ivy Inspector + * - Srikar Vedantam + - `shruzki `_ + - Merging Master, Merging Wizard * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Kacper Kożdoń - `Kacper-W-Kozdon `_ - Merging Master - * - R E Zera Marveen Lyngkhoi - - `fleventy-5 `_ + * - Mehmet Bilgehan Bezcioglu + - `BilgehanMehmet `_ - Merging Master * - Sheroz Khan - `ksheroz `_ From 050be25de2b5b320917b0f6c34a7452ac3020890 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 25 Feb 2024 11:18:41 +0000 Subject: [PATCH 904/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 80f3e986f7a3e..07dd38d316ac6 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Kacper Kożdoń From 76bef3e371392b2d2017c5cef77a494216d5f693 Mon Sep 17 00:00:00 2001 From: muzakkirhussain011 <138936198+muzakkirhussain011@users.noreply.github.com> Date: Sun, 25 Feb 2024 17:41:35 +0530 Subject: [PATCH 905/978] Add recall_score function in Ivy with Test (#27986) Co-authored-by: ivy-branch --- .../sklearn/metrics/_classification.py | 33 +++++++++ .../test_metrics/test_classification.py | 67 ++++++++++++++++++- 2 files changed, 99 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/sklearn/metrics/_classification.py b/ivy/functional/frontends/sklearn/metrics/_classification.py index e6679505631b5..4cee0d9e9187b 100644 --- a/ivy/functional/frontends/sklearn/metrics/_classification.py +++ b/ivy/functional/frontends/sklearn/metrics/_classification.py @@ -17,3 +17,36 @@ def accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=None): ret = ret / y_true.shape[0] ret = ret.astype("float64") return ret + + +@to_ivy_arrays_and_back +def recall_score(y_true, y_pred, *, sample_weight=None): + # Ensure that y_true and y_pred have the same shape + if y_true.shape != y_pred.shape: + raise IvyValueError("y_true and y_pred must have the same shape") + + # Check if sample_weight is provided and normalize it + if sample_weight is not None: + sample_weight = ivy.array(sample_weight) + if sample_weight.shape[0] != y_true.shape[0]: + raise IvyValueError( + "sample_weight must have the same length as y_true and y_pred" + ) + sample_weight = sample_weight / ivy.sum(sample_weight) + else: + sample_weight = ivy.ones_like(y_true) + + # Calculate true positives and actual positives + true_positives = ivy.logical_and(ivy.equal(y_true, 1), ivy.equal(y_pred, 1)).astype( + "int64" + ) + actual_positives = ivy.equal(y_true, 1).astype("int64") + + # Apply sample weights + weighted_true_positives = ivy.multiply(true_positives, sample_weight) + weighted_actual_positives = ivy.multiply(actual_positives, sample_weight) + + # Compute recall + ret = ivy.sum(weighted_true_positives) / ivy.sum(weighted_actual_positives) + ret = ret.astype("float64") + return ret diff --git a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_metrics/test_classification.py b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_metrics/test_classification.py index 7977c77df3d03..1d8342188abee 100644 --- a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_metrics/test_classification.py +++ b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_metrics/test_classification.py @@ -1,5 +1,5 @@ from hypothesis import strategies as st - +import torch import ivy_tests.test_ivy.helpers as helpers from ivy_tests.test_ivy.helpers import handle_frontend_test import numpy as np @@ -43,3 +43,68 @@ def test_sklearn_accuracy_score( normalize=normalize, sample_weight=None, ) + + +@handle_frontend_test( + fn_tree="sklearn.metrics.recall_score", + arrays_and_dtypes=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("integer"), + num_arrays=2, + min_value=0, + max_value=1, # Recall score is for binary classification + shared_dtype=True, + shape=(helpers.ints(min_value=2, max_value=5)), + ), + sample_weight=st.lists( + st.floats(min_value=0.1, max_value=1), min_size=2, max_size=5 + ), +) +def test_sklearn_recall_score( + arrays_and_dtypes, + on_device, + fn_tree, + frontend, + test_flags, + backend_fw, + sample_weight, +): + dtypes, values = arrays_and_dtypes + # Ensure the values are binary by rounding and converting to int + for i in range(2): + values[i] = np.round(values[i]).astype(int) + + # Adjust sample_weight to have the correct length + sample_weight = np.array(sample_weight).astype(float) + if len(sample_weight) != len(values[0]): + # If sample_weight is shorter, extend it with ones + sample_weight = np.pad( + sample_weight, + (0, max(0, len(values[0]) - len(sample_weight))), + "constant", + constant_values=1.0, + ) + # If sample_weight is longer, truncate it + sample_weight = sample_weight[: len(values[0])] + + # Detach tensors if they require grad before converting to NumPy arrays + if backend_fw == "torch": + values = [ + ( + value.detach().numpy() + if isinstance(value, torch.Tensor) and value.requires_grad + else value + ) + for value in values + ] + + helpers.test_frontend_function( + input_dtypes=dtypes, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + frontend=frontend, + on_device=on_device, + y_true=values[0], + y_pred=values[1], + sample_weight=sample_weight, + ) From 13670b7f91b3cf25cac5fb15f0f59aa513f0d821 Mon Sep 17 00:00:00 2001 From: Dhruv <59387969+druvdub@users.noreply.github.com> Date: Sun, 25 Feb 2024 12:32:04 +0000 Subject: [PATCH 906/978] feat: Paddle Frontend implemented special method __mod__ (#28245) --- .../frontends/paddle/tensor/tensor.py | 4 ++ .../test_paddle/test_tensor/test_tensor.py | 41 +++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py index 51ba3eee9a1d7..90aa0c6357afb 100644 --- a/ivy/functional/frontends/paddle/tensor/tensor.py +++ b/ivy/functional/frontends/paddle/tensor/tensor.py @@ -264,6 +264,10 @@ def __int__(self): def __long__(self): return int(self._ivy_array) + @with_supported_dtypes({"2.6.0 and below": ("int32", "int64")}, "paddle") + def __mod__(self, y, /, name=None): + return paddle_frontend.Tensor(ivy.fmod(self._ivy_array, _to_ivy_array(y))) + # Instance Methods # # ---------------- # diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py index fe5e3dda8add5..c6381728e70d9 100644 --- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py @@ -906,6 +906,47 @@ def test_paddle___lt__( ) +# __mod__ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="paddle.to_tensor", + method_name="__mod__", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + num_arrays=2, + shared_dtype=True, + min_value=0, + exclude_min=True, + ), +) +def test_paddle___mod__( + dtype_and_x, + frontend_method_data, + init_flags, + method_flags, + frontend, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={ + "y": x[1], + }, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # __mul__ @handle_frontend_method( class_tree=CLASS_TREE, From 4454c23b6c6037416e5c03d915154288c7e05928 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 25 Feb 2024 13:03:56 +0000 Subject: [PATCH 907/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 07dd38d316ac6..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,9 +93,12 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master + * - Dhruv Sharma + - `druvdub `_ + - Merging Master * - Kacper Kożdoń - `Kacper-W-Kozdon `_ - Merging Master @@ -105,3 +108,6 @@ Contributors * - Sheroz Khan - `ksheroz `_ - Merging Master + * - Syed Muzakkir Hussain + - `muzakkirhussain011 `_ + - Merging Master From 024be98294a3fcf1f7691948d367ff30a71308ed Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 25 Feb 2024 13:05:15 +0000 Subject: [PATCH 908/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 7a50d3f95bbeeae9a1b58393a06e8b93cf961efb Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Mon, 26 Feb 2024 11:54:19 +0530 Subject: [PATCH 909/978] fix: fixed cummin not passing test at some backend (#28400) --- .../backends/paddle/experimental/statistical.py | 13 +++++++++++-- .../backends/tensorflow/experimental/statistical.py | 2 +- .../backends/torch/experimental/statistical.py | 2 +- .../test_experimental/test_core/test_statistical.py | 1 + 4 files changed, 14 insertions(+), 4 deletions(-) diff --git a/ivy/functional/backends/paddle/experimental/statistical.py b/ivy/functional/backends/paddle/experimental/statistical.py index 84425deeee725..2a611367b7151 100644 --- a/ivy/functional/backends/paddle/experimental/statistical.py +++ b/ivy/functional/backends/paddle/experimental/statistical.py @@ -680,8 +680,17 @@ def __get_index(lst, indices=None, prefix=None): return indices -@with_unsupported_device_and_dtypes( - {"2.6.0 and below": {"cpu": ("uint8", "int8", "int16")}}, +@with_supported_dtypes( + { + "2.6.0 and below": ( + "complex", + "int32", + "int64", + "bfloat16", + "float32", + "float64", + ) + }, backend_version, ) def cummin( diff --git a/ivy/functional/backends/tensorflow/experimental/statistical.py b/ivy/functional/backends/tensorflow/experimental/statistical.py index 537dd72bcaf09..ee728a6bcbf87 100644 --- a/ivy/functional/backends/tensorflow/experimental/statistical.py +++ b/ivy/functional/backends/tensorflow/experimental/statistical.py @@ -564,7 +564,7 @@ def __get_index(lst, indices=None, prefix=None): @with_unsupported_dtypes( - {"2.15.0 and below": ("bfloat16", "complex")}, + {"2.15.0 and below": ("bfloat16", "bool", "complex")}, backend_version, ) def cummin( diff --git a/ivy/functional/backends/torch/experimental/statistical.py b/ivy/functional/backends/torch/experimental/statistical.py index d5aa9e44c085a..f8f44a8f6ad03 100644 --- a/ivy/functional/backends/torch/experimental/statistical.py +++ b/ivy/functional/backends/torch/experimental/statistical.py @@ -630,7 +630,7 @@ def cummax( @with_unsupported_dtypes( { - "2.2 and below": ("uint8", "float16", "bfloat16"), + "2.2 and below": ("bool", "float16"), "1.12.1 and above": ("uint8", "float16"), }, backend_version, diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_statistical.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_statistical.py index 4a7f96a3f0714..88a710e3bd663 100644 --- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_statistical.py +++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_statistical.py @@ -463,6 +463,7 @@ def test_cummax( dtype_x_axis_castable=_get_castable_dtype(), exclusive=st.booleans(), reverse=st.booleans(), + test_gradients=st.just(False), ) def test_cummin( *, From 116d9bef5b7bb3bee108678b072eaeebbf210887 Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Mon, 26 Feb 2024 10:27:54 +0000 Subject: [PATCH 910/978] fix: removed code modifying ndarray/torch tensor methods (caused an issue with torch.compile recognising dunder methods). but added the same functionality using `__torch_function__`/`__array_ufunc__` which are the proper mechanisms to enable this behaviour. also simplified the test (#28394) --- ivy/data_classes/array/array.py | 4 +- ivy/functional/backends/numpy/__init__.py | 30 --------- ivy/functional/backends/torch/__init__.py | 75 ---------------------- ivy_tests/test_ivy/test_misc/test_array.py | 24 ++----- 4 files changed, 6 insertions(+), 127 deletions(-) diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 77536ed75c53e..58c94d8a97e70 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -349,7 +349,7 @@ def data(self, data): @classmethod def __torch_function__(cls, func, types, args=(), kwargs={}): args, kwargs = args_to_native(*args, **kwargs) - return func(*args, **kwargs) + return to_ivy(func(*args, **kwargs)) def __ivy_array_function__(self, func, types, args, kwargs): # Cannot handle items that have __ivy_array_function__ other than those of @@ -382,7 +382,7 @@ def __array_prepare__(self, *args, **kwargs): def __array_ufunc__(self, *args, **kwargs): args, kwargs = args_to_native(*args, **kwargs) - return self._data.__array_ufunc__(*args, **kwargs) + return to_ivy(self._data.__array_ufunc__(*args, **kwargs)) def __array_wrap__(self, *args, **kwargs): args, kwargs = args_to_native(*args, **kwargs) diff --git a/ivy/functional/backends/numpy/__init__.py b/ivy/functional/backends/numpy/__init__.py index d739b919131b9..d343709a92a00 100644 --- a/ivy/functional/backends/numpy/__init__.py +++ b/ivy/functional/backends/numpy/__init__.py @@ -16,36 +16,6 @@ use = ivy.utils.backend.ContextManager(_module_in_memory) -# wrap __array_ufunc__ method of ivy.Array to prioritize Ivy array methods when using numpu backend - - -def wrap__array_ufunc__(func): - def rep_method(self, ufunc, method, *inputs, **kwargs): - methods = { - "not_equal": "not_equal", - "greater": "greater", - "less": "less", - "greater_equal": "greater_equal", - "less_equal": "less_equal", - "multiply": "multiply", - "divide": "divide", - "remainder": "remainder", - "equal": "equal", - "bitwise_and": "bitwise_and", - "matmul": "matmul", - "power": "pow", - "subtract": "subtract", - "add": "add", - } - if ufunc.__name__ in methods: - return eval("ivy." + methods[ufunc.__name__] + "(*inputs, **kwargs)") - return func(self, ufunc, method, *inputs, **kwargs) - - return rep_method - - -ivy.Array.__array_ufunc__ = wrap__array_ufunc__(ivy.Array.__array_ufunc__) - NativeArray = np.ndarray NativeDevice = str NativeDtype = np.dtype diff --git a/ivy/functional/backends/torch/__init__.py b/ivy/functional/backends/torch/__init__.py index a9df06e5a6129..6068c355b1155 100644 --- a/ivy/functional/backends/torch/__init__.py +++ b/ivy/functional/backends/torch/__init__.py @@ -20,81 +20,6 @@ use = ivy.utils.backend.ContextManager(_module_in_memory) - -# wrap dunder methods of native tensors to return NotImplemented to prioritize Ivy array methods. -def dunder_wrapper(func): - def rep_method(*args, **kwargs): - for arg in args: - if ivy.is_ivy_array(arg): - return NotImplemented - return func(*args, **kwargs) - - return rep_method - - -# check for previously imported torch module -modules_to_patch = [] -tensors_to_patch = [] -tmp_globals = dict(globals()) -for name, value in tmp_globals.items(): - if value == "torch.Tensor": - tensors_to_patch.append(name) - try: - if value.__name__ == "torch": - modules_to_patch.append(name) - except AttributeError: - pass - -methods_to_patch = [ - "__add__", - "__and__", - "__div__", - "__eq__", - "__floordiv__", - "__ge__", - "__gt__", - "__iadd__", - "__iand__", - "__idiv__", - "__ifloordiv__", - "__ilshift__", - "__imul__", - "__ior__", - "__ipow__", - "__irshift__", - "__isub__", - "__itruediv__", - "__ixor__", - "__le__", - "__lshift__", - "__lt__", - "__matmul__", - "__mul__", - "__or__", - "__pow__", - "__truediv__", - "__xor__", - "__ne__", - "__mod__", -] - -for module in modules_to_patch: - for method in methods_to_patch: - exec( - module - + ".Tensor." - + method - + " = dunder_wrapper(" - + module - + ".Tensor." - + method - + ")" - ) - -for tensor in tensors_to_patch: - for method in methods_to_patch: - exec(tensor + "." + method + " = dunder_wrapper(" + tensor + "." + method + ")") - NativeArray = torch.Tensor NativeDevice = torch.device NativeDtype = torch.dtype diff --git a/ivy_tests/test_ivy/test_misc/test_array.py b/ivy_tests/test_ivy/test_misc/test_array.py index 3098bceadf03c..1fb44cef282d3 100644 --- a/ivy_tests/test_ivy/test_misc/test_array.py +++ b/ivy_tests/test_ivy/test_misc/test_array.py @@ -2543,30 +2543,14 @@ def test_array_property_strides(dtype_x, backend_fw): @handle_test( fn_tree="functional.ivy.native_array", # dummy fn_tree - dtype_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("integer"), - min_dim_size=3, - max_dim_size=3, - min_num_dims=3, - max_num_dims=3, - num_arrays=2, - min_value=3.0, - max_value=10.0, - ), op=st.sampled_from( - ["!=", ">", "<", ">=", "<=", "*", "/", "%", "==", "&", "@", "**", "/"] + ["!=", ">", "<", ">=", "<=", "*", "/", "%", "==", "&", "@", "**", "/"], ), ) -def test_dunder_wrapping( - dtype_x, - backend_fw, - test_flags, - op, -): - _, data = dtype_x +def test_dunder_wrapping(backend_fw, op): ivy.set_backend(backend_fw) - x = ivy.to_native(ivy.array(data[0])) - y = ivy.array(data[1]) + x = ivy.native_array([1]) + y = ivy.array([1]) assert ivy.is_ivy_array(y) assert ivy.is_native_array(x) res = eval(f"x {op} y") From 6c6ca509aee5998d1e2d8182f92102ad6e4c7d4c Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Mon, 26 Feb 2024 11:23:31 +0000 Subject: [PATCH 911/978] fix: Fixed Frontend Failing Test: paddle - tensor.torch.Tensor.repeat (#28324) --- ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index 6b8f122486cd8..a26b37feb402e 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -11338,6 +11338,12 @@ def test_torch_repeat( backend_fw, ): input_dtype, x, repeats = dtype_x_repeats + + if backend_fw == "paddle": + # paddle only supports size of the shape of repeats + # to be less than or equal to 6 + assume(len(repeats) <= 6) + repeat = { "repeats": repeats, } From 7ba2e795c3aedc8432101bd26a7367730ea67e42 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 26 Feb 2024 16:54:26 +0530 Subject: [PATCH 912/978] fix: Fixed `zero_fraction` in tf front for jax backend (#28356) --- ivy/functional/frontends/tensorflow/math.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index ab281931c99ee..6f8b9dfd19e8d 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -1044,8 +1044,8 @@ def xlogy(x, y, name=None): def zero_fraction(value, name="zero_fraction"): zero = ivy.zeros(tuple(value.shape), dtype=ivy.float32) x = ivy.array(value, dtype=ivy.float32) - count_zero = ivy.sum(ivy.equal(x, zero)) - count_nonzero = ivy.sum(ivy.not_equal(x, zero)) + count_zero = ivy.sum(ivy.equal(x, zero), dtype=ivy.float32) + count_nonzero = ivy.sum(ivy.not_equal(x, zero), dtype=ivy.float32) return ivy.divide(count_zero, ivy.add(count_zero, count_nonzero)) From e1c93cb8ae8b550f5387595685d4e3bebd4cbbb9 Mon Sep 17 00:00:00 2001 From: Eddy Oyieko <67474838+mobley-trent@users.noreply.github.com> Date: Mon, 26 Feb 2024 15:18:37 +0300 Subject: [PATCH 913/978] feat(jax-backend) - Implementing native jax while loop in `nms` body (#28274) --- ivy/functional/backends/jax/layers.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/layers.py b/ivy/functional/backends/jax/layers.py index 146514399b07b..02e980559fd37 100644 --- a/ivy/functional/backends/jax/layers.py +++ b/ivy/functional/backends/jax/layers.py @@ -501,7 +501,8 @@ def nms( keep = jnp.zeros((size,), dtype=jnp.int64) keep_idx = 0 - while jnp.unique(order).size > 1: + def body_fn(loop_vars): + keep, keep_idx, boxes, areas, order = loop_vars max_iou_idx = order[0] keep = keep.at[keep_idx].set(max_iou_idx) keep_idx += 1 @@ -522,6 +523,15 @@ def nms( boxes = boxes.at[forward].set(boxes[forward[::-1]]) areas = areas.at[forward].set(areas[forward[::-1]]) + return keep, keep_idx, boxes, areas, order + + def cond_fn(loop_vars): + _, _, _, _, order = loop_vars + return jnp.min(order) != jnp.max(order) + + init_vars = (keep, keep_idx, boxes, areas, order) + keep, keep_idx, boxes, _, _ = jlax.while_loop(cond_fn, body_fn, init_vars) + ret = jnp.array(keep[:keep_idx], dtype=jnp.int64) if len(ret) > 1 and scores is not None: From e22cd908aecdb32de317e6dc666bb0c3a0314567 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Mon, 26 Feb 2024 19:17:05 +0530 Subject: [PATCH 914/978] fix: Fixed `ivy.argsort` for jax backend (#28422) --- ivy/functional/backends/jax/sorting.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/backends/jax/sorting.py b/ivy/functional/backends/jax/sorting.py index acee3f979316d..fc54befcf72ce 100644 --- a/ivy/functional/backends/jax/sorting.py +++ b/ivy/functional/backends/jax/sorting.py @@ -20,7 +20,7 @@ def argsort( ) -> JaxArray: kind = "stable" if stable else "quicksort" return ( - jnp.argsort(-x, axis=axis, kind=kind) + jnp.argsort(x, axis=axis, kind=kind, descending=descending) if descending else jnp.argsort(x, axis=axis, kind=kind) ) From c7a867d59233464afa0686404d3482633c643ed6 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Mon, 26 Feb 2024 14:35:22 +0000 Subject: [PATCH 915/978] fix: Variable frontend methods setting ivy_array to frontend tensor (#28423) --- .../tensorflow/python/ops/resource_variable_ops.py | 13 ++++++++++++- ivy/functional/frontends/tensorflow/variable.py | 7 +++++-- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/ivy/functional/frontends/tensorflow/python/ops/resource_variable_ops.py b/ivy/functional/frontends/tensorflow/python/ops/resource_variable_ops.py index 1ac276f9d2224..03ce4f5103d3f 100644 --- a/ivy/functional/frontends/tensorflow/python/ops/resource_variable_ops.py +++ b/ivy/functional/frontends/tensorflow/python/ops/resource_variable_ops.py @@ -3,4 +3,15 @@ class ResourceVariable(tf_frontend.Variable): - pass + def __repr__(self): + return ( + repr(self._ivy_array).replace( + "ivy.array", + "ivy.functional.frontends.tensorflow.python.ops.resource_variable_ops.ResourceVariable", + )[:-1] + + ", shape=" + + str(self._ivy_array.shape) + + ", dtype=" + + str(self._ivy_array.dtype) + + ")" + ) diff --git a/ivy/functional/frontends/tensorflow/variable.py b/ivy/functional/frontends/tensorflow/variable.py index b580ba13d89e3..77f0053f6bf08 100644 --- a/ivy/functional/frontends/tensorflow/variable.py +++ b/ivy/functional/frontends/tensorflow/variable.py @@ -58,6 +58,7 @@ def assign(self, value, use_locking=None, name=None, read_value=True): as_array=False, ) self._ivy_array = value._ivy_array + return self def assign_add(self, delta, use_locking=None, name=None, read_value=True): ivy.utils.assertions.check_equal( @@ -65,7 +66,8 @@ def assign_add(self, delta, use_locking=None, name=None, read_value=True): self.shape, as_array=False, ) - self._ivy_array = tf_frontend.math.add(self._ivy_array, delta._ivy_array) + self._ivy_array = ivy.add(self._ivy_array, delta._ivy_array) + return self def assign_sub(self, delta, use_locking=None, name=None, read_value=True): ivy.utils.assertions.check_equal( @@ -73,7 +75,8 @@ def assign_sub(self, delta, use_locking=None, name=None, read_value=True): self.shape, as_array=False, ) - self._ivy_array = tf_frontend.math.subtract(self._ivy_array, delta._ivy_array) + self._ivy_array = ivy.subtract(self._ivy_array, delta._ivy_array) + return self def batch_scatter_update( self, sparse_delta, use_locking=None, name=None, read_value=True From c982cc8f02a0e5ac609d2bed1e23789eca64bde5 Mon Sep 17 00:00:00 2001 From: Matt Barrett <83289589+mattbarrett98@users.noreply.github.com> Date: Mon, 26 Feb 2024 16:55:41 +0000 Subject: [PATCH 916/978] fix: added `axis` arg support for torch frontend `stack`, + extended test (#28252) --- .../frontends/torch/indexing_slicing_joining_mutating_ops.py | 1 + .../test_torch/test_indexing_slicing_joining_mutating_ops.py | 5 ++++- ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py | 4 +--- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py index 7244d46ffad01..5e46854039dcf 100644 --- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py +++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py @@ -397,6 +397,7 @@ def squeeze(input, dim=None): return ivy.squeeze(input, axis=dim) +@numpy_to_torch_style_args @to_ivy_arrays_and_back def stack(tensors, dim=0, *, out=None): return ivy.stack(tensors, axis=dim, out=out) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py index 591d477f57ecf..292576018b1eb 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py @@ -1356,11 +1356,13 @@ def test_torch_squeeze( dim=helpers.get_axis( shape=st.shared(helpers.get_shape(min_num_dims=1), key="shape"), ).filter(lambda axis: isinstance(axis, int)), + use_axis_arg=st.booleans(), ) def test_torch_stack( *, dtype_value_shape, dim, + use_axis_arg, on_device, fn_tree, frontend, @@ -1368,6 +1370,7 @@ def test_torch_stack( backend_fw, ): input_dtype, value = dtype_value_shape + dim_arg = {"axis" if use_axis_arg else "dim": dim} helpers.test_frontend_function( input_dtypes=input_dtype, backend_to_test=backend_fw, @@ -1376,7 +1379,7 @@ def test_torch_stack( fn_tree=fn_tree, on_device=on_device, tensors=value, - dim=dim, + **dim_arg, ) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index a26b37feb402e..ea81f425eecbc 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -11679,9 +11679,7 @@ def test_torch_scatter_( helpers.test_frontend_method( init_input_dtypes=[input_dtypes[0]], backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x, - }, + init_all_as_kwargs_np={"data": x}, method_input_dtypes=["int64", input_dtypes[0]], method_all_as_kwargs_np={ "dim": axis, From 6579c75d912256d4d3b54dac31942042280006c0 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Tue, 27 Feb 2024 01:20:22 +0530 Subject: [PATCH 917/978] fix: fixed the maximum at tensorflow frontend (#28375) --- ivy/functional/frontends/tensorflow/math.py | 1 + ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py index 6f8b9dfd19e8d..3a0118409774f 100644 --- a/ivy/functional/frontends/tensorflow/math.py +++ b/ivy/functional/frontends/tensorflow/math.py @@ -621,6 +621,7 @@ def logical_xor(x, y, name="LogicalXor"): @to_ivy_arrays_and_back +@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, "tensorflow") def maximum(x, y, name=None): return ivy.maximum(x, y) diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py index aec91a0c64eab..3d14053f47e38 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py @@ -1793,7 +1793,7 @@ def test_tensorflow_logical_xor( @handle_frontend_test( fn_tree="tensorflow.math.maximum", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), + available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True, ), From bd69e0778632a7ac7a13a8fe9b07e85c5a907837 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 27 Feb 2024 11:38:09 +0530 Subject: [PATCH 918/978] fix: added a check for when the dtype argument is None in check_unsupported_dtype (#28434) --- ivy_tests/test_ivy/helpers/assertions.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ivy_tests/test_ivy/helpers/assertions.py b/ivy_tests/test_ivy/helpers/assertions.py index a4f7a942a4080..5da824e9a8ca6 100644 --- a/ivy_tests/test_ivy/helpers/assertions.py +++ b/ivy_tests/test_ivy/helpers/assertions.py @@ -211,6 +211,7 @@ def check_unsupported_dtype(*, fn, input_dtypes, all_as_kwargs_np): break if ( "dtype" in all_as_kwargs_np + and all_as_kwargs_np["dtype"] is not None and all_as_kwargs_np["dtype"] in unsupported_dtypes_fn ): test_unsupported = True @@ -221,6 +222,7 @@ def check_unsupported_dtype(*, fn, input_dtypes, all_as_kwargs_np): break if ( "dtype" in all_as_kwargs_np + and all_as_kwargs_np["dtype"] is not None and all_as_kwargs_np["dtype"] not in supported_dtypes_fn ): test_unsupported = True From 44c3b13c8ef1ad50b3f3177a1d9174c5c765ba74 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Tue, 27 Feb 2024 07:33:48 +0000 Subject: [PATCH 919/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 6e48405c993c82c19707aa28614b4ffe3e4cb80c Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 27 Feb 2024 07:35:06 +0000 Subject: [PATCH 920/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 8189e01230fdea6acb7ef29a4ae7ba6a1ace96a9 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Tue, 27 Feb 2024 08:34:31 +0000 Subject: [PATCH 921/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From fb149459d773b1bc9883bc812b4fce845f048941 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 27 Feb 2024 08:35:51 +0000 Subject: [PATCH 922/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From c472678a9dc83a9a5a5dbec88a24f53bbf5f5413 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 27 Feb 2024 08:38:32 +0000 Subject: [PATCH 923/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index 104f88a7be642..d04fc08afb693 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit 104f88a7be64234ec58950deed8142bc7748d9da +Subproject commit d04fc08afb6932fa767e462f6035fd3620a10c6d From 5cd0312c2bc8eece7491f6e55949ce8409666694 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Tue, 27 Feb 2024 12:04:24 +0000 Subject: [PATCH 924/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 70a45fb3a6fa4eb22467713312956c68d471fbdb Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 27 Feb 2024 12:05:39 +0000 Subject: [PATCH 925/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 60a72303d87dab18daa38769e5de1f4e0a03b374 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 27 Feb 2024 18:27:59 +0530 Subject: [PATCH 926/978] fix: changed enable_x64 to x64 enabled in the assertions after the jax release --- ivy/utils/assertions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index 952d2be8f8303..c4a5a315077e3 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -346,7 +346,7 @@ def check_dev_correct_formatting(device): def _check_jax_x64_flag(dtype): if ( ivy.backend == "jax" - and not ivy.functional.backends.jax.jax.config.jax_enable_x64 + and not ivy.functional.backends.jax.jax.config.x64_enabled ): ivy.utils.assertions.check_elem_in_list( dtype, From 774a9935b0322ec438c6a1701b0a2306afed78a9 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 27 Feb 2024 12:59:28 +0000 Subject: [PATCH 927/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/utils/assertions.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index c4a5a315077e3..e3c7323c481ba 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -344,10 +344,7 @@ def check_dev_correct_formatting(device): def _check_jax_x64_flag(dtype): - if ( - ivy.backend == "jax" - and not ivy.functional.backends.jax.jax.config.x64_enabled - ): + if ivy.backend == "jax" and not ivy.functional.backends.jax.jax.config.x64_enabled: ivy.utils.assertions.check_elem_in_list( dtype, ["float64", "int64", "uint64", "complex128"], From 02a222332c581d993b0686b41c043224f10ce123 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Tue, 27 Feb 2024 19:18:37 +0530 Subject: [PATCH 928/978] fix: fixed the `less_equal` to support the complex dtype (#28429) --- ivy/functional/backends/paddle/elementwise.py | 12 +++++++----- ivy/functional/backends/tensorflow/elementwise.py | 2 +- .../test_functional/test_core/test_elementwise.py | 6 +++++- 3 files changed, 13 insertions(+), 7 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index cec3a3703d480..1e426659e6458 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -140,8 +140,8 @@ def equal( return paddle.equal(x1, x2) -@with_supported_dtypes( - {"2.6.0 and below": ("bool", "float32", "float64", "int32", "int64", "complex")}, +@with_unsupported_dtypes( + {"2.6.0 and below": ("bool",)}, backend_version, ) def less_equal( @@ -154,9 +154,11 @@ def less_equal( x1, x2, ret_dtype = _elementwise_helper(x1, x2) if isinstance(x1, paddle.Tensor) and isinstance(x2, paddle.Tensor): if paddle.is_complex(x1) and paddle.is_complex(x2): - real = paddle.less_equal(x1.real(), x2.real()) - imag = paddle.less_equal(x1.imag(), x2.imag()) - return paddle_backend.logical_and(real, imag) + real_comparison = paddle.real(x1) < paddle.real(x2) + imag_comparison = paddle_backend.logical_and( + paddle.real(x1) == paddle.real(x2), paddle.imag(x1) < paddle.imag(x2) + ) + return paddle_backend.logical_or(real_comparison, imag_comparison) return paddle.less_equal(x1, x2) diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py index 5a86d3e29e637..c1a1c0c289491 100644 --- a/ivy/functional/backends/tensorflow/elementwise.py +++ b/ivy/functional/backends/tensorflow/elementwise.py @@ -423,7 +423,7 @@ def less( return tf.math.less(x1, x2) -@with_unsupported_dtypes({"2.15.0 and below": ("complex",)}, backend_version) +@with_unsupported_dtypes({"2.15.0 and below": ("complex", "bool")}, backend_version) def less_equal( x1: Union[float, tf.Tensor, tf.Variable], x2: Union[float, tf.Tensor, tf.Variable], diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index e842285adf61b..b97ae0f0d5baf 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1183,7 +1183,11 @@ def test_less(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.less_equal", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2 + available_dtypes=helpers.get_dtypes("numeric"), + num_arrays=2, + large_abs_safety_factor=6, + small_abs_safety_factor=6, + safety_factor_scale="log", ), test_gradients=st.just(False), ground_truth_backend="jax", From 5c28183f23fdb7c187ebfdfa6d594360bc543793 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 27 Feb 2024 21:10:43 +0530 Subject: [PATCH 929/978] fix: imported jax instead of the jax backend in the assertions.py file --- ivy/utils/assertions.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index e3c7323c481ba..f1bf4fa032ce4 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -344,14 +344,17 @@ def check_dev_correct_formatting(device): def _check_jax_x64_flag(dtype): - if ivy.backend == "jax" and not ivy.functional.backends.jax.jax.config.x64_enabled: - ivy.utils.assertions.check_elem_in_list( - dtype, - ["float64", "int64", "uint64", "complex128"], - inverse=True, - message=( - f"{dtype} output not supported while jax_enable_x64" - " is set to False, please import jax and enable the flag using " - "jax.config.update('jax_enable_x64', True)" - ), - ) + if ivy.backend == "jax": + import jax + + if not jax.config.x64_enabled: + ivy.utils.assertions.check_elem_in_list( + dtype, + ["float64", "int64", "uint64", "complex128"], + inverse=True, + message=( + f"{dtype} output not supported while jax_enable_x64" + " is set to False, please import jax and enable the flag using " + "jax.config.update('jax_enable_x64', True)" + ), + ) From 0c3f7198b5d57b0a2a5da9d7d73747523ef3f1ff Mon Sep 17 00:00:00 2001 From: MahadShahid8 <93673498+MahadShahid8@users.noreply.github.com> Date: Tue, 27 Feb 2024 20:43:04 +0500 Subject: [PATCH 930/978] docs: add docstring for _train_tasks_batched (#22628) --- ivy/functional/ivy/meta.py | 54 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/ivy/functional/ivy/meta.py b/ivy/functional/ivy/meta.py index f468ded38a0e3..fa47220fc3137 100644 --- a/ivy/functional/ivy/meta.py +++ b/ivy/functional/ivy/meta.py @@ -262,6 +262,60 @@ def _train_tasks_batched( num_tasks, stop_gradients, ): + """ + Train tasks in a batched manner. + + This function trains tasks in a batched manner with optional inner and outer batch functions. + + Parameters + ---------- + batch : object + The batch data. + inner_batch_fn : function or None + The inner batch function. + outer_batch_fn : function or None + The outer batch function. + inner_cost_fn : function + The inner cost function. + outer_cost_fn : function + The outer cost function. + variables : ivy.Container + The variables for optimization. + inner_grad_steps : int + Number of inner gradient steps. + inner_learning_rate : float + Inner learning rate. + inner_optimization_step : function + The inner optimization step function. + order : int + The order of computation. + average_across_steps : bool + Whether to average across steps. + inner_v : object + Inner variable. + keep_inner_v : bool + Whether to keep inner variable. + outer_v : object + Outer variable. + keep_outer_v : bool + Whether to keep outer variable. + return_inner_v : str or bool + Whether and which inner variables to return. + num_tasks : int + Number of tasks. + stop_gradients : bool + Whether to stop gradients during optimization. + + Returns + ------- + object or tuple + The computed cost and, optionally, gradients and updated inner variables. + + Examples + -------- + >>> # Example usage here + >>> pass + """ inner_batch = batch outer_batch = batch if inner_batch_fn is not None: From 9d4eb175d7f28fcd178e99dabf6beb40ae1dc974 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Tue, 27 Feb 2024 15:44:44 +0000 Subject: [PATCH 931/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ivy/functional/ivy/meta.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ivy/functional/ivy/meta.py b/ivy/functional/ivy/meta.py index fa47220fc3137..f4d5b6a633b8e 100644 --- a/ivy/functional/ivy/meta.py +++ b/ivy/functional/ivy/meta.py @@ -262,8 +262,7 @@ def _train_tasks_batched( num_tasks, stop_gradients, ): - """ - Train tasks in a batched manner. + """Train tasks in a batched manner. This function trains tasks in a batched manner with optional inner and outer batch functions. From 69fdbacaa0d36690517d0eb72646c1d106a1b3b5 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Tue, 27 Feb 2024 21:15:35 +0530 Subject: [PATCH 932/978] fix: dealing with boolean arrays with tuple query in ivy.get_item and added a test (#28435) --- ivy/functional/ivy/general.py | 4 ++++ .../test_ivy/test_functional/test_core/test_general.py | 9 +++++++++ 2 files changed, 13 insertions(+) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index dfc16539047ef..cb70031569070 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -2937,6 +2937,10 @@ def _parse_query(query, x_shape, scatter=False): array_queries = ivy.broadcast_arrays( *[v for i, v in enumerate(query) if i in array_inds] ) + array_queries = [ + ivy.nonzero(q, as_tuple=False)[0] if ivy.is_bool_dtype(q) else q + for q in array_queries + ] array_queries = [ ( ivy.where(arr < 0, arr + x_shape[i], arr).astype(ivy.int64) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index ebeecffba73dc..0a75937e8a1ca 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -1074,6 +1074,15 @@ def test_get_all_arrays_in_memory(): container_flags=st.just([False]), test_with_copy=st.just(True), ) +@handle_example( + test_example=True, + test_flags={ + "num_positional_args": 2, + }, + dtypes_x_query=(["float32", "bool"], np.ones((1, 3, 3)), (np.array([True]), 2, 2)), + copy=None, + fn_name="get_item", +) def test_get_item( dtypes_x_query, copy, From 25e9c7d5422f5d689882817a315c7f4e66d03a3b Mon Sep 17 00:00:00 2001 From: NripeshN Date: Wed, 28 Feb 2024 00:08:20 +0000 Subject: [PATCH 933/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 61e35321242857079068df66f3d998b8aeaf981d Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 28 Feb 2024 00:09:47 +0000 Subject: [PATCH 934/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 8367486cdd307493e11bed66001812672f1e4c32 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 28 Feb 2024 10:44:59 +0530 Subject: [PATCH 935/978] fix: removed the jax.config import from the ivy_tests init as it's deprecated in the recent release (#28444) --- ivy/utils/assertions.py | 25 +++++++++++-------------- ivy_tests/__init__.py | 4 ++-- 2 files changed, 13 insertions(+), 16 deletions(-) diff --git a/ivy/utils/assertions.py b/ivy/utils/assertions.py index f1bf4fa032ce4..e3c7323c481ba 100644 --- a/ivy/utils/assertions.py +++ b/ivy/utils/assertions.py @@ -344,17 +344,14 @@ def check_dev_correct_formatting(device): def _check_jax_x64_flag(dtype): - if ivy.backend == "jax": - import jax - - if not jax.config.x64_enabled: - ivy.utils.assertions.check_elem_in_list( - dtype, - ["float64", "int64", "uint64", "complex128"], - inverse=True, - message=( - f"{dtype} output not supported while jax_enable_x64" - " is set to False, please import jax and enable the flag using " - "jax.config.update('jax_enable_x64', True)" - ), - ) + if ivy.backend == "jax" and not ivy.functional.backends.jax.jax.config.x64_enabled: + ivy.utils.assertions.check_elem_in_list( + dtype, + ["float64", "int64", "uint64", "complex128"], + inverse=True, + message=( + f"{dtype} output not supported while jax_enable_x64" + " is set to False, please import jax and enable the flag using " + "jax.config.update('jax_enable_x64', True)" + ), + ) diff --git a/ivy_tests/__init__.py b/ivy_tests/__init__.py index c4f97ca7a59c2..2452ba2f6226d 100644 --- a/ivy_tests/__init__.py +++ b/ivy_tests/__init__.py @@ -1,6 +1,6 @@ try: - from jax.config import config + import jax - config.update("jax_enable_x64", True) + jax.config.update("jax_enable_x64", True) except (ImportError, RuntimeError): pass From d2a64803681031bab1e917d3c54f25a7889aa156 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 28 Feb 2024 11:34:46 +0530 Subject: [PATCH 936/978] feat: added the test_trace_each flag to the tests to also have tracer tests that trace each example separately (#28436) Also updated the number of test examples to 10 --- .github/workflows/intelligent-tests.yml | 2 +- .github/workflows/manual-tests.yml | 9 +- .github/workflows/pre-release.yml | 17 ++- .github/workflows/run-all-tests.yml | 2 +- .github/workflows/run-failing-tests.yml | 2 +- .github/workflows/test-ivy-cron-gpu.yml | 2 +- .../workflows/test-ivy-cron-multi-version.yml | 2 +- .github/workflows/test-ivy-cron.yml | 2 +- .github/workflows/test-ivy-tracer-cron.yml | 2 +- ivy_tests/conftest.py | 2 + ivy_tests/test_ivy/conftest.py | 6 + .../test_ivy/helpers/function_testing.py | 118 ++++++++++++++---- ivy_tests/test_ivy/helpers/multiprocessing.py | 8 ++ .../test_ivy/helpers/test_parameter_flags.py | 17 +++ ivy_tests/test_ivy/helpers/testing_helpers.py | 21 ++++ scripts/run_tests/run_tests.py | 27 ++-- scripts/run_tests/run_tests_pr.py | 2 +- 17 files changed, 191 insertions(+), 50 deletions(-) diff --git a/.github/workflows/intelligent-tests.yml b/.github/workflows/intelligent-tests.yml index 6614e53eb42fd..23a6e2171d83f 100644 --- a/.github/workflows/intelligent-tests.yml +++ b/.github/workflows/intelligent-tests.yml @@ -89,7 +89,7 @@ jobs: run: | cd ivy set -o pipefail - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' 'false' ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt continue-on-error: true - name: Upload test results diff --git a/.github/workflows/manual-tests.yml b/.github/workflows/manual-tests.yml index 71c231e952c49..6bb0b423712d1 100644 --- a/.github/workflows/manual-tests.yml +++ b/.github/workflows/manual-tests.yml @@ -22,6 +22,11 @@ on: default: false required: false + tracer_each: + description: 'Tracer Testing Each :' + default: false + required: false + permissions: actions: read @@ -64,7 +69,7 @@ jobs: pip3 install pymongo cd ivy python3 scripts/setup_tests/setup_tests.py ${{ github.event.inputs.test }} - python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' ${{ github.event.inputs.gpu }} ${{ github.run_id }} 'false' ${{ github.event.inputs.tracer }} ${{ steps.jobs.outputs.html_url }} + python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' ${{ github.event.inputs.gpu }} ${{ github.run_id }} 'false' ${{ github.event.inputs.tracer }} ${{ github.event.inputs.tracer_each }} ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures @@ -106,7 +111,7 @@ jobs: cd ivy sudo pip3 install -e . python scripts/setup_tests/setup_tests.py "${{ github.event.inputs.test }}" - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} ${{ github.event.inputs.version}} 'false' ${{ github.run_id }} 'false' ${{ github.event.inputs.tracer }} ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} ${{ github.event.inputs.version}} 'false' ${{ github.run_id }} 'false' ${{ github.event.inputs.tracer }} ${{ github.event.inputs.tracer_each }} ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures diff --git a/.github/workflows/pre-release.yml b/.github/workflows/pre-release.yml index 249038c320383..9dbef46f9fd3d 100644 --- a/.github/workflows/pre-release.yml +++ b/.github/workflows/pre-release.yml @@ -1,6 +1,16 @@ name: Pre-release Testing Workflow on: workflow_dispatch: + inputs: + tracer: + description: 'Tracer Testing :' + default: false + required: false + + tracer_each: + description: 'Tracer Testing Each :' + default: false + required: false permissions: actions: read @@ -35,9 +45,4 @@ jobs: - name: Run CPU Tests run: | cd ivy - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'true' 'false' ${{ steps.jobs.outputs.html_url }} - - - name: Run GPU Tests - run: | - cd ivy - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'true' 'false' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'true' ${{ github.event.inputs.tracer }} ${{ github.event.inputs.tracer_each }} ${{ steps.jobs.outputs.html_url }} diff --git a/.github/workflows/run-all-tests.yml b/.github/workflows/run-all-tests.yml index c7bebee196cf6..7fb8304e0f52d 100644 --- a/.github/workflows/run-all-tests.yml +++ b/.github/workflows/run-all-tests.yml @@ -64,7 +64,7 @@ jobs: cd ivy python scripts/setup_tests/filter_tests.py ${{ matrix.branch }} set -o pipefail - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' 'false' ${{ steps.jobs.outputs.html_url }} | tee test_results_${{ matrix.branch }}.txt continue-on-error: true - name: Upload test results diff --git a/.github/workflows/run-failing-tests.yml b/.github/workflows/run-failing-tests.yml index e15935ccd581d..cbd95ca62b532 100644 --- a/.github/workflows/run-failing-tests.yml +++ b/.github/workflows/run-failing-tests.yml @@ -72,5 +72,5 @@ jobs: - name: Run Tests run: | cd ivy - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true diff --git a/.github/workflows/test-ivy-cron-gpu.yml b/.github/workflows/test-ivy-cron-gpu.yml index 03e8f5b36851c..f4209e776b030 100644 --- a/.github/workflows/test-ivy-cron-gpu.yml +++ b/.github/workflows/test-ivy-cron-gpu.yml @@ -75,7 +75,7 @@ jobs: pip3 install pymongo cd ivy python3 scripts/setup_tests/cron_tests.py ${{ github.run_number }} true false - python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} + python3 scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'true' ${{ github.run_id }} 'false' 'false' 'false' ${{ steps.jobs.outputs.html_url }} stop-vm: needs: run-gpu-tests diff --git a/.github/workflows/test-ivy-cron-multi-version.yml b/.github/workflows/test-ivy-cron-multi-version.yml index 5f4177b3d0cf7..d4aaee594b6e6 100644 --- a/.github/workflows/test-ivy-cron-multi-version.yml +++ b/.github/workflows/test-ivy-cron-multi-version.yml @@ -38,7 +38,7 @@ jobs: cd ivy pip3 install pymongo python scripts/setup_tests/cron_tests_multi_version.py ${{ github.run_number }} - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'true' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'true' 'false' ${{ github.run_id }} 'false' 'false' 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures diff --git a/.github/workflows/test-ivy-cron.yml b/.github/workflows/test-ivy-cron.yml index 047076cc012b4..c79ac18644b5b 100644 --- a/.github/workflows/test-ivy-cron.yml +++ b/.github/workflows/test-ivy-cron.yml @@ -38,7 +38,7 @@ jobs: cd ivy pip3 install pymongo python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false false - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'false' 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures diff --git a/.github/workflows/test-ivy-tracer-cron.yml b/.github/workflows/test-ivy-tracer-cron.yml index 0696b5c4aedf4..3039d90f9ec42 100644 --- a/.github/workflows/test-ivy-tracer-cron.yml +++ b/.github/workflows/test-ivy-tracer-cron.yml @@ -38,7 +38,7 @@ jobs: cd ivy pip3 install pymongo python scripts/setup_tests/cron_tests.py ${{ github.run_number }} false true - python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'true' ${{ steps.jobs.outputs.html_url }} + python scripts/run_tests/run_tests.py ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD }} ${{ secrets.MONGODB_PASSWORD }} 'false' 'false' ${{ github.run_id }} 'false' 'true' 'false' ${{ steps.jobs.outputs.html_url }} continue-on-error: true - name: Check on failures diff --git a/ivy_tests/conftest.py b/ivy_tests/conftest.py index 96533c7bc5784..c79160013ec4b 100644 --- a/ivy_tests/conftest.py +++ b/ivy_tests/conftest.py @@ -139,6 +139,8 @@ def pytest_configure(config): if max_examples: profile_settings["max_examples"] = max_examples + else: + profile_settings["max_examples"] = 10 if deadline: profile_settings["deadline"] = deadline diff --git a/ivy_tests/test_ivy/conftest.py b/ivy_tests/test_ivy/conftest.py index 3776351090e77..13731b6f5eb4e 100644 --- a/ivy_tests/test_ivy/conftest.py +++ b/ivy_tests/test_ivy/conftest.py @@ -290,6 +290,10 @@ def process_cl_flags(config) -> Dict[str, bool]: getopt("--skip-trace-testing"), getopt("--with-trace-testing"), ), + "test_trace_each": ( + getopt("--skip-trace-testing-each"), + getopt("--with-trace-testing-each"), + ), "transpile": ( False, getopt("--with-transpile"), @@ -348,6 +352,7 @@ def pytest_addoption(parser): parser.addoption("--skip-instance-method-testing", action="store_true") parser.addoption("--skip-gradient-testing", action="store_true") parser.addoption("--skip-trace-testing", action="store_true") + parser.addoption("--skip-trace-testing-each", action="store_true") parser.addoption("--with-variable-testing", action="store_true") parser.addoption("--with-native-array-testing", action="store_true") @@ -356,6 +361,7 @@ def pytest_addoption(parser): parser.addoption("--with-instance-method-testing", action="store_true") parser.addoption("--with-gradient-testing", action="store_true") parser.addoption("--with-trace-testing", action="store_true") + parser.addoption("--with-trace-testing-each", action="store_true") parser.addoption("--with-transpile", action="store_true") parser.addoption("--no-extra-testing", action="store_true") parser.addoption( diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 4e0f7126b1dd4..2926065df3f5e 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -35,10 +35,12 @@ # Temporary (.so) configuration -def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=None): +def traced_if_required( + backend: str, fn, test_trace=False, test_trace_each=False, args=None, kwargs=None +): with BackendHandler.update_backend(backend) as ivy_backend: - if test_trace: - try: + try: + if test_trace: if ( t_globals.CURRENT_RUNNING_TEST.fn_name in t_globals.CURRENT_TRACED_DATA @@ -67,10 +69,15 @@ def traced_if_required(backend: str, fn, test_trace=False, args=None, kwargs=Non fn = t_globals.CURRENT_TRACED_DATA[ t_globals.CURRENT_RUNNING_TEST.fn_name ][backend] - except Exception: - import logging + if test_trace_each: + fn = ivy_backend.trace_graph( + fn, args=args, kwargs=kwargs, backend_compile=True + ) + except Exception: + import logging + + logging.warning("API key is invalid, test_trace is skipped.") - logging.warning("API key is invalid, test_trace is skipped.") return fn @@ -226,7 +233,7 @@ def test_function_backend_computation( fw, kwargs, arrays_kwargs_indices, kwargs_instance_mask ) - if test_flags.test_trace: + if test_flags.test_trace or test_flags.test_trace_each: def target_fn(instance, *args, **kwargs): return instance.__getattribute__(fn_name)(*args, **kwargs) @@ -246,6 +253,7 @@ def target_fn(instance, *args, **kwargs): target_fn, *copy_args, test_trace=test_flags.test_trace, + test_trace_each=test_flags.test_trace_each, precision_mode=test_flags.precision_mode, **copy_kwargs, ) @@ -256,7 +264,9 @@ def target_fn(instance, *args, **kwargs): ), f"Ivy function returned non-ivy arrays: {ret_from_target}" # Assert indices of return if the indices of the out array provided - if test_flags.with_out and not test_flags.test_trace: + if test_flags.with_out and not ( + test_flags.test_trace or test_flags.test_trace_each + ): test_ret = ( ret_from_target[getattr(ivy_backend.__dict__[fn_name], "out_index")] if hasattr(ivy_backend.__dict__[fn_name], "out_index") @@ -326,6 +336,7 @@ def target_fn(instance, *args, **kwargs): target_fn, *args, test_trace=test_flags.test_trace, + test_trace_each=test_flags.test_trace_each, precision_mode=test_flags.precision_mode, **kwargs, ) @@ -383,6 +394,7 @@ def test_function_ground_truth_computation( gt_backend.__dict__[fn_name], *args, test_trace=test_flags.test_trace, + test_trace_each=test_flags.test_trace_each, precision_mode=test_flags.precision_mode, **kwargs, ) @@ -390,7 +402,9 @@ def test_function_ground_truth_computation( lambda x: gt_backend.is_ivy_array(x) if gt_backend.is_array(x) else True, ret_from_gt, ), f"Ground-truth function returned non-ivy arrays: {ret_from_gt}" - if test_flags.with_out and not test_flags.test_trace: + if test_flags.with_out and not ( + test_flags.test_trace or test_flags.test_trace_each + ): test_ret_from_gt = ( ret_from_gt[getattr(gt_backend.__dict__[fn_name], "out_index")] if hasattr(gt_backend.__dict__[fn_name], "out_index") @@ -407,6 +421,7 @@ def test_function_ground_truth_computation( gt_backend.__dict__[fn_name], *args, test_trace=test_flags.test_trace, + test_trace_each=test_flags.test_trace_each, precision_mode=test_flags.precision_mode, **kwargs, out=out_from_gt, @@ -517,7 +532,9 @@ def test_function( >>> x2 = np.array([-3, 15, 24]) >>> test_function(input_dtypes, test_flags, fw, fn_name, x1=x1, x2=x2) """ - _switch_backend_context(test_flags.test_trace or test_flags.transpile) + _switch_backend_context( + test_flags.test_trace or test_flags.test_trace_each or test_flags.transpile + ) ground_truth_backend = test_flags.ground_truth_backend if test_flags.container[0]: @@ -693,7 +710,7 @@ def test_function( backend=backend_to_test, ground_truth_backend=test_flags.ground_truth_backend, ) - if not test_flags.test_trace: + if not (test_flags.test_trace or test_flags.test_trace_each): assert_same_type( ret_from_target, ret_from_gt, @@ -740,7 +757,7 @@ def _transpile_if_required_backend(backend: str, fn_name: str, args=None, kwargs args, kwargs = ivy_backend.args_to_ivy(*args, **kwargs) backend_fn = ivy.__dict__[fn_name] backend_traced_fn = traced_if_required( - backend, backend_fn, test_trace=True, args=args, kwargs=kwargs + backend, backend_fn, test_trace_each=True, args=args, kwargs=kwargs ) func_timings = [] @@ -815,7 +832,9 @@ def test_frontend_function( optional, return value from the Numpy function """ # ToDo add with_backend refactor in GC - _switch_backend_context(test_flags.test_trace or test_flags.transpile) + _switch_backend_context( + test_flags.test_trace or test_flags.test_trace_each or test_flags.transpile + ) assert ( not test_flags.with_out or not test_flags.inplace @@ -915,8 +934,11 @@ def test_frontend_function( frontend_fn, *args_for_test, test_trace=test_flags.test_trace, + test_trace_each=test_flags.test_trace_each, frontend_array_function=( - create_frontend_array if test_flags.test_trace else None + create_frontend_array + if test_flags.test_trace or test_flags.test_trace_each + else None ), precision_mode=test_flags.precision_mode, **kwargs_for_test, @@ -975,8 +997,11 @@ def test_frontend_function( frontend_fn, *copy_args, test_trace=test_flags.test_trace, + test_trace_each=test_flags.test_trace_each, frontend_array_function=( - create_frontend_array if test_flags.test_trace else None + create_frontend_array + if test_flags.test_trace or test_flags.test_trace_each + else None ), precision_mode=test_flags.precision_mode, **copy_kwargs, @@ -1021,8 +1046,11 @@ def test_frontend_function( frontend_fn, *copy_args, test_trace=test_flags.test_trace, + test_trace_each=test_flags.test_trace_each, frontend_array_function=( - create_frontend_array if test_flags.test_trace else None + create_frontend_array + if test_flags.test_trace or test_flags.test_trace_each + else None ), precision_mode=test_flags.precision_mode, **copy_kwargs, @@ -1148,6 +1176,7 @@ def test_gradient_backend_computation( on_device, fn, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ): @@ -1173,6 +1202,7 @@ def _grad_fn(all_args): backend_to_test, call_fn, test_trace=test_trace, + test_trace_each=test_trace_each, args=args, kwargs=kwargs, )(*args, **kwargs) @@ -1203,6 +1233,7 @@ def test_gradient_ground_truth_computation( test_flags, kwargs_idxs, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ): @@ -1236,6 +1267,7 @@ def _gt_grad_fn(all_args): ground_truth_backend, call_fn, test_trace=test_trace, + test_trace_each=test_trace_each, args=args, kwargs=kwargs, )(*args, **kwargs) @@ -1264,6 +1296,7 @@ def gradient_test( input_dtypes, test_flags, test_trace: bool = False, + test_trace_each: bool = False, rtol_: Optional[float] = None, atol_: float = 1e-06, tolerance_dict=None, @@ -1295,6 +1328,7 @@ def gradient_test( on_device, fn, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ) @@ -1315,6 +1349,7 @@ def gradient_test( on_device, fn, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ) @@ -1338,6 +1373,7 @@ def gradient_test( test_flags, kwargs_idxs, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ) @@ -1358,6 +1394,7 @@ def gradient_test( test_flags, kwargs_idxs, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ) @@ -1391,6 +1428,7 @@ def test_method_backend_computation( method_name, init_with_v, test_trace, + test_trace_each, method_with_v, ): init_input_dtypes = ivy.default(init_input_dtypes, []) @@ -1540,6 +1578,7 @@ def test_method_backend_computation( ins.__getattribute__(method_name), *args_method, test_trace=test_trace, + test_trace_each=test_trace_each, precision_mode=method_flags.precision_mode, **kwargs_method, ) @@ -1580,6 +1619,7 @@ def test_method_ground_truth_computation( class_name, method_name, test_trace, + test_trace_each, v_np, ): with BackendHandler.update_backend(ground_truth_backend) as gt_backend: @@ -1621,6 +1661,7 @@ def test_method_ground_truth_computation( ins_gt.__getattribute__(method_name), *args_gt_method, test_trace=test_trace, + test_trace_each=test_trace_each, precision_mode=method_flags.precision_mode, **kwargs_gt_method, ) @@ -1663,6 +1704,7 @@ def test_method( xs_grad_idxs=None, ret_grad_idxs=None, test_trace: bool = False, + test_trace_each: bool = False, backend_to_test: str, ground_truth_backend: str, on_device: str, @@ -1729,6 +1771,8 @@ def test_method( gradients are returned for all returned arrays. (Default value = None) test_trace If True, test for the correctness of tracing. + test_trace_each + If True, test for the correctness of tracing (tracing each example separately) ground_truth_backend Ground Truth Backend to compare the result-values. device_ @@ -1764,6 +1808,7 @@ def test_method( method_name, init_with_v, test_trace, + test_trace_each, method_with_v, ) ) @@ -1808,6 +1853,7 @@ def test_method( method_name, init_with_v, test_trace, + test_trace_each, method_with_v, ) @@ -1832,6 +1878,7 @@ def test_method( class_name, method_name, test_trace, + test_trace_each, v_np, ) ) @@ -1862,6 +1909,7 @@ def test_method( class_name, method_name, test_trace, + test_trace_each, v_np, ) @@ -1897,6 +1945,7 @@ def test_method( # input_dtypes=method_input_dtypes, # test_flags=method_flags, # test_trace=test_trace, + # test_trace_each=test_trace_each, # rtol_=rtol_, # atol_=atol_, # xs_grad_idxs=xs_grad_idxs, @@ -1917,6 +1966,7 @@ def test_method( # input_dtypes=method_input_dtypes, # test_flags=method_flags, # test_trace=test_trace, + # test_trace_each=test_trace_each, # rtol_=rtol_, # atol_=atol_, # xs_grad_idxs=xs_grad_idxs, @@ -2018,7 +2068,7 @@ def test_frontend_method( optional, return value from the Ground Truth function """ # ToDo add with_backend refactor in GC - _switch_backend_context(method_flags.test_trace) + _switch_backend_context(method_flags.test_trace or method_flags.test_trace_each) # Constructor arguments # args_np_constructor, kwargs_np_constructor = kwargs_to_args_n_kwargs( @@ -2193,9 +2243,12 @@ def test_frontend_method( ins.__getattribute__(frontend_method_data.method_name), *args_method_ivy, frontend_array_function=( - create_frontend_array if method_flags.test_trace else None + create_frontend_array + if method_flags.test_trace or method_flags.test_trace_each + else None ), test_trace=method_flags.test_trace, + test_trace_each=method_flags.test_trace_each, precision_mode=method_flags.precision_mode, **kwargs_method_ivy, ) @@ -2498,14 +2551,25 @@ def flatten_frontend_to_np(*, backend: str, ret): def get_ret_and_flattened_np_array( - backend_to_test: str, fn, *args, test_trace=False, precision_mode=False, **kwargs + backend_to_test: str, + fn, + *args, + test_trace=False, + test_trace_each=False, + precision_mode=False, + **kwargs, ): """Run func with args and kwargs. Return the result along with its flattened version. """ fn = traced_if_required( - backend_to_test, fn, test_trace=test_trace, args=args, kwargs=kwargs + backend_to_test, + fn, + test_trace=test_trace, + test_trace_each=test_trace_each, + args=args, + kwargs=kwargs, ) with BackendHandler.update_backend(backend_to_test) as ivy_backend: with ivy_backend.PreciseMode(precision_mode): @@ -2529,19 +2593,25 @@ def get_frontend_ret( frontend_array_function=None, precision_mode=False, test_trace: bool = False, + test_trace_each: bool = False, **kwargs, ): frontend_fn = traced_if_required( - backend, frontend_fn, test_trace=test_trace, args=args, kwargs=kwargs + backend, + frontend_fn, + test_trace=test_trace, + test_trace_each=test_trace_each, + args=args, + kwargs=kwargs, ) with BackendHandler.update_backend(backend) as ivy_backend: - if test_trace: + if test_trace or test_trace_each: args, kwargs = ivy_backend.nested_map( _frontend_array_to_ivy, (args, kwargs), include_derived={"tuple": True} ) with ivy_backend.PreciseMode(precision_mode): ret = frontend_fn(*args, **kwargs) - if test_trace: + if test_trace or test_trace_each: assert frontend_array_function is not None ret = ivy_backend.nested_map( arrays_to_frontend(backend, frontend_array_function), @@ -2579,7 +2649,7 @@ def _get_transpiled_data_if_required( traced_fn = traced_if_required( backend, frontend_fn, - test_trace=True, + test_trace_each=True, args=args_for_test, kwargs=kwargs_for_test, ) diff --git a/ivy_tests/test_ivy/helpers/multiprocessing.py b/ivy_tests/test_ivy/helpers/multiprocessing.py index 39234c644de27..47ee2c1dcaccf 100644 --- a/ivy_tests/test_ivy/helpers/multiprocessing.py +++ b/ivy_tests/test_ivy/helpers/multiprocessing.py @@ -177,6 +177,7 @@ def backend_proc(input_queue, output_queue): on_device, fn, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ) = data @@ -193,6 +194,7 @@ def backend_proc(input_queue, output_queue): on_device, fn, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ) @@ -215,6 +217,7 @@ def backend_proc(input_queue, output_queue): test_flags, kwargs_idxs, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ) = data @@ -232,6 +235,7 @@ def backend_proc(input_queue, output_queue): test_flags, kwargs_idxs, test_trace, + test_trace_each, xs_grad_idxs, ret_grad_idxs, ) @@ -252,6 +256,7 @@ def backend_proc(input_queue, output_queue): method_name, init_with_v, test_trace, + test_trace_each, method_with_v, ) = data ( @@ -280,6 +285,7 @@ def backend_proc(input_queue, output_queue): method_name, init_with_v, test_trace, + test_trace_each, method_with_v, ) # ret is none here, because main process doesn't import framework @@ -317,6 +323,7 @@ def backend_proc(input_queue, output_queue): class_name, method_name, test_trace, + test_trace_each, v_np, ) = data ( @@ -339,6 +346,7 @@ def backend_proc(input_queue, output_queue): class_name, method_name, test_trace, + test_trace_each, v_np, ) # ret from gt None here, because main process doesn't import framework diff --git a/ivy_tests/test_ivy/helpers/test_parameter_flags.py b/ivy_tests/test_ivy/helpers/test_parameter_flags.py index d3429718636d6..cc6cb961ff9db 100644 --- a/ivy_tests/test_ivy/helpers/test_parameter_flags.py +++ b/ivy_tests/test_ivy/helpers/test_parameter_flags.py @@ -45,6 +45,7 @@ def _as_varaible_strategy(draw): BuiltWithCopyStrategy = DynamicFlag(st.just(False)) BuiltCompileStrategy = DynamicFlag(st.just(False)) BuiltTraceStrategy = DynamicFlag(st.just(False)) +BuiltTraceEachStrategy = DynamicFlag(st.just(False)) BuiltFrontendArrayStrategy = DynamicFlag(st.booleans()) BuiltTranspileStrategy = DynamicFlag(st.just(False)) BuiltPrecisionModeStrategy = DynamicFlag(st.booleans()) @@ -61,6 +62,7 @@ def _as_varaible_strategy(draw): "with_copy": "BuiltWithCopyStrategy", "inplace": "BuiltInplace", "test_trace": "BuiltTraceStrategy", + "test_trace_each": "BuiltTraceEachStrategy", "transpile": "BuiltTranspileStrategy", "precision_mode": "BuiltPrecisionModeStrategy", "test_cython_wrapper": "BuiltCythonWrapperStrategy", @@ -98,6 +100,7 @@ def __init__( container, test_gradients, test_trace, + test_trace_each, transpile, precision_mode, test_cython_wrapper, @@ -112,6 +115,7 @@ def __init__( self.as_variable = as_variable self.test_gradients = test_gradients self.test_trace = test_trace + self.test_trace_each = test_trace_each self.transpile = transpile self.precision_mode = precision_mode self.test_cython_wrapper = test_cython_wrapper @@ -142,6 +146,7 @@ def __str__(self): f"as_variable={self.as_variable}. " f"test_gradients={self.test_gradients}. " f"test_trace={self.test_trace}. " + f"test_trace_each={self.test_trace_each}. " f"transpile={self.transpile}. " f"precision_mode={self.precision_mode}. " ) @@ -161,6 +166,7 @@ def function_flags( with_copy, test_gradients, test_trace, + test_trace_each, transpile, as_variable, native_arrays, @@ -178,6 +184,7 @@ def function_flags( instance_method=instance_method, test_gradients=test_gradients, test_trace=test_trace, + test_trace_each=test_trace_each, transpile=transpile, as_variable=as_variable, native_arrays=native_arrays, @@ -198,6 +205,7 @@ def __init__( as_variable, native_arrays, test_trace, + test_trace_each, generate_frontend_arrays, transpile, precision_mode, @@ -209,6 +217,7 @@ def __init__( self.native_arrays = native_arrays self.as_variable = as_variable self.test_trace = test_trace + self.test_trace_each = test_trace_each self.generate_frontend_arrays = generate_frontend_arrays self.transpile = transpile self.precision_mode = precision_mode @@ -234,6 +243,7 @@ def __str__(self): f"native_arrays={self.native_arrays}. " f"as_variable={self.as_variable}. " f"test_trace={self.test_trace}. " + f"test_trace_each={self.test_trace_each}" f"generate_frontend_arrays={self.generate_frontend_arrays}. " f"transpile={self.transpile}." f"precision_mode={self.precision_mode}. " @@ -254,6 +264,7 @@ def frontend_function_flags( as_variable, native_arrays, test_trace, + test_trace_each, generate_frontend_arrays, transpile, precision_mode, @@ -268,6 +279,7 @@ def frontend_function_flags( as_variable=as_variable, native_arrays=native_arrays, test_trace=test_trace, + test_trace_each=test_trace_each, generate_frontend_arrays=generate_frontend_arrays, transpile=transpile, precision_mode=precision_mode, @@ -457,6 +469,7 @@ def __init__( precision_mode, inplace, test_trace, + test_trace_each, generate_frontend_arrays, ): self.num_positional_args = num_positional_args @@ -465,6 +478,7 @@ def __init__( self.precision_mode = precision_mode self.inplace = inplace self.test_trace = test_trace + self.test_trace_each = test_trace_each self.generate_frontend_arrays = generate_frontend_arrays def apply_flags(self, args_to_iterate, input_dtypes, offset, *, backend, on_device): @@ -487,6 +501,7 @@ def __str__(self): f"precision_mode={self.precision_mode}. " f"inplace={self.inplace}. " f"test_trace={self.test_trace}." + f"test_trace_each={self.test_trace_each}" f"generate_frontend_arrays={self.generate_frontend_arrays}." ) @@ -504,6 +519,7 @@ def frontend_method_flags( precision_mode, inplace, test_trace, + test_trace_each, generate_frontend_arrays, ): return draw( @@ -515,6 +531,7 @@ def frontend_method_flags( precision_mode=precision_mode, inplace=inplace, test_trace=test_trace, + test_trace_each=test_trace_each, generate_frontend_arrays=generate_frontend_arrays, ) ) diff --git a/ivy_tests/test_ivy/helpers/testing_helpers.py b/ivy_tests/test_ivy/helpers/testing_helpers.py index 37f87c76abda5..36d01f0d5892e 100644 --- a/ivy_tests/test_ivy/helpers/testing_helpers.py +++ b/ivy_tests/test_ivy/helpers/testing_helpers.py @@ -27,6 +27,7 @@ BuiltWithCopyStrategy, BuiltInplaceStrategy, BuiltTraceStrategy, + BuiltTraceEachStrategy, BuiltFrontendArrayStrategy, BuiltTranspileStrategy, BuiltPrecisionModeStrategy, @@ -45,6 +46,7 @@ "instance_method", "test_gradients", "test_trace", + "test_trace_each", "precision_mode", ) cmd_line_args_lists = ( @@ -335,6 +337,7 @@ def handle_test( test_with_copy=BuiltWithCopyStrategy, test_gradients=BuiltGradientStrategy, test_trace=BuiltTraceStrategy, + test_trace_each=BuiltTraceEachStrategy, transpile=BuiltTranspileStrategy, precision_mode=BuiltPrecisionModeStrategy, as_variable_flags=BuiltAsVariableStrategy, @@ -378,6 +381,10 @@ def handle_test( A search strategy that generates a boolean to trace and test the function + test_trace_each + A search strategy that generates a boolean to trace and test the + function (trace each example separately) + precision_mode A search strategy that generates a boolean to switch between two different precision modes supported by numpy and (torch, jax) and test the function @@ -413,6 +420,7 @@ def handle_test( with_copy=_get_runtime_flag_value(test_with_copy), test_gradients=_get_runtime_flag_value(test_gradients), test_trace=_get_runtime_flag_value(test_trace), + test_trace_each=_get_runtime_flag_value(test_trace_each), transpile=_get_runtime_flag_value(transpile), as_variable=_get_runtime_flag_value(as_variable_flags), native_arrays=_get_runtime_flag_value(native_array_flags), @@ -481,6 +489,7 @@ def handle_frontend_test( as_variable_flags=BuiltAsVariableStrategy, native_array_flags=BuiltNativeArrayStrategy, test_trace=BuiltTraceStrategy, + test_trace_each=BuiltTraceEachStrategy, generate_frontend_arrays=BuiltFrontendArrayStrategy, transpile=BuiltTranspileStrategy, precision_mode=BuiltPrecisionModeStrategy, @@ -529,6 +538,10 @@ def handle_frontend_test( A search strategy that generates a boolean to trace and test the function + test_trace_each + A search strategy that generates a boolean to trace and test the + function (trace each example separately) + generate_frontend_arrays A search strategy that generates a list of boolean flags for array inputs to be frontend array @@ -552,6 +565,7 @@ def handle_frontend_test( as_variable=_get_runtime_flag_value(as_variable_flags), native_arrays=_get_runtime_flag_value(native_array_flags), test_trace=_get_runtime_flag_value(test_trace), + test_trace_each=_get_runtime_flag_value(test_trace_each), generate_frontend_arrays=_get_runtime_flag_value(generate_frontend_arrays), transpile=_get_runtime_flag_value(transpile), precision_mode=_get_runtime_flag_value(precision_mode), @@ -626,6 +640,7 @@ def handle_method( ground_truth_backend: str = "tensorflow", test_gradients=BuiltGradientStrategy, test_trace=BuiltTraceStrategy, + test_trace_each=BuiltTraceEachStrategy, precision_mode=BuiltPrecisionModeStrategy, init_num_positional_args=None, init_native_arrays=BuiltNativeArrayStrategy, @@ -657,6 +672,7 @@ def handle_method( "ground_truth_backend": st.just(ground_truth_backend), "test_gradients": _get_runtime_flag_value(test_gradients), "test_trace": _get_runtime_flag_value(test_trace), + "test_trace_each": _get_runtime_flag_value(test_trace_each), "precision_mode": _get_runtime_flag_value(precision_mode), } @@ -746,6 +762,7 @@ def handle_frontend_method( init_native_arrays=BuiltNativeArrayStrategy, init_as_variable_flags=BuiltAsVariableStrategy, test_trace=BuiltTraceStrategy, + test_trace_each=BuiltTraceEachStrategy, precision_mode=BuiltPrecisionModeStrategy, method_num_positional_args=None, method_native_arrays=BuiltNativeArrayStrategy, @@ -850,6 +867,7 @@ def test_wrapper(test_fn): as_variable=_get_runtime_flag_value(method_as_variable_flags), native_arrays=_get_runtime_flag_value(method_native_arrays), test_trace=_get_runtime_flag_value(test_trace), + test_trace_each=_get_runtime_flag_value(test_trace_each), precision_mode=_get_runtime_flag_value(precision_mode), generate_frontend_arrays=_get_runtime_flag_value( generate_frontend_arrays @@ -959,6 +977,7 @@ def handle_example( with_copy=test_flags.get("with_copy", False), test_gradients=test_flags.get("test_gradients", False), test_trace=test_flags.get("test_trace", False), + test_trace_each=test_flags.get("test_trace_each", False), transpile=test_flags.get("transpile", False), as_variable=test_flags.get("as_variable", [False]), native_arrays=test_flags.get("native_arrays", [False]), @@ -979,6 +998,7 @@ def handle_example( as_variable=test_flags.get("as_variable", [False]), native_arrays=test_flags.get("native_arrays", [False]), test_trace=test_flags.get("test_trace", False), + test_trace_each=test_flags.get("test_trace_each", False), generate_frontend_arrays=test_flags.get("generate_frontend_arrays", False), transpile=test_flags.get("transpile", False), precision_mode=test_flags.get("precision_mode", False), @@ -1017,6 +1037,7 @@ def handle_example( precision_mode=method_flags.get("precision_mode", False), inplace=method_flags.get("inplace", False), test_trace=method_flags.get("test_trace", False), + test_trace_each=method_flags.get("test_trace_each", False), generate_frontend_arrays=method_flags.get( "generate_frontend_arrays", False ), diff --git a/scripts/run_tests/run_tests.py b/scripts/run_tests/run_tests.py index 18a1e1e9bef13..f60131c799651 100644 --- a/scripts/run_tests/run_tests.py +++ b/scripts/run_tests/run_tests.py @@ -21,9 +21,10 @@ workflow_id = sys.argv[6] priority_flag = sys.argv[7] tracer_flag = sys.argv[8] + tracer_flag_each = sys.argv[9] - if len(sys.argv) > 9 and sys.argv[9] != "null": - run_id = sys.argv[9] + if len(sys.argv) > 10 and sys.argv[10] != "null": + run_id = sys.argv[10] else: run_id = f"https://github.com/unifyai/ivy/actions/runs/{workflow_id}" @@ -38,6 +39,13 @@ else: tracer_flag = "" + tracer_str_each = "" + if not tracer_flag and tracer_flag_each == "true": + tracer_flag_each = "tracer_each_" + tracer_str_each = " --with-trace-testing-each" + else: + tracer_flag_each = "" + cluster = MongoClient( f"mongodb+srv://deep-ivy:{mongo_key}@cluster0.qdvf8q3.mongodb.net/?retryWrites=true&w=majority" # noqa ) @@ -120,7 +128,8 @@ ) command = ( "docker exec test-container python3 -m pytest --tb=short" - f" {test_path}{device_str} --backend {backend}{tracer_str}" + f" {test_path}{device_str} --backend {backend}" + f"{tracer_str}{tracer_str_each}" ) os.system(command) @@ -216,16 +225,14 @@ "_id": function_name, "test_path": test_path, "submodule": submodule, - f"{prefix_str}{backend}.{version}.{tracer_flag}status.{device}": ( - not failed - ), - f"{prefix_str}{backend}.{version}.{tracer_flag}workflow.{device}": ( - run_id - ), + f"{prefix_str}{backend}.{version}.{tracer_flag}{tracer_flag_each}" + f"status.{device}": (not failed), + f"{prefix_str}{backend}.{version}.{tracer_flag}{tracer_flag_each}" + f"workflow.{device}": (run_id), } # add transpilation metrics if report generated - if not failed and report_content and not tracer_flag: + if not failed and report_content and not (tracer_flag or tracer_flag_each): if is_frontend_test: test_info = { **test_info, diff --git a/scripts/run_tests/run_tests_pr.py b/scripts/run_tests/run_tests_pr.py index 3d78479544b55..fc7a08e43208f 100644 --- a/scripts/run_tests/run_tests_pr.py +++ b/scripts/run_tests/run_tests_pr.py @@ -14,7 +14,7 @@ print(f"{'*' * 100}\n") sys.stdout.flush() ret = os.system( - f'docker run --rm -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis unifyai/ivy:latest python3 -m pytest --tb=short {test_path} --skip-trace-testing --backend {backend}' # noqa + f'docker run --rm -v "$(pwd)":/ivy -v "$(pwd)"/.hypothesis:/.hypothesis unifyai/ivy:latest python3 -m pytest --tb=short {test_path} --skip-trace-testing --skip-trace-testing-each --backend {backend}' # noqa ) if ret != 0: failed = True From eed6c6baf42b987e9a40c40e244bf428b3973470 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 28 Feb 2024 11:47:05 +0530 Subject: [PATCH 937/978] fix: added the sudo pip installation in pre-release.yml --- .github/workflows/pre-release.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/pre-release.yml b/.github/workflows/pre-release.yml index 9dbef46f9fd3d..246f99d88207e 100644 --- a/.github/workflows/pre-release.yml +++ b/.github/workflows/pre-release.yml @@ -37,10 +37,12 @@ jobs: run: | pip3 install pymongo cd ivy + sudo pip3 install -e . mkdir .ivy touch .ivy/key.pem echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem python scripts/setup_tests/setup_priority_tests.py + cd .. - name: Run CPU Tests run: | From ef6c1f98d9329aa3955669723225e238f6a41019 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 28 Feb 2024 12:59:51 +0530 Subject: [PATCH 938/978] fix: fixed the IvyValueError not import error (#28441) --- ivy/functional/frontends/sklearn/metrics/_classification.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ivy/functional/frontends/sklearn/metrics/_classification.py b/ivy/functional/frontends/sklearn/metrics/_classification.py index 4cee0d9e9187b..2c05ae5da5edf 100644 --- a/ivy/functional/frontends/sklearn/metrics/_classification.py +++ b/ivy/functional/frontends/sklearn/metrics/_classification.py @@ -1,6 +1,7 @@ import ivy from ivy.functional.frontends.numpy.func_wrapper import to_ivy_arrays_and_back from sklearn.utils.multiclass import type_of_target +from ivy.utils.exceptions import IvyValueError @to_ivy_arrays_and_back From c241bb816720369d24ef5f859d331916facf8d76 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Wed, 28 Feb 2024 13:02:30 +0530 Subject: [PATCH 939/978] fix: fixed logical_and not passing tests at paddle backend (#28433) --- .../test_ivy/test_functional/test_core/test_elementwise.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index b97ae0f0d5baf..6be1e5edf6766 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1362,7 +1362,7 @@ def test_logaddexp2(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.logical_and", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), num_arrays=2 + available_dtypes=helpers.get_dtypes("valid", full=False), num_arrays=2 ), test_gradients=st.just(False), ) From abd573502bfb3fa9fab5d819460f7af772b7ebc0 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Wed, 28 Feb 2024 12:04:11 +0000 Subject: [PATCH 940/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From b1bf7f0bd4b2e8577f29cc18736b7ce536fd4528 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 28 Feb 2024 12:05:31 +0000 Subject: [PATCH 941/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 6414e6b1c48101959acc48916136675999b24d83 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Wed, 28 Feb 2024 12:48:48 +0000 Subject: [PATCH 942/978] =?UTF-8?q?Update=20demos=20=F0=9F=A4=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/demos | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/demos b/docs/demos index d04fc08afb693..d3fa2b9c2a7ff 160000 --- a/docs/demos +++ b/docs/demos @@ -1 +1 @@ -Subproject commit d04fc08afb6932fa767e462f6035fd3620a10c6d +Subproject commit d3fa2b9c2a7ffa93573bb63d2e66abbe3dd198fc From 67870900b6d1f4ebd1a2b4abeea23d60e84b7c3e Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 28 Feb 2024 18:38:16 +0530 Subject: [PATCH 943/978] Update compiler.py ccb0a3d (#28450) Co-authored-by: ivy-branch --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index b982b20f2a8b3..62915323aa321 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.7.2" +__version__ = "0.0.7.3" From d83646fcb34af26fc87a140b792ffd8ddb8ff0fe Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Wed, 28 Feb 2024 13:26:13 +0000 Subject: [PATCH 944/978] fix: support 4d input for torch max_pool3d frontend (#28451) --- .../torch/nn/functional/pooling_functions.py | 12 +++++++++++- .../test_functional/test_pooling_functions.py | 4 ++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index cdc334a740329..2a0b97c0db0d6 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -286,7 +286,13 @@ def max_pool3d( stride = kernel_size if not isinstance(padding, int): padding = [(pad, pad) for pad in padding] - return ivy.max_pool3d( + if input.ndim == 4: + without_batch_dim = True + input = ivy.expand_dims(input, axis=0) + else: + without_batch_dim = False + + ret = ivy.max_pool3d( input, kernel_size, stride, @@ -295,3 +301,7 @@ def max_pool3d( dilation=dilation, ceil_mode=ceil_mode, ) + if without_batch_dim: + ret = ret[0] + + return ret diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py index 27091c4ca9bba..f8e6a04c07ade 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py @@ -523,10 +523,12 @@ def test_torch_max_pool2d( ), test_with_out=st.just(False), ceil_mode=st.booleans(), + without_batch=st.booleans(), ) def test_torch_max_pool3d( x_k_s_p, ceil_mode, + without_batch, *, test_flags, frontend, @@ -537,6 +539,8 @@ def test_torch_max_pool3d( dtype, x, kernel, stride, padding, dilation = x_k_s_p if not isinstance(padding, int): padding = [pad[0] for pad in padding] + if without_batch: + x = x[0] helpers.test_frontend_function( input_dtypes=dtype, backend_to_test=backend_fw, From 24a56b6cfe2ab93f45e4ce60b78b06b41f6b8b12 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Wed, 28 Feb 2024 20:16:05 +0530 Subject: [PATCH 945/978] fix: added the missing init files to the tensorflow frontend to get them uploaded to pypi (#28452) --- ivy/_version.py | 2 +- ivy/functional/frontends/tensorflow/python/__init__.py | 1 + ivy/functional/frontends/tensorflow/python/ops/__init__.py | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 ivy/functional/frontends/tensorflow/python/__init__.py create mode 100644 ivy/functional/frontends/tensorflow/python/ops/__init__.py diff --git a/ivy/_version.py b/ivy/_version.py index 62915323aa321..c5f70fd6098e7 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.7.3" +__version__ = "0.0.7.4" diff --git a/ivy/functional/frontends/tensorflow/python/__init__.py b/ivy/functional/frontends/tensorflow/python/__init__.py new file mode 100644 index 0000000000000..010d264b5a0d6 --- /dev/null +++ b/ivy/functional/frontends/tensorflow/python/__init__.py @@ -0,0 +1 @@ +from . import ops diff --git a/ivy/functional/frontends/tensorflow/python/ops/__init__.py b/ivy/functional/frontends/tensorflow/python/ops/__init__.py new file mode 100644 index 0000000000000..f0c2bd56a0634 --- /dev/null +++ b/ivy/functional/frontends/tensorflow/python/ops/__init__.py @@ -0,0 +1 @@ +from . import resource_variable_ops From cd8f8acef8d34d0a9b8e2f46f216371b9f56d0a4 Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 29 Feb 2024 00:18:59 +0530 Subject: [PATCH 946/978] fix: fixed `ivy.equal` for paddle backend support all dtype (#28426) --- ivy/functional/backends/paddle/elementwise.py | 4 ---- .../test_functional/test_core/test_elementwise.py | 10 +++++++--- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 1e426659e6458..150b145c02665 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -121,10 +121,6 @@ def isinf( return paddle.zeros(shape=x.shape, dtype=bool) -@with_unsupported_device_and_dtypes( - {"2.6.0 and below": {"cpu": ("bfloat16", "complex128", "float64", "float32")}}, - backend_version, -) def equal( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index 6be1e5edf6766..f537458a49b54 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -694,7 +694,11 @@ def test_divide(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.equal", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid", full=False), num_arrays=2 + available_dtypes=helpers.get_dtypes("valid", full=False), + num_arrays=2, + large_abs_safety_factor=6, + small_abs_safety_factor=6, + safety_factor_scale="log", ), test_gradients=st.just(False), ) @@ -708,8 +712,8 @@ def test_equal(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): on_device=on_device, x1=x[0], x2=x[1], - atol_=1e-03, - rtol_=1e-03, + atol_=1e-02, + rtol_=1e-02, ) From cd44da86795815dc4cf02e024521de51f3f61dae Mon Sep 17 00:00:00 2001 From: NripeshN Date: Thu, 29 Feb 2024 00:08:38 +0000 Subject: [PATCH 947/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 884c467cd142c9f896e3e6289149589cf97d5540 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 29 Feb 2024 00:10:03 +0000 Subject: [PATCH 948/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From ec1807ff4e1b5a459e15ca74bb2ca9d1407d82b8 Mon Sep 17 00:00:00 2001 From: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> Date: Thu, 29 Feb 2024 09:31:59 +0000 Subject: [PATCH 949/978] fix: remove to_list call in ivy's get item (#28453) fixes compiler related issues --- ivy/functional/ivy/general.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index cb70031569070..84e8170f47ce5 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -3127,7 +3127,7 @@ def _parse_slice(idx, s): stop = 0 elif stop < 0: stop = stop + s - q_i = ivy.arange(start, stop, step).to_list() + q_i = ivy.arange(start, stop, step) q_i = [q for q in q_i if 0 <= q < s] q_i = ( ivy.array(q_i) From 79ea9794797d352409693ea385fbdad094ec8123 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Thu, 29 Feb 2024 12:05:20 +0000 Subject: [PATCH 950/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 181da4ee88ed1bcec8052c18aba21f25d11c7fcf Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 29 Feb 2024 12:06:36 +0000 Subject: [PATCH 951/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From cd7cb35ab5dbecc1dffd0f55dec73bac313a0895 Mon Sep 17 00:00:00 2001 From: Haris Mahmood <70361308+hmahmood24@users.noreply.github.com> Date: Thu, 29 Feb 2024 12:56:25 +0000 Subject: [PATCH 952/978] feat(ivy): Add size to Ivy Functional API --- ivy/data_classes/array/array.py | 13 +- ivy/data_classes/container/general.py | 134 ++++++++++++++++++ ivy/functional/backends/jax/general.py | 4 + ivy/functional/backends/numpy/general.py | 4 + ivy/functional/backends/paddle/general.py | 6 + ivy/functional/backends/tensorflow/general.py | 6 + ivy/functional/backends/torch/general.py | 5 + ivy/functional/ivy/general.py | 45 ++++++ .../test_functional/test_core/test_general.py | 19 +++ 9 files changed, 224 insertions(+), 12 deletions(-) diff --git a/ivy/data_classes/array/array.py b/ivy/data_classes/array/array.py index 58c94d8a97e70..4d8a3e27def1c 100644 --- a/ivy/data_classes/array/array.py +++ b/ivy/data_classes/array/array.py @@ -1,9 +1,7 @@ # flake8: noqa # global import copy -import functools import numpy as np -from operator import mul from typing import Optional # local @@ -262,16 +260,7 @@ def shape(self) -> ivy.Shape: @property def size(self) -> Optional[int]: """Number of elements in the array.""" - if self._size is None: - if ivy.current_backend_str() in ["numpy", "jax"]: - self._size = self._data.size - return self._size - self._size = ( - functools.reduce(mul, self._data.shape) - if len(self._data.shape) > 0 - else 1 - ) - return self._size + return ivy.size(self) @property def itemsize(self) -> Optional[int]: diff --git a/ivy/data_classes/container/general.py b/ivy/data_classes/container/general.py index e372a016796d4..b1debe2fb187e 100644 --- a/ivy/data_classes/container/general.py +++ b/ivy/data_classes/container/general.py @@ -3874,6 +3874,140 @@ def get_num_dims( map_sequences=map_sequences, ) + @staticmethod + def _static_size( + x: Union[ivy.Array, ivy.NativeArray, ivy.Container], + /, + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + """ivy.Container instance method variant of ivy.size. This method + simply wraps the function, and so the docstring for ivy.size also + applies to this method with minimal changes. + + Parameters + ---------- + x + ivy.Container to infer the number of elements for + key_chains + The key-chains to apply or not apply the method to. Default is ``None``. + to_apply + If True, the method will be applied to key_chains, otherwise key_chains + will be skipped. Default is ``True``. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + + + Returns + ------- + ret + Number of elements of the array + + Examples + -------- + >>> x = ivy.Container(b = ivy.asarray([[0.,1.,1.],[1.,0.,0.],[8.,2.,3.]])) + >>> ivy.Container.static_size(x) + { + b: 9 + } + >>> x = ivy.Container(b = ivy.array([[[0,0,0],[0,0,0],[0,0,0]] + ... [[0,0,0],[0,0,0],[0,0,0]], + ... [[0,0,0],[0,0,0],[0,0,0]]])) + >>> ivy.Container.static_size(x) + { + b: 27 + } + >>> x = ivy.Container(b = ivy.array([[[0,0,0],[0,0,0],[0,0,0]], + ... [[0,0,0],[0,0,0],[0,0,0]]]), + ... c = ivy.asarray([[0.,1.,1.],[8.,2.,3.]])) + >>> ivy.Container.static_size(x) + { + b: 18, + c: 6, + } + """ + return ContainerBase.cont_multi_map_in_function( + "size", + x, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + + def size( + self: ivy.Container, + /, + *, + key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None, + to_apply: Union[bool, ivy.Container] = True, + prune_unapplied: Union[bool, ivy.Container] = False, + map_sequences: Union[bool, ivy.Container] = False, + ) -> ivy.Container: + """ivy.Container instance method variant of ivy.size. This method + simply wraps the function, and so the docstring for ivy.size also + applies to this method with minimal changes. + + Parameters + ---------- + self + ivy.Container to infer the number of elements for + key_chains + The key-chains to apply or not apply the method to. Default is ``None``. + to_apply + If True, the method will be applied to key_chains, otherwise key_chains + will be skipped. Default is ``True``. + prune_unapplied + Whether to prune key_chains for which the function was not applied. + Default is ``False``. + map_sequences + Whether to also map method to sequences (lists, tuples). + Default is ``False``. + + + Returns + ------- + ret + Number of elements of the array + + Examples + -------- + >>> a = ivy.Container(b = ivy.asarray([[0.,1.,1.],[1.,0.,0.],[8.,2.,3.]])) + >>> a.size() + { + b: 9 + } + >>> a = ivy.Container(b = ivy.array([[[0,0,0],[0,0,0],[0,0,0]], + ... [[0,0,0],[0,0,0],[0,0,0]], + ... [[0,0,0],[0,0,0],[0,0,0]]])) + >>> a.size() + { + b: 27 + } + >>> a = ivy.Container(b = ivy.array([[[0,0,0],[0,0,0],[0,0,0]], + ... [[0,0,0],[0,0,0],[0,0,0]]]), + ... c = ivy.asarray([[0.,1.,1.],[8.,2.,3.]])) + >>> a.size() + { + b: 18, + c: 6, + } + """ + return _ContainerWithGeneral._static_size( + self, + key_chains=key_chains, + to_apply=to_apply, + prune_unapplied=prune_unapplied, + map_sequences=map_sequences, + ) + @staticmethod def _static_array_equal( x0: Union[ivy.Array, ivy.NativeArray, ivy.Container], diff --git a/ivy/functional/backends/jax/general.py b/ivy/functional/backends/jax/general.py index 79817119b082e..538788b21af30 100644 --- a/ivy/functional/backends/jax/general.py +++ b/ivy/functional/backends/jax/general.py @@ -222,6 +222,10 @@ def get_num_dims(x: JaxArray, /, *, as_array: bool = False) -> Union[JaxArray, i return jnp.asarray(len(jnp.shape(x))) if as_array else len(x.shape) +def size(x: JaxArray, /) -> int: + return x.size + + def inplace_arrays_supported(): return False diff --git a/ivy/functional/backends/numpy/general.py b/ivy/functional/backends/numpy/general.py index 4fde7cbcd4f39..e185ef08998c8 100644 --- a/ivy/functional/backends/numpy/general.py +++ b/ivy/functional/backends/numpy/general.py @@ -174,6 +174,10 @@ def get_num_dims(x, /, *, as_array=False): return np.asarray(len(np.shape(x))) if as_array else len(x.shape) +def size(x, /) -> int: + return x.size + + def inplace_arrays_supported(): return True diff --git a/ivy/functional/backends/paddle/general.py b/ivy/functional/backends/paddle/general.py index 0f9747fe6353e..5f8e28ccf335d 100644 --- a/ivy/functional/backends/paddle/general.py +++ b/ivy/functional/backends/paddle/general.py @@ -2,7 +2,9 @@ signature.""" # global +import functools from numbers import Number +from operator import mul from typing import Optional, Union, Sequence, Callable, List, Tuple import paddle import numpy as np @@ -364,6 +366,10 @@ def get_num_dims( return paddle.to_tensor(x.ndim).squeeze() if as_array else x.ndim +def size(x: paddle.Tensor, /) -> int: + return functools.reduce(mul, x.shape) if len(x.shape) > 0 else 1 + + def inplace_arrays_supported(): # there are some operations that support inplace updates # but it's not supported in all functions diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py index c093b475cac89..47ac3efa9450a 100644 --- a/ivy/functional/backends/tensorflow/general.py +++ b/ivy/functional/backends/tensorflow/general.py @@ -5,6 +5,8 @@ """ # global +import functools +from operator import mul from typing import Optional, Union, Sequence, Callable, Tuple import numpy as np import multiprocessing as _multiprocessing @@ -195,6 +197,10 @@ def get_num_dims(x, /, *, as_array=False): ) +def size(x: tf.Tensor, /) -> int: + return functools.reduce(mul, x.shape) if len(x.shape) > 0 else 1 + + def inplace_arrays_supported(): return False diff --git a/ivy/functional/backends/torch/general.py b/ivy/functional/backends/torch/general.py index 4781a195a0f9e..5aab5d54c01c7 100644 --- a/ivy/functional/backends/torch/general.py +++ b/ivy/functional/backends/torch/general.py @@ -3,6 +3,7 @@ # global from functools import reduce as _reduce +import functools from numbers import Number from operator import mul from typing import Callable, List, Optional, Sequence, Tuple, Union @@ -281,6 +282,10 @@ def get_num_dims( return torch.tensor(len(x.shape)) if as_array else len(x.shape) +def size(x: torch.Tensor, /) -> int: + return functools.reduce(mul, x.shape) if len(x.shape) > 0 else 1 + + def inplace_arrays_supported(): return True diff --git a/ivy/functional/ivy/general.py b/ivy/functional/ivy/general.py index 84e8170f47ce5..7d2606defc47d 100644 --- a/ivy/functional/ivy/general.py +++ b/ivy/functional/ivy/general.py @@ -4047,6 +4047,51 @@ def get_num_dims( return current_backend(x).get_num_dims(x, as_array=as_array) +@handle_backend_invalid +@handle_nestable +@handle_array_like_without_promotion +@to_native_arrays_and_back +@handle_array_function +@handle_device +def size(x: Union[ivy.Array, ivy.NativeArray]) -> int: + """Return the number of elements of the array x. + + Parameters + ---------- + x + Input array to infer the number of elements for. + + Returns + ------- + ret + Number of elements of the array + + Both the description and the type hints above assumes an array input for simplicity, + but this function is *nestable*, and therefore also accepts :class:`ivy.Container` + instances in place of any of the arguments. + + Examples + -------- + With :class:`ivy.Array` input: + + >>> a = ivy.array([[[0, 0, 0], [0, 0, 0], [0, 0, 0]], + ... [[0, 0, 0], [0, 0, 0], [0, 0, 0]], + ... [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]) + >>> b = ivy.size(a) + >>> print(b) + 27 + + With :class:`ivy.Container` input: + + >>> a = ivy.Container(b = ivy.asarray([[0.,1.,1.],[1.,0.,0.],[8.,2.,3.]])) + >>> print(ivy.size(a)) + { + b: 9 + } + """ + return current_backend(x).size(x) + + @handle_exceptions def arg_info(fn: Callable, *, name: Optional[str] = None, idx: Optional[int] = None): """Return the index and `inspect.Parameter` representation of the specified diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_general.py b/ivy_tests/test_ivy/test_functional/test_core/test_general.py index 0a75937e8a1ca..a7edfe7e96f2b 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_general.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_general.py @@ -1749,6 +1749,25 @@ def test_shape(x0_n_x1_n_res, as_array, test_flags, backend_fw, fn_name, on_devi ) +# size +@handle_test( + fn_tree="functional.ivy.size", + dtype_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("valid")), + test_with_out=st.just(False), + test_gradients=st.just(False), +) +def test_size(dtype_x, test_flags, backend_fw, fn_name, on_device): + dtype, x = dtype_x + helpers.test_function( + input_dtypes=dtype, + test_flags=test_flags, + on_device=on_device, + backend_to_test=backend_fw, + fn_name=fn_name, + x=x[0], + ) + + # stable_divide @handle_test( fn_tree="functional.ivy.stable_divide", From 16260888a7cf7388e20ef88d3990cb20529a75fe Mon Sep 17 00:00:00 2001 From: samunder singh <83540902+samthakur587@users.noreply.github.com> Date: Thu, 29 Feb 2024 18:47:35 +0530 Subject: [PATCH 953/978] fix: fixed the ivy.not_equal at paddle backend (#28431) --- ivy/functional/backends/paddle/elementwise.py | 4 ---- .../test_functional/test_core/test_elementwise.py | 10 +++++++--- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/ivy/functional/backends/paddle/elementwise.py b/ivy/functional/backends/paddle/elementwise.py index 150b145c02665..b9f468220fe91 100644 --- a/ivy/functional/backends/paddle/elementwise.py +++ b/ivy/functional/backends/paddle/elementwise.py @@ -613,10 +613,6 @@ def negative( return paddle.neg(x) -@with_unsupported_device_and_dtypes( - {"2.6.0 and below": {"cpu": ("bfloat16", "complex128", "float64", "float32")}}, - backend_version, -) def not_equal( x1: Union[float, paddle.Tensor], x2: Union[float, paddle.Tensor], diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py index f537458a49b54..9cdc25220a3f8 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_elementwise.py @@ -1587,7 +1587,11 @@ def test_negative(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): @handle_test( fn_tree="functional.ivy.not_equal", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid", full=False), num_arrays=2 + available_dtypes=helpers.get_dtypes("valid", full=False), + num_arrays=2, + large_abs_safety_factor=8, + small_abs_safety_factor=8, + safety_factor_scale="log", ), test_gradients=st.just(False), ) @@ -1602,8 +1606,8 @@ def test_not_equal(*, dtype_and_x, test_flags, backend_fw, fn_name, on_device): on_device=on_device, x1=x[0], x2=x[1], - atol_=1e-03, - rtol_=1e-03, + atol_=1e-02, + rtol_=1e-02, ) From 7d8f37f72dd948f30ca0b29cf6bcce247cf580a3 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 29 Feb 2024 21:15:56 +0530 Subject: [PATCH 954/978] fix: fixed the example in the README --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 44bd3b7170790..f526fd1c0535b 100644 --- a/README.md +++ b/README.md @@ -202,8 +202,8 @@ After installing Ivy, you can start using it straight away, for example: b = jax.numpy.mean(x) return x * a + b - jax_x = jax.numpy.array([1, 2, 3]) - torch_x = torch.tensor([1, 2, 3]) + jax_x = jax.numpy.array([1., 2., 3.]) + torch_x = torch.tensor([1., 2., 3.]) torch_fn = ivy.transpile(jax_fn, source="jax", to="torch", args=(jax_x,)) ret = torch_fn(torch_x) ``` From b110a28f636315c7be71b839f60ba8b13e02001d Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Thu, 29 Feb 2024 21:21:21 +0530 Subject: [PATCH 955/978] fix: added cryptography to the requirements.txt --- requirements/requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index f4aefa27b826e..84262042721ed 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -16,3 +16,4 @@ ml-dtypes==0.2.0 # mod_name=ml_dtypes cloudpickle gast tqdm +cryptography From ca87bf6550cbdf5a085b5b4afbf159e614f1a495 Mon Sep 17 00:00:00 2001 From: Shephin philip <132887262+shephinphilip@users.noreply.github.com> Date: Fri, 1 Mar 2024 01:19:19 +0530 Subject: [PATCH 956/978] docs: fix placeholders in api_standards.rst (#23404) --- docs/overview/related_work/api_standards.rst | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/docs/overview/related_work/api_standards.rst b/docs/overview/related_work/api_standards.rst index 04d6939840436..31ebe5da5dbee 100644 --- a/docs/overview/related_work/api_standards.rst +++ b/docs/overview/related_work/api_standards.rst @@ -16,8 +16,24 @@ This standard can be considered as “higher level” than the ML frameworks the The Array API Standard takes the lowest common denominator approach, whereby each function in the standard represents the minimum behaviors of the function without restricting extensions to the function. This means that two very different libraries can adhere to the same standard, despite having very different extended behaviors for some of the functions in the standard. The standard is also not exhaustive. -For example, there are functions defined in the standard, whereas the functions defined in each framework are as follows: +For example, there are 64 functions defined in the standard, whereas the functions defined in each framework are as follows: - +Table: +__________________________________________________________________________________ +| | | +| Framework | Functions | +|-------------|------------------------------------------------------------------| +| NumPy | all, any, argmax, argmin, around, clip, cumprod, cumsum, max, | +| | mean, min, prod, round, std, sum, var | +|-------------|------------------------------------------------------------------| +| Pandas | append, diff, fillna, head, isin, loc, mean, min, pct_change, | +| | prod, quantile, rolling, shift, tail, to_numpy | +|-------------|------------------------------------------------------------------| +| TensorFlow | cast, clip_by_value, equal, greater, greater_equal, less, | +| | less_equal, maximum, minimum, not_equal, ones_like, reshape, | +| | sum | +|-------------|------------------------------------------------------------------| +| PyTorch | abs, add, mean, max, min, pow, sum | +|_____________|__________________________________________________________________| Therefore, two frameworks which adhere to the standard will still have major differences by virtue of the extra functions they support which are not present in the standard. From ad0ae6c892874dd9333b8cf24003d656c66a80eb Mon Sep 17 00:00:00 2001 From: savita921 <141542782+savita921@users.noreply.github.com> Date: Fri, 1 Mar 2024 01:20:07 +0530 Subject: [PATCH 957/978] feat: Add dropout function for MindSpore Frontend (#21362) --- .../mindspore/ops/function/nn_func.py | 19 +++++++++++ .../test_function/test_mindspore_nn_func.py | 34 +++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py index c476401281148..deffd6d14b6dc 100644 --- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py +++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py @@ -218,6 +218,25 @@ def conv3d( return _conv(input, weight, bias, stride, padding, dilation, groups) +@with_supported_dtypes( + { + "2.0.0 and below": ( + "int8", + "int16", + "int32", + "int64", + "float16", + "float32", + "float64", + ) + }, + "mindspore", +) +@to_ivy_arrays_and_back +def dropout(input, p=0.5, training=True, seed=None): + return ivy.dropout(input, p, training=training, seed=seed) + + @with_supported_dtypes( { "2.0.0 and below": ( diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py index 46a0d22c152cd..b4e04fe61550a 100644 --- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py +++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py @@ -356,6 +356,40 @@ def test_mindspore_conv3d( ) +#dropout +@pytest.mark.skip("Testing pipeline not yet implemented") +@handle_frontend_test( + fn_tree="mindspore.ops.function.nn_func.dropout", + d_type_and_x=helpers.dtype_and_values(), + p=helpers.floats(min_value=0.0, max_value=1.0), + training=st.booleans(), + seed=helpers.ints(min_value=0, max_value=100) +) +def test_mindspore_dropout( + *, + d_type_and_x, + p, + training, + seed, + on_device, + fn_tree, + frontend, + test_flags, +): + dtype, x = d_type_and_x + ret, frontend_ret = helpers.test_frontend_function( + input_dtypes=dtype, + frontend=frontend, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + input=x[0], + p=p, + training=training, + seed=seed, + ) + + # dropout2d @pytest.mark.skip("Testing pipeline not yet implemented") @handle_frontend_test( From 782e745c956fdd7e488ead22f37190f6f3f54403 Mon Sep 17 00:00:00 2001 From: adityadeshmukh369 <107697598+adityadeshmukh369@users.noreply.github.com> Date: Fri, 1 Mar 2024 01:21:18 +0530 Subject: [PATCH 958/978] fix: update tensorflow avg pool2d test tolerance and ensure correct output type (#26116) --- ivy/functional/frontends/tensorflow/nn.py | 4 +++- ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py | 2 ++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/tensorflow/nn.py b/ivy/functional/frontends/tensorflow/nn.py index 7cc55e31428bb..ca340335899a3 100644 --- a/ivy/functional/frontends/tensorflow/nn.py +++ b/ivy/functional/frontends/tensorflow/nn.py @@ -100,7 +100,9 @@ def avg_pool1d(input, ksize, strides, padding, data_format="NWC", name=None): # avg_pool2d @to_ivy_arrays_and_back def avg_pool2d(input, ksize, strides, padding, data_format="NHWC", name=None): - return ivy.avg_pool2d(input, ksize, strides, padding, data_format=data_format) + return ivy.avg_pool2d( + input, ksize, strides, padding, data_format=data_format + ).astype(input.dtype) # avg_pool3d diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py index ce528f775d260..da6f3aac33f11 100644 --- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py +++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_nn.py @@ -687,6 +687,8 @@ def test_tensorflow_avg_pool2d( ksize=ksize, strides=strides, padding=padding, + rtol=1e-2, + atol=1e-2, ) From 76ed84ba901c53bee401a5a77783f40afa79bffe Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 29 Feb 2024 19:52:56 +0000 Subject: [PATCH 959/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../test_ops/test_function/test_mindspore_nn_func.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py index b4e04fe61550a..ead7157dcd54b 100644 --- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py +++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py @@ -356,14 +356,14 @@ def test_mindspore_conv3d( ) -#dropout +# dropout @pytest.mark.skip("Testing pipeline not yet implemented") @handle_frontend_test( fn_tree="mindspore.ops.function.nn_func.dropout", d_type_and_x=helpers.dtype_and_values(), p=helpers.floats(min_value=0.0, max_value=1.0), training=st.booleans(), - seed=helpers.ints(min_value=0, max_value=100) + seed=helpers.ints(min_value=0, max_value=100), ) def test_mindspore_dropout( *, From 78df55e1c09a4be52d43253553afbb526c68b225 Mon Sep 17 00:00:00 2001 From: Partho Das Date: Fri, 1 Mar 2024 01:58:21 +0530 Subject: [PATCH 960/978] feat: Add `negative_` method to torch frontend (#23766) --- ivy/functional/frontends/torch/tensor.py | 5 +++ .../test_frontends/test_torch/test_tensor.py | 38 +++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py index 95d737be609a3..d7ffcf14ea36f 100644 --- a/ivy/functional/frontends/torch/tensor.py +++ b/ivy/functional/frontends/torch/tensor.py @@ -956,6 +956,11 @@ def neg_(self): def negative(self): return torch_frontend.negative(self) + @with_unsupported_dtypes({"2.0.1 and below": ("bool", "bfloat16")}, "torch") + def negative_(self): + self.ivy_array = torch_frontend.negative(self).ivy_array + return self + def int(self, memory_format=None): self.ivy_array = ivy.astype(self.ivy_array, ivy.int32, copy=False) return self diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index ea81f425eecbc..cf0426e9c4adc 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -10296,6 +10296,44 @@ def test_torch_new_( ) +# negative_ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="negative_", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_value=-1e04, + max_value=1e04, + allow_inf=False, + ), +) +def test_torch_tensor_negative_( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # new_empty (not actually intuitive for testing) @handle_frontend_method( class_tree=CLASS_TREE, From 81de93435c5126ccecf41f6a9d4f23467103aa59 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Thu, 29 Feb 2024 20:29:39 +0000 Subject: [PATCH 961/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../test_frontends/test_torch/test_tensor.py | 76 +++++++++---------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py index cf0426e9c4adc..fff739b50489d 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py @@ -10296,44 +10296,6 @@ def test_torch_new_( ) -# negative_ -@handle_frontend_method( - class_tree=CLASS_TREE, - init_tree="torch.tensor", - method_name="negative_", - dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("valid"), - min_value=-1e04, - max_value=1e04, - allow_inf=False, - ), -) -def test_torch_tensor_negative_( - dtype_and_x, - frontend, - frontend_method_data, - init_flags, - method_flags, - on_device, - backend_fw, -): - input_dtype, x = dtype_and_x - helpers.test_frontend_method( - init_input_dtypes=input_dtype, - backend_to_test=backend_fw, - init_all_as_kwargs_np={ - "data": x[0], - }, - method_input_dtypes=input_dtype, - method_all_as_kwargs_np={}, - frontend_method_data=frontend_method_data, - init_flags=init_flags, - method_flags=method_flags, - frontend=frontend, - on_device=on_device, - ) - - # new_empty (not actually intuitive for testing) @handle_frontend_method( class_tree=CLASS_TREE, @@ -13307,6 +13269,44 @@ def test_torch_tensor_logaddexp2( ) +# negative_ +@handle_frontend_method( + class_tree=CLASS_TREE, + init_tree="torch.tensor", + method_name="negative_", + dtype_and_x=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_value=-1e04, + max_value=1e04, + allow_inf=False, + ), +) +def test_torch_tensor_negative_( + dtype_and_x, + frontend, + frontend_method_data, + init_flags, + method_flags, + on_device, + backend_fw, +): + input_dtype, x = dtype_and_x + helpers.test_frontend_method( + init_input_dtypes=input_dtype, + backend_to_test=backend_fw, + init_all_as_kwargs_np={ + "data": x[0], + }, + method_input_dtypes=input_dtype, + method_all_as_kwargs_np={}, + frontend_method_data=frontend_method_data, + init_flags=init_flags, + method_flags=method_flags, + frontend=frontend, + on_device=on_device, + ) + + # positive @handle_frontend_method( class_tree=CLASS_TREE, From 29c0310390d77ec0bb26c87d732a92d8fb11ede9 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Fri, 1 Mar 2024 00:09:51 +0000 Subject: [PATCH 962/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 56cdc809772f6b1a60a00b82750534c7078f6977 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Fri, 1 Mar 2024 00:11:06 +0000 Subject: [PATCH 963/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 9eca7a96acd8bc280b963df80ff81681314290ee Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 1 Mar 2024 12:55:44 +0530 Subject: [PATCH 964/978] fix: added max_pool2d accessible through the root namespace of the torch frontend and updated the condition to work when stride = [] (#28457) --- ivy/functional/frontends/torch/__init__.py | 2 +- .../frontends/torch/nn/functional/pooling_functions.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/__init__.py b/ivy/functional/frontends/torch/__init__.py index e9f0986016442..c2d3e94b8bc01 100644 --- a/ivy/functional/frontends/torch/__init__.py +++ b/ivy/functional/frontends/torch/__init__.py @@ -260,7 +260,7 @@ def promote_types_of_torch_inputs( from . import nn -from .nn.functional import softmax, relu, lstm +from .nn.functional import softmax, relu, lstm, max_pool2d, dropout from . import special from . import tensor from .tensor import * diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index 2a0b97c0db0d6..a2bfe3f320ddd 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -256,7 +256,7 @@ def max_pool2d( ceil_mode=False, return_indices=False, ): - if stride is None: + if not stride: stride = kernel_size if not isinstance(padding, int): padding = [(pad, pad) for pad in padding] From f02ce81b79c9fcfb3a3851656d0313191a271f18 Mon Sep 17 00:00:00 2001 From: Ved Patwardhan <54766411+vedpatwardhan@users.noreply.github.com> Date: Fri, 1 Mar 2024 13:35:34 +0530 Subject: [PATCH 965/978] Update _version.py --- ivy/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ivy/_version.py b/ivy/_version.py index c5f70fd6098e7..c8de1df2308a4 100644 --- a/ivy/_version.py +++ b/ivy/_version.py @@ -1 +1 @@ -__version__ = "0.0.7.4" +__version__ = "0.0.7.5" From 8fb4c26c05d5493b8dbe0e3bf8d0bf1bdb0b8aa1 Mon Sep 17 00:00:00 2001 From: Gadri Ebenezer Date: Fri, 1 Mar 2024 14:49:09 +0000 Subject: [PATCH 966/978] fix: add safety factors for test torch leaky relu and setup alphas correctly(#28392) --- .../test_non_linear_activation_functions.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py index 162ef1b2e73b6..3f3e971ea1bc1 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_non_linear_activation_functions.py @@ -515,8 +515,18 @@ def test_torch_hardtanh_( fn_tree="torch.nn.functional.leaky_relu", dtype_and_x=helpers.dtype_and_values( available_dtypes=helpers.get_dtypes("float"), + min_num_dims=1, + large_abs_safety_factor=25, + small_abs_safety_factor=25, + safety_factor_scale="log", + ), + alpha=helpers.floats( + min_value=0, + max_value=1, + large_abs_safety_factor=25, + small_abs_safety_factor=25, + safety_factor_scale="log", ), - alpha=st.floats(min_value=0.0, max_value=1.0, exclude_min=True), test_inplace=st.booleans(), test_with_out=st.just(False), ) From 94412c1061ecbe26225b652ded34fccd9b5a15ac Mon Sep 17 00:00:00 2001 From: Mahesh Sahoo <108557691+Msahoo876@users.noreply.github.com> Date: Fri, 1 Mar 2024 20:39:32 +0530 Subject: [PATCH 967/978] fix: specifiy unsupported types for adaptive max pool 3d in torch frontend (#28401) --- .../frontends/torch/nn/functional/pooling_functions.py | 5 ++++- .../test_nn/test_functional/test_pooling_functions.py | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py index a2bfe3f320ddd..5f7cbff10383e 100644 --- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py +++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py @@ -59,8 +59,11 @@ def adaptive_max_pool2d( @with_unsupported_dtypes( { "2.2 and below": ( - "bfloat16", "float16", + "int8", + "int16", + "bool", + "uint8", ) }, "torch", diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py index f8e6a04c07ade..a4c3e9bf7de99 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py @@ -118,7 +118,7 @@ def test_torch_adaptive_avg_pool2d( @handle_frontend_test( fn_tree="torch.nn.functional.adaptive_max_pool2d", dtype_and_x=helpers.dtype_and_values( - available_dtypes=helpers.get_dtypes("float"), + available_dtypes=helpers.get_dtypes("valid"), min_num_dims=3, max_num_dims=4, min_dim_size=5, From d8645a9ed78bf3de1194d6caa020f4ba2d73ffeb Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 1 Mar 2024 21:55:32 +0530 Subject: [PATCH 968/978] fix: Removed un-necessary workflows (#28449) --- .github/workflows/synchronize-db.yml | 22 --- .github/workflows/test-array-api.yml | 80 ----------- .github/workflows/test-frontend-jax.yml | 82 ----------- .github/workflows/test-frontend-numpy.yml | 82 ----------- .../workflows/test-frontend-tensorflow.yml | 82 ----------- .github/workflows/test-frontend-torch.yml | 82 ----------- .github/workflows/test-ivy-core.yml | 131 ------------------ .../workflows/test-ivy-experimental-core.yml | 122 ---------------- .../workflows/test-ivy-experimental-nn.yml | 120 ---------------- .github/workflows/test-ivy-nn.yml | 128 ----------------- .github/workflows/test-ivy-stateful.yml | 129 ----------------- 11 files changed, 1060 deletions(-) delete mode 100644 .github/workflows/synchronize-db.yml delete mode 100644 .github/workflows/test-array-api.yml delete mode 100644 .github/workflows/test-frontend-jax.yml delete mode 100644 .github/workflows/test-frontend-numpy.yml delete mode 100644 .github/workflows/test-frontend-tensorflow.yml delete mode 100644 .github/workflows/test-frontend-torch.yml delete mode 100644 .github/workflows/test-ivy-core.yml delete mode 100644 .github/workflows/test-ivy-experimental-core.yml delete mode 100644 .github/workflows/test-ivy-experimental-nn.yml delete mode 100644 .github/workflows/test-ivy-nn.yml delete mode 100644 .github/workflows/test-ivy-stateful.yml diff --git a/.github/workflows/synchronize-db.yml b/.github/workflows/synchronize-db.yml deleted file mode 100644 index f5632e4f6ded0..0000000000000 --- a/.github/workflows/synchronize-db.yml +++ /dev/null @@ -1,22 +0,0 @@ -name: Synchronize DB -on: - workflow_dispatch: -permissions: - actions: read -jobs: - synchronize-db: - runs-on: ubuntu-latest - steps: - - name: Checkout Ivy 🛎 - uses: actions/checkout@v3 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - fetch-depth: 1 - - - name: Synchronize DB - run: | - pip install pymongo - cd ivy - python scripts/setup_tests/synchronize_db.py ${{ secrets.MONGODB_PASSWORD }} diff --git a/.github/workflows/test-array-api.yml b/.github/workflows/test-array-api.yml deleted file mode 100644 index 7db65e56a0379..0000000000000 --- a/.github/workflows/test-array-api.yml +++ /dev/null @@ -1,80 +0,0 @@ -name: test-array-api -on: - workflow_dispatch: - -jobs: - run-array-api-tests: - if: contains(github.event.pull_request.labels.*.name, 'Array API') - strategy: - matrix: - backends: [numpy, torch, jax, tensorflow] - submodules: [array_object, constants, creation_functions, data_type_functions, - has_names, linalg, manipulation_functions, operators_and_elementwise_functions, - searching_functions, set_functions, signatures, sorting_functions, - special_cases, statistical_functions, utility_functions] - continue-on-error: true - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: 'recursive' - - - name: Download artifact - if: github.event_name == 'pull_request' - uses: dawidd6/action-download-artifact@v2 - with: - workflow: test-array-api.yml - workflow_conclusion: completed - name: 'hypothesis_${{ matrix.backends }}_${{ matrix.submodules }}_zip' - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - if: github.event_name == 'pull_request' - id: unzip - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: steps.unzip.outcome != 'success' && github.event_name == 'pull_request' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Array API Tests - id: tests - run: | - cd ivy - ./scripts/shell/test_array_api.sh ${{matrix.backends}} test_${{matrix.submodules}} ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD}} - continue-on-error: true - - - name: Zip Hypothesis Examples - if: github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - if: github.event_name == 'pull_request' - uses: actions/upload-artifact@v3 - with: - name: 'hypothesis_${{ matrix.backends }}_${{ matrix.submodules }}_zip' - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - - name: Check on failures - if: steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-frontend-jax.yml b/.github/workflows/test-frontend-jax.yml deleted file mode 100644 index 13e676f735a5a..0000000000000 --- a/.github/workflows/test-frontend-jax.yml +++ /dev/null @@ -1,82 +0,0 @@ -name: test-frontend-jax -on: - workflow_dispatch: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] - -jobs: - run-nightly-tests: - if: github.event_name == 'push' || contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') || contains(github.event.pull_request.labels.*.name, 'JAX Frontend') - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Download artifact - if: github.event_name == 'pull_request' - uses: dawidd6/action-download-artifact@v2 - with: - workflow: test-frontend-jax.yml - workflow_conclusion: completed - name: hypothesis_frontend_jax_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - if: github.event_name == 'pull_request' - id: unzip - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: steps.unzip.outcome != 'success' && github.event_name == 'pull_request' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Frontend Tests - id: tests - run: | - cd ivy - docker run --rm -v `pwd`:/ivy -v `pwd`/.hypothesis:/.hypothesis unifyai/ivy:latest python3 -m pytest --backend all ivy_tests/test_ivy/test_frontends/test_jax - continue-on-error: true - - - name: Zip Hypothesis Examples - if: github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - if: github.event_name == 'pull_request' - uses: actions/upload-artifact@v3 - with: - name: hypothesis_frontend_jax_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Check on failures - if: steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-frontend-numpy.yml b/.github/workflows/test-frontend-numpy.yml deleted file mode 100644 index 464b98a0d802d..0000000000000 --- a/.github/workflows/test-frontend-numpy.yml +++ /dev/null @@ -1,82 +0,0 @@ -name: test-frontend-numpy -on: - workflow_dispatch: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] - -jobs: - run-nightly-tests: - if: contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') ||contains(github.event.pull_request.labels.*.name, 'NumPy Frontend') - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Download artifact - if: github.event_name == 'pull_request' - uses: dawidd6/action-download-artifact@v2 - with: - workflow: test-frontend-numpy.yml - workflow_conclusion: completed - name: hypothesis_frontend_numpy_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - if: github.event_name == 'pull_request' - id: unzip - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: steps.unzip.outcome != 'success' && github.event_name == 'pull_request' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Frontend Tests - id: tests - run: | - cd ivy - docker run --rm -v `pwd`:/ivy -v `pwd`/.hypothesis:/.hypothesis unifyai/ivy:latest python3 -m pytest --backend all ivy_tests/test_ivy/test_frontends/test_numpy - continue-on-error: true - - - name: Zip Hypothesis Examples - if: github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - if: github.event_name == 'pull_request' - uses: actions/upload-artifact@v3 - with: - name: hypothesis_frontend_numpy_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Check on failures - if: steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-frontend-tensorflow.yml b/.github/workflows/test-frontend-tensorflow.yml deleted file mode 100644 index 1ba8b51c427d6..0000000000000 --- a/.github/workflows/test-frontend-tensorflow.yml +++ /dev/null @@ -1,82 +0,0 @@ -name: test-frontend-tensorflow -on: - workflow_dispatch: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] - -jobs: - run-nightly-tests: - if: contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') || contains(github.event.pull_request.labels.*.name, 'TensorFlow Frontend') - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Download artifact - if: github.event_name == 'pull_request' - uses: dawidd6/action-download-artifact@v2 - with: - workflow: test-frontend-tensorflow.yml - workflow_conclusion: completed - name: hypothesis_frontend_tensorflow_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - if: github.event_name == 'pull_request' - id: unzip - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: steps.unzip.outcome != 'success' && github.event_name == 'pull_request' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Frontend Tests - id: tests - run: | - cd ivy - docker run --rm -v `pwd`:/ivy -v `pwd`/.hypothesis:/.hypothesis unifyai/ivy:latest python3 -m pytest --backend all ivy_tests/test_ivy/test_frontends/test_tensorflow - continue-on-error: true - - - name: Zip Hypothesis Examples - if: github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - if: github.event_name == 'pull_request' - uses: actions/upload-artifact@v3 - with: - name: hypothesis_frontend_tensorflow_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Check on failures - if: steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-frontend-torch.yml b/.github/workflows/test-frontend-torch.yml deleted file mode 100644 index acbe96ab030c4..0000000000000 --- a/.github/workflows/test-frontend-torch.yml +++ /dev/null @@ -1,82 +0,0 @@ -name: test-frontend-torch -on: - workflow_dispatch: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] - -jobs: - run-nightly-tests: - if: contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') ||contains(github.event.pull_request.labels.*.name, 'PyTorch Frontend') - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Download artifact - if: github.event_name == 'pull_request' - uses: dawidd6/action-download-artifact@v2 - with: - workflow: test-frontend-torch.yml - workflow_conclusion: completed - name: hypothesis_frontend_torch_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - if: github.event_name == 'pull_request' - id: unzip - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: steps.unzip.outcome != 'success' && github.event_name == 'pull_request' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Frontend Tests - id: tests - run: | - cd ivy - docker run --rm -v `pwd`:/ivy -v `pwd`/.hypothesis:/.hypothesis unifyai/ivy:latest python3 -m pytest --backend=all ivy_tests/test_ivy/test_frontends/test_torch - continue-on-error: true - - - name: Zip Hypothesis Examples - if: github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - if: github.event_name == 'pull_request' - uses: actions/upload-artifact@v3 - with: - name: hypothesis_frontend_torch_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Check on failures - if: steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-ivy-core.yml b/.github/workflows/test-ivy-core.yml deleted file mode 100644 index 25c41a929e9e8..0000000000000 --- a/.github/workflows/test-ivy-core.yml +++ /dev/null @@ -1,131 +0,0 @@ -name: test-core-ivy -on: - workflow_dispatch: -# push: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] - -permissions: - actions: read -jobs: - run-nightly-tests: - if: ${{(github.event_name == 'push') || contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') || contains(github.event.pull_request.labels.*.name, 'Ivy Functional API')}} - strategy: - matrix: - backends: [ numpy, torch, jax, tensorflow ] - submodules: [ creation, device, dtype, elementwise, general, gradients, linalg, - manipulation, meta, nest, random, searching, set, sorting, statistical, - utility ] - continue-on-error: true - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - fetch-depth: 2 - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Check Files Changed - if: ${{(github.event_name == 'push') || !contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') }} - shell: pwsh - id: check_file_changed - run: | - cd ivy - $diff = git diff --name-only HEAD^ HEAD - $SourceDiff = $diff | Where-Object { ` - $_ -match 'ivy_tests/test_ivy/test_functional/test_core/test_${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy_tests/test_ivy/helpers.py' ` - -or $_ -match 'ivy/array/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/container/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/functional/backends/${{ matrix.backends }}/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/functional/ivy/${{ matrix.submodules }}.py' ` - } - $HasDiff = $SourceDiff.Length -gt 0 - Write-Host "::set-output name=changed::$HasDiff" - - - name: Download artifact - uses: dawidd6/action-download-artifact@v2 - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - with: - github_token: ${{secrets.GITHUB_TOKEN}} - workflow: test-ivy-core.yml - workflow_conclusion: "" - search_artifacts: true - name: hypothesis_${{ matrix.backends }}_test_${{ matrix.submodules }}_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - id: unzip - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && steps.unzip.outcome != 'success' && github.event_name == 'pull_request' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Functional-Core Tests - id: tests - if: steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped' - run: | - cd ivy - ./scripts/shell/test_ivy_core.sh ${{ matrix.backends }} test_${{ matrix.submodules }} ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD}} - continue-on-error: true - - - name: Zip Hypothesis Examples - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - uses: actions/upload-artifact@v3 - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - with: - name: hypothesis_${{ matrix.backends }}_test_${{ matrix.submodules }}_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Install Mongo Python Client - if: (steps.check_file_changed.outputs.changed == 'True' && github.event_name == 'push' && github.ref == 'refs/heads/main') - uses: BSFishy/pip-action@v1 - with: - packages: | - pymongo[srv] - - - name: Update Database - if: (steps.check_file_changed.outputs.changed == 'True' && github.event_name == 'push' && github.ref == 'refs/heads/main') - env: - MONGODB_PASSWORD: ${{ secrets.MONGODB_PASSWORD }} - run: | - cd ivy/automation_tools/dashboard_automation/ - python3 update_db.py "$MONGODB_PASSWORD" ${{ github.workflow }} "${{ matrix.backends }}-${{ matrix.submodules }}" ${{ steps.tests.outcome }} ${{ github.run_id }} - continue-on-error: true - - - - name: Check on failures - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-ivy-experimental-core.yml b/.github/workflows/test-ivy-experimental-core.yml deleted file mode 100644 index e45ca220c1be2..0000000000000 --- a/.github/workflows/test-ivy-experimental-core.yml +++ /dev/null @@ -1,122 +0,0 @@ -name: test-experimental-core-ivy -on: - workflow_dispatch: -# push: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] -permissions: - actions: read -jobs: - run-nightly-tests: - if: ${{(github.event_name == 'push') || contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') || contains(github.event.pull_request.labels.*.name, 'Ivy API Experimental')}} - strategy: - matrix: - backends: [ numpy, torch, jax, tensorflow ] - submodules: [ creation, device, dtype, elementwise, general, gradients, linalg, - manipulation, meta, nest, random, searching, set, sorting, sparse_array, - statistical, utility ] - continue-on-error: true - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - fetch-depth: 2 - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Check Files Changed - shell: pwsh - id: check_file_changed - run: | - cd ivy - $diff = git diff --name-only HEAD^ HEAD - $SourceDiff = $diff | Where-Object { ` - $_ -match 'ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_${{ matrix.submodules }}.py' ` - } - $HasDiff = $SourceDiff.Length -gt 0 - Write-Host "::set-output name=changed::$HasDiff" - - name: Download artifact - uses: dawidd6/action-download-artifact@v2 - if: github.event_name == 'pull_request' && steps.check_file_changed.outputs.changed == 'True' - with: - github_token: ${{secrets.GITHUB_TOKEN}} - workflow: test-ivy-experimental.yml - workflow_conclusion: "" - search_artifacts: true - name: hypothesis_${{ matrix.backends }}_test_experimental_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - id: unzip - if: github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: github.event_name == 'pull_request' && steps.check_file_changed.outputs.changed == 'True' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Experimental Test - if: steps.check_file_changed.outputs.changed == 'True' - id: tests - run: | - cd ivy - ./scripts/shell/test_experimental_core.sh ${{ matrix.backends }} test_${{ matrix.submodules }} ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD}} - continue-on-error: true - - - name: Zip Hypothesis Examples - if: github.event_name == 'pull_request' && steps.check_file_changed.outputs.changed == 'True' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - uses: actions/upload-artifact@v3 - if: github.event_name == 'pull_request' - with: - name: hypothesis_${{ matrix.backends }}_test_${{ matrix.submodules }}_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Install Mongo Python Client - if: github.event_name == 'push' && github.ref == 'refs/heads/main' && steps.check_file_changed.outputs.changed == 'True' - uses: BSFishy/pip-action@v1 - with: - packages: | - pymongo[srv] - - name: Update Database - if: github.event_name == 'push' && github.ref == 'refs/heads/main' && steps.check_file_changed.outputs.changed == 'True' - env: - MONGODB_PASSWORD: ${{ secrets.MONGODB_PASSWORD }} - run: | - cd ivy/automation_tools/dashboard_automation/ - python3 update_db.py "$MONGODB_PASSWORD" ${{ github.workflow }} "${{ matrix.backends }}-${{ matrix.submodules }}" ${{ steps.tests.outcome }} ${{ github.run_id }} - continue-on-error: true - - - - name: Check on failures - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-ivy-experimental-nn.yml b/.github/workflows/test-ivy-experimental-nn.yml deleted file mode 100644 index d6d3e5e3ed5cc..0000000000000 --- a/.github/workflows/test-ivy-experimental-nn.yml +++ /dev/null @@ -1,120 +0,0 @@ -name: test-experimental-nn-ivy -on: - workflow_dispatch: -# push: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] -permissions: - actions: read -jobs: - run-nightly-tests: - if: ${{(github.event_name == 'push') || contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') || contains(github.event.pull_request.labels.*.name, 'Ivy API Experimental')}} - strategy: - matrix: - backends: [ numpy, torch, jax, tensorflow ] - submodules: [ activations, layers, losses, norms ] - continue-on-error: true - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - fetch-depth: 2 - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Check Files Changed - shell: pwsh - id: check_file_changed - run: | - cd ivy - $diff = git diff --name-only HEAD^ HEAD - $SourceDiff = $diff | Where-Object { ` - $_ -match 'ivy_tests/test_ivy/test_functional/test_experimental/test_nn/test_${{ matrix.submodules }}.py' ` - } - $HasDiff = $SourceDiff.Length -gt 0 - Write-Host "::set-output name=changed::$HasDiff" - - name: Download artifact - uses: dawidd6/action-download-artifact@v2 - if: github.event_name == 'pull_request' && steps.check_file_changed.outputs.changed == 'True' - with: - github_token: ${{secrets.GITHUB_TOKEN}} - workflow: test-ivy-experimental.yml - workflow_conclusion: "" - search_artifacts: true - name: hypothesis_${{ matrix.backends }}_test_experimental_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - id: unzip - if: github.event_name == 'pull_request' && steps.check_file_changed.outputs.changed == 'True' - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: github.event_name == 'pull_request' && steps.check_file_changed.outputs.changed == 'True' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Experimental Test - if: steps.check_file_changed.outputs.changed == 'True' - id: tests - run: | - cd ivy - ./scripts/shell/test_experimental_nn.sh ${{ matrix.backends }} test_${{ matrix.submodules }} ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD}} - continue-on-error: true - - - name: Zip Hypothesis Examples - if: github.event_name == 'pull_request' && steps.check_file_changed.outputs.changed == 'True' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - uses: actions/upload-artifact@v3 - if: github.event_name == 'pull_request' && steps.check_file_changed.outputs.changed == 'True' - with: - name: hypothesis_${{ matrix.backends }}_test_${{ matrix.submodules }}_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Install Mongo Python Client - if: github.event_name == 'push' && github.ref == 'refs/heads/main' && steps.check_file_changed.outputs.changed == 'True' - uses: BSFishy/pip-action@v1 - with: - packages: | - pymongo[srv] - - name: Update Database - if: github.event_name == 'push' && github.ref == 'refs/heads/main' && steps.check_file_changed.outputs.changed == 'True' - env: - MONGODB_PASSWORD: ${{ secrets.MONGODB_PASSWORD }} - run: | - cd ivy/automation_tools/dashboard_automation/ - python3 update_db.py "$MONGODB_PASSWORD" ${{ github.workflow }} "${{ matrix.backends }}-${{ matrix.submodules }}" ${{ steps.tests.outcome }} ${{ github.run_id }} - continue-on-error: true - - - - name: Check on failures - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-ivy-nn.yml b/.github/workflows/test-ivy-nn.yml deleted file mode 100644 index 8e89adaf2ab2b..0000000000000 --- a/.github/workflows/test-ivy-nn.yml +++ /dev/null @@ -1,128 +0,0 @@ -name: test-nn-ivy -on: - workflow_dispatch: -# push: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] -permissions: - actions: read -jobs: - run-nightly-tests: - if: ${{(github.event_name == 'push') || contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') || contains(github.event.pull_request.labels.*.name, 'Ivy Functional API')}} - strategy: - matrix: - backends: [ numpy, torch, jax, tensorflow ] - submodules: [ activations, layers, losses, norms ] - continue-on-error: true - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - fetch-depth: 2 - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Check Files Changed - if: ${{ (github.event_name == 'push') || !contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') }} - shell: pwsh - id: check_file_changed - run: | - cd ivy - $diff = git diff --name-only HEAD^ HEAD - $SourceDiff = $diff | Where-Object { ` - $_ -match 'ivy_tests/test_ivy/test_functional/test_nn/test_${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy_tests/test_ivy/helpers.py' ` - -or $_ -match 'ivy/array/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/container/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/functional/backends/${{ matrix.backends }}/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/functional/ivy/${{ matrix.submodules }}.py' ` - } - $HasDiff = $SourceDiff.Length -gt 0 - Write-Host "::set-output name=changed::$HasDiff" - - - name: Download artifact - uses: dawidd6/action-download-artifact@v2 - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - with: - github_token: ${{secrets.GITHUB_TOKEN}} - workflow: test-ivy-nn.yml - workflow_conclusion: "" - search_artifacts: true - name: hypothesis_${{ matrix.backends }}_test_${{ matrix.submodules }}_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - id: unzip - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && steps.unzip.outcome != 'success' && github.event_name == 'pull_request' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Functional-NN Tests - id: tests - if: steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped' - run: | - cd ivy - ./scripts/shell/test_ivy_nn.sh ${{ matrix.backends }} test_${{ matrix.submodules }} ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD}} - continue-on-error: true - - - name: Zip Hypothesis Examples - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - uses: actions/upload-artifact@v3 - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - with: - name: hypothesis_${{ matrix.backends }}_test_${{ matrix.submodules }}_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Install Mongo Python Client - if: (steps.check_file_changed.outputs.changed == 'True' && github.event_name == 'push' && github.ref == 'refs/heads/main') - uses: BSFishy/pip-action@v1 - with: - packages: | - pymongo[srv] - - - name: Update Database - if: (steps.check_file_changed.outputs.changed == 'True' && github.event_name == 'push' && github.ref == 'refs/heads/main') - env: - MONGODB_PASSWORD: ${{ secrets.MONGODB_PASSWORD }} - run: | - cd ivy/automation_tools/dashboard_automation/ - python3 update_db.py "$MONGODB_PASSWORD" ${{ github.workflow }} "${{ matrix.backends }}-${{ matrix.submodules }}" ${{ steps.tests.outcome }} ${{ github.run_id }} - continue-on-error: true - - - - name: Check on failures - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && steps.tests.outcome != 'success' - run: exit 1 diff --git a/.github/workflows/test-ivy-stateful.yml b/.github/workflows/test-ivy-stateful.yml deleted file mode 100644 index b8ea545d0ff24..0000000000000 --- a/.github/workflows/test-ivy-stateful.yml +++ /dev/null @@ -1,129 +0,0 @@ -name: test-stateful-ivy -on: - workflow_dispatch: -# push: -# pull_request: -# types: [labeled, opened, synchronize, reopened, review_requested] -permissions: - actions: read -jobs: - run-nightly-tests: - if: ${{(github.event_name == 'push') || contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') || contains(github.event.pull_request.labels.*.name, 'Ivy Stateful API') }} - strategy: - matrix: - backends: [ numpy, torch, jax, tensorflow ] - submodules: [ activations, converters, layers, modules, norms, optimizers, - sequential ] - continue-on-error: true - runs-on: ubuntu-latest - steps: - - name: Checkout 🛎️Ivy - uses: actions/checkout@v2 - with: - path: ivy - persist-credentials: false - submodules: "recursive" - fetch-depth: 2 - - - name: Install ivy and fetch binaries - run: | - cd ivy - sudo pip3 install -e . - mkdir .ivy - touch .ivy/key.pem - echo -n ${{ secrets.USER_API_KEY }} > .ivy/key.pem - cd .. - - - name: Check Files Changed - if: ${{ (github.event_name == 'push') || !contains(github.event.pull_request.labels.*.name, 'Exhaustive CI') }} - shell: pwsh - id: check_file_changed - run: | - cd ivy - $diff = git diff --name-only HEAD^ HEAD - $SourceDiff = $diff | Where-Object { ` - $_ -match 'ivy_tests/test_ivy/test_stateful/test_${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy_tests/test_ivy/helpers.py' ` - -or $_ -match 'ivy/array/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/container/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/functional/backends/${{ matrix.backends }}/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/functional/ivy/${{ matrix.submodules }}.py' ` - -or $_ -match 'ivy/stateful/${{ matrix.submodules }}.py' ` - } - $HasDiff = $SourceDiff.Length -gt 0 - Write-Host "::set-output name=changed::$HasDiff" - - - name: Download artifact - uses: dawidd6/action-download-artifact@v2 - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - with: - github_token: ${{secrets.GITHUB_TOKEN}} - workflow: test-ivy-stateful.yml - workflow_conclusion: "" - search_artifacts: true - name: hypothesis_${{ matrix.backends }}_test_${{ matrix.submodules }}_zip - path: | - ivy/.hypothesis/ - continue-on-error: true - - - name: Unzip Hypothesis Examples - id: unzip - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - unzip examples.zip - rm examples.zip - continue-on-error: true - - - name: Create Hypothesis Directory - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && steps.unzip.outcome != 'success' && github.event_name == 'pull_request' - run: | - cd ivy - mkdir -p .hypothesis - cd .hypothesis - mkdir -p examples - continue-on-error: true - - - name: Run Stateful Tests - id: tests - if: steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped' - run: | - cd ivy - ./scripts/shell/test_ivy_stateful.sh ${{ matrix.backends }} test_${{ matrix.submodules }} ${{ secrets.REDIS_CONNECTION_URL }} ${{ secrets.REDIS_PASSWORD}} - continue-on-error: true - - - name: Zip Hypothesis Examples - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - run: | - cd ivy/.hypothesis - zip -r examples.zip examples - continue-on-error: true - - - name: Upload hypothesis - uses: actions/upload-artifact@v3 - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && github.event_name == 'pull_request' - with: - name: hypothesis_${{ matrix.backends }}_test_${{ matrix.submodules }}_zip - path: | - ivy/.hypothesis/examples.zip - continue-on-error: true - - - name: Install Mongo Python Client - if: (steps.check_file_changed.outputs.changed == 'True' && github.event_name == 'push' && github.ref == 'refs/heads/main') - uses: BSFishy/pip-action@v1 - with: - packages: | - pymongo[srv] - - - name: Update Database - if: (steps.check_file_changed.outputs.changed == 'True' && github.event_name == 'push' && github.ref == 'refs/heads/main') - env: - MONGODB_PASSWORD: ${{ secrets.MONGODB_PASSWORD }} - run: | - cd ivy/automation_tools/dashboard_automation/ - python3 update_db.py "$MONGODB_PASSWORD" ${{ github.workflow }} "${{ matrix.backends }}-${{ matrix.submodules }}" ${{ steps.tests.outcome }} ${{ github.run_id }} - continue-on-error: true - - - name: Check on failures - if: (steps.check_file_changed.outputs.changed == 'True' || steps.check_file_changed.conclusion == 'skipped') && steps.tests.outcome != 'success' - run: exit 1 From 15f0ef3b118ba72b1a53ec27e99eb1d77ed65617 Mon Sep 17 00:00:00 2001 From: Sai-Suraj-27 Date: Fri, 1 Mar 2024 22:58:57 +0530 Subject: [PATCH 969/978] feat: Updated `Ruff` to the latest version and fixed lint failure (#28463) --- .pre-commit-config.yaml | 2 +- ivy/functional/ivy/meta.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 7f554e7ec95f6..cbf4307237040 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,7 @@ repos: - id: check-toml - id: end-of-file-fixer - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.2.2 + rev: v0.3.0 hooks: # Run the linter. - id: ruff diff --git a/ivy/functional/ivy/meta.py b/ivy/functional/ivy/meta.py index f4d5b6a633b8e..1da6ed819a3cc 100644 --- a/ivy/functional/ivy/meta.py +++ b/ivy/functional/ivy/meta.py @@ -314,7 +314,7 @@ def _train_tasks_batched( -------- >>> # Example usage here >>> pass - """ + """ # noqa: E501 (Line too long) inner_batch = batch outer_batch = batch if inner_batch_fn is not None: From f4faa04f413f42dc85924a1e36c0da0aa3cc0ebe Mon Sep 17 00:00:00 2001 From: Chaitanya Lakhchaura <90706514+ZenithFlux@users.noreply.github.com> Date: Sat, 2 Mar 2024 01:01:31 +0530 Subject: [PATCH 970/978] fix: preserve same named parameters between frontend function and test functions and fix test for matrix rank in torch frontend(#28390) --- ivy/functional/frontends/torch/linalg.py | 4 ++-- ivy_tests/test_ivy/helpers/function_testing.py | 6 ++++++ ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py | 6 ++++-- ivy_tests/test_ivy/test_functional/test_core/test_linalg.py | 3 +++ 4 files changed, 15 insertions(+), 4 deletions(-) diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py index 2dd1074416540..d0db7936cc929 100644 --- a/ivy/functional/frontends/torch/linalg.py +++ b/ivy/functional/frontends/torch/linalg.py @@ -190,8 +190,8 @@ def matrix_power(A, n, *, out=None): @with_supported_dtypes( {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch" ) -def matrix_rank(A, *, atol=None, rtol=None, hermitian=False, out=None): - return ivy.matrix_rank(A, atol=atol, rtol=rtol, hermitian=hermitian, out=out) +def matrix_rank(input, *, atol=None, rtol=None, hermitian=False, out=None): + return ivy.matrix_rank(input, atol=atol, rtol=rtol, hermitian=hermitian, out=out) @to_ivy_arrays_and_back diff --git a/ivy_tests/test_ivy/helpers/function_testing.py b/ivy_tests/test_ivy/helpers/function_testing.py index 2926065df3f5e..6d7ecd8ebbd5b 100644 --- a/ivy_tests/test_ivy/helpers/function_testing.py +++ b/ivy_tests/test_ivy/helpers/function_testing.py @@ -823,6 +823,8 @@ def test_frontend_function( if True, test for the correctness of the resulting values. all_as_kwargs_np input arguments to the function as keyword arguments. + If an input argument has the same name as any other parameter + of this function, add "arg_" before the argument name. Returns ------- @@ -844,6 +846,10 @@ def test_frontend_function( test_flags.with_out = False test_flags.inplace = False + all_as_kwargs_np = { + k[4:] if k.startswith("arg_") else k: v for k, v in all_as_kwargs_np.items() + } + # split the arguments into their positional and keyword components args_np, kwargs_np = kwargs_to_args_n_kwargs( num_positional_args=test_flags.num_positional_args, kwargs=all_as_kwargs_np diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py index 299edb7a9fd0e..4b75c6fdb4482 100644 --- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py +++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py @@ -1002,9 +1002,11 @@ def test_torch_matrix_rank( test_flags=test_flags, fn_tree=fn_tree, on_device=on_device, + rtol=0, + atol=0, input=x, - rtol=rtol, - atol=atol, + arg_rtol=rtol, + arg_atol=atol, hermitian=hermitian, ) diff --git a/ivy_tests/test_ivy/test_functional/test_core/test_linalg.py b/ivy_tests/test_ivy/test_functional/test_core/test_linalg.py index 9c081e53af64f..b6ca29eacb3ab 100644 --- a/ivy_tests/test_ivy/test_functional/test_core/test_linalg.py +++ b/ivy_tests/test_ivy/test_functional/test_core/test_linalg.py @@ -279,6 +279,9 @@ def _matrix_rank_helper(draw): ) atol = draw(tol_strategy) rtol = draw(tol_strategy) + if not (atol is None or rtol is None): + assume(type(atol) is type(rtol)) + return dtype, x[0], hermitian, atol, rtol From d07f6f3c923527d45751ab216301ecf2f4e0bbff Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sat, 2 Mar 2024 00:08:27 +0000 Subject: [PATCH 971/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From f67a1289b5952544c4f73066e17f9d9256c7e782 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 2 Mar 2024 00:09:45 +0000 Subject: [PATCH 972/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From aa46a0eb96d578cf83b1fe1e637bd1fb4652d315 Mon Sep 17 00:00:00 2001 From: Sam Armstrong <88863522+Sam-Armstrong@users.noreply.github.com> Date: Sat, 2 Mar 2024 00:30:47 +0000 Subject: [PATCH 973/978] fix: torch frontend max/min to support dim and keepdim as arg or kwarg (#28469) --- .../frontends/torch/reduction_ops.py | 28 +++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py index 03d6ec6d91fb8..564bbca97f9cc 100644 --- a/ivy/functional/frontends/torch/reduction_ops.py +++ b/ivy/functional/frontends/torch/reduction_ops.py @@ -100,11 +100,25 @@ def logsumexp(input, dim, keepdim=False, *, out=None): @numpy_to_torch_style_args @to_ivy_arrays_and_back +@with_unsupported_dtypes( + {"2.2 and below": ("complex64", "complex128")}, + "torch", +) def max(*input, dim=None, keepdim=False, out=None): if len(input) == 1: input = input[0] elif len(input) == 2: - return torch_frontend.maximum(*input) + input_0 = input[0] + input_1 = input[1] + if ivy.is_array(input_1): + return torch_frontend.maximum(*input) + else: + input = input_0 + dim = input_1 + else: + input = input[0] + dim = input[1] + keepdim = input[2] if dim is None: return ivy.max(input, axis=dim, keepdims=keepdim, out=out) elif out is not None: @@ -173,7 +187,17 @@ def min(*input, dim=None, keepdim=False, out=None): if len(input) == 1: input = input[0] elif len(input) == 2: - return torch_frontend.minimum(*input) + input_0 = input[0] + input_1 = input[1] + if ivy.is_array(input_1): + return torch_frontend.minimum(*input) + else: + input = input_0 + dim = input_1 + else: + input = input[0] + dim = input[1] + keepdim = input[2] if dim is None: return ivy.min(input, axis=dim, keepdims=keepdim, out=out) elif out is not None: From 73201af1947599a7f45d6822d9424f505b158f61 Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sat, 2 Mar 2024 12:04:17 +0000 Subject: [PATCH 974/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From add68a8e41ebab29d7efe63ae3541ade03574069 Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sat, 2 Mar 2024 12:05:32 +0000 Subject: [PATCH 975/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From e7645e309931e25b2eee79702601dc2be847da8f Mon Sep 17 00:00:00 2001 From: NripeshN Date: Sun, 3 Mar 2024 00:09:17 +0000 Subject: [PATCH 976/978] Update volunteer-leaderboard.rst --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index e091024c3fab2..5ad4a4ddd6475 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 2e80c3ec59ccc9384ebca5eae476b8f76d30982a Mon Sep 17 00:00:00 2001 From: ivy-branch Date: Sun, 3 Mar 2024 00:10:37 +0000 Subject: [PATCH 977/978] =?UTF-8?q?=F0=9F=A4=96=20Lint=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/overview/volunteer_ranks.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview/volunteer_ranks.rst b/docs/overview/volunteer_ranks.rst index 5ad4a4ddd6475..e091024c3fab2 100644 --- a/docs/overview/volunteer_ranks.rst +++ b/docs/overview/volunteer_ranks.rst @@ -27,7 +27,7 @@ Rising Contributors * - Name - Github ID - Badges - * - Muhammad ishaque + * - Muhammad ishaque - `MuhammadNizamani `_ - Merging Master Silver, Merging Wizard, Ivy Inspector Core Contributors @@ -42,10 +42,10 @@ Core Contributors * - Suyash Gupta - `sgalpha01 `_ - Debugging Dynamo, Merging Master Bronze, Merging Wizard Bronze - * - Sanjay Suthar + * - Sanjay Suthar - `Sanjay8602 `_ - Merging Master Bronze, Ivy Inspector Bronze - * - R E Zera Marveen Lyngkhoi + * - R E Zera Marveen Lyngkhoi - `fleventy-5 `_ - Merging Master Bronze * - nitesh kesharwani @@ -93,7 +93,7 @@ Contributors * - Waqar Ahmed - `waqaarahmed `_ - Merging Master, Ivy Inspector - * - Aryan Pandey + * - Aryan Pandey - `Aryan8912 `_ - Merging Master * - Dhruv Sharma From 662504475db98cffd0f3ff73016d753abbe9b827 Mon Sep 17 00:00:00 2001 From: Asad Ahsan <61329893+AwkNinja@users.noreply.github.com> Date: Sun, 3 Mar 2024 02:03:00 -0800 Subject: [PATCH 978/978] feat(frontends): Implemented numpy fftn with tests (#26917) Co-authored-by: Ishtiaq Hussain <53497039+Ishticode@users.noreply.github.com> --- .../numpy/fft/discrete_fourier_transform.py | 34 +++++++++++++- .../test_discrete_fourier_transform.py | 47 +++++++++++++++++++ 2 files changed, 80 insertions(+), 1 deletion(-) diff --git a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py index 738f68cdd1681..0cfe2a10a75a2 100644 --- a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py +++ b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py @@ -1,6 +1,6 @@ import ivy from ivy.functional.frontends.numpy.func_wrapper import to_ivy_arrays_and_back -from ivy.func_wrapper import with_unsupported_dtypes +from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes _SWAP_DIRECTION_MAP = { @@ -53,6 +53,38 @@ def fftfreq(n, d=1.0): return results * val +@with_supported_dtypes( + {"1.26.0 and below": ("float32", "float64", "complex64", "complex128")}, + "numpy", +) +@to_ivy_arrays_and_back +def fftn(a, s=None, axes=None, norm=None): + invreal = 0 + if norm is None: + norm = "backward" + if s is None: + shapeless = 1 + if axes is None: + s = list(a.shape) + else: + axes = [ax % len(a.shape) for ax in axes] + s = ivy.gather(a.shape, ivy.array(axes, dtype="int64")) + else: + shapeless = 0 + s = list(s) + if axes is None: + axes = list(range(-len(s), 0)) + if len(s) != len(axes): + raise ValueError("Shape and axes have different lengths.") + if invreal and shapeless: + s[-1] = (a.shape[axes[-1]] - 1) * 2 + itl = list(range(len(axes))) + itl.reverse() + for ii in itl: + a = ivy.fft(a, axes[ii], norm=norm, n=int(s[ii])) + return ivy.astype(a, ivy.complex128) + + @to_ivy_arrays_and_back @with_unsupported_dtypes({"1.26.3 and below": ("float16",)}, "numpy") def fftshift(x, axes=None): diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_fft/test_discrete_fourier_transform.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_fft/test_discrete_fourier_transform.py index 26506d7008684..b17dc06b34bfd 100644 --- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_fft/test_discrete_fourier_transform.py +++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_fft/test_discrete_fourier_transform.py @@ -62,6 +62,53 @@ def test_numpy_fftfreq( ) +@handle_frontend_test( + fn_tree="numpy.fft.fftn", + dtype_values=helpers.dtype_and_values( + available_dtypes=helpers.get_dtypes("valid"), + min_value=-1e5, + max_value=1e5, + min_num_dims=2, + max_num_dims=3, + min_dim_size=2, + max_dim_size=3, + large_abs_safety_factor=10, + small_abs_safety_factor=10, + safety_factor_scale="log", + ), + axes=st.sampled_from([(0, 1), (-1, -2), (1, 0), None]), + s=st.tuples( + st.integers(min_value=2, max_value=256), st.integers(min_value=2, max_value=256) + ) + | st.none(), + norm=st.sampled_from(["backward", "ortho", "forward", None]), +) +def test_numpy_fftn( + dtype_values, + s, + axes, + norm, + frontend, + backend_fw, + test_flags, + fn_tree, + on_device, +): + dtype, values = dtype_values + helpers.test_frontend_function( + input_dtypes=dtype, + frontend=frontend, + backend_to_test=backend_fw, + test_flags=test_flags, + fn_tree=fn_tree, + on_device=on_device, + a=values[0], + s=s, + axes=axes, + norm=norm, + ) + + @handle_frontend_test( fn_tree="numpy.fft.fftshift", dtype_and_x=helpers.dtype_and_values(

    y`F{C(CO|h$1DCz^uaR#4Jv0L5PH`)K`s3TMXU|Y< zF1FH~IT(YX6D(QUgs!ffv{HARV7}b*HzM&Igd}qzg-h>gUUc4^!7>SQc>}4m4oxG7 z?#32{IWLkdTm6L0Lt!W9>Sm>sA!)QO%$%YqBh|N4W9XGdO=MnIi< z6q-grQeDBlNrJj&D6PUD7OQbko&n1kC%6{2I6a;8Bc^ zyYVtJR$@r1R+(W5IF+S$PvBM6J7zNT9U3TEIEtKDurb!?R z)jOEtRE7pHk2{eG&-rU6@28R^UAg69aG$JaBcaahA?Uez zQk@=yIiL^+i5A>q46 z8HNU(2_CWt93yAN#x6<0wppkxD63j0H=&m8Ae9LEOHhyk+^owZ2Q*7^PqX&xM{L0d*$X zpbSt%AQ~*g)9k(XpE5q)PYIw89N&0$zHQaJs)-wg`R*;Bz^3Q>664kz>Pr?i;r$=3 zuc0IL2C?hqPx>1h%q*Cuf%RAZWy4^8-yJvL*=G*MBtxEN_?Y;f&+9m6RTo;@nxuCx z?#7eKXj_zxcXAkWL%WbplNz&q2khG%xGb;(P&Zl$&zURIxdL^N0Q9;Qg|?_G7k5L)5CGO!2ymmp zNbgY-sB3`%9E+T!ES_Ez=0Z9iEpY=l>RYtCzI8hjFlX>Lw(+4ZeHDZ?Je2xvieTX6 zQJ^(rqPxXHT5f+EZXf2CSFP_I8{WXT|9wNlp}unU>9Qa*f%?v^2k`o@K3+Gdx3B*% zw6y0>3e=ra0j&5&=vm@wc7Q<$QmWP=7}3sO(7EQ-M{m7g(h4>poDx9K<>%c?WLH`_ zL}Bifw&9lVJy#(%5A}rl-(COCx^IWtv-6)YIx;@vbWGF0x+^}>5STlq9k}H`zKFv| z3R8ml-0loko!gC6+Jx)6a2yw|>%w(>cdb6mrIhYM`e^q&3ddt`grv?GG>yPCHRu{w zrD{6i-ZT9Wg?Z2^$6?L@6p9{>9V?+!^uia_5bCx=eF-`Wb5S;7)W@WTL!C1ZOYHG> z79F?R4x()08c}klTqp8Y<7<&L!gZWF)EVL4?vm0|UCpY;lJX}2a;ac*7Cy-1``kOO zSip9@hPpTS3P63MYB5b9G)F4b z<#d9G;$n7Z=2sI|u0i3X1AXYki`S;IbI;_zDtCENm;=BQzxphWpO}2=q8?EH#9y3O z_Z`%F4_rT^ozv8C-Ua701m^umAHw&)b2rLm(OHGdQ3>WNRsZywqE5KaL&oZTK<3$fAdTk8!+ab7yF0K*OJ=d22 z#6Tjn<{2OYGGf`9{O?0ufw_8}nlDl9dz3g)Z+8S?$vkpJY)}xd zafT_8T60FQ%E1*&*?g6{r+}MriJeh@DH{twE_UK$j6+bU-viJCAOtOG9qnmDcBa7~ zFf6?bs1FxCeEKVo;=rC`XcW}XzxpFJgZiVtcpmPNAJzrxddKhLtTm^f6sS9n12+0P zm&{d5Q5EXK=X*r`-r1&g?R@e_e>P#|8W2u8&~q(|BNNaGqwa)gTR#$GYFUcM2&^J&c|BHhK=cF?qx)!iATtM%&!aquwyzx%GD3`IF!J23pm@+%O0( zSvL=zU9E5&7mn@1aXhI`cO0%>mo8oXwdT}|TC@k2$-1(JoH76XRF2UIl%tX;z&rin z5eG+)moV60hHXz`zfdEnbNKq5X$0o-d`L1!Xh$_QPbsBG(umq91=o^L*%%X0kCs^J z{43Q%DM$QRsF?g55$7XqrGRGbiWbajvx31+D8F#(ovjvMbMAV+3f;-VQxBa9*y)?8Ra0`ADMW7ya1sj3-oKE9g6IQGN;iLk6uy^C59$r`EzjMGM>p*D zudfc~%`GM_y=*a3DT__8G1?p$5PUwa53OsqBuKov;l5$VbQ z;(8Q=17#dLR>att3vVi0@77RKPqh38he%-2&O$I(B}XZ#N7A57P7TWAv4KD&eqvR_ z&6pfVNi%*dlqHwWNjQdpB>=QEnOL)WA>MP%ndoW@+;Rq8YLJJiYv^hgAG+C-1xow6M1>P@ng^Uxk@6PmcP%SFv#uP$verK?&Vg1?ogcOS6^R{lxda zJz>S_98Mb08Dp*a)-(Rs1TiYY{K)RV$F`kA)5>?IQ2*d{E0AsfpVP{_nn1ll?0xlH zHL++vYvt00!2H3VeHG6>bI`xOI+!n*pTor$F9v`J%ssx&+!5a26pMCg%}(KX;m%n= zK3MJ|R-pv<(3?QbZrdIP`pYD8+1bh(Fopg#bR`{STe0> z9_K8|A(hfA8o32-f&IPY88BM*Fk1HDP`)HhKt0&RhJ+jv$@XR8b|i$L#WIjHHL!%n zks1f()a?%+#`kW16pe!VMOVM0CL6k(I6jD1AO4D;Uu~hT<SP!BGt4 z;JZ*1OY;(-uFO4kcenoev17*)gw)1_lLqvW{uggD&DNGm=jHBP3E|(r`51t>>af}{ zU8pxg)qd!;PoY#S&p4fhi@Py*=~q#2nBRBD4LERM+`qm$n6Ftg3umu9&4;%u=gj%X zlOT6o?m$MYJLlVmGP&VOY>l}j5QA<6^W{JwnFlfWw{n@H??f4WePt9&!8124n9GY% zHPnetU}bdVn+>#d7-(wI<#Vktz{2TzZ~E3>PKxX)a~9Ed7H{T;I(9^ zOPKQ`xvXZD_HSs+R+|aoq&SvgjJ2AnmfJMVOf;*R2<98^eGh*7La-?bQJ=0UgsDP3 zpEL2#pZ_$>%sErftjaKShGYQFt>|aasS=7;_#7zfBobz zHw+DzUA_n{t$EnCuwwTl&^?bEzy)qyxfeLs4YorSbLPSrF7%snCliLni6{-IVsK`# zZHmDG2cx5oRISRhGl97p5*{)_04t*-mDZ8V>quucm==MihX){)BxgbaFku9zfE)pg zc@2X!B+L=`&X^j^gX7|LBjR^-#4$l2%3t*uB?u%|k%(!PEd|*;-hFGNKn<@5f=w`^kC)6ZkU#Tqw2V!%c4aV_UzaX z&+}=9={cV{wD%a6FVmsrSNJCl)XMox^StwLV&|{G#4-a}7AV@d+B=_Nl)=O>NOpcu zZ$kXG_iq|85?*nFT-G?F&+hp5d_LcBXEP^7LLcdW@g`kQ`@`#~I#Axm4&94``wq-FotBn7&OEoi8?D&It@yz$_e=@q%`GOby829HGAU`n z9vH#7Qq}G{%AC3I!|ev}4z|FIZ?HlsP`15LzEPNa9`~Kz*H?z^_^NfaW3Cm<0ZBg7 zBFN@-w6qy$>$H%|=}4uu3NB7b1=t4vgYOZkoCKS#0Q|ksbiU@?NQ3)q*DDVelJaH> z%tiSG{H7WzN$QjYd8m>)2+))>uz2BIe}^<>KXZQ*7Rxfx+LA^pWq?xV`}tQ5-w=Yi z>d$|lvO>mF+KmAyxfBQbODOxx2&vNkY7v9B51$wDb)umyr9&steopx=t_85Ir-;x0 z-^VaMDwcfKPg2*LR^x5&T@T9=MitYS)F1fa?V!bjsI{c7<su3xh`i zuL!71s^x%6ol_6pS(uhdio5UsSz?9i92yREK6ifBABK;L5$nYB#=pAfA241_zVY>h z`nfCGaLHSLKD`X82(G;k2X@~#<8(~Zz`2*)0L^FvP+ypr%hbQVI+(9pw*-U`1>P=P zA)))rid=_DiJUu zcLkYd&`pALR!38dfsQT>EQyFRVtS39U%t8PVScU!}u z?ztXV|5M^=2nv)qr!LOv06fe+t>Z1nj~{RNTzbQSJ~q7lzXRz!2$R9QFnBxeeV}K; zIQ4*fK4;()e_LOx_MX@O6|OTgBRJDEaQ?cFpK>r~3|P5x4m3?u=E=hr?T+KYv3-cE zhHx%?kc&-N;*xn1+#QEvaL~rkppDT{N6wK4+nr9dzIu8Ok(J`};BB22+S)DT@;a=P zCe^bb$@9;uL_Imoc~{H37Y3#=5EIZ+fR+aI6rfoIOh@dY4$rN}(~o**i%aGLyy19M z1DM7DGF_;Lt?|Wi(S6RJ*X|ochW9Y%&xqm$&Skz&_OQjeaP`WVzjVzvjB`Bd*E?Q5 zk+*>CV8KQIxIeG1Xhg(TvMS6~SO)_kuGMI^44CSY%IHl}ehw5|eD+@(1NFJf--)%C zub45^4<9^%{f~cA$**=$UvTBuVOU1Pp+4F_298-_V~#7V-6RV$Fn zuLp2y!5jdN9vKYg%au8ERn6{tk*!e0f7M}(uxj^`VJ;*l(SbV-L$Tn&^@7p0Dy1@? zwnFL+LUj+3X=%te8|avoLQ|`OR7QuUlK^^3TTs6PiME$oE&z)39)~#qz+hk&^B4(!SIl#O`mnd^{TCWilw3Hu?J*&I9mB{Fta~XRC=!+EOHR z&xg72&F;^SJL;}!OoH3>!pqYbf|U`Lp+S@F7B|+D{|Rr?g6*Mq+(FqlwiC|_Q$5`& zx0r_R9sg*ALp`m>^9$NDxQD~V#zB4YxxbI4XP-7>s6YSIcDP4>qU2W_sB8IiaOTPd z3cwo&b=v!+-y~wbT{Mvb^_bg4f_d}W*6n!gwuZWdZ79$!EB~J)@(5Q0^CP>j$HPw? z4X&9aeyyOsWKk2Yy7t%8ORUPE>1~*Q*3DS7boJzsD}*zaosQ<&p8{~|!JIMR;K6Ye zi{+3-JBN8-(XQ^ECN^AAy}${$2c32xd5MpBxr1XYR1T(yg6dp3qfxgcK&4lM=meRZ zf%dKxTG}n7vql`A5g1Cz+?UivdxhI7?EE+k1Qt8)iL``d7)g^CR;hO+NH~Z1ufi$% zo(5G&j6=Y|ZZc4f#oV+fh1lQ#!5VD_VDa3nl+48zsH*Cn1D^UFJK%W1Gb5I$c}y&A z^ap=_T{HmgSwksH-1)Q^Ac?v-E=7OAM#*ELwxcZ4t0fJdl(ub>P-n5|ltI}LghTzG zzw&59pnm>UA3}Rq^NgYX@LfOU^XW3b+CV+K_Aa!vH#HpU5&u))Zq>iCsR_+7GH=W(wao)eF?|C&a2Y_4t;|n<67dIH3sL!Z{_4}tj^;R@> zylv`(Jh{5Tk>e;X2i|3uC~X?hY(C>jwY#sRwg_8zdb&I*M!t&~+_j(HSITq@kTs%rJ{8g!-{r+z=4F?Ez(2HT~f z_7|m92Rl?bUUDfs!jRH5<(`M{9g(0@LvVjmy2b|^v4Ne48f?Q_b{RJQ_5d!uXnx(T z-%metE_S`T9n_@?u%~AIUM@Q*^=-!774KB?18QOY-r8>9@N1hCOZQ+ByPnqXx_bh8 ztJt?gJfQ?(|Hsky3CK4$ckFm+W9aQI zp-{AuN$Ya!Qvq(r4J_INYj*LSR)o1KjZ@`&6y~yga@s4|nmh_c)6&q~Y9ilcz%aGM zx&ncO7MHx^?d4xmLFx@U1#z4Y4EXn$A)kmR`WOTtsHA=mtJ8^+QgA*LpYZcx&?O8W zlFCK^swE9K`2CR5L=k}T#V9X2s0!MOkpS+FM`2S2OVbkv0HGv8AsOn4&x(>(qo7WVHY{31@%k$V zmC8&V>W=GS>A7nGqq(L~*P2$r9JwEZeWMM9y6aG+@=YM7uybQb+!P@KbwUUnmb##M z&hq+h%PI0pQpeRgFveN|I!I)vQ60Ba7hL%z{F4o5SbsHJmhl*zWLqz z>b{fOL}Bd2x3Ty2XW=-m-w~;jCWEePSaso_Bb8r&%EMd)VRf!+1l`>k7>35Z!YLN* zj<8-nDnfzyAVh1S%mPL?jGGJMnlpB*_u1J=uN?(y`gAPCI z1g{zZ03ZNKL_t&ndx8nmj9!;)p&q)(Pcwn8fHLnJJ}1DDbbn=8{1Ha93SXW7~s2u82~Z-^BO>O{~Y{t1caCfb`mqNf9t(?{>kk@W&HZ8 zgEFGPkH~gmSasnUSbq86fuy?uV)}Wj`I+DbW)=r`=v?rfmkAu`%66s9K8}}v_%1kQ z51PhdEjD5z{-#X9F%EBC)BJ%8gGMxHy5>LA1e&It*ZAN-(=})sfv$0=6GD({$|AMs z4}!AFnpc3jABU0*`t?<9vu4ejo_o_NgoezakMzIrt?9u0@UH76%mLokNnx@f$yDdm zKXBd3lL~VH$ann}&RX-gXll+To?mwM%DTavF$WLc`#@b_F247?QNZx99kXbU!dx|m zON2QKU@kwCz1Rd!gsVSI7I$isy;8h1BY_rVY%_TcP#hl>~^OX$f4)Fi^5l@WQK9 zXgFdlsQ0HOWgw*oomA{yQHUTNxAAymvj8U-bo$ z)GS_q=Jz25*OAaEErOg2L$~DS?IM^zvW0NFs(XPrs zA(UsNLP_Zcl-$;=^79g>xCO z0Pe0ZXrqBs9&WWBXm|$74#vv?pjC{8`WP16BLGMnI+_hVLBOco$3`XflB;%7;b%e3 z``q~%{N43e1JLRwsk8D?Z1~yFG0-;}seD{gUv%a?tbO~(K+=mL=9P(NLhevj2T6VB zU6*6HZv=qWFiAa~Ng;RUb%}Q}c2;q&AL)PLdzsw))l-G} z)@MJ8Uq7-x@vJgs5CU;i?Hl%b>aAYP7Z#FwnOjxqKR@pL1jVB=etr z6+JyugZYvrd8E@iMn~N#!5jc=heFr2NiEvN2t1wEk;&;WO%18E4$~wkmuM*6slZ&* z37T6>w6vPO`_&M$rU!G8NbEcieFRldCK}5{49ZwEQ6;{pn|#iRlBaqJA&K=1%BaqV zCS>QAH71uR&|%7`q7uxL>JUE`v~zT>no?kJ%)yCa2ZjcuOr5Vqr-9~xLmJW&UaUX} z>@ECfMW#!T(lzKBLD^02EJQg1LplD}r3@vH!qWAKHgUpUNuEs`d`{h!?@XYbh^BOG z*hTN&H*o&i#gH(m@tis_nlZQA#lBsKLB*6nWKP|(Osu_pC01PV4k4$nSgV<8y^Rng`fN`Q975l`;Y$_0!U6Sx`udBz@VoD-pGUZ91s}L(dL=sNoPoCX zWzfwzb%FVo=WfL-+fMk`PY!d#&~U*8bI?7v1G&73mSzpbq6gdNFX3b`7suegGZR^~ zGX`XG26Tf!-OpUtHCQQvq5^f%Q3DghJexDn)^5SHw3q}W%cj&_exKlca45RB_{0G7 zQ5-rRoF_7lI=`!?6RjKZ)$c0QLwS+pb>v9-XN^3!+ms!MwUbG^7mzn=_)wyZsryuZT92v!4r|H5Oj1k+Mt80@W}ytpA;b zXl-jku~TbVEZ^ zvjJ)8F3weedCJl-YjzsVEr$ORCp7(xV6I$4s)c#@c&z;so$?iL%5{!D?Pdj zbMZHE-d@C2t`C)e8ZZx*-6`>8JA~6q+>+G)Uvwz;^%k-HjWLWBT?uLF$6bXtL+luh zv>V~FG_}qvyKYaKww!gd|^_){*eD1rj zaLF8{5Wt#CmgDN{J_D=s9sV(OF5L0c5!(>^zw0okKJU`6@OuZKQFH39f9h4xNM zI(A9|>*O$JvGa*A7imSF(aJDSmdb>YUo;_F0p{Y6fV#+pM$Q9>Na{&2R-hlfRvA30 zQwFhk@zj+%R30ooOx<-Juv<^cHcT$OiJOE$2?G@~M{Rrv_^|e=BiF|Vg`Q{AX z_6O^5=GqVVW%2-K``0xd>RQtpoVjXY!=YY0zBRZDnvrl@mAfw`cc8nw^DmO_eXT;> zfIi%}rwy+Z?G?v!@O0aUef z=4&sShio?OL)=EGWTRAaQ7U^V+Z1+*`dcz4!`w1;q*FQ!gTT-=n5G89&|v5UhQSR` z9G7Bj+`+)GEq6r=l}mxS2u&@fd~SqvCPKc+KxbD9>9m#zf$6~?EKVy7Qq=M%mxseI`JM%7j@usg z_Z4t_qzqSrT$Rd$w)NyOKX0OZXFyih(Q26!Ps@n<`yZFl89<$&HEl@MH=UqODS)rt zvKeC|d}pwFKwY!u;+kvM;q8C?el*X!LV@tfhkD1w--Ti54TbvHXaQ{Wbq;f>+mGH& zDkXREHfD2{weR_R{*n0qYLF>4w@ds_-kO$Ik= zv$#>4X(U5k*ZKU_*tm;gF@Sm{gEUal_>5^`<6M7_P>zO*&Q;%)@|6hEP16 z*!PMsuK=?uVIImWN&QY480G7*Z5wcGhEjo{EI$rHDwQr&*t z-BSkY#O%OXt4{}|w4qQRKl+k#9}}QXbf|Y(ys6h2YxzP#%4v`U@Hi^ZV|&0p+rI`6ES1fcZJ+v}4}FtsHrIIzO`K1`H34p}q5Gn7!zeFs#!nM{Y38w>)<%4j&O4 zK17O=0P_X&b69kGcOaGfKrffLWX@qu;W%O&R2CYH&7Pe>d%Fd@T*(=Lhw%8)kLPkL zSI=V@7%XG9nUTxOL|N6KX$0*ZDVRoNgA_#9GS3X=wnx!dv~gg}MQ_Q$ak~iS0S*X% zv^@rR45m#1m!do0gwC{qxh({z&En32FfcD+KvJRJ zYP?u`snO)Xg2n0}eatKUv52SfCD70eZtN(gzQRefP28|IgP!QsB;7}J#Lulm>gCT!2 zfUg^8E&u}zPH0IaV1O|f#S7YiPWB^Sk#hmyZs&334C=bG^i z;|yKH+O>1wx*kd;8+MtZRQ4hR0j{bS0|Lk4d!xG^yoD&-T6 zC%!kO3^ZAWY}=@7T#=p^YeQZr0>GvWV`T>dwK{+%ONSNPPBTa&SuI+*a}&CN6XOn? zsAXs@E)Spk#D!SAtlQUG*3bEjkO_%!2IIqwJBslaIE9?X_|9hPQxz7`}ko3}nu2Xg9d<)a{?@iw6_FsQF;>+I~TsiT>itK3KWpa0fW zVGaQI-+k+(Y1dl)e%*D`-?DU~K)pd6*t;pT)nmDAW7lij@cK(1LTTh7r9h2^xl`PV zd+vI^YM8gQnmBLuLO8Y?lFWrgd#UWfDF+aDd{w(;2J?*b=Vy`4rIAXRNT)4WDGh1g zDt)Tz_hQlWt=OjybKZv2gLz+}j14D-arf9LHoM~}>P8seKCpxDfSjnMkpCG4ik^qp zj*Q}t$B*FY&BGWkxQXRZ@54m(^<2O$GL%R8T(;}OJZ1pL!vBNsarJ%lTJ^W5wr@hY zgt41Qnnm&q;_(%_lmgTN>~Uaxh@mtLI0aw8Bh}qApmIKy4D3eBE>09|-#T7DD z#k3fYV`&8K84Il`16>&l?HLQEp5%5TXyfUs-#fB_kzD1typI3&y_YaPQaYv8??*R( zt>)_Yl^2}@sXA|v`n}Y%!M}yNavxdbwi1A7e!Bu1T#WB|;HMMb%xQ$0JC@N5^HyC? zr<2bn!`vzCz<+=L$8g+dpeiHfCHPEzd!(a~P;-^2p4ddf(RWLVA4eQn~hOTSAM9yJeEb{f@r80$6W+>a9 zoHN%n0$t}LUIC)>&g(`l7d#T&p#$|5ijbWYW8xftnZgDpfY|PeXauGiUD7i-%){~H z*Yb7_A9E)gE`*PzmOg zGB6jgiwvHPm~^SCoYkoY^>|!;ABQ=Ywv(@!s9l8=s~#hX@f4+`7zi+~WpK-YXA@8l zzIs-@K6&61&nJi%sOA;8GKPZd!P1FvYZ9|@2nQ1TNq~?Kc=dRtYgs&{#3SlCjQ|-# z!+3(~U8d_7*P{$OU+uwVmoDX36OkjIGN{Mas{mE_#ht(qF!`My*D!kUHr#*fx3T@@ z{aCiRA7<;CnmL~_y55Dp9Y2C&ySy)9%ukySG3()c#&KQbX0MdecdX+gqKuI3KnQ`6 zO3%02&iqosZJc(fDbV|mKJ$ru^XY$(d^Q>80Py4kpTOp=+!IkXz^(<Vr5)Jz;@v(VD}RQEM{%s@H)zVfj#U040QHCYb5DOCd-e=f1#9g@l`eGmS7E=AALBKikB%%7ctZUk)+lR_!rmKoe4pCd=8F3EM4(2Ui4 za>=~nz(;|6^w>m8&PauLNmlPtdUpY*#32s=L??-5PtJ$L(hp4o`=RJk=o$%uIjJ4h z@~H_Xc1d-Bx=#46bEO2~CtBX2f(LW#1kN~{yD2@{Pu;|qFumTwP<%^TR(<7>vTGebjCs| zWg(rmkV;!KQop;d3XEF7Jied#q46T_wa0M6)FP6$0&l8H+=zod^c?}jr8-{u&lnEA zF^UH^oPb^SRfQ_>JisY%3v$m+f=wlu^8=Naf(5GPsl!}pza*Gb#75J>I`jCkXqwSA z>7K)_=nI1sc7ghaO3C+`PLRIp07nf&We1~~GC_^boC=a~T<*mYDHtTkT!PD}f-&w&%6UG|2CirDw;m-%%y zQooyLeH+sqL%; zi?4}czU`Sm$74?(j2*A1r2g@bUQie5yfAPlwr|@wsdOIwjE|S_#=)0hX9=#QYz>FxkY=q9Jgo>ry1}3*I#y)FD8mnZV-PulDejI z3B7ibxws~P`LEnD*hEVPc_Of*U`JdUPdXNXda>x@&|w>=FU<1gb`eS_Q+pZGm6Y-42Hfk%O2$wQ$?Vd#OeP;y&U zhG%deA~072Q6=+02Crnis@_|YkT-P!x5PVD0s_?rta}l8cHtT4mQckUk%S~Ifg4PSpd@#25ch7`b+9>Y`+_i|MEB3zdJ5W z0K9FF^z>rY+BG0%d(9;E&eU(wv-g;kw(BjaGmjyk8Uo2LRT{}REL7SsB&lmUQrTQ) z_vU9G=v=t!Xwto#YN*+=H7lL}a{OhP80G-*dGJAMf-(T8(&fl*p>m;=E5KYs|G7jC3VFmG-#vErQhD3=`H_{~PS?4Vrod{1zJ zRl4JH%X7KTI|1eZkV>^yQG0uWbCD%&TCF5=73KgyaHvqgue>qXL{E^&5vbHv!?y}^ zyoyS-X65h_UkC^20ZY!56aU+H2KmIILPHw-vn@Jh1)l! zP&1%s^9v$-j!q8q!oW|lZD&+fp@cd>{krSUt1jXc!^rWk;@HvtXe0<7jH0T}3NY z2X*04v$ik?Mr<2Tx4ds|xHOj)jRDOGD<7-&H z<`L-aSJw>ctJa=@jT^QC6b*s;$j}&CN=HC43zWJgK%JPucL43J)6eEDFX;Y^TK9a@Ts@sZ0HL#v++ltS-S3nUrxNqQwTLNic4qOKNkF|4(3jA2R1$5Cx1`4zLHHY zdGItQKL4KoQH3|!X@vfsPhn(uJYw|bRsCu2XhyE>k828Z#$4QU=Wk*iX(gC1T#&=u zd0ipNyi^j)(>x#MeBRvkJ;8Zi++TZ4waS2Jp4ty1y%m=a@tymAfT6n&W5WgC!@Jrpix(IXmvuXHW^QRfJw>4~|*@F$3)X}+g7|J-Q7 z#o^;6yt;c7n|F+0{~JXNjk;;48?=QYwI^_0(DoZM6FZ|S#bD8ixow>Z)C&&9iGqW{VlWj`3F^_R?(4I$>G4JaD&ifLq6!#+62&j9H=>4n!03ZNKL_t*4 z13U4katD2A%l*;=Lq8Sj9o=(J8yFa<#@J}WFk_Yb@QF=dZ0$N9Q-L{S4u1XMj>O?) zz0~hlUpW_M`mCzUSZ(M%a6N{H#wUo8(0M4|&swn%W@bfAVeXW+;_=7!1o=$>a{yR- z@qE~}gJMyr+8ybm-M0BMHPt1nFovU)p-|*5UMs;I0Bpy@w{LzPU%hcNtlS#^=+xEk zqvNhzB3CPzQ^v4otcU@F#9g;W;jS}$=s!P+TbF&Yin3P@@94S=&%gKrENcov@Vvy2sVefx zyut|}lgK^x1t-`A2G?d>4X=|BO2SF|>UhNQK4Lq7Wg??%N=zigB^a^85HEQYqqc|k zv+ssP z1L*G^l4asRW3jR(ec!sJ2bWy^IP|u+C`~eb^*b>;F#q&9*!x-!Z&Sar^;Ex~IC2=X zyOldA-NA~QM&{Ht9Rx0hcisP=?HB*)A0^zfs>6(dp2?r~zNx}|_{dkVw`V+9O4b0V zU-kByXf$HsrRTQAb``58FaW8Pfu$=xR#TXRIk@M}M?)RuL@-~zycw2d`t#Jb{mY`g85~XulPRh_dD~+WK^Jr-{ zkxm)Vbs&>AKnPQ$@UWJP5TKH6Sn@l>pOsRX`o?iCM#fwW43#l3gsew^lo?*xba(0 zFt9hWdrSb2c9O`Nl|lMxh?esROD;f?(q#kKxkyzeR$ZAD%wc=dJx)?Ah`6 zvd!xa^}=WgY^>h6W4%oN_fE$dBg&%g$N|-JHd%R3n)8?0;CQ z+9!i~XJ-nF7I%l1rxgnU%vFo_K+R4=FsBq4FS_U(D8qJWD8KQ7izCMi@O-uW-UFlf z%=LeUvHp9eq<-)1FX6~>ZmC~um>(Z6U|1uQtTP9e{?Xa^&B|}bGo3-0lkUWg+rKj* z%ta`cbu2tBhxS$r*^G{KDzXWLAEb0k;^%_+$y<|(?M73UhD=(=?9LRHF3jP=RqeR? z(pk82eHX6&oi3cevK6OwXOPbrF}1r;^J|2=L)8g^rhHtF;lzNA{fCO^?JvV|f;nIT zAvH_|=HgsZbE*Rcx6HxrCdeVttHYWAUb+$6si=MzFz3HXtc;W~6suIf7hMm>3uOs& zkq20itMXL_b%rKE2?~I#-nVbw1IB{(td;t`t$QVA&+G6x6_k^gRV^%0{mRL5Zhg52 z?!cq|!I`Vy_2xC0w`f-EKGakFUO4hBpqcTTqy8rUkG=Pfmh8CiJHK^9=kAx|%zKl7 z84Lme5=0=u00spHktGBI-dk3~5+Z;pp|EFH}WLj_QTi-V4(C;?X-~WLJd(7qL0^<`-MIdSe|+E3Jg}Vs^fXkA3XV@#mlV82r|Wu25fCs^Pg8 z=5hTdAJW)qm;=CNkEM^D>mKbc#h?A`A0;mu69OI&Jo;F$QlT2jhxh$7_W$Hv8=m{h zwH2XNr+KKGj&6DyO}&1a-X_zvUkuta=4SkXz6=gb74YEe`tj(ShVke_!?@#M2_u6U z)6>EbXsj}{8~QQn z*E3UjXK1bMW6cY+RG{hw3g%MMjCUz65ecY!G{j0%thtaFgO>j#p|1NB=y{7@k}=@- z{`3si*BZM5^+(=yugaU=;Yo*jtZV?D{Knr!TK5h>{m}jIP{5Y5n^0f4xg6d6G^iV6 z>Jijkvi=*`hHT5^o-2;MvzPsJm|uM1mr!q|tn0f==J&CYJSJ}cyTQ`_9#&E|S-2XzYZ!V^%MKDkEXooPlQ_(>Y72CKL zL#w^<5X|2`HiN%?>@yf0{ydHz>Bq=u4z_C}@B>`Ax{k%AHrifPPj&<50C3G~341K- zsHNZa^AF(uVz;G>iT278@jrjLCER_`RA2zW|Mq|V4nFkf8(Z66xmL%)=@LJGjOu38 zE13oW3?T??6&)-+4>W~(X+tP_!|&Jx<)VW^zK8=;1=Q*Rme&HzFSgKZ2H>+e(>fdG z_eL{7vlXCJa8NEeaP0JVUe}ZpW9o`(F{sC(A1ja71j2wJTLj`Oo|<(jGG)u_G(`}p zzKnyKA0!>$n0f3*qMP5Fo~SSK;55@ZgJFJ;-!gp+UN^tX_qF9S{PpLb#ZQ0qZEBC5 zGQVd_2XNaRdvN~r4ajxf5$y(MlqXt+Oy>KAvsQ>g&y)J#jHs#6h9#6zD?^XIL8B8AfWdqLJg?V-5S)4w-+7rx2 zMsgS%AL8TYYI<7IquujE!=s&poGF;gu#-$^>%B(i(q(?Jg_Y_&hKI9ag|-w3?-I-# zUVvrFLr5lq$jA?2`0XF*+-W8qn`*NKc3>d@jaO{|z3pE{(V}f zB5j*~-_`Jgww0!&`5s^BCSM`2-L!K?$C@2C4t0-G1TnSST-nWZvXkvxs*OZI-P1GL z1JqduKb|<$<30-Cc&Una&n#nPa!_4hr=WiCgNJec^bL_l)SY1Bx9L1!LY)D4@|)kq z+kWCvk@@XI{oaQUy zd?EFLZXjC*daf||v5oeL!`yG3!qdl=l*etF>?G7n1s6x}|Fw;>xoMd>_lsCwX>Yt^ z2f6>jBPPt5?4fyEf;mHg&wuubo?z~}7VbDYie|GV=9~LywZeo)yFP9n3awn4+9~BP z<#u5X@Rwt7D09nU4sf7*#1eDQksLdxK;NDU-rwJOj`?Q9h7F4JP_6s_-5as+vwzd| z_;VLmL4!8x%|HN~h-qc~V_V$7A5BSv+6Um{+Kx?71F*R4!FB*ZZfCG9-e_f9K4q|2 zbWqIMC>0$P^O5>0dCn+z^kS+WM9|OY9AvW=2K!yC*8?oAd8pSzP|B2bA&Mz(0>0%j zw7meOqK$mc92M*ib148xLAJhTTM^ex%`~1!8Bkwi$mI##Lh_91+BV^xS^;y?abFYa zuFV~xx&@zcEdphr+5qa@K1{H8*v0r&yC>t^Vjg^cYPDi;JZcA_Mo0S^hFMbQ_HGe~x1Hk_MMQ#>v z^7-a%0rOTXFg)5#&73cfDz$S49z{#Se5+zv1VbZPIQDKVw4$9S)qKma?9=CeT+Yq22c2wR}vBd04Jp$BiXEOC;3t1@QYU@5$_% zkCVqQ;;z>p+Ht7g`_K^s=;j?uOE4SpW8Zrg4}aj@kmKjufjV)AFm+%I7tdS=G+^&0 z)am?JVD0%S5NRhN0GM0=CkA!G%|io2L$AjcWlK(RYfCTvGuzH)I&DvbIRJd+%O|y+ z(&w^D*$GFv_kQ4Ao%h|Mtlj)yap{#64RD+LJoqLt7Mp;%97_*31#>VTU;68pdV+bS z;$mWQP%XUDZc*jY?t3iZ(H@_kMk%lKahPvaJ0BX!iqNsQ9_9eh46Rg;cHJp%_`#{I z6fGtZ$VrD+?!6;#-|#F!5W;Z?Y@0VGu5H1!E!Y-d+dSxtZFAV$7U0?hS(osY)NBIF zwqV;)U>L_HaBS(c79G#M)QRXg$lx-7=Toe#dAM?;iAz@+xH8kg(kk~U6#T`ln}&_gS~P$>+HhN4Z>S3b!3KJH>jrbdKu1Pz2Hw*Pr(Z$r^f7=D- zzGi;!4dzch{yAeMwN5YxfFnnSq8RPXuqTgpT{D*+?K=VUfx*nH3UdHpoz^$kR#FSs zdtVr(y9h11!`AWaa8GA(YzvOXK^{eG6Ck$uboz|L*O9j@0da@Gwk-vE$A$p8gtqif z=i0p7?%0Sxt3`+7={&q@y+JXz(!vh%%_PNMr zEZBt4nYTq5R363k8RPTgJ-=6&%d})$5$#7((zt{Hu)a(|Q$|P<*CFw`DF4PabAG*b zKQv(-gF0ity6~Xy1a-!M54?2{x8E_1cFTw7`S9C5JU@Wvaj1g?)}aPnr(*D&;BjIM3AX%LfszuG4u~tZW+{TYjv>Z zHSO7@K;3e9f)!<=Tq*r(@+oaBTQa%lOOvTfy>)^)0KEJ>Hzy`c?QD05!}=mF;9J0kNtkPdUdeG$iw&8qWvgZacn9=2@> zN4P*}=B7uxFSK($*WC1ImoGrvqkSt>S_#!SxD~a-UYpk= zsoC2W4`QNg?Go-pz}v~$DCBJT0Yjt7>twpqoSt{UbxjJ~779$F}3w5qJ(ML$&Rrl650|vYq&EYR`azxGx~? zc|LsKN8oYC*2$qPM*7-VSo00dT+61+M{F7_SySdTE5=^{Wy3d{lE@ozm9WvvU$0bpXH zWO%fDUT2T?FvPBSv;#mc=b*no^O}G;W9S?mjsl(Ht8Yir{oH}s_F`&!T*iiT$O(|! zjs@2dCTcO)JDUGZ6v%B$I?qLO!{u1IO@P7vC~}!>^eF?{tq@J&DA^MAg^$CFeU-y5 zQOC;Sg&}X$hygvbwPxbIw`_vE%R3~VPf=SB5QNbfJii7Y5o8e{2ziIVvNoZ5F+rogR3t(>bH&MuvGOEph1$5vUgq{VM=Jr*&Gft5Bc2zJ#d*+P#)gms2V< zZwm?ae4*%`{mv(T?8w_T=k2~}lY6c-{;%R`8^OG}{5iaG%`~?sOzmvv%wy zWjJ|q8B0q|v|1tBZT{h&?a{co94lvx!Er3OV*HI^XFS>+*TTS{``Umx7_!iu;v~Qg zCplpLJ6C%yUzh4DuGtyrUs-s3!}FJlSriL4+zel+Mw-6m$0EsvR+KZGa)RS9Pv$H- z-nI!cEB#~P?=Ru5!(~kGDPVXYgF?>HItY9`o>=@7E$R}P&$Ag`pCFy= zNXolQfPB`**l-3z11>VI**UQ+s4;&Lc{SBJHN6gP7UrfozEPv_nkKv%0}>Ho5|tq4 z)s2W%LCCP&46so5uvl-S+V&CBC=^gUck!rdH)j{oZutnj06`GI^8*B4z+oOR_yI!@ z0;QadvA#^|Ipe>-eX@#rttHIOvi#dOzvoM1IDB+Mvs1*cADQ1-;yx0*`0P1x?GW2F zzY})|hmLaJm?&_ zY$S(b-r2TCJHW@yBaJOee>GqZ0E0P_I#o^A(62vrsbhK40>yNLde~vg8UXy!r~ltB zM{==kTWHprr#d3-TZguuqe#m&gS^;8hkZN%4AD=aO!k$MgVCWJ4o($t`@SN^hjXYD z9i9&odEZA7;Ub5(T-HK=*+D)hLdI&>21JL#A|S*hmhB#XYX!!>cO6ClrL+fWXI zY4u9VRy1=}a4o&H&J@&@;tD9Jr}PCnB_yno@v-uF6R+~7J=_~N8wmUWUR!AAK8JY_ zFtP3efiEIEP7P){b`hn>KNkpG1`9Nat;3S*Tl8A z5A~^oTknyETGgj=JK)K|izmiG4Mz7M>pMmR` z4J7dD!5jc8xeQz{P#*1R%cTa@0Kb0a4?32sSEvUFJ8I_uaP~hv)p47Yfqs{ROq+YI zo5~3RY}-Pi;GkHrQ7kyfj|SKJ2P!TmMsvvJ9O1#wA`Q6QdINWQT3Wgeb^Z25^~+38?3lK%Oz!}7b?;+PfBeK6PM)1dz1c$GhX{iZK?rz0 z*UXh;YslxmPYz_eLS5ea(=#p1i_oPz3H83=NlfnTS7l2WS4grWqsw={@j|Rk+&a{A zxBUkc%lTUd^_y200Wc6ES6R~wsX?7YntQ(B=FUI;r*e79o@7%%w=7F7S=KAeo6DcW zWzF2a+faYgLnA%qt0&n6%=Pum?d%lpd-HGLXMf=nc;5%_!9DkX7@LE6pnVUuYcqiP z`1)6lZ3*Vlizv$CKemBN6FR-ZdZR}t<)W`2(He;i&oW<~97JDc1 z*fUD`2S zt=a&jx4VA#^#@Dr#P*CG{t7lBn*w^SF!ElYcbEgf%g=u);jy}#P=D(?-_mp5x=Jd{ zeNjoQjxaZ3v$GHf@BBBgGm~3{d4R~o&#%3^>hp6vCz=IQI91i#Xii>Q9zpT;}FU|WhpiM4gpoNm)sos-uCQlJM8nP!b53|LgJWQT;2 zXdGBem-j18Izc^YmXCcA_on4hJbP{(&tF)F@AJrYJbna!ra>4v(+!tgBU?;dN4B-{ z)TeGVF?(}m$Duwtxd-KnbOwvAX^g8UG<5<-2pVmQi!Xg2NGMfXgZk8+ZvhqMx)o4w z-S~?6Ky|2-H2-vla$luu0JpgG+(L(8*q<-&J-8W|g9SKydWLsCZUNNChjZwg{Lj7T zuak6zx%@8YiFSZFe1K4FT{BO=_Se61Or(iJw+M4RO~%ab26IaJ`1)q0uis4svUoLN zzP9S)8;{MRwjS`QUo8SldA75phE5p}0KfZ#zlJX@KHjmMowRh?1?B+oU}2=_a$~IS=RsdCok}OvBOZm@4+Lnw<0!n4i5ErYr_b^ zGv7NIwUgU~x;^qflq&gK2KAMtT1qRy#MHHP=^GgxURzu1@3=!udY-nnI`_oS42*4J zp%WIsZ=S+4&o8StiNqTAw5e*_nbP*AhevzQUzdCXy~3P!hPgNwhdJ2>%%h6iZe7OQ zT+4W=blD2b;}Guz^Q}m!=|`%W45Ur)(9dHN|EoEbad+`$vO}{mv|%17?5!Zh6b`KtZUl~)ifs8 ziGWKr!1KnCq1g&irwkdFAeVFC``jla%Az@^yp(qkQof#mt~u(Rj={bRiUo?L72c2& zn>R9y@*80hpj>oNs|N^TOS7`5&n zlIP0+6A9<-O=+7xIF3x_G}`UBlc+f(KrU3H-+^m$hyXGK001BWNkleC0uaq{>jP*7N+3qc5WWlG!pjb%*uOJMF$ly_qudQu1>SU&gFU+8<_ zr+zDShnVyXbT^a#DRBvGTr)Y0uAl#81o2w{^|!p^kzR|_HQ&9#T$EQW z&h@A@8KZ zO6qF1MNr7uYAPj9)g8qcvaW?aV>!$&c?vFSF)QJ9-(Sw4*6`78n{i`PJ6}e2L%v0{!iD%B^EgyU* z7z?%y_35McP9AZ!2CYBU32@EU@rG3U0^O3S_!uW^LFbhPM=-_Z)Cc|d~%|I zk&&!fylui9*jVe+rBX3N{r3v<6PX%5v&Y9XgA{9-OiJJvn2=6eTt$!mMz!M-^UPT? z-7vee1k|7Zucz>bH$K;r^#dD^o4?kiUT@?1mlp9SU%Y{p)ixO6&;&R* z+CDe4H(PuL1yiP84wWF}-)rjuuHS58X_a?~d1pZU)y(YxkjvP}XSrvvKE$Ti#JyuV z6mqth0l+_%lC7NY`b#cyhK~qIur*Ct*a+qTe@SLN7k^ZVk=3@=TpnO!?EvDBR@^$#6P**R5u0{ZI0i*I%_ z<=EQiDK%4rIRJeB*iy9jE<^pHhsM%3^dg&rxjvmNZEU>LdgcKbJe97F?*Zmu0iOQe z^WwLebxO_Gy}vJmhu?e%k34c4-u>=_xbtWqa#?%ZFsFLG zHUsm=CoFidOl{k6Sd&_HhjfZAutyTs%ES)C#2%&T$MEa@AHR{_S>8bTQu1r3{|mgv z)|cOXwZ-=X{LQ!Ku(IkYO%906w?W9zY*Vz_d~E;#Dgcap6pS%c*L~cWZ*eEOj1|p^ z7jxA4aa{A`fow#_6eje8fMTdWgHpkUZE@$#zLEpiC9rJ3vVnn$qoB?uf_gg4lZo*p zJyNCLX7K827gQ#93hKpD0ekjF0Y|BEQ_^e_k*v2VuDtve>=e}Z z9U6~@=yn6`5%&EfhrdODsx9WI& z!a^7aaDW)xJAgcqru{Zd>G5q^dMeb#U)g9fhV^F`l7-oXTz>M*wvK--i0=pZ(qnT7 zf+!|@w9Ywq+@lQe1EB3mPit<5ry|&iBf`Bct$J8q^N?{Z9&wI9)BYon&s*0HRJm=>kNJ?R@Zxgy4?SV z9vZ~2|Kc0*k)OO555MsM?tjA+-tf8!yz>FRa8JDBp$}g&F<@WJSXzWiL}8nSb{+~I z6GBkQI?(tGAPW7f%VQ_1+FbaZgZk}9r__C5h(q1{&D6c)X=h)$BHH5ZLw(=T`v8Vp z0(GzLgRMN(xx+$iL^g{E>S)jZi%y5=(i70L*@{NX6sX5w4gfDacQOHNV0WNCF_c4P z;@8tN-%Yx}eCft-;qU(DpJ3*~Z-`6AAP;839MS>KiorZI;LnfuHU;zNp81xsq8gBd zE@Qyq+bXD3N(h1wVHhF^cx>k|pePn|IC^vd`}dW$4D;w(JP6G|9|yaP`~?7|g3B9F z^bYeD0z5tzAk@dN6ToJgR<8eM9pIkwyQ4Wh2Ja32<|j+Z0&PN^yAw+x{Jj+45AeO` z)>J?nAbOwmpf?;OOvPuXlqt~KgpVzHKE?bJw^|hP+*}^5-5#As20s#gD8Bi3&h0d9y4#zQbNkU^oqp`JcVB3aIEnt5CrRSFt!4!b~|F(99_@yj1Qiue4` z>yXc9#Oi4Qe9wp1_K|U2ObnW#TjRb+0MK7_K`Gwsrh#NnW|Kij_4V z)tZMOWMXc41a$dbMzWLe=UOxo%f1p79A>5Jp;q%zDLZNr86avS!jQqXfqYKJg*O|9 zAOOaPv*;_i$hfu&YNO`9TfpdG7OtCYWa3)5nFf^)o|b+*V;t%UNrAeA`7eF+9!yV< zquut=_QZ;5o)1r~ZSMO%?meJ&B1yVsVWiBx+oh>J5ZbxS7X{Qz5JLFxf~z@!=^Z4k zyp#dod~QvHGj;^(8P~yqL&N6%j@?%RVvMn?4h?{FFP;Pt?g-SU4~_G7`xZcbX?`tH z9&;Xg66%$~u|4QPHU#?m>ZSMEb|#aoz^o(8{pKm0JX?*jx64q!^X{H~2E=h2o7qpD zUQnjG>Z*rlp1Oul{=wJq$G`tk9Dm~1(5ik*oGcD=`Mn#=A)MpdT6#Ln=VneDLl;Sy z^U8JPa2b|GB9Moahl315rLni$p%F4xm#x6OQ<|(*y}%p*uI5+-^0-DGU=vz7(&0^! z4sZkH=mK%^mjaobgU>zkd&zEC^c1*u>f9kfsk21f=10A(mA=cIdG@GHY zC}}2mHSQgGqI+!$M&zn#QA9aEU|3xCP%PNUWTFLKqyzznRv~YxPJ&*q`uki=P315; zlu^*v!_N`|OpfMMm}4NVt|p&El;gy zE*P^e`Hz6f?V&8y7y6fbVWWy_9!w;NDMm%u7Ogfcfl&--Oo=#p+Q| zt4I-xpt|Pcd*68lpZNVx$Ya?#wxY$ey;uQ z=Fx5dTu;XaX7}h*8ZP2Xm;M41+4S(jBnEJ+i%aw0ed*hH(=s$2SR{K*)gCl0p$A(g@U6X4G@$| zHgW|%g=p{I945zd+Tu0Q^&N*`?|7a&hNae3GcnD?Ew=Ev@3C!OgCR(Z<}1%5_J8hN z4d*Ug5U*8nC5v*<6m=qouGEV(!`QN*79tmf6OLq}-l zI*?>W05}#wA!7oCY30>x@E5*(Ufi3VgZjWo1$`w;T~`+!;*t41%F&BwRzVw=b_D9h z13wQZBO_YwKGefGK2wII!dx%4xD&*I#p)ZbzP8~!^jvY|f#{cj`UcVB&Yj^)PR8es zr@a*0ou_`!U47_TdUSw0fA%U5l(E6-=I2{@?3-ut*f)O%w;%4uq1&f$;P8h8%poce zfiY%oM3&R9O%pJ0wU)3jFSPg$Fb9A=lYH8R4)Rdb)H&oS78jGA)vq?p83bU#(lzps z0of4u{^N&1c-LLI#$=iY8V3*pzXn08=G7%8|TTX?O=a(8g z1NtAFgfp1I+aK76UwYs-JHot^=xbr?GMXR5-~GWc9Q*B)I9@%8KmFQYfK@{znl(9o ztlu%=qrh#*BH4-#V9J9}9>E7dWGDns9Sg zTJu4}C?E}E+$vBg*l09D3=X)Mn#ijg65qe@^{e>jKT#H@_5fbn7wepd2m>a<^YW;Djze(A zWKk@QN~1+s0@&0|&t1^LnA4frHJ?Qy-ri!qp42!ZJZY zV1a^(ph-JBPkniQ1*6lwjCd1BN4Y|=^zcS|ZwPcZH!y7^^bq>>%<0ISu-j07;Gx?# z%n#3ZCz$I!IG%p)+`Qo|(u-WYu!hBj2KFD;VJ^=r;Abp>s(D&6U*yR)_IdgEX#f#) zRXd=;8~_g8J}R_u?g$qKx|Ysi9)=9fmT6V#1asRW$cm|Ml=7t*{UGWucY?XRUx|^C zZZHQ#SDbaw$oW3M{?LEq&P}jj!-4|~HnBip!vTQ}8w3OnY}nd<7A)8z%@TXb-;OxO zh7CuUh3(k+dYAOQEs!pYrUGxM+==@tciLx@oA z6Cwm<48Gcf!UsjjLIh$@pM?k!!bgaZQTPZDAcW5Xo(76G6KU|^i+wy6;OqF~4T0|1 z7W(@$sMiD3>OR+QD6gZo=-_!iL8$4 zUh^^3pTSDi2cs0ZoDIf!xLDUAn3~KZo3+IFGE*=igkayk0*VC(^+te@G2ur-&}i^z zcax)8T%VQeBgA3e*#R!z$>xbrF8~dJR)Zl|B5D>&bYdu|UtehBg%_{k;Qm4QUI5>x z+}!SQkOzT?%^rwP7{OdkQDe{o$nbkF`^hp}AX=wR%ShI?k+Cg!A%%tXcbR}ko_qSc zr||Cg+|L8q>=4v%zjGSTe*dac$(hmnAP5t!aMVdYcj_wccw+#-**4Ut502x?g`1#^ z>^jsJ=T0)M=;x|s?%JsToR@+VU`@uVY zbi+Jt2Ig~@ehZ#QRa|J>ief~kEeWZA4&6QqfW}}huSbz;T30X!7(63S&mFs&47(bG z`S5TSuIoeq7cf`axqx{XFyyjP<>;oF%N47n36DDyi4IOTm@}9Q26fnvmo+*M>om_? z*VbR-(h2<*NLSPQYhDgzHryqo48BiAKo=Le95;j8Hi2c!g;+!^b{iP%bCJt%hc$g# z86m*@vX4tw8>&9az%`5k%WED6DlYo^G8i4oVPZ6gfqoa|GS^FjfOkN{5TF4JbML@_ zi$dN(A?skUl0`9ZBbz0#091-DMu#$+gL&K@ZETFbdJTrqODZJ%0@40o`~D)D^|o?? z^E|m)8iglf>Qe!5{y}675f%}pom1^SMPzBD3`h?V&!@0iBso?c?}L2p*b473(CGc$ zuKB%K%41|WBQ&}A&5`*?W}JcG#OYOp%`3b;WenRfzYk2lUbxLfi`nd!`F(Y%2KbAj zTq#bJKw`eS(YpdY^w)kmx_cYL8~|o6M&sGL4fR9&ipUTAME4AB0_F@pu3eo? zfZDcr!^A)6_&IXtZQAv8m}?rik)D<(3dTaLEL=s~GaodsOlI-+?W?G9a}MuNeJJHn zry9Jed0pu zY`70&;46Fyuv-Mk=WQO?MZHHbz&+6CV6fkX?MSCJelD8;^=61u7iucjH;F+V0B$a{ zaOFk=GjnY$EO}U855(Hvysl7)wpzel!hUJZ!kf16 zM-Nb!Uhk=A6UVnbhUZT$3!qaD?SR1#pw=|^Mft)2YGphM#Z5X!Q#rLt73=kLEWz0kD-yuErWVE^Jmw9=EKuX;Qg##Sci%m{L54O5bFdH>FW!u4Tii>jp+qCog(e;ciqL=HtSbeHa5%i?T*0ue~&^k zfKvqQ9O0HsVTud_hQOzMxI=Z01uVhM*bvULaRc143p7jgerXltoYnR1lf8 zqQs$12tnSlRdKpO{j*;@CCutO2lai2qDY^K`0ZL=(jv;8efbI^hve-+eQa`wU*{G; zeQ|D0mCt~BJd&IS!9sc9A#{x@2hcFmEh> z2J2N{%$X&Lj|Kg=*%%zWZA?3FCz#801{3D`{yb>SjoD^YloXgV#xOZq5ZZYVgSj-l z3k{t{F}24=b7~H58q8g>xP}gMSxHs2sZa}2k@Dhg2IiD8Fx~4sE#&KKR72m~7(3V0 zT{vnC?!OmVTk+7S^Ra#>PvBMnw+y%ifVn`^3qS~g>qOkf;p9(-A4UFBPuJ7+PmKz^<++lxRYAHz{mk_ygp#>qP%o777#Wh!lEk1+Vo;BS0C?&2GWay%?L&QH zdKgSJZo3Wjh1q3wzZKN24sC;Y9}4C2-t--~bZl9IAlUC_b0U6w_Xd@TRmT9}mFrFY z`tkhmi|!EAClCK}hYW2V<^XW>`bF5b1>5E!DD9MwW5v_>{XhRcVMtTi(JlDbP6 zF(!NevI0WAgq^(J?Aw!v<5&Xr0KiT0S8g_O@_Y?| z*$ynPd2n3|8O=AOwjRLqDB5ib&kM0$H_bZ)NvP`)>2etxW5Zb_#&A1U!E~s{_h%Gn z*EPpdW54LYv)AjWH$vgX9<6I0hSKpZ>YRtt)Xo?J$~wcFbx4N^ZP&8l+7>o~x))G9 z^W@1Lhx%=IP8s=R@iBc8ebLifEr!LJlREbkcbbyOrn`!$?M>>WVPRsycVi5~72l7Q2 z=+DA&Z3KQ8o36$*fO8Go=+TSbelc$&o3VHgKcq&FpE0Jb&?LikLcyIf82C{yrPh(| z8RkIbj@v0&Qocng$x%2G+jp~ickiMr9R%DA@4!}5xfn8#cZ-3E zI;Q=W-&ypF$}v(gp@*t85yM+}!$;oo6qHF1c`E$nDUSK)vB0YFEcaY8J`Ifl6bM?v zi#fw1!Z{X!?Q&lfkAx`oIe-tenpA1xgaGBDi-Xe^uHI;3y}>|<^pq!9SoZMpxhn2C z!gUN;eb%Zz$|Z+uus&}%TdfeTYhiUQP*d8BXUg~-_I%z(s}-uIP3|)>l0|jhN3+H6 zX=j*6nAj-?wlCr-P|7uRFzMCK zuPObdm3D5>(R@FR+d-hFtW~lOmKvTa6NzmXr^4gUF5`hWF_mxm?6>3nK7DW;PkiT< zWd8JWs9SALX*+-NDuySIs?G}`j%aH)=lyPFCNMBu!OCJ4pcKTiKp9{WwkzK6;mn`F zp8OC9abbcy=KU_cjS0ch`LF&|`3?X0w^JTvXAPaedo;R(>ed?js1?S9oI8726-b?D zmo)Xe?;c9-ylI$6rtZ+2!OYDnh)rT2q@ z>(kXHCUcr*9!6$%F(;MM2<%iqJ@A<_!AC1HNnodqnZtm&?0xIcP48h#hqz6_9N@kC z)bVpf=J%dtvnbvzbnmhd^9zCA4M}Q@X2*qS|HqHrdUm8nEj3**z;7_LYaFubeX#+L zQm`!0KjMmc=dxvCDCBG$K2YTG+^r~>jAa4yiymG)Q%wN2D%M!Hg-O5F=3|t#dVp3d zL_TjDEf;0NdCwwn96ptZ#BSZ8sUmDUJ?Kp5yPzo`9i%0+bfu}vqcvsa@&K>P>X#Q=n#B$~qN$h41yss*ERV7y zU?xeCW9ny4-VmJyitTFZ6MKgtv%A}x`pV7A0I|X102ig><<(=n0}g5ZAUa4#py!Jd zZ%Dm^s)3d;k4`ajEn0EDeYXQ>3$=}-L3+tccl&~TC*n4TIH04Tt4RD$wCyF5?>+l5 z3BeFBDm>N^`J7mMS<$6AAN93R#Chjer<9@Tho}rY$dzp6Co!kWeg2uG=CLt z1(;iCc~*43W)h%eI2A@MaMp;}Q%H zY&>O8mrl?z?v)34tyq0F-W!4-pt!Nz5)N??V2|F}fRbo>nuNM`{p1w6-l0xFP|DaF zLOlo>jy-j1$DzLe;IObr#m()+ESHv-5Wv;B06}wSpguk|r1HPpP+wW9MfX1q>iV=H zQRq_t*xl$L9f6)H499}OM|UtXvzw|^G73xOZiAplr!g~%5ylm~4% z*=Xf0#(+ap1q=^n#foXX4X`YN*@YHfI2CE?5**c9fLzvw=kvN+7vtxi$0EytRxb(R zP}kQ>$*q4~}csjz#O#rnE7mNF4rGFWyA7IM&voJ}~)a zP!?HIb`$Cgv#Z9PHlVJ;!kTV?`M%*nbdc0Bbl>;)+qRq1Jtfe`%=P|2d-W@5GILi(6vc;K1GjPF;w!sPyu8dD7a$l6z6g zEf<-bY0?)w1OT*rhWV<8O5TkuYT_N_)6*o(nE_1wlKT15GSg{HJ(sazHAN>M2F?}K zEdZC7+5+O@WMc2_jH!=J4k4Q%Xtj07nMII83=BkEoBuv@>Ix3tdAHc+sG%PQY-&uM zWX3T#+=u1GHCV(_9hKb}Q};a|ta<{Za<9763>3*2?-6fZ*S2f5+WvC6d^!H?QVF(r z^~*n=md+ul9}@K(=5Kt5_o5+Q@Lkl@@48z=!0QR-0-{}D?l(@L(e%2S)s2rG1)3Qd z?H9c}{d&@~Jq_kzw2uLEhF8vBiYgkCFqhx^`g2`8+9Q*D5Kx4HshR8Ax15S5dyr6C zyVh_hm^0&fnE7JS`1xjG4)M6UncRB|gYX*Dz_*v5UXBeBVx2Xy#A>)smvAAR!P)RS zF40-M63*dbcoVa96*uV$X6Q0*&?PL;D%Mzoe`p=6Y#pntj%JV3Q#*<6aOXEmGy=I2 z!T3ZDg`A^J@8pf$r3(#QxzZ5xz`2#c3wVdJTy)?R04ozU>y^chl76oOCl!{8&po z&>*BZdE%1lSnQOhKD9?%DpuH)65j5yP7(lIdZh-geFxaCrY^_PZ-u5FEPdO!)14P= ziSEL}$v^wKv^`RR?q+g{An>LGToURxuFdl;w*czX`^Pp1b0eUOgt@P*4J-3c3zIrb z(|XMLO^~tC zV&mw_sfIC4LzmY!Va^!8FM3||yz??`0p<)b%^XR%ckmk4r859`&ue`ur_GN=6Ux;Mrb48!+w@UU^&3pWEOiS^KhJK&2wS_ zbF*!{^kNlZz?AvD9WXRnAqrUsc80*o@y3KQ;NWx-!$PaKETT;CXD-#$JayjI^2JOj z1#HVwom0M@q1g^9U_m(~HL&2Kcs!>^sq<=&jOH5KUj z($szW@3=R6@=%KNXKqGYb{XpXkNlX(R~+WT@hlE=wU4yb_{PIsm|ul$+uFzCe=Qr1 zW5cnn)K9roK)!rW3d}|4A#N2gV9ug+@P|J$&*$({YQAN9?{#1>qa5J^%^5D;qn*D@ z=5mTjZM~aEyWV)jmzp#hv=k5bo?s4WW9LYMd;_Pr?y&9+<*yd-J7e6GHVd#q>zJi0 zSfVv=}`AWhFUvB)e924>HZD!=b0N#k+ySCm(kkNq%+ic=B`|v z6>aMKL0!o=2UH8 zo}Z5%vi8F0Fb9CXJ~wiH3*_{(bdPpM&A)0Ji&ZM7Yv;N%T$I)g=22yamew208N{@k zw6XIZP44L^BptVP-tyX!5EKpOVUbp`#_DKednWO%%2;{2r~PCfw7MQ(dDTNmB`P^s z+&saN!zGN0pe<69Z#F|5du|o$)u?=wGBiAjT*d;xU}p(zhu4{d(?t{u+>9?5b_pr) z%!w8F0fn?G0X*Q19>hl0$!0S|CTpwxWP00=I!U@lOc^jdm_ygR1w*>0T zOI1XxTIo+KMT9xNP##EKc`X5S-}n1%+sW{Z=nin5#6oN3FVSd)riVRt2kHm+6*qu+ z2U9$N$jnXz%tKIr9_@BpXy#5wP2G0l+iVOC_oc&}`H12?`T!Gany12?KhzhGpXXpT zpegSkPaN#yeu_HGqeyV3N4tc$(#|E+HCUUb_oPQVw3kxXT+(2!zgL@qIWG`1J=!TV zwe+;X#*RW#zIEQGxAa>l6clyV#wz1x^mL=_t&{yd0bPR<;Y+37m}{cC?wix=EMU)c z9{cwd`GQ8^QQ9bFc=owf)T;7b;-7Xvk)0 znmAt6a|X29q3Dc8vpGV_&}xNn#5{A=K!d;&tHzmS<2y}^W)hI@RA*9Qp7JQYI*T-4 z<9I$45m2D!g;ANb8j%QKLx83qDqjWNBVEVDax*|c8R~w3#ioyIt1YZFd=Bwg$-zXM zO!W6QYNr`vc;bmy40!DX)F<~;%z~xlD@|r*>U{SdfcoIDFuU(E)V;P3Ry&dKRY(+) zM1Jb73uk?Oy+2<5#OV9l+|%zK9KQo#er%W`ZQ?rs=3{;31yzZNWmYsfh9jXa3%phD z_oH`?V{0%Ew1>#ojs}4BLMrv zF&{dMDpRFjXy<`BRvwD!ENXgM%%fdRe@QX3M~*g0?{+!&-P!==h8b|PFb6a*cb2ZD z_sm(M{%#e`yN&d;+64d%6fO8@Ghak~+gbU`8(&8tBEyAZeRR2YI%OeWLmeUZmG@%0 zG_~;wHSyY!357SdyoAeZd>nVrXigD;5MX31gM79Rr_Zf{GH&MfeTt`_S;2!344_hW zRbBKML&mlE8s;_thrpo(M-G(m^4T>I3I+DX6%QA$)UkhWLDlQF&%hWp+7wC|+Fpok z*@drpwgWtHi`~HktG}E$HvuCH&FxeO`8jcO}Vg0!;8%rkA1vNVXq(^nh#Ao#m4y}Y43(B=6y=lwo5 zIf$3fu7ISDEQ$5dS@c`}xH{*d)v6+#2S2UfnFP=++kUgYAWK)Mi~TN~zs6k_ zZUNM%_Q@bF+kv@ArvYl!Ds0=i7hYXN-h`!0!CpG0>`%CQ3}fe7$eB%EKKhy;_|gR zLK@98KXYjvgZ&v43y$g(v^#xnLD%5n&91L{K~{XDM( zyAJim>sK(ohvzN`R5%>9vajK2FeD^p#uC{FksF?RVnzxm6~q^^H8O!KD6F>}K_hG<^^%48|U)Xbq?R4*)}dSSVzeS?7E z!nt)^JYPpPZzG#?4X3OpP(?Q5z_u;pwW1+Kv+0Xyg}nY<{lW}Nr5qf`R+^YHBWso< zP@vTg;0J+`{?*6lQ7Q4rcTpYWelhWCYTK64xt2oWR0S|J;9zpZMycqeLVYVR2e{ci zQxFR!X_`9G&bi(W;N~+%8UO^0q2ULpdm+3q#Rk7csO#SBa$8*0k(zqQ7*4-<8Ao5Y zf5)I+Di=^G*;uQEUAwu-Z3I^@&0_lC7zhcr1@->nvbfi~5B256HH>SeQczcpa=LH^ zTfy2J;#(3x&*p{?=xTj*o3xu3bCg?JY)2;dU50wD|3`X&dBAh5o4i>7CcUdDpWa3Q zRIBxvhOU>mvy>{u7_`L_eDF+bfP5h+g&aqc1(FTPnKLuSxpk;YDHI$HE|gjqT;H+1#EJ z;6l55Fqo~#+yZdw9FWhu*gKlVKws2+COZVZ!5rXiWau;4u5Ja?G-D9d#1ga;Faf1} zjdV&kxYp*OE=SnRc39Y4M5biNLmqSNr6nA_XFo^L4nci%D2ugPLtG>N4w-q@)(fM5itEGCQ6*1Ua9o)?JUq>9y9GLa0@d# zWf9agt>EUIzV^BN8)+5*P%1ly7rUIQrkmMy$OkDfk38C8Xyt~votfLr@pC8(gOL`a z;$~pZco(0)@cP)f1Ur?@PPzo3FvFRq%f|ZqZlj&I93dz?^lo0CZ7_KAzT182Caqb{{d)HzEd;aPlVE!7ErIi*g-)O_=E^Yzl z1c2YxAa3^Mg=J4qknq{ewX|bNGL@e%y1vRn4CY)@C)y7D&q~u5>#;{|9AJ8R^YixZ z{XRHYf%%r|%2!h4f-cP#!|F<%cbb`Og98EE&3V5M4wv~5DM*xW**V%_@Aq)=%ZOke zl`2(;1J_OQfzyAiE}nT`@<>ZuIK5SEHJj?1yAAb`k^U5zr%g@M9tr|JO zp&;!jh{va`kr?DH^z|2^9PJpuo!)eq%ZC*OjZrV2R%02XxOrtpCF_56$z`o5_PX?7 z4;ZKl9Aid+i)-uMJlf6huKISU=vYkjPL0Mx1H4Mw3d{jB^s9KcltbJG)7CZzp2o^&+Y5Nl|Mww0(0?ah_@`e*sCkh8gS_@+eyNG-Iv?WOD$M1NpvBaDeksH< z0jrGg9sE|hOJ}I3nb}7MTuhJTkk49><%_bLg!+|>H+K~3<9i09YiY7ksTqK|nPo6W zwhi@Cxghd$3!vV*f%LGiu@aMLhPCuM^Ax;Ntmfk?EX7 zy~f=zzwezIgE2jB3T4$VU>!52Lf>x`|opg*_x3T%XR4O1cvxl+HMD&pOUv0TO z9qb{WQF`vojjk}K49MkdPzn`9MlFw;vNUSQl1_0F+-V-|onQ`d@Ajx1+CADym@`CX z^+cpN4f5NTR|n<{Oe~bLvHbg!AIE1N{Wuy+>${$>e~_J%8}lCe%1-M0+er+V3kh00 zh>qN@X36R%VVIhE+IhN5()^yySePEmVYK2RpS3Yuam6eefQAfL7MghRm1Lb{ARvs1 zOaaGVn#aCF6TFSLcE`|tmv+{*yEo2}e$91IE0&a$%1olkBB z)cYrX0$fu}8#CviCMr#bIrnncrqp$yd!(YUOnV6_g*08y%*oJ+$$KmBMJ{ifpo~aeG*wb! zn&70!7gE;_DC1Lv^?iGWIS>JxGSeweYU@3DxhExRE?ym>UB%OA9FWbA<>#}a^0yf6R#s%Bh z!EvaGfe^?yfrJn+@C~6QKp=$j`-adGO2DBTOveW7*no|@cU{)oz2)xi-P_wKlIHiv z^pSLq&b{|6*e{-a-90KJX(Wy2JGrKP(YnH1pAJbRK34QQ19q&!M;PIjE&ZH zsUU64?d{z&isvE(rR<%|7wVmTgX|u;RiTkkpPrae&or(K8FAiOCUZ?4hNrs$bkEDJ z)E}9IRTUWP=qO9e$!(g#^<+u0Df^{Ufos2BS66sYKH2@pnO?u|AWk1ip78f9jFHN zB$xxNP7HnK?XK4+vMg)$rYhI-hr0O2_Z%)_MPHs<03m;czl}qH_7)Gv#^cK<131N@ z(K3S;77yxO-EE*yLnm!-cbeehKQbP0fG!N`B-4Xz)+CSc^>FM+>ch^{x2u%STZzm5|A{BHqld9=Qo~D)XV6t7m4WWh-1Sl6seM zQ{I(B)%=Pcn;ll)d9=@*f!x%<174Bq!_!2bvKhx1a~=r==6XJ1zKF76ar-$^GkuU zw)_WKkW9}39eT9Vn6g(5=0buJ;CRtAN#=L4VdJV6oPBaTPT8~yekH)v%q+h4gB{p& z$ed$C=1w-)DGra7P?0k;a;W<(94qC{wLL9a43AeL`6sfjCMX91W~S%R+)`LHs5gsv z0@_oxYXchdnU75RvYon6sCV_YV(7p)KpLy5PfQ5MR}1Qf$Gd5F%;cK-^!v6=?%nJq zr*y=jK8hvQyMYEny{D%D>C~W2fogy{6q>u(P7*b91#^3{7IUt2ejq5Vz|C}`kg>+L zYuYwX%9e=(gn_YNcc7q@vf&V1#A^!WFfH~hb6H0V93x;J4eKhQ&Cjo*z{PvCt7SHG zRmO87_aR?%O_+-?2=&7pfTp2qFxMR7;w%`|gj89pwskS|bmkdRJ;M)8Jb@RVefhj1 zxf#;t0;_Ytsw{FR7qH@jwI~dBp|g869002)=HQVsN-jm{5KwMQap1tAfJ+?^N|6OY zCIoV!1A;t;n%d#QfkPa)00>+-AaIGp*9aUqaN&ZxOTi&*nWc2(vO^rUpPz-T5qMDN zB7|+P{#=3B#u?RrLYa;lTgCAr5;_~_Oyv<&?g?oq8)PAXj`B1<_wk$Y_`g3`@7qBw z4cfjN0>Cd(WSXrKoM3*Z08U)hj4Ll%fn`g25%>WrWgmg>BjdVw-WgrkbLe0+SBCYC zpzNzq(Xw8ls%}9Dv=_X{eME;B6YSePgcDC$4Th+NL%n}cADPAWNBM2{sk7_s-+Khh zSM@I#>dh?$P&&r***K_APt0mhSUeZo$%}vc9|LD@#8$^nBUn z`}FgB#N}t=X^5kijq|%4>}t81=z!Lrx4B0FU4Iv$w3qO2gs+RnSIDylylS@ z*NN#$BZMgboDiBK!0P5O1hSrkLe{}tIW#Q>+IcB}ho6|hiKno7W3iy#+m*r5kxIfh zP7_zhN2joSRsVuD^_KQ#P^v?=aZnGAd>3y2wfz3$=0-Q6o^9?h=Jl08FPF=!T$HpY zQ$;ugOLJ<_f1{zkd_}(nbIs9BYUX8_edhJToG%-}Vf09I(9-DeBOKJBb{t;>Vqnhh zVRG7>GE#r?;#6LSFjITNge#)2OTb(}JjtWogt_wYUyzwy+g2~kDfri>Yv|G;j%^FW z+HlsY0mR|`ct|an-}t~y`1)BNpZ^6;YXY9r3bYb*p3#og7hHtP+Rx>B@*m{)QCOvI zS+A@#c8Lwj%-cO~7@VliUw*|PR;^e9-}mABK8sON2{_0@RQy0r%_^@G3v*_jll6$+ zZKo*H&emd@n#Xro6v1u(Y^M`tOPa8Y- zI6yrt?d4XhxZ!JdDIg$(Vs>_RRZ~;bUO*d%J~njM+2#RB=TheQLkEYgapPj1V|Bcv zJ(z`zQ_tr!02~-|i_;2+xvh=Iz&xULS6Ie`nVqujY?e7{!CVEe0oD7&nK4iI7+3o_ zKm&FICd}Es=^17X32hCO!#tOD*m(1pesbLzPFMhxc^%NEma}aV{C9MSj9o`vEGI0KOle;LZBCI}qv=YlFk&Ifbaq6Q-M{2-a zdkTC!`pE9v&lg+ek$!n>b>slMkXn7~rDB=2Dxh9yqcrudCD$Pm?p4A(go+jy#={&o z%*Fk1Gdn`WY4^~^yDRNonAr(0q1?=F6=dP;MFUmc3z!2yg`3CquUb!+%`oqF+X+sO z(Jmm)Ku$EstG;vbL4_fMxu=c2mmcej0P`c$a~LX894!SnRGi`C;vMEm?^Adc3gU;z zQU~3+Jo=kG47Pi!02!J&B-B&!96%aW|1MyD=KC+jwtu{{{u3|B0#|ncOS3?kBGUt$ zaLqZmwEwDk=JXHJC~+KOgjE%ah%R>TZ<3xFR?KfJPL3U$#Na>=8~q|@UJUqOh%gM% z-dex~r*`4)tz$Az^4dIaD|+)-KiI4(3amO4{prGICk%k5jBDge#&_r22mxj*3Q|%t zU!bPm+1&<^VY801p3^o_`~UzT07*naRGz*b0-%Iot{AHGVg8zWXHOd_1qk8y(LhbT zls1r*27SLcx?U{Ht@)<@lcGmyP>*qxGsd8!u~2t&D>UGS3g!qPJl++E38XK80du9r zE0~Mz0@QjMJ$Q}K-Ua9g^my&c%+9rO*)p@t?|kLZ{-co2+x)qRbON%jOCm5AX7t#( z&BG8O)mn+dazI(jk`NjTbNSx1{H2BYlwZNlxiWV7B}@|b;Ul1c<0?pVQ2VTKpb}Ed zOwZ!!2@0}bW(MZ?bM-sVVdyDkVTi8<^Hcuzd_47ud+R^(1TVf_Rt{0DdJ#nX+Wx&>T+O7$6LkM$XLd0Ur?)A`C)o zTHA*9<_vyz|1ioG1zrGHJJ5uaR<=mLoH&Qukb4hO3gk7bp6z#|H(vJb8p6u8gNp|B zOvZz#a$$j6!WuwmJ=Oik1TPi_bvN6gv8}OCpPHD7Q>Cp!k}>YH&^9R9tu*w~kuG3m z%+XW<&XVy_HKS1@p}uN)0Y?9M=mT)AKJ$t?NKTi^OyxxGkHXwE;oGKqKPHWc!EVCM z@NyT~FwE?{U=acu1{fc+W`mOZ)QfT*Vnm3GOna*3L&Rn zVa&E9m=|e)`{$;y(+%M}U`CFZG30DnTel`(p+XziH1b%pdsRsX4u;24#;l8% zEHY>#O~{dq^kpXizm8ZIp6vQE^Llp(f%0=#|I$BwQe_SNihu$phYhP;KtbUU3JOQA zGte*-X%Q(Mf~yFnFlHhHqTiE4NNm~BaTNN|;cL1)wQmNO1_A3o_X7#?AP5ooAwo@4 z@9E0okDfPxo%?4{_SyXM1D!eKJYw~oi@HSB8&m+E*VWmKBLmEcx=m>6V%+rb@HAGg z2?63P3e@`sLRmkrj2@fg_uDwAPmIsV`-=T4^{F0^eyQx0chgW88* zd=hiBGsqX3Kq*BgzdQhoj8ICn>bv#2vM+x39(@jLo-SlB z-yx6zUqm0d=>*5&9cWs+25);t(~Ne~jJ#IC5V;inpIE8% z8S>J+h2%8E*iYq}@+~(95>mO&0HM~4X-D|Ph^q7Wx==8w32IUQ2~AzU3%!_!K8531 zEdx#V4;L{rQ-tR_QbU*XJOlxPFyxatu{y$a2-YrZX3+OV#7Q+g%`mxBv7MXUq3V^a z=b+*%%cLFOoq%Hd-dUV+HsE0Kpq|gTm@NlNQ#T$9>kC(9NhO#Vn?_qli}aYEFVu7S zECMSb;8O9bkXzIAr()}E7BiY+n)4W{!zCk%C{3d{lE;80P%)J8(RtA_`b z358QZN#;}6o)wUFjXH!qDa+XC2#UorFfO9p9f9LG$YeY?4nZc9h2uEzG9Cya@G@C; zPB;H`%bC>(Pj@ydhHYn|qGfD$u8q?`SoBz4n3hg7OCKP|=4;lzLdL=L z9P8G!yA{CiW_*T6+@y;K^{x&VvquGwlsR61Hv01xTPMb+v5fmTEd=Trm)sYh`A) z%l;8ypNn%v!>awP6zYpu#DS+DI6=L z(aP=hm}MQ<_AG0bxxJQyP%Sy0F#p{CZ`KdbW5f@D@``Pheq7=_V%bL+h8ED1#BA@;kOHnM^z3}R0Mr(#FLf z6@PTz%G1L2uKMKr!@tBE*T1U1g9OZliM<@k-xU{ZK!@8BdsrSB+?c-v15PIZR!RJ# z@+cnhcgx@{$6Kc99ExEXtt5{&(k!FFDKX9C&n9skf~@DDSPqPDi0xEWY8vx9z%+DI zqG=8uEAb#Q4CYKDXMttJBu+l>S7%c%>v1a(>BbX^ff%wzDd2}(OXqb<&U325+#x{8 z=ce&RgnCm;9>A>8_#ucW>84O%u2_~BTL{!8oVj7Ykx=&!e+}NiOTnxlwwXN&^?b(~ zIj&EpCPW`|trwtps268PWvjE%P+zld8PmXJLqp783$B^FkWOzz09=bACzmMzAFiwB zlQpG!RpWY|1!^kC5=Ok-B|wF#-f9Fu^$jz)Y6X?>7JVqp?0_DMQ9#=W`KrNO^>3j{ zY<6*7^={)}UI_!-8_Z!e=V&H&RM*Pm%Pb+yep66cFQN8w_0)?ahf2eE&3S(U zzn%ziujvK0v@jEUg(|35DBOPFw3RPNJoJj}776nrt>9~=J8+Cn{ayr_nWZJn(F$5f z9&MzlW?0wxO8U1LO<7k7NRiNS2{Il*sbYRdvL5G}y0~_d`Mr83%?(FJOAO$Ch`<*^ z);OR8HS|oxW~ajchHK}32suPeKpjFMu=>sg)T_Nq0s5lP6&HT}f4MD6@UcLh%O)`9{k(K2o>{SwFMr1bHwCQnW7#vM=Jf!S|Ajp>I+ zvH!0G?HtW-)*P|WePV-5}`geT~VIx+?pp$?SW6#tZ9J)b{J~? z=oFe093;qvcCI_biS!vSzKn@SBtF%VqZ8=vYhN^|w|BJyI3k}xq?^Key~bY3g2F5W z>Z(p84Tm~ASFP`b!CWlQ&CPWb3Wag8D^8 zrvV%xlt+451A9rM)EqLI%slin6OQ&oD`LB7jvHyIo|ZXk2uXsu*epIcy&p`N%S>-} z)6_1XGgSWAdorPJ?l)n+zcPzQ3qci-!vr~i<|PI6zkChWoc~;GX+IS%ab!Gk9!(rS zJ8~EH|M*@!{jXb59xH3`)_z5iqZIj$=ES$sLCk%>3v=!zzrGRM>lvQ*+CE@Qvvhnj zek&9R19Yrgk$Cu3nJoYq%)eavIgW*seBzX3`NCsg!stJ5!=787NR`Ej2ZjLv!#{f( z+we==f{&v8tX{19*Yog(Q(lMD+G-D>1K2B^p+y7;&`ffv8Xfh@;@ey57smlyk06sF zD3;@)%@QKk{0_uJJvO1X;lRNu^mga?P&Ls_r{EpPiC4^MlYs?w>8}G`hd|XSlwVVT zUiTFM6wFn<0}LOYKzCoqqG{@gB0T!eW1jhr{Uw>Xg+M)%^ArLb4E5n7V_3GzzB&6| zBTDIM0PgSrU~K5_zTUw#2}f#Br)99q6O>BIOS{ofZ|l7Q3g(dcP!qHWfL8$GaLrt3 z(%eZ-zBq7`d#y?!iUz3(OPE{ccS*x|GrK4_#W^1GRc1guWAWVBR$*$_&Fn&3w;kYg zm{SS}7lA0O71UWC;$iO75cfGn=FP5y-0nN)Fwb;}2~WKGPOa~pn#&Xzc;TwVb9q&-)OdMd@-h7HMK`BT@BHl&gqv~^2RQjx zra*Imv$`&bJ^oB@9XgyA5CC5+-HzdKqNpO43_CNX&#&!(XdutJyxPKTAJpWd_ z4!5HHtX`bPV^$}o(7EvHM=`?q|#N=Vr8E!Ee1cVT{4jZSP1oI^G zdlJ;8h8~+q=4C!HT|swemTT(Flilaey#nAWj)koph#A(X`s{RTA7IooLUI`gb0uYk z5c$^Er{|Po++skzx4$#)sT<~ZD$VcO^91iIAXpI8JG2=h@gsYG zxpdiySF)O*IJvVglEM%Q6)8@%*K|u1dk91;du*9%Y1l*6*VD#+H#KuH98K52^*HV# z*o=U!Xax8GEdj{D^_t;&&G6h7xNctlIc`Dw%fs=sKi35_v$F@SU=Frjf?MxX*VC%~ zyZ4M~A3T-6G7S{WrN_F~e;yaFT{po~N{zmAc3tsH0dCewf;j*@R++PShyCb3gb;iRWk``NVz4L$0~< zYWU@J;Tp+xU2raHk8yybhS|O2#ID41oa8ah{X6Af;cz&Xm~ON*j!%E+1GwjuFD(kp zZJD@#7p?3mOBa(LqwZwC6EhX~J_oY~aWS`fKy@=a4>wJt{x>1D)$9I34sgQ6t~WNQ&$s(vj&v^A#4NrzA>g#IKerjg?ErCGLEKh2ZVMc@RsA`w zaGW+cP8&dlnO$kb0JK7@W?NHz>ULUD_!Y$E)8mUFRqai^HLX4-8|Kt7vx{3aUY`YP zcAYSBe~|{*<`%1uGv^-c120~Rmw)J;=*XB8DAXg*={^JRy#L>^?B(2yE1?c-`ox8} zZs}#Q$Mul**zL&@tt1zs-Cy$S8!_~&z3CF4*9zwi1E9q)Ml(0J75b997}hw0cp})3 zhy2}%X~s%p_^&J8gPrevpw2t0UxLXp9=-0TxODJby!1z}!{HQQ4-lXXKd!o3ur$V6 zQ~Ruh5O|)$;#gSy%t;!1EvQF5-4Oxl(b2Nh&cl$x_Z7Tl-2u&$Jp_+o0r(<~u<(T% zv_oA{P^NcEfvn3t-L?CwR_81h)Ww8ST#q)d7xSn@n&Bg38k{k2s7ohC?ShSfdTCA{ zo~Kvr$-ZAr9V-R^?iA;G`FQUe0MQuk>~S6$8UbLN(ih+SzHBMiz+~UJ8RC_4lRF?L zU2yQD2oxq@oG|35ofZeZYW;Y8Vfao?^nAP^NiHc$LQ!uCe z-ia0FRUe)f{gvn8LrfekuyQ=ihb+vzYxrn)}tC`mktEIP}+K%VFw$5Q%3DTYI z#C!hZV;KAR1ip0NeseN7JJErS36DjnaH z1DyI}+X}4-L)AzY0PwBS-HDePD~;nzSH2&|esi$C8(N?QlVv<|%};Pq$1ia4Fa8Xl z+5Asc(^F7X5FiT{1#&SZtqHxJk?6I=;S+f{ggK5?eBs;_4|5^&J$)VWnK3guTdCLl-q)MK(cuc4 zyBv)(zYiZCvkdMOsNp1+ZR+a>IMsskSQ`*yb&r{lg=bSbTmg-RdZFMzMS`n9j|wNX zZj=?YsqO_|=4~W#A)jmGqQbQM@&x#!UsC8afzmnH0b&@em506BruV5+BW<}7)sA)Z zH=ELr7o?CHtz_F7PJVQuYW=#74r$Z$u3L1(`=ZviCr|sYq|C$@pncABi;4Ond3omOS;``3^zXY%T zrA{}#U%nSblw4Czz@05j{P8k=cE;y$?lrgL^I!Th&TLPfOooCY zKnU+R_Nk|Z{d~mZ0i5zV2eZZ6Fc(q{>Vkh_AH;s1aAc~?`^`m2S7mmW(cdWVvZG83 zhpao8Nj{>Tiy~+!4=PUtMAm1HoL*jsNPZvDbiDf7#jkW_E=wW3dS}P~QTzjor zfo&Ajl||p2_LOq-J5YjdlBb6GT@SCy(i69Znb5WSfR-xha}WI~*d}$zyb~C+su?C6 ze&0aEG;Wxlj647|3@wj#bzS+<@$@>(*>i-JziKeI^8*|!&tbx~U@kn`Lk0Hb?>Gso z3QJ?36~MH~v%K{<$z92dI6(;&>IdbbBT)XmOTz=>4@cGUE zTqPwlHR`k3FP5Y)0jzSZcAi>N$Wmz;tL7M&BymvJzfoay(@#kV3sCjzZKK${rVWG; zK7bAo#uRHYiCEu2DU4T|tXm0WBtcNX3$?OD+1NDxsR(|f< zvEQM=Q`UzvAM=B{u(X1p!BE#sPqqP3yEA_qdT^N}p>PR7plNuGg1P}} z*&j||nA7DnseIZmS^TDOyZCM>SdL^r1J>e;!wTCs*mUD(PyFdHeJKIz=u4Y$^cPSq^RiOpkW)tC`)) z#rWqk8crpKa{a;1?_=*jJ(MnA$4P?83VwL{r*Of0AHXed`zn^^YWUtZKo+H0m%=Ho zvpu7Lo^_0GE3Md27k%ilFo)W<`|vCd9GkpIZWmX!)X7#V*q`qXVj0WzF4r98k4 z%xmh32?eC)3lfDoAq15$)cTqi59;+y=(5;QH|p31LS3;?nAv$ab^x(ZC#p{H03g@8 zQmIA_Orf-b@zEI^52%alu?5Y!4P_|PdH^}+IrK5-Y6dlgMV22Y2jaHFgtmBS zy4d@ZU>?=RRa(*4uAAROl!HK~k6wd)Tw;ic{-MbaRi=xY%j1^Q!5jc64h1~Me4Ix+ z*V32VxDFj&ys3SO(~ZB(Um3ekNFQm(D{>d(2jzQlI2^B<)|U0|60CPbaZLm8`Zd20 zVIs``^uf1bY*z}eagP8uEs1UqC?bJmER#E_)JKD{@;J6W?|XF}v+2B3amGu|Mdw+A zsPqzyRVFa*PhrxZ#>Dsp#KhPfvVmugO)P8B9nX8N4KWKAsHr;{ksMW@}7c*+glzN4J0Hici-#n#&8@f&LgrmVm}M#aU+epgz>x`SABq9#3cOShivr-tq76LI0NJ z7%C0pXn6#~WfRzLO9qA0JAqT1;QdiAN>fFY?;e5ws|kd^nM^oybs4+oFfLp1JbY!x z_i$C;h4VVcLWCPmq3Sbg?W=WkZ3#n)p`%3{9tm*Z&>TwT0F{c_b(zU{$You$GbNvj4djHZcJbmzB!=XOTCzOeb1$81UpadT8r&A{PNZ8jX)Txn% zfXI+|4TL&~26L8A%44>JhjwLW_BCSJAzys}%%Q=_4#4~j;(&n2{<+y%wia=K6NO&@ z+yrORcKhn`o&jS_sQHmuIn(xueCW=K@i12nG#lnql`?$l7=7hZOAlGe_gXxh+5oO+yyJVgy6@t;j-8)W1NY+U z==X1(!q~*on&~PPAC-!a=@}J&yS+7!o=z7X?OFqnPlc|VxrOOHq^72B%fYcCCg*&d zvZ4(RVa{=g0NVt+>CsM;>oNOc!pshlp2&Rajeutd)YWY_8tST*WDDmqiFRiK9OyJC zIzW@P%Y?epj;Xf4@lXfY02f9&4d7t_88ikJ5UOVQiH3Y7(j>36bNvCOgL;xvoM~nk zjURhEU=(ouN!oxnJ~r(Gga&w6K-TgDRD(IYKwP834=8*JQ!6(nWTEI-k?dK1b|zgo zP+dfcTIuv-mD3-argpWP4&Z63a35i!&-J&{YUfuZkB=vLHxfw39=*$zOozm$}!-(^_k;?$ueHP{>Av( zj_>2DzKiCckJM8AtuNNlwXuoll*?&lVycLVDIk+^v8+Fj?k)y)y}2YDA;oBzS|xs} z=;NtF)7UWB0#F{$A`tb826O}9;+MqKUCB?8=;3S~g(6kAKRck#o`(;)Fbus&xToB~lMZ?01R2ZU>T?XYd)8VFXzC2+9PlBS$(`7F zV8@5@p=mG|ooETyl-sqSF~&UQ+~l5Lmpt}+oimuYubR}VoRap>M-Q)djL({*vHNa( z=q5}bNoj7rzB~E)?Or61j2&F2xMK$UX3~u#e`4g3ROvqTU;lxQj*e7mQ%Q>pyrCcX z(pumYTN$V>!DJaPTYoivIDF^g<);pbF9Y+p>MWL2f&hCC&*JetGnkuGzD)L<3{Hxy z5)d4lE@S7B8D?hJd~r;T+%~~cCS>!1R=3=|juJttg zb`QnETs#X=F!ZSm70kgM;jBU&b1v~_SUR=Sgt@+*=QVD+Qw{9-)yYxJ79xuYb$eUd zs>y2l5dZ)n07*naRN6<7xbH`Q`rqkJ(&5GToeRkjkgQWZxXc`I_|UdgmkaJ6t(oT9 z8?M9McixSQFS-~@^Zhul^E6yPa2Y;y`8#pzO<%?K?>>ymRH^29Vx>O=d}Iai`aYmJ zy)&3US;kA(y$E*<{bYXEeYS}MR_QswtRLX!kWvP|> zp{h#)t$xx)fz6Tij}TFnWE|5BZDfmYd+N!<&nl<`6rpo`pl-bpepu~ULOnfw-7YK?Ge`eFbxUCp6l@|D;uPR!mP5Fh zDt`e!k&76xi8L?=OqiS72`EB6?juCuBgQ!?FZuEVNN|MHUtbV}$iUIAtsP@rQN2qe zZ74tvvoD>4-5;;+yw*rbGM>h5x3|@TdI%QeByL#PXAgV>!`p_^W%Bv81MQIZ4Cs+c zeCSsW_CxP}7`XZJbl0pQKmOj2@ZE3R64`$6iKlV!iKl_@0GXB?dY``n1Fzi(^v*+D zy{-#5wF&s>5U@L4gPhM(V$Kpf!$8kcB|KnpEpY z{qSE`4`XV`skP0|&Wb$3ZPT$6vq;Cd-;Cmc!}s9qf#+5|SD2}Nhow?&z*eS9IP`-Z zIP`-Z=zGlxXuf_4kkApAC~Nb;hgSgaJqT<~*H1sWcNS+}a3T)fSKHE1Tk3h^zb8V# zDn>W{ceEH_>&`ixx~@siplBX!!rO*9z#6OjM`p36w^@TW<#m}_Mob+M@-s=;TKf$< zyOu3NiHsxiY=JrePd&O*KlSSgr8 z!d#@$oaCg*JI;|!A66z{F46?hhg?t^T4o!L;nXl^Uy3v*8DTwjm}|#?Ij$HISi{%k zF?>Cw^3{X^O*XUZje$_##y=#Vnp(Ow27UJFWH0X>;liVojnXL`rp((tNfu&$pN|~9 zzmCXuYirN`=B_D3;wFLkT$iAyGlTW3n{f7N?RfsVojC9GcAT)P8Lb6ZS_=WF?f~og z5fFtEt1f)To8Q&t8)|-64>Kt|xg}hK_tfRY9f^KK)_UPOG@_cicAf@m>aOb`DD9Tl zqg2()b_9noPN(7Uxzt^-Snge<4XfRLtaAF0(F{uUKz*UI=@S>?-s@8Y zZgEk)|6EAUfxD&&!Pe=-8P`yu82$bM+_UpGJZF9K*#5PxE0J!{T7BXlE@Jp~52EF5 zYe8N(4`(_)84YfmNR|Aa4{paL*S;FJpZ$gUuT?`9s<-!^zY=@Do-)*LJyHwiqR-JG z7!LyM94cbtvZ&dl7R<%^(Ww$za~U?ShpIYC)CIY$gUvI-=b&7na9yCO$wg;p z9w(pNjmIA!!Q;DTWSuQU2A0vjKrcg(&1TpTJEAkgRPw|SJdwu!m5QHshYkT|XG+++ zd&n^R%h@~S28!mU0#>ab1R(@|NM*1drAUg{@A7h7(NtG-2;jLcDCKNxu%=D{5F_lX zE|#Xwpicp1a_1#LIKU}WL@d;4g~MCCAT$i>6XVku8yPlXq}`f0-mc1N(lWI_?WkEu z-xnGhwJKDy;b0wMo`*!Xi$;dZJ4@E z0zbhijsgL}k^S4SW@8lSqv14uT6qwcWzLA~i<5i&C-JDi7XbnZa9hUd3?B9O;3;wt zC%VhA#)%)_y-;!CBx-86T=hAu$o~j_F>XFfO#(20rO-~j&8-L?n2a~O3r#%)p1km9 zShD>@tZiKtd!99|E77v91JgU}i@29ora!z3nTNaK{e7+2`7u%_)PH`?7xCHsSKu#} z-4MHUfv~Y&`ndY#CjJtgK&zcrHQKb5O2? zF;Ccqa75m;sT-Xg8QgkzTpR=Q$oBTEHq)8qyREbrePiT|x+QYkBYW_gccg1r>DSt_ zsTrUAV87hx)9AH?)m0u#?YbP8o)WQ0jtA5;{MqR7V07V7w={T#d1Gjr{z!=SKb7eS z5oUIts$u4Laf5pMOy4fHL|;&Rdb_yNgzapfJ{2kSs(|O(g@8hd>J_-W+<+#l>n+z&9V z{F~*waF4$oW%yOo3aQWl+k$;~B-mX$@jNAI)~~@_FHZl$73og$=_9~&vbVet_rw-B ztzL3~8Qxmib z&J_a`ixj0&1;x2C2A8y9-7?cxL{n~!t%e0tUX#YAu@yDFE6`SKYDpv|e^}D0Yg|j1 z(7;)1h&f)4mbWXQc&N+q-kOP`(NNd(^K5~7RO2?&+69AZ z>0(Xv)-u4LF034Onh4Cr^(fGnca6w!x-zrOi? zChr@@9hZI><=OaWcHwDPBiB*8?|vZ?+%}5f(Lpa1m-IdtOE0PJtFZ1ZXX3L@eH+&=P1*1RaQTvp@a7+X6leVETDUDa6?Nr&QV)2JwLn%ndm;{|mk2~f9Vz4J%t7;A=@P?xis@qI#rZZy>G z{5)Hr4%mfBEND)3q18^T0&rWxkQ)8tHDS(Wuq}s7Ifys6i(enu_h-MXdi}dAkKrS8 z-^Qm(Kg1VHx8uvDpX1+(x8R56`%yv-({&9w7>;0=rZeN#BLpONo^gO_>DT`B_32Ku zbr!g#w%2y%yiRy)o1@x!j0`<6j-OxhFR_|>XSM^YK6g&Kye&Y&TSh>CHc!+3hgSf7 zDf|ln41ISu&icuJ2h<`5e;4Z4ufL4q%2!$VGgi*a;BuFdJZXt?^9HKS{Kw^$3<^PHt|Zf z25i@Lk!@N%M2+LBJh&91pNj>_hm7SRo$R&i>s`wsrAE;)9P{M1#y~yVT+^UVvPde^ zJVk=%oYWY7#JSA>0qWX$>VP^B)xh;W8v<&;+!*#@9c!OUh=|dwHA-v39AE(>mKRzy zfWzuTXTKAVjp3Ky|626ImJEfX*c%?j)8SE+=)yp*%VYlDs)1nUD@kTo0QkxoAHm?3 zmFZ6OnWMm?wTEsszhbG`k6uM~Jvxp5S@SO3ap>;IzRNE8W3;X7ia9D?Hr;y#PWsLZ z>elSTj~)Vc&12fz78iK;($v9c9=PIr`0RmiB<`=@^j-_<1X*}+5*l=yTTj4`j{XYk z{^E2r_q3pGWhYMk;g$H#^j-MCX>Y4DFHu?7vJy9Z?;RZKL_yus(BTk-F2UhBQCBcA z)vtIF?SrY3FE!zEB}5QV1VQ~!U)7&Hu90cL$#st2qaICTYVx`R^g@Ntt7V+ZaFc>H z=@#1*$z$W8uI=FYVvxyN+f30)Z~VieauzIt-v!j8d46U?edU@#3+7b)itUcJ-7>XX zjmD}4Jq$w)>Tw@d^jJzMHgsp;h~aAj>@k}9?$`eocRlul*lW*60Np?$zy4?6t@!8H z`~}{6#>?=wtNtAS`tTf-=_esrFu z_qBNzE;gn7-G#5K(VwoQwho>o=8;V#xoe<5*Nty}>f5+;=pp=k=e_vM3qOj!d1~cx z(wS|?MK`|=UW=yy&I)8ib3a@ubLZo9Fc;dW0Lh&1gHqP;7eKEU>hZ(qAcl_Pq|Iw2 zxZ{+EB;dh_Vcpb^%`W%sq4=5p0CkL!Qeg^gwB1=%W;@qPEq@uRynhrwJS z)*;UL4Je*?{_VJ9TYYnJ+cHuf$3I^Em-zV!pTe%2_u%N`!#H&NEZwJ&K>N_!vIed?P-2 z>fhj#oqvs8SKXER_=z1O_|l$lp*z=szxluK#;L!(CjG^C7um!t^N~y2foqc|_|au% z_arX+;!6|vhgH7sG!mCSPqOf0oQ>uqS(3qk(}@l45^QvrVbJM9KDJU;vbuQ%R{z&I z@t*HQY3}8Wi^-xdZL76l4yby>A;4TkmC2A|UQn;Z__GR_>s4N8RZXU&TpaL|9px4x z;&3q(*mjgNI+Y`Jq&8*Bae#Ux=T*bLDrjmZcN6Lg=5a=yFm?i!MnGL`ezrkf!Cc!a zKLjfrE9}Ch0^G#qS(iX>MbqR~ukFQo@{&A=?Hs4WT`Q4KTyPtH@Nb{5>WQ5sUwZ26 zc>mJZ;>hiLWB2d**hBb_?eTHc$EyUNS*TR&hrIt~x1wu9U%C_RE&*?Qx+c`S{^=xS z*QK9&R+q_L_04!DWbDh2$>o=w{3=}Y^iA;E;-_Vd$StG5k$HBZyrDm}lib!f{GzJq z-G+J^vEQxzraMVS`$LUFoxs+n8>^`U&mO2t zGq?qFc^1Ml7CTlG=5e*4t`|m1VK~a^Y3x>XPg@QvTMCKhcJmk5`<@4J^YVYdkAHSE z#!`U&M+bk74_)>q+`suNC{I@pO}gvd|C_jPoX*s|RwLwR_x%E1E}fGXc9%eFK;3Ea z(Eo`ukXx6+lYWup$TxQx>sxwG$EDlenC{@2aQ<340K9uy>i+b%KmV_*>`hnEN57N! zE$ok=le8u}NLCXU4pun5SmpG=gA1ZHAH?@R=yc&ZnN4V|5?goq`!`3O;-rSoey6EE z?mXsxVqh+$=rcfMJfcm_njY%2vp$YZ^2x9eubJzT+%FD(?I^U3x(mSc)chKdfu(IL zNCU$BE;MyQbZ84J0ppeMYdWq_H>^cfpzgHH0V1#r$%r87pmGSC*-BDiqyP=ri=%dc z7=DC+x0dnw2A?@PG>%QDs{9zSfDyl4M>s2J1or(HX^ix>&#&)u96k7q3Vk8c>z7^$7-QBEq-sgY%KqKx;fGoE8tuK6y3{zUe*`cP_qvfGrcdqFokS zdNyPKy;ow}IX|j>g4-s5SN5cfj%Q1MhQ+=AO>Ha7*sft*^6MLM`*Xe!*;kL=7X40= zQ)Y;ZUeboKa0=5%H`z=x$)n%tKn@v%P_ZS5#5$F~8MxT&t;XGz$54rJ?(A51B9OTk zpibf#^~umYPDE=1s>58rPf97WS%SF|YZ8PMKy2T*fC;O}hsG3Kg#%pNw61pDMPoMV z&?eft$RoH#a{KQ2%{jkubwNIxIAw^L->Ft@GOK}pJ7E~&=x|ZyQ`ofiMvVRp78-np zC5-F(iI3+_+^i3|hlnPH&u_xk$hAkn$D%u2>u$8BZWhF6ho+u!wRk=4bOFO?)pxU02aWZH7&Jmnhf7}5ZmAW8$5E-xA2>FpT*tl zK7+?zbUXI`*S5M~{`)K+J?SQ#dGl4N)6?BW_;1|Ti<0`r#pUUn-^ z_?z@&!0GNH%74EbVHK#mEg5Y5^2HeVll6;{#d*oq|Mpi5D77SISl7rgpE;U3`Kp&} z!hJ8hwf^g%Hq=RqR5_ACkJFBoPCu48-B{|fzvWIZHoD8O-04LN$;&gzSmY4eIgEAv ziv1+nL9lIgdyHnT{sNZ=A+Z!73Q`m1A`{}v%I96=GPR*zEQOev^Wk%+GNy^DQ;OqV zhscbn$*{zFe1I8UQ;)*F{^prHcL-Ur+UGVJ7y6JkQ4iYZIu1}@vZR^ssdmpo-Dg^S zSeYvV9O!dXdn40iMWAj)lWT8p1_+J=)F}vYo@G!ckpcy3YUUtjUedNwYia7@H`erI z!CV}>YOsLQ)>=>(&B@#(@oHo-jqQ%cua1NikTLhl6 z@K8Vw1?12~a>;c^WR2IT#MIQgoMfMg!lt&Ep=%c4wbp{Jnd_Q*oDi)VWTsw%Lf%D7 zlZ#A-$n65?lu`sC5QN+u%{6n#I#r3Ofty=xAjWCwaVB|6X-c=Scu^+zq_D4C0-iHY zW#ZWV`=sGe&o}7}>1r=gS$gLt_Y48b3obsr_&+YNOsL*vBcWa{vF6gV3F;X!6Pf{A z)hwh`Y4HTj>V+{avAK8nUf7t~(ogB};`@-co@2l5h!(W_*roqK^m|J%BhN}C|zx>*CT6$X3 zd7UuNbmXw@?ng10>rG5U7VM8+U6h_F)@_|WNe4I6+S<7jIZspy>sk{auC0q}@r&r1 zd7Pu1+-EbC=f-mhn({8%T0OM2dT43!P$;;_c#gcB&*NLj284Ad4k5^A_4gvo?V+}= z8XhtaF>u${pW0hHP*a?=HoFks^lHuw%Q6Zmb9>01FXhuvi|&L{+04Iw>|#Ql9aqCT zK{ANrm;(Tg*Pi@EQeQivf;w?Dt+RnppO{c%;h!x~?`+FzAAubLku5tOF90<5b=H(> zP`9%!JuD+1levBM(k5KIr58>4%pWv!OP1t%@yPv;qU+rHW`isJ>=?%0{1}46$&Pm^81>XUs zF`FiE^Zd+NS1d<0=I9;h`4ywwxemrsdiH3(oKf?{Mc&>-DdsH?N8>#0RsgQsvZZ4&_Za(8pxu^nNQ`jG=w zU>Rz9a&xGM+#I`@-tYPi65;?9ts zytYgkfjm35rz?jSp5KdYPt9QGp2kes`An6;TrVEE;~{K*{^=OK=Wy!d{9Q8`{__XX z{_54}xuLo<+VYFnW5XpUqu}OHaPla)c{DkBG`R&dxp{o)@BRai|7L5|a|n6KX)mjp zX2}ibV*gtoiQg$$b*us$tt7{4-&JH|@n_N*O}(}(ZrS-$T-E#hDygbQEJxDUV(y7= z)W?1QjFiwm6t*`my#TkG^-Rw*h3@q}CnIr2W%L(AvCeREU1(5Rwj^i`*zoJ>bs>ol zpu}sn$i1n3$%Ch&kdIRk^rxljm#SXqi=jLaO#|oW7CnY~wnaC(&@U;d+9=XcVH{EX z6L+>4-tR`&tC2&3cxO2RFV{5*er=Rzj~%w#WYMwc;xVw>?(Xg2S~ockn!0&|&vZ?F z&1&YstO_d8V9vye8L^N?zo>nTWuhU;&UZ=XuZ-v5^i8d}^5Q|PSk^X=Ts?bbFxQ7i z?s%wfO+B3PG4}s<;J};i!^}hV&qOzJU>NUy;ahO$H*Qare#1YUjqYqm&2*=ApMvbl z=I9Pl>j}v0Nf_EyC(HrhP4~XP2F%lZ3-x|2Bw>wINoH%a`j~TQ;I`5bmHJ4S92Cf( zDOb_ZA$ve$9pLQSH(<_Qo*OsL47D}&ATne|0~TN3xTaO+!!)HUklU8Ys$S>-w$Ib# z&dv|{fTHGi)dc_mln`kp(8sBpc@s;EucOOYv;Zf{+ z<8QG0rh72EqqYU4I5~&gK5;8Pboo26|M9)4uXD|tZcLrF>%~i>8^wn#AhRz9=<|U2 zD;{|(KDx2`WGD3++G`21e(gO04KYP$aX1{suHZ0s1c$IAIEW{M{n!^C#Yi}X3iQaD z9EKXWO}MM&-C?{XXS_0nsr^$Xyot8#5ahxDS>E!Gt$xJy31ok@sHc)(E~FaNt=WBL zAG3aJGw-*iR-YjQm#sXS$0m89&)4L>e6?y^>y}++eh*{KlT^QU2#ilmN0K!P>iMRa zA(A!15zkHTKMZh_d%kt;5dl!s%r3GQY3{NA9e{?+grJ)r7Tf&p`$0@Tp1J1t_Abr2 zDFNo}c@SKjSiNd&4j4 zK7Qh^A#A;C2<>O|W7*Xk(0|qn+#a^qJH3$PpJ(y%w0r*K2Ml`<6w>;AidvJ;Kzu31HLA?vfQ_C$CU$(D)w>N7Qf z4#-*!u*~m)Zn`FRdbX{nw?mrI#Xj?4vsul=vUnSM{R}|%buZ+tH@DLn{NXj;{h=!-9z24H2an*f+DTK%!1*ij zcUQcvuBm66S1(a38c-z6T>=!f=P(@r?>$%-%wKTtjmH({wXPE&#Bex?GLqX2CzAjG zAOJ~3K~(#=Z5a)xFcMB;xzmddr&(&bM1E&fLj7Pkf~UgBXkjTw{(F1WquuI1?+hF@ zaw(>+*N2vwwI+~F`QgPuy%YrU{1M^XdImb7v|z2$r)C|;YrTYSKeh3(t@~2tH})Qk z>*);%Cd~ZKI?Cmn5~1P4X=m#+lzoj*dyFM=|!yG`~BdpT-L1SPL?|8$i?x(ym9W4c z9tJqjo12@*DcqQXZ>wt+*yGWU2h>4$EB9Fh^^D^f*NC$kL>=QA5A|w&>G3d+ABGZl zjD37*CO{pE;_t1bf%=PjFT}RTADdUd`eH~^R|{VA=zGzfP4-z>?Z!Luoi+FzsjaXX zz@Rj9kN>$)FyEan_BjBY@V;~K#Jhf7$DLG{G~WY>S<|;o(3#ly>h;Lsa10OnJMmO_ z5Ko6ku{St^$AhPFcjYnc3aXFA-~EBxxcwE0Fwceo+8qnZyz+>^+`LtI4nfvFwuXq> zsS<>VFc%lex{hT|w?euSyWZeHv--33z%)B{FT^2EzZM6$Xh`UqwjOd@9LFm&dumnv zS02BJP_G{PRo#b3o5^Ix0gcR*s?dd|h#FpRt%h)O%OtcK4fWZX(z6cgtxc+5#2$kw zKMgPbcv~6=^)xUyx21(S0F)~fK`~~>Gf;F#rz9E7_2Kc)+>ZTjXiUV;jIlwwEt z)Gs~)90|vhWuwJxrzLOJ-=a8X$zN>lsC#S@Q|gGetukmC)Qda!89h zN95ORY-pX@(Cht>A2%}-%Ba^WU*@lng+e_)_&4cpjt7`2PVJS$VITeLv93MdP8K@45l`t{WPvsjptuYQ1dJ)Fgr|BzJW+4(f*IY6D?TDMh*b z?9kAK5Rg<*KcoFbJax-9{GZ4F3C#`YTW@L4;>z33$G?92J7_H=$C+;-1zeqFus;yS z$CeMuQzlqkD3FW4O8WQMckOCC{Ez=z$K4zs2@xiG{vRnH!(}I*hOb=qE$sT*Hf;aM z{rI0P|ALFxorQnf{+|oJ_V;#u6WiW$Cr}YuxmHP9Q131UXtGSQv3=&&DhrFTx$WuQ09wQVhrG+Hl-xz5#H z5UI#g0Obl>J|0j{C0ew&z%R*AjS?5cYgh3brESEwHkfqj>TNqNP#+yD$#bwojfFZu zK%5qFDKrA=?Hw(0pXN5AoHQsvKw|^U*ym2lS6WFrrZF&Qt#)yrrBeNlN5AhvAk3k) z-^K?wz8MF09>jGI{Vkf;EY6gvm%n)fKCtVHc;kg1ubM7PJY1SN4Ox-_0WeJCXHJ`W z`jF|-F8&0}GgVYVOFGXTz_0%2m-XGyagq{}P3^DyyVv5-p2-MY%hP3i?*;#kzxvNN zVYocM;g?_i?Psy=&36Em>iy<$2s}`%^Bv>Mui9sBDQK-Z&q`3A_}t`fRL53cdV83e zJ85zj!<>zn+M8?l`hdS3`)2CSD**KM=8Wq^;%kIdPLB$J1(lK4R};F7Oe#xaBcZ-( zX%;o#3o$J$#BGTJeR}lCJ;sg3jz>2RK`xh()0;LL>XnLr+@MaJ7I=k|RDK!&^(D)D z`5s*}H-CXR$2eP(p&nB8S4$!}j-hc~FptZr)>sizszbATrilkPHoRt>{O9KPW8cpG zc=1DT!r)bF>%P{qE&aIir`OGHLq@8h3e^G57^_k)1%#B1cDlH`A@W&-4SkP(V1Fc(4~hh1eI7x_qq zlKvT$V}`5gP#4=*t{sdurN_r`S0{*blnc3bKRwT&GJSnwh_DsEJ)~MFSiP~qV!G>j z^eaBE=ZLYr5m3(;ax#6akZ5m*kJLNwgPYna_qQR zpp^1)=VZ~wsZWeeqo=P!_3!c$L?{It%eQ#r)V%_mkfN=v8IzN&Wyn4p0`&}3K55)? zmGg`3S=T`+;AWkK0^wxh8Y{M#c?zi+`~hIkyH<24aV6iEMNOW!KA3AYjJ&TX%oiRq z;`d)XI0yk$5Y&8&0Py+E??-s+d-1^JeF&1E?f^4KXK~*jeG}KUeHY8G zS%>w1b|Ka`uf%yBrvm`C&+Nq$v%9hVH+SLS%{wr6tP~IN*f6gIon;?Op&ZT}LLi4r zC)NMz_Rx{fCVX*e>KLFBMki$fKT=dJInRx1!4igXbpYQZ>U68V0D#B0JzX%5nkTsZjW~=eO4_>}s z_LWJX7pIOqhW-Ii8rG;|`CZTeEiHKos76CQ@Kp<~kx*}IZv&_g5D$g+=U{5`Hr*(& zs8DZj%HZf^NwpfSZ;FDoBpsI^46L0IVdsv8xoip3nouuSC?CEd?u5qnIn{)@$P*#T zgEThXvsXhG;=n-`4l1d!4xH9@B0hEMdq7VO5rQJ%xDF_bSQa8g0KQCV>S0#BP8-hk zHX=(r`3{D{(L|s>Jh~O-{d39@&f|YN%rg!!mwf%sa|iJMv-jrFmKrlq8kRI+T#!V5NwZOkz+7^d;`Vh%Iy?qT3S&%iVd4Tom!W@tBKpzUsY z0U8e&o6RT0l4`HFzjv41B4YlCjEsm}?!9j-$wptDS2r^uFaQ#nHe{w})9o8jqEqd#(pJt1g@*;$}fTEHI7+kXpGD za7<`!OXZxSm;!k(^Ak>9jPei|ho}GqYirwN;m%b4#zI2HFz2X5x)DXOoXU0_)F-A! zVSb?`uM#i^fL{A@>US!Y2Rh!=86jrp03RSGOhj{D)l0?e0CrUTzP7p!eRIT4iQjAE z-v$;h06a!*`rWA4y_}AysPmJu>ptT5v8J#FMFC)PD3Q=$vAcRJ59U1mr8Iv4f+WfS zKVYE7!hvi7%(eW<;CSEYL;zIaq5=mu%Hx?%F0pZkeGsp6Z$~9Hs3Hh?jK`yAOW%9( zxBgnp5)O(*?QQ~cC0^mi@1MiNk9_JS;LNv?inwUIfQ!zBC0t8v31c@}rXz;|-q{60 zg;Lz!wNg>LMbsE9Tc7K}j%A_gn1E0`0tYPi3z!Pi%AH^$wQ$$dEZ%coWGH8BX-g71 z`@$yAL9ZvO2}8Ut^Uqk^bDdKc@i-S?yRzJq6-+txtVDFX#P7Abr-jPs{dXm}-c%}b zPm#N|_rcE?S(Jf#s%Ih?AD;vv)(rvmUPp+hb_&#O+s4$~Nf5gU7B8isK6Uv2!StT{ z;b`XO+Xd=Jk4z#xGB5*p`eN7`W)WC%kBeJqLh3Kkk0 z0(0$`l*jw~L^dqc;h_QtgC@}JqB&~}4?4Hw7JF9`qVoN#=xHqS?BPd(R>DfUa^3cVh(ET^ejI4$fJEZ^I`Vy-x%sshLl^*fNf6S4F$|)*M;{b=_Q=`?LC4~ zs6$v3m=A6@0)mOESNLorpdKWyLWCsY8rMbRUOaV>tS-PkduTtA%1m}fPV5= zGsEp?^Op+=c}KK3DpI>cRh%6Lb!l6rG8;VkPwac}v+_EP-E20`N9!&Kw3F7j1rXhR zjyZ6NH!FUL1q%!eJ12hcb_3ZCLd2dl=4Qq3AOyB;!M1I9UJZ^n2V#$a#q&lTEoTb# z+4rJ83&g!=K*KAbzBq4sW&R5Yg3!oAhk4_=K>WUY-!vFMk944LfD@kE_HWrrjMJY~ zuPf_NlnU2|Ie0=Nw@w@gr9%G=zGou0)f9(lAcXKsPO#>?NC z|NN&e48fsq|E~gbF-;FNfYXRWwC_~SOGWKv@$yge%!=tyrd-UwZ~qj4yuWl6Mznhq zxEYte?o}~31Fp<(ZV&q0lrH|yjxTdQ)`bE(aSn8QER`}!UU8?y?_PaUE8;Nz0xY<$ zdtTld@E`ToyI#$!E0X~Y)TKCHv)Xkhz7>T0VN&3o1@*P%jsf1A1$D+KqL9LI?SwN2 z7>mK<gNq7r5P_n{gDtxp z_26R0YG5~+M3uOO%Y=Ehg2&=#u)^A<={$V(Q@HwTXNtLUojbRX^V>dldKQ2F$S3=9 z<`zgIrPvuNlF{{x(+?lRE8XEZ^sWAC7VTp}jAN0VirI_6ycmoXwY*B=V!A&K1L`5u zZJ3JFaV-n=kt!HxAlm!+!&veMSV;~&HI&u3hchqquo;@2sbum;;XR-h6Ztp&N(Vt?XtKUb-svb{gY^~T}Kc^x}+alF_fDeadB-m zNSiuKQXEBGVjM(lC5AObitRE9a}GA>h3N7oO#!4i8OIL!Aims{A&3&zxs#ILE|!-u+HnTMAe4%=dg)bnY^} zc_sOK(d3@SPS4`c9{I}woVkSxHt((MhEoyvZj?jM8NU_BbHH(+!?BmRsYtyaXRc-) zHOp8aXn7UXo#CY)gFro`qDK|!>}Ak&Q{VH=lUIx8k|KserbLnjfw=qfmo940Ha1xt zJHBTim>0R-*2AJGvmbK@L49r_852W-IRHfd>awTKpUDEce+|HHF~vx*lmkCSXXv0l zKH0>zE6ZSsn0F^ZeQl+U$?4X%aOz0J@0>HlF-07AL1~Oy%>;ECUck!LPaulqdAR08 zDe~PssPCSw;@Ya8ioNxCO1C81!>O5~t`roZeqE0s=o#9a5|BlXIA>rP@q00tZx3g_ z9bkTytzeCGVI@<51?j;`T+4sCYf|)Fq#)KvgE^aAy$b&4h0hFELb-bfHf&;}PCPJh zggg@C3mlB_G>!v1O;K3FQ>^iB8n?>>ba{X__c6~`u*$ojC6>xMedxWv0{?ucK-5lz zxV=IYcYaO*`q=4NeDsk|^ySQLSg4`Wm$TeSGGSpzkSH=-BiJ5}JW105$1We(%LuBL z+L|_;n4P4*7J$iG6|SX@0v(phKs{ulM@f?hipuWD^#pHA=iL-s6F1NJ#ehAxcr<^*W>sY$}6c|$y zitRp6{pgW7eEusd#(M-Arwg+6EfpsBpQ?0|GCAgozCXwkBaEf1Wm5Q#EPv6EQu$~c zd|xo%=yX#|SNSp=E_AWNLz@ko5ZJI1w=Nd!B+N=;*~zbyykoBxb}Z=#ZlP5B&NsVew;^ zHO?HxoOy)+=Yw?r`Pk`M{PDwoF%Zn_#2eVI+fN(k?hJB}0c7Mj^f_vw4UVn@urkmm zfW9!W2uCC2n1PKM09DJ;g`ehJQ_^I5Te_Bo@u~;?OsDMt^^lt#Bnjb`I2qn^_k?x3{W+xrn>n zpuTIrJ^^Z-xd8AKm`gZF*T3p@0B+Sn*keO*%&NV0y|`@wj$?^%ru-O}Q69_(apoF7 zT5!n3D|F*&Ib6mEe(2}0@QF*xqCIN>SJAlhm;-0TcpN)DgFk%u&oMIq%$ubC5`ej+ z&4W5|>;f*^{F@*)_Sy~t%Fv@6KH=~kfHQ`5S1>_!YQYOFxE!d)zz74z#yvH)>UpM% zayc&+)kwAFXvM{dtBY#6akUjt4`PaZ`w`=k5MbX;v*{DA0ks7EV!e6RP>yLOAUIQK z;Xe3Vo;*5YFg+r_Z27a!vP@$>0vI0Zb{fNEcn&&=Pjh`+g>K8B zbm00I(?qrDI}qF4l1v7RzXh1Lnl3!ohUba=geAP#3b(WpB8*sJ`HRZcZ&hr7erB89 zEA-OPpIvzbpMLv)Lhn*niP`nvBJTW&E)a2you0vm9{#hwVD7?3i!@$BFfXTJVBT`A zyvSVVzNM}kK$Tdi$`|A0FA(Eg2M|IM6L0vxBj(zG;6eEhFbhWnA=c(_X6;punyROv%JO`S&(&VdxN==HbvIEF` zuhn#M>%kFBPgKyT3(J2U%qiojRIFTU5iQNlgZV4;Qqp3$f`9+PpT}R`^*#aSy1qOM z=AOo#UkQOrA;wP6;P)T?Q_OmkrFl58F-}G>%n5WaThhV1$SBS(nj^H=iCmP+d-3bk z^JreKGuP)Df{JBfvgTo`R)tgQ{m~5H=+c=3@H1O$iohHI_D$FFYQii-0qJ$pl;rWu zoG0Tv`}Cy&B`k0ALkCA8_mdk%;$`}L{a#&Pn$Mr|mh-QpeKUz!o7t!C)y7NflV+9C zvA3p<{)v8{)4<2E8#_+qq@|N3h6S)>&$T6=5jYcX1|c62&!ro`9puzQKSZTk*-=hi zcQaeWk(Y&UmQ%m$FKcZdrm;XK}eMn{iXLP8kQK42+6S zOPT2W71zowPg1e}KrkiV7nJI$S%c|3TcTNC_L{S&7OP<~oWh*XNFK2e2`t#?9aVV3o_(;Rn z#MhEbF4E=q19pYkPhI{k~8Z%xN4&PNom#0KK<9KR-G?zANWzn`t_A zW`g?IL=!7Z>$nl1zPi%E>@F|;Ksy2IlqND`&mV>!x+h|oPaQmIZ zutT6O50B~x<`x0=9}@cWtfhEXlnp@Jr>+&B>lF}<@%d-ghAgF7zeD@#DjjVxk>=2c zBiGBbx}uJ3-Dyxiuv_=$m;XXpFb4p?bLr|x)!ZJMi{*EgUKkx8-({Rf#H1KrT7j6L zKGLXRb-A4sWM@HrZMB2hT@w%|4ebo5+qUQkMZ;jHKz+R7VsSl6!$ng0vK4{3=UF%~ zSI6$T8pcLz;Edy|XIJp_^J{P`KoqJRbucFYI1~Qg1(=KHlqVL}Oyws5eQRJY2WzGQ zhM?a$^wYyf-bVUCe9udg@3s9#a;x$ZS_2q@N zw5mG=>b5N%GLW<$dL!=ys2|*2$I@3;wSl1Lp+>427{J_=hdYn8FgrI1MmYjMKp4gd zf(RpZVe#sC0FBf(xa`2QERwo{m11{sn1L8{;vKP=vMnK~F~K}PHI#$7Ru}ohIL5~s zSk_jdLJ+c0JlConAaU=I53yAji4S-mI3p8!h{eUoNJgx$N;$vQ!|*_lzqX=0v<*!ntwZ~3+T0`OQmuR-xrwkyl5j26pYJ@V@7X(3P#+G`$H@#KjW1@y zax$|xW{=5IaULUYhN&#v0S+)=a(1^cWJ^Fz7`5$;q1^gPN0%KaZ%TSI@a;F0)58D( z`sP3_Scz*-2N}xUbl6@s3jdIcLE3`$* zfjRPEu7i4om>hb@Fy*%Jdr$ubUO#<*->j;{#U5)iQCz$nsjO53N?XX4XZ~bL1Hc>> z;8Z1p(I3nK(|UYp>WkDxvsp12`g2WPkPW-{ZXxz9GB{(|u*^J^HI$Q&o_czvPs#cb z!HE-7>9r`6sz;fj9E^MMw`5qjt9lpNGi}vS?(ngF`I-#y7#Gv%@oZRbCLP=V(4UFP zJVpvY{Xm_^uH)F_-} znK#G)Zfw+rS8)*p5yCJ+7(|Go2vHa#ikSEd8D=JgUdD0&Vw*-GjB|`N#bm)~!j*F_ zu4P`@;Nu){9Rkael8t;j^#$|H1S7*41NO|AUY%Z{Z6X2_h$N5?1oMPDUyX44&%6e| z_XmHBsXoSU05E1XaFaEQ&3M>*DJY9~eIeaOF{o<`B{6pm0CNCtvQ=#uF!wA6-Vnan z3u%j>?lab>9wZHO2*K3MSOF;V97yZZOMnO|Ad~GN+fK}XUwn30{kchp_SI0YSGD}r zHyOCt(8{>J)icJE1sz3-Xj1JtzVdt{t9VW#DwTCu@-qO&7X zWY5v8J7_j+Fq#pyLviI&JE4})013=T; z;^8%00QG<-`tyPU>OuRb>INv5Z41ku50Rbdg#C_6_zTZ%4$yDeUjs)r|4dyABm&uT zFE4d-^Od0O2laZ@MrHi%>XjkDoW^13I8IKCQP^X;?bWNTvBq8v{*Z#Y6klYHQf-Yj zuyB1<&GbB(Om;x0zP{E0FfBlxC{4^(bn3Nw4VC&KSl%Jn)k6Sc@VE^|*8#Q)PTLSm z6Hxm_p=UGcm?9w#V0kUV^=r$h*F1!w0P`@U2qT6tVu&Mg z&UqYj9GI%(+FF3FPf;NpG~}pxHfl8+am-UgI0fQ)(Y!uBDis?&pQfPBwGLYh=H}uh z3+6KHwp$zc+*1_o&gPCve1$Y3P(ZF5!RhW?bNkJO^AxK?aq>6589#IK|LSYSE@{6t zg>ll{+4{W1#C4TL7To1M27oyPcW&8aU_4-p+__PB6!8xUWyWR_!T^Mn4g_-mc;J+h z-1OfDmgJ;4lTzTO<~c$L7OpMf+J^P#f^JU?;y{qu9;+L?$pNCo?^#B0ej!p(C38an zBM{r8Q$Mu7nno-$fXhVuIVk05c@CyWDwrAbFg@v^RPDNP zFn@~xRZly`iJ9@T*ZSLXJY~Tg5c}az9vi_(;}!AymM8^tqQG3&ofm<*4cI=#(I37C z?|<|U@KY!M#lUPT#K93~FD6Ly8sw&bdCfN%Rt%!Dvja5902O>HmWW*$f<{n z6^agW<^Y6X|H0W(uH3lSB!KCBkV*j6f`~DOr=DINT&EJc?L;e`*Yv8H#=AVnxG2e_ z2wYl?G!9Irq35)HocfVt!b2P(HcD1rIqI&Rf2t_Fu-Als_?djMlRKsx3aHFm<0Faa zdgnpCz1~F}vuy+Qu>DNF5scLxhY9K$z*$z>4%-3hvtwR*-;Yy1f2Egrw2Kji3^Yo> zJYoruGf>JA%RdIhlq-w&g1wR=Q(v*cF(iZRcp3fc`#4H6QAuxU@oazb#Uso z77p%j!r8#lkFStMV$ck>Xtx0b3{_&|?q7X9e*M$Gho61>&tj@F(La3v6J!L(?fs}j z?VWu&gL+xn@(fE!JYr>Z=P(W8l0_6D<=gZsb&_T=2+SQ~p`P^^vQ^pusQ2PHeI<=i z@b1(|B?FX-Nl=S;uI+FUsj>{15}0$rW1nB{Ta_}JnXF)Ps%0`J$SyWWI=|`nx}jVY z#aLR6Wdf>@$j({Y1L}MB&ty3B!Jr;T{%4EA3wzDvk?;9Wz|%ja7h8x+B$!LNxXhfO zGX4Mvc~;!XkGzB8_oanZ%*;&)kvk__62JF)KALpBkGMmoAf6Kg}*q@%ue@ zPT}&S7xT_!xS3uQGhDp5j&e^SL*?sDOn4=aF7vrfootx3NTl_wA;0?L7`mVr;iJ2 znx&xyvCm#LK$41VGEoo5wh^bUVz&a9;3ZNVOgS1jt#tcImCsF zo13)y5=Y{*7wNI40AN>aj2@oA%n#g*```7gc+MD5alPs7SH@_nWg}Q5S zj%UAo4c+eM7Q=TO9g)e1Uzm%AOjgii=~1q0{@ZsN)ax}1-o$sA5Bq^SaY5r=P zjq&7@%ed>VaRbyj7v2TuCabtI-$M{`*p`^Y$EGS6p8%HULj=A!@TN>Hq0_E^bOhe6 zTKeJF|7sr5wO(m_+5F>g-UDaMgZoemyKg#*S54iES#KQj#CWUdc&|R>z{1VeZtSzB z2S@(8pi(sJ^Gcp0&vWP{Sy{=cYD0oKAo_?}B-~g~m)7loDNWGNmjHmNrl*P4lW|^9 z%%KeB)PMNQ6Ppva1He7^OdDJ`m-v!aD8JY+IdwtT7fr+5odoqej*XVEOa-8xSic9| zt5=+o(+x`jy|X(1RBL=}&h!*luwu}@;>7eQ7Ux%CTV%&UeSNJ18dKPgG$hy>s0Zx} zsOj~}8blgx04Ddx6H^0I4#Q?2_D@5&yb$fciN-Q{b z#sNkdcS*S$nL&TrYb*pZ=@oJov4wMesZuj;$}EL^teo zDe5&FQN)e1gkg+o)dA;B)ISEoHiKKU5GSA>#w^W`abVy61~>o6=`AI^Gr`o~V-)b7{7 zh7F4l*#D;hS{O4{gypdoh^ngEw0rJznv( zOoMY^VJX1$WYvhrIS_;ljzi!&qVMVC`xKRm@QNn~VBBLMApvRxj%^`~S$Z%Hz_E9q z*c<=MGwTqBzd~){hYU}Bc@4K58o|t*mrm$%aL-Ow(QHtxwnHJZC*pgLwj4A^9Xx;W z>t}1;1vU>ttW-o#l10PSX;-=R55rD?PkcFg9NeM6PAXF5voFEEXH|y z&%|f|(_$1+>&|IhdHPD8QzzP=MiR`eidf7Q6VZOnykpL=9*1Z;`i_rcP>(r4IfH9$ z!lh3J)TJ?;xd1VjNPuuAbM*Kw@iYZWQRyPR^dK%>d>3G8eg)STH@98w{*z-#+Oo_@ z%ORN{g=9R_Sb9s?!bxbM5_2fH?sC z$w&V+s#P0n?MU-MFQpC~>+Lx0SJ`q?%2BV$HLQrhDM#3*h_>BGX?UKkJC)?XhKA;t>p;5@yC zOKcG_UIK%_9i;k!QH>+l|1^M4NP;;4)J6w^dH!B5^w+}(?KsNBGpFmdD8@pshm|12 ze9y;97-7R*E1AL~&Jc56Fm3>n8S{H5Yw38)CZ%7Av5*CGK_Kc#!C zOU8Dlj7%?2iZ9aZod~!#K!TQKf>Pc#vp~qj*GRX1pFI5UjAyy%hLaibbYkyAA1Nze zDWH#yjh*lHqFw;)KoY+psHaY4G9V9v(Xo*m2I>pfR#aG~9Ge04sQs7oV+Tt>YUft!;~`@Thai=Sh`J(GX*r9BXzf!8ruyG=4ROeF_+b= zmMSMPJ9n8uOi_J`uJ!o$-#v-O)DPms;Zd~P5yC`&F9)uaMl3Fea2+cxpCrZ@{D3Ad zdox^7z!0}NEK1S^f;@<3dd|ZgcaFlgiLyW7Vv%(DY7fsmy^5e?a!<0IZO6jshzrlN z1h88K*`Dx?L_LJK#1_%T*N+rpC`z}e5hNnNoXA}Vb8m#eDwKbggS-TDIVY@zA(jFk zu_3+|nXQHqx>01z9|5IU@`Fu*x=(2dm}`*|dc$jXL3bo=04K@%PnY1Tk82gC)5kwG zzrlhFs@HAoKQNh=vB)`=QeP(XKOrC)_L&e17q9vQnVanb^@DqB`3G9EDA;us`b%xw zw$GQ9t*?}(*YPjtWg{TSdWg${`qXp_ByqU1)1dD6LioLK+d#eB>47u9pd}d0Lup6` z4@?epJ3xJ6dKC4Fom)Q;WCsUFyB8yp;`YQSF4i2!FwPAil6x~{TAL&FVy&t=o<8>s z5~=I;DSM|VjlFy7;2c<96$_bkA1N2tlrk(X2PvonQY5AT*>H}Nlz~zXL;!j~+!JZi zq|KV6E{+@@fmgGk@6%_Dquq(|^p{t$a4k}*I)b#vQOaRk7Amd{$Jwx8^y`io7_PHb zbcO`=K|1W01r0KavsFK~9D>S75pb6;<>X=@J4g7G;(D)#)i6kby&Y5Z;<#Ww5pCIx z^E%*uM8OdQ&dq`HcYejY2-w&Ze8uf`^u0(fr_ zsIM%oL9TAil57stY5VUA>qSI_^iKMIFQ)AQ^;h4O_m6FYxgbh8)_Za4%2nKOka=h?D2j|Xo5cz5nk-wBOL=i<4QA|z^_J$WO?!dOT8%!LZP>YtZwT z4HX^CB88S3XHE!EEflp61Lh^q0d!*_US9}&w8O9v%w<|W-58+v#YvD2V_ z>+u7H>GpH~8gv(OC#>nz7to2f>x1d!%8HMYGr~B9Gw~JxM8pnk{QhmA4{0Li?W+^_XaV51tqr8;Kl-CO0&z~Pe^vCH7c!XJF6 zN3pmPq1ziYIf#_1p1zH1D_~xp#*rhV0D!yiIg*BjAw#I9GwUszd17Sjdk-Cep&Cp$@2s*+GA1q+^0T1JoZpvve25=^TeRVa$SHH4` z<%L*DE4Zw$0RCZ|i_pi{2gZ5169>l%ZNMv^FC?maJ%5{R_L9DK(e`gW;gekqufI9CNy9Jw|# zXTbdvk8Mue4gklFkLUB&#=6pz>-91DF=7$CctPJ5y7QpE`^bB9=?(Jb?zrRsweRzO z5BD8?{iFWEr>JX11$$r22@*U6V1c+(XtwHDU+uyo9L%yHH!AOh_4{(l$w=^4oF_NJ zhqHcfw^!iJ>d*(EZ0k?5Fi9tD#$eleTmkBvwSI3jJnWvR;^JZtTrt1u4edT=9K9%p zOKibeb2X5pm|c7WQM0t85+EdMgJX zzV@SkGcevuNz*5GW9oYj;s5@pKZ!d=j~B)X5hFxgxV4RnBbN&4N-&RiKK5Qb|D&J5 z)i1oL9*99JzC-#8?KC+g{_7#!+*?~lMr;Jq*ZN~cjmi;x@RddV? z0&^M%(b(KwkM)Z)P@&gdTfZiYlP9?xk(PmCwLLjGnl{`{bLx~bEL@kT$ZZd&PCH+O z?x`)`RGN1X0)tb}@4ws{r~VypJ!Xj6Who3DRPx)6C@2%FC0*1m3uu;2IHus7!*#7hC#c>7#J3n9tH7}>P{t8-D7s4&>+=*g2xj+qXpB0k zK2ci3bI#G}Qe3*&6S{THbK7L=8^cfi{Fg7|*?;*Meqi_8@WWsDnbLSYUTisBCT_nH z%;UC`ci{0i{=Nz3KwjjX&Y+h12sQ$41Ca$p1PCo4 zl)n}bSSElIEnn@|VH_40qIT17Pk%74c{YCVe>#ls`}Tu4cBo}Mw;=as>+d8B)`GMO zawyGPlHkrYM>6_538?FH(YHLbTRh4!7N#$BJxniP-cU|FfA~`i1It=QuR1xFjJZ4q zZrCmM(ZwSW7RWYmY%zse=x|oOVRPB8qW8cB`F5!_b*=Z3)Osrwjb1QJ-#1m zt{=`ZQ|Pbu)t{@9_A8{j>zDO{7;Tg8MVBK(kTdzs$==%=1L{lHS71)kTLbl8`8bP9yFH5KwFnDKA^d=Ck~1G19{^r+&lG;^ecyunA9^oXyaE1sJNDDHz;l!0LI5E zm>jQybEN*=ZN~zS0f$?d9`i8Tbkn|R+Asi}PK3ql0sJ+F{RhW#W%zog$Pe+8Kk?&* z&lq^>@(0;q=P%>~vtso!khM#~H?tU!oOnO|IRWNYvZD6EV1DGLQJlK#X7qXi zdOaV$9{>zEaq~F7?bUm5et8imWayD%-W#aZj zW`C6`CK*ZR$jc1n)L2q8&G~anIajO0k`TAolJXLB1p<9u74ukj&$+@Pf~(g9aAeh> zI&Ckg?>+k7qzuD*S>&j^e^8u(sqH`Z`bYiwN2zObJ8c*MoM(-tB&ajMX<=-%;`PGEYvWl3DOO28=) z2OLoZEQgU%-R!jr%hr21Fh71v6DN+gaPVLYGjo$Tbjv|ljtASB28*xf^0Dl3yy`7~ zj90xyg`I!uAK`^_SMhVd{6w0zE@HoQwTIoaH8e*YW1%C<%{hl{Lmb+oNjd-l%#FH@ z{d?+ITnQnK=PXO~8`~xrbsdb>9W1Xzh++zwh(Ih0U|e`K=yWI!%({5-T)yqTo@xEl z`EMkNf)C}%>`&$&MI2-}dINBwan?g}=sL*vTMU%_rs8$|PlS#8F=idz`Nv=|Z`2&T z>pPCa?}g~~0{FcUK@h?BDf~bfQy!cdLDQ??>GR77BC5?_Nt5&ea{#I6pF#k87Zi2J zM#U1`zjRt-a^@2F%v5byc;MChAnkI@_*O>E$Wz84ovHfxPyfir3nVc^(&;TwVJU?tT85oOVfUEjt zBW{LMzvoyh&0D3J7h4l>guGZgse6197$uiDJbh*!G6Pf^1dc~Ek-b*BQZQHVn`st- zxvI~tH#c$n9lLPi_Cwgcdm2#~g2e%7JP$?_?mS*HICY&m3%`l>dJkWG@=EG-Cf#19 z?EtuVrHj?|2+}w%UkBmVRxUbICo_p9yW}dXXAY79bG1lL?(o?!Y~DNE>3fA9TE_%J zpo!nJ*6l>Y9rfn(=gcjlJI$#dJ-&NGU=9Gi_KRN|Cf-o|ez)s?dIJ0)KmZ=Ygug5i zfKxQ5ZwEPZ1)OuCx7=Y)eewDVZaKO)d1kB+u^CR?@AXjOJ_sxwnpC<(fnZ9>EoB@o z&vM?xh`3Qs{lRZKj>n&V+_1qtk(izyN#Gk0ZD(v7$|WfBc4|NziNjvx znqGD2>|i$EH?7$-Pc!xW@W(FW!ymg0&N*f#t2ng3j??$e;Gs9%51?4j)|vk;eCYQ+ zgpWUR6_>8`G9o^n?n76cwg|s)sSCENj+ z*u_dFQY%@YRy`Z_x{WyESY8Veg+liZ&H;W=fyg!|@I# z6>-}`0PU84iJo?G9@UuQ$UH%-YH5WnsfGsTciuXI!-w{u)A8Z=0{DIazef=S3}MI+ z1{`4|d={+t;+*Y@Rmddt2lFg9Nz;YAD3eT1MU$Mm80)V(Ju8BfN^q7{Ll#)Cr$;c7 zbe_y|_mBM5g-suo`uYc^QtNhEM^&pNYnYYGGjyVS7cb?ViR~n(e%F0>ZlI=ug6_&+ zH75th8*Y?U=KiAq>JTZ{Sk{4g48VdldJ3*|7#Pj~03ZNKL_t(*iw3y?oO%$1=(Ky< zv#oRL)IXbC*(yG#DusTaPAR1I`*v{Z^+pw^4mWf86l4t!;hPyK0$IhWThbyJ3as*9 zRfvndCV^#(da&Grqc|Ta&ezjd&x#g=O5$*R(Z^?>T*9xt|2h00Kk^4?uP){|_5bmK zAHcW0?U(Su|9&n9=78YH!{nU!?4EqefEO=yaq&t|>AbmFPM!=%%O*KaUr)<%2y9yc zxw7vNE$Vp|cFokVYqp9;-4QNiIlvik@>mPU4v)cczP>HrD|HXQ^-I59_)Hw>G93H< zp1t3Vqd$B)d2s;n8k{=%#~q|A&!$5lCm!RsLMiqxQQUTsV6tkS3s6Klm`}DmeAio# zC!Bcz-w)yY6hS}*cOEc=Aw?81gfYj$s-H>Aq_i|dCU-@JAE={v^~DT8Iq>-s$hhkg)!%7PFpt-|VR8*80n ziStfy>W#XMkv;!0^aCf}_-L=|`y#p$spLSN>$)!sQ?ug=ux|jU zU%RxB+;0!4hwEQTVrI6m=^pb)!EojrVGt*E*gjBy(_8KkE71b*mCF$M%LoT8I-nTx zT@kNJirvfV#FBAQ9VH+IxHHg^Oy+snASn}nKmTF}ANcK08RGXp_|HFu|M!Du`lcx- z63Uc&SjMIIJRy=_SPF6O#V)emGWD%EmPJsh5F=b22qP8@V!ND>2uM*Mu?TDnX`l5f zHfE+g?4GS*eAI>Oh;M)M{s!Lk+F9IoWD;{Tqo~yedy;!Okz23e7tVeVGbLvPB4 zGz-}Ld>~oA#&m7&~lMe0ZOx{Z79+XX_T zB2sOY*G|~D_ir<&!*Kp{F1Zeq8?_}~Bh7!Mr5k-}@p*VEK zsT*Q+lGmwo##6^7go|{yDt@mwD%d~e;oS9Jnub_zm|!l-2SkLy(m0fz;GDsj+b zRJAdbuqtcMQXRG6ud(!mu`&==*K+a4`wosl>HOtm*YFSCy^PV;IDmQl?uX@;%)GB? zWXjFC5Hn`EZ=NjFmRCdg0mV)G8gN}rM6Z1j%OY@HAP9J}MNb*b$-U<>1;QwXV-t*y zI%?sSE=EO5ScG7-SwVAzBaEfal;M_}YPjX5I&7Q2N}tzAet}}c zDm|5Lmp6^4pZF3EA3luE;(9Sxt^GDb0=H+C+H_1$R4~$TgbIpkeX~Q2ni`(JJcoYHrLL`^!1c8NFr2@99{9nf_1z_(?1-tm7jeyMl*5Ge5NW{S6PO zg=4}inlcL_S14*eB$}ZdhqOZ=IDc`lL!0dszu$G=k}`{d;B2~5Lh}FzJr{45QONqd#YU9z^TU_>Dyh_Sv8r_(Iu#B-!$?Q ziN!W@>hE~#@ub}ph-Xtw7t-JZePv5fZ&(hz4EtRqGA9YBTh8!cUiff8a8cNozjPK+ z7~=09|2wqXLP|0S%!{7MKf!5>!Px1>c=l^+SX+;b2};+S69Rai1=}XzoTR?;jeYNo zBZw&G7X$QqG~pV|Z>U7_1fFYSwCQ4E%)|It1@)Q@*OflzizjYkV-=Rcb9-!9?#Ud^N z^B@D}^0#7)qi_6WA_Jeb3QzPk%$r?O|~_L=a{i zyJyI<0LQjauQ?cL*l0FgG#WO%iiL_RrAjg%q(|UtHPn91tw%+epo5mU7m;k6Ac{Dy zFAO%+n?1b`zkUBNmp&&T7$YO4&z(fOUPj+O^$6dVSuP?@qQneCM|w5hC_(fFKZJc0Zs9LILJc#1O?2)P>_BN*QXd zlkB!A&#U2>gRo{f7;~$r5UcN~&(g$~iYrQPlP13G1mOKuH`9==;>u zbU2{PGxd4mb+6rnpZW1S@tePJGBJ9~FZd4buj9Z?6S;3l2+7P*=ALsA2;=_j86|GN z5upC+d&l5ZPYjV0pmduY6MJ6wUxs^W1Asm;F|o3`v~pckJ$a2M9!z8z3P8OzK9X`N zHv-hJU0Kpfuys(UF#`)ibdc-sW>)b%VEJ09BI2$!#Rap6igactAC zoLmDG3${aGI|P-A1L3?Wu1on7cLUJZ5+>uT>qq`<+L@ z8B#FsbrT>DDMDX>xv**%pdQ82CPM)GRHIs$BOyT5cHmig&?5kvj*F(_mcCndFUR>? z9^94V$ia)Yp#hw7qghPnF;*%)NuB~I_9!O-cyhXl|Lq?i!*Bl5Dg3kl=b4q!)l#1YbR8N}+Zd)Q_FmH$)DAZm85-J9pl)td%~o4I17}4S@Bv z&L>*q&F=$YfZ>-{0h%%?BLI)#P2CUjwLeVm0n4&>RHsg3ipBX=Ois5nz}uQmJ?_2$ zcXS*kr*7)a%XI2N5TVwnswN_2%R2SR*)bg5+rYCI+bO56I8e1MO{N`j3Y!eJG}hl0 z@2ka|3}xEbZPYA0bZQcZ4~-*^C}_;^w@)nLb5E^kX_REPK`;k^Yl{Kmm}0eE;7W7| zFxSHz+d@nk(vu@I>!Q_mjI}ds*te^O@m9q!I#ObI(SNI+1wY`3G`*+d=#@L*z^Ay{ z>*4D49>!V~v|6s=<}<%t5$R;enbOtEKjEzoX}^$8HaIvuSF*LD4@fD5OtagIQxA4Q zD8#>hNa6bwUpqHg+&+7HAKta++Y6srurOzhC(@q5)DQG`Ri<&v58R1oe)DsEE!raw zaJoRP=3r*ZgRM{ETLg2bO5lxd49o%G9dF!^R>m^4~%S zZIY>*#!~?RE?rne6f=WS0StDvls2nVKYq`53`iNsS{?T~*Z#adc5Lu_32g|_!`S&1 z0N)1|CtqJ0$Q6LP6vbB$Vx(C^dp$Aax&ffRoB%q~l5GvtgCK-U@DWF8tiTd#rFZNMHgB0EC>PI+UA1o#P`gB{J$uH#`gPdDjU{ zPfj3=BE&I898-Mz+yrhvejOkD{TB=BWj0fm>o1EZX<;cu98=6MhM9Q9Xg(-S#}@rJ zjIt6273ciLE*6$T?Au*KrJ@Y4vT0Xbz_u*}p|DOCd-gS8*EkZ!f%!!r*XDiHsy4=2 zE}Bgj6-TG4lNy#Rv1dXJq1k`4e7SJh98K<7A{%Z@wA&g@69@cmQ zyek3o5WXKLp5SN#=F-N28TJiQ+^)7qit3J6E8t8Vi#oJeH6hy~038m@Ekf|-hlGdB zbRNv~bsz|Wytr~atryqs&z|k5 zJTfKQ2~fXze;u`nclA${ILJ0Oqx3fh6eXAQ&~*6p_deP4xsb+V|90&iOUPW|V#I#VNElT+7HNY)vhPA|!u7)!;ih~H}s5BDBv zspK+cAZb|yQO*$!AykTacJ(blT?b(T;0M0*R!mQhBaUM*$^@WC6qHiz+C7d3?~&Ux z%z71x--i{w&o2h}#b165^P2BxWko;u{h~12Ch#iiIioz)5lVmXYwIDNJG+jn*L_40 zOY=;*XRZL(v4uZ)v3FeqSS}V>F-5X3Uc~QoDK1^<;hC?j;pyjAaq(&w?RJzCzndI; zHg5&y`hufq?{5m~#v(y1acL6n`*{gSmfm^t9fjczY>bk6;j_)sw@W}B!ts?fJ>$_TP7`dc~m8Y?oCGf!DlB5(<@1iDyUmQUTQx!bHm z-e@o@UN73GPGgF5mwKuAJ=+Gr_KV*idi^c^6C?R;kWsk0HogB1PYqF&Os*TC)#cT{ zQC}Fyfx6**M*Lryek};W4F&b(g*D?NZ57l5Um6Kn#+xMb3&>6`L7jt92EQ95d2b)6 zzxi8khn>+E=@WW79Fnkz(>@(gkk9hmnOKplF1~lh!@hkppp+tx;}p~>rRndkUHXY) z3XJk;Zw!pT@_bthGb3i}J1|YTdbbE_RSTAdbRttab-~4kA;X2sU3~3)8|$4&oQP}} z&Mue~5HQJkYuvd4dY)d(MS%=wMMvjl=#5jwmhIaO=8`6En(n)OjoT0l=$9DG_s-Vw zy>B}%4qWL4@cjtA9##9ylideG)Xp`XxsdFnJ0_s?%o5BuL!CG(06pzmuQMTd=+$$% zKE?7(daloB_o;&rGprPplXlG9>m}5kHL3e@AlK72kSM{7vu74nx%KCnI&LSZpSb7k z<%#4Zr=ldi^-F&}L=g&d+yJewEdQDWIRGZ8a|)?n)|-lW`%oXL-cV4#a&bXx8oik| z2kM*yEV^Q(H5k<81CDM-85(UDsMkiS_*QLCW~wqUN1Acz^WwdpA!k^lc^=+ek&CA% zZfT|>cA@u^V9t{;bsTA7d*q9@aWF0$L>mNiNfr^H?pAD2CeM?XUgeVQX&h*GVmx=I zjq?{f==5SS3F}-li2R_vJvYg1E8J1AsFb80{FB)`l`56QDaa zJB}CIR|KeoBn}WHh;P46z0>y5ZTn&&0TX;Tt5c8sRa6>{G+G|i%f;_e93u)sxQTo> z)twUvQ0JS|slWQ0PU7RA{UrQE#lSgF%breHP{wWy908{wTzmt{#X*)VnRz$$L zu>4j)p8UlOj7m;w64*;<*jMmt)84m!wiV*W# zmN1laY%9@~Bkd1z54zC53pGj*QDIT7>HJ@gGR$Ii*~s^O}A)QVs@4QJ4@9tsV76G`rc-_^DZ@4XZ^t3u`HavUpX(yW+}z*I?s_c zlrzIbB1DM2^pv1<=L`y@)2D@p&!}|dd_Z#TpJj;5bj4e1t8FYUhcIKNvp(b;u0PwV zPW_=bl!)8=*fd4{Vtd!kZ~fSSY;&|>4jllNmsUToJ|Y2lta0kHLK>&eDZHsyr{b0y z#i>g!9WXoaW;u0ADLCyJ(FTLM0;ILI4oJ4cZ3CzNeQ&?TtO3stNZlkP;tT<&h!QZD z>k61-F-LNNvbY>74n3w|F$IldgHz`Ksx1pV*T0KByN$K-?m@HSIy0=OYg?^{IZ*{c;Bt}P6PSjuT996VLx zeie=sl(Wukx<18vJHqN(h=rvPSLb`UHt*y5f-t_jHXmSqF~Gu7fW_qyYwZYY?I`6M zb!o&_sK>*>kv2i|pSqCe&@)G&Ry5IS8SNC9e@9}`E)QJkbz}HJEOrp|vuJ0kk4UwL z4(6L(VEH@-Gv*qt4!JrJyy4zm5DWHVFi)=`7o=IP+>DoU&YWXB+0UNUo$LB-nY!3d zu5sX&_C4f$oMHgUqzfY~TSpLrXTGdXXw0_5PI2nDohlHw4=_;fuD|%{A+pTTrU1RY z?*F2=A`t%Dl@)Xj)L8_8gLr!}(yZN3P+wkHN1QW`)2}xU>T$3PC5b=@sAu@=1k}So z9F@4;pnmJ|1K2%YO*1Z^lNI-9mQ5>j!GO-b)9EE*bt(W|=hPWvpm8iD1rAUfH674M z(XUP;4I8KL9LMdqHnn*9x^Kjqy{HX_0dqagTGhgM%Yo}?;^_>Sa?TM&4D*X2&Ryu> z!j&#M9hzFX14u2&(|i+d-L?rv>NX}@E~ds@jMS2YTQXp+9|Nlv2|VTSQ_;N!3TAoD zMM-{Z>blfGCbxSDC%fROxNaLy&yB0zCU0k@*!{Ta$Fw%jU8~Qyv1tGw3EwoxL z_RQ6A=s-j4e;=)&Qjs3%5;wJ)?p<=!DQCw`@Xs#-veE|SP)C2(4-_SR?9yKqhIhDM z>Z5%tbnV>b0=>EVvk8Ztn}QYX6qo}*t69-3+T(#1?UbU>qFs0ZREw?6QkSVkl>u&< z_K`+nZ+X!46JC^m-cXL`#}rX>yQJ|6!JUtfkBPahfOF0n%2|RlmosQiPfoIiaxlh~ zp0-YB&n&dhTR45Bg(6B} zTTW<&+-`P3V!k7;IUcxU40Chisoq?GI!!op#ih4K1jm_tGE_zg+`9Q4Y#TUr+ZZg1 zB%*3ycFM!iL#DgXjf1&a^UZ>}PF2ss)P#$Xnw)1_fsFQ8ah3UKji4_D^{ zw0m)yryK+FTK-u?^lgg(jk<%mnJR8Q*u)*jS~ziJ6bJV;FgsPnNW($Zvvb_I$;oGd z+*AW7!#r7U@yxL;)V#qCVXpsFxdHAXUoU;O8TwZ*z8{FKQe!w+fWE`Z{3&91tNdho+>{>ye`Ab zwyKqg-;FrNd%#oAtmey~Yac!Lt%Lflr+!S!WH^(x?)rsIiQ9oq7{y6iU-y4u7w|_a zL<4nsj4IJUkJun~9j);OR+l@lEr2o$oU=r7wljuufgfURrH#?C5n~e1g6~EQbK4n@gnXg_3vz+R=nzhLP z&)$27S#p&3{@?0!@|igkcQz-5l~!712?>M}A{b!Tq~{vn z$E0gtaJbhwU=wU?!!;%eB$9-LB$UIhHq7qiop5r8s^1^g)m_!yC(fCf3JS6Y+PoY{T;y8V!nSjjuUw zIB_jmhMMK?zdlkjkunXWQyPYf++p*nV-?(U?`+$9@%R^yV!5$^k<4W5yBcetLK?^; zoshD3`J0da5q}_)VD6tUdda#;Cz$sW0Z#eePy6`M6*#tsD-VsK(Qtj3hno3X&B3v` zHAt%+;ZlaRhJ(7}VaT#NMsn;V9t)S9Cc_-ccRC?>*=@T4AQ9wIiJnuS$r8>XwDy>p zi-YTkPL$3?-MKD47-<<%P7^<_)OROX4FHCP`DIjUp_8DnM9IBstWSjaefx8iyZ-7C zm?Cz2moNu_Ms4wCo6WQ7d%p@|(>J^Pfe zrECt==gyo(aX1(2%+~{T7TC5UP^ZdKkXn<@HEPYk1Aov^fAg!)!=HZkDdo3{!aUl3 zRjK8@m+VXp+<%1kbDX0e?T!J#>b2@IgcmzK@wuYrO z8w^0HXky2{3?_zBN;E9^COmO&Y$OHGV|eyNe0#%a=L58Yxhm^{xh&iaZy=vDuv&Ie zYq%}*kk5G@;~{0ME-Zta*z*|!xm@@f5+Z(j@tY$E?<&3r)aRfy#6heP5)2LizU8Xi zcDanWgeP}Qrjjm*$!~rBcks#A|4HI^i*yZ?(2ncUJy2-eo|gFi7nbkFvAdq)P6ur? z^r9Q@UfaPuRqTDEmDu-@w9lL>qgr=ycy9@w7i#8B+r{+RsseLJB|9F)s%@iWrPigL zSE=pSyB*BK&$nD1Uvthib+wj^#dXrC2f4=M4oAKxFfIOUnwcYE*_83$jk1VFo&@Ej zrD|$}BAA!bgy$Z3a2ZkAXsF+Kt8Z@a0p_l~T;8_tm0#{UK}6OSpK)ci{=G~#`{LjP z^AMsd8R~lJ7U<@)@EmW`puW7g2HSRFS;oMiF7`SP&r5$3HFeeezA(3fy@ja&-h+br z`4{iT!Mji4+4-7UH6S6a`h9SUGMu+7hbs;b;lc~{25ZY**9CPw->Jt7=FkJvyBlsQ z!6U8#xwL_6FDwPiay-ht!^1V%a*!3@bj&2EQ{cH%A=K3lh_|OZn8&sCFwex(Ek)Ep z*MX5?6GNVXl{GgpWNItO*P9;d^B#1aAd@mMR5UP@H;_&n&~Rn&{}ITNMf9F|ww$8>+-ZFgh-HA~o@8cY0sjn&YAjSNyq z6AOme$uIav{dw=!CjOt|6cu~`03ZNKL_t)0>ze?osUGb_g}DyIH1w7**MQ8B2HlFc zJ1Kp)Fc)cNmg-noZD7Yp4yAkwgaN0PYN*>@B)yu>r4$X%P26my8)+~XUc~>Q9n8n_ zX`FX(6!M#*zFQ^FweQ$3}TrSCa(0I*r%eZhgU z^O}IVxY_=Hlt0vC6T`t9vsrWMr=Ob-z8ln>I;Bi`2$V;G#UBhA>aOczb-5BgkOUai zocdedbQJ_4oy!|^SQuw7eUWm86?g|{baIfmkF6PL6kaNvknA!b68B#zD z&!b@oRRL`;oF|l{u?ee3=snJ_87*1Zvoqt@H%`ayVV*4g!dxy**9k_4P3)LVBb(L( z7>G-gmb{6wU6-L;buc|s#}h{@c;cBg96edZ6VI&S>1WDFr**ZHCSk`cLreWW`h0iN z&cn8ddY!kw^|q%%>{=7Q@a8wQy~YDY6-}(NDppt-WmZQWO}Ow{{w6}Mz56v-e0s61 zW)6*@;4oOypr94Zx%1n`!CZ*zGMt#N;Gttnc6j2;%I*wvBh5Y8bpzN)n5*X#u5FVp9tFL# zPykiW?Hc9)@Pb3*$Yj$J$fX`kfqPVYPKK#`%>2s;0dn~?%+&e8bz|FaiPX!#n~}U^ zh9u6(cXE`|!b=?6#ZyORC(X@)`ipP5A+elxV%KKphsKZe?GOj7)8q~SXBSugEuSBI zLuh=ELGFK6Mtcle<{&cJZ=qgm@~C0~)Hlxj?s*imrx&qf_XLFLdJyLKFoozv#Ch3K zPAx->Gabi8Wvv$M89zw#`<2&UhV9nTXc$ysYUh6=OT#F`NYMn@mBpzu4L*Q4XJ9Us zPQ-Hw6blB51p`f+Vy(;_=-TBW1~Y)@p!of%H#}5pE*8#)8`4;&2FucrO&c%_f}y;L zbV>su8d52OLe32G5c%=HVR@7?RBJApzQba*>Y`G2(QJ6AH#}5oE(}A1>vq-}|L&Gg zW9IugeB$yCbiB43`Ps*Q6Myx_kH$^y34e!eioBN!+Lr|LR6$;0ac;sK;MR;@rRKRx z#+_h3oJrxxWfKV+IS_qYk~H$@Tb1NZE@bzfDNtI5rWF8UAUpB~jF0~-78fJid$V{% zxiFuwyb$($Nn6W^a#H;se{4Q}QH!2oQ0Di8d$P#y_+Uc0?WI~i`Po!{Z_nvuA?tC% z0Dy&sh2ar;|1#h}ol%h1qRVsYzIaPt!6{&1@uyl|YNVFyUUb)4d% zpHI*6Awq^;f{UwF&sFbsrr1dbjzbWjHBzDqb2WeO8ML~ z^Us42ltzmv4Clg}h%|4-Lh}+Yn@M8{ANW!mRN;;+wMrAe^O3vx{S1>PT+8#=F`2^K ze&#CJj;naG%m2ijxhv+-l^_}Zp5T%;?s?%Bp6c8=|Givco)<8eOzz<_tPt?^ri*7! z)c8gx%I~DwLE6JSYBOms-M%AntB3k*3D5Xyt@9>1^0SaQczN+<=Y_3i`3 zT=f1I;$MF2)6lt14F)vmL<>KIK!*;E@V^8E2ExxX_9AZmi`U?ZPuvfH#3RE+jtKz{ zl?igLkqC356QqZQRt}uYFee&d5*6nLT&%r!#rraKNGn~TP4SKp-M zdGffALc8NkHjS%a^j~0DyFv7P0QF}1o4D_rzYoWWd*g#7-Q}p(E)Oh1Whq`~2G{ZM z_n&zhw(Ygj%M;JaOO#t(DcK`p-~GxjUxULh{M*F5TMGe*RU(9}biTH=tjpvM0ORB1 zD~k)uCl!rcWKCsLyc|Ie(1)*uq4W8{%`(4xF2(ZV8W1sEuh;yZZ0?F^@IuMf2!=-r z*t36|?|Cof#H74PM6>V1{GQFH@Vb}m3hI@_0NK2DYPNwdfAuji0qw}T94=)e9O8}^0Otbqg z;_>%=3pX6P7+-$&Z+a^fTr1yu(*Zp32NKNNXy(v>Z8g>s=0=(zJMyCga{w^gtc8z? z!)Q-1Cxqa-L*oj}qtB8$cP*b&wdA&5=io5E^zv&#G!vAT!MqA6Ed$I&s_F$w*fwo?VamJ)hBW!Ii(3m~T6&tv&nb zdSMO>0O$ZvF1vrsKS@xh{x+(?U5P+l&!bq%`j+I)gZi0MBEI|Jpss1^ix7fXg?cuZ z#*W?N7#=M`(==#FBf$Yf{i^FP#N~U7kQMx}tnjk{$=wevuv_rV?a&X=C~V}Zy(Cw$dPdXagfLB9tMVyzfa0nK9|m< zu>ar=9J%r~nCXi^-8C>;Nrd{fw|^d2TyrJ1?-*0dW?bn}%ZfV6sqK`yL?zu1A74|h z-wdd~@VXJ0nadONY$b#kXx5gJ*MIgX>o&OysT})EGm}g6MTg9Z^ejZW8zT5j6RbIp zna95bvH$O8ncw#uoWkhDkW#nxn%^mmE<>HS9%nODEqgCb+ zDN`qm2G^l}gba#luP!@XOUw8)v&%tpP9qg z?wO0VH%t|k7P#-x{QifZd@nMiKhri(HGcz6bE#scCkq`f?n2h>6enb5)%#v1%WmY` zrV{?N22f`J6HwPU@L__aCXg+pQ7boiXXR_^8|^4JJH03Yo!4!>j&j0cApi8bMo=i` zVOmC*ni0Re5b7G?YpLb30tXEr-s^Fc%M~(s>l-e{NB-jBAn$NsBHA2Y-?Tma%U4d| z&X*quwnG&j?bM@z8Qt??9$QZ?MSi26JTK1g7WG#+G70ef8WO^ss^0m`r+9dZgMG(j z8rh72+4)9-moN){^Uk8)lWt^CFgFby7oA_k#TN`AmDX@ze;x-96!`P*Ysbf)tKtWb zoW)Z|%V^jh7y}y3_`dTXy=m!DF--!)&|sPbrmi8K(qWhc<*J91)0N~z?M&kUoVttW z9-oWAUgLd&4%K_TO}ut!fWauvtLQ4sbs&|ChZf!lm=h3~I)Mfa6cn~c*9G&mW+0;* zU7JcPUbx_|8<+#YORwJ%gL(2ic{{iRnQRKBkpj}`6m(tp{~6GA1Dc`1^IQPs=)^0i z3us2@NkxGe)Ki6<007z2odAFd0MwnwxBmU-BJCsoKi-M7a+Lf2gJ)yy6OyF%s6D-O zE$iMSGxc^3$<`=YL_%{DztE3PtTt`ulSl@ z#?-mhgOR`yj^6`GEBAjJD%G7aV7Oo)Wo0lu(|{9M%iEg;D!!br<(2D%`Eb#~Xeous z@ig}A%p#rP=5|dJ=FSl2x<+vR!8|TFuYgL`!9$O%V0xy81%CyDM>*VuG@G=eHg6aj zOv8VcG{QshM&?s_JNdbEN(Ui%oH!MMx`t4@Zs(C6)w)}n*1;cL8SwlCfx#%wujt5o zMsTmq3_+?uqAQuO5in2d28x!ceCsiw?AoxU=dKgXbxlK7H(+VK1$(Vg7p{-WZef0C z$1ry6%*W0rUE8kCgz(L-YSjijm%_9RWHNGSUl}F+K^*{U%b!7`d@q(37O=Rm!uvMm z3ek`1QVAjK8GvKY%wnz5-kEbFpnlV>hZ0Ik&XY*(Zq}B66C-V_+qDeL z8%)y;QlK~mN^xtELPLPyT4;gd(&A2WcL?r91BK#R9Euey?(Q1g3GS}>^1SDK|MDj} zC%ZelcV_O~3w?T$uzcIqCH2BRGDO+jw~)~flR6TL;GtT?6ZExvwW4{^^oz^!HUh1R zd=7b2Qul=z?Gn=CZaQ=REWkIc9yy`CyVc`wos$Vxnv8dt+RmM8%54wo^8lZk-8_06 z(Y*5w<{zweLhxNKjpqS*QH4i(Iygp(E&>}mf4+TTeyT%`JS3Ex%*nFj0vu-TI`iefWZ*gn8gb7M z_oHMFu+yUO6@|B@=7E%`l>y6Lc*p(uTr~?x+OC}3DKyKsnQ^?UH2!S^qlLL|7FF$OQvY-ZYTkF31wLClG-#7)B6tO&|w(yk|_ z*;(o&7$GoZ;MB+89>lYKZfEe5=~z-zUkx~$#*s)Z&jCwtdSjx=zF4$K65miG#-hSw z^ZLPmtsdhasrybHI5Cl$oqe$iMeDzvvTt^yBF?pZ+3D|a9?X=f_MA>E(alN=-vv0Y zc!;)0#>$e1&_JN;UX1g~!vCl);-Huj5zcK~6r9xb< zaQN>IB{j9Rqs0Z+8%)kz_pyeLtWtCTi=d77JBtI^;H#vixs!0q^^si{l1lDC-DihF}bYL`QB(RkvGY>yUDASmRkLBs;%)cdXE=;Xtp@ z7YX~Ap(7h6es`esT{|Mxw5`5QE}rK75aMT?VOT0A+>I}4f~MCx3G6J!kPd2D1a@tj z4;nqZDlyy>tRtK3SY$wm{w>xkD@--$Do9ST$9SNvkN=o9-zR;yDW+Q!dw#<`wu8G> zjlpF}&6uBnZb7?-dTMJ#V|6yM>QZKt+r00O!tcsN#hxLo*QGt*Tas6GT4g{5KNrwa zQ+fr<<##NI`PDcjMX4khHk<0%&2G;bk)c5SuFqc)D+(Ntg65Lzmz?zXwQLHQqC7IC zHZ|cd&oGK17cunfn_ty##5ATKjPLxIlVS zy|2KgB&bNUJ3zDBm}7(ppzep`gs0x85F;Ygn0IcSf8_nu>=Zy3Gj@9NNcFqz>#Nds z+|J}&X-EI!>(n?k?W{#j`@B_XXckj568EX@#`SQUhnpv}dB-*De;e|8C#kK$daVDb z7Q<@B+S7<1AjX; zD8-b_6oz4aFrJv5Q$Ie3*9%$!)Cs&MkcnrgJoh(yD~)-fGhWc*pJO?vK1`SIY~EO7 zM`ych@lRhmnK?`-JW>kFVi+CQ)VD23%NdF?LxbEb>Felj!xf6jGxO{jPO(Dz`{02X zOTY=vXu5uPYmjkai?UjlkPlf{!|wp;p;rqwd7|Qm+t@?+Z9a!_mVeYce+kpO@u{n| ztuOqC#Tj5F0#e9do%xk(K$S^#qFJy1eU0M&@$vDr$o+(CjUnochSXDWIV`q1_>Q>^ zT^!AHrNDBZf}Y=d8)digx_N3^>@3{tv^yojsnzu>SKv`DtFC7Up@9?JtG-De%UQPJ z8Ys~;=)5l>m!)HE+`43=664JwFju$D4dVH5tC+|55>^jMq~z^cGA6DKEh)1{AJ)l- zUPn9K7l-5OyNvKlNvn-NmZ|D=JT~2Y*a)D_{9GNho%8ML(;*tC=GKvl5zsxa>^$7f zbtW`2BqEZuFVs91xHHr>77QSV8b?vQ$rr@6@Fv&J^iTeMT&BH912?$?hpIkDXmj>| z$5nuJ+2m&?OTCtZDgPC;XKmV_b11S3iF&^&u>7epl6poM<7-g{R;n9_cC7GhLE~8I z5xB?C+IBoyJC~(fa+KM!7|ZcGNWgW>`E0lA>>oNsxP&&fP4^(vnV0b*@cEiHb4z7C z?|@HI4Uy${iSk`aAGV?W6U+Je+VUUFK*1D}uTHHSQCSzDSUk z{EMBtHF_?KxaoCnIR)X{OKqfT?0a1cV{_b}y~on=COHGkIG+{5@I$k+lHh%K zQbsBSCgq_bb)k_I6hJrb!|TUQ*aBrmDV_lF8fvB-*ww&QXtF zGuz8R8TOAsHqJ1P9v820F49de(VfrIKUb*uzY)M63yD^9Q^vU$H#BWPrLd_zH1@RQ zq^E7WVOST~i`Wv3Bv2KFiU?vZ;+OrE_}WukT_f&(UK_QZ&!->*f*PbDHEWC5#m+N6 zc2Ug%veCq&qn}@i#~S)uy;J(LC?1D&=ZB`XpZj8~3%JEY-i^E^~j? zu*)*M?ObMAmatj4uPqICnr?yFS+h_P5wVR{POI&!}7YaT>KJF zbC@{9ptyHTm*9_P!6y-Bns49KTwyzB5X$43SDEJl9U3yKR+6Lmo>QHL6v3F?YPT2Hxr2%|8|0YfYX9E_`P@D?$ z`QHyZ<(q2JS?RCyyiMc)tRNmnbLx)PI;4}fhk5b#`BosGC9qX?c*pR#{aQ)~FIgy2 zFM~8%&neB5DCNSHlXxz$roS8ui=j@yB{EbZQugw*BgUAE%r7jPFGi9&$7R@0ihgiI zGg(X^#pD(%hB;;*27{Opqbie4rZj!{^Y?J#L&jWnJF{6=&ZKcOAG!8$NuZ z@Nzee9jcpc{(YoTAkfHKjG2s6MNMGv47UL|uiv$**PR7PYhw;tFza&K;W-Zq3bluO z3wAVr!)Ka^_m$9O!s{?VNlgIK{rRd$AAmg&=?9XyE>kePLp*(R zxEfmDcHBvKV)yT=+l5@tR0v%A0C(d6wQzf66CQMJE4uRA<|OlKx9~*tk2?rQG+3eG z)wj9AjTFUaxhl=yN9qZ2^?#p%Ws3|8ku4Amhoq;Ju3zp!kiz61>hog_d_-eXY{^4? zwilL;OE2M0)ZgU*6L)n54Jvr*asIo{bOlPuJ5x;8P_oM9)fVMC?9WEPU=^eAjiJ$A zZt|@U#GXT+I=DD9zqnJ!@ND;`9id;WQK6(xccsF*Q+KjQms*jHx_W({5WS`d+lp|@ zf8j8f(57aX$AdS(|AjWBMgN=j>|jJYp?<+^3OZ~+^#knmw%Tggt(b`t`zp(~>nfa8 zJ7qp(+Pa$ds07ugKNRJuoyYwdrk%m_B9AalP03%-`J)qN?0~io>Q%h-w~7-VMjQ@gOK#hgfLS8Ek2R{@c~aNPtnA(TT0&xj_0fUc0Te-Gnt z+y_yzY?3$q)=vwoIRKm$OWu~18q$N1{7BVh54P-t0 zEvocNmUe32Q|5is(%wp5J6KJY+K7(lTEr?UU1-o9y9T)*{;G|$<#_z05pqLMiQxiB zPSJZ%0|17o`6MIJsS89?6iPCXw^GqF;^RW zLyF7_WkfNbZdjz-R-RzdtC=;C!P9P+7ry}e=jR{4v1!18PtKlQ?bpT>%Qj6PFo=Jv zBNdjWQ#BJAT&|d`9>9dSh3tn^qlSMHBiZVQpPoE@OG-FBC$pF2 zExSQNRf`20nu~g0U7Z79uqjx~pEX01ZOuT4-0==}D&Y-fZI8~!`=b64P(OT4hVPxL`aD~(O>NQClF>@szq zMjF%XHJ~D6K?jiR>Bu}4+E9y(aDE~IW&*5MCs@=%ze3=BfJj5K+X~*WNQF@nlfms- zIribE3X0JGa{<(NNp|Do8CGDyu`h;ZJCfBm>nBSlNS{G zC*C{J{0RWp7la)G_*aGIB}Ke#3cS3s#&Wy zJhShUy0&TQLWr9$Z^K~*O6M^$1?PpiY%$~Jg@KdF@luIqKeg^?=&5%qt$4l^z0aXM zt9C!`>1gpbiLx^SZp9VeMkK0Dow-gPy&ZQ*_O`18k@ZdJBHz!FB6_}ZdZChzenJb# zE{=aNc)3&9){4Kf><8O5)Mybzp!xgol#Eim*9iEX(U4}AgoT3XJXA0PY?0h{{p+C# z!&4eh7!tkFqWJ1yTr>+5z4_0&I8~SCU?xoZ;{V*#@-#$&cAj<$M|ef z2%0-b8ob*wqj5zg!FXXYhd~A8fHRoc-Kz}fMR7QSGH9%M2hE_vYWd|t*(|p&2Uw!g zUN|VB7&BFsa3`ZjA%_8~Y;DdW1RR~+)V8d#?*MhUVpTTegY__}X@Ccki52B+K`cyonhZ$Lnr>;RBbwiQYHay!GFdxR zekxzH+KW%6R3PM)evfGTA$JOKJD|468f18e_o~e3h#*OF^)=f$y7lBr^QPXm4 zFzZ)gBKB-|How)|N^{z~1q%R%Ie0Mu&bYYn)GvnHJb9r!-yLK1=FPV++GDHoK>$cqhfB6Q^D_Ii!$ek zS!l55Vn$F0AY;LEJ6m6{h{VJog(ouKGpSnZUa1lo!u1|!`|aHBN*LHYL8|2w(f&% zU+uW!&58UBDUNF=p$J{V<8c}67Fjd+v7Y|#*=AX4`RWy5N?Q$v)$z6ULW-g+zqSA$ zP(34PGsagfE!c5@4_)J_;6Jq9!54;hy6W=B;Eb72U1nm!O!+;3M@VOBcM*R`TDnx; zL?$}WMR!fEVYH(~0GRlr%!1v)I6nN`P^z^&xwg`r3mPX3-Q9sCSa1I{1M&iX8Ue>r zB1QdSrkgt>O}|QZI^%9mV!T)Jh7J7sM88+>bsxk}y5#3G`!}nl+6~H%N(;#L^U)~s zrrs?ew~IZ7DHp=Q^UsdC>u%fIB2OuZcRJ1uEQ_zS|}i!K9lc>!IG>F!k9!Ad>#4$R)1uRJiI8 zWB^^c2A7smKP;HFQ_a0a7U*aYy$1T89RW*E==dHtWgmxsVWtZHhJW@oIZ8nuuaRr% zwY1V=s6CsJ@dJrwW!&(EhMM1M*f#||EYr9N1qTEcQzYwFPkQ6@-e7@B$@J%uG|tch z=_<|oUu!HAIgy8#HBHF@f-ZZ~8yr`vT~ZBu-GZPqO2l9qfsxJke%N@iJ;WVN$pB{L zAcE1i?Rct})OmH2R7m0hf#5-@G*-RfAsB2EG-I!WKF)L!i4>-+yZr%RRwsg#Qn`@) zgP>w-nTIS_iAu9YP0Kk|bE=!=V@!Cy1a>^56Vuh*|mk0IYN~At#!Vf|`o2=tUZ6Ad_54;;;?VB_wU+$I=PsIOj ze0gZRVSg1Bp87v`dE7i4ACbd_$$V((w>-vPKEwvtXD!GA8~4m<`F&OqzE)Q6y-)&2 zE?odLSP~#-L+o|&s!)P1J7FwYt$#f4iLwN6d4AjX&z9m;54|C0>#TI5+LxbJaVa4j z^wiuzv1!@&B#DL)Cz>J~8b8*M9@Gs5G|P~gD>VMy(DHCs^;7V~%ad{(iP|(MMO6c!K=_(|XC z)|7`z8SYX{hT`i@#ZK~fo32O7dwzEL{aH}Mb!`r3_{M(B#OZC&5wTXDJYM z6&AFaEMqS32caY1&y<_6nLA|(GO_?En5;b%OXtvVw{aI|{5I?b8QA?!J_r5$@-9_~ z=XCDGNq=Gpj4BVG)U*_2SzOQTi}f!cGUT_F;n-TsZe4KD#^(nZB4Tt6_1&qJ0tL}r zdzLtGz)tua{*atr%cf=Yf%Q@lD%+1Dl}|d%!E`43{rN7MjrejfRFa`1<>BeCk2a5f zj1yPsV%!_0>YyyDFD5(R@zplT4_6YA*d5<732~M8K!*X&B)Cv-x_QY4J+&Z^#0~?w z3rEa^MoUHdOF9+mxl)si9P{q)Y0RQs@HJbB{hj~1cyN#6$+zvUram2B*W|qczuCGk zdMICgDx*<2`ZCEpZ2-A=TL8T65{+QA;DxPZp47Mc^cSE$ZKU}f2gKhzUDdlQYVo0) zxtj%vV+Mtt>Qe3ZA~D(mAF8rF({!n|D?0~!HdwUPQkhR4EtEB|R(aZ*7fJ3iqF5rP z#VR1t?R#t5?;;E73t~!VvOD;VM7+mw zCLs=28vC^{EQrj8Y~UiVdV>a(k?{YfRr zN#S;0iH($6LPQJvN?YnvMjh0=%3hkLslW+IuEM1E#`}AqJjZ)Ojb)^`E|_C>4EcFY ztrfwPHofRsBa|676B?AdSyw~y$!O|Q*bps1zW`tObz6LfVQMw*<23Y0&9GGke$`s* z!_czzL1FJ`zwgypG2A`#hEXiNcaM8U^VtXK1BN(*wUk!;e$NJd8rq$Xq&cYg{WMT8 zl7o|yl0r^X>}N6n4#!|(@OF&l{-IKf$i*&FBLkr5G!V?pdaM@Ap@er^u*#!?zWwar>X*)IFQFlj+7eX%?dcrNLQfrEF&{$~#j40L?`1qD>5^sd^ai_*c z=)LE7S00wfd3KREBka)+y|G+!ipQcu;JF2!1;e9Gt5tl`Yx8ErKN*ySw=ErJ%Of&D zy@p;S+}li4VhokK<)_5E>Rh3r#t|nmqz9mBE4mWrI;8eLJB<3rj~UgHc5j9et=6^DV8&Mi3jsE5B=C09&8 zgnFJQbl!KHxzK@5db@;Kp}w>6%y8lcCV}Ww_Y+s9xJ{2%gS!RCxoZrTj4xu!nrNWj z*s*<&yNsvLRv$R*NB>($!EqG2T11QxHD$u;46m|zoJxur{V&R}0>>YAywlddFcNq8 z$o30z?&Rdb2-<*xy>ajeLi*9UIkVBhY2j1Rs<&k%p5EIcOg3V2zBgm)6q?rj&o?C* zzmx3L$qBn#BQtkAE9UWSpiFs$8l35@FyuRDTs#}B=|>nQ&=v;M6MQB99?-~EG=FZ1wC(K8O8rqNH*Xr(XdWqgjt4S_vYXmzDh%W|#m1IXm#59b_t zpP;i!uAKo$45X!ONYhfs=)h+|uFXex(li>k!#kWL_Fc@|gQ9Q@3ugi&y9908ZzJZZ zl1mygI(tEJJwC^CqN_A>|LX(F{q@nJhT@od8_j~qtL#zTQ&Zdh-@05bTt#DJ z>|NDeEk1k{`>6$8U>8w8yWM9oyig<+yaTGOT|5j4(!cUkSNsJz@vc$Jv3^<73xoLhX zXH47IIL5Wp-({CcLLNtK~{>S8j6kkJ2!&2F^(I z&*Kp*8i~I?OpXS8Kt=WzZ`$@pt)l0`l?%)Biu-cxVyHqfY+fR@3X(-RPhj6KvhC2B z+-4quF?f2oPPfF3^U7`8rWzX>D=z(fCT^jP$<<|oKzOObT$MkF64OQY$jXR@U%Gmifz>DPw*q0;v~a5nl@e4bnIB+m53 zdGpbmjoU1_JqN6+UsR0NzA{p+G_>E)=S#hkB^lRL_LX3Uk`L?^8ulo>swAQ zrr5rHwPn6;Ejof`+T&eB8D$&d_L7g9;+AIOk+pQC1O7dw9{qcMvFJ6Mj^bjgZ=Ylj zGj%OKsvoP@6ScZCc-{x6)+K?KR;Y>)gH85(Y;1j6`XB7#-0*Ga$LsA^Te-N^;1Bsj z%4E)P+yP~Cl1iqy!DJnbEA9N49`dRv}cy4xi zACKyL05IhzX(0!TqCqCD575-2|3MpK4Gn9=_hfs;A zoaL^c`6+_z%LO|c@Nop?+zMr`HvJW4+F7^ymlTLdVDt}o2vP%jtC^zE&CE+Vx za4mSHoTC_sX6E#?1tF*Vx7n-5k9eGz<5?b#9|E07IV%nq%Eb~$EuIwkE_HgW`Y=~k zPM?lRE&m9J4!w_y46ST|npy#rwS3{ZI{6uBI#@0MegwQ8alW6rQz1$`Km@Mfs>B;?3DU+MuF1Z@28Cz!M41jiv(U?|ZM_l8${=J3rfd z0T&o*Pt*4yY;q@HTeY7N_N?(`SnaTQXxZj=He>CWZf#IT*B{S3=*#>`c3;4C zd#l$~|Mbrl;T#DkB)k?yIMOHUl;mn#-|HW}>ej=zU&oSp=kF!jEW$w!k3uoG9(gm| zrP>tMkZ;X`_ht(}SJP3FxTz>!8#;Tnz?t4N_B2iZ?tYODKF~B!So#;E{HUHr<`WcI zJ56eXPz?MMG6n+N+L_EeX88PJZ8oF4o?A61}RX001sD*Cvh|!N@E?xIwQw zd;4>(i{+O@7MDe3_4kV$RdUHms>R|$P!5d)ErqcB`eOzxdXMV{E~>B>)*~82_^mhn zsI7NFi%v3Nbw z61!ZOKSHBTRnKH4+EXOek9p1RQrPok!Pgz;eZ|&Sscl!UciJoA<0KqShL{VxmtFib zCajkF5AKXsDxdXt8`)B8c=tf+AM&Z_A;9>@NkUgonBYYA4!%F3Ei%IDbbIzE1HbNc zeAJu5s=4%}gRrizCKFs65&EEiLc#?C$th{W?;J?V-46P+z3)8ft=}p{fJ=Q##Tw1E zBLms_C|JT39>IKZRg+`#*0yte!%qD#>QHv4ZmT+D`>-l;c^6vY4}o*gD=K8*NTj^C z9<}rs-XNOjyt%DeUt3Cn)}G!a|UC4BTl~?hVgxGqql}O!0GS zbZl4=kBuap9reM_wl1xPwk^RMB+M9m8Svq7r%XhQR#&^l`{>`6_%55I>$kI~!lY)l z`^@_<0D`yPcR1yXG_&>6W!|T$)!HXzv)5UW4REH2zLfbqe^J{NS;dic3dN5A?Ym1Q z+`Lx@2?|gWn5?4r1N3CIh0*;TK@BV9dUsTR+F*>m^#lw>ab zhf}IzDX(SBpVodweo z%%DZ+z_SNNMP{v_BfyO8IPZBBo_h@L3{lk zFM+b8V7BBbm~cxTjeL36vJzG{okH0ia)Jr(BFCxlou}Dy+I!Rg+Y{9>x>;|fCG#LJ z&ON^1!Md?xb#mjq=!KH>#33t%?qq7%XimJ&08RyYmkwg+2BIW`n=mGN+tb;fy>ScjH)OLo}^Mj?+XSAGoVkT>d1f z#}{UV+a_}t!>bh7C}%jzC6=Eu{zq?os_AiZI<5rfL2)(1oS%AYiu@u0mS}^0f|p zW2~K7G<$b^4;pn%i^BKAJ>1(Wp-Apik1XR4T{6-P!UQhXEd{m58tie{0|X{QAa@0# zD#N{4NiYl?x``HNeml{n*PhPVel47?RTh>Q7wqH`O=q84Srbf3ibj~k`L&q1nc%7Y z@$~qWU8AEpyU)fMMzHnM0xYvj%x{mx7x4sRC>@@6AFVGHtRUV3Wbq*mcQO;27rf#+ z#6^;LPS>GrWDWW|qv0s~Gij-r^B9Ih!i%O8t2eDTwyx9wK#y^iMTml3^G0J7xT(_z~%9URQ9-*VE)ek^*A}dsK0si+>R?&`ZUel zz4I}xFPpq;{Ljl(tx?noc8ggOa2)_v-fgz?lBj(<>&5g-qO_k$CPSQ}J#`-Z4oS4GwyLKO|ImeUrt1f{FZq8v{kdrf)F zO7R%HJ%7T=)Pz}Og#<*yL!Kuz1j7~XqN#G1@ETA_hN2+ynIPyak-(>BV2JrJ$>uNc|A!mDU@WRB4loX9AKpuq=pd~5ILSp-d()O zi4(O*`8Ut=QIOK$PI(1wm!qH9kLR}o7e)1$h@DlZm-xEp9W;^Ka`T|4IdS*_yF%xS&f4WQM}g$JF0NQ>EeUv&cDA61-V zs3k+b93=8Z&A{?Dts>ULeSGloIiByRU3n!qx0_j-5cFBknntkS5$fi;mwNc-_2@fB zfF8h$h=~^>)@@Hp9*4U>lUY7Ji{~tX70UJcI%=B{#r1cLBfH17E;Q#bY)^rlLiG~? zhU0{VV^A!{)p&O1dFvJS1$CF!lJ5on)-?zY!0Usx$ij0MK}NgY4KnO@weDfl1jhrL?xN?)&>qKRK1y!x;>+pll~?wE(uoxv z{|>Y7wc%oMd`ESCNr@Np65O_f$AbE^jo-teZcxPzzQwR)MoL6-53{rRB+$f*V}7Ov zuodT)8y_~ZC}z#8Z)5y%2Bd$JQ-E(%kW1Ab%VBm_SHJ3S@Xv(6MTD*)t5%pFYbbG1 z9!uGs1zw8B4zu;J<$Du%k_3)L%@QMfC}o~WK(yxEiI`e?%v`Cxd7td?u1siYNC@{e zqfmeGLVXRs9)=bfh^#9&5p+Yz%d(^b2rVe1gh!oq$YUMfu6UVDd_*LZ@g^2|AlD`I@vm9I#-KQ)3X?z5Jdei5jN>#yS=(u3A4(d zsIFVRr>Iew0%qm+%%F5oDIcjyG)gWu`PTLo+rPqi_nt%K9*$hG=5%KYK>$_TPCUWk zd`g4F9wewtT~bW|(F>a{7DH%>;nhPV_IG&=)cEA7AAobm)`Mvk#l)SlC8#V1t-R(t?Gj!QVmmnX0GK+0P<4WSr^foBbKRJ`y zkDckLMgQ=1rHI!_ykly=hyYF1Jg$bW-v;UmtgP88h}~m~$pkmBKit62)(Lcj(hXoA zhvRRw%@^HHcl_?KC`O8=E+9w_-IKY#ABvsd5t&!NK5_tm3yXP3;N|7s-rjoEK3|e* zVi_mETQP&-(UIZLi4pJra{-ji8QwOpCe})?Eo^`I-%QOkK;J`D||=l%5DLBA@s>Tp5=?KDDo) zt~{(`diC=L-!;JhTP1U(%6o>8dpT8>{u43CA6*Ux{`7GaR@{_xrzgzcfHux!D>rgd zYlY^_tmIEf{J*e#oGqPc@Cy||XwX4WK5?|OEXO=fA9Ou1BvpmL-6d{IHm&WO-_RnC z(i|ub>)P!z@hse-)t;c^D$6i^>7=LQ-n^c+l=@K zB@c12B*Tisz7;muB|~?(ZyR9gWI>+w@GCdVS4c*fZYl5S!AVQKbu!x0<8x`74@b!_ zh=%Ev>W-rA?Y>6lig+^Ga_Z{pRhHkM2ljA^2S3}roYfuyEax?gh54FFV}9!WbU7!96jR+-wJ}_Skm(qA%vC-`1j;_!s+c*C zE5PG1XXkW4Nh~^*x*R1&taLy2)9XP%RV;nk0ZRdHUNk7iYbrmvjEDFfw+s;f4oB?j zr=BXm+P<`i$#W=UNmvvA^;-gWlw${=2)LSUffa2`5`_{acb%gwIfn?vw-EMENx`SV zG8cYrMnP)i)FZCUi0&nIQR(u5E0ze2#`Dq zs+Gs-<~di~zH(Be8XNnt`P7Dxq!L=Odh+uUsN{e`y-ynx;Wr;)cR83!Yvo>zv>tzy zw5|6=QWh9N_Ops2@q@>Le#TtAVfe zMu5;AFZfFnecXt_q`H0?y}`JVrst{NX1B>}Z30vt*}7XMtIz9Bm7}Q;4`lX$w~-#K z(u@x^=e)ebGsXkzHQP!iU3{xdjt8*YkDh*#`9+LgV)rnlP z=lWK3H@JNgYm}FY|7DEJ-@B)MoKTRuY)I8W&ukVjkGiY#-(jbYP;diDmmUp?RIS?T zT+NbNdBT_gzI%YlTSuaf2zpCob&vMEO2s7xqBwx(k2Ib_r3=`Bg{;BP6 zv+?Ew!RTfpnL>wb@!|k}<7i(@W=B#hq~N6Sn)yusynRL3_j%dfJw-R9VQ1!WaFCnN z{JiP4cHW$mKp_vZ?gAOh@-afV^&T-ws1*VU=MgE9;6i*n2bljpx8d}%s)F7W_)viV z1*1q!ern?{8VR!#Kg@{>L;V+5n{5GRCP(SB(W){x9-ugs^SbU+I4 zN+HpAyugo&CeUd6QYW48OPdu)S6Id26%&*0iV1z&<1C zwZ`e*81*uM`JdfeZ&W8Ow6+JYiqDo_WY(i!yd#$f&l&wPIrPpig34A6x6?5N0qkOz zg}>GVdtn9K(mZX_nLMvOx*p_~Qn|&S@>WyqsHe*kLY6Vz{dZFkwEI5d)N~$)>$$gE zV#3jl@n8;`(fRjBWH-Rd?(QA9i7O^Z)MmYw&z=B2D3XLWSk(akFq<)Cq-UD#mC#}G zmI&@Wn!XyeruocfmO!Fb<3h`58^dQ_sayzneSr55+$h07GC%C=q4Co2?Q7xQ1Aw!C zy~ur(D;s{Ug$IqzDx_XNnKCsrNw-PFam;DkBM8||$aqNd^TF_YgpGBV>p&lSg@B!M zc4GXog3|xhS5_aFb2ZsY*Ms;pZsSku44O&!nlG#MbZNpGmXkB8CKpGGd3L@yDGK&{ zHm&2mevdK5S8a{eWb;9SWA&q=Hzsyo0YHR6qB1|m$!)54z+4FpRQU_}*@P5%NKoM4 z#4m*>n^p<*VE`c21Csbi4oy1IFa}^ zg;HF?hPb2$14Mtg$(o8iX|5Dba+rV!lh#EDhq4BEz-aVM;DnTmehNW30~#L_ z0c_f9M*U~6vh61{P~sOx^VIO|&pX3IJe1S!ufD=k`iy{7Pk`H%$4Bym*KiW?j7CjI zn?DWL;)dl!fu&=#T|z4^;iwmO)GPNq-|Cw}3D->gZiDaw?v6OV8LdRKwtUMlb)+K8 zx;xy|L5_PF{=590(~6uhaWmPjMJt~U?T4a|6X+pQD`l{4^qof*K_CRjs_g{@0z) zNnI4lQ?yXG3N%P6c_Aoc3YD3Uhso2z7{B)GClqE$4iNPxBbub$y%GQWSW{yiU}OT3 zUGS?A0l=SG+ku~?+Qr(QHPRoLmNoIHrK;fknr;+Dol^}x7VTRvoKSUBv*PWm^;kA<;4KyP3AS*rDsGu07png7jAm zQqVIc4O&QlHuPQjO2pA>MCsJ964+(ao$g%P+;%^+bGj}DVbC|EJvP7eEl<&PvrEjezAsKg)}D-+ERW~l4g zlH$pL%vJ7z0!GIePk*yB+7Ue*@S(ESlJ3ck)N-gPM8-7qG0E7vc~ztyMZEzNa?SAO zZYamo*tHXN<@ ziyl^ufhOiwh9s4^)QwV|8B=f641s-?WN7uff5Dyrmbd8qB*{aQL&-u7B6{L2n4DN2 zdtBS!5R6fb_;ZDN4{lv^HXKcKm<5tDEU1TZf{Vf;4ziCM9G*IsvkgV{Wj1Fx=A#*t zxz?ruX^k5F5xT&*GcAxXE#pwfQE*BMxSr(9(ejsG9g2r3Q(< z#y!6H)tj~RBk6i=wbeT3LxlB7^Cn}{U=u>fJ)*!e)lAB^R$;OEz?H8&9Oj0Lf~hYn z;}7sOu{y_)m-mk){3$N8`=O^|FWf+avkDDJauaG>2{UbJ(pP7*RZB7hx2#?~J1#cZ zn&o{%`Y_(y%?aHsshvcPBJ~6p^(Q4U-hO-Eu7qh!G|jA`1ZLf zXU1WkIr7$~*9hID1=TEek{kr@Wp>mH;oU=rJ^k-nH@dYWfJM;~;8f`k*RP+6wjs-Z zWzDgjQN;gD1tl5GhiMx7a>L5bYvt?dBI`X{0jJ?gVj+EgJbpJ#t0&!sq7dM9=G3aH zk9N3;{P|>#%969a*Qxy?T=8*v=cem9Oo5`)n`hXH&uRwA==u53mI-xH_r6!gDN?f~ zrnt(~M8jqj7hw!>E-KBw>@#?wogrm(Y-w?-?}NO#bnAi<&lAobj}F*8Dy8um56hZ6 zX4nwj-F=tb(y15FMS7imitd98{|41M(&72WksBpf)*Mltl57TwBzns>H0V%xreXyO zJhdKm{JCuUpy&sK>=nga^blgg0TO;Bm0r^=g=UO)H zU*dkp=JmSXvjES*qjCxaF4$oT`vPX~5BY#eqJ;LlrfX7GA_EJZ64Pt_(j|vFyPU(z zRg#*n-!$@eewkyVgUn2&BqDTv${fQrKi-)zFdO!=VlhAwO5BRi%xzZQu+Echshl)e zqn%m6G4v=>UyvWzNID*ExJoH1D=>kOLSz z?+m3WUJJzwj>(U$V~SB|=R}(fL!PX8H(c%8R^dQfEN4J+8sz+>Gh9xr>Xt_bQl_1a z*1k);%0EF?YB&8+?@z!h)ZL{M-05PhlBkxXUVliy|NbL^Doftgli-T#9Lb@5r0=p1q$8#A$8i4)CtlSaGj=tzD$W>Pn2w7`D#Nf$J*8m`6o{8%ExxQN>FJ!`qH8U*9y>ryU&f zC76foEi(4tZNWNsPy6hQLek6;iX^NJgSIi?MU}KG9%V%KM&;1ZRb;oWiMCT~Rtr|1_H`anq!Nlq6Op(raas@_tZT;NgYx+I92401BVy)Qs6E}oN zTKBvw&oku(P12FW&QGsDB8{m`11@L}f?TPdOyKQ&e*A$cJ7~~2Hw~U;U?zFf4MGoS1h|0p<^D|wJZ+0uX;`Cj{Ge074 zCn=id_49CO4&yDhhWTlONro17hjts1*VdP=M#BI0Tt*&6RW5$Kyw5!~8Z5r5;ippZ z*}7rwRCbvU_ZVKNLcqj>?95ZW@@Jc+-QAaMD&=cwOq+X0Qi^Yewej_mD^XamMA= z=uD6#=$*`!K)=t&*YBXkus5Hor!OBB)Gmo(z@lU*4@OK!fnw`tJ_V{*J~+&TKdno? zf6zkkehk2jh5KxyYiKk0^L{xJdTa`!^FH8tl$-jI=*2rQ8C+-f2h86aI-%5+ZtZ4& z8#AZZR5xQYNq8IK`j5mLt{1h;138XmT5{39X!TNY5AsY0thCpuPCkwPvaV)$`mF|Mqw1 zmQzq9N4Z|pD$kcguy`=V#ImU3#2RNr(qeW@axlZNj%d(C39SA*E)6~x5gKoC#qR{- zu%xsx8D2G5=F=a(dKmO~srM-UkSt^M;%Q6c`DWSj10R}hchet|a~o2^GH9TjdVW5p z{l4YJ#M1QVO+lL7?vw4&OMC*aMM31>I-{U+IzV-u%3Ter`FrEHgP|$@a^G&4Mte}! zgeo-jC{-;`DI*56B^>VO&Jk~~HtWxj92QFjX?V2qfs+vum1>y+HX+KOSGT+uELJ*(xpc>3k#x+Zm>k=Y_j)*0kwf-y?gg~NZh)0M>NZIE!S+i z@JEkzgXWfS-NhW`W>D@Uv)kFr<%{frkAKcxur@)0!hVM=-Pe^jmEDyKe?F)IE=AhVP z?)w zIq5h0{%A$v9r6VjJ|!PhEoGAj*&UxfGi2V!KlgE|b*hhX!aw&jQL-0{^K0dAS}Lh6 zd1E45uJ|L4f_vGOIQqB3kL8hC=-?VX?5o|iI#4}ipNC0UQ_GAtqI{^osg$+ zkyGzr2G3lIQnj?8w-oNjf6kuD($jT(zZ=KOPm@lnagu=DU95oFft~fXT<&}0{@x`f zKGFNY6eL3=(B?ldiTQDv!pv#gMb07}(HuO+JlFK|t5?`f=GE&sK>?fK)9eP1-YY;M zJVs~YUibCAk;u6|u3b{LZjU2{EurC2|DOCuSJQP;c{jl$nMI-lNCg+#_+Z_@hE9%n4eYv82TCR?a1bs)P`mWD9Ww zNe?V!$g2{*k<|1P)b{hc6uxbX?>bAH@+W0v$m~gL_o5wPev{!ctd)B+M{+c$=aiv* zyEzv*b?S@hw~)U6{eD7HprMd%|3QXJEulxXDT3-J=Ox~+<{bU`%(|$l=YZTt;Y(M0 z2CX{}G&D@3Ah`Mp3-0e)Tl1Me;f~5wJ>JKMX%xO0vRU`C9|2#hCzJC~imEatD7OXW3s6a7cKWG)Ht~?(ao|vdX@3vXZX*WI9z8QFae&v45ew^n zwl0mxf@2>^6nZRSvD&*7_);?bI{ayxRd#mk-HiH! zwT>0xV0i;alc2ZQ!Poh{gW`rjq1byZfuKTR_X}H^YD1?YQ8EC|yjUJ;XWZj9{tg-= zgsJShZxwtr0Jmo1{+67j#Kg2oM0d@JK}T#(xYF!38_Bl^Jt*q7^7W5ZvTEx!CE(=0 zA6npc1=TH|&sue z4(L{OG?JL(Mp$w)82-^mtNiI1wfHl>fJUQB|8@VgA-Q^ZcN3hjlC>n)(}Lh92h_+? z5mCT}R=blyJq%9M+X^9+FVgImxn%4dTNw-}Yh9=R&wkwXy3pCwTA2!t6g^mACfpC| zV%IA#uiXTEl%&MqXERLYuiin^dQsfw4`9_Ci6yqP4>1Si;$qIbE+mLFRh@N@SNN+1 zxST4YB*w|96(w%0P4jg^UOPG1-Wr9jP1(`U6bO~2UZRXXB839HB*WdC3Z_)zoD)yz#qy)(2+ANx!t6ry#@=!f0*~zg+?oDB70- zTLM=;LXr&|H;PN`2Mum?0ipb7X05vVDc~bi;R0;rL>TQ+d6S(iSYLsXM=yQeu-C@8?bQ_}mStm&$`rL9y3vk+a$!I2+uOipV|-~;LPP+?e$Jru5W(! zSs)5aM7AUfW7&vikjc&1c{zW)#x}T<@YwmmRUl;EXX4xz_f*Br@z>gt=P__@`0Dtd z1NY--^g-nUHT*ULtwT{O1S4P#rxMi16gYN13PdNCzNkl;rXpDhr>mZYk_UUfdVa3Z z_EEDM_lp922EvV(VrEFi``WEI4ptgjec(;|{7f<{&GEe181fYP4X|wQ7#fS5hn34F z22qSEMJf}G*It=??x4ZO+Q)nO{{qhBd6Es59|h9?`p1+x&TTj7B&?R~(CxH@8x|2j zB-iFaD~H@lCU&2qHzOtqyh()wtUlSYoJ%l`^Wr02A3C9v6`S>P7<@caA(~4t*zH$h z+{fJRR}KjiwqF1-fpVJHCRn6xqYh88WAkFwKH$Or{A<*sL~-N!5m;`2;z(t}B&$rl zYtoL?*1_ARk52K5Q@MHd9ZvNEl_D~A;Jwi_E*UYgq2z5wy7B=;9u=;*@FJM|;_N-~ zhI>j$Wt*<<$Q$=?2i->I0|l!*LMXxd5S02|iWt9LIA0&xm42!^8JhaMhA1l|r^`E7 zFswHxrylo86C?v@G#Qt<1o7LInNvhfAcG;9zt=tCfiPq9EWaUXI*x-2XQPdw9zf8e zIlMa=vURCwqoF9zhd6vE*Cc>#1gX7zpMRUj9Q${y)omhHA2VrBHseV?nb`+|zu2eD zKq}_2ayrQ>mIR&BO)2OtSIDA~U*$kiAwJ%;3#}%u61e0rEmB+hh7@!4cgO-aYRT4QnHI@!F0war;c zS;FeDJ>9sJGU-a~^mC~9MMAYnj~IpYzh$@i`)OQLA3I3+`HTPAibpJxH0`j-Dg6DP zr5@iThU87lr;b_=Sw0N(yTnrCZ0=gTZcdqc23XQ{95cq*X%iOhe8{V-%AVyQJtc=K z&-Ml(6r7&`zuv2BW`!V?4g-Rg>wd`@_{MG&scBS%te?m+`(G{q4+TxiGskzm2uE2f z&vq@1xd*0OLB%2Z#qONE3nY>MqG3^AwqsloiVr-$oiF-i8#hG`-||Q7n1KeFT??AV z8T2td3)|74g|%Kc-5@ka*YCR=vOSGt9DM@!YZc<16$r z)IdMX?~6VEZHTuODf|mp6*jb3TPYvrQd7^4 zSL8D#jGj@Q!9I z3D4KBZTz=2lP4%d*%LRhspa~L@(&BxOrP_Z;f+r04-1$;Kk^~F#MiZeDT7@FwX!Zb zsw1Kbu%2GCvyyw!lx~FknH2VI#l9(amsB-zYl?f<+m}#MbKuSMB2{wj55Y7I?$9my zx$oO6{BYT)*GP(8a#gGST|!LK+FPd4az0~4!ZA$e_c68P2{ls(%l)~=rE-jwaq+M= zLY`qTCt}@^K2cgSlpr_#_xih-(4!Nq)`q#b%NCeaMSIZJ&x9o2-GN}g5lY6Fsr8lS z3?GEdO}P`)8e0QxE#SWx^|ye#f9t&vaBL8`!P$CH0HV!<@QxZ_UL(q^Fz#-(sShwz;BpRj;WR}tt|Vncn`#`@uG}i84Y9 zQ)?R?tDONd<)SW6$vq85=8v1i4;J*VLYoy?H-%t0DDDX%`g{nZliYWRJmsgqV-qYm zZayiIeQs&qhnEU%(L4PjrH`$LD!r~V&loWwW4F##qw%V<`j^daR`eRMQ&q5DP8=7u zX)ex}3W(?B>#+p}BQ2T|6` zY<)jEBYC?g_u10i3Fu<_V6?LB2LnsM60_%}C*O_4%MhJ4O9E<=%?K5DOpIQ)UuA1B zWm&y_cj)kTM05M~aSegWJ?m$lGu2sI1bPFujeR;#g?MDgX+r#i7$F76#;?B+CnYVI~NC?0;Q(-lvE)K9Av;7$3ne6?kJ zycfsKD4UwnS=RESoN-iOnxWf&v5joYtjaF5i++gj$j0rpy86mNZq5gP8mTG?AYs(B zQ@qHKVCFu+uH!HnhqI7Jb9mch>+Q`c_nzn+X~BfdJ5m!{If@}PO?fpbHsvYf9 zbXj1&tZ0V9TUb+rq|lH}c6Pdj>ZF55E48c!1YDxuGdlV_fpK8vDx7<;@DGwGnV0O0 zT*?CvdiI;3l$NKv!IX) zEfx)tV1+kwyp2FQW>oe(b0S6sVhM;js&uSe@QRuVA#kWX-V*I?xWC#Dc~wo$V>lR8 zd@Tf%x@_*lhVL}K!ry*Qo7{^4nGtzQ5F(qUC=L@?a|l(7J9aQjLD1anH!3$+gL5xx zu_&w4xr$A-6lKMx+Tx33rKRKZ^BEJEM^?Ar41-+l@5th=51n3y1TE$eE?(7lQiB&U z9;W))85u9<14mqqT&TKYy8`UGL!H0jc>n7v_ivC~zrPZ}%)8Qi6NYA4A2n!Lw$Mc9F%I{RgH2poVGMZOvZwbs;a3T@yZ4 zzk2@Skb@j@rC&i${k{Q)|Lfe8EHpPWIfNW6HB(`oHyx6hZs8)XF+4mg@R(OZ_Uo^0 zA1vj>Eg?_ofdH512r~1>MeThX_}9Mv>^{9l1a1eu3{E*|-Qqt9m+O&1|2bZPu7k$r z41W$iR$C9-K4_TdWcvUQ9OjhC)xXg((pm+(015CgsE+WYr>lw>AZh9e%|C%`*qJdiaIE^QiJ=RJDy`fAxf}_#d1vxb@(L2x zaDoj^Pk6Zi|1B{pI|ij5@R}lRL}HA zaDXwZGoS>VGqmY8BBLnbCTXiOmtgoKTo+{ScXlw+eN%aV#IEBs6obeZ1uOjRM8M2OrCZ7;85WybJ|*kG>RL@@X(ToVk7CbC#y%)Xu0z8Fh6Mi_?mikq1eic=8F#nQ84zbnf@s zYoo~lmpB;t}*7~fHRCO4=6_+ael#+(BMIZbZ^fS01bGicPxgW*Y(=02QuZM$R_voj+?F+_EjB9hzL5`i(6kVK zrsA@W0>cvamsykD-&y!)VmUI_m^$1Le~nh8bM zZm~Gu7l6!&YI6z47b*-*FiIZxc6%1{jrg&|M29}vY?r!Ti%Ew zf%8q7)Wrdz{-=^h)?msIO2-hY+)x$}>IJy<(XU)AMune-lsaZaj=7(mxcnxy5?r|!F*K2<#`e6p(*!Mmy!3Ho7B@Nvg3Acd zrW2J6EPBCTNL=FtbhE3+cE0canXA5U`}Y-h@whE`P0$SMWtQ@aX6|S6N~*uzlHix~&hpT}p?Q-4TBh_Nc1iUeEiYQhI7*sEnVb|0I@t#ss zMV=IDo165>dIx|i@(TRQWu)vZQJk+n;kD4tS7T-2`wL1Xb)tM8mdyOfjMJok zTykI{KWaMUh`jk)`#}fOz3Xm{{Gkz^CLSAvh#>jT+7>A)<$PyQq8U{q^{lq30Mrkv z`&Sx@WThA!djA=+Il4ge>PK@~c^-s2bYexxTOBthhl{6(nB%prkeFn+W_3ZB(RJQf zD&ihJKrD0pMZ3fiizT@XG<9%5u_cV{)dkY`&C=F$; z0hZi0ptIGRDj)dZfnQW*@24YgLiOqsJhNwTo$%R6~-}sNbYCMK__X3>}^XzD6q5wc#t#VGZjpea;n~txW?bM(ImG zxjHRSTsUgoF?HW-CD^wwaiKd}$>c@4jdd?XcXt`~b2Msx2oC9y7(ATKi{R4{-V%Nx z9eKk{t0?(x|Mkn<;+n6}%bV=R9f6A938(EgZA~3&Rs}M8r)pNztmJ2Sn7!S_tCjG} zz(=;Qk-#^s_y`i<%3+96F=My<--cFj7@5F!_B!%R1)j9OM^`2YJ^iZPs%ZEdLhrIK2bFpar&;)L#|tgGEkkD48EY7 zmIEaEYKXD9Y%SMaOd=U%|Zt{sO*l=G>&#wZC^1m=M>_LCr8~ z?3P?2yArD%{J-@)Vwh`Oq2}Kgd0)|gzU{y4>}SCk8z)A0fo4 zb%N`}8jQ#sDP-HPMJ6J)l&Wl%3296}gY}*lc4`L=f23GjtFNvg6VO0Pc=7+e3YSjf zT|HJ#1d#8h9x}xng#|ATDM1$?)KYksBz+VVH2Nna2IrO(Hhg|~|6ABQ;Na*$t>VyM zsuWw}GRQWMKe6bM3Ych)DI9pUEV*Y5NDhkPpw{KibZ}uRL^hmSZy?2#heS`t7$UmZ zYWYwpf8lH_UJ+uUpNF{CW7BD~y7#p4iy_5)yG7JvU_aG`&z~cZ+;Ca_DlW%1Xl1ek zwQp4yiEaVra~RNH`QXy`L;mZ)=d+>kx$wrn*@RwuDjmBin{@gRS7D!*pC-kO_6xXk zH+7MoBiRrZMT5wT-P``F_@r;=TeXbP2KYbx=b+6ZcOYKby`n_e^0zrUeeqn*XEAQ( zlfEUXEaTetPWI@U<|~ETs%K;8HU2BST_OR)Y$l)EO-%VKmJ+0NyaYhY57JKsR4rc> zdgIcOsPmk_~e@dh5(Z3LE`Zq~^1iTK*QjwNGw=Hm8vCj;yk}i#Qh>RV5rEt$Kud6&% zIlcDwe%CvVAGcwgov1#yyD}^reiTxpdBfYhZm{vK0cB)>yco|<^4W{AE3BFIa|fDa zRqBpwx=5Ik4>D|~tWGP*`v04KvwET!2bJM>B?%mZ?M+v^e%Pcbw(PV7|0GWtvZX}~ z%yp?mJ~`DJGQ|9Gm#F55FGIg5o6;fhW-yM10z*&Dt;r?|bFD6|BhlnR$7 zivN%z*oDG?=?eSd?D9EZCPG7tsU#ef%vAg-AU}b9YYZIoJ8Z41q zrH;v;jS+2q^o)$z3>=lTT-kq*Cm8$%-$cLPC{2|-RaQqhb~Et7*qe5UaG{+MURRU;cs~U!#I?{VMhKL;Js-SpYn& z)uLU8!s9ID*Oa4sZCkRN+R&d`?O6RS6(_d15XZF2j}O*O?~R0SGeomJB>A=C`omt8 ziFhM|d*><3@-A)<>*js%KI3_A zG18IJWL^KqiKB7nrwiWt#iI=%m6fv)jNQJNt5jl{vp2P;Q_RE%^!y!oJoIR@=`4Q^ zCx5{uU5~vYwL7%!x1`UAp0lh&+*&JkiQ=3&3Lo>l50(ozG&ICH=>n@s#=`0pTlqC5 zvayjj1=~A`ohwvRPf;m9>yRp$87kk5D=hukBix%}V`8vlpHbHA@MwC7Mt=@*w!fFo z3&Q+;+ID_#YMIkaw{1VSo<>N${lmeym6{v529ViaQjj-MU_99#y0J03v(b_x2>L~` zpf;ksO!#re1HI%IDlZB|2es=XiYf|)lBXJnuVI)ON9HK-mYU+*_V|{#-|Snu3v07-Cqq7c$2@D+l4*GH9|Zh z;9>)KERShqcF*1)q;Q0cb8`off#I6OQHtO~-sn3%qQ(Wt4;qAnli(d+W)}_i`D^eY zar25B$ydD)g}}uHjR*5gdcDyJ8vxqGRyE>F-- zu)Iaz>J7v+Qa>d>vmTFou;jImKeE&Oi>=ctOwuC~NsdtxJO?GW>Ir~m!a?QbbO=SS zjn|d{p!JH9lt2PSwn7qmz4wlOGPb^)i@rlUj(s~vhAoWl4Vi7Ak^Ias%-PEpK$Qb! zr>gW$p*;_t&sht1#uF8!`l@0*>9X?K%%IC=_WkB7^a>`y*>zQ{Y2#7+YAEfKW zT0Kf}-#ia6m^}epXFAarFCJbbF1^f-9*?evEZ{-E-N0#$4?-`=BrQ(zJ+{bAJAl3 zLXq(%puFo7*k<6x_pz<=fuia<0V7PgnrnFKYkq%EPkaKi?9Mo9=kq#jSS~uW;dYF9 zS8M!JCc)se3M*OUPm-UPXJI!Uf8X5~kF}U&2lA8oUq{IA z`Q*&4t%0=)ll*&>Sg}CGc$2Zjc}T$8m^b$UKZF>z`myK+4#!gmg?1#`jb@L(F*wjYp)A?Lz>miwV5Z@g*ANqVaD%}y68Ed* zKy2p^f6B98+=_7yo6Z-GXSu zV~M(dGh!G_2~Oz?4M=Xo?Q6k!Cj=+4r12FP~uyo%(7v6a_)?4NS(qKDnnYJ>7}RBSX-#AP*P#*|8n>x%e` z90Cg%cZ1UAI#H$Pw_|m>BJ^`EE#I=+3TI|Sf=~09xFYiN;6>Gv^cw>km zwaDpn`;A{n;06}>x$Cz`h3T_@bQK{?M7Ms=2i6Q)jr2ARA2OgBNuNg>fQ?h zXKSua$G7b&0IN5O)6K6o+KTgJ+@(|=T|bo{boI=wA;Z!u)$7KRxz`l&sP4!V2$u+-R2?xmg&@E=~b!f7QHg7J;yOHCz2*D`uoeO4v)^e zPa~G^0Vep`tM~4r!i;D(RP!2h%kDy&<&7^HxpsB9-=lOiPsux3;eVX@(-95gCG==w z0Eiueovim)S?w)u-K@U<=6fN911p<3wwJaeF(^G?5>SN4f-hKknuN$NCHAr?A{CJc(jg2O`}ZbKes4e2NUBt!rH{Ge{I;Yt-3tWiECC?p$qT+Ikc zOchMxF$!~)QM@g8Sqv>Ry&7@#zpRHA;tI%Cdb11ov#?j}>f3qlT+o zbmV1H1`Bk{<=wtyJ$IgTb*ascSCDiXgcb}tsb^I6r20K+EdFXx_|@)H0=1B&hLV_3 z4K8<-r0Z~n;G)Nx8uh`s%~ulO4U=lq(sg0w_HnwIn-yQ1;X3S9u-PlWl`XS&A67PL zDss(S`Zwzyzb8TXm`EqfB0+r2Z@zopB?0w($y3r&(JzV%*ci?8qFP8X4%|YHy_z+Q zO)j8~{BOAIIRli%I}0q6@<%ADhHFYh_@I2R^gCV$B0@b`xD{)gU#tK5rY7CsaH^oN zQTMizhPRnhOhsY{!_-#s0oStKHq3Y2HlyfqH`u!85x2OvUv z`3W*7`_1)dB-wwRk1JHh50Id5ME|xzS}sJ5+!l5Z?PatENcSyr zvZRiNz&?jkBR@bD8`K2XJd>)4OF>TF<_EnikWPV!53X!~bgRBEzKyJBb$auyX^9TO z8@zu0;={Gw`quZ3d|5e!>ITno(Lbvg5U`v+w@gQV(no(~2w!0Xgt7tb^CoTTI{Sq^ z8S_fgt zt*w*2$2nE8v;3i%c@x+cxQn3zCWx-?ZSz2<%5I(Go_yro1ktD>NcK2H@DT&5tDdFS ztlx7K*s?aDy&3W*ZRJyC{87qJm|P{9j;>{nuB1RJV=2)HXyP;WNSDAnsQNQugicC6 z^*0jZxMF-djz5&_`#64bh?#mIcDtvJH*Wln zXT@6??)r>I1GHOX9LC`5xKFj382MY0Z0J~2WF zVk3SctAWPnXD>bvpg)i70&nQiU;yH&`&?}kh)U@)KtG0x5u+xO%kK>UnRiEgY5Bpu zX+sfwO4Nc|x>vJ+2Sh)9w6@gbzzQ+j@O&9Vgb7n@eIXBT#G27;_$cY7un$)0)yP>) z)U5uM-=+Yq)G8fN%@x;}>q~tSF;_Iks-E$Rs^CN`bX<%a#vQPeUlG#cazg{2zUBNB zF{F$SAW)V?pXrdI6f3${hW`yW5eig+Xn3dX=J?RMogcy_o}rP~mm^>knQ}FN_Z@Q= z;Pp&qh~<^tCSG#vV{+JkKgAr92qf;wz*xiWsitndpe?b(EBy2{lHx=vcTTer+p0=F zx4cRXrl$MN;3W}?Ky_thH7G|bknfp3Mf2tHyS(|9#t3EvDUCLnJ&_asq*C`Me>lJ5 zQ55pl$z&0PFOGlYUpW)*QTew%70-fP-yXpMwKeCTiraX15}_WkmKN|c;!~4uhQuhk zs;8&t*W^m`0Sj%kF{@gpRbEBSATUJpOo_!i=8zR9GkmuLajs$MM9chN{|z$2z=-jh zZRY(X=W|-LJ$LsiP;+5vnhp%_=gjiE8y@a!av@mScN&Vt31r$nQf#<;t4?#9<~sU} z&+Q4W_U%nW2y*y^Ab7#1-RG5vH*R+Z4!}%d#4utE7XenhHGz8vp+_Cn&5P+@o@tu0 zDXYKrh2*Yf+X!xEX$Y<*$G;G`T%pynR)c3(eh`D|B9Zn@I2;I)3kD5@U9?D24s}9a zW&pEC|8oh{OW;?O*zTe8paQumt@;_qOHfbM&NY#n6cnA*j7H}J;%D^q_I9OwX+B_> z9)+>Vzj^>$4V$u~&EsGCCYB?^onSFRiJd1IH~u%U&sGI71r#PQVs^WJmbI5Ixu4vgdSA1`aKESP00-#sOgmzt|bQ6Voqvfb=`%y zDXDU;28{-kEV?N{+I{yP;z@K*PYmlb>Z8xAIG8E_2YH?c$sRm{(ZaZ>PbZ$G+0Vzdba zQf9fkZa=$-T--k;a(;{{wRUFK(#s$AdaVnknIAQMnA}nbJE(mTvpOC4hVv9Lx%=M` zWz@jB;H0%akJM{lfginEvdryBzYR05NKLSZ@x!yEuDb!8OFdiuwXuT|1#afDUubb!s{w%2b!A;*8%`4*t?H7qGWu4cRnPu)Eev&v}<`TJC`eS8QF# zV?L5}-EWgMZaTCkJm(t}H02uHJ=c6D?){gbvm$PBM1I(sia;{0oP(3ID<$c2VG_;K z8a7(M$YcL#8KkcOmq@2Oq=xEA2@~@ocvJlYFH8$L6WHK?{`)+9QU!cF9)~LNV)sL+~;U4(vxJX0+?x&0?A}sG(T^sU>-1m@MTij7r(( zdB&j+hSN%4y#_+NTTw3PP+lsMMfjUlpG`8Eg9K{QmHhl!`1K~1oat5R!ZfUtVEH76 zFN&XKkel$tBZ|3P+x;-!%dE$?!b21gLvKLx-%+qBEir-14#bE5Y3=(+F9lyTE0IjGl0nPFz~r2T(^C1GbiE3u-2U0MafNOOxT#9-R&=ad&NOQ5&JY zt)`{PBuNj_VzpS7S-0$UfK5N0LZP%9UH67rF3y!JVaRCKPD2JQ^lz|<$(Hk}|C2uk z`zL`H8-kEKcjhF?cgovmAgc^8kX-9 z8-_tMRh(1JyY*_7mpA9;=%!o)S1e;=e78IgzL?0|+Z|bfui~87tIdQMcLYAHzf?9{ z2o?=;6DAsj>Pc$j^@Bn%r1mv(z4Ln_0D}5{^JE!{9{=HmaG721t*Aj(o&HeUW(nZT zZj)jC9T8#YW>GPyPms+*q%`bj*_q+tHWLj<^j1_@_|fo#rStF#CA5xgWerXq$juIZ zqtJtb+15Ye$j65j?6Fk-iUvql?2UzGe?;tsz1c*i!ZS)lUU&dcL+Rk2^D(qc`|4s# zd6DJ09Lcy|Q;8#~s+r79%fF9Dob|ywX<1md3=RL2D=RYR-$;AHM}X&*;MGltnS!F3 zR*3Z#OlW$s0rSsd6Cz1z++&1nvDcDQ@Y}>4_wapMEX?4D#6ePJAQ8YaBHni&P$$W#;MpsNKE?4Zju z1-8o~+4d2#H&D*sSfyTn#GsszD@PhHF&RZ77>yLpb_ya4WYz0}2lE<|=4<(AkC7jI z=8>N9j!h;_xkz&ZYNmj=ktTPfKeC*wkaeVe!@Ah;AZOblKh5n`#6x@vyg#_7s0`rb zytN_DSd%M3@7^=+uk7|Vr2+w-F>k4r`dxdX7ykU=K4xd;4K(7TG6SL}wdpYmFHN?M z5>wjEQ9y}`0YYYs;-tt&LW)y?f>gQa_1{8+&rbWc;(%%x2~;^|0vCgG%k0@L4WP|d za~D{+>}eg3eCsae84PD_5RV!MH4MiUEFjRq1ZguK4wscF3A74ucFXvZ-*I$hSb5(X zJ*D=A*%miU-~ts?O#nX7EClOb74w>!f^s5{{e@98H`-}AASERkUxD9$By2d;+0wY# zb9sT<61F719}WoRE`X|O9IX@{?S&`Q7zko&d#&@vA8qr`1sgq3O-r!^b!2ChTH^ZiHvLd^X9p?Fzi~Ssk`6mI z%xlA+jSFppq-4yo>Gp!EW7i!G;h*)m(SpJ$*hMPMTq;F8HXK{jk1=09ljI}JVik*; zuw(*-d|Jj!L5amUz@H#orbT9-=6lpAHm`lGDyc`$kn{64Zd6v97GLqtqJKNeDiIl# zPsQ3!7JYR-#W?^(o8dZp&-Locb}@>xU+MYEAA|G06^Wmrlu&^xZky>-DNQe%BXOY12*;@B`T6 zU%I_@FUHl9wS>o3F|241CY9nvvUO&yEsmv@DK)g=lT}I@&dGb6xa;a;dV^6v#IBif zCOELk!kNo7g$T3hUOMTCOlAp2Bs1KL|2G!be`8hVn+4tnq}AMY4x29{q0e(ZKX=~n zUI4!SXagktDVi+-UgY?!Yn|V+1zqZp8!GA6ML*ipqMr^leN#PfEpgmk3A<`p7a6te zG>*$llibX&%TJbiY0UF(NsDIpUVQ3uj$lg%i@!qb5rHH+Q&SR7&Y5_7CL>$9TMo~! zaALY6PXrq@(dH=7YXiqRp{>)1UyBJ;%EM*x)>uOk*9N%FyMfpHWS(0=Hzc z79=Y3-kxy?Rsy5g`(C^+O74n8r=m@+q2jXFV9_hkO*_4Clb=9Aou}x`BBNK9n)At}xmru$!WY5CH=D}w_@;?8FUx)#zFw>%}U_B{A2d;vWk=kP@o$b#w7 z*yPBychMk6cibN|E-X5yaZ-5sE6OTlsukk=@D{8Ik#u7)#r~1+?BZkuhI85WH;f9@ z;(B1!ofy|^4i8T`6vY^pdlndG`uEVx269c;tsPLmSYBPV*8psl@c=?0zv?CIWM#m9 zW5#K5_&{cI+^3~x_Xl5X>V;%B6SKOjM|vK%Lmq~WubY)D-?_QBiKm$kGn99L9r0-6 zUx`7rDfh#u_GEP?+0`>o&Vj3#aB}bWPsjZ?DvkNk|8F1JW)>6{>MjCB^{s%TNrpTR z_FQ?{UhO?I`R=@Pjd|P6uLZ9^({?1vj6tBHdG;?Ezxm=*g1S~UUn`C){T|KmN@9=I zvAnOx{TyT(l?r#bG6<|*>SS1+B*Fl^t@GN$zLZr6m;r_%=O`i|B1y7j$siy}f*>N2b54>5 z0m+i@9*^g|=e*zd*LQE#U-z%S>ZOJ~d+ptOtzNyl`|0krAquRaM1)U+kA{Xur2I%x z3k?nZ5cPWl2e{HZzVHkUjmyf~Qr-ad?TB!;0xmNE-!|6#E|zFF(MW^P(B7hnrnzGN zx&Tl~{-#p;gUb1zR0ubyI0E5dBhDvkBV-8?6yvsnhzWBG^7DhZt*mVk0l%qadUToLE*pyXkUIm!20U}E127V^MLhV)alj$ zMUI{2A6J5NZT~oXf|?Bv#KyrLV&e>l*}8jLx7o)AZR9KXG=SX18~C@=H_ha z?%;rG^SVIo937y*M4;9XWkoM8FJ~8V2S9@ag=|DEAtHR-eEc9jZb31A2)7uB-;!HY zSVTw^VrwZTAixLvHL5wVaHt_*ZeGH_md{+-2@nw=dEgQ+zbFqMlO<|Z%~7k)3*r&s z5oSW2a=XES7QYY=zx%)SW9|U8g$1|%5~k}P8u7O-?K~iEs0FY=b$#sscd&z6x+B~m zUbo>8C)+!}gfI0=!~VME_%9_6d1H-mbMj*QciMkZ@cw%Cx6b}vv8__uCCAV#Ka2ED zv7@W;J8~g~rktHG$w(g_ve*oAw*S%T{r{=czZB|sxA*pX!e&nHg>8{6mk2X^Kb7KG zJ|Z+)HQDx#^^0?3toobkprNtL{#JuOG?w4`zcJRoW(=qTJ1I&PhQkzd&_(a&+5)$9 z;O;pN?r?V<*b@k#zd6<(mQIGmf}jv$5C{_k9St~P!@=W-cocC$gpP}m9YTByxI}@0 zj>$&?BErG5h(inw&bMF;Wy+e27P zEqhfIxEgUD7VoOA_#SNW=(gC zgdfB&z{k(e2NL5K5#%$%xFOmbfAEs^*gQLgpam3yjSC9F*v$s`$G{-PX2^`6V2HFCM|6_L6Dd*llCJyz^IvY9GoHA?v~Cj4p2KL1vwA{ zH4(o6NDL$j`t@T(O(Y-)Sdj?7fRLDwm=Va}f0GFii02O`*#2VT4`Yy%(^301DqyzG zE=*bwxC>wo5I2w^h#UtOm~X!n20G4-UniL8xR~;2Sn6Emk54hLYu693ll4l48A-1GYI{z3v+B$*spYVqTiMK=WnGf{uxAM#RVwE{G)_PA;hQ;dGCjIpv0+M}tDp zBSFLfOY|h@=+{_Sm>9T0AVO4|9M#4Ep@FDSt$U~zAqXGm1}6?WHa0Hi4GYjeauHX{L2z8qgOB?hUq?xUrts0^HCsMdM3GkqR!5Uaz z9&4C0@1N5Ay`oBjzt{7R<^20g;+{dzoyVQtgi2OOf|@}HnFZl!z>C-Se_X*P={BzfI0uL+mXpNGqEGI$Z&GO) zEibw}=BEfk6i0XMd1@)%4D^y*35~AWSKg%Fk`-KkVgFU{{1(KhtA(KK8~Fq8ZxuyM zl4B(1LpkR*=@PfK5m*GlN#79Bd$}(6H@~)&vs%T_Y1kIU_SjVMJ+k1Wel~#LWt>0b z`>;}&{FQ0?=dOO1PcLf>S-A7|J%>_)tMQO;C6Rw2&~GU6>TdgEjHy@M8AajQBIz=;H!@!Z zyb{jS??kT=QL^_rc$+zYfV@O%eB0a$h ztt_UtB!4a6h`lSU#eLaTrKq=JonKqt^m{0Nvi6;;6TU&2*;c!F*9$DF($x;*%nbdS zpDtkKGWYy#JLe@eylVAM!2JNGIsxvaTx{bmoRF!&K+^mXq z-e!hNzI@We3kOf)<7d=|DZ0JlJa5eP8-6o`x;249aLPd;SV_NKA+E4U{aqcuNu|3HbnvMO`K!C-wC7{D;o+F@sPx3;4)ee?9T1 zkJN&}+yO`V%M`?{f#h3osWF0PHaEF;I5%DMAQG zxu#vpP5H5I_dU$c{dke$FBNX)DIBU9fU7N%ZAK1B1KQIw0C^>fts`61$+Wm?+15oYsF zYu`iZ#4_~uocTK)0%m)t2y>Hcsd@Fhihuu+7@6HJalWQHYF{hyCZ~bB zEPDxDp?^Uohwh1J*ZqSpZ~vdYE%4#v17T(LXr^H^gJh&Fn-2T)XsY2l!BBD)8G6~lg*0tV!@L1aff@g z3~3#&be;M{9)#Cfm(>>; zdACV3SGmE{Hh#}7eNz=ft575$LAz9f{)RHit3ENGx$Aq@scc+QGEWNkY(L8NY1YZ6 zF*C~!)|21uo2B;>|CU*{D(L!hg7wKaQFuuKx@L=vgjbnb*?DK8?>4@df|4MBB-)9Ja%WJZOhd?xc48FCROI z6?7K_JQy;)_bSm>I1J-K+!!00!VK9*icZ|!9`EV|STo@`5WvqMd z5*2d^yH*jFiUjqbBr!WLA!~b}v=U;7BLD;*yg=YV{X6iWH71aluKZ@Ye?XL}Gc-N? zcko5!V2FPP9(O>@s4xPboaT?@M%x=mvz+0m=mX~F0{d0F;G+l8qKF8{DgGe(6=*PN zL)<)oupZ9G^2`4Kp~&q&ZiC%mHVA9?zX+I=1b$~_Kr!R5ScG2?1T_DQMS^qqZh}Zq zqhJ!=u(ovIb^$s;E#a?$3CR^;PrmvES=zdY#=x)R87z^51=*9yR-Yi5(v=6^C1{!Z&Qz(0XX3@aL zEp*1FIOrOOisZXiwNfqOe!BHZnN<+#?C<|39t)&iCwYY_oHJ`q8X zu%(R+pBUh-tgQL0toa3OdDQ?O;O+`qYQK_Pkw0ey#2=iX`yjSI+dzg(`#T~)jr1$a z{o7E#vVcD`cm4Z5{OVt?z6oixG2Vsu!?jBm9RJP!e<8nq?Bmx9O!yb}xmm^6cgLhC zQ=29~p0)Iw^w(ydaFhRhSlK|klqap|!L6O)&6&T;#s7#bhA+c8u9}9XxgVS)x7s&x zoRsT!Y1RT2p_0ilQq59LGCW;iYmPt0$iLW)5O4xkxV)=?_^ISjuvMNd)}**XkMs@EB55t>0%dOV9;}QYlv8I0g|su0eaJ`u7_ z54)H`^j7P|e#(&09sad3DU~p`N6aZj(Rch>(fTnvY3@xtL_@digPN{0uAIE?Y56kw z@%zs0arIjKJlCE(gbwa=yJ~iZLXPmm@8*p$^Q7Vd)>-x2(257Tr?+k^o?Va8<5VVZy*bwCgJJ|3apcyUPu`i!qfZ1rWi-`uDWtjy`MNB9C$dPj7bfrN%C6(Q(bZ*^-X2K$ z8FPAUr8`u|SwL>$r_|3*9}!};h)kO+qUm=-e3-YK8__;!x`(PzgxxzAe!KDJf!wya zyQNr1ZH;zRu(Z?kfGaIeU=yW-3kD6R)f>XZ@dY~deZ;_Pb#-Oq)-+mk$JakK4x^wn zqua6~Zz*ma2M}jHp=H!P(j;l(7RmdO9klvlF>L9kG|T;qG`|y{qE@}mwQ3tjT*}Y~ zZ(|vygh^jxkx=%~dcHY*_?aa`$n+Jj$NJjIgDNqJx5dTBws`~Q!wtHVosnm}70nOe zuWJ#nrIpLwmOIA;`n|4(N9UC_g5_)a?oCRC)zgrgSj4Y%w7Lr2To(%TC&_USt$7o} zMip>w{fXYwLE@TGj=c5$>&WL>#EGVn6ZorPA=1S=;>JAB!TjOR@k~}jTat7pm8o

    m_@Q% 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

    • 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 z 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

    V6{aWpY>Oi1$BY{8C=1y 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 G(Ek8?l&8l4 diff --git a/.vaunt/badges/badge_02-03.png b/.vaunt/badges/badge_02-03.png deleted file mode 100644 index 4f6748d6f05e836750795f1deef8da5b08a12288..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 99890 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

    • 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

    m_@Q% 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

    • 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 z zk5k6(GxBdvNj#2VeMFy99LpHc0UAc?ps@NLbcYyxbGi!PA1@9emf_Nvo4@W}5+O-Bnx_9#fHrt)c)4OPF(obx- z3I`7`%#{O9J`|5dQ}i80R7)J&9;Mc`)KPE=ux1PeybG9oI;eN(v%DL*dT@!@8$7Wh zu|;&@uI0xvH(<<-t?T_l=o@uFrFN8}0crt&8aV)J#Qa7Ltl|c3|Cr5j)EL-MY+B6P zzgZ2~>7ViP{|(gm&2Eth@&1V3zj&*h44ooB94z>R`1trm{{jm^KHya3Pq6s^2*ds- zGTTVY)82ls&iIkjEmnA?6TI7LwZ?vI(HZV%@lx#!98 z*m7@Ae|~VNibK{P-$?!<t_&m4RpmbcG{vi>CHZe*TBI2>}UX2)RR1`BK zj?iky@tv70!c6c}S`%HjA`*Pa=QT;j=wjtTS6Od&Hf`ta-d@x6u3)@RNb^(cec{^9 z0x~l{C4Tn!3FD|lWm?~2&%YbvLn3o-0lioE41Y`%!F(lDx}Ez_X5Y-yLi9s@omNb! zq|^L}J0(wWE3v&BA_b>qE>`07GL`BvY$R1xRmrF$jnd2^^{3j87#E7keQDuRBC@j} zoGeF5TAfpM+*WSk{G;rUjrf&_ReVVX_Up8ObHCya-JZ=_YX>yq@Q0-@X(fd4Qju|q z`zgJ1FBCp8WZXA-!|S!RdH%3QRJ^pL9N)` zB{1xBJ3jeENi9^iZisnSBBGH3&)7U+{X>WQef+Ka!GX9rp5b-5FIY)}uB<*%d)tfO z(aI2Zu%|{p&%#MGiJrmOhzOG`IS@1Ad9J}9`TU;oMtFOY_N)?#cJ*rZb>ML3(CVLL zRuI5H@PA8Y@BaZJJYX&`M>bnFOBB<;=pN5si3ablBM*Qj+VcMbhkt-40xFp35Aei> zS8;z;*a7fF1MB^Pm>OU;u*zT80l1U`OZ*8YhzKNn@E)PSJ|4WL^sg?R?V(n@0Ko9V z^DZ-}mld#SUEupjV-Z-xBGV zsH-LPv@Gx?|bkxg22nF`^36Oo1N7c;~~BzHZF2a-pFynwHPfeZPZ%b1p4aBhtEwd z8$GA>7&eLB+lr{#V#L9c?GWMWz}Mpf`y`pY!odnQ-c9Dt6x#i^G?a?bB+1%rRdd94 ziqG%ME(}m(Km$(F6f-^~zh~g)RM6Ip>tvXH$e}N9+P{0Mc@vz$Za zywZMf|K_-n7)eB$@zJY<@;&`^Ufz;-yfK5!rS4b53N<>{R@rDNaz9K`q$LH&at!?-g+GDX(I0reG4| zQ(V|LtZsZdKk7Z@+QU6zx=@$xwcBD_8rsR>dm4FmP@aK<_rrj6=vxe8oy+5sPf;K% z-B~(X6~Xte8!1d=PkCo&EHW`kS1dKpms;Vwu?Co}f9%En=kI?s@E;BQM+5)Sz<)IG z9}WCR1OL&$e>CtP4gCLH17`*ZAhZeJld;ZBgr42*xjz33V`37|ie$BY98UH;I;gP=g5n_8Y)VZuf5dYY2lw4q_?Q1C>YRh+H|LCULeO-tbH~-M2Wn zdW$KnCs|nGK!AqpdBW&cp8Ev2R zy$s&~D#f?w!4d+g0F%^>Tv z3Jm^I5B}zxS?UmqhiKH`G*=55oc@{QSk7ran8clzJ7y;t^01F5oz2d;lc&Pn*4G0W_lc#RL&q(}3HwSl|A;U2qyKZxr1B0ys19Re_f`_}gwB3%Zj zx7kTzr>Mk(E!_{z4<~c4b1#;1GQ&!UwJPI!@=O~SG6=c2c<2!m5U~2IJLal%_%EIOS0x(=BC(*e{LZX?F>sOgX5JnyDQzHeP7`#s1^rE>L(9NFSL+qy(z zVA9Gy?vPaq^(}3)0T<<74M3hKFH!6U7}#jAMx>l^Aivix;0i@Y$Hh96|B%pNCpiD= zDf2EGDk_e4qHcOwNu}>Z?J=Nlidv`ah1&aAz3bnv8Mj_8y-7?wO>kqV%?4Mw**uZ4 zfFv#K*UT$gavfM_Cy5L$a=7xRI9|-wmgl(WkYK`=>KN`#+Dj^{ht%@YBWtQW|8aV1 zvWI(`^}T7akKlVx^h8;aGd40}gYt4x1^usiu@lAhIX2MTuFzBo`$Ha92e`|ab`dqQ z4r1q{=}4n8uCm#oJ{ap6a!Jx-2(VXpYjmMdTqK5unA;=tR=CRaR{crr#_<=Dj&yG3@EtCo9Z{w;%{kr{7dvHXJpQ-}w0OD|xIK&rMM5 z`VB5p?CuKmfj!l4<$sE?Ul7#D=Sxin*EAMw$rY_EO1AsWi(gz^V6&IH4o>GMV0#+9 zHZ0=FG@Sy9`@v64S5rfzz>G6l-_TxRQ)w+Oae-e;oACF19?HqY*xb!g398cl?rjLIUrUN45Er0&FAbs;UfUh`Z-crq(o%z`UGpctwnV+~%UCdbMm-=>}2JlSj$vE59^ z`-+7Ln=0o0!4U-qgO-eUw^TFx@qWt(^c?9b*kJP;n$3B_+D8Cfm zdPsTHzyi0)R1JcMe8D3nH(C9|!?#Wb?mO2Hf=yjY1Akt8(ftHQDkPtLEn`S4z{;X1 z@c3QGs>a%(b|KP+NU<^=OtCub@)7nMWn!(OyVMPkiBd;X zE-tQjiW3W|;M!0Z$3@4hgp7I~z3JpIl!xAG>}8p$Jd2=j7hiTh7TBBCAvo%e_kBir zoyXUwGf?Ldi_3hQDVU!vZK7>aIns-y>s4oV^J_|%{SMjbUQ~64C%)*&Jc8p3Q_xbW z$vcdMPlU>(+@g@$G;X7H1wef-l-rxnmy8Bt2j6R&8hcrpy3k2aL?b~tIE#zcNs^Ow zRSz4jxkjjVui5+rii`GZ)vdDA^C>!QPOa!aJGDFu^(e9274$9*_2{?UozEdle&0*? z@soMJz~sWYT5;9k7OlZ;Ld9lc9fT7Kc)@hjSTyT-;P{5e?L&yt26kj<7*$Yf@hiGh ziHt9gj_CC}x}!w>tz$zyNHo+*H$VC`eg8y&_K>r<8!NM$j7|7WuWcnuVI_2`Zii~} z;z2@}o42d_VXMJ#`SM5x^v1Qk)P7Kxr60AW;`ubC|8jc)Th+>8+2b-7HvUkN#4nN9 zOfah=QG$Sci%g92kdV54Qm}{!I>^r1`5_Zk6dgKxbT@FESci`gMweaGN+}`Xfv%4y zn2r(FW-^S49ww(s_@-2B+gnD%kqI5~_~axZIT=?5Z$)GL@#DuUr+x_NM}F;W-0Z*y zUmuvhVatl<*Ko-v$xq>kR1Dxy1FUo$D*_hBXUl_ zaro6(c`^;DNeP#^IC)I;Rz}oCi-*un9gEE>V&~&s(ZNznK{TswWJ5zkPZb!p_x9xV z^hk3P&!iPGE^FL;d^o9 z^8g(+9Qez|!=d{vsDd;LA-S(KK!=^DZqZ$XGxCwh_!RAK@E}6pU7G*W>Dg0XBXVZ= z;ACGhZ5)aIZfB)6=NFe4+w&fZ?e z2VCBg&rU~8^{zfOPQ7>##xNih?UEHD6(UUs>R67GrVDxY48uo)hKR3P-8_NAo}wUYGXkuLL58g5s|&u~*p*$ua9eQ%7%=3_Vf z<}EauzZ&aNA9JNlV7^6=S2aE`1QF<^U}{>Lj@!4D&Mso)*A%;m$V=YQ-3ZZi*~P_V zK^?RYA3iK*<5hHV;qicq_I<`9$r@Xh+td)oniU9b8T&9Jm*GMJ@`QOEkW-=G)w+Bi z@54p`VEHlJS10TDw}t@v#RH2}y2tHt0Q7R^`x~ zx|jxQObO@PpI9C|UPn0_;+u(0txRw85m()s{OKm|Y?!Dnf|g#1`BS7XvPUGZtv@9iqtYb&I#C#&dxq{6Dbd8 zuE@eEUom%(yD817Y_xW}hzW(;u{$HlIy0 z_i*YWnp0)`n@opt`D&5LSGI81Crh+MV7o-Asi}0*xC$A>HgXvYyeHWQ=DWHY8X@Da z2#~{Nh)78p2bqzAn11C1DEeTJG(d*|Qp1U=7<2QlNQ#DtTXD zQN-P_Fd&mK3}Dew$*6R8-3+pQIJom|M;t%)kLJj?YIMdSOtTyUlKhRnq)}w z0xQ|pMpaNyz{bI$pqpgVZiFC`ks?&~0j8M8xaK z7cSQN^Z8q@JBfesSyvV0ND{d^s>^Ya3(U_^TVTgS&n_*+=%g#7^ zffx3&;br4m&8*(Hr0EPHiDGV}XYf3jh@R=rb8s%%R&S^+VOfX*9DH$YG~3`zd3Lxw z(%FYKCp0-1;Mt0Onh+|c%E`k6=$8B$#Z zG&N|^MR?%x0N|F0StBAPj8kg@0N{UoFdq~n&oDkWcB*Zlv?I*P!QoWBFb?1@w@yU- zHLlvh?cu|Tt>6z>UpwnVFCZnDuGGt6!luD;uo8j9F!d}HQ0J9m;~lVT1`9T#VjHL#5Eut9 z^Jac5Bo(q)eji9iMWs!<^6>+FQAdo6F~dMb6ET2M0+#b({rh&Mz>Tnu3UxJwT~VOb zRx2hRUW~kWtC;v5%wVaOHjT*E@l`+SCDY6qVXKg_p2XF6hF}?&+5o^d??lfS8eEp1 zy=GM(Ft=!!)6m0g%#j=h&~Z`nA&+Hj}3w6!YPSVyCD)%_=}wP@1v7> z3@)G9(>Jh0I%TVCw)u!NNiY6N_umx1A!D!n`Oz@hDyf#_>$l(r7!8< zFAQxHwdbDjyAKYo55xpC6Scq4up_`Pjp$UI<_xIjd$!sjI}eAfg+;;xvCRCSUk$%f z+9BF*WLdLpYH#1i7k@A5YmF30V7CxsLRpB+dFS}Jx|D7yFbeZTZ=rD|lGL;_hL9D+ zhHDpuM!7rRJg+e`&U$Y$0|)K;76hbP@p)VVj;N_2bg!tI?PW?>sdAdwiaro&)z-a7ih58F5d66v=w) zYq8?M@UViffoSK=^SP7LrlsT0h%#X53>0r$TUN`O6pT}!2QSqiQbJXifa^Y$rH<(Q zcAER{-REOirS=Y&q}8R-6QW&AYV1haEYq5RNC}D{M8M*a$204$vffuZoCP+|N%m=+ ztCDVZ90uT~2|2GBfAjkmqFR@eNwKS=qw@*qUI%jD!@~nebf4(xpx}k=?K!EiS48Ds zqk#zM`8yKP8mZ(WF<`lpqxB=nhDLA2+@-Cvhr?1g^A=iKTC7))IIgd*uJAD;@m|P} z&CNmN0+E3bj~MXYn24B|kIze0&LrTYLogq`f?tb2jai$|_wFc_hK~indV;8nrD_Y= z8dq?qx(42%wbwjG+vN3bk5=tiig-O>F3dr>`{*9bObw^BwDgI#c0_KjrAh`rifI+8 zauHWNpDJxN*1LzyCLklldym#0TdW zlylOwTbDc=Z+864CBdh*HwSH9&*Q0uwnXgORMqAW2PD!pk&Ve z_!Ntt$*DzoX@AA5kIb>jv(uL%N!UN!IUEwzv2{s}F;f~}c|EwCCY){atwZrSO?A>3 z>F@7)mr7wAd~=#2R)DHisM2*>X`jlBt>kQm0Y%_1-|-@uNA?>`52^cX&l(bD7>5g9=kqVNj*g9mDsyvVe9aS@6fMRC!HH8=R@G)v%Y2I1Qm~tO zH6O`~K)+Sl1w-06AlTrXuFeIjSEcBjlXo^{E4MsGJ)w2FV;6G$^1Q1{M!(CaRwmF; z6?@Y(SOTuc=9!^x*%_5#6E$u(OAM%Vt1iQHlBUbIN~AfB+b}+;=<8Q1+UE~wwTgUw zll=>2OwKd#ew?4@)z=dPjtdZ#hqksw*subX^jim9wyG+<-r1pAjF!wdrDOI~h-Tp@)bm{<(&%E=Yy91M=$7TdVl$9u zp*j}w$i?L0fmBw@df%g<^yH@ZA#W0`M4;~mA(mThPUg-?5B2nIAWn@0sARx8(wY|q zsCS(%YV@fpDk`@3wxyMoF%6A)RUH5W#A#Y`0SLnGmxIEkLGuH`8`p&Pk=GJ;XlNf^ zv`a`dRvI^t)7+C%1EOlW-PVqTlnJ>0EXTNN0BCB zB_&;p%}~Dc%VvE6nCN5Tkh;e>Pz+1vjBT{0Cw5vhE%Hyl+~C}!3+uX3J2~cazld9V z%xw61ap2~Q!>R|Zx`yr2VU0dkMMW}EQ)6ykd!VK)0OvsZM~Q-h;wF}HNqNR$x%=Z* zQ{ls%&(3(kvTEv_uEHl&zfI0NpNSIc`l*?rf_sc8C%WS=&GrK*fOr%3OwCVR#jSYj zG9X2~kp!s7>IW<#a=8ujAM~+Nr+fpIU$gQr=x9KZzRu$B*^sn5IZtSfWmi%TWq!E% zGCy95wtyTWmc~njkyBrQa(a5&H0h^A{zS?*`@l^E4;^{sv{T&b+&pTsgDAU`K321*6s<279)}cd$O*!cIEtP_0(_bDmnU6!)n*F!w%rz3o}_EY_5-z9`x1nm&f1Riu$yB?Z~cDY@!l1zqo(Is&k zMb$gbSURgwn>jqj?&T-FH)g#1Sj9x!V|1V3c?Rf1^YV^aU5cnh_K>UkW)KiXLP2@T zehhL;Ih`$ab%X#nl)Z`c16;##OI#-B!0pqaB`z{zDP`uZBv5w2LB~Uf!=hQae$85} z68}5}>-5r$-Y}2tgd*bR-T5eQjr{~m1RC&_d%6sB4P4Z4{r3T) z(-kJdTu-$MNCot`oG{Ff0N3P}d45#`!5l^HjHxYgCKo{C8x~OCfR8ORnc=&3%AY* z3VM~2i-XiOEqD71OYVWz@QC$+oOKXwQqI5l;9M8-M%-L3BkZl=0X8-^+4f;pyapPm zaRIwy88>+l;?_}jo@8JAEa4*t0v&QLTa;0%k);3n3*q-~JQa=dSSYv2bI)J82JaNk zQ%ZIfnQ?!nox31xtF|X>gsn*j?$6ijn>J#dtG2%$x$jg!DNv;AqnQ$3iCUC3{!v}a z>ijhmh70zt&8XVU4Gu_kXvohT$cqx6n3=`JVq*iW`gtWb3&tch4qAXDtw##!m9%{h zkRhGkuAPN@n3*+u^m=vKK6T2DYd;<_77Moax_Iso)IHUCJ@wPeY4K-@Wnvo0n@X;| zun_f|)O#B5;R~{X2!`8YJ!YCp^UYX7H>4F2OiB>J0D(Y=xxTaltV2#ve{+|Q?JIdP z6KKYu1`R%95Eb|H1;Ie!& zyaBswX$j$(xQ)Rii<`^SpDDJHt11ezs3~$%@v3X)JeqE`mENDqdSmEF%DV7@e{hrR z1&J#{;*hLfL$t}!w&5XQ?IZ4e)I#a$?k zM5~4NRj>B!>@29PvhqOc^`Y}O!%wJ}WZT`)t7UyY=#I0^0+3A8QU_tB3AJaJcMRL5 z%LZN?6YF;bNk~5Nsmp0#tk4Dv8|5a}SC?$?NFPS2v-u;2N#YV}snd0Z&Th-nmR>D6 z`9q-sRHM??a)EXl-X9RqsO*}@!@8q!*VlSu2@!YIiU{XSdFukoE#E4?@-s{62g-I+ zOH((W#|xBc!Ao<~_g`cG7}L3pNfKb)(jDdzSP-E~5q|9zaPi%BUGqtIj(4X~8bBhtJtX(XNr*baX>`00)Xi|!8PO2(ATQh(1oxqNnHwF?@h z-IY2xznW3Wl3aRO7WWG9g;!_kQa*APF1L;X%0(AL4Y+8V9Zf$FX%?EE)DNKO=L+WK zWPUsOWoofgS?z@`FjKim(N;VxRe|z8oOOcAdn_44oH7w0v~^Qk87Hc)%mDx}Q+p@V z($enJ&1%r%7b8i_KVRD(%MMOulSt5AV-56V5hz(_UU(^>I(4fJ~=Qs-iF5 zEO$Y4F`7*U1sipaGnMsQWoA}$(j6cDZbrrL0{U{}0tX$gG%Vgnr*}5e1|kCy(r`^A z+z(9F6Q%Cjnfwv-Rr-<-dMj{O=@H5<7dFOUl$F-Xo6}l`=^F}q{7iYuGXquuN_uoT zcCgd5T;I0IcdE}7m6=In)x?N0X`sh>_;56o+=DCWqjiQFtFhWveuUW5ko7Hfb2$A6 zUX2>w&Bn*+umY1xp+X!)<7SVIZ)Lg_m%PA`DKXC}8V*?2dUD3JWcp+2w}eAk<( zI@{#Vh>C{#oU#vLQkf|BTDh(d^{ccWxM(Ma30#yl$4~GaG8}eeX(WJ(h9<*wZweqn z0|VpFX;6E1vm5A}mM@x^X|-4h@Z$Q$^7Oa6BU`4Gz%;ROOB4G%C6y9}@yRhDj-`Z(qT{o*e|%h`L;%e0C)PR2(;7JY3)2-`82N5Yd?FnjdW*ZM}Gr zf!n@CH@FeCu&?oDIMQMA{Ih`e?#`i zX8}-9jyAp)lQdYk8BrW~Z^#*H%>y&M^pk5jBjcDXN$z|%(dmoq6LOLR@>-!mdB3n9 zHS_IZ!whEDNHn11W>Z4sU65OwX~V1>z2wKti(dh?Z(XPAt)CfFf{uzwNQj%rVthtM z`)t(ZrvcPU^xZ@xSFWZ?kF%Es1ryMUV=RRk$QutL@=-0-}xy`0JQcMXfmdUqBNAKN1n$krf4TwW5T5I(}lkBxm6zu{3r zA`}mJ;%5D`k`vwF2Q-RiW?A!3vMDft4P{Ra+rce_k+@o6r>(^wZN#{;K-#*ZvjRk} z)sa&x2I)YJXDi#^8AUw4vJu4eG=;ScZiMwQMymi;&m%1z92~60M$`fsO1)pCidl2t z8Xzw8`=Y@sQO$|aFO3xaI9S-5cVCViodSOFA*EcXgZMFay}$U9zV|vwRtR`;y6V7& zw1NdjJ5(c07u6A??>4%DL8g)(&>M7Q#G{LVbrQHAWD|8|-uSy; z|NQQb0{Fqb#)Z5j#>V7Zp2xsmsV_1*-a|erjL7Nfsj0b%c?D^qQAO#I1HYYhZ|?W| zxBzY7Z9BW~v{d`>RyM*N;dEm#dA;iJ>bRI2{q@VJHJdHP2Bc%T=w%*WA~`N@sI>bC zVOVGn-CB(Z;1g`mP>YpcAu}ksiBZKf-E(PFM7t_4=gPRsmKn4kr$N)Q6xnZ(EVY;cV_9OKqwOh8tc;r&6cis~N zU$rku7eFMcUGZqf(oi2F9BL`LipeE&advKZUTT3YXze+10tG>{0wLODGn@5nrzSI5@0)TX%fbf1HnbLfWqzaPGg%SKgah z0!Q{H?{3rpN14rb)VGbLC}c}}*R4Z4LCDi5{V=V0^daZAkM2zIbPVzgrK3qHGVTN@ z5@@j01J4$K6>Si=PDXEx7QMs&c;h038_1@S{L_kXf3`cOB&~T8*u;224I;NqD!>rMT`hD<>Fh7gh@BoL9i?P)bI+X6>o2IXF z7TaC(szMT-)Q5*mc&rR-kLX?^TQa!-9i%@j2W&A! z;89N^80)Ak%@Y3>(kEg{%KBb^J|0-W z#K6#a@+5S8oWE)5;CYl7$av4`!@*MP*wU0lWlm-~-^Ua&kf5+|us>k)cj?xOMl1j@ z$V=3m?wCpVtRn>{ajCa}@2(w##vw~Qpmo_?EIkEXpyRjS~Z+v$8@|2e&X z(6uP38I$MhJ;|Raw6!amajGVJ?o29OYK^S%(#DUsvvFiq6r01t@i7O0FOCucy8dw* z$#p z2}1l1{97r2_KK|J!>rp?NOEVQ0(HlVjO66H85oYYvX_(!SCJnYh@e|rJVp!738$m_(8e%Acfq^R-IdY*bSdUSg00xiS zg=e|@ptCE`cIn51qaiU+`Bes9po+=hpf}4`(gc-~(hqOgwI*kxZ5SrS^Ok1cJBtGq zA%2(a;g+$XeA_sDKrMoTf)6~tRW#0PsA~z0PE0=fa9t;L_v*o`3`uDLyj{sGTuLFQ z&c?0a{%d)D`F``tAT^}T9&7)~_!rq4=9eK5VmT~)0yMhTFK9|cE=?;TNCZrIl%^My z%02jTeXve}ra7G%zsm#fx)eVvtJjE>*c>>~a_5_ZqE*@cZWGb3}@2 zrITGZ>H8L{IBLQ}vw_e#y3P!Y$picsLmr7*!n84B>=4*DIdC2pGhp{Z| zJWR}!M}s|ysW|UN!;9;uMvxfIE({ILrKf&m+3VnYkKWGS1@%ejy16v-wxm{PwK>78 z^XQi%9BERmA}i#l*4Sq4I#~hV$?KmBTJ9Qt`C+x&CQjpt9g#-+L$AVxp>r+JZ3O?U>q1VBprz=Y_JjU&8|-7L_>qI+C6yfqgEHD>rTE;@}V_ zho?Zb8%7rrVpM^Rh%VqKMH5$+cZr=5hySeP+sUp31+WL$;suc<<4MM>vl;pbu=kab zA)R?vfoz;l)0YX1ig>ZT{3N>|LEcfFkCVKnZFYT=T0rrS;DzAl9V+OJx}ZR|WK{#n za^O)~@t{W8wRhm5#reUKot+(s{+K_T^6+Zw4S0r|3&}Z$>}F7pOE*0H%*}RiLmVw) z`@}(G{0!D?+%$Zjn1M<3p7K8BGBf9v|g0V0mduBMcIg_E+;r8?OdYTOxy6uQu)$tB((=Sl}ykSO4Apf6;W- zK~cVM7hk%&r9(hz=}rM@M7lvbrE}>J1w=ZQ{L(Gm4NAw--LMEtcf60knRkZqUuSop zz3=Nf=X1_J-p_Xlu#+c#(0J)3>kNjE`Y-&qQ#)UGoO$;AV7N0M^b79`h*F{h!JA|) zEhQ6TN{_498I0}ORmbW3^-p2Ya>nOqLkHK{X>l4nd&rD7){|oe!I|FoFnl;eq}R9z zn~}0QKoTJUObde9Xx=!j@=vCI3!Z*U47mc$@ILcI0Yz#p!HG;073$W&WXgC4Spzk@ z4;XtBIq|=KoqrDz0a1zgBm3W+jM_(S2$5 z%=S+X+P$ug^ix&Ep#k5TuP|2BRcz}WE?$o%L=f+FuAh((M;KX!b_uXUB7GB(OSyL%)l`l zBQ7Z)`Zx^C6##g3zTP99827W2vCm%seLlO@>)lu2xaPbT6>^EXPh|SXgy=Q95)2Oy zCtXnamzd%putz8NUNL-Vf z1+>+_-6oa(fDh^!=1)e14NI2hcAgYv)|}P7gzm~X{j4Jo6rVYJCD3^$gi9;I(8u}J z&)@&c>dzKdx1B?yoq+F#8`E+!m!yqf{Y|D3Oz?sXsvOfVG&Wb7l^7!2f&%dG^bu~u z9r>^u$<3H3U%y#_BZ~6JhKXO1N}0y5t(l-t<|0Z(w6Z@5JlT{$NI0ZN6mnZWzJa22 ze*bS5i;oC|04$6DJT^LfDQRhhUmYgRMx4?4=$gdI@{!UhdUQ)%u}ovO?CRVf=s~FW z4_}@ieT`Z@C|X)tevi$rr8x=-?)lUQf)I;0f|2u|^A{V5kt>%j{iY{$hOch9t?oZz zN1{y?vddfQ&|WW#zvuQ<`{Oy#Czl7b|XqR5rm6}TV{t^&J*!q42t9{RQ;AmS-Gpy09~}4 zv3yO45iUc2d3|k>8}#GiGt;*&2MDdqB>+Hh%~NczzynxfIykMYtn}(_2>>&9aOERf zuzM<}+5Wh(A`>BnL+Q+VO!|Ua^v_-oTx8EKHr=X#9&p|_K&g$%UVl2L_GWLtYbXzN z$UxZpL;rY(7S)Q!(2 zzl%&bzN`jkyrN`bi4?onJg&H^>W5O?w97Fa#YIItKq9!rDIm&v^BCOTT}RVG-ZjY& z9i^oooa-<^p7&j>F$YJ7by zL51<>Zgmgk-m(XRj!ffVvBKD6PF%l+R#D@OA!ajDFSHPG26{YYG zHS7{#Yl0`jj}N8Q)$v*n%Po9!i7wJwd0b#`oJ1BfjZ)Kjt<7f3v`_uojh16Mp$~=9 ze^;CE00(Cq5jMwNyv(NzIbn&h5F*B`tSm2IPW&a!+{`RKX)1iW7wYLgPt|OnCitxM zHNAL}Rd#j%ViPMT2;a2)P6pN*8#qw~jkBi*4Sj>BGP_&X7y0ayk2w6?=Y^LA zTCcY*id?${`T0xn+{`RwAkK+Q7~krqA zJ~bOBJD#slJPYvD1vHOP|?2O+m)W-12SuSWI#RGU=4Oh*}`MzAWlR zwPtA##QL<>aZEJmz~>!4#IKMd)IIa@Pe~CW^hLPAgJ&~tU9xygygntB)&`M}Zln#R z=?}K;*hw?ulP&8Z-OoiyxYB@V9@<0q4}=BKhgkX9-H$jQz2?1B@5Xtj;wq2yGItY? zSYjAB8ydF&>k-h!SUEZ8U?YF!m(k|Ua;dbryU1T_TLJv7HfjD;Qv==iO(|iih_1z! zG=pOm2pv40ZcG82mnyC@q*@oiZ$(5! zzucW$UA-ba0ZM=vRf?7Ot!YCaAb#oqHfWlM z7>FBtiM-tVx_(4-+}!i>U0B={8bi&;UzKc2Qey4Xc|BD~wRDeNIH}p`x>GaPk_04- z!L%X?w4pJ~t%c)Ga%x@zG2gyv>gb>X4!I&9fZVBJbq&993J}r7rw6D5A@HM6{uHZ{ zvhwDzTWo7#_UmTuHf!eIujnEoBJV~%vfRIM`eUvJ#|oqY!Yb>tvklGp`CEc-C@m4~ zKO#Q;&$AFNcaELC28NGt`}B*6`r7dOKD;0lNrPMO(y}1c*)R#Q#q)P20T)(4u%l>H zeIjuaZ9X?ZnH3MWDoK$k#%cy=0#?~xgZAzz)RkY1rcc2&=q9`n4_Lh+qSPyV{DV(w zc~x~aeO?zrBhcp0Mw70icGfD*XDOJ1YXhNr$_t($_a>7mK)V!-Z+|JEtTw&!EkCyFY2Uw}zMJE17tE9m_$Wj6E`7xGYAsNneFla$34UFc zcM>p;-rb6XAWMU`BU3-Q+FwlaOTpM(LflIkJyljWz+}ky76Ex!J{s=S7_uUkhjqL7 z3|)AT1{xMos9h)E#wF<{6)=&9GyT!wdpd-{-@EIL=!oNaVofBT`_s|=ki)PU&yoi4 z<+8H!jW7NlSFdnN&@N&$BnlD9xJ<(PJ2%;p0D>pI_4H#gugU)yUguq}h zh#mhR^3;DZd6G>R-gs+GFrs)vCv^bZ`N?rRe$!b{Id%eCplz!S=gY;l?NY&d{jGFf z1rpQcdr5qOezQ<+RJq- zdw!Kgu;M>P_P9QZ{6+S&J*seh?IPpV$>xhL7ws23Q+9S`bI$<;6jA`?cttuDa%UJVDJ=_CtW^kvxl>+&CVbCi0LX;1@gkU*VA`J|Z%ofB@JH zaCH+0Kj!dBNooZ7jQu@NH>@ZsE=0Si#2iJtq#VSD@oN=t-bI0hi^A4TRNCX4*8H$| ztc=|(5ZS;rDPK+#&ge^=_fd!Mo)A`QtZ|&nZ%f7_s_NP)(k>iozP;Uw{r2a#6+R?$ zwG7F^-nZ^l)m@3w#p&W$0gg4}#p|SA^6;@lP(UCwP#Hji97>SRV?2P5POdM)?=IGd z`KHv1BhLta34rfab!&!1*r;EQIGXbR`|mR}k0yn|=VG;qmlOuf>)(IaaDWkhvPL}I z-_LRC|N8uKR5OQNYChmgDA`#HX<)j<&KXl^z9rR7QTW2$c~ zG(y5r?4A;8+MMgJk*=TdS9WxIYlkMZ^%xm2^!4hjaZXrG9fZxs95Y^dw#>9!*LqwB z?h!IE{ot-7GS$V@z%NYNXGC|++V9aKD%QpPJ*Sx-=f#TfjA9-Vx0n+%ShaNv< zDZ2{b)w#hPod{%{Mp9y=yemYgcr)DcT{906CrxexN)-kT_Ru_Bkl{^WaAaiU_pnwk zV?KTTzwHHJz=iv>f5DL^;ItG@dnfTG7+kiia^#s@H!{{(h;(6Hzo{-D5gr+d3Sw^@ z!u_Y2v(U6{qLq%c%KJ$Nkipw8;?5hnqt-a=EVR$@c$9^B9yIk(iGQq{_%VW>FkK%< zv~LRy?OMAXi&I*iCo|o|j1@wnQOie1%gq#(-IX#?9XPm_)qu%Op6?aFB(W?lErDbv zmzRq>>zN7S*|^w3Fg+VSF41zt+L`)^U2!tL5;Ec>L#GF@V)R=iP;h7{;?Dkl-?mpl zvyf2fKeVpj2l3zg@Dza+{ieE|+U`cwAMca4&gS*9ivk$@Tp}AdpCB&ezNa!MWsDzQ zzY1Rx=y>P=5@i8Bp(q!TQ2cETBANsL3EBY5#qR@6=}yXIdpXOu_%M<*t=QL4T3|N} zD8HZ3O8tTZe8ytnlcs;1JsREE{eM4FXwAexW0o-M+$77La#!6$k+2Ay-%>?2YNt9P zQ>cAYd}|!lDaBNY-hD?MnAUToNNSy03^(L_wua5?T*j^8z}5scEl~&xl0-#C{bZ)0 z3=t>wH?27?;zLixGl1A-ko-lcIijkWSKfe0RhJKKOM7|Y1_%q6l$FT*M8W1brL3y4<-ioVQfD6UBAl1}EiI_8t}o$vDu?jdJF|pGt}H;K*x@ z9dqYKTb0n7Gj~m!yE4xi2piOWyOO(gJpzkt5(*6;{1%Ij7pXnp+`Yp5Q_&;-^_-IB z%)<2yaHcMnc}t~E*v?+0FyzicB1D!`0;0mMx+fJXYI*5jJca83_)EjsIF^FfI=7pwV0gIpaM|H<-< z-9sQ)XBO4tL7QYRORa#_T7nMO{TZzS&CsrLDijSL&ofw^=#pDw(~MfHx~yz4vLUBi z}eF z_lHgVgPb{sM@D!Y=GdW7=yyXvW(}U3)1eacK}SMDg58xDXBRy{8U@$K!|_+Z%g1Sw zL7kmMd`cQ!z}5Ev@5qLsV#_Z3D9V9C-3+`QdzBKJL)G_w zLyv51Z2Zq0eMLz*MLTU0kdOGY&RLr88xUZF6pmK|d`6hEr9u}k8nkfAE&FLIu^Da{ zG`x$1O${mvlZh{0ixnblplLL<#MC8SO-m+PAwT8N~}b0|H3 zuh0)5Rn9%V7!~B zg0-}CT&4^OX?0fh#(l;o=02==vqX@fVY(h%pb(!AK$3)l2Bt1nY+;KF0t5$r27egW zWzHo+AKPsz4Lj4ny2YpACCyAT$+)g&3A1|blsDzmToXdIx028}MYBUBR2pa^TF`~G?bC#<_64$-X{@JYd5!j9ZDGeLg8DKE`(M(BN-Xe9~3NPQUCiZ`b zWRh}H&v=nB=nN$MI{ym)wi>>}zTv(w=8(;GDuEgU*#$ZR#HgRujb5BZs+o}jT0Z*! z&jN&@;pGEDiIV~YI{qam;gxB~gIv6-)DN=XeNIiQMP7dBxmvb`gT9*u($QFNT2)H}vDq2O~mLeLK2{ON-rFn!7 zOTMc>PURfU{2(gvysBpN*nJ z$9s|JOUf$xpByB<+J%ZGYM{I&z#jPp3&uK-Z~R78kKok$O7tF*Vsn6uFRdHt1=ctU zIN$j|B@sYw41p+Ny@@v+j8&@SSo0jmTTNj4U{gxe+y0F*cu{mcidVyVD*yd$(?e%e zwb&g;masdj2D{pQ{2EU64J-KwbOrtgHaPcfHRt+mv>bGtFd+$^U*hpS*MX(Qn7lfy zFXY$sM|OjHboc#nYO<78I-$wAxyXMucUPCG!y40x_kEOSm*i_T7v9z%?q!JiT!mQa6WW z2iX?xl~|<8JKwg6uL%+j~U@HSBlMmGb#o}z=`}L-{mhxv*LGDdFwN7|3u}A zI*2?6=VdVxp`}!pl4v}H@)cpviC63M8$i^vghFJ|@bZe=481vDA@{T>^OKeJcvgv7 zdyt}sScBL!bVqo6#T|czxQQ$X?M#^7o$Ja89Nu|GVP>d)2+}LAIdB5!tta4&^hHsXp8^ot3AJ)HbC_u8d6tj zJF04{!Y(Cv_lXGgpxAJ{VYD<$zo!TXWiRL~%B75P>1(&xmk>>0XG{$Xx;u%Nr{1gn zLG5ER?;riXfLW*U9Q1Kd{X(M{kBJ5rd_8GU?}~Af>B(}AoHPE>+8oz4xCzv}7~m#y zv+@>IJ-1~=yFACXYOkt_({a5K2VlY+h*H25f-J zFm;Hjh%;y&-sgvPdyStd>NdAJ1*DpJ*=6M7Ht+)bt84^4c@vdZsUEuzCalZ#t31 zR5}L2WhIMOr|b5LcFyOSNJIdCylXL+d(e~mCkiU8KW&!8TfbPrzX^F9{1`v~Oe^rS zADfgnL?luPg`vleSkt81@b{XC9~1!%``pF~H3YatV@TL)Y^NA*-Q0Ev z-(dsh-3IXR0k5-Wh1_T;)eC)9U;lPxUjnUKFtaof$Futt%()3otvKOB^jMc?-;Rw*g6c{Q}Xc5SB=G!^}NDletXWdF{)kGzde zt5pW&>>i63pWcs7U#5^u;lQR0;Xq0icrndxg*ZT%;as%Fj_2oEAt$T+uZ>=G^VO*FD!TXAAsVFW(ZRPDR%wNH!Cc36)z@>bW2Zb22A--64Ly+|rT?%9cc@&ub z3H#12%0F&!c^)meB<0SwbUi|2E~ZM!tQ(B+h@6jg($jJ^%QifO!@wFqSUy14gXLECCTPZO_<_X{F-_NRpuX_I zeaRbNMGOJ}{1ozj7Bk>%Nb}ZN$e~%b&e}%?(Gf24(<)05zb4+V|}n$hvvB7w^4q51E|>8*ub!k4fr?n$S}@StUZa9? zeF>b^^P-l+NpH5j!1vABjb6X*F5`~M_pq_{K&KlMo%yl0skHAizQq?2O8a{8;C(67 zRd7PT7VcNKySNKTW({)2dsV^bG=F19rM0N{c`*AaORW@>qK{=4`@zN^ps(58aWIN^}J6H z6HYp`#)i&n9{rdkIvS`lZu^%9w`vfO?hHWw5q%EHMndAAn^h+E!youq?3;{NFAZ({ z%mGHc8(;<^$WGk#EjE*DYgI?lFe+rZ!yUpN*B3>(X>TFu z)71?$;@;1e^~ z+o^b9f26eJFI3GQFA4FP%8y7B@qD}HyH9<2bCp+8f(~%DAD0a?BU#`qK*l8+83T83 z%(vBDvon4-sWB`HcdL61N$AU?P-~T~JQCAgs~W^4%ol5aJ7w9q$76sJ!Duz9QH~+R zmJhL7kWxd$*?*2#HX~Es= zu}o7-cIUE$TBy65JGaY;7_o_N3^KuPh{Z6LNVH<{$!|vA*H)QyghskNlvdhS%{(>O zyqf&~xhpA%x*~Tizr3}mZML_oLt6Avrk-rmSzHiaH4S!5{N5myO@{JJag0Mk>{ z+1W24zJtch7iH9vb_U?ozsrzGt?{0q$rAS`eLQfIsvVuh;yCEQ;ltZ5%-vUCg~PmS zAT(CERnD|#a~1kP;f9R2w;Zb9#??vmufGdqAK6MRW$)Bfd`aez|G?8V|XS=hlfpyh~9bUz4!UGp-zo2K> zQ3~y)Z=jml0r!jc(YM>P_@IgaMn+t~Qk~(k8Mwl)%j*{9A3gNW(EW-2_FS3A@*bO= z!!$U41BPZU5#?R;&<7DQD-IQjAaHbb$fM%>ia z^HkMt^gc9v?|H-rV4WtX*2aV7UVfw|rSW>U*H9C^ZImtWzJlecz2@G1OL28#zT2Zh zThESrWp%`1-$5xSS%a(ev?zjfF4bZv=|yScclR1!rp9m9zQW*+;O|NY7J!yC-^|f zD-B8aJ#5VL3r$TOo_vjUe;7!h>;9FA?=A_Icz{Y|)4iB7-d@GYQ{ux}i{w)xK?tx^ zhs_*Lud*T5UkebeGBfup8X7L=lZ@zQsTpiyLz_KXOm+Dkj$F+<Q=Yq@bK4B6B#oE!?^Dszx@9```Y$xt zknPJC_kW~I?tL2nCKZPlWIk8?Bg$xIYWLAhh+kD0w+k_A_R(E9misW&+21kd^g}p5YAy0`UI8A8-!Hi2)@oK!e4ORjdT5&((OhK2(q3s?US|1RJ6^ZUHIOq_vZh28&ZT;R^VY_VZX=5BIvlC?8n@w4-;j0ooQD5E zd{LfrH<@(iTClyDUJOzX| zw=VKL=ZV=DL0)39_xFBRqLvEw`w4_FKgE{S^R^85L<Tg<-8$A3ITz-H$50cSqyd6>lA*?4gSRRTopm)#=;>NMfvNg zH4+K_9)r#O&5K^nGzEsVdE!wNo29Qt@waOsdia-8z%?)4Zyql*8L5uiS_0rhK?MPj z)Z^Y^@!6qzAm&VwnldF!7ggjG*gLka=1qqjs$EbCFMW%8GQWdHOB>s-Xh25%(D$1C z8yj>$o(_Z%YH^l103EBirZOE*0+s-YR-d!2sF|t&R9mB#6+9E6U)E=rD9a(6J&*A9 zXO{LxU*20Z%mtS|k1jN2<=V?Q5=Hc_=su&>oP!_$A6EqS?Tl|_6k4aXG1?^q9*yU> zcKf^~)z!K|W`AEoPueWBznpjnQ}1%RTKZB zmLr`Ep5{PBApi|$eH6SX)XjTT?nAwlIoD|hl{l#wF9Y=yz_JuAUl1*C`R`vg9X~M| zT@KF=#Pl%??Iv767<DqD&AmT!;h;I4Fe#z&cwgAxCCpXu|RDIzHQ z;n*E$ooaqroA^Cq{Z_%}a5ohw(QsXle4q#UJdMpGfTHkd1w2TJV-C`boO$EKC$Far z_gdLoxvYn_EB*G2gsTyn1A*$i>l$pKufccovs;bJ&Z(j{+Y3)?Yin`)z*RG)NZfv6 z)I|eaP>mj4v=Z*vwBTmS374ht?V&h?e6h*I=y}q;iq5B}7sd&-W~H09`6F!+yZd!x zAP^EAe3E@ag0;s*E?8|qtt;j7*Y+^$qme$4Ig^~a|M^OA|2Q@w_`cG69igaxYgyU@L9j{p!=9*uAVNm938$ke0SsUl52nDoPvN^W)^D9$g=0ThDZ ztK4*?pSdOh@OC4aK8I;%V7o+3uK~6M@b{CocXt>-Lg&V6QE~^LDgkCx0t1i{@vO(v zzS^?K*yQ+=26l9$@jD2dpP#$#{3htn*9_R}oS*~9h1;)0wl1l~Rn%fW_z8;rX0tU& zy9-2#)gh0rSIy$Vaz7NAfDL0eBu9-i?!)(7D^bg(vmG%&k8U=0#@CeLdzCCpC-*Vv zS9l$CR$y~!z$d4q7z9Xq$~qf>MMRsb0mr-AE-lXfDb9QOD14?7s5t#R2$OLG86aWl2fd+jL>J}YC@Xzc)l zGphwBQ=_&4>ly0mH>Cg&2@%o03d}ARxO%VT1mOp8eA?C3)!)|G|NZ>)GuK%&1~`7v z0<2^i`0Wqu5SM9JcHO@DyO~)XYySn%Mxa{5bF5t|M}!It&cTEGK6aFpS0aJ3B-~#G z26iYiYv}>W1fT_r;PfFut@!M6B3qu1Fk<<5aC8(KklN7uxZOBF!xw)f+<~Vfzp)Ir z$ea$MM4znm^$e}Z95K9m*OLt{>udgLPG$dTuD(*98()qgL5d*(|1RmzXR{3Eq_HQr zHUV4bPFrI;n0qZ4$7hA6{h<=xKUk$&O<7_yZ5MFUwmxvXAjG$CyH_VqI@>S{7%6>u zeNo)JyxXAL<1k_G_@Gm9pBFR<*O3dTad>WfyU`9c-AJUC#;zKP2+JVz^AMoEnvxaW z%%e=In~1ybr(9Q&ks-Q+eCA&s(Z{pJM_{E}U3wZp+XXj$Z@nwY(?ll>p@=I|R-XKb z+Vr2GI=#nUWI$Zyw0U)*&6|tnrVFF{5u_W$J5bW?tEwz`fsWt?TG`$4d|bZiikB0s zGSotWdXykdk5=86aFfM~3)X!T3Yi7UA6y(1-lfaEP3NS5CD?wt9QY}AqubNdGrcew zY{nh^`5nNfrjx-^?DE?4jo81u>46>0ptz0hBz?RMlxTlChD#ll>1?u0?zoxT+hYP_ zd4&1rU|H)`%Dq;n>RD9aeuyb^?xIFneT@^)_6)Q%f1E#Vy)-Hi6BK0NWGOw%^vj@gKeDse()U?gbnm8JAS-BEwG~)=~ zG9T}{z)dL_ANXA2Mcp-o&+NLffdD|7nB?cypN`mAU@ne7zfDLsjyWWB7(Wx+QBUO!6MMsg%O^Kik6Lf9p%BlRj>sI^Aw#gqH1d5GyjNk&* zs1W@_S{M?{WHK3YJ-j^`$(Bg+&P$*x4@KEp2Z>lf-UwUBG@*m;fm zM-3Ggp35@ZxNK?Ehx$0QD+buySW6 zAP|qT@6=(wg|j4DTo&`jO(gs-BzZ; zvnOAC4v@jubvZrnHYe?S{*LDDZc!=ANJx2sK8E)>$_>d3;P>px_ zc`y8eo*X+5Xjg-7hZypkYQ-EL+Nr3kV;!eCwA!!DLq8RCRN~b7nvENyQlu53G`kg( zitrzupR)pxI}b0f`;5<+ic)6p;8ERgvV4c_jCAVz4q+%zg9P5=&ua0(jhDP97w~lY ztXqj+B6%@l`VTGS#zyKRDoD%9=x>;!{QY?vajBXm&D|T;pasz4){OHm1hB842~Dc! zY3ehuuI}!keO8-uMAeYn%t~>#<;%|ekmtXD_66ZaO~)NrEpy=!T~EWhKUA1E`!6kI zI@rm<#yu;(A8W>(*t4_4gcw2xgu%j5(bgs} zLUcDz+pWr3661q9h<>e7W+g2I>Ed?(FC7;_Vxt!K0-R2)Q zZZ=K541i1+x1gY|$77M545SWH9x^PS^P>9@_jRkfXd<6@(Gj(vpupDI85LyI<`rwV zBlkJM`b>ke+qT~5Qj7HHXF74cw_<5CSx^;FQUn}Rq$KM`GJ6FXT)%qu_SvDc{AN$E zD6>I9?R_^D zahxThrAXM!L|5btn%V}&#Qfx91H$SA$3leaMX#6wZ&QymzSi=)WKc8kL?1o8 z#FUo45jDIT_^?p^4q-*X8Z z?p|pAnm(>DsPLCVuTpG&snjiasb1xA!$z{7Ey}cKNaCC)>3y#<>J{*RV5M?x9elO) z+1)8mQys1Sf*v`*=hlaCMuL0+Ag|(hCqpCZUC|4UXQ6D~?ao}JfNUlNEQVsvoekws zsCLQzkviA6Bu`r4Nl$F^I=R2dN@VM)k9&NbZm^?L5UuFso^)4C%<~skiuz% z5$;6~*_oy$bNbfCQ-AXS%lx$tB-EGN=Vo4|RD$c4R;`fRGUH@Y4PgJ$$X#yO5^@3NhI;7d)IV_6LI zkGR}pHu&2<=ZA1}A0NFP9v4Mz-eP;O4Lv#3H*mXPan`dFV*SxGybV3$61x<@ z)iXBZ8`WJ;B<(M?HweBJ@W50~bDz(8%GFEE<#5RSz8pi`1=+-iqw7v$opRVvlKMhD zJC?fmlZz1e99iNv1dqXp)Bqofrhxio2g;Mx4O6ifS=pbjEGk)|M?88qyuha*UQMBIBqOiZ3F+qF%z0X(WjjIpQ z(Cj^lSE3X;yG34OL+6gf#k~g3aIZQ3LYr#{-Np^$M^b4mSw;~95e&5YsOgC^4{Jzb%g+< z=g`9@w+^3jewqbIESW}eS?RoJd#>Q58gE-L)t8>*vu-OvDx~fCv$!i4gxACr@ffg= z^;+~#i*^l^R7!8Gt!?BOdqdwW)#`XL$uToCYfPEMRwf%O-eTg#6(m^%SRgJ|B+PUv z-}#-ujFH)Q+%qG4baY2Pn}5b8FX}0BYca~$fw{H(_+y`sKt+Dg2som)Z-Ph6hnG9pu3%IjdWRX zv%JgcZA8oZC! z6%CiXk$t?JHQm~Zl~5U1?b)Fd&|w~BoI>|{TA~p<^>^uWdE6cPvaYZe+UVqLdxBPu) z@&wsE(!z@xX$4+hJU_pH3Hx1M%4B78gca&wwK`Dq{?;!eqqKxB{#lZicu83M`KSxj zTrxc=nw@hXaWRO5Sv?W8iuX4Rq0Tl1*Noq%%Qd7}xL)(+#ii6c1J%*O+L#&V|F zqXF;hr=Qx>%h>K$CiVfKhdBS~gTITx+5SzI`_HQf7+zbVEMP!` z`L3=KedNxk6vh2tb`v(%p`6l;Ue;0+(DpF_pY@I;%J2o(=%=_#ljb^TkxAT5tq)Pf zT3S1!*75SDWoF8kyR7JU1WklQ`KG=sRiM+qXTX&{!MA;tVt~;^a@I3R|096Io>8t}d zk88>Z+GrM{=0xYr9+27~6xx$d+b%&AT+cgZQ=2UhTc*zxOUuiP_vrl`!EaN%UdypF z)%_T-0d7nnzNViQccyu*+z{{f0Nt+bm)dXjbb2ibC2S=@xeO~dd7No$y$LK@IDI?% za(^JXmDBkg?gehi?Yx=4?!%t?DPQ*>4qmBq>cVw@pnc(Zg@$q+jz2m&x&bR>1A2hE zRUAoE>?(!QMl8KJRezyFqc$pW@{0=oB~S(8NH67e`A!}+igT^y>lC`mUy-{!mKM~G zp?NlaY=MmQBT50CS8GpI-g&FDpYUOQeSOUyhd=eCRS{)pX_A->MSPqhsELV>Lt)Cd8lD&O%TK5F#<||I1$V~pl^U~yR-$Flm=5&3p*~#}I zCgxFAX?;uK;U%^O%+GP}HM2DK$K5JO2e&*v@ki;DrvGh0Rs3uzwSiAa9B}3^U!fn? z;4qi}Dga9a-ED! zseTeSWLo%2-T#`Z2Q&K9`^{?fUg|4`BYtyoX7)bfQ{z9}@J>rCuXZO|ffKm=SXrwW z*WbOkuC{(hD%$l+1l5B#gPvZMLpBmGrgGvaDX0LufCWG+7O8SJ!Wv`ONarHC$NAQPs@Xm_hkbOFbuXq-#|`oyt~rCEf_8xv{M7b}f} zWY5>#R7t&7gw4#s&|AJO7M3rJlTjOG=nPKUwtBN>@bAcl37@$><=BiTfn?p1w#gbLMuT6I7p)dg1`w!Fbh zP5`Ousb=Jf?NgiAc9vS<@w)*R1!-!HR363D4>p@vw|qg1`xO!mkk`oP9m~%t1*WFd zI|qD;bvz(9{B&Fsg;&wpsJ7--S?phYr>kT3+w&T?iRb$|z9-ks1eKf$ zxgyBA&~M+DgY7baOS+NSbXIg}vC>fY^tz70u>;|ry^n@SlD$)m3VdC=p?(Vfq7pB^i(OGurPY%CRZjhS&8fbOLO=Q*!O_;RaIBl#QhYCNW+%S`F#J2qqC+q89 z6vl47-!LVS_wXdKH-u@D;v(f{=%l!0i$tT0d^E$;K58&!DV&B5Ld&wOEP!O_yvh6t zQUaKUMVT-;R?>4&A2f*kTM*CaN5oI6ZebLhhsc^w!zorWUw-#lGv=2q#qe83bpH2d?~N2^utzH*DiV@wO!By09PN7N9=y!<4R7*1 zE!#%lDIB(H&%fBiL#vKfnoZg#3L{0DT5B8D^o4&0!n{;<=~UflQN zAWeZNEhK={Z(XQUBUj$(=G#sb{ZKSrwQ;ONa{Bv6;Nn z7pN*n5G?eWJkpS2_G}L~XAb#(=@*rzN1{~EW5o~QJRhHmlHvw}xmIZKZaJOgQ(}F*WmZQsTv1jmWQlM}Vk9as$Z=JTcT#nP7lCfZ zS{dF(Rw+l01)iApNiokWy+H5#hb`Yd{0yr37%c6O*j3|iwPks)toR9#UyYcBv;MLs zwd)JD`i$JJ`*u{&Y5h9{?_?mdBU5w6=v$!|a`zpIn!baR6G^ZMZpp;xX!ribSN{W< z&Tx^Y^WW!+1YhN|ktaKH(TwH1mqVVX7iHmVb#}TBW4*%WxFB`07pKNH4cw}9L#2|J z!Kff27teJZP>CGzY!Bx5LFSl9VSbM9qu*ty#naV!bJW?$GNx7QeL#R+@qRVXv-zU4 z?f+;x>!7%rD2ope+&wrUxVt+c5IneRaCf)h5FmWGOK=VD9wf-%?m95IJM7DDZPmb^ zRMFG#b>Dk`=Nxt+u9(;L3V#1%>T1KI=8`{a0co}uYADUp;&f<*0X$Li-NcBn?}Bge zBde?W$~7vuPc&>g71V%5+A}3)XdDf5P1nwMp4LZKf-fyE>%~@@J5W93Hm$GC5`DAd zWg1bT$CIQyAoO?pk0Y8WyZ;l1mVBWkVj{XPta+ngUl{SNxD%6J%b87IZI$9tTj!b3%6K1snzT46XonF&Ik2M=2B$3a`VuAZ%?NVHdB-J zV3%dbmo>l>K}Bt=^FL#9w6Nbtr)!H|Mws(w%aJPI zux}aYd%vn&XEPf(-$cNcR#(q6OUt9**zv{yWUv)?d7)8+PrkY7$Asa1v!QsAI{%g1 zf~1)umu9kqBfa^To$tu%uzbVb@8(lKwp9}=Rw)AUMa)WaMDOrQ+eKL0sp_ECsznp} z!EGpX+hH$f{v+kmaezyQYQq?p>sL-;`BI@C*?j#%^JNcSdv+V#^#EJKPund zp@ez+$_UNduLK!jo=J^9@-qJsxGGW~y7Jq8d~acCDc=>K2q9Ln>8*1UXXBZ*w6MU! zh!_9~+%hwZ?d#DJfC{D#HbD1pY?HZSFBM`--QH&%PoMWg1VGPoZ_jnYze%$8f_!vz z-UmJ>DDM}RG&K=4bbA45FI=u%^gH5~Rk%ojq))HY*BCUUc=bXFv1Txd9kis8ElA&k zL2bUgzkF@^)^A^%clwsDTKpbylt{&ZSr72Ca}5{^41pyd4LdH=Q2;dH?1xfLz=f#Y zc4~RKTw-mC2ZrqR?Vqlq6MZ zT!zp-i7Lwdw5jB#PdvzQp*N^P&kU69gtIG92II2inr zt-8@)tncx{1wY_GAJ$_@>FH`9$Rmeb%`EgjDZf82?c5X;)#JO1R2Zv+tYdB>EYT2L z(N~$!_J!__`=IvOi+-M%E;oSfBw9K zLPyc=Zgi1mW6J|d+Qbas z{HvbuYQ@FHMr2HpSEO)+2xsUda+aV6PJjQ$roVT$efnZU&msg8`?JiSmBGd?H(4m|Rywb0wLL zb=wuWMi0FHn}?D=Qp$1(wkw-Sac$SWw z2A^LXZgJpuciVYWQ&ZS_uKM8&A}n7CVxGX+sU2XPC@hLaXkL-0qxnTeYwjq^6AtOB z-KNT^ID$sb9xW|U%J!q+>00EsO`D@Aq2BCRJxxL$dA}@KnpPXpd+UCJ zvsO0kzG4=Dr@}BJSGCLR(2m_M4LJxQn{^-sEDxe zb0Z*xUE%!qb-W~BMZBHH#R{Q%9N>Ky0QtQ{(Sd&dm=9|IqjCm?_Lca$sR?6l&1Lz?+xVfq4#fL4oj3=bGJb*}#cgEl9LD~;nDyfqikAL%} z)}&W&2}&l{V_$b4LHsvs)(@0pTs_4idRS{(@rB7I;s*KbHD%?W@5uC~8XZyRZz?^z z=4hM-fQ*X3d(V7}`w3H4F&U%%rE1oq$iP( zkkne7=qe~FQRPI&NcJX++1NrEsjtwJb|5X?CcoXM+-0_Iy#Nwsi^{>-o--#Xfd^1k zZF#fj@1!hFnyX2v>vs00D5Qk%Iz_f`Vd!kPQ2o?cko=GHMO7%t_pWoT3kbd1!;dXb& zDqQXWh|IauNYehddx;XyQuJ+O?<{ zoNuV6ch#Gakf6Mg+6QLN3sB{*7xt`hf63BnO--$PiunSalIIA%EHMZ>LkZuN8rH*m-Sf62?A z{GHUl13(%#B~4@e5r673OI@3riCEkHoGj8j-fbZt9OrH#&Zf;ikXKHoY z>8fgyF-nJ$uk?G-U#BsSj`;{5+hDESC+o{wkCxl`%ZhrJ7BKcQs)U+NkHGenplYMe za5!bL7_OlSYsy`R#0p@lu-0^?&2THi*MB6`vc zfE!c16|**hoP5yAPB^N95a6JC{^ak}F4DSh0$Zj0;;Sse0FHsNQOVAr#XVF&;F+7F zsx!@V&?P{KKqMpPoe)VU41D1;BJeJ-KvhomiuVu>7N;BvP3NscL(|=BXgu%Ozw-_y zqxsJdZjUMfsjYoU-6YVJNPlHS^WE5sp_riW{4dKhUbnN=Z9l2zxjhDs%_0f1Zxv7V zOf|U_+LJ;2_y?fhRrQGfnqEXiI+~><;laQRu+}?fIMMrY_QAmsAcC5u|1ENEo6mk` zrV#Jm>YW9Z7Wp2p-1H48_Yvj8Bus2}>SZ(!cY4OmQ3*U4Mmk z8J6q#J=(MzIj~GWJ`-uv;k9Slo)Z6=`+Di!;GPp$eh$KFXlULFp?G5#54xB_CiOX` zAr(C5WHsoZCdAP}NUKnxcz_sA-hHiHYr%l(pXk@K1Z#)>VHJXkxBB_lE{hBBusSNvjyo{iNWBPfx-9efh2^&N(_W-Ulu$LPub!kkqF`>og1n>2=!7jT|2BqIvheImXg#}&I|C%v|s+hp2!aLt|GG5Ip z=Lm!W+Kqfj4%zuxWk(fze2R3f>jtZv{mPHx`F-I<{d88D(87loh9DA4L;|;X-_v%X zp|k4tvp&q%6U1SQ`cae{V40IrQ)BjkQKK5&2xj~c?t2o7CpmxrmnVWGWK_3Nlxv8g zugR5&h^Of8bvF?(lF#javp?}_&3iqU!Zd*>Dx9pY9i9#@$b||N;YpcE9jv$LfRgXZ zVgg*N96Ngi29zb6oC4eG*$kqVOe_|9tJ8Pq-Z+V|)eH<+$h{|4&WC-;rKt#pwnAz) z2XecEP%S4uq${upjKR;s{0OKgynaE03S|rWUaQ#BN)YPu+SOHa-*|Bi4=LWlYs6q5A$I>?5Y?uAF zV7dePcyp<2vJKWWT)D~F$xt$1j{-}GCh%&4kZ21xfAa9O-z2&EZSKF8i%$|ggSz-e z3OeoP^29&438VpllD?=Nx+K9yVU^spG;zR<6=Tf2YuAXjsjYawQzo9`={e4RCDs1R zqB*>edExe1cECW-Go2aY#d9xYDHvg+C=3`}kcj$10vVx8pgdyyQVcCqJD-liGTUEj zI~a`$zVG+a`1`OLs}ju_h9=6~U1Rk$70~a6+c!JnEcJ5^9dG@wsgytI_L-ZkK24H1 zZ%9?vkq2yH<-A?E@?R|j42@FM*M%5#*YogP*k2n5Z~@tw8~McOG@zT#Ev79=!H3qny3(_; z$*`vxAu)9*FmGOYccX2N(^&q2U8{q637cW_Tx)%Z6H@OsHO3IHM522}pT3mk>w;up=|J6tzA=j${tP4IiM2o{*=k_+EJ68G*Oj*yXm;Ult6p zx_%A>d!JMmlUYGXVSC6t&w7C$7?A#9=l9&#qj=}bxt$hgd#p|QI98l7Z*572&t2=N zk4LI%T2HeYRsZ!ncTJr!Y73KNt~wAZ%uMGw=n$CJ3V3yj0z|9VssmOtiD52gFy+jc z)E1@W7JD^@{@gUoaF`u;tjd=mAbhCCa@*0=gGLxQTQv) z!1qVIo~95op{d2iw5!S*nG$qKw;uf~&Gp_TsS@M#fyT4)qxF$NEWFUi9FhCK$^o#1 z`oJsaA_}=^MNUvdWdiXgqiy*qo>ZjH1nAd65n+#4<{pw6}Ifj-xi;N0Z@ z)?FlC)_ukau`&+sHt&f8yCuPsYN zr;FzS=@0=ppI^x+|IY%zhCCkNcIHtOYB!guWlUeC*%u9t%AwE%X=~ws3dV0&<|l1R zZKa+@lZiCIV8QzRu` z=P@-)YmQ{$gbBM3%|=FwE06Xhsd)SD`0k5MjflVmV^nDT(4$3if6Fu*#m=1>gNXnG zS4g`PHUX8?Kwv5L<2U@Bwr2Zac!Wzo6~_vP-Zu9mKnK=dsS-c5BTJo##GvcbCF}u| zql8pb!?|!?g}Y0t^Bh3Pm$q=T!9)L!iM+aRU%;oV_G+`~;YS z5pkr9A128p#WhJ7M7zXe`@a`yQROg8Zr#D3Pr_mT z108kxgJQ6fQXw{n580f`*{W%Mg*lmbNh%+%N7Uge<{Jtgb5f+UEl=|uW*2yYT}-z4 z+d+W9OUIDTUN9Ola+^&8tauC!3^HzUbdtDRuXB(2xAq&pLxw;k*2l!Z%uKUGLqmXo z*tEGb44yVe$}h*qTY8`$z{2o>v@&_oZGWAhfP?3Rn$z_bIB{#>p}406XN$1uChmQI z+&K$CL;q$H!+(6^(5nTUz>W0Pm}}w-kE~_bIDHCP9?MbNnAJqC=*zbY4Q4}{mCu6J zH}ZRe-I_UEmj>t`Iz85ks@LiYn5ig=>hh^zpT32 z;V-0!O<Ep>`P1s04Nko}5<^Uqq1SXd~A1Az0=y4MB?R%}W?d)@LHT7M8zVykt( zEQ2&vw&b$xXdC!SqVlL(ltKIi-dcCQ>DSHHO$_YS9J;;NLI^xzlYVRUr$b7Lv20oo z?7?{??)(MTh>OLO#WrcN z``TV+iJ=})`~oSq%504(IhM#-1MW43{Eu_Slm`q%`z77+ude|hk7D}&nn%l4zP>y@ zTWu0mWvTHHJ-tPUJ#Q7v=nPlc=xgANl}RT=4sj4>*5@V;i@NIJQZKf-`%&+j-Q#oM`+J|*~)0AftC@cCX=wy(^sx`P~ibK`*&-uY*Y!6oz&F~ zr+>xL?FecYNtLpMgS$rk(=xKdtuuZzqh6@P)?WxHfE7Mue-WA<2qW5-P4IKAm~YCv z*&3J{)8cE`GQjMVlAH7v{X|zv-$4daCIEy0@+VJ3{hdK&$ZV@0s=M zXnxt*dMD~xDYHLi)(kM=-dy|(2m-{+)OI3M1QZjLbS6I#;?TTH*a#|E6YQRI?aQ@Y zkLLe$`RNnhxc;h2E91li>6-o*>Z$Fy+^@JRr14}7@!J$RuYv(rEZuRzqgueTm0$Lz zMsW~P_+Vi4Rq0G^fgslz8%zF7jc}Q&sOj2~DqSJ^VGU@Yy(c3Zh&x#s(1k)rDdnhz zJdgXfKGv8z#If|3VtG7lk2Q`uIEw!E5zFgom{fOGwP^ibpoZ>XN<=$zZEX> z^T+#=+yLAvGW+ItuBWs)Euri6giF@GU9N)JgR`^Tv~|z5Z10Nz2Q1 z3BStZC+izHKMOJ8;b(Ler>_*adpD3ioi4_xu!kz}?s&0U1P@zq$So z{&fDD5FnYi1ZsirNua-|Fjpj5rdV&G&v?iP_YejELY0i1_RClO!t)5Mg8)j((4L}u zTyhK#k){b()F9Mp$=?3!+^!#CEvMwXec7o?rrb9ozPDEMWqXse_2EEj07fJEx|=4< zhkv`@maqD4{yS%hY;&Qw(L$Xj8h$s?tVaF1nz9H@0Paw-Jp4@rx!-wlW)0ra?L%|l z_y2vLO^NYS@+gAJsR|bbB?g*3e&Q;C4Ykq|B?h}aky%*T8Az;p?>`=(;3{fUg`rz`y|`y@C@ zkYS$sw=Gq&rSF9PAIa5u77=!$>6maI`#coDt8EnHruM@5>noD;X-S??qjG0kG4xGa zWgqV_1?_7)8<`>|r9p=ufLFggeTzET0@B;(}tM!wU}UNS3Dj*Bni6 zmM-1`Vhz)eDd!Z_mQ^wQ_yWvWdM$>4ZAU{f!o+D4`6K-jTGn)o?YjPU(joBRz^Q%x z1Xry1D{Y2Yce8w!>k@?!kMWaPy>bIpwBz$r^Hf{YPKq&jZFhmq%+HS$h>~!?l%Rb7 zi5f>jS{k0QqWrf$DY$)D)ZRlBV4fNi>0-Y7EEJCeqJu&#;ATYLt`do1 z7UIZPT5d05B#M)M_H?@zHON_st0+_;#Vbswgos5>6o zsHhG05|YOY&K37Y2L)Y_n6(5HUGuDZZnPuP@@&B}5JB5LkG~J?0L{Az0Lsph4Jy6) zFySh|;~B`V;{JGixSdMDGQ~nPIoh|i@fUIijKF|a>H1v`PV5O#-sMM-8=iAFN>&#+ zYkXlZNeKf+z)OqFj{Z8IJi@+qx}E6fc-pLQE?DXEPJt@|ra8rvTt|3D9OpV}4%f?@ z95!U|r3*c3Y_2d4jkxi`-Vr?j`r<<2?}4um%~MUq|GVC?fufkBrWxMU#Gk#T;ekx= zf1$f^aTx8j&fZ5P4X%_c5VF*|lquQSSp_#YHwQm{wk`TjV4%0b zDozv3W$2%CcP}^su!4uK*QE9Bj_~LWqzi&$-c%BnM!Gydc zf76@>CaU4bA>f$9uy~s=V;C(v^M=08p=uFuQ#!nfcrMwZCt=+DWC~)@Ya8%^ABDe3 zNWdQM6=_vr`xbup=r3>KVT6;Hdm1$?dn}5ZL>X!EAcdy0oc}j{}tDsT?$X;dc zx&vPkb%SgjtXYxw^McH^-)Fv0?7@lqPSP34A5Ne|j!P55@U79!3MSO{q?`g9qA%yS zETCd-(eUD}O}MpygFR?&RC2p?@#G>_&4ES#;@VMzG2$q_>ryPf<`DWrxYz^ZMnRCK!4ughM9~^9_jd4EVN_B|3eMwX6&{w- zmeJZnTqId;t4NB?#K(s?MVicd_R6tK)U|~56T`s%i5@$7R;PJds<)KaQ|7vlJeCJT zN@4Q#2RWJrg^LbySFx`Ydyeark++dgA;VtYqjJOFJ+)UF!m8Z6RZ2ZQ?IoyHn<`au zffg7u!RY^Ly+)Zv__BopPvgGBIP|h0Pu3S-1a2@ZfP+Xth?wN+aVdz2Le4 zw!D=r$otP;9?`b!^m)!qz=+xLCLMxm8Hma<>+8!aO$ z)oq@{&9gxj{vj-rWV;CL>u5)@E9&KzhitKrqryqsKj3E2_M0pWwTwa@!x6Fs-BriQ zJB`veenpD92aq}b1_qvvj%@qewV9Is8m=*m2cf7)O1RzD?}shwWCs)feduP;hT-#A zb7hM)>KW+|9c^s-1{FypB#LNr5TR;nYX6eYXa{M5U5=F-`+*}>oHOAQZFcQKS96lk z?q51|sE;6RXFWUfRf@^$#a#eeulPB^Qw8C|TC~##TN!e|!}_;|8hnzEwUN29Q5bP% zU2%8iOl4fI-^2a)oW}Ncy4cAzgymjHl- z78H(%lbE4FLM{qtRLtWyp4!&QuWbL(VbH`6pcqer*tQgt5Ge1m{P}1q$udTs%0UtJ zUu$Q|Ct~*?mr^fAxi93)3)P0~fXY&UI|8UTfOL@JbYEew(;hB<|NS3h#EcwC9}B@V zC9LB+K4LA_83#v4Oej#r*m2VnCk*#d?gSX@^)uBv?547q)k)>c7Hx z`t1e+I~OqgKXE&F*=3w9u`E6x$(NG7Jo$Rk0o>Uw=0DLUOPI38-P@4@;m4n8N1I68 zk!V2;qOR*DhK3r!U+z{}dWE;qw{Xv1>_eY>X-=9At&Hxf{6H%O2t~!a!L2AZ^r9~F zF;p&UH+?vPA&-mq{G7MC$XMUA@f5P- zTq}#KZxw+{Z%o(uTfu~sn9IfehQr3B+PNRNRNvP@fMiK2Z-N~0-R#NOfBrV!`{}9t z$}hD;NZ%h}5?uKO3A#h7UV8X6sKBF8lq6TlpY*Yko{iGkls3ToNoR--_Y<&Q0G*ieN;W00xXob2*F- zm#;kgTj$*?2J9<{U^F2UQHP+UTVy4E#3SqtV*Z68__&!$Jt{1|6}I;!%0Cmf!VgAj1p0P?$FyN zUfmH-2Kl<7q#BorVB0CUdMA#burk1_)DTg7dzI?y0dJ@G1hJ|Ay&4U zokPerl?+%>J%%}_12K~F&vx+=7b#+J? znVJlD<2>E2C)y_zTH|ManX)MS@6gld0nwkEo7*sVDTTCJZhCs}#ex#jfsj^`ne#}Q z_2lVilk}A0&XPoiwD79dt8E1aN&GFnnX!$#_GUYa366HQOUr!g$;Ux_i3RVRFXMks z+2~ZY2}~%fEn%A&n=W}c7BhvOpw?+R5QhLhPXiGH$*t|aT}hss(>VjA7#@-o8MWM; zocR)ef~68e9gWt53IdjLplnK)>TYhgmC@;P{U@Z{5V-fJ#zh7-&B_$1)063_EBco; zT$u<4qY^F(@5_3>bIbEeQ;UHm7#O~%XQXNZ0&|4Kz7>715-E$u#O^MebSUyE@>_9s z3V~<9i*x#tErY>eV-uiiw!02;Dmvrbu5D?__b7Y$#f;Ot3~ux>Dfwi}A9^nFss2yB z^tvAZ-s1XZ5kUQK2;IYVT;()x**G4e8vbOO&Kl&>gJ18k?XECE_JvSlRb*T1$nA}8 zy%zudJe^S-CA+9o<)$ct6U%7fC&EgPo?t>8^l={J zrnQ0Ys1YSAR7-+>!n~KS-7e^K3jIFaaaJv4?pxh(^4tQfFOb#6@3a|ImCn{#oHK60 z0f-%ni)qsr3P|f&)aTm329)nh1#g!xHdfc`PbdhJoV`~IU^~0YPZJ-WApngh{PuhW z!b@T1n6!k6F+A_+80~5{qL@sf}9&Q%awXzj&8v$7RFGvI5 zsx?i<;~6Cj2?*kB&H1IlT4PtMMyZ>~FpuE7?FrE<=`7*~^Ivw>ya4FV(c;eK6 z$BtdLXR3|7DbcUf3|>)DjDB_?6%>Dcb;vq^kk%7%Ha6=-ZO+pC0&m$T`AJbhVH2=_ zl0@3+t6zox*;nWFvg<7a1O4&e@MT^o4;tK3CCq=6=Z~Gg(QvhU2ujCq6z`|las~l) z)*#)Wgd*>4kiT9YEqr6V+97vwaj`ghOl%<^a}!0|;XT2t`c+AB)robtJve1OP7#^t-Q(daF-_8c`4uD4=k#E_}@J)6xG) zl@h0{#g`I$t~(YCuvqV*$=gZytYgPT6ur9>dj^RIzda5a{m!q3%TT=?3pY7rZ{~qT z-(U5s1XK;%BLhr=f0A6~x9BIn4TKIk09?qFJ zb6|3l^2f67r;*ulT@XGL+&NCLmcy6*p#NL=M}GvS8GsxCo)$3(H`zj-+pUlsHOj6A73Gqd_Y@Q| zii)vb6a&{~sai>n!amQ7;bbdKsiGO|@p=uS*CVnIxdJZ^2!O3haJ-$?_j1fiUKL%W zy#aZnZ8UhxTpxRT7STEr>#>sv-}u^B*^qQ(16IQC!Nx#QM=;QHV=G|#!;eyYWM`zA zvyslR8kZjs=csGo6Iw>S8cmHg?()xA+Cm)zc3JNG*#Zz)JE|dCpE-0~(@&NbNd=*)Fi7sc96paiE@K(F3@oREPS9ozsvG;-=HVY5KS^W1j_r+}yiq{E(p_WNQJ436RUXa=v^_emr{$MhqV-PH z&UE`fcO3a2$gh-$^70mcLtF3zm0ACtu5e*`kK)&~`-5qd0R6x|)*iET2;c#DuBceE zwB99}2LZz$L*g_sv##i^Et9EX=h9S}f`8o#Xb=Bau@inTm<1BM%=oN8sty#Pi`w`( zuan4Kfg8cSB(%)#X-LJnqxY`F^F^-zJj~4k;uuWOyibG1RzsH|`RBis?n>UA2_qrW zPcEtQpZfF3kr05^8f}AmQ+!LMJVB8uNVhB4<&tMOT(&rYM_YisDW8>uyBrT$UYMyU ztl7{!LukB}E<*6`2)h0wC57PW;X|d}F+p1x3m!^sm048Voj{;yO4H#{VvTKD&B`pY z3u>ST!KfKyylbel`6>TZzMNNMf!YbF_@2dAl`aXIX9jksS4QSv_Xa$zws!UipbnP< zEZ_}AfDaY&Ji%lCKQRJjwo(jd)to;(6zmP%l3mJ_2e-gFd<}XXS?Z_2e0-5yWkmp- zTxZobETbp|DO>dHN+bGBo`IZrn1A`A+7xA%wP?8cvMtnUA*$NpVOvw!$S%WurG4ov zx@L5gh+y?AwGS-D)%tW^(4Ysu4Z(viVDDD~axY-Fj=kLokU(oF(%{5*pcc}iF5KD} z^?6q8^wOLO+kZ0&p+JF_a_W*_S1!lJCrFt4m+{v~wuo3t5 z*Hm7t|2$K9k=?8`QHCodBx?PiJb-)|ls_jp`|=KoDo52QH-Ocf6MvPtM0kc|IHX}Nvte)BH>jKG6prqArCsl#KX=~6yyIum^jP@nB zHVejNy3O{)O{zCQ!2A;w^PL_#y-=pXBKLt62se_3K$*#7>a`c-pcDfZom9;tZI z&9F@DN-mx~505Mb! z&8Wa{ARE~xUltp5DgADNKft*2bRt6Zh|cnhKgBkn&UsaHcRz=c$r@=7M; z5!6CWkMtoZCQ{&NhD%MhST#;Kxx0Vs_kVDYPvjzjJMM5--M&zYsij8I_%4I!C<6i3 z7HFn09avR-Zp3`y{la2?`lR`Xx^5U2r4sSL*T#DKxnw@gKAo5x|63houyl|Q;Bf0F zx={xpyNUo1yf1pJ_&8f(YvZA;q_loH;@pgO-4BWPhoMK`r)7SAnh4C1i7*r_-Ef@{ zk*~9OinqWtwy;1bHrWkpTiKKBp@mFshI{u$&0c-R z-NI8%$YAUO{MdrKI{~W`pEF(q<=6)f)H%lDKHa8Jo4|JN?g}=&&|RHs0@##`jE!`& z5)%socFO9mj1AS*XP}A&`um35rHHEmfNiSn0xQofA|hfVgtS8p_m8a7WMgZ`1Fr%1Q!?id z-OsSAnTR*==EMk??6xotO~?BdF>rD`W`+$&>!eq z1@qi!GY=M5VDAxYM-J>P` z0RhpdgqRRuNpqjKDYg|Ied`Zw=>3VbiZZ`9r^^LuIs~>}Ljs=p0&7$%yH_vi!WftE z2Z2~bIxVD9O-to&KdO>p!krA=i~*9Aw_selI5Qg?x%)N7S*E@{z`jjSvo!w4kKLXu zq1Ohm=uMrh&ger7#L-%BP7k)tIz5+Bu+p>*&vhad8Hy=-Z(RGA`7c?(jYe7aimtb) zqKN9h6H4DUn>-gMOa+hlHF!tw!3no>GC(3&*utlHuhf}}PiZCI=I)(ru-Ot>Pj%vz zQ5jkI8v?oaHTLsgqd;ud8ei$2Rl-}d8OzhYefu?fCZ>=Hh?FpSYVvBWCtnzMx2ss^ ze{z=Zb+nTJOS2D|9HBw@NcUmkr(48r8xyxW;p^Hk^rZ$d$?K%e#j`m3o^lKdqkxai zdYX0IE(&f~o>H=(6ACOVA+`#HqIrmg*jgN{cJ~@M+v%A_E#rUpcDR(j#4VJ0=5RNC zx|cV@@Er#Q30Fa-#TC}>n^=Gy+G6|(BHSP{90GC@JMH^Wj;&sVcWHUd**}AYoTuS? z;SE+%eKSvaA;tcC6-hPG}97cxcRN+*Ci#HF!5Gs#Gv*6`D@gMP5WZ1%;T=_$%nU=wkU5K5(GHgnY zY`w`%?y7t*MLvS?qd5_c1fi>gnlS49;gpBU^mgf9e+kOb)iK8YAui z3uc=Hi6-i_L}h;G?a;#uC+&8`#nv-h%4qH#2rYWZwkwL0{#tW&quRu+*6XsV2itk& zAraD5ijYIU%)X0iHkBlgFg&mexVn3g*63pEZhV8BI{tyI6c zV(Nk6ZcddT3xb+DJm5`Re_W0mG%c+zn;LPNvcdzB;el884lXVM^@oj3C5?LS@#LY( zq0xb}cSVZ?816S1Ab1c zA%mvqpgSsu4-~%5-cz?JFR3*~b5xPZ|B-V`;ka1t4ipQIh!{b*DT+xgsIEROkoY$) zd8X8}3QzYlgGROev6WX+u-HetE-~`E8{9w6e>&o z4^D}GuNSK;>F?n&51TBcPI1!-K(Jj#5n`$jz5F9 zp`f*uh_Y{Ul9IP_4GXF)n9U2X6E*~=9g)yz;-~)U*SRW#j)|A%{eX5|WCO8UoK+bA zlsrJf_W-L9oBQ?*0Wh{U8kwX(5%7%@#H@=u!dOr$Zuq2;l zZMBH6RBCwm=MLx~i8J77^T(8<^x+l-3Osr-1T2z(wvRV)E?UD56`|*&!o*mb(=dD4 z^N24L==b++55xdml@(eHAxm#MR|$t-zl(##mj*{W`Def0H zHo?t~n10!&Xtge-LC{*x8e7@A1yj0os~p`@#2nW4Lezxvk9%r4ODyBNxQ7wXAVxG! zZ+DN)o7*iy%rS;)#TeZNw%sIb^KQ=#(N&jG7ArfucUTAr2xNF9>FVXGe;Q1bUm>QV!|pLK7Dg-z|> zxo`B_uQFNQ*!E36P&n4as-7sJ?y2L0PF-X zn$m7H4V!n_;NpKnU^K@d6^?9bqDe8}CLVC=$MW%gayk{S zNp>iYAQ=6O)&YUJ>V93^0F&&~t}#4|E%BOaaqmdwb^NR*%SUA&uG4BS*EuY!Yj%+t z%n6K1M2w$c=o-~z-XY%)eVp(({gb(V|C!+?onqFk_PwTu+vY*SM-`F^eY8?Gow`rz zqTc14uviI1^)>y)yIGe=LvP z%@)eJ%2nU){CI6$1(MMxic{2Z#ox0b!KLZX^6PteMb-Uw3b(KSih`Yn$rV?9n&44! z`tZTS#MFBWQD>np(P||)Oe)zMA_~b(cYzQ!gI$~L+uGvRYV2b{j4A9TrsSDBczn$4w=pz1N%_w%*=J*)h^!7vT7YtxX^v?x0;gL` zJyHM~A|=JYFcY%1^#KhN)6By|lR1?U{{-)6i0N6Sy24e}?*tUW#FohCwB$~;bmhN> zk34qFq(O$mgZ?#3J{m1mWmN+iJhtqjqSZSt+NVp#+m0nsEyxwY$05KmPPJn?fv2)< zv><%9@fHhwbJ`tV90V-7p#V9-&C6qAoVOu7+NEX33(FSk-TxfBvXMo&KM=Xpn>@Gr zruzp>e64U?O*~pXY_JgX?v}Jd@9#t7aoW8i&tUJR7>sY=qbZml!dY9+|KHzln_(u~ zcm7YeCUQ{yWU1#a^HBo5q^_RrJ1$Fb8iy-eno;uBe`(MR=wNH~8e~=~cYN&ibG2`) zaR9%2pDx5B-xtcH<*~WHTp<^y_u;DVlyKAXMVzllMOoylS`0U5q-voRaQSxhjK@n1 zmY$wDqokS{##Xd(p0K&7yZ*M#vnJ4VobQXeEcQPhRzxKzTaB+-v2BXi}Rj+_I~ygEVt90-~-7cy-NZ_ zZIxxVA5k4)#$EF<1QqG&PVEV6>FVKzN9|g<@bL2f&-t){x}IJ%dy>;&jCS{J;w&E@ zVoc}R$b>Sft<-O$1H-h?{C=B|UVsmEV+!S8&*y`G^{r4EYYi5hJdrm8hyUXB&bxv5 z0zd>smoNnuI&JjLp825JQgm8LQ!Sykeo}sE<9%1=tv}_)T<4;xJydTw`WkQz6UODm zd-LWEU~b)*??fS;t5t5zrw4ojZ^ms@m|g2;HK1E?3|fDDLPElp-MuViB;betcKQk3 zVW7KbR=CGZ{lM50>VBF>4Btz|e8#QiQzV#qTYIav+C)^z2WK^@IHhV~yx~-M{nKFn z&hR1AxVWrykaJ(-5dtOL4<1vi}I&ON9iyrA%x= z&5^e#vH=Ap6_2%)>oK&Pz7$-KTkqn&#p}Z_WF%fk=NA+pZ$lMgBSdb$0*OPiq|CTd zv^4VQg5(BWQM<&sj&4o35>Ogvx^!6Ikt4N!EZ2jA{QpYUASzH-9QoV6?a^cU}V7bFZmr$i0Q!-j0dQZkT>G+6kwtJ&lZ zXr?RMfO>|5iyJ)_%8MGNZ{mgD~x%*WqUW*W`_JiIdpTQs#E5veKwCMg8))m zn_Qm{h|&`dx;YGV^g7v-DY`A2d>X+TRU{bYA@r>$7x}(gH)4Bn)qD54sU|=YNOJs7 z;8~{Z!;}BihAWgt(G)rqnP6Q@)7}2`sw3dh5mB3KQ+FS}Mn*<9?c^pSk)dqY0z_`uDM$C}3Tqh;e zk=LCgF2tPH!^|=T!S#SnwAE3(CNM|%eEXT z8VpEDYz*eyQi$3iKd-4McY3&umFhl7(dld`GWH#nc6P$FgOG;aj+Z9``5;vt`rc(5 z?z1XZIuVyvRE=i^dko#J$McA5$ZA}k@<}g{Wbb4K77ke z^~D%II{F>jbo78Gm6|1^nwPTXd*~?2I4cNWT;AQMxz%BWgO%h&F~{!#S#P9OalNaW zl0^BZ;B+uZW+BGCZuR0rFEs`1+3N{(N(?eNS1@o_lR%*iHni7gDI`y7EB97V_;7`A z5~op6QoC~jEq;t8 zHaBock7*gu7kunWvnj7poAfF-R?kY0CDqG&zBUG{05kv z0|SY{CVoGCFM4ZRURCWg;Sc8jZq7I6Dg-}`ZzPqIc2s6yq)+$z7z-wZlZOE3o$d0!6b`s-mvcLQ5SCS&m9|V8Q zyv9SBM0v3^WsBZ4R+SFa!dB(Jk}_iNNKQzmO-G;f86xQ_hw%sy9+I>8d5%5qSd?y| zJ&P92?{zDbx>qZ(~AzJGf%fwzjN~9pR=mpPGXC^ z@w2yQYxd~qDsv&WaO*W(xB7OBcCu;%0sX!RUcmczZ;6eINbx>YT4qCo7o(mF1lpYL56P?rR8xg{f z%o4T1kE|hiH+5yE9W!%lykmGNp7#vE)VSlB(m%!IJHttSZn~i^4H|7`o@<7OaL4=Vb!oEzqlK_&p zGX?^-ocSQ7KOo2Fu|74riHVqahlV9~UWf6&?u^8`k?WrvZ~gsCP>5NapSXjLE1^hW zZPRR{nX2ajdl6ePCDorp#@7N9gdxXj1=xicPQw@OiXz0ji!8HeRfihG?c8pXmRZv% z)}s}kY?$xmsO<{KwVcl{wAya`Y;2h92w&oZA&JYUK*CBx!t0|X@Ud55cSBo)&j!~` zB-gj3{vR){Vq#*vDlW~<0==8Df#`?%MQq$_x0}h>a1lCIDUbF2d9(Xep)K0=yTFc3 zT<4zO22R0hUp;Hde{-12gqxeGN^VZe6p-0CVxkCgj`t~JeoNL@j@%_9`dl;;@T#ie zt&>^^RErE{2>U6b4Hc=F(zKNr)Ll9OQX54xU1f1ZuCMM8%F0A*cwrfEo)scu{SvkG zj{B#!palrSTNM3KXAy89QUqM(hxmFx+O%)+5R!DI3NbE;wn>(bK}Mhozt$TK2uW(l zt)PEfdPvZM6B$C%R+!qCPNmG*Uixj}TOMON

    V6{aWpY>Oi1$BY{8C=1y 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 G(Ek8?l&8l4 literal 0 HcmV?d00001 diff --git a/.vaunt/badges/badge_02-03.png b/.vaunt/badges/badge_02-03.png new file mode 100644 index 0000000000000000000000000000000000000000..4f6748d6f05e836750795f1deef8da5b08a12288 GIT binary patch literal 99890 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