//  [python]
def _update_Wout_loading(self, X, Y):
        """
        Update Wout matrix
        """
        # Compute zones
        self.C = self._compute_conceptor(X)

        # Compute free zone
        self.F = self._compute_F_matrix()

        # Compute conflict and conflict free zones
        self.M = self._compute_M(self.C)
        self.E = self._compute_E(self.M)

        # Debug
        self.e_rank = rank(self.E.C)

        # Compute increment for Wout
        if quota(self.F) < 1e-1:
            self.w_out_inc = self._compute_increment(X, Y, self._ridge_param_inc * 1000, F=self._compute_F_matrix())
        else:
            self.w_out_inc = self._compute_increment(X, Y, self._ridge_param_inc, F=self._compute_F_matrix())
        # end if

        # Debug
        self._call_debug_point("w_out_inc{}".format(self._n_samples), self.w_out_inc, "IncForgRRCell", "_update_Wout_loading")

        # DEBUG Wout inc
        self.w_out_inc_nrmse = nrmse(torch.mm(self.w_out + self.w_out_inc, X.t()).t(), Y)
        self.w_out_inc_magnitude = torch.linalg.norm(self.w_out_inc)
        self.w_out_inc_rank = rank(self.w_out_inc)
        _, self.w_out_inc_SVs, _ = torch.svd(self.w_out_inc)

        # Targets: what cannot be predicted by the current matrix Wout.
        # Yt = Y - Wout * X
        Yt = Y - torch.mm(self.w_out, X.t()).t()
        # Yt = Y - torch.mm(self.w_out, torch.mm(self.M.C, X.t())).t()

        # Debug
        self._call_debug_point("Td{}".format(self._n_samples), Y, "IncForgRRCell", "_update_Wout_loading")

        # Compute matrix Wout update which predict what cannot be predicted by Wout using the conflict zone
        # and the free zone.
        self.w_out_up = self._compute_update(X, Yt, self.E, self._ridge_param_up)

        # Split the matrix Wout_new into update and increment
        # Wout_up = A * Wout_new
        self.w_out_up_nrmse = nrmse(torch.mm(self.w_out + self.w_out_up, X.t()).t(), Y)
        self.w_out_up_magnitude = torch.linalg.norm(self.w_out_up)
        self.w_out_up_rank = rank(self.w_out_up)
        _, self.w_out_up_SVs, _ = torch.svd(self.w_out_up)

        # Debug
        self._call_debug_point("w_out_up{}".format(self._n_samples), self.w_out_up, "IncForgRRCell", "_update_Wout_loading")

        # Compute final matrix
        if self.A.quota > self._forgetting_threshold:
            # Gradient
            self.w_out_gradient = torch.linalg.norm(self.w_out + self.w_out_up) - torch.linalg.norm(self.w_out)

            # Wout = Wout + Wout_up
            self.w_out += self.w_out_up

            # Update A
            self._update_A(self.M, self.C)
        else:
            # Gradient
            self.w_out_gradient = torch.linalg.norm(self.w_out + self.w_out_inc) - torch.linalg.norm(self.w_out)

            # Wout = Wout + Wout_inc
            self.w_out += self.w_out_inc
            # self.w_out += self.w_out_up

            # Update A
            self._update_A(self.M, self.C, increment=True)
            # self._update_A(self.M, C)
        # end if

        # Wout magnitude
        self.w_out_magnitude = torch.linalg.norm(self.w_out)
        self.w_out_rank = rank(self.w_out)
        _, self.w_out_SVs, _ = torch.svd(self.w_out)

        # Debug
        self._call_debug_point("w_out{}".format(self._n_samples), self.w_out, "IncForgRRCell", "_update_Wout_loading")