【PaddlePaddle Hackathon 2】3、为 Paddle 新增 corrcoef(皮尔逊积矩相关系数) API

python/paddle/fluid/tests/unittests/test_corr.py

@@ -0,0 +1,134 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle.fluid as fluid
+import unittest
+import numpy as np
+import six
+import paddle
+import warnings
+
+
+def numpy_corr(np_arr, rowvar=True, ddof=0):
+    return np.corrcoef(np_arr, rowvar=rowvar, ddof=int(ddof))
+
+
+class Corr_Test(unittest.TestCase):
+    def setUp(self):
+        self.shape = [20, 10]
+
+    def test_tensor_corr_default(self):
+        typelist = ['float64']
+        places = [fluid.CPUPlace()]
+        if fluid.core.is_compiled_with_cuda():
+            places.append(fluid.CUDAPlace(0))
+        for idx, p in enumerate(places):
+            if idx == 0:
+                paddle.set_device('cpu')
+            else:
+                paddle.set_device('gpu')
+
+            for dtype in typelist:
+                np_arr = np.random.rand(*self.shape).astype(dtype)
+                tensor = paddle.to_tensor(np_arr, place=p)
+                corr = paddle.linalg.corrcoef(tensor, ddof=False)
+                np_corr = numpy_corr(np_arr, rowvar=True, ddof=0)
+                self.assertTrue(np.allclose(np_corr, corr.numpy()))
+
+    def test_tensor_corr_rowvar(self):
+        typelist = ['float64']
+        places = [fluid.CPUPlace()]
+        if fluid.core.is_compiled_with_cuda():
+            places.append(fluid.CUDAPlace(0))
+
+        for idx, p in enumerate(places):
+            if idx == 0:
+                paddle.set_device('cpu')
+            else:
+                paddle.set_device('gpu')
+
+            for dtype in typelist:
+                np_arr = np.random.rand(*self.shape).astype(dtype)
+                tensor = paddle.to_tensor(np_arr, place=p)
+                corr = paddle.linalg.corrcoef(tensor, rowvar=False, ddof=False)
+                np_corr = numpy_corr(np_arr, rowvar=False, ddof=0)
+                self.assertTrue(np.allclose(np_corr, corr.numpy()))
+
+    def test_tensor_corr_ddof(self):
+        typelist = ['float64']
+        places = [fluid.CPUPlace()]
+        if fluid.core.is_compiled_with_cuda():
+            places.append(fluid.CUDAPlace(0))
+
+        for idx, p in enumerate(places):
+            if idx == 0:
+                paddle.set_device('cpu')
+            else:
+                paddle.set_device('gpu')
+
+            for dtype in typelist:
+                np_arr = np.random.rand(*self.shape).astype(dtype)
+                tensor = paddle.to_tensor(np_arr, place=p)
+                corr = paddle.linalg.corrcoef(tensor, ddof=True)
+                np_corr = numpy_corr(np_arr, rowvar=True, ddof=1)
+                self.assertTrue(np.allclose(np_corr, corr.numpy()))
+
+
+class Corr_Test2(Corr_Test):
+    def setUp(self):
+        self.shape = [10]
+
+
+# Input(x) only support N-D (1<=N<=2) tensor
+class Corr_Test3(unittest.TestCase):
+    def setUp(self):
+        self.shape = [2, 5, 10]
+
+    def test_errors(self):
+        def test_err():
+            np_arr = np.random.rand(*self.shape).astype('float64')
+            tensor = paddle.to_tensor(np_arr)
+            covrr = paddle.linalg.corrcoef(tensor, ddof=False)
+
+        self.assertRaises(ValueError, test_err)
+
+
+class Corr_Test4(unittest.TestCase):
+    def setUp(self):
+        self.shape = [2, 2, 5, 10]
+
+    def test_errors(self):
+        def test_err():
+            np_arr = np.random.rand(*self.shape).astype('float64')
+            tensor = paddle.to_tensor(np_arr)
+            corr = paddle.linalg.corrcoef(tensor, ddof=False)
+
+        self.assertRaises(ValueError, test_err)
+
+
+class Corr_Test5(unittest.TestCase):
+    def setUp(self):
+        self.shape = [2, 5, 10, 6, 7]
+
+    def test_errors(self):
+        def test_err():
+            np_arr = np.random.rand(*self.shape).astype('float64')
+            tensor = paddle.to_tensor(np_arr)
+            corr = paddle.linalg.corrcoef(tensor, ddof=False)
+
+        self.assertRaises(ValueError, test_err)
+
+
+if __name__ == '__main__':
+    unittest.main()

