added tests for tensor functions

Author: alexsu52

nncf/experimental/tensor/functions/__init__.py

@@ -9,6 +9,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from nncf.experimental.tensor.functions import linalg as linalg
 from nncf.experimental.tensor.functions.numeric import abs as abs
 from nncf.experimental.tensor.functions.numeric import all as all
 from nncf.experimental.tensor.functions.numeric import allclose as allclose

nncf/experimental/tensor/functions/numeric.py

@@ -478,7 +478,7 @@ def sum(a: Tensor, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims:
         with size one.
     :return: Returns the sum of all elements in the input tensor in the given axis.
     """
-    return sum(a.data, axis, keepdims)
+    return Tensor(sum(a.data, axis, keepdims))
 
 
 @functools.singledispatch
@@ -496,7 +496,7 @@ def multiply(x1: Tensor, x2: Union[Tensor, float]) -> Tensor:
 
 @functools.singledispatch
 @tensor_guard
-def var(a: Tensor, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> Tensor:
+def var(a: Tensor, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False, ddof: int = 0) -> Tensor:
     """
     Compute the variance along the specified axis.
 
@@ -505,9 +505,11 @@ def var(a: Tensor, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims:
         of the flattened tensor.
     :param keepdims: If this is set to True, the axes which are reduced are left in the result as dimensions
         with size one.
-    :return: eturns a new tensor containing the variance;
+    :param ddof: “Delta Degrees of Freedom”: difference between the sample size and sample degrees of freedom.
+        By default ddof is zero.
+    :return: A new tensor containing the variance.
     """
-    return Tensor(var(a.data, axis, keepdims))
+    return Tensor(var(a.data, axis, keepdims, ddof))
 
 
 @functools.singledispatch

nncf/experimental/tensor/functions/numpy_numeric.py

@@ -235,10 +235,13 @@ def _(x1: Union[np.ndarray, np.generic], x2: Union[np.ndarray, np.generic, float
 
 
 @register_numpy_types(numeric.var)
-def var(
-    a: Union[np.ndarray, np.generic], axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False
+def _(
+    a: Union[np.ndarray, np.generic],
+    axis: Optional[Union[int, Tuple[int, ...]]] = None,
+    keepdims: bool = False,
+    ddof: int = 0,
 ) -> np.ndarray:
-    return np.array(np.var(a, axis=axis, keepdims=keepdims))
+    return np.array(np.var(a, axis=axis, keepdims=keepdims, ddof=ddof))
 
 
 @register_numpy_types(numeric.size)

nncf/experimental/tensor/functions/torch_numeric.py

@@ -233,8 +233,10 @@ def _(x1: torch.Tensor, x2: Union[torch.Tensor, float]) -> torch.Tensor:
 
 
 @numeric.var.register(torch.Tensor)
-def var(a: torch.Tensor, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> torch.Tensor:
-    return torch.var(a, dim=axis, keepdim=keepdims)
+def _(
+    a: torch.Tensor, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False, ddof: int = 0
+) -> torch.Tensor:
+    return torch.var(a, dim=axis, keepdim=keepdims, correction=ddof)
 
 
 @numeric.size.register(torch.Tensor)

tests/shared/test_templates/template_test_nncf_tensor.py

@@ -753,3 +753,200 @@ def test_fn_mean_per_channel_incorrect_axis(self, axis):
         tensor = Tensor(self.to_tensor([[[9.0, 9.0], [0.0, 3.0]], [[5.0, 1.0], [7.0, 1.0]]]))
         with pytest.raises(ValueError, match="is out of bounds for array of dimension"):
             s_fns.mean_per_channel(tensor, axis)
+
+    def test_size(self):
+        tensor = Tensor(self.to_tensor([1, 1]))
+        res = tensor.size
+        assert res == 2
+
+    def test_item(self):
+        tensor = Tensor(self.to_tensor([1]))
+        res = tensor.item()
+        assert res == 1
+
+    @pytest.mark.parametrize(
+        "val, min, max, ref",
+        (([0.9, 2.1], 1.0, 2.0, [1.0, 2.0]), ([0.9, 2.1], [0.0, 2.5], [0.5, 3.0], [0.5, 2.5])),
+    )
+    def test_fn_clip(self, val, min, max, ref):
+        tensor = Tensor(self.to_tensor(val))
+        if isinstance(min, list):
+            min = Tensor(self.to_tensor(min))
+        if isinstance(max, list):
+            max = Tensor(self.to_tensor(max))
+        ref_tensor = self.to_tensor(ref)
+
+        res = fns.clip(tensor, min, max)
+
+        assert isinstance(res, Tensor)
+        assert fns.allclose(res.data, ref_tensor)
+        assert res.device == tensor.device
+
+    def test_fn_as_tensor_like(self):
+        tensor = Tensor(self.to_tensor([1]))
+        data = [1.0, 2.0]
+        ref = self.to_tensor(data)
+
+        res = fns.as_tensor_like(tensor, data)
+
+        assert isinstance(res, Tensor)
+        assert fns.allclose(res.data, ref)
+        assert res.device == tensor.device
+
+    @pytest.mark.parametrize(
+        "x, axis, keepdims, ref",
+        (
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                0,
+                False,
+                [0.9, 0.9, 0.3],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                0,
+                True,
+                [[0.9, 0.9, 0.3]],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                (0, 1),
+                True,
+                [[2.1]],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                None,
+                False,
+                2.1,
+            ),
+        ),
+    )
+    def test_fn_sum(self, x, axis, keepdims, ref):
+        tensor = Tensor(self.to_tensor(x))
+        ref_tensor = self.to_tensor(ref)
+
+        res = fns.sum(tensor, axis, keepdims)
+
+        assert isinstance(res, Tensor)
+        assert fns.allclose(res.data, ref_tensor)
+        assert res.device == tensor.device
+
+    @pytest.mark.parametrize(
+        "a, b, ref",
+        (
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                [[0.1, 0.7, 0.1], [0.8, 0.2, 0.2]],
+                [[0.08, 0.14, 0.02], [0.08, 0.14, 0.02]],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                0.1,
+                [[0.08, 0.02, 0.02], [0.01, 0.07, 0.01]],
+            ),
+        ),
+    )
+    def test_fn_multiply(self, a, b, ref):
+        tensor_a = Tensor(self.to_tensor(a))
+        tensor_b = Tensor(self.to_tensor(b))
+        ref_tensor = self.to_tensor(ref)
+
+        res = fns.multiply(tensor_a, tensor_b)
+
+        assert isinstance(res, Tensor)
+        assert fns.allclose(res.data, ref_tensor)
+        assert res.device == tensor_a.device
+
+    @pytest.mark.parametrize(
+        "x, axis, keepdims, ddof, ref",
+        (
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                0,
+                False,
+                0,
+                [0.1225, 0.0625, 0.0025],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                0,
+                True,
+                1,
+                [[0.245, 0.125, 0.005]],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                (0, 1),
+                True,
+                0,
+                [[0.0825]],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                None,
+                False,
+                1,
+                0.099,
+            ),
+        ),
+    )
+    def test_fn_var(self, x, axis, keepdims, ddof, ref):
+        tensor = Tensor(self.to_tensor(x))
+        ref_tensor = self.to_tensor(ref)
+
+        res = fns.var(tensor, axis, keepdims, ddof)
+
+        assert isinstance(res, Tensor)
+        assert fns.allclose(res.data, ref_tensor)
+        assert res.device == tensor.device
+
+    @pytest.mark.parametrize(
+        "x, ord, axis, keepdims, ref",
+        (
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                None,
+                0,
+                False,
+                [0.80622577, 0.72801099, 0.2236068],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                "fro",
+                None,
+                True,
+                [[1.10905365]],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                "nuc",
+                (0, 1),
+                True,
+                [[1.53063197]],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                float("inf"),
+                0,
+                False,
+                [0.8, 0.7, 0.2],
+            ),
+            (
+                [[0.8, 0.2, 0.2], [0.1, 0.7, 0.1]],
+                2,
+                None,
+                False,
+                0.9364634205074938,
+            ),
+        ),
+    )
+    def test_fn_linalg_norm(self, x, ord, axis, keepdims, ref):
+        tensor = Tensor(self.to_tensor(x))
+        ref_tensor = self.to_tensor(ref)
+
+        res = fns.linalg.norm(tensor, ord, axis, keepdims)
+
+        assert isinstance(res, Tensor)
+        assert fns.allclose(res.data, ref_tensor)
+        assert res.device == tensor.device