def __call__(self, A, Y, rng=np.random): tstart = time.time() Y, _, _, _, matrix_in = format_system(A, Y) # solve for coefficients using standard solver X, info0 = self.solver1(A, Y, rng=rng) # drop weights close to zero, based on `drop` ratio Xabs = np.sort(np.abs(X.flat)) threshold = Xabs[int(np.round(self.drop * Xabs.size))] X[np.abs(X) < threshold] = 0 # retrain nonzero weights info1s = [] for i in range(X.shape[1]): info1 = None nonzero = X[:, i] != 0 if nonzero.sum() > 0: X[nonzero, i], info1 = self.solver2(A[:, nonzero], Y[:, i], rng=rng) info1s.append(info1) t = time.time() - tstart info = { "rmses": rmses(A, X, Y), "info0": info0, "info1s": info1s, "time": t } return X if matrix_in or X.shape[1] > 1 else X.ravel(), info
def __call__(self, A, Y, rng=np.random, E=None): tstart = time.time() Y, m, n, _, matrix_in = format_system(A, Y) # solve for coefficients using standard solver X, info0 = self.solver1(A, Y, rng=rng) X = self.mul_encoders(X, E) # drop weights close to zero, based on `drop` ratio Xabs = np.sort(np.abs(X.flat)) threshold = Xabs[int(np.round(self.drop * Xabs.size))] X[np.abs(X) < threshold] = 0 # retrain nonzero weights Y = self.mul_encoders(Y, E) for i in range(X.shape[1]): nonzero = X[:, i] != 0 if nonzero.sum() > 0: X[nonzero, i], info1 = self.solver2( A[:, nonzero], Y[:, i], rng=rng) t = time.time() - tstart info = {'rmses': rmses(A, X, Y), 'info0': info0, 'info1': info1, 'time': t} return X if matrix_in or X.shape[1] > 1 else X.ravel(), info
def __call__(self, A, Y, rng=None, E=None): tstart = time.time() Y, m, n, d, matrix_in = format_system(A, Y) # solve for coefficients using standard solver X, info0 = self.solver1(A, Y, rng=rng) X = self.mul_encoders(X, E) # drop weights close to zero, based on `drop` ratio Xabs = np.sort(np.abs(X.flat)) threshold = Xabs[int(np.round(self.drop * Xabs.size))] X[np.abs(X) < threshold] = 0 # retrain nonzero weights Y = self.mul_encoders(Y, E) for i in range(X.shape[1]): nonzero = X[:, i] != 0 if nonzero.sum() > 0: X[nonzero, i], info1 = self.solver2( A[:, nonzero], Y[:, i], rng=rng) t = time.time() - tstart info = {'rmses': rmses(A, X, Y), 'info0': info0, 'info1': info1, 'time': t} return X if matrix_in else X.flatten(), info
def __call__(self, A, Y, rng=None, E=None): tstart = time.time() Y, m, n, _, matrix_in = format_system(A, Y) sigma = A.max() * self.reg # magnitude of noise Y = self.mul_encoders(Y, E, copy=True) n_post = Y.shape[1] n_inh = int(self.p_inh * n) # form Gram matrix so we can add regularization GA = np.dot(A.T, A) np.fill_diagonal(GA, GA.diagonal() + A.shape[0] * sigma**2) GY = np.dot(A.T, Y) # flip the sign of the inhibitory neurons so we can do all # the solving at once as a non-negative minimization GA[:, :n_inh] *= -1 X = np.zeros((n, n_post)) residuals = np.zeros(n_post) for j in range(n_post): if self.sparsity > 0: # choose random indices to keep N = GY.shape[0] S = N - int(N * self.sparsity) indices = rng.choice(np.arange(N), S, replace=False) sA = GA[indices, :][:, indices] sY = GY[indices, j] else: sA = GA sY = GY[:, j] indices = slice(None) # call nnls to do the non-negative least-squares minimization X[indices, j], residuals[j] = nnls(sA, sY) # flip the sign of the weights for the inhibitory neurons X[:n_inh, :] *= (-1) # compute the resulting rmse rms = rmses(A, X, Y) t = time.time() - tstart info = { 'rmses': rms, 'residuals': residuals / Y.shape[0], 'time': t, 'n_inh': n_inh } return X, info
def __call__(self, A, Y, rng=None, E=None): import scipy.optimize tstart = time.time() Y, m, n, d, matrix_in = format_system(A, Y) Y = self.mul_encoders(Y, E) X = np.zeros((n, d)) residuals = np.zeros(d) for i in range(d): X[:, i], residuals[i] = scipy.optimize.nnls(A, Y[:, i]) t = time.time() - tstart info = {'rmses': rmses(A, X, Y), 'residuals': residuals, 'time': t} return X if matrix_in else X.flatten(), info
def __call__(self, A, Y, rng=np.random): import scipy.optimize # pylint: disable=import-outside-toplevel tstart = time.time() Y, _, n, _, matrix_in = format_system(A, Y) d = Y.shape[1] X = np.zeros((n, d)) residuals = np.zeros(d) for i in range(d): X[:, i], residuals[i] = scipy.optimize.nnls(A, Y[:, i]) t = time.time() - tstart info = {"rmses": rmses(A, X, Y), "residuals": residuals, "time": t} return X if matrix_in or X.shape[1] > 1 else X.ravel(), info
def __call__(self, A, Y, rng=np.random): import scipy.optimize tstart = time.time() Y, m, n, _, matrix_in = format_system(A, Y) d = Y.shape[1] X = np.zeros((n, d)) residuals = np.zeros(d) for i in range(d): X[:, i], residuals[i] = scipy.optimize.nnls(A, Y[:, i]) t = time.time() - tstart info = {'rmses': rmses(A, X, Y), 'residuals': residuals, 'time': t} return X if matrix_in or X.shape[1] > 1 else X.ravel(), info
def _solve(self, A, Y, sigma=0.0): import scipy.optimize # pylint: disable=import-outside-toplevel tstart = time.time() Y, _, n, _, matrix_in = format_system(A, Y) d = Y.shape[1] # form Gram matrix so we can add regularization GA = np.dot(A.T, A) np.fill_diagonal(GA, GA.diagonal() + A.shape[0] * sigma**2) GY = np.dot(A.T, np.maximum(Y, 0)) # ^ TODO: why is it better if we clip Y to be positive here? X = np.zeros((n, d)) residuals = np.zeros(d) for i in range(d): X[:, i], residuals[i] = scipy.optimize.nnls(GA, GY[:, i]) t = time.time() - tstart info = {"rmses": rmses(A, X, Y), "residuals": residuals, "time": t} return X if matrix_in or X.shape[1] > 1 else X.ravel(), info
def _solve(self, A, Y, sigma=0.): import scipy.optimize tstart = time.time() Y, m, n, _, matrix_in = format_system(A, Y) d = Y.shape[1] # form Gram matrix so we can add regularization GA = np.dot(A.T, A) np.fill_diagonal(GA, GA.diagonal() + A.shape[0] * sigma**2) GY = np.dot(A.T, Y.clip(0, None)) # ^ TODO: why is it better if we clip Y to be positive here? X = np.zeros((n, d)) residuals = np.zeros(d) for i in range(d): X[:, i], residuals[i] = scipy.optimize.nnls(GA, GY[:, i]) t = time.time() - tstart info = {'rmses': rmses(A, X, Y), 'residuals': residuals, 'time': t} return X if matrix_in or X.shape[1] > 1 else X.ravel(), info
def __call__(self, A, Y, rng=None, E=None): tstart = time.time() Y, m, n, _, matrix_in = format_system(A, Y) sigma = A.max() * self.reg # magnitude of noise Y = self.mul_encoders(Y, E, copy=True) n_post = Y.shape[1] n_inh = int(self.p_inh * n) # flip the sign of the inhibitory neurons so we can do all # the solving at once as a non-negative minimization A[:, :n_inh] *= -1 # form Gram matrix so we can add regularization GA = np.dot(A.T, A) np.fill_diagonal(GA, GA.diagonal() + A.shape[0] * sigma ** 2) GY = np.dot(A.T, Y) X = np.zeros((n, n_post)) residuals = np.zeros(n_post) if self.multiprocess: pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()) args = [] if self.sparsity > 0: all_indices = [] for j in range(n_post): N = GY.shape[0] S = N - int(N*self.sparsity) indices = rng.choice(np.arange(N), S, replace=False) args.append((GA[indices, :][:, indices], GY[indices, j])) all_indices.append(indices) r = pool.starmap(nnls, args) for j, (XX, res) in enumerate(r): X[all_indices[j],j] = XX residuals[j] = res else: for j in range(n_post): args.append((GA, GY[:, j])) if self.tol is None: r = pool.starmap(nnls, args) else: args2 = [(a[0], a[1], self.tol) for a in args] r2 = pool.starmap(nnls_predotted, args2) r = [(rr, 0) for rr in r2] for j, (XX, res) in enumerate(r): X[:,j] = XX residuals[j] = res else: for j in range(n_post): if self.sparsity > 0: # choose random indices to keep N = GY.shape[0] S = N - int(N*self.sparsity) indices = rng.choice(np.arange(N), S, replace=False) sA = GA[indices, :][:, indices] sY = GY[indices, j] else: sA = GA sY = GY[:, j] indices = slice(None) # call nnls to do the non-negative least-squares minimization if self.tol is None: X[indices, j], residuals[j] = nnls(sA, sY) else: X[indices, j] = nnls_predotted(sA, sY, self.tol) # flip the sign of the weights for the inhibitory neurons X[:n_inh, :] *= (-1) # compute the resulting rmse rms = rmses(A, X, Y) t = time.time() - tstart info = {'rmses': rms, 'residuals': residuals/Y.shape[0], 'time': t, 'n_inh': n_inh} return X, info