python/paddle/linalg.py

@@ -16,6 +16,7 @@
 from .tensor.linalg import norm  # noqa: F401
 from .tensor.linalg import eig  # noqa: F401
 from .tensor.linalg import cov  # noqa: F401
+from .tensor.linalg import corrcoef  # noqa: F401
 from .tensor.linalg import cond  # noqa: F401
 from .tensor.linalg import matrix_power  # noqa: F401
 from .tensor.linalg import solve  # noqa: F401
@@ -41,6 +42,7 @@
     'norm',
     'cond',
     'cov',
+    'corrcoef',
     'inv',
     'eig',
     'eigvals',

python/paddle/tensor/__init__.py

@@ -40,6 +40,7 @@
 from .linalg import matmul  # noqa: F401
 from .linalg import dot  # noqa: F401
 from .linalg import cov  # noqa: F401
+from .linalg import corrcoef  # noqa: F401
 from .linalg import norm  # noqa: F401
 from .linalg import cond  # noqa: F401
 from .linalg import transpose  # noqa: F401
@@ -275,6 +276,7 @@
            'matmul',
            'dot',
            'cov',
+           'corrcoef',
            'norm',
            'cond',
            'transpose',

python/paddle/tensor/linalg.py

@@ -21,6 +21,7 @@
 from ..fluid.layers import transpose, cast  # noqa: F401
 from ..fluid import layers
 import paddle
+import warnings
 from paddle.common_ops_import import core
 from paddle.common_ops_import import VarDesc
 from paddle import _C_ops
@@ -2990,3 +2991,71 @@ def lstsq(x, y, rcond=None, driver=None, name=None):
         singular_values = paddle.static.data(name='singular_values', shape=[0])
 
     return solution, residuals, rank, singular_values
+
+
+def corrcoef(x, rowvar=True, ddof=False, name=None):
+    """
+    Return Pearson product-moment correlation coefficients.
+
+    Please refer to the documentation for `cov` for more detail.  The
+    relationship between the correlation coefficient matrix, `R`, and the
+    covariance matrix, `C`, is
+
+    .. math:: R_{ij} = \\frac{ C_{ij} } { \\sqrt{ C_{ii} * C_{jj} } }
+
+    The values of `R` are between -1 and 1, inclusive.
+
+    Parameters:
+
+        x(Tensor): A N-D(N<=2) Tensor containing multiple variables and observations. By default, each row of x represents a variable. Also see rowvar below.
+        rowvar(Bool, optional): If rowvar is True (default), then each row represents a variable, with observations in the columns. Default: True
+        ddof(Bool, optional): Has no effect, do not use.
+        name(str, optional): Name of the output. Default is None. It's used to print debug info for developers. Details: :ref:`api_guide_Name`
+
+    Returns:
+
+        Tensor: The correlation coefficient matrix of the variables.
+
+    Examples:
+
+    .. code-block:: python
+
+        import paddle
+
+        xt = paddle.rand((3,4))
+        paddle.linalg.corrcoef(xt)
+
+        '''
+        Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True,
+        [[ 1.        , -0.73702252,  0.66228950],
+        [-0.73702258,  1.        , -0.77104872],
+        [ 0.66228974, -0.77104825,  1.        ]])
+        '''
+
+    """
+
+    if ddof is not False:
+        warnings.warn('ddof have no effect and are deprecated',
+                      DeprecationWarning)
+    c = cov(x, rowvar)
+    try:
+        d = paddle.diag(c)
+    except ValueError:
+        # scalar covariance
+        # nan if incorrect value (nan, inf, 0), 1 otherwise
+        return c / c
+
+    if paddle.is_complex(d):
+        d = d.real()
+    stddev = paddle.sqrt(d)
+    c /= stddev[:, None]
+    c /= stddev[None, :]
+
+    # Clip to [-1, 1].  This does not guarantee
+    if paddle.is_complex(c):
+        return paddle.complex(
+            paddle.clip(c.real(), -1, 1), paddle.clip(c.imag(), -1, 1))
+    else:
+        c = paddle.clip(c, -1, 1)
+
+    return c