Github action: auto-update.

Author: github-actions[bot]

dev/_downloads/02fe230fcb90df96787f11e615bb0af8/plot_guide_for_constrained_cp.py

@@ -8,10 +8,10 @@
 # Introduction
 # -----------------------
 # Since version 0.7, Tensorly includes constrained CP decomposition which penalizes or
-# constrains factors as chosen by the user. The proposed implementation of constrained CP uses the 
+# constrains factors as chosen by the user. The proposed implementation of constrained CP uses the
 # Alternating Optimization Alternating Direction Method of Multipliers (AO-ADMM) algorithm from [1] which
 # solves alternatively convex optimization problem using primal-dual optimization. In constrained CP
-# decomposition, an auxilliary factor is introduced which is constrained or regularized using an operator called the 
+# decomposition, an auxilliary factor is introduced which is constrained or regularized using an operator called the
 # proximal operator. The proximal operator may therefore change according to the selected constraint or penalization.
 #
 # Tensorly provides several constraints and their corresponding proximal operators, each can apply to one or all factors in the CP decomposition:
@@ -94,7 +94,7 @@
 fig = plt.figure()
 for i in range(rank):
     plt.plot(factors[0][:, i])
-    plt.legend(['1. column', '2. column', '3. column'], loc='upper left')
+    plt.legend(["1. column", "2. column", "3. column"], loc="upper left")
 
 ##############################################################################
 # Constraints requiring a scalar input can be used similarly as follows:
@@ -103,11 +103,11 @@
 ##############################################################################
 # The same regularization coefficient l1_reg is used for all the modes. Here the l1 penalization induces sparsity given that the regularization coefficient is large enough.
 fig = plt.figure()
-plt.title('Histogram of 1. factor')
+plt.title("Histogram of 1. factor")
 _, _, _ = plt.hist(factors[0].flatten())
 
 fig = plt.figure()
-plt.title('Histogram of 2. factor')
+plt.title("Histogram of 2. factor")
 _, _, _ = plt.hist(factors[1].flatten())
 
 ##############################################################################
@@ -133,15 +133,15 @@
 _, factors = constrained_parafac(tensor, rank=rank, l1_reg=[0.01, 0.02, 0.03])
 
 fig = plt.figure()
-plt.title('Histogram of 1. factor')
+plt.title("Histogram of 1. factor")
 _, _, _ = plt.hist(factors[0].flatten())
 
 fig = plt.figure()
-plt.title('Histogram of 2. factor')
+plt.title("Histogram of 2. factor")
 _, _, _ = plt.hist(factors[1].flatten())
 
 fig = plt.figure()
-plt.title('Histogram of 3. factor')
+plt.title("Histogram of 3. factor")
 _, _, _ = plt.hist(factors[2].flatten())
 
 ##############################################################################
@@ -150,8 +150,9 @@
 # To use different constraint for different modes, the dictionary structure
 # should be preferred:
 
-_, factors = constrained_parafac(tensor, rank=rank, non_negative={1:True}, l1_reg={0: 0.01},
-                                 l2_square_reg={2: 0.01})
+_, factors = constrained_parafac(
+    tensor, rank=rank, non_negative={1: True}, l1_reg={0: 0.01}, l2_square_reg={2: 0.01}
+)
 
 ##############################################################################
 # In the dictionary, `key` is the selected mode and `value` is a scalar value or

dev/_downloads/07fcc19ba03226cd3d83d4e40ec44385/auto_examples_python.zip

