From af3d010339f33035736418ee3614c59b9cffde69 Mon Sep 17 00:00:00 2001 From: Mouliraj Elamurugan Date: Thu, 24 Oct 2024 17:08:33 +0530 Subject: [PATCH] #8142: TTNN log-alike ops incomplete documentation (#13969) * #8142: Add documentation for log alike ops * #8142: Update sweep tests --- .../sweeps/eltwise/unary/log10/log10.py | 50 ++++++++-------- .../sweeps/eltwise/unary/log1p/log1p.py | 50 ++++++++-------- .../sweeps/eltwise/unary/log2/log2.py | 49 ++++++++-------- .../eltwise/unary/log_sigmoid/log_sigmoid.py | 49 ++++++++-------- .../operations/eltwise/unary/unary_pybind.hpp | 58 +++++++++++++++++-- 5 files changed, 157 insertions(+), 99 deletions(-) diff --git a/tests/sweep_framework/sweeps/eltwise/unary/log10/log10.py b/tests/sweep_framework/sweeps/eltwise/unary/log10/log10.py index b9e6a6f6212..e7ed425f251 100644 --- a/tests/sweep_framework/sweeps/eltwise/unary/log10/log10.py +++ b/tests/sweep_framework/sweeps/eltwise/unary/log10/log10.py @@ -6,7 +6,6 @@ from functools import partial import torch -import random import ttnn from tests.sweep_framework.sweep_utils.utils import gen_shapes from tests.tt_eager.python_api_testing.sweep_tests.generation_funcs import gen_func_with_cast_tt @@ -14,11 +13,6 @@ from tests.ttnn.utils_for_testing import check_with_pcc, start_measuring_time, stop_measuring_time from models.utility_functions import torch_random -# Override the default timeout in seconds for hang detection. -TIMEOUT = 30 - -random.seed(0) - # Parameters provided to the test vector generator are defined here. # They are defined as dict-type suites that contain the arguments to the run function as keys, and lists of possible inputs as values. # Each suite has a key name (in this case "suite_1") which will associate the test vectors to this specific suite of inputs. @@ -28,45 +22,53 @@ "input_shape": gen_shapes([1, 1, 32, 32], [6, 12, 256, 256], [1, 1, 32, 32], 16) + gen_shapes([1, 32, 32], [12, 256, 256], [1, 32, 32], 16) + gen_shapes([32, 32], [256, 256], [32, 32], 32), - "input_a_dtype": [ttnn.bfloat16, ttnn.bfloat8_b], - "input_a_layout": [ttnn.TILE_LAYOUT], - "input_a_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], + "input_dtype": [ttnn.bfloat16, ttnn.bfloat8_b], + "input_layout": [ttnn.TILE_LAYOUT, ttnn.ROW_MAJOR_LAYOUT], + "input_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], "output_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], }, } +# Invalidate vector is called during the generation phase where each vector will be passed in. +# If invalidated, the vector will still be stored but will be skipped. +# Returns False, None if the vector is valid, and True, str with a reason for invalidation if it is invalid. +def invalidate_vector(test_vector) -> Tuple[bool, Optional[str]]: + if test_vector["input_layout"] == ttnn.ROW_MAJOR_LAYOUT: + return True, "Row Major layout is not supported" + return False, None + + # This is the run instructions for the test, defined by the developer. # The run function must take the above-defined parameters as inputs. # The runner will call this run function with each test vector, and the returned results from this function will be stored. # If you defined a device_mesh_fixture above, the object you yielded will be passed into this function as 'device'. Otherwise, it will be the default ttnn device opened by the infra. def run( input_shape, - input_a_dtype, - input_a_layout, - input_a_memory_config, + input_dtype, + input_layout, + input_memory_config, output_memory_config, *, device, ) -> list: - data_seed = random.randint(0, 20000000) - torch.manual_seed(data_seed) + torch.manual_seed(0) - torch_input_tensor_a = gen_func_with_cast_tt( - partial(torch_random, low=1, high=100, dtype=torch.float32), input_a_dtype + torch_input_tensor = gen_func_with_cast_tt( + partial(torch_random, low=1, high=100, dtype=torch.float32), input_dtype )(input_shape) - torch_output_tensor = torch.log10(torch_input_tensor_a) - - input_tensor_a = ttnn.from_torch( - torch_input_tensor_a, - dtype=input_a_dtype, - layout=input_a_layout, + golden_function = ttnn.get_golden_function(ttnn.log10) + torch_output_tensor = golden_function(torch_input_tensor) + input_tensor = ttnn.from_torch( + torch_input_tensor, + dtype=input_dtype, + layout=input_layout, device=device, - memory_config=input_a_memory_config, + memory_config=input_memory_config, ) start_time = start_measuring_time() - result = ttnn.log10(input_tensor_a, memory_config=output_memory_config) + result = ttnn.log10(input_tensor, memory_config=output_memory_config) output_tensor = ttnn.to_torch(result) e2e_perf = stop_measuring_time(start_time) diff --git a/tests/sweep_framework/sweeps/eltwise/unary/log1p/log1p.py b/tests/sweep_framework/sweeps/eltwise/unary/log1p/log1p.py index d5236c73e5f..a188e346f78 100644 --- a/tests/sweep_framework/sweeps/eltwise/unary/log1p/log1p.py +++ b/tests/sweep_framework/sweeps/eltwise/unary/log1p/log1p.py @@ -6,7 +6,6 @@ from functools import partial import torch -import random import ttnn from tests.sweep_framework.sweep_utils.utils import gen_shapes from tests.tt_eager.python_api_testing.sweep_tests.generation_funcs import gen_func_with_cast_tt @@ -14,11 +13,6 @@ from tests.ttnn.utils_for_testing import check_with_pcc, start_measuring_time, stop_measuring_time from models.utility_functions import torch_random -# Override the default timeout in seconds for hang detection. -TIMEOUT = 30 - -random.seed(0) - # Parameters provided to the test vector generator are defined here. # They are defined as dict-type suites that contain the arguments to the run function as keys, and lists of possible inputs as values. # Each suite has a key name (in this case "suite_1") which will associate the test vectors to this specific suite of inputs. @@ -28,45 +22,55 @@ "input_shape": gen_shapes([1, 1, 32, 32], [6, 12, 256, 256], [1, 1, 32, 32], 16) + gen_shapes([1, 32, 32], [12, 256, 256], [1, 32, 32], 16) + gen_shapes([32, 32], [256, 256], [32, 32], 32), - "input_a_dtype": [ttnn.bfloat16], - "input_a_layout": [ttnn.TILE_LAYOUT], - "input_a_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], + "input_dtype": [ttnn.bfloat16, ttnn.bfloat8_b], + "input_layout": [ttnn.TILE_LAYOUT, ttnn.ROW_MAJOR_LAYOUT], + "input_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], "output_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], }, } +# Invalidate vector is called during the generation phase where each vector will be passed in. +# If invalidated, the vector will still be stored but will be skipped. +# Returns False, None if the vector is valid, and True, str with a reason for invalidation if it is invalid. +def invalidate_vector(test_vector) -> Tuple[bool, Optional[str]]: + if test_vector["input_layout"] == ttnn.ROW_MAJOR_LAYOUT or test_vector["input_dtype"] == ttnn.bfloat8_b: + return True, "Row Major layout and bfloat8_b are not supported" + return False, None + + # This is the run instructions for the test, defined by the developer. # The run function must take the above-defined parameters as inputs. # The runner will call this run function with each test vector, and the returned results from this function will be stored. # If you defined a device_mesh_fixture above, the object you yielded will be passed into this function as 'device'. Otherwise, it will be the default ttnn device opened by the infra. def run( input_shape, - input_a_dtype, - input_a_layout, - input_a_memory_config, + input_dtype, + input_layout, + input_memory_config, output_memory_config, *, device, ) -> list: - data_seed = random.randint(0, 20000000) - torch.manual_seed(data_seed) + torch.manual_seed(0) - torch_input_tensor_a = gen_func_with_cast_tt( - partial(torch_random, low=1, high=100, dtype=torch.float32), input_a_dtype + torch_input_tensor = gen_func_with_cast_tt( + partial(torch_random, low=1, high=100, dtype=torch.float32), input_dtype )(input_shape) - torch_output_tensor = torch.log1p(torch_input_tensor_a) - input_tensor_a = ttnn.from_torch( - torch_input_tensor_a, - dtype=input_a_dtype, - layout=input_a_layout, + golden_function = ttnn.get_golden_function(ttnn.log1p) + torch_output_tensor = golden_function(torch_input_tensor) + + input_tensor = ttnn.from_torch( + torch_input_tensor, + dtype=input_dtype, + layout=input_layout, device=device, - memory_config=input_a_memory_config, + memory_config=input_memory_config, ) start_time = start_measuring_time() - result = ttnn.log1p(input_tensor_a, memory_config=output_memory_config) + result = ttnn.log1p(input_tensor, memory_config=output_memory_config) output_tensor = ttnn.to_torch(result) e2e_perf = stop_measuring_time(start_time) diff --git a/tests/sweep_framework/sweeps/eltwise/unary/log2/log2.py b/tests/sweep_framework/sweeps/eltwise/unary/log2/log2.py index a2ec66fc172..b695f39d690 100644 --- a/tests/sweep_framework/sweeps/eltwise/unary/log2/log2.py +++ b/tests/sweep_framework/sweeps/eltwise/unary/log2/log2.py @@ -6,7 +6,6 @@ from functools import partial import torch -import random import ttnn from tests.sweep_framework.sweep_utils.utils import gen_shapes from tests.tt_eager.python_api_testing.sweep_tests.generation_funcs import gen_func_with_cast_tt @@ -14,11 +13,6 @@ from tests.ttnn.utils_for_testing import check_with_pcc, start_measuring_time, stop_measuring_time from models.utility_functions import torch_random -# Override the default timeout in seconds for hang detection. -TIMEOUT = 30 - -random.seed(0) - # Parameters provided to the test vector generator are defined here. # They are defined as dict-type suites that contain the arguments to the run function as keys, and lists of possible inputs as values. # Each suite has a key name (in this case "suite_1") which will associate the test vectors to this specific suite of inputs. @@ -28,45 +22,54 @@ "input_shape": gen_shapes([1, 1, 32, 32], [6, 12, 256, 256], [1, 1, 32, 32], 16) + gen_shapes([1, 32, 32], [12, 256, 256], [1, 32, 32], 16) + gen_shapes([32, 32], [256, 256], [32, 32], 32), - "input_a_dtype": [ttnn.bfloat16, ttnn.bfloat8_b], - "input_a_layout": [ttnn.TILE_LAYOUT], - "input_a_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], + "input_dtype": [ttnn.bfloat16, ttnn.bfloat8_b], + "input_layout": [ttnn.TILE_LAYOUT, ttnn.ROW_MAJOR_LAYOUT], + "input_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], "output_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], }, } +# Invalidate vector is called during the generation phase where each vector will be passed in. +# If invalidated, the vector will still be stored but will be skipped. +# Returns False, None if the vector is valid, and True, str with a reason for invalidation if it is invalid. +def invalidate_vector(test_vector) -> Tuple[bool, Optional[str]]: + if test_vector["input_layout"] == ttnn.ROW_MAJOR_LAYOUT: + return True, "Row Major layout is not supported" + return False, None + + # This is the run instructions for the test, defined by the developer. # The run function must take the above-defined parameters as inputs. # The runner will call this run function with each test vector, and the returned results from this function will be stored. # If you defined a device_mesh_fixture above, the object you yielded will be passed into this function as 'device'. Otherwise, it will be the default ttnn device opened by the infra. def run( input_shape, - input_a_dtype, - input_a_layout, - input_a_memory_config, + input_dtype, + input_layout, + input_memory_config, output_memory_config, *, device, ) -> list: - data_seed = random.randint(0, 20000000) - torch.manual_seed(data_seed) + torch.manual_seed(0) - torch_input_tensor_a = gen_func_with_cast_tt( - partial(torch_random, low=1, high=100, dtype=torch.float32), input_a_dtype + torch_input_tensor = gen_func_with_cast_tt( + partial(torch_random, low=1, high=100, dtype=torch.float32), input_dtype )(input_shape) - torch_output_tensor = torch.log2(torch_input_tensor_a) + golden_function = ttnn.get_golden_function(ttnn.log2) + torch_output_tensor = golden_function(torch_input_tensor) - input_tensor_a = ttnn.from_torch( - torch_input_tensor_a, - dtype=input_a_dtype, - layout=input_a_layout, + input_tensor = ttnn.from_torch( + torch_input_tensor, + dtype=input_dtype, + layout=input_layout, device=device, - memory_config=input_a_memory_config, + memory_config=input_memory_config, ) start_time = start_measuring_time() - result = ttnn.log2(input_tensor_a, memory_config=output_memory_config) + result = ttnn.log2(input_tensor, memory_config=output_memory_config) output_tensor = ttnn.to_torch(result) e2e_perf = stop_measuring_time(start_time) diff --git a/tests/sweep_framework/sweeps/eltwise/unary/log_sigmoid/log_sigmoid.py b/tests/sweep_framework/sweeps/eltwise/unary/log_sigmoid/log_sigmoid.py index fdf97c265ba..75f73eaed12 100644 --- a/tests/sweep_framework/sweeps/eltwise/unary/log_sigmoid/log_sigmoid.py +++ b/tests/sweep_framework/sweeps/eltwise/unary/log_sigmoid/log_sigmoid.py @@ -6,7 +6,6 @@ from functools import partial import torch -import random import ttnn from tests.sweep_framework.sweep_utils.utils import gen_shapes from tests.tt_eager.python_api_testing.sweep_tests.generation_funcs import gen_func_with_cast_tt @@ -14,11 +13,6 @@ from tests.ttnn.utils_for_testing import check_with_pcc, start_measuring_time, stop_measuring_time from models.utility_functions import torch_random -# Override the default timeout in seconds for hang detection. -TIMEOUT = 30 - -random.seed(0) - # Parameters provided to the test vector generator are defined here. # They are defined as dict-type suites that contain the arguments to the run function as keys, and lists of possible inputs as values. # Each suite has a key name (in this case "suite_1") which will associate the test vectors to this specific suite of inputs. @@ -28,45 +22,54 @@ "input_shape": gen_shapes([1, 1, 32, 32], [6, 12, 256, 256], [1, 1, 32, 32], 16) + gen_shapes([1, 32, 32], [12, 256, 256], [1, 32, 32], 16) + gen_shapes([32, 32], [256, 256], [32, 32], 32), - "input_a_dtype": [ttnn.bfloat16, ttnn.bfloat8_b], - "input_a_layout": [ttnn.TILE_LAYOUT], - "input_a_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], + "input_dtype": [ttnn.bfloat16, ttnn.bfloat8_b], + "input_layout": [ttnn.TILE_LAYOUT, ttnn.ROW_MAJOR_LAYOUT], + "input_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], "output_memory_config": [ttnn.DRAM_MEMORY_CONFIG, ttnn.L1_MEMORY_CONFIG], }, } +# Invalidate vector is called during the generation phase where each vector will be passed in. +# If invalidated, the vector will still be stored but will be skipped. +# Returns False, None if the vector is valid, and True, str with a reason for invalidation if it is invalid. +def invalidate_vector(test_vector) -> Tuple[bool, Optional[str]]: + if test_vector["input_layout"] == ttnn.ROW_MAJOR_LAYOUT: + return True, "Row Major layout is not supported" + return False, None + + # This is the run instructions for the test, defined by the developer. # The run function must take the above-defined parameters as inputs. # The runner will call this run function with each test vector, and the returned results from this function will be stored. # If you defined a device_mesh_fixture above, the object you yielded will be passed into this function as 'device'. Otherwise, it will be the default ttnn device opened by the infra. def run( input_shape, - input_a_dtype, - input_a_layout, - input_a_memory_config, + input_dtype, + input_layout, + input_memory_config, output_memory_config, *, device, ) -> list: - data_seed = random.randint(0, 20000000) - torch.manual_seed(data_seed) + torch.manual_seed(0) - torch_input_tensor_a = gen_func_with_cast_tt( - partial(torch_random, low=-4, high=10, dtype=torch.float32), input_a_dtype + torch_input_tensor = gen_func_with_cast_tt( + partial(torch_random, low=-4, high=10, dtype=torch.float32), input_dtype )(input_shape) - torch_output_tensor = torch.nn.functional.logsigmoid(torch_input_tensor_a) + golden_function = ttnn.get_golden_function(ttnn.log_sigmoid) + torch_output_tensor = golden_function(torch_input_tensor) - input_tensor_a = ttnn.from_torch( - torch_input_tensor_a, - dtype=input_a_dtype, - layout=input_a_layout, + input_tensor = ttnn.from_torch( + torch_input_tensor, + dtype=input_dtype, + layout=input_layout, device=device, - memory_config=input_a_memory_config, + memory_config=input_memory_config, ) start_time = start_measuring_time() - result = ttnn.log_sigmoid(input_tensor_a, memory_config=output_memory_config) + result = ttnn.log_sigmoid(input_tensor, memory_config=output_memory_config) output_tensor = ttnn.to_torch(result) e2e_perf = stop_measuring_time(start_time) diff --git a/ttnn/cpp/ttnn/operations/eltwise/unary/unary_pybind.hpp b/ttnn/cpp/ttnn/operations/eltwise/unary/unary_pybind.hpp index 025f3c1ba81..dca165f2aef 100644 --- a/ttnn/cpp/ttnn/operations/eltwise/unary/unary_pybind.hpp +++ b/ttnn/cpp/ttnn/operations/eltwise/unary/unary_pybind.hpp @@ -810,7 +810,7 @@ void bind_power(py::module& module, const unary_operation_t& operation, const st } template -void bind_unary_composite(py::module& module, const unary_operation_t& operation, const std::string& description, const std::string& range = "") { +void bind_unary_composite(py::module& module, const unary_operation_t& operation, const std::string& description, const std::string& range = "", const std::string& info_doc = "") { auto doc = fmt::format( R"doc( {2} @@ -824,6 +824,9 @@ void bind_unary_composite(py::module& module, const unary_operation_t& operation Returns: ttnn.Tensor: the output tensor. + Note: + {4} + Example: >>> tensor = ttnn.from_torch(torch.tensor((1, 2), dtype=torch.bfloat16), device=device) >>> output = {1}(tensor) @@ -831,7 +834,8 @@ void bind_unary_composite(py::module& module, const unary_operation_t& operation operation.base_name(), operation.python_fully_qualified_name(), description, - range); + range, + info_doc); bind_registered_operation( module, @@ -1472,8 +1476,32 @@ void py_module(py::module& module) { )doc"); detail::bind_unary_operation(module, ttnn::log, R"doc(\mathrm{{output\_tensor}}_i = log(\mathrm{{input\_tensor}}_i))doc"); - detail::bind_unary_operation(module, ttnn::log10, R"doc(\mathrm{{output\_tensor}}_i = log10(\mathrm{{input\_tensor}}_i))doc"); - detail::bind_unary_operation(module, ttnn::log2, R"doc(\mathrm{{output\_tensor}}_i = log2(\mathrm{{input\_tensor}}_i))doc"); + detail::bind_unary_operation(module, ttnn::log10, R"doc(\mathrm{{output\_tensor}}_i = log10(\mathrm{{input\_tensor}}_i))doc", + R"doc(Supported dtypes, layouts, and ranks: + + +----------------------------+---------------------------------+-------------------+ + | Dtypes | Layouts | Ranks | + +----------------------------+---------------------------------+-------------------+ + | BFLOAT16, BFLOAT8_B | TILE | 2, 3, 4 | + +----------------------------+---------------------------------+-------------------+ + + BFLOAT8_B supported only in WHB0. + + )doc"); + + detail::bind_unary_operation(module, ttnn::log2, R"doc(\mathrm{{output\_tensor}}_i = log2(\mathrm{{input\_tensor}}_i))doc", + R"doc(Supported dtypes, layouts, and ranks: + + +----------------------------+---------------------------------+-------------------+ + | Dtypes | Layouts | Ranks | + +----------------------------+---------------------------------+-------------------+ + | BFLOAT16, BFLOAT8_B | TILE | 2, 3, 4 | + +----------------------------+---------------------------------+-------------------+ + + BFLOAT8_B supported only in WHB0. + + )doc"); + detail::bind_unary_operation(module, ttnn::logical_not, R"doc(\mathrm{{output\_tensor}}_i = \mathrm{{!input\_tensor_i}})doc", R"doc(Supports bfloat16 dtype and both TILE and ROW_MAJOR layout)doc"); detail::bind_unary_operation(module, ttnn::ltz, R"doc(\mathrm{{output\_tensor}}_i = (\mathrm{{input\_tensor_i\ < 0}}))doc", R"doc(Supported dtypes, layouts, and ranks: @@ -1517,7 +1545,16 @@ void py_module(py::module& module) { detail::bind_unary_operation(module, ttnn::square, R"doc(\mathrm{{output\_tensor}}_i = square(\mathrm{{input\_tensor}}_i))doc"); detail::bind_unary_operation(module, ttnn::tan, R"doc(\mathrm{{output\_tensor}}_i = tan(\mathrm{{input\_tensor}}_i))doc"); detail::bind_unary_operation(module, ttnn::tanh, R"doc(\mathrm{{output\_tensor}}_i = tanh(\mathrm{{input\_tensor}}_i))doc"); - detail::bind_unary_operation(module, ttnn::log_sigmoid, R"doc(\mathrm{{output\_tensor}}_i = \verb|log_sigmoid|(\mathrm{{input\_tensor}}_i))doc"); + detail::bind_unary_operation(module, ttnn::log_sigmoid, R"doc(\mathrm{{output\_tensor}}_i = \verb|log_sigmoid|(\mathrm{{input\_tensor}}_i))doc", + R"doc(Supported dtypes, layouts, and ranks: + + +----------------------------+---------------------------------+-------------------+ + | Dtypes | Layouts | Ranks | + +----------------------------+---------------------------------+-------------------+ + | BFLOAT16, BFLOAT8_B | TILE | 2, 3, 4 | + +----------------------------+---------------------------------+-------------------+ + + )doc"); detail::bind_unary_operation(module, ttnn::bitwise_not, R"doc(\mathrm{{output\_tensor}}_i = \verb|bitwise_not|(\mathrm{{input\_tensor}}_i))doc", "Input tensor needs to be in the range [-2147483647, 2147483647], INT32 dtype. Support provided only for Wormhole_B0."); // Unaries with fast_and_approximate_mode @@ -1736,7 +1773,16 @@ void py_module(py::module& module) { detail::bind_unary_composite(module, ttnn::cosh, R"doc(Performs cosh function on :attr:`input_tensor`.)doc", "[supported range -9 to 9]"); detail::bind_unary_composite(module, ttnn::digamma, R"doc(Performs digamma function on :attr:`input_tensor`.)doc", "[supported for value greater than 0]"); detail::bind_unary_composite(module, ttnn::lgamma, R"doc(Performs lgamma function on :attr:`input_tensor`.)doc", "[supported for value greater than 0]"); - detail::bind_unary_composite(module, ttnn::log1p, R"doc(Performs log1p function on :attr:`input_tensor`.)doc", "[supported range -1 to 1]"); + detail::bind_unary_composite(module, ttnn::log1p, R"doc(Performs log1p function on :attr:`input_tensor`.)doc", "[supported range -1 to 1]", + R"doc(Supported dtypes, layouts, and ranks: + + +----------------------------+---------------------------------+-------------------+ + | Dtypes | Layouts | Ranks | + +----------------------------+---------------------------------+-------------------+ + | BFLOAT16 | TILE | 2, 3, 4 | + +----------------------------+---------------------------------+-------------------+ + + )doc"); detail::bind_unary_composite(module, ttnn::mish, R"doc(Performs mish function on :attr:`input_tensor`, not supported for grayskull.)doc"); detail::bind_unary_composite(module, ttnn::multigammaln, R"doc(Performs multigammaln function on :attr:`input_tensor`.)doc", "[supported range 1.6 to inf]"); detail::bind_unary_composite(module, ttnn::sinh, R"doc(Performs sinh function on :attr:`input_tensor`.)doc", "[supported range -88 to 88]");