@@ -11,7 +11,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Introduction\nSince version 0.7, Tensorly includes constrained CP decomposition which penalizes or\nconstrains factors as chosen by the user. The proposed implementation of constrained CP uses the \nAlternating Optimization Alternating Direction Method of Multipliers (AO-ADMM) algorithm from [1] which\nsolves alternatively convex optimization problem using primal-dual optimization. In constrained CP\ndecomposition, an auxilliary factor is introduced which is constrained or regularized using an operator called the \nproximal operator. The proximal operator may therefore change according to the selected constraint or penalization.\n\nTensorly provides several constraints and their corresponding proximal operators, each can apply to one or all factors in the CP decomposition:\n\n1. Non-negativity\n       * `non_negative` in signature\n       * Prevents negative values in CP factors.\n2. L1 regularization\n       * `l1_reg` in signature\n       * Adds a L1 regularization term on the CP factors to the CP cost function, this promotes sparsity in the CP factors. The user chooses the regularization amount.\n3. L2 regularization\n       * `l2_reg` in signature\n       * Adds a L2 regularization term on the CP factors to the CP cost function. The user chooses the regularization amount.\n4. L2 square regularization\n       * `l2_square_reg` in signature\n       * Adds a L2 regularization term on the CP factors to the CP cost function. The user chooses the regularization amount.\n5. Unimodality\n       * `unimodality` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that each column of the factors is unimodal (there is only one local maximum, like a Gaussian).\n6. Simplex\n       * `simplex` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that each column of the factors lives on the simplex or user-defined radius (entries are nonnegative and sum to a user-defined positive parameter columnwise).\n7. Normalization\n       * `normalize` in signature\n       * Impose that the largest absolute value in the factors elementwise is 1.\n8. Normalized sparsity\n       * `normalized_sparsity` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that the columns of factors are both normalized with the L2 norm, and k-sparse (at most k-nonzeros per column) with k user-defined.\n9. Soft sparsity\n       * `soft_sparsity` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that the columns of factors have L1 norm bounded by a user-defined threshold.\n10. Smoothness\n       * `smoothness` in signature\n       * This constraint acts columnwise on the factors\n       * Favor smoothness in factors columns by penalizing the L2 norm of finite differences. The user chooses the regularization amount. The proximal operator in fact solves a banded system.\n11. Monotonicity\n       * `monotonicity` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that the factors are either always increasing or decreasing (user-specified) columnwise. This is based on isotonic regression.\n12. Hard sparsity\n       * `hard_sparsity` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that each column of the factors has at most k nonzero entries (k is user-defined).\n\nWhile some of these constraints (2, 3, 4, 6, 8, 9, 12) require a scalar\ninput as its parameter or regularizer, boolean input could be enough\nfor other constraints (1, 5, 7, 10, 11). Selection of one of these\nconstraints for all mode (or factors) or using different constraints for different modes are both supported.\n\n"
+        "## Introduction\nSince version 0.7, Tensorly includes constrained CP decomposition which penalizes or\nconstrains factors as chosen by the user. The proposed implementation of constrained CP uses the\nAlternating Optimization Alternating Direction Method of Multipliers (AO-ADMM) algorithm from [1] which\nsolves alternatively convex optimization problem using primal-dual optimization. In constrained CP\ndecomposition, an auxilliary factor is introduced which is constrained or regularized using an operator called the\nproximal operator. The proximal operator may therefore change according to the selected constraint or penalization.\n\nTensorly provides several constraints and their corresponding proximal operators, each can apply to one or all factors in the CP decomposition:\n\n1. Non-negativity\n       * `non_negative` in signature\n       * Prevents negative values in CP factors.\n2. L1 regularization\n       * `l1_reg` in signature\n       * Adds a L1 regularization term on the CP factors to the CP cost function, this promotes sparsity in the CP factors. The user chooses the regularization amount.\n3. L2 regularization\n       * `l2_reg` in signature\n       * Adds a L2 regularization term on the CP factors to the CP cost function. The user chooses the regularization amount.\n4. L2 square regularization\n       * `l2_square_reg` in signature\n       * Adds a L2 regularization term on the CP factors to the CP cost function. The user chooses the regularization amount.\n5. Unimodality\n       * `unimodality` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that each column of the factors is unimodal (there is only one local maximum, like a Gaussian).\n6. Simplex\n       * `simplex` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that each column of the factors lives on the simplex or user-defined radius (entries are nonnegative and sum to a user-defined positive parameter columnwise).\n7. Normalization\n       * `normalize` in signature\n       * Impose that the largest absolute value in the factors elementwise is 1.\n8. Normalized sparsity\n       * `normalized_sparsity` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that the columns of factors are both normalized with the L2 norm, and k-sparse (at most k-nonzeros per column) with k user-defined.\n9. Soft sparsity\n       * `soft_sparsity` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that the columns of factors have L1 norm bounded by a user-defined threshold.\n10. Smoothness\n       * `smoothness` in signature\n       * This constraint acts columnwise on the factors\n       * Favor smoothness in factors columns by penalizing the L2 norm of finite differences. The user chooses the regularization amount. The proximal operator in fact solves a banded system.\n11. Monotonicity\n       * `monotonicity` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that the factors are either always increasing or decreasing (user-specified) columnwise. This is based on isotonic regression.\n12. Hard sparsity\n       * `hard_sparsity` in signature\n       * This constraint acts columnwise on the factors\n       * Impose that each column of the factors has at most k nonzero entries (k is user-defined).\n\nWhile some of these constraints (2, 3, 4, 6, 8, 9, 12) require a scalar\ninput as its parameter or regularizer, boolean input could be enough\nfor other constraints (1, 5, 7, 10, 11). Selection of one of these\nconstraints for all mode (or factors) or using different constraints for different modes are both supported.\n\n"
       ]
     },
     {
@@ -58,7 +58,7 @@
       },
       "outputs": [],
       "source": [
-        "fig = plt.figure()\nfor i in range(rank):\n    plt.plot(factors[0][:, i])\n    plt.legend(['1. column', '2. column', '3. column'], loc='upper left')"
+        "fig = plt.figure()\nfor i in range(rank):\n    plt.plot(factors[0][:, i])\n    plt.legend([\"1. column\", \"2. column\", \"3. column\"], loc=\"upper left\")"
       ]
     },
     {
@@ -94,7 +94,7 @@
       },
       "outputs": [],
       "source": [
-        "fig = plt.figure()\nplt.title('Histogram of 1. factor')\n_, _, _ = plt.hist(factors[0].flatten())\n\nfig = plt.figure()\nplt.title('Histogram of 2. factor')\n_, _, _ = plt.hist(factors[1].flatten())"
+        "fig = plt.figure()\nplt.title(\"Histogram of 1. factor\")\n_, _, _ = plt.hist(factors[0].flatten())\n\nfig = plt.figure()\nplt.title(\"Histogram of 2. factor\")\n_, _, _ = plt.hist(factors[1].flatten())"
       ]
     },
     {
@@ -137,7 +137,7 @@
       },
       "outputs": [],
       "source": [
-        "_, factors = constrained_parafac(tensor, rank=rank, l1_reg=[0.01, 0.02, 0.03])\n\nfig = plt.figure()\nplt.title('Histogram of 1. factor')\n_, _, _ = plt.hist(factors[0].flatten())\n\nfig = plt.figure()\nplt.title('Histogram of 2. factor')\n_, _, _ = plt.hist(factors[1].flatten())\n\nfig = plt.figure()\nplt.title('Histogram of 3. factor')\n_, _, _ = plt.hist(factors[2].flatten())"
+        "_, factors = constrained_parafac(tensor, rank=rank, l1_reg=[0.01, 0.02, 0.03])\n\nfig = plt.figure()\nplt.title(\"Histogram of 1. factor\")\n_, _, _ = plt.hist(factors[0].flatten())\n\nfig = plt.figure()\nplt.title(\"Histogram of 2. factor\")\n_, _, _ = plt.hist(factors[1].flatten())\n\nfig = plt.figure()\nplt.title(\"Histogram of 3. factor\")\n_, _, _ = plt.hist(factors[2].flatten())"
       ]
     },
     {
@@ -155,7 +155,7 @@
       },
       "outputs": [],
       "source": [
-        "_, factors = constrained_parafac(tensor, rank=rank, non_negative={1:True}, l1_reg={0: 0.01},\n                                 l2_square_reg={2: 0.01})"
+        "_, factors = constrained_parafac(\n    tensor, rank=rank, non_negative={1: True}, l1_reg={0: 0.01}, l2_square_reg={2: 0.01}\n)"
       ]
     },
     {

dev/_downloads/0d7c4ccdff2f531825995c8fa152400c/plot_guide_for_constrained_cp.ipynb

@@ -4,6 +4,7 @@
 
 Example on how to use :func:`tensorly.decomposition.parafac` with line search to accelerate convergence.
 """
+
 import matplotlib.pyplot as plt
 
 from time import time
@@ -24,7 +25,7 @@
 err_min = tl.norm(tl.cp_to_tensor(fac) - tensor)
 
 for ii, toll in enumerate(tol):
-	# Run PARAFAC decomposition without line search and time
+    # Run PARAFAC decomposition without line search and time
     start = time()
     cp = CP(rank=3, n_iter_max=2000000, tol=toll, linesearch=False)
     fac = cp.fit_transform(tensor)
@@ -44,10 +45,10 @@
 
 fig = plt.figure()
 ax = fig.add_subplot(1, 1, 1)
-ax.loglog(tt, err - err_min, '.', label="No line search")
-ax.loglog(tt_ls, err_ls - err_min, '.r', label="Line search")
+ax.loglog(tt, err - err_min, ".", label="No line search")
+ax.loglog(tt_ls, err_ls - err_min, ".r", label="Line search")
 ax.legend()
 ax.set_ylabel("Time")
 ax.set_xlabel("Error")
 
-plt.show()
+plt.show()

dev/_downloads/2af0682e07ba2fb9ad2fd36324f584e8/plot_cp_line_search.py

@@ -18,7 +18,7 @@
 # to comprehensively profile the interactions between the antibodies and
 # `Fc receptors <https://en.wikipedia.org/wiki/Fc_receptor>`_ alongside other types of immunological
 # and demographic data. Here, we will apply CP decomposition to a
-# `COVID-19 system serology dataset <https://www.sciencedirect.com/science/article/pii/S0092867420314598>`_. 
+# `COVID-19 system serology dataset <https://www.sciencedirect.com/science/article/pii/S0092867420314598>`_.
 # In this dataset, serum antibodies
 # of 438 samples collected from COVID-19 patients were systematically profiled by their binding behavior
 # to SARS-CoV-2 (the virus that causes COVID-19) antigens and Fc receptors activities. Samples are
@@ -45,20 +45,26 @@
 # Now we apply CP decomposition to this dataset.
 
 comps = np.arange(1, 7)
-CMTFfacs = [parafac(data.tensor, cc, tol=1e-10, n_iter_max=1000,
-                    linesearch=True, orthogonalise=2) for cc in comps]
+CMTFfacs = [
+    parafac(
+        data.tensor, cc, tol=1e-10, n_iter_max=1000, linesearch=True, orthogonalise=2
+    )
+    for cc in comps
+]
 
 ##############################################################################
 # To evaluate how well CP decomposition explains the variance in the dataset, we plot the percent
 # variance reconstructed (R2X) for a range of ranks.
 
+
 def reconstructed_variance(tFac, tIn=None):
-    """ This function calculates the amount of variance captured (R2X) by the tensor method. """
+    """This function calculates the amount of variance captured (R2X) by the tensor method."""
     tMask = np.isfinite(tIn)
     vTop = np.sum(np.square(tl.cp_to_tensor(tFac) * tMask - np.nan_to_num(tIn)))
     vBottom = np.sum(np.square(np.nan_to_num(tIn)))
     return 1.0 - vTop / vBottom
 
+
 fig1 = plt.figure()
 CMTFR2X = np.array([reconstructed_variance(f, data.tensor) for f in CMTFfacs])
 plt.plot(comps, CMTFR2X, "bo")
@@ -81,8 +87,8 @@ def reconstructed_variance(tFac, tIn=None):
 tfac.factors[1][:, 0] *= -1
 tfac.factors[2][:, 0] *= -1
 
-fig2, ax = plt.subplots(1, 3, figsize=(16,6))
-for ii in [0,1,2]:
+fig2, ax = plt.subplots(1, 3, figsize=(16, 6))
+for ii in [0, 1, 2]:
     fac = tfac.factors[ii]
     scales = np.linalg.norm(fac, ord=np.inf, axis=0)
     fac /= scales
@@ -92,12 +98,20 @@ def reconstructed_variance(tFac, tIn=None):
     ax[ii].set_xticklabels(["Comp. 1", "Comp. 2"])
     ax[ii].set_yticks(range(len(data.ticks[ii])))
     if ii == 0:
-        ax[0].set_yticklabels([data.ticks[0][i] if i==0 or data.ticks[0][i]!=data.ticks[0][i-1]
-                               else "" for i in range(len(data.ticks[0]))])
+        ax[0].set_yticklabels(
+            [
+                (
+                    data.ticks[0][i]
+                    if i == 0 or data.ticks[0][i] != data.ticks[0][i - 1]
+                    else ""
+                )
+                for i in range(len(data.ticks[0]))
+            ]
+        )
     else:
         ax[ii].set_yticklabels(data.ticks[ii])
     ax[ii].set_title(data.dims[ii])
-    ax[ii].set_aspect('auto')
+    ax[ii].set_aspect("auto")
 
 fig2.colorbar(ScalarMappable(norm=plt.Normalize(-1, 1), cmap="PiYG